@beyondwork/docx-react-component 1.0.0

package/test/io/complex-content-roundtrip.test.ts

@@ -0,0 +1,632 @@
+/**
+ * complex-content-roundtrip.test.ts
+ *
+ * Integration tests for complex OOXML rendering content:
+ * Charts, SmartArt, Shapes (wps:wsp), WordArt, and VML shapes.
+ *
+ * Each test validates the full path:
+ *   XML fixture → parse → canonical node → surface projection → PM state
+ *   → verify PM atom type → verify rawXml preservation (round-trip)
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type {
+  CanonicalDocument,
+  ChartPreviewNode,
+  DocumentRootNode,
+  InlineNode,
+  ParagraphNode,
+  ShapeNode,
+  SmartArtPreviewNode,
+  VmlShapeNode,
+  WordArtNode,
+} from "../../src/model/canonical-document.ts";
+import { CDS_SCHEMA_VERSION } from "../../src/model/cds-1.0.0.ts";
+import { parseComplexContentXml } from "../../src/io/ooxml/parse-complex-content.ts";
+import { parseShapeXml, parseVmlXml } from "../../src/io/ooxml/parse-shapes.ts";
+import { createEditorSurfaceSnapshot } from "../../src/runtime/surface-projection.ts";
+import { createPMStateFromSnapshot } from "../../src/ui-tailwind/editor-surface/pm-state-from-snapshot.ts";
+import { serializeMainDocument } from "../../src/io/export/serialize-main-document.ts";
+
+// ---------------------------------------------------------------------------
+// Fixture XML fragments
+// ---------------------------------------------------------------------------
+
+const CHART_DRAWING_XML = `<w:drawing
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+  xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"
+  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+  xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"
+  xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <mc:AlternateContent>
+    <mc:Choice Requires="c14">
+      <wp:inline>
+        <a:graphic>
+          <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart">
+            <c:chart r:id="rIdChart1"/>
+          </a:graphicData>
+        </a:graphic>
+      </wp:inline>
+    </mc:Choice>
+    <mc:Fallback>
+      <wp:inline>
+        <wp:docPr id="1" name="Chart 1" descr="Sales chart"/>
+        <a:graphic>
+          <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
+            <pic:pic>
+              <pic:blipFill><a:blip r:embed="rIdChartImg1"/></pic:blipFill>
+            </pic:pic>
+          </a:graphicData>
+        </a:graphic>
+      </wp:inline>
+    </mc:Fallback>
+  </mc:AlternateContent>
+</w:drawing>`;
+
+const SMARTART_DRAWING_XML = `<w:drawing
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+  xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"
+  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+  xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"
+  xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <mc:AlternateContent>
+    <mc:Choice Requires="dgm2009">
+      <wp:inline>
+        <a:graphic>
+          <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/diagram">
+            <dgm:relIds r:dm="rIdDgm1" r:lo="rIdDgmLayout1"/>
+          </a:graphicData>
+        </a:graphic>
+      </wp:inline>
+    </mc:Choice>
+    <mc:Fallback>
+      <wp:inline>
+        <a:graphic>
+          <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
+            <pic:pic>
+              <pic:blipFill><a:blip r:embed="rIdSmartArtImg1"/></pic:blipFill>
+            </pic:pic>
+          </a:graphicData>
+        </a:graphic>
+      </wp:inline>
+    </mc:Fallback>
+  </mc:AlternateContent>
+</w:drawing>`;
+
+const SHAPE_DRAWING_XML = `<w:drawing
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+  xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
+  xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing">
+  <wp:inline>
+    <a:graphic>
+      <a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape">
+        <wps:wsp>
+          <wps:spPr>
+            <a:prstGeom prst="roundRect"/>
+          </wps:spPr>
+          <wps:txbx>
+            <w:txbxContent>
+              <w:p><w:r><w:t>Hello from shape</w:t></w:r></w:p>
+            </w:txbxContent>
+          </wps:txbx>
+        </wps:wsp>
+      </a:graphicData>
+    </a:graphic>
+  </wp:inline>
+</w:drawing>`;
+
+const WORDART_DRAWING_XML = `<w:drawing
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+  xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
+  xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing">
+  <wp:inline>
+    <a:graphic>
+      <a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape">
+        <wps:wsp>
+          <wps:spPr>
+            <a:prstGeom prst="textWave"/>
+          </wps:spPr>
+          <wps:txbx>
+            <w:txbxContent>
+              <w:p><w:r><w:t>WordArt title</w:t></w:r></w:p>
+            </w:txbxContent>
+          </wps:txbx>
+        </wps:wsp>
+      </a:graphicData>
+    </a:graphic>
+  </wp:inline>
+</w:drawing>`;
+
+const VML_PICT_XML = `<w:pict
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:v="urn:schemas-microsoft-com:vml"
+  xmlns:o="urn:schemas-microsoft-com:office:office">
+  <v:shape id="s1" type="#_x0000_t202" style="width:120pt;height:60pt">
+    <v:textbox style="mso-direction-alt:auto">
+      <w:txbxContent>
+        <w:p><w:r><w:t>VML text box content</w:t></w:r></w:p>
+      </w:txbxContent>
+    </v:textbox>
+  </v:shape>
+</w:pict>`;
+
+const CHART_RELATIONSHIPS = [
+  {
+    id: "rIdChart1",
+    type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
+    target: "charts/chart1.xml",
+    targetMode: "internal" as const,
+  },
+  {
+    id: "rIdChartImg1",
+    type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+    target: "media/chart1.png",
+    targetMode: "internal" as const,
+  },
+];
+
+const SMARTART_RELATIONSHIPS = [
+  {
+    id: "rIdDgm1",
+    type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData",
+    target: "diagrams/data1.xml",
+    targetMode: "internal" as const,
+  },
+  {
+    id: "rIdSmartArtImg1",
+    type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+    target: "media/smartart1.png",
+    targetMode: "internal" as const,
+  },
+];
+
+const CHART_MEDIA_PARTS = new Map([
+  [
+    "/word/media/chart1.png",
+    { path: "/word/media/chart1.png", contentType: "image/png" },
+  ],
+]);
+
+const SMARTART_MEDIA_PARTS = new Map([
+  [
+    "/word/media/smartart1.png",
+    { path: "/word/media/smartart1.png", contentType: "image/png" },
+  ],
+]);
+
+// ---------------------------------------------------------------------------
+// Helper: build a minimal CanonicalDocument for surface/PM tests
+// ---------------------------------------------------------------------------
+
+function makeCanonicalDoc(inlineNodes: InlineNode[]): CanonicalDocument {
+  const paragraph: ParagraphNode = { type: "paragraph", children: inlineNodes };
+  const content: DocumentRootNode = { type: "doc", children: [paragraph] };
+  return {
+    schemaVersion: CDS_SCHEMA_VERSION,
+    docId: "49d3576d-a0e3-4ce5-97c1-dc42f6200c1e",
+    createdAt: "2026-04-06T00:00:00.000Z",
+    updatedAt: "2026-04-06T00:00:00.000Z",
+    metadata: { customProperties: {} },
+    styles: { paragraphs: {}, characters: {}, tables: {} },
+    numbering: { abstractDefinitions: {}, instances: {} },
+    media: { items: {} },
+    content,
+    review: { comments: {}, revisions: {} },
+    preservation: { opaqueFragments: {}, packageParts: {} },
+    diagnostics: { warnings: [], errors: [] },
+  };
+}
+
+const MOCK_SELECTION = {
+  anchor: 0,
+  head: 0,
+  isCollapsed: true,
+  activeRange: { kind: "range" as const, from: 0, to: 0, assoc: { start: -1 as const, end: 1 as const } },
+};
+
+// ---------------------------------------------------------------------------
+// Chart tests
+// ---------------------------------------------------------------------------
+
+test("parseComplexContentXml: detects chart in mc:AlternateContent", () => {
+  const result = parseComplexContentXml(
+    CHART_DRAWING_XML,
+    CHART_RELATIONSHIPS,
+    CHART_MEDIA_PARTS,
+  );
+  assert.ok(result, "Expected a ParsedComplexContent result");
+  assert.equal(result.type, "chart_preview");
+  assert.equal(result.previewMediaId, "media:word/media/chart1.png");
+  assert.ok(result.rawXml.includes("<mc:AlternateContent"), "rawXml should contain AlternateContent");
+});
+
+test("chart_preview: canonical node validates and round-trips rawXml", () => {
+  const parsed = parseComplexContentXml(CHART_DRAWING_XML, CHART_RELATIONSHIPS, CHART_MEDIA_PARTS);
+  assert.ok(parsed && parsed.type === "chart_preview");
+
+  const node: ChartPreviewNode = {
+    type: "chart_preview",
+    previewMediaId: parsed.previewMediaId,
+    rawXml: parsed.rawXml,
+  };
+
+  const doc = makeCanonicalDoc([node]);
+  // Validate via surface (triggers canonical validation indirectly)
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  assert.equal(surface.blocks.length, 1);
+  assert.equal(surface.blocks[0]?.kind, "paragraph");
+
+  const para = surface.blocks[0];
+  assert.ok(para?.kind === "paragraph");
+  assert.equal(para.segments.length, 1);
+  assert.equal(para.segments[0]?.kind, "opaque_inline");
+  assert.equal(para.segments[0]?.label, "Chart");
+  assert.ok(para.segments[0]?.detail?.includes("Chart read-only preview"));
+});
+
+test("chart_preview: PM state uses chart_atom node", () => {
+  const node: ChartPreviewNode = {
+    type: "chart_preview",
+    rawXml: CHART_DRAWING_XML,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const pm = createPMStateFromSnapshot(surface, MOCK_SELECTION, []);
+  const paragraph = pm.state.doc.firstChild;
+  assert.ok(paragraph, "Expected a paragraph node");
+  const chartAtom = paragraph.firstChild;
+  assert.ok(chartAtom, "Expected a chart_atom node");
+  assert.equal(chartAtom.type.name, "chart_atom");
+});
+
+test("chart_preview: serializes rawXml unchanged (round-trip)", () => {
+  const node: ChartPreviewNode = {
+    type: "chart_preview",
+    rawXml: CHART_DRAWING_XML,
+  };
+  const para: ParagraphNode = { type: "paragraph", children: [node] };
+  const content: DocumentRootNode = { type: "doc", children: [para] };
+  const result = serializeMainDocument(content, undefined, []);
+  assert.ok(
+    result.documentXml.includes("<mc:AlternateContent"),
+    "Serialized output must contain original AlternateContent XML",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// SmartArt tests
+// ---------------------------------------------------------------------------
+
+test("parseComplexContentXml: detects SmartArt in mc:AlternateContent", () => {
+  const result = parseComplexContentXml(
+    SMARTART_DRAWING_XML,
+    SMARTART_RELATIONSHIPS,
+    SMARTART_MEDIA_PARTS,
+  );
+  assert.ok(result, "Expected a ParsedComplexContent result");
+  assert.equal(result.type, "smartart_preview");
+  assert.equal(result.previewMediaId, "media:word/media/smartart1.png");
+  assert.ok(result.rawXml.includes("<mc:AlternateContent"), "rawXml should contain AlternateContent");
+});
+
+test("smartart_preview: surface segment is labeled SmartArt", () => {
+  const parsed = parseComplexContentXml(SMARTART_DRAWING_XML, SMARTART_RELATIONSHIPS, SMARTART_MEDIA_PARTS);
+  assert.ok(parsed && parsed.type === "smartart_preview");
+
+  const node: SmartArtPreviewNode = {
+    type: "smartart_preview",
+    previewMediaId: parsed.previewMediaId,
+    rawXml: parsed.rawXml,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const para = surface.blocks[0];
+  assert.ok(para?.kind === "paragraph");
+  assert.equal(para.segments[0]?.label, "SmartArt");
+});
+
+test("smartart_preview: PM state uses smartart_atom node", () => {
+  const node: SmartArtPreviewNode = {
+    type: "smartart_preview",
+    rawXml: SMARTART_DRAWING_XML,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const pm = createPMStateFromSnapshot(surface, MOCK_SELECTION, []);
+  assert.equal(pm.state.doc.firstChild?.firstChild?.type.name, "smartart_atom");
+});
+
+test("smartart_preview: serializes rawXml unchanged (round-trip)", () => {
+  const node: SmartArtPreviewNode = {
+    type: "smartart_preview",
+    rawXml: SMARTART_DRAWING_XML,
+  };
+  const para: ParagraphNode = { type: "paragraph", children: [node] };
+  const content: DocumentRootNode = { type: "doc", children: [para] };
+  const result = serializeMainDocument(content, undefined, []);
+  assert.ok(result.documentXml.includes("<mc:AlternateContent"));
+  assert.ok(result.documentXml.includes("dgm:relIds"));
+});
+
+// ---------------------------------------------------------------------------
+// Shape (wps:wsp) tests
+// ---------------------------------------------------------------------------
+
+test("parseShapeXml: detects wps:wsp shape with geometry and text", () => {
+  const result = parseShapeXml(SHAPE_DRAWING_XML);
+  assert.ok(result, "Expected a parsed shape result");
+  assert.equal(result.type, "shape");
+  assert.equal(result.geometry, "roundRect");
+  assert.equal(result.text, "Hello from shape");
+  assert.ok(result.rawXml.includes("wps:wsp"), "rawXml should contain wps:wsp");
+});
+
+test("shape: surface segment is labeled Shape with text", () => {
+  const parsed = parseShapeXml(SHAPE_DRAWING_XML);
+  assert.ok(parsed && parsed.type === "shape");
+
+  const node: ShapeNode = {
+    type: "shape",
+    text: parsed.text,
+    geometry: parsed.geometry,
+    rawXml: parsed.rawXml,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const para = surface.blocks[0];
+  assert.ok(para?.kind === "paragraph");
+  assert.equal(para.segments[0]?.label, "Shape");
+  assert.ok(para.segments[0]?.detail?.includes("Hello from shape"));
+});
+
+test("shape: PM state uses shape_atom node", () => {
+  const node: ShapeNode = {
+    type: "shape",
+    text: "Hello from shape",
+    geometry: "roundRect",
+    rawXml: SHAPE_DRAWING_XML,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const pm = createPMStateFromSnapshot(surface, MOCK_SELECTION, []);
+  assert.equal(pm.state.doc.firstChild?.firstChild?.type.name, "shape_atom");
+});
+
+test("shape: serializes rawXml unchanged (round-trip)", () => {
+  const node: ShapeNode = {
+    type: "shape",
+    text: "Hello from shape",
+    rawXml: SHAPE_DRAWING_XML,
+  };
+  const para: ParagraphNode = { type: "paragraph", children: [node] };
+  const content: DocumentRootNode = { type: "doc", children: [para] };
+  const result = serializeMainDocument(content, undefined, []);
+  assert.ok(result.documentXml.includes("wps:wsp"));
+  assert.ok(result.documentXml.includes("roundRect"));
+});
+
+// ---------------------------------------------------------------------------
+// WordArt tests
+// ---------------------------------------------------------------------------
+
+test("parseShapeXml: detects WordArt shape (text geometry preset)", () => {
+  const result = parseShapeXml(WORDART_DRAWING_XML);
+  assert.ok(result, "Expected a parsed WordArt result");
+  assert.equal(result.type, "wordart");
+  assert.equal(result.geometry, "textWave");
+  assert.equal(result.text, "WordArt title");
+  assert.ok(result.rawXml.includes("textWave"), "rawXml should contain geometry");
+});
+
+test("wordart: surface segment is labeled WordArt", () => {
+  const parsed = parseShapeXml(WORDART_DRAWING_XML);
+  assert.ok(parsed && parsed.type === "wordart");
+
+  const node: WordArtNode = {
+    type: "wordart",
+    text: parsed.text,
+    geometry: parsed.geometry,
+    rawXml: parsed.rawXml,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const para = surface.blocks[0];
+  assert.ok(para?.kind === "paragraph");
+  assert.equal(para.segments[0]?.label, "WordArt");
+  assert.ok(para.segments[0]?.detail?.includes("WordArt title"));
+});
+
+test("wordart: PM state uses wordart_atom node", () => {
+  const node: WordArtNode = {
+    type: "wordart",
+    text: "WordArt title",
+    geometry: "textWave",
+    rawXml: WORDART_DRAWING_XML,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const pm = createPMStateFromSnapshot(surface, MOCK_SELECTION, []);
+  assert.equal(pm.state.doc.firstChild?.firstChild?.type.name, "wordart_atom");
+});
+
+test("wordart: serializes rawXml unchanged (round-trip)", () => {
+  const node: WordArtNode = {
+    type: "wordart",
+    text: "WordArt title",
+    rawXml: WORDART_DRAWING_XML,
+  };
+  const para: ParagraphNode = { type: "paragraph", children: [node] };
+  const content: DocumentRootNode = { type: "doc", children: [para] };
+  const result = serializeMainDocument(content, undefined, []);
+  assert.ok(result.documentXml.includes("textWave"));
+  assert.ok(result.documentXml.includes("WordArt title"));
+});
+
+// ---------------------------------------------------------------------------
+// VML tests
+// ---------------------------------------------------------------------------
+
+test("parseVmlXml: detects VML shape with text", () => {
+  const result = parseVmlXml(VML_PICT_XML);
+  assert.ok(result, "Expected a parsed VML result");
+  assert.equal(result.type, "vml_shape");
+  assert.equal(result.shapeType, "#_x0000_t202");
+  assert.equal(result.text, "VML text box content");
+  assert.ok(result.rawXml.includes("v:shape"), "rawXml should contain v:shape");
+});
+
+test("vml_shape: surface segment is labeled VML shape", () => {
+  const parsed = parseVmlXml(VML_PICT_XML);
+  assert.ok(parsed);
+
+  const node: VmlShapeNode = {
+    type: "vml_shape",
+    shapeType: parsed.shapeType,
+    text: parsed.text,
+    rawXml: parsed.rawXml,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const para = surface.blocks[0];
+  assert.ok(para?.kind === "paragraph");
+  assert.equal(para.segments[0]?.label, "VML shape");
+  assert.ok(para.segments[0]?.detail?.includes("VML text box content"));
+});
+
+test("vml_shape: PM state uses vml_atom node", () => {
+  const node: VmlShapeNode = {
+    type: "vml_shape",
+    shapeType: "#_x0000_t202",
+    text: "VML text box content",
+    rawXml: VML_PICT_XML,
+  };
+  const doc = makeCanonicalDoc([node]);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  const pm = createPMStateFromSnapshot(surface, MOCK_SELECTION, []);
+  assert.equal(pm.state.doc.firstChild?.firstChild?.type.name, "vml_atom");
+});
+
+test("vml_shape: serializes rawXml unchanged (round-trip)", () => {
+  const node: VmlShapeNode = {
+    type: "vml_shape",
+    text: "VML text box content",
+    rawXml: VML_PICT_XML,
+  };
+  const para: ParagraphNode = { type: "paragraph", children: [node] };
+  const content: DocumentRootNode = { type: "doc", children: [para] };
+  const result = serializeMainDocument(content, undefined, []);
+  assert.ok(result.documentXml.includes("v:shape"));
+  assert.ok(result.documentXml.includes("VML text box content"));
+});
+
+// ---------------------------------------------------------------------------
+// Mixed content round-trip
+// ---------------------------------------------------------------------------
+
+test("mixed complex content: all five types in one paragraph", () => {
+  const nodes: InlineNode[] = [
+    {
+      type: "chart_preview",
+      rawXml: CHART_DRAWING_XML,
+    },
+    {
+      type: "smartart_preview",
+      rawXml: SMARTART_DRAWING_XML,
+    },
+    {
+      type: "shape",
+      text: "Hello from shape",
+      geometry: "roundRect",
+      rawXml: SHAPE_DRAWING_XML,
+    },
+    {
+      type: "wordart",
+      text: "WordArt title",
+      geometry: "textWave",
+      rawXml: WORDART_DRAWING_XML,
+    },
+    {
+      type: "vml_shape",
+      shapeType: "#_x0000_t202",
+      text: "VML text box content",
+      rawXml: VML_PICT_XML,
+    },
+  ];
+
+  const doc = makeCanonicalDoc(nodes);
+  const surface = createEditorSurfaceSnapshot(doc, MOCK_SELECTION);
+  assert.equal(surface.blocks.length, 1);
+
+  const para = surface.blocks[0];
+  assert.ok(para?.kind === "paragraph");
+  assert.equal(para.segments.length, 5);
+
+  const labels = para.segments.map((s) => s.kind === "opaque_inline" ? s.label : "");
+  assert.deepEqual(labels, ["Chart", "SmartArt", "Shape", "WordArt", "VML shape"]);
+
+  const pm = createPMStateFromSnapshot(surface, MOCK_SELECTION, []);
+  const pmPara = pm.state.doc.firstChild;
+  assert.ok(pmPara);
+  const atomNames = [];
+  pmPara.forEach((child) => atomNames.push(child.type.name));
+  assert.deepEqual(atomNames, [
+    "chart_atom",
+    "smartart_atom",
+    "shape_atom",
+    "wordart_atom",
+    "vml_atom",
+  ]);
+
+  // Verify round-trip serialization preserves all raw XML
+  const para2: ParagraphNode = { type: "paragraph", children: nodes };
+  const content: DocumentRootNode = { type: "doc", children: [para2] };
+  const serialized = serializeMainDocument(content, undefined, []);
+  assert.ok(serialized.documentXml.includes("<mc:AlternateContent"), "chart AlternateContent");
+  assert.ok(serialized.documentXml.includes("dgm:relIds"), "SmartArt diagram relIds");
+  assert.ok(serialized.documentXml.includes("wps:wsp"), "shape wps:wsp");
+  assert.ok(serialized.documentXml.includes("textWave"), "wordart geometry");
+  assert.ok(serialized.documentXml.includes("v:shape"), "VML shape");
+});
+
+// ---------------------------------------------------------------------------
+// Negative: parseComplexContentXml returns null for plain images
+// ---------------------------------------------------------------------------
+
+test("parseComplexContentXml: returns null for plain image drawing", () => {
+  const plainImageXml = `<w:drawing
+    xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+    xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"
+    xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+    xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+    <wp:inline>
+      <a:graphic>
+        <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
+          <pic:pic>
+            <pic:blipFill><a:blip r:embed="rId1"/></pic:blipFill>
+          </pic:pic>
+        </a:graphicData>
+      </a:graphic>
+    </wp:inline>
+  </w:drawing>`;
+  const result = parseComplexContentXml(plainImageXml, [], new Map());
+  assert.equal(result, null);
+});
+
+test("parseShapeXml: returns null for non-shape drawing", () => {
+  const result = parseShapeXml(CHART_DRAWING_XML);
+  assert.equal(result, null);
+});
+
+test("parseVmlXml: returns null for drawing without VML shapes", () => {
+  const noPictXml = `<w:pict xmlns:v="urn:schemas-microsoft-com:vml"/>`;
+  const result = parseVmlXml(noPictXml);
+  assert.equal(result, null);
+});