Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

fix(open-knowledge): inline-image source-fallback targets wrong PM range (#2505)

Nick Gomezb4cc5a06c275
diff --git a/.changeset/inline-image-clipboard-range.md b/.changeset/inline-image-clipboard-range.md
new file mode 100644
index 000000000..404bceee6
--- /dev/null
+++ b/.changeset/inline-image-clipboard-range.md
@@ -0,0 +1,5 @@
+---
+"@inkeep/open-knowledge": patch
+---
+
+Fixed copying prose that contains an inline image with a relative or otherwise non-portable URL. The clipboard HTML previously duplicated the paragraph's leading text inside the source-fallback span and silently dropped the image markdown; the fallback now carries the image's own markdown (`![alt](path)`), so pasting into other apps preserves the full sentence and the image reference.
diff --git a/packages/app/src/editor/clipboard/serialize.inline-image-range.test.ts b/packages/app/src/editor/clipboard/serialize.inline-image-range.test.ts
new file mode 100644
index 000000000..a08ae1c4f
--- /dev/null
+++ b/packages/app/src/editor/clipboard/serialize.inline-image-range.test.ts
@@ -0,0 +1,295 @@
+/**
+ * Inline-image source-fallback range contract: position resolution must
+ * target the image atom's own PM range.
+ *
+ * tiptap always renders an outer `.react-renderer.node-image` span around
+ * a React node view; fixtures that omit it exercise a topology production
+ * never produces. These tests model the real production topology:
+ *
+ * .ProseMirror > p
+ * > span.react-renderer.node-image
+ * > span[data-node-view-wrapper data-clipboard-inline-leaf]
+ * > span[data-rmiz] > span[data-rmiz-content] > img
+ *
+ * with a leading text-node sibling in the paragraph (`Some prose with an
+ * ![alt](./x.jpg) image.`), and pin the contract stated in
+ * `ImageInlineZoomView.tsx` and `findDescriptorRoot`'s doc comment:
+ * position resolution for an inline-leaf-wrapped PM atom must target the
+ * atom node's own range (direct `posAtDOM(<img>, 0)` path — no descriptor
+ * misroute), and any offset handed to `posAtDOM` counts childNodes (text
+ * nodes included), never an element-only index.
+ *
+ * `buildWalkerEnv` is intentionally private; the env is captured by
+ * stubbing the walker entry point via `mock.module` and driving
+ * `serializeFragment` — the same public wiring production uses.
+ *
+ * The registered mock DELEGATES to the real implementation except inside
+ * an explicit capture window, so it stays behavior-transparent to every
+ * other test file in the process. Bun's `mock.module` registry is
+ * process-global and never truly un-mocks (oven-sh/bun#12823), and an
+ * `afterAll` re-register's factory can observe the already-mocked
+ * namespace — a restore built from a namespace spread leaked the stub to
+ * later files on some runner file orders. Delegation avoids restore
+ * semantics entirely; `realWalkLiveDom` is captured before the mock so it
+ * is immune to in-place namespace mutation.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+import type { JSONContent } from '@tiptap/core';
+import type { Fragment } from '@tiptap/pm/model';
+import { Schema } from '@tiptap/pm/model';
+import type { EditorView } from '@tiptap/pm/view';
+import type { SerializeResult, WalkerEnv } from './clipboard-walker.ts';
+
+const actualWalker = await import('./clipboard-walker.ts');
+const realWalkLiveDom = actualWalker.walkLiveDomToInlineStyledFragment;
+
+let capturedEnv: WalkerEnv | null = null;
+let captureActive = false;
+
+mock.module('./clipboard-walker.ts', () => ({
+ ...actualWalker,
+ walkLiveDomToInlineStyledFragment: (slice: unknown, view: unknown, env: WalkerEnv) => {
+ if (captureActive) {
+ capturedEnv = env;
+ return { childNodes: [] };
+ }
+ // biome-ignore lint/suspicious/noExplicitAny: pass-through to the real implementation
+ return realWalkLiveDom(slice as any, view as any, env);
+ },
+}));
+
+// Imported AFTER the module mock so `serializeFragment`'s walker tier hits
+// the delegating mock above.
+const { createClipboardHtmlSerializer, findDescriptorRoot } = await import('./serialize.ts');
+
+// ---------------------------------------------------------------------------
+// Fake live-DOM elements. bun-test has no DOM; these cover exactly the
+// surface the code under test touches (`classList.contains`,
+// `hasAttribute`, `parentElement`, `childNodes`) with STABLE
+// object identity so `parentElement ===` and `childNodes.indexOf(...)` work.
+// ---------------------------------------------------------------------------
+
+interface FakeEl {
+ classes: Set<string>;
+ attrs: Set<string>;
+ parentElement: FakeEl | null;
+ children: FakeEl[];
+ childNodes: unknown[];
+ classList: { contains: (c: string) => boolean };
+ hasAttribute: (a: string) => boolean;
+}
+
+function el(opts?: { classes?: string[]; attrs?: string[] }): FakeEl {
+ const classes = new Set(opts?.classes ?? []);
+ const attrs = new Set(opts?.attrs ?? []);
+ const node: FakeEl = {
+ classes,
+ attrs,
+ parentElement: null,
+ children: [],
+ childNodes: [],
+ classList: { contains: (c: string) => classes.has(c) },
+ hasAttribute: (a: string) => attrs.has(a),
+ };
+ return node;
+}
+
+function chain(...els: FakeEl[]): void {
+ for (let i = 1; i < els.length; i++) {
+ els[i].parentElement = els[i - 1];
+ }
+}
+
+const fakeTextNode = () => ({ nodeType: 3 });
+
+/**
+ * Real production topology around ImageInlineZoom's inline `<img>`, with
+ * the leading/trailing text runs as paragraph siblings. Returns the
+ * elements the tests interrogate.
+ */
+function buildInlineZoomTopology() {
+ const proseMirror = el({ classes: ['ProseMirror'] });
+ const para = el();
+ const reactRenderer = el({ classes: ['react-renderer', 'node-image'] });
+ const inlineLeafWrapper = el({
+ attrs: ['data-node-view-wrapper', 'data-clipboard-inline-leaf'],
+ });
+ const rmiz = el({ attrs: ['data-rmiz'] });
+ const rmizContent = el({ attrs: ['data-rmiz-content'] });
+ const img = el();
+ chain(proseMirror, para, reactRenderer, inlineLeafWrapper, rmiz, rmizContent, img);
+ para.children = [reactRenderer];
+ para.childNodes = [fakeTextNode(), reactRenderer, fakeTextNode()];
+ return { para, reactRenderer, img };
+}
+
+// ---------------------------------------------------------------------------
+// PM document mirroring the inline-image-in-prose seed: `Some prose with an ![alt](./x.jpg) image.`
+// ---------------------------------------------------------------------------
+
+const inlineImageSchema = new Schema({
+ nodes: {
+ doc: { content: 'block+' },
+ paragraph: {
+ group: 'block',
+ content: 'inline*',
+ toDOM: () => ['p', 0],
+ parseDOM: [{ tag: 'p' }],
+ },
+ image: {
+ group: 'inline',
+ inline: true,
+ atom: true,
+ attrs: { src: { default: '' }, alt: { default: '' } },
+ toDOM: (node) => ['img', { src: node.attrs.src, alt: node.attrs.alt }],
+ parseDOM: [{ tag: 'img' }],
+ },
+ text: { group: 'inline' },
+ },
+});
+
+const LEADING_TEXT = 'Some prose with an ';
+const TRAILING_TEXT = ' image.';
+
+function buildDoc() {
+ return inlineImageSchema.node('doc', null, [
+ inlineImageSchema.node('paragraph', null, [
+ inlineImageSchema.text(LEADING_TEXT),
+ inlineImageSchema.node('image', { src: './x.jpg', alt: 'alt' }),
+ inlineImageSchema.text(TRAILING_TEXT),
+ ]),
+ ]);
+}
+
+// Paragraph content starts at 1; the image atom sits after the 19-char
+// leading text run.
+const IMAGE_POS = 1 + LEADING_TEXT.length;
+
+/**
+ * posAtDOM faithful to ProseMirror's documented contract: the offset
+ * argument counts CHILDNODES of the passed node (text nodes included).
+ * For the paragraph, childNodes map to PM inline children 1:1.
+ */
+function fakePosAtDOM(para: FakeEl, img: FakeEl, doc: ReturnType<typeof buildDoc>) {
+ const paraNode = doc.child(0);
+ return (node: unknown, offset: number, _bias?: number): number => {
+ if (node === img) return IMAGE_POS;
+ if (node === para) {
+ let pos = 1;
+ for (let i = 0; i < offset; i++) {
+ pos += paraNode.child(i).nodeSize;
+ }
+ return pos;
+ }
+ throw new RangeError('fakePosAtDOM: element not in fake mapping');
+ };
+}
+
+/**
+ * Markdown manager double that discriminates WHICH PM node reached
+ * serialization: an image node emits its markdown source; text emits the
+ * raw text. The assertion below is on which node was resolved, so a wrong
+ * range surfaces as wrong bytes, never a false green.
+ */
+function discriminatingMdManager() {
+ const serializeJson = (json: JSONContent): string => {
+ if (json.type === 'image') {
+ return `![${json.attrs?.alt ?? ''}](${json.attrs?.src ?? ''})`;
+ }
+ if (json.type === 'text') return json.text ?? '';
+ return (json.content ?? []).map(serializeJson).join('');
+ };
+ return {
+ serialize: (json: JSONContent) => serializeJson(json),
+ parse: () => ({ type: 'doc', content: [] }),
+ };
+}
+
+function captureEnv(para: FakeEl, img: FakeEl): WalkerEnv {
+ capturedEnv = null;
+ captureActive = true;
+ const doc = buildDoc();
+ const view = {
+ posAtDOM: fakePosAtDOM(para, img, doc),
+ state: {
+ schema: inlineImageSchema,
+ doc,
+ selection: {
+ from: 0,
+ to: doc.content.size,
+ content: () => doc.slice(0, doc.content.size),
+ },
+ },
+ } as unknown as EditorView;
+ const handle = createClipboardHtmlSerializer({
+ // biome-ignore lint/suspicious/noExplicitAny: markdown-manager double
+ mdManager: discriminatingMdManager() as any,
+ });
+ handle.setView(view);
+ try {
+ handle.serializer.serializeFragment({ firstChild: null } as unknown as Fragment, undefined, {
+ appendChild: () => {},
+ } as unknown as DocumentFragment);
+ } finally {
+ captureActive = false;
+ }
+ if (!capturedEnv) throw new Error('walker env was not captured');
+ return capturedEnv;
+}
+
+let origWarn: typeof console.warn;
+beforeEach(() => {
+ origWarn = console.warn;
+ console.warn = () => {};
+});
+afterEach(() => {
+ console.warn = origWarn;
+});
+
+describe('QA-005 contract — inline-image source-fallback range resolution', () => {
+ test('findDescriptorRoot: real ImageInlineZoom topology (outer .react-renderer.node-image present) is NOT a descriptor', () => {
+ // tiptap always renders a `.react-renderer.node-<name>` span around a
+ // React node view — the inline-leaf opt-out must neutralize the WHOLE
+ // wrapper stack of the same node view, not just the annotated
+ // NodeViewWrapper, so the direct `posAtDOM(<img>, 0)` path is taken.
+ const { img } = buildInlineZoomTopology();
+ expect(findDescriptorRoot(img as unknown as Element)).toBeNull();
+ });
+
+ test('serializeElementMarkdown resolves the inline image atom, not the paragraph leading text run', () => {
+ const { para, img } = buildInlineZoomTopology();
+ const env = captureEnv(para, img);
+ const result = env.serializeElementMarkdown?.(img as unknown as Element) as SerializeResult;
+ expect(result.kind).toBe('ok');
+ if (result.kind === 'ok') {
+ expect(result.markdown).toBe('![alt](./x.jpg)');
+ }
+ });
+
+ test('descriptor path with a leading text sibling passes a childNodes offset to posAtDOM (genuine descriptor mid-paragraph)', () => {
+ // Same paragraph shape, but the wrapper stack is a GENUINE descriptor
+ // (no `data-clipboard-inline-leaf`), so the descriptor-parent branch
+ // is the correct route. `mathInline` is the inline descriptor that
+ // actually sits mid-paragraph between text nodes (`MathInlineView`,
+ // NodeViewWrapper as="span"). The paragraph's childNodes are
+ // [#text, descriptor, #text]; an element-only index (0) addresses the
+ // leading text run. The offset fed to posAtDOM must count childNodes,
+ // so the resolved range is the descriptor's own node.
+ const proseMirror = el({ classes: ['ProseMirror'] });
+ const para = el();
+ const reactRenderer = el({ classes: ['react-renderer', 'node-mathInline'] });
+ const innerWrapper = el({ attrs: ['data-node-view-wrapper'] });
+ const leaf = el();
+ chain(proseMirror, para, reactRenderer, innerWrapper, leaf);
+ para.children = [reactRenderer];
+ para.childNodes = [fakeTextNode(), reactRenderer, fakeTextNode()];
+
+ const env = captureEnv(para, leaf);
+ const result = env.serializeElementMarkdown?.(leaf as unknown as Element) as SerializeResult;
+ expect(result.kind).toBe('ok');
+ if (result.kind === 'ok') {
+ expect(result.markdown).toBe('![alt](./x.jpg)');
+ }
+ });
+});
diff --git a/packages/app/src/editor/clipboard/serialize.test.ts b/packages/app/src/editor/clipboard/serialize.test.ts
index 9fbf5c271..795fd1634 100644
--- a/packages/app/src/editor/clipboard/serialize.test.ts
+++ b/packages/app/src/editor/clipboard/serialize.test.ts
@@ -336,14 +336,23 @@ function chainDescriptorEls(...els: FakeDescriptorElement[]): FakeDescriptorElem
return els[els.length - 1];
}
+// Memoized so repeated `parentElement` walks return the SAME wrapper
+// object — real DOM elements have stable identity, and the climb's
+// same-node-view containment check compares by identity.
+const descriptorWrappers = new WeakMap<FakeDescriptorElement, Element>();
+
function wrapDescriptor(el: FakeDescriptorElement): Element {
- return {
+ const existing = descriptorWrappers.get(el);
+ if (existing) return existing;
+ const wrapper = {
classList: { contains: (c: string) => el.classes.has(c) },
hasAttribute: (a: string) => el.attrs.has(a),
get parentElement() {
return el.parentElement === null ? null : wrapDescriptor(el.parentElement);
},
} as unknown as Element;
+ descriptorWrappers.set(el, wrapper);
+ return wrapper;
}
describe('findDescriptorRoot — outermost-wrapper selection', () => {
@@ -421,45 +430,63 @@ describe('findDescriptorRoot — outermost-wrapper selection', () => {
expect(root).toBeNull();
});
- test('(f) wrappers carrying `data-clipboard-inline-leaf` are skipped (ImageInlineZoom opt-out)', () => {
+ test("(f) wrappers carrying `data-clipboard-inline-leaf` are skipped, including the same node view's outer .react-renderer (ImageInlineZoom opt-out)", () => {
// `ImageInlineZoom` wraps inline `<img>` in `<NodeViewWrapper as="span"
// data-image-inline-zoom data-clipboard-inline-leaf="image">` so
- // click-to-enlarge works mid-prose. The wrapper carries
- // `data-node-view-wrapper` (tiptap stamps it on every NodeViewWrapper)
- // — without the opt-out, `findDescriptorRoot` would match the wrapper
- // and route clipboard serialization through the descriptor-parent
- // codepath (`posAtDOM(<p>, idx, -1)`), which has different mark-
- // interaction semantics than the direct `posAtDOM(<img>, 0)` path the
- // bare PM image node used. The opt-out preserves the pre-
- // existing clipboard behavior with zero risk surface. A regression
- // that drops the skip would silently re-introduce the routing change.
+ // click-to-enlarge works mid-prose. tiptap renders the node view as
+ // `.react-renderer.node-image > [data-node-view-wrapper ...]` — the
+ // opt-out must neutralize the WHOLE wrapper stack of that node view,
+ // not just the annotated wrapper: the outer `.react-renderer` belongs
+ // to the same node view and matching it would route clipboard
+ // serialization through the descriptor-parent codepath
+ // (`posAtDOM(<p>, idx, -1)`) instead of the direct
+ // `posAtDOM(<img>, 0)` path the bare PM image node uses. This models
+ // the real production topology.
const proseMirror = makeDescriptorEl({ classes: ['ProseMirror'] });
const para = makeDescriptorEl();
+ const outerReactRenderer = makeDescriptorEl({ classes: ['react-renderer', 'node-image'] });
const inlineLeafWrapper = makeDescriptorEl({
attrs: ['data-node-view-wrapper', 'data-clipboard-inline-leaf'],
});
const img = makeDescriptorEl();
- const live = chainDescriptorEls(proseMirror, para, inlineLeafWrapper, img);
+ const live = chainDescriptorEls(proseMirror, para, outerReactRenderer, inlineLeafWrapper, img);
expect(findDescriptorRoot(wrapDescriptor(live))).toBeNull();
});
- test('(g) opt-out is wrapper-local — a real descriptor BEYOND the inline-leaf wrapper still matches (defense against accidental no-op for nested cases)', () => {
- // Pin that `data-clipboard-inline-leaf` only skips THAT wrapper, not
- // the rest of the climb. If a future schema nests `ImageInlineZoom`
- // inside a block descriptor (hypothetical, but the walker shouldn't
- // care), the outer block descriptor must still be found.
+ test("(g) opt-out neutralizes only the same node view's stack — a genuine descriptor ABOVE it still matches", () => {
+ // Pin that the opt-out skips exactly the inline-leaf node view's own
+ // wrapper pair (`.react-renderer` + annotated NodeViewWrapper), not
+ // the rest of the climb. A genuine enclosing descriptor always
+ // interposes its OWN NodeViewWrapper between its `.react-renderer`
+ // and nested content, so if a future schema nests `ImageInlineZoom`
+ // inside a block descriptor, the outer descriptor must still be found.
const proseMirror = makeDescriptorEl({ classes: ['ProseMirror'] });
const outerReactRenderer = makeDescriptorEl({ classes: ['react-renderer'] });
+ const outerWrapper = makeDescriptorEl({
+ attrs: ['data-node-view-wrapper', 'data-jsx-component'],
+ });
+ const innerReactRenderer = makeDescriptorEl({ classes: ['react-renderer', 'node-image'] });
const inlineLeafWrapper = makeDescriptorEl({
attrs: ['data-node-view-wrapper', 'data-clipboard-inline-leaf'],
});
const img = makeDescriptorEl();
- const live = chainDescriptorEls(proseMirror, outerReactRenderer, inlineLeafWrapper, img);
+ const live = chainDescriptorEls(
+ proseMirror,
+ outerReactRenderer,
+ outerWrapper,
+ innerReactRenderer,
+ inlineLeafWrapper,
+ img,
+ );
const root = findDescriptorRoot(wrapDescriptor(live));
expect(root).not.toBeNull();
- expect(root?.classList.contains('react-renderer')).toBe(true);
+ // Positive: the OUTERMOST genuine descriptor root is returned.
+ expect(root).toBe(wrapDescriptor(outerReactRenderer));
+ // Negative: the inline node view's own wrapper stack was neutralized.
+ expect(root).not.toBe(wrapDescriptor(innerReactRenderer));
+ expect(root).not.toBe(wrapDescriptor(inlineLeafWrapper));
});
});
diff --git a/packages/app/src/editor/clipboard/serialize.ts b/packages/app/src/editor/clipboard/serialize.ts
index 5abdfeb45..39fe65836 100644
--- a/packages/app/src/editor/clipboard/serialize.ts
+++ b/packages/app/src/editor/clipboard/serialize.ts
@@ -488,6 +488,13 @@ function sliceToMarkdown(slice: Slice, schema: Schema, mdManager: MarkdownManage
* mark-interaction semantics than the direct `posAtDOM(<img>, 0)` path
* the bare PM image node uses. Skipping these wrappers preserves
* the direct-leaf clipboard behavior while still mounting the Zoom UI.
+ * The opt-out neutralizes the node view's WHOLE wrapper stack: tiptap
+ * always renders a `.react-renderer` element immediately around the
+ * NodeViewWrapper, so when the annotated wrapper is skipped, its direct
+ * `.react-renderer` parent (the same node view's outer wrapper) is
+ * skipped too. A genuine enclosing descriptor always interposes its own
+ * NodeViewWrapper between its `.react-renderer` and any nested content,
+ * so nested descriptors above the stack still match.
*
* Exported only for unit-test reach; the production caller is
* `buildWalkerEnv` below.
@@ -495,6 +502,7 @@ function sliceToMarkdown(slice: Slice, schema: Schema, mdManager: MarkdownManage
export function findDescriptorRoot(live: Element): Element | null {
let descriptorRoot: Element | null = null;
let cur: Element | null = live;
+ let optedOutWrapper: Element | null = null;
while (cur && !cur.classList.contains('ProseMirror')) {
// Opt-out: live-editor render wrappers around bare inline PM atoms
// (e.g., `ImageInlineZoom`'s `<Zoom>` wrap). The PM node IS the leaf
@@ -502,6 +510,17 @@ export function findDescriptorRoot(live: Element): Element | null {
// `data-node-view-wrapper` on the NodeViewWrapper. Skip these so
// `posAtDOM(<img>, 0)` stays the resolution path.
if (cur.hasAttribute('data-clipboard-inline-leaf')) {
+ optedOutWrapper = cur;
+ cur = cur.parentElement;
+ continue;
+ }
+ // tiptap always renders a `.react-renderer` immediately around the
+ // same node view's NodeViewWrapper. When that wrapper opted out, its
+ // DIRECT `.react-renderer` parent belongs to the same node view and
+ // must be neutralized too — a genuine enclosing descriptor always
+ // interposes its own NodeViewWrapper, so this containment check
+ // cannot swallow real nested descriptors.
+ if (optedOutWrapper?.parentElement === cur && cur.classList.contains('react-renderer')) {
cur = cur.parentElement;
continue;
}
@@ -567,7 +586,10 @@ function buildWalkerEnv(view: EditorView, mdManager: MarkdownManager): WalkerEnv
try {
const parent = descriptorRoot?.parentElement;
if (parent && descriptorRoot) {
- const idx = Array.from(parent.children).indexOf(descriptorRoot);
+ // posAtDOM's offset counts CHILDNODES (text nodes included), not
+ // element children — an element-only index misaddresses any
+ // descriptor with a non-element preceding sibling.
+ const idx = Array.prototype.indexOf.call(parent.childNodes, descriptorRoot);
pos = view.posAtDOM(parent, idx, -1);
} else {
pos = view.posAtDOM(live, 0);
diff --git a/packages/app/src/editor/extensions/ImageInlineZoomView.tsx b/packages/app/src/editor/extensions/ImageInlineZoomView.tsx
index bcb3df6ad..9ac4cca23 100644
--- a/packages/app/src/editor/extensions/ImageInlineZoomView.tsx
+++ b/packages/app/src/editor/extensions/ImageInlineZoomView.tsx
@@ -17,7 +17,9 @@
* `findDescriptorRoot` (see `clipboard/serialize.ts`): the PM node IS
* the bare `<img>` atom, not a descriptor, so position resolution must
* stay on the direct-leaf `posAtDOM(<img>, 0)` path that the un-wrapped
- * image used.
+ * image used. The opt-out neutralizes this node view's whole wrapper
+ * stack: the outer `.react-renderer` span tiptap renders directly around
+ * this wrapper is skipped too.
*
* Doc-relative `src` is resolved against the document's folder here, the
* same render-time normalization the block path applies in
diff --git a/packages/app/tests/stress/clipboard-relative-url-source-fallback.e2e.ts b/packages/app/tests/stress/clipboard-relative-url-source-fallback.e2e.ts
index d7477d940..6f797631d 100644
--- a/packages/app/tests/stress/clipboard-relative-url-source-fallback.e2e.ts
+++ b/packages/app/tests/stress/clipboard-relative-url-source-fallback.e2e.ts
@@ -143,6 +143,47 @@ test.describe('FR-2 walker URL classifier — WYSIWYG cross-app source-fallback'
expect(captured.html).not.toContain('src="./x.jpg"');
});
+ test('QA-005b inline image adjacent to marks resolves the image range and keeps the marks', async ({
+ page,
+ baseURL,
+ }) => {
+ // Behavioral pin for the direct-path resolution when the image sits
+ // inside marked text. The mark-interaction semantics of the direct
+ // `posAtDOM(<img>, 0)` path (vs the descriptor-parent path's -1 bias)
+ // only matter when marks surround the image, so this seed puts the
+ // image inside a strong run with prose on both sides.
+ await fetch(`${baseURL}/api/agent-write-md`, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ docName,
+ markdown: 'Lead **bold ![alt](./y.png) tail** end.\n',
+ position: 'replace',
+ }),
+ });
+ await expect(async () => {
+ expect(await getYText(page)).toContain('![alt](./y.png)');
+ }).toPass({ timeout: 5_000 });
+ await page.click('.ProseMirror:not(.composer-prosemirror)');
+
+ const captured = await simulateCopyAndRead(page, 'wysiwyg');
+
+ // text/plain is canonical markdown; the serializer splits the strong
+ // run around the image atom, so assert the pieces rather than exact
+ // bytes (that emission path is untouched here).
+ expect(captured.plain).toContain('![alt](./y.png)');
+ expect(captured.plain).toContain('bold');
+ expect(captured.plain).toContain('tail');
+ // The fallback span carries the image's own markdown, not a duplicate
+ // of the surrounding text run.
+ expect(captured.html).toContain('<span class="mdx-inline">');
+ expect(captured.html).toContain('![alt](./y.png)');
+ expect(captured.html).not.toMatch(/<span class="mdx-inline">[^<]*bold/);
+ // The strong mark survives around the swap.
+ expect(captured.html).toMatch(/<(strong|b)[\s>]/);
+ expect(captured.html).not.toContain('src="./y.png"');
+ });
+
test('QA-009 all-portable selection: walker passes through unchanged (regression check)', async ({
page,
baseURL,