@beyondwork/docx-react-component 1.0.0

package/test/io/table-roundtrip.test.ts

@@ -0,0 +1,302 @@
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import test from "node:test";
+
+import { createExportSession } from "../../src/io/export/export-session.ts";
+import { serializeTable } from "../../src/io/export/serialize-tables.ts";
+import type {
+  ParsedTable,
+  ParsedTableDocument,
+} from "../../src/io/ooxml/parse-tables.ts";
+import { parseTablesFromDocumentXml } from "../../src/io/ooxml/parse-tables.ts";
+import { DOCX_DOCUMENT_CONTENT_TYPE, writeDocxPackage } from "../../src/io/opc/docx-package.ts";
+import { readOpcPackage } from "../../src/io/opc/package-reader.ts";
+
+const PROOF_DIR = ".tmp/wave-20-table-proof";
+const PROOF_PATH = `${PROOF_DIR}/roundtrip-summary.json`;
+
+const proofReport: {
+  reportVersion: string;
+  generatedAt: string;
+  fixtures: Array<{
+    id: string;
+    source: string;
+    tableCount: number;
+    roundtripStable: boolean;
+    gridColumns: number[][];
+    mergedCells: Array<{
+      row: number;
+      cell: number;
+      gridSpan: number | null;
+      verticalMerge: "restart" | "continue" | null;
+    }>;
+    formattingMarkers: string[];
+  }>;
+} = {
+  reportVersion: "wave-20-table-roundtrip/1",
+  generatedAt: new Date().toISOString(),
+  fixtures: [],
+};
+
+test("fixture packages preserve table topology through parse and serialize roundtrip", () => {
+  const fixtures = [
+    {
+      id: "F05",
+      source: "test/fixtures/docx/F05-table-heavy-agreement.docx",
+      expectedTableCount: 2,
+      expectedGridColumns: [
+        [2200, 3200, 3200],
+        [3200, 5400],
+      ],
+      expectedMergedCells: [] as Array<{
+        row: number;
+        cell: number;
+        gridSpan: number | null;
+        verticalMerge: "restart" | "continue" | null;
+      }>,
+      formattingMarkers: [
+        "<w:t>Commercial terms matrix</w:t>",
+        "<w:t>Escalation matrix attached.</w:t>",
+      ],
+    },
+    {
+      id: "F06",
+      source: "test/fixtures/docx/F06-merged-cells-signature-table.docx",
+      expectedTableCount: 1,
+      expectedGridColumns: [[2400, 3600, 2400]],
+      expectedMergedCells: [
+        { row: 0, cell: 1, gridSpan: 2, verticalMerge: null },
+        { row: 1, cell: 0, gridSpan: null, verticalMerge: "restart" },
+        { row: 2, cell: 0, gridSpan: null, verticalMerge: "continue" },
+      ],
+      formattingMarkers: [
+        "<w:gridSpan w:val=\"2\"/>",
+        "<w:vMerge w:val=\"restart\"/>",
+        "<w:vMerge/>",
+      ],
+    },
+  ] as const;
+
+  for (const fixture of fixtures) {
+    const sourcePackage = readOpcPackage(new Uint8Array(readFileSync(fixture.source)));
+    const documentPart = sourcePackage.parts.get("/word/document.xml");
+    assert.ok(documentPart, `Expected /word/document.xml in ${fixture.id}.`);
+
+    const documentXml = toText(documentPart.bytes);
+    assert.ok(documentXml, `Expected document XML in ${fixture.id}.`);
+
+    const parsed = parseTablesFromDocumentXml(documentXml);
+    assert.equal(parsed.tables.length, fixture.expectedTableCount);
+    assert.deepEqual(
+      parsed.tables.map((table) => table.gridColumns),
+      fixture.expectedGridColumns,
+    );
+
+    const mergedCells = collectMergedCells(parsed);
+    assert.deepEqual(mergedCells, fixture.expectedMergedCells);
+
+    const rebuiltDocumentXml = roundtripDocumentTables(documentXml, parsed.tables);
+    const exportedPackage = readOpcPackage(
+      createExportSession(sourcePackage, ["/word/document.xml"])
+        .withOwnedPart({
+          path: "/word/document.xml",
+          bytes: new TextEncoder().encode(rebuiltDocumentXml),
+          contentType: documentPart.contentType ?? DOCX_DOCUMENT_CONTENT_TYPE,
+          relationships: documentPart.relationships,
+        })
+        .serialize(),
+    );
+
+    const exportedDocumentPart = exportedPackage.parts.get("/word/document.xml");
+    assert.ok(exportedDocumentPart, `Expected rebuilt /word/document.xml in ${fixture.id}.`);
+
+    const exportedDocumentXml = toText(exportedDocumentPart.bytes);
+    const reparsed = parseTablesFromDocumentXml(exportedDocumentXml);
+    const roundtripStable =
+      JSON.stringify(toTableSignature(reparsed)) === JSON.stringify(toTableSignature(parsed));
+
+    assert.equal(roundtripStable, true, `${fixture.id} table structure changed across roundtrip.`);
+    assert.deepEqual(
+      [...exportedPackage.parts.keys()].sort(),
+      [...sourcePackage.parts.keys()].sort(),
+      `${fixture.id} package parts changed during document rewrite.`,
+    );
+
+    for (const marker of fixture.formattingMarkers) {
+      assert.match(exportedDocumentXml, new RegExp(escapeRegExp(marker)));
+    }
+
+    proofReport.fixtures.push({
+      id: fixture.id,
+      source: fixture.source,
+      tableCount: reparsed.tables.length,
+      roundtripStable,
+      gridColumns: reparsed.tables.map((table) => table.gridColumns),
+      mergedCells,
+      formattingMarkers: fixture.formattingMarkers,
+    });
+  }
+});
+
+test("table roundtrip preserves cell formatting markup in package-backed export", () => {
+  const documentXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:tbl>
+      <w:tblPr>
+        <w:tblW w:w="0" w:type="auto"/>
+      </w:tblPr>
+      <w:tblGrid>
+        <w:gridCol w:w="2400"/>
+        <w:gridCol w:w="3600"/>
+      </w:tblGrid>
+      <w:tr>
+        <w:tc>
+          <w:tcPr>
+            <w:tcW w:w="2400" w:type="dxa"/>
+            <w:shd w:val="clear" w:color="auto" w:fill="D9EAF7"/>
+          </w:tcPr>
+          <w:p>
+            <w:pPr><w:jc w:val="center"/></w:pPr>
+            <w:r>
+              <w:rPr><w:b/><w:i/><w:color w:val="1F4E79"/></w:rPr>
+              <w:t>Styled heading</w:t>
+            </w:r>
+          </w:p>
+        </w:tc>
+        <w:tc>
+          <w:tcPr><w:tcW w:w="3600" w:type="dxa"/></w:tcPr>
+          <w:p>
+            <w:r>
+              <w:rPr><w:u w:val="single"/></w:rPr>
+              <w:t>Underlined clause text</w:t>
+            </w:r>
+          </w:p>
+        </w:tc>
+      </w:tr>
+    </w:tbl>
+    <w:sectPr/>
+  </w:body>
+</w:document>`;
+
+  const sourcePackage = readOpcPackage(writeDocxPackage({ documentXml }));
+  const documentPart = sourcePackage.parts.get("/word/document.xml");
+  assert.ok(documentPart, "Expected synthetic document part.");
+
+  const sourceDocumentXml = toText(documentPart.bytes);
+  const parsed = parseTablesFromDocumentXml(sourceDocumentXml);
+  assert.equal(parsed.tables.length, 1);
+  assert.match(parsed.tables[0]?.rows[0]?.cells[0]?.propertiesXml ?? "", /w:shd\b/);
+  assert.match(parsed.tables[0]?.rows[0]?.cells[0]?.blocksXml.join("") ?? "", /<w:jc w:val="center"\/>/);
+  assert.match(parsed.tables[0]?.rows[0]?.cells[0]?.blocksXml.join("") ?? "", /<w:b\/>/);
+  assert.match(parsed.tables[0]?.rows[0]?.cells[0]?.blocksXml.join("") ?? "", /<w:i\/>/);
+  assert.match(parsed.tables[0]?.rows[0]?.cells[1]?.blocksXml.join("") ?? "", /<w:u w:val="single"\/>/);
+
+  const rebuiltDocumentXml = roundtripDocumentTables(sourceDocumentXml, parsed.tables);
+  const exportedPackage = readOpcPackage(
+    createExportSession(sourcePackage, ["/word/document.xml"])
+      .withOwnedPart({
+        path: "/word/document.xml",
+        bytes: new TextEncoder().encode(rebuiltDocumentXml),
+        contentType: documentPart.contentType ?? DOCX_DOCUMENT_CONTENT_TYPE,
+        relationships: documentPart.relationships,
+      })
+      .serialize(),
+  );
+  const exportedDocumentXml = toText(
+    exportedPackage.parts.get("/word/document.xml")?.bytes,
+  );
+  const reparsed = parseTablesFromDocumentXml(exportedDocumentXml);
+  const roundtripStable =
+    JSON.stringify(toTableSignature(reparsed)) === JSON.stringify(toTableSignature(parsed));
+
+  assert.equal(roundtripStable, true);
+  assert.match(exportedDocumentXml, /<w:shd w:val="clear" w:color="auto" w:fill="D9EAF7"\/>/);
+  assert.match(exportedDocumentXml, /<w:jc w:val="center"\/>/);
+  assert.match(exportedDocumentXml, /<w:b\/>/);
+  assert.match(exportedDocumentXml, /<w:i\/>/);
+  assert.match(exportedDocumentXml, /<w:color w:val="1F4E79"\/>/);
+  assert.match(exportedDocumentXml, /<w:u w:val="single"\/>/);
+
+  proofReport.fixtures.push({
+    id: "synthetic-formatting",
+    source: "inline-package",
+    tableCount: reparsed.tables.length,
+    roundtripStable,
+    gridColumns: reparsed.tables.map((table) => table.gridColumns),
+    mergedCells: collectMergedCells(reparsed),
+    formattingMarkers: [
+      "<w:shd w:val=\"clear\" w:color=\"auto\" w:fill=\"D9EAF7\"/>",
+      "<w:jc w:val=\"center\"/>",
+      "<w:b/>",
+      "<w:i/>",
+      "<w:u w:val=\"single\"/>",
+    ],
+  });
+});
+
+test.after(() => {
+  mkdirSync(PROOF_DIR, { recursive: true });
+  writeFileSync(PROOF_PATH, `${JSON.stringify(proofReport, null, 2)}\n`, "utf8");
+});
+
+function roundtripDocumentTables(documentXml: string, tables: ParsedTable[]): string {
+  let nextXml = documentXml;
+  for (const table of tables) {
+    nextXml = nextXml.replace(table.rawXml, serializeTable(table));
+  }
+  return nextXml;
+}
+
+function collectMergedCells(document: ParsedTableDocument): Array<{
+  row: number;
+  cell: number;
+  gridSpan: number | null;
+  verticalMerge: "restart" | "continue" | null;
+}> {
+  return document.tables.flatMap((table) =>
+    table.rows.flatMap((row, rowIndex) =>
+      row.cells.flatMap((cell, cellIndex) => {
+        if (!cell.gridSpan && !cell.verticalMerge) {
+          return [];
+        }
+
+        return [
+          {
+            row: rowIndex,
+            cell: cellIndex,
+            gridSpan: cell.gridSpan ?? null,
+            verticalMerge: cell.verticalMerge ?? null,
+          },
+        ];
+      }),
+    ),
+  );
+}
+
+function toTableSignature(document: ParsedTableDocument) {
+  return {
+    tables: document.tables.map((table) => ({
+      type: table.type,
+      propertiesXml: table.propertiesXml ?? null,
+      gridColumns: table.gridColumns,
+      rows: table.rows.map((row) => ({
+        propertiesXml: row.propertiesXml ?? null,
+        cells: row.cells.map((cell) => ({
+          propertiesXml: cell.propertiesXml ?? null,
+          gridSpan: cell.gridSpan ?? null,
+          verticalMerge: cell.verticalMerge ?? null,
+          blocksXml: cell.blocksXml,
+        })),
+      })),
+    })),
+  };
+}
+
+function toText(bytes: Uint8Array | undefined): string {
+  return Buffer.from(bytes ?? new Uint8Array()).toString("utf8");
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/test/io/text-roundtrip.test.ts

@@ -0,0 +1,344 @@
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import test from "node:test";
+
+import { createExportSession } from "../../src/io/export/export-session.ts";
+import { serializeMainDocument } from "../../src/io/export/serialize-main-document.ts";
+import { normalizeParsedTextDocument } from "../../src/io/normalize/normalize-text.ts";
+import { parseMainDocumentXml } from "../../src/io/ooxml/parse-main-document.ts";
+import type { OpcPackage } from "../../src/io/opc/package-reader.ts";
+import { readOpcPackage } from "../../src/io/opc/package-reader.ts";
+import { writeDocxPackage } from "../../src/io/opc/docx-package.ts";
+import { writeOpcPackage } from "../../src/io/opc/package-writer.ts";
+
+const MAIN_DOCUMENT_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+
+test("text import, normalization, and export preserve the Wave 3 text baseline", () => {
+  const fixtures = [
+    {
+      id: "F01-like-text-whitespace",
+      xml: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:p>
+      <w:r><w:t xml:space="preserve">  Leading</w:t></w:r>
+      <w:r><w:rPr><w:b/></w:rPr><w:t> bold</w:t></w:r>
+      <w:r><w:tab/></w:r>
+      <w:r><w:br/></w:r>
+      <w:r><w:t xml:space="preserve">tail  </w:t></w:r>
+      <w:smartTag w:uri="urn:unsupported"><w:r><w:t>Locked</w:t></w:r></w:smartTag>
+    </w:p>
+    <w:sectPr/>
+  </w:body>
+</w:document>`,
+      relationships: [],
+      assertResult: (normalized: ReturnType<typeof normalizeParsedTextDocument>) => {
+        const paragraph = normalized.content.children[0];
+        assert.equal(paragraph?.type, "paragraph");
+        assert.deepEqual(paragraph?.children.slice(0, 5), [
+          { type: "text", text: "  Leading" },
+          { type: "text", text: " bold", marks: [{ type: "bold" }] },
+          { type: "tab" },
+          { type: "hard_break" },
+          { type: "text", text: "tail  " },
+        ]);
+        assert.equal(paragraph?.children[5]?.type, "opaque_inline");
+        assert.equal(Object.keys(normalized.preservation.opaqueFragments).length, 2);
+      },
+    },
+    {
+      id: "F02-F08-like-headings-and-hyperlinks",
+      xml: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:p>
+      <w:pPr><w:pStyle w:val="Heading2"/></w:pPr>
+      <w:r><w:t>Payment Terms</w:t></w:r>
+    </w:p>
+    <w:p>
+      <w:r><w:t xml:space="preserve">See </w:t></w:r>
+      <w:hyperlink r:id="rId5">
+        <w:r><w:rPr><w:i/></w:rPr><w:t>https://example.com/terms</w:t></w:r>
+      </w:hyperlink>
+      <w:r><w:t xml:space="preserve"> today</w:t></w:r>
+    </w:p>
+    <w:customXml><w:p><w:r><w:t>Preserve block</w:t></w:r></w:p></w:customXml>
+    <w:sectPr/>
+  </w:body>
+</w:document>`,
+      relationships: [
+        {
+          id: "rId5",
+          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+          target: "https://example.com/terms",
+          targetMode: "external" as const,
+        },
+      ],
+      assertResult: (normalized: ReturnType<typeof normalizeParsedTextDocument>) => {
+        const heading = normalized.content.children[0];
+        const paragraph = normalized.content.children[1];
+        const opaque = normalized.content.children[2];
+        const sectPr = normalized.content.children[3];
+
+        assert.equal(heading?.type, "paragraph");
+        assert.equal(heading?.styleId, "Heading2");
+        assert.equal(paragraph?.type, "paragraph");
+        assert.equal(paragraph?.children[1]?.type, "hyperlink");
+        assert.equal(paragraph?.children[1]?.href, "https://example.com/terms");
+        assert.equal(opaque?.type, "opaque_block");
+        assert.equal(sectPr?.type, "opaque_block");
+      },
+    },
+  ];
+
+  const report = {
+    generatedAt: "2026-03-26T00:00:00.000Z",
+    componentIds: ["docx-import-and-normalization", "docx-export-and-serialization"],
+    fixtures: [] as Array<{
+      id: string;
+      importedParagraphs: number;
+      opaqueFragmentCount: number;
+      exportedHyperlinks: number;
+      preservedXmlRoundtripped: boolean;
+    }>,
+  };
+
+  for (const fixture of fixtures) {
+    const parsed = parseMainDocumentXml(fixture.xml, fixture.relationships);
+    const normalized = normalizeParsedTextDocument(parsed);
+    fixture.assertResult(normalized);
+
+    const packageFixture = createFixturePackage(fixture.xml, fixture.relationships);
+    const sourcePackage = readOpcPackage(packageFixture);
+    const serialized = serializeMainDocument(
+      normalized.content,
+      normalized.preservation,
+      sourcePackage.parts.get("/word/document.xml")?.relationships ?? [],
+    );
+    const reparsed = normalizeParsedTextDocument(
+      parseMainDocumentXml(serialized.documentXml, serialized.relationships),
+    );
+
+    assert.deepEqual(reparsed.content, normalized.content);
+    assert.deepEqual(reparsed.preservation.opaqueFragments, normalized.preservation.opaqueFragments);
+
+    const exportedPackage = readOpcPackage(
+      createExportSession(sourcePackage, ["/word/document.xml"])
+        .withOwnedPart({
+          path: "/word/document.xml",
+          bytes: new TextEncoder().encode(serialized.documentXml),
+          contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+          relationships: serialized.relationships,
+        })
+        .serialize(),
+    );
+
+    const exportedDocumentXml = toText(exportedPackage.parts.get("/word/document.xml")?.bytes);
+    assert.ok(exportedDocumentXml?.includes("<w:document"));
+    assert.ok(
+      exportedPackage.parts
+        .get("/word/document.xml")
+        ?.relationships.some((relationship) => relationship.id === "rIdImage1"),
+      `${fixture.id}: expected image relationship to survive main document replacement`,
+    );
+    assert.ok(
+      (exportedPackage.parts
+        .get("/word/document.xml")
+        ?.relationships.some((relationship) => relationship.type.includes("hyperlink")) ??
+        false) || fixture.relationships.length === 0,
+      `${fixture.id}: expected hyperlink relationship presence=${fixture.relationships.length > 0} in ${JSON.stringify(
+        exportedPackage.parts.get("/word/document.xml")?.relationships ?? [],
+      )}`,
+    );
+
+    report.fixtures.push({
+      id: fixture.id,
+      importedParagraphs: normalized.content.children.filter((node) => node.type === "paragraph").length,
+      opaqueFragmentCount: Object.keys(normalized.preservation.opaqueFragments).length,
+      exportedHyperlinks: serialized.relationships.filter((relationship) =>
+        relationship.type.includes("hyperlink"),
+      ).length,
+      preservedXmlRoundtripped:
+        JSON.stringify(reparsed.preservation.opaqueFragments) ===
+        JSON.stringify(normalized.preservation.opaqueFragments),
+    });
+  }
+
+  mkdirSync(".tmp/wave-3-core-text", { recursive: true });
+  writeFileSync(
+    ".tmp/wave-3-core-text/text-roundtrip-report.json",
+    `${JSON.stringify(report, null, 2)}\n`,
+    "utf8",
+  );
+});
+
+test("F08 export preserves relationships referenced by opaque OOXML", () => {
+  const fixturePath = "test/fixtures/docx/F08-hyperlinks.docx";
+  const sourcePackage = readOpcPackage(new Uint8Array(readFileSync(fixturePath)));
+  const documentPart = sourcePackage.parts.get("/word/document.xml");
+  assert.ok(documentPart, "Expected /word/document.xml in the F08 package.");
+
+  const documentXml = toText(documentPart.bytes);
+  assert.ok(documentXml, "Expected F08 document XML.");
+
+  const normalized = normalizeParsedTextDocument(
+    parseMainDocumentXml(documentXml, documentPart.relationships),
+  );
+  const serialized = serializeMainDocument(
+    normalized.content,
+    normalized.preservation,
+    documentPart.relationships,
+  );
+  const exportedPackage = readOpcPackage(
+    createExportSession(sourcePackage, ["/word/document.xml"])
+      .withOwnedPart({
+        path: "/word/document.xml",
+        bytes: new TextEncoder().encode(serialized.documentXml),
+        contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+        relationships: serialized.relationships,
+      })
+      .serialize(),
+  );
+
+  const editedDocumentPart = exportedPackage.parts.get("/word/document.xml");
+  assert.ok(editedDocumentPart, "Expected edited /word/document.xml in the F08 package.");
+
+  const editedDocumentXml = toText(editedDocumentPart.bytes);
+  assert.ok(editedDocumentXml, "Expected edited F08 document XML.");
+
+  const referencedHyperlinkRelationshipIds = [
+    ...editedDocumentXml.matchAll(/\br:id=(["'])([^"']+)\1/g),
+  ].map((match) => match[2] ?? "");
+  const missingReferencedRelationships = referencedHyperlinkRelationshipIds.filter(
+    (relationshipId) =>
+      !editedDocumentPart.relationships.some(
+        (relationship) => relationship.id === relationshipId,
+      ),
+  );
+  const missingRelationshipTargets = documentPart.relationships.filter((relationship) =>
+    missingReferencedRelationships.includes(relationship.id),
+  );
+  const blockerSummary =
+    missingReferencedRelationships.length === 0
+      ? "Edited export preserved every relationship referenced from preserved OOXML."
+      : "Edited export still references relationships without matching part metadata.";
+
+  mkdirSync(".tmp/wave-3-core-text", { recursive: true });
+  writeFileSync(
+    ".tmp/wave-3-core-text/f08-relationship-audit.json",
+    `${JSON.stringify(
+      {
+        reportVersion: "wave-3-core-text-f08-relationship-audit/1",
+        generatedAt: new Date().toISOString(),
+        fixtureId: "F08",
+        sourcePath: fixturePath,
+        editedPath: ".tmp/wave-3-core-text/exports/F08-hyperlinks.edited.docx",
+        source: {
+          referencedHyperlinkRelationshipIds: extractReferencedRelationshipIds(documentXml),
+          relationships: documentPart.relationships,
+        },
+        edited: {
+          referencedHyperlinkRelationshipIds,
+          relationships: editedDocumentPart.relationships,
+        },
+        missingReferencedRelationships,
+        missingRelationshipTargets,
+        blockerSummary,
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  assert.ok(
+    referencedHyperlinkRelationshipIds.includes("rIdLink2"),
+    "Expected F08 edited export to retain the preserved table hyperlink reference.",
+  );
+  assert.deepEqual(
+    missingReferencedRelationships,
+    [],
+    `Edited export is missing relationships for ${JSON.stringify(missingReferencedRelationships)}`,
+  );
+});
+
+function toText(bytes: Uint8Array | undefined): string | undefined {
+  return bytes ? Buffer.from(bytes).toString("utf8") : undefined;
+}
+
+function extractReferencedRelationshipIds(xml: string): string[] {
+  return [...xml.matchAll(/\br:id=(["'])([^"']+)\1/g)]
+    .map((match) => match[2] ?? "")
+    .filter((relationshipId) => relationshipId.length > 0);
+}
+
+function createFixturePackage(documentXml: string, relationships: Array<{
+  id: string;
+  type: string;
+  target: string;
+  targetMode: "internal" | "external";
+}>): Uint8Array {
+  const imageRelationship = {
+    id: "rIdImage1",
+    type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+    target: "media/image1.png",
+    targetMode: "internal" as const,
+  };
+
+  const documentPackage = readOpcPackage(writeDocxPackage({ documentXml }));
+  const documentPart = documentPackage.parts.get("/word/document.xml");
+  if (!documentPart) {
+    throw new Error("Expected document part in fixture package.");
+  }
+
+  const nextPackage: OpcPackage = {
+    manifest: {
+      ...documentPackage.manifest,
+      contentTypes: {
+        defaults: {
+          ...documentPackage.manifest.contentTypes.defaults,
+          png: "image/png",
+        },
+        overrides: {
+          ...documentPackage.manifest.contentTypes.overrides,
+        },
+      },
+      parts: [
+        ...documentPackage.manifest.parts.map((part) =>
+          part.path === "/word/document.xml"
+            ? { ...part, relationships: [...relationships, imageRelationship] }
+            : part,
+        ),
+        {
+          path: "/word/media/image1.png",
+          surfaceKind: "content",
+          contentType: "image/png",
+          relationshipsPartPath: "/word/media/_rels/image1.png.rels",
+          relationships: [],
+          compression: "store",
+          byteLength: 4,
+        },
+      ],
+    },
+    parts: new Map(documentPackage.parts),
+    sourceByteLength: documentPackage.sourceByteLength,
+  };
+
+  nextPackage.parts.set("/word/document.xml", {
+    ...documentPart,
+    relationships: [...relationships, imageRelationship],
+  });
+  nextPackage.parts.set("/word/media/image1.png", {
+    path: "/word/media/image1.png",
+    surfaceKind: "content",
+    contentType: "image/png",
+    relationshipsPartPath: "/word/media/_rels/image1.png.rels",
+    relationships: [],
+    compression: "store",
+    bytes: new Uint8Array([137, 80, 78, 71]),
+    crc32: 0,
+  });
+
+  return writeOpcPackage(nextPackage);
+}