@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/io/export/serialize-main-document.ts

@@ -0,0 +1,1342 @@
+import type {
+  AltChunkNode,
+  BorderSpec,
+  CustomXmlNode,
+  DocumentRootNode,
+  InlineNode,
+  MediaCatalog,
+  ParagraphNode,
+  PreservationStore,
+  SdtNode,
+  SectionProperties,
+  TableNode,
+  TableCellNode,
+  TextMark,
+} from "../../model/canonical-document.ts";
+import type { OpcRelationship } from "../ooxml/part-manifest.ts";
+import type { RevisionParagraphBoundary } from "../ooxml/revision-boundaries.ts";
+import { getOpaqueFragment } from "../../preservation/store.ts";
+import { retainRelationshipsForFragment } from "../../preservation/relationship-retention.ts";
+import { serializeParagraphNumberingProperties } from "./serialize-numbering.ts";
+import {
+  serializeTableCellPropertiesXml,
+  serializeTablePropertiesXml,
+  serializeTableRowPropertiesXml,
+} from "./table-properties-xml.ts";
+
+const HYPERLINK_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+
+export interface SerializedMainDocument {
+  documentXml: string;
+  relationships: OpcRelationship[];
+  paragraphBoundaries: RevisionParagraphBoundary[];
+}
+
+export interface SerializeMainDocumentOptions {
+  documentAttributes?: Record<string, string>;
+  media?: MediaCatalog;
+  finalSectionProperties?: SectionProperties;
+}
+
+interface SerializationState {
+  nextHyperlinkRelationshipIndex: number;
+  relationships: OpcRelationship[];
+  existingRelationshipMap: Map<string, OpcRelationship>;
+  retainedRelationshipIds: Set<string>;
+  media: MediaCatalog;
+  preservation: PreservationStore;
+}
+
+interface InlineSerializationResult {
+  xml: string;
+  cursor: number;
+  boundaries: Map<number, number>;
+}
+
+interface ParagraphSerializationResult {
+  xml: string;
+  nextCursor: number;
+  boundary: RevisionParagraphBoundary;
+}
+
+export function serializeMainDocument(
+  content: DocumentRootNode,
+  preservation: PreservationStore = { opaqueFragments: {}, packageParts: {} },
+  existingRelationships: readonly OpcRelationship[] = [],
+  options: SerializeMainDocumentOptions = {},
+): SerializedMainDocument {
+  const nextRelationshipIndex =
+    existingRelationships.reduce((maxIndex, relationship) => {
+      const match = /^rIdHyperlink(\d+)$/.exec(relationship.id);
+      return match ? Math.max(maxIndex, Number.parseInt(match[1] ?? "0", 10)) : maxIndex;
+    }, 0) + 1;
+  const state: SerializationState = {
+    nextHyperlinkRelationshipIndex: nextRelationshipIndex,
+    relationships: existingRelationships.filter(
+      (relationship) => relationship.type !== HYPERLINK_RELATIONSHIP_TYPE,
+    ).map(cloneRelationship),
+    existingRelationshipMap: new Map(
+      existingRelationships.map((relationship) => [relationship.id, cloneRelationship(relationship)]),
+    ),
+    retainedRelationshipIds: new Set(
+      existingRelationships
+        .filter((relationship) => relationship.type !== HYPERLINK_RELATIONSHIP_TYPE)
+        .map((relationship) => relationship.id),
+    ),
+    media: options.media ?? { items: {} },
+    preservation,
+  };
+  const documentOpen = `<w:document${serializeDocumentAttributes(options.documentAttributes, content)}>`;
+  const prefix = [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    documentOpen,
+    `  <w:body>`,
+  ].join("\n");
+  const suffix = `</w:body>\n</w:document>`;
+  const bodyPieces: string[] = [];
+  const paragraphBoundaries: RevisionParagraphBoundary[] = [];
+  let bodyLength = 0;
+  let sectionPropertiesXml = options.finalSectionProperties
+    ? serializeSectionPropertiesXml(options.finalSectionProperties)
+    : "<w:sectPr/>";
+  let cursor = 0;
+  let paragraphIndex = -1;
+  let previousWasParagraph = false;
+
+  for (const block of content.children) {
+    if (block.type === "paragraph") {
+      if (previousWasParagraph) {
+        cursor += 1;
+      }
+
+      paragraphIndex += 1;
+      const serializedParagraph = serializeParagraph(
+        block,
+        state,
+        cursor,
+        paragraphIndex,
+      );
+      const paragraphOffset = prefix.length + bodyLength;
+      bodyPieces.push(serializedParagraph.xml);
+      bodyLength += serializedParagraph.xml.length;
+      paragraphBoundaries.push(
+        offsetParagraphBoundary(serializedParagraph.boundary, paragraphOffset),
+      );
+      cursor = serializedParagraph.nextCursor;
+      previousWasParagraph = true;
+      continue;
+    }
+
+    if (block.type === "table") {
+      const tableXml = serializeTableNode(block, state);
+      bodyPieces.push(tableXml);
+      bodyLength += tableXml.length;
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+
+    if (block.type === "sdt") {
+      const sdtXml = serializeSdtNode(block, state);
+      bodyPieces.push(sdtXml);
+      bodyLength += sdtXml.length;
+      previousWasParagraph = false;
+      continue;
+    }
+
+    if (block.type === "custom_xml") {
+      const customXml = serializeCustomXmlNode(block, state);
+      bodyPieces.push(customXml);
+      bodyLength += customXml.length;
+      previousWasParagraph = false;
+      continue;
+    }
+
+    if (block.type === "alt_chunk") {
+      const altChunkXml = serializeAltChunkNode(block);
+      bodyPieces.push(altChunkXml);
+      bodyLength += altChunkXml.length;
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+
+    if (block.type === "section_break") {
+      // Inline section breaks must be emitted as a paragraph with <w:sectPr>
+      // in its <w:pPr> element (OOXML compliance). The body-level <w:sectPr>
+      // is reserved for the final section only.
+      let inlineSectPr: string;
+      if (block.sectionPropertiesXml ?? block.propertiesXml) {
+        inlineSectPr = block.sectionPropertiesXml ?? block.propertiesXml!;
+      } else if (block.sectionProperties) {
+        inlineSectPr = serializeSectionPropertiesXml(block.sectionProperties);
+      } else {
+        inlineSectPr = "<w:sectPr/>";
+      }
+      const sectionParagraphXml = `<w:p><w:pPr>${inlineSectPr}</w:pPr></w:p>`;
+      bodyPieces.push(sectionParagraphXml);
+      bodyLength += sectionParagraphXml.length;
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+
+    const blockXml = serializeOpaqueBlock(block, state);
+    if (looksLikeSectionPropertiesXml(blockXml)) {
+      sectionPropertiesXml = blockXml;
+    } else {
+      bodyPieces.push(blockXml);
+      bodyLength += blockXml.length;
+    }
+    cursor += 1;
+    previousWasParagraph = false;
+  }
+
+  const bodyXml = bodyPieces.join("");
+  const documentXml = `${prefix}${bodyXml || "<w:p><w:r><w:t></w:t></w:r></w:p>"}${sectionPropertiesXml}${suffix}`;
+
+  return {
+    documentXml,
+    relationships: state.relationships,
+    paragraphBoundaries,
+  };
+}
+
+function serializeOpaqueBlock(
+  block: Extract<DocumentRootNode["children"][number], { type: "opaque_block" }>,
+  state: SerializationState,
+): string {
+  return lookupOpaqueXml(block.fragmentId, state);
+}
+
+function serializeTableNode(
+  table: TableNode,
+  state: SerializationState,
+): string {
+  const propertiesXml = buildTablePropertiesXml(table);
+  const gridXml =
+    table.gridColumns.length > 0
+      ? `<w:tblGrid>${table.gridColumns
+          .map((width) => `<w:gridCol w:w="${width}"/>`)
+          .join("")}</w:tblGrid>`
+      : "";
+  const rowsXml = table.rows
+    .map((row) => {
+      const rowPropertiesXml = buildTableRowPropertiesXml(row);
+      const cellsXml = row.cells
+        .map((cell) => serializeTableCellNode(cell, state))
+        .join("");
+      return `<w:tr>${rowPropertiesXml}${cellsXml}</w:tr>`;
+    })
+    .join("");
+  return `<w:tbl>${propertiesXml}${gridXml}${rowsXml}</w:tbl>`;
+}
+
+function serializeTableCellNode(
+  cell: TableCellNode,
+  state: SerializationState,
+): string {
+  const propertiesXml = buildCellPropertiesXml(cell);
+  const blocksXml = cell.children
+    .map((child) => serializeBlockNode(child, state))
+    .join("");
+  return `<w:tc>${propertiesXml}${blocksXml || "<w:p/>"}</w:tc>`;
+}
+
+function serializeBlockNode(
+  block: DocumentRootNode["children"][number],
+  state: SerializationState,
+): string {
+  switch (block.type) {
+    case "paragraph":
+      return serializeTableCellParagraph(block, state);
+    case "table":
+      return serializeTableNode(block, state);
+    case "sdt":
+      return serializeSdtNode(block, state);
+    case "custom_xml":
+      return serializeCustomXmlNode(block, state);
+    case "alt_chunk":
+      return serializeAltChunkNode(block);
+    case "opaque_block":
+      return lookupOpaqueXml(block.fragmentId, state);
+    case "section_break":
+      return serializeNestedSectionBreak(block);
+  }
+}
+
+function serializeNestedSectionBreak(
+  block: Extract<DocumentRootNode["children"][number], { type: "section_break" }>,
+): string {
+  const sectionPropertiesXml =
+    block.sectionPropertiesXml ??
+    block.propertiesXml ??
+    (block.sectionProperties ? serializeSectionPropertiesXml(block.sectionProperties) : "<w:sectPr/>");
+  return `<w:p><w:pPr>${sectionPropertiesXml}</w:pPr></w:p>`;
+}
+
+function buildCellPropertiesXml(cell: TableCellNode): string {
+  return serializeTableCellPropertiesXml(cell);
+}
+
+function buildTableRowPropertiesXml(row: TableNode["rows"][number]): string {
+  return serializeTableRowPropertiesXml(row);
+}
+
+function serializeSdtNode(
+  block: SdtNode,
+  state: SerializationState,
+): string {
+  const propertiesXml = block.properties.propertiesXml ?? buildSdtPropertiesXml(block);
+  const childrenXml = block.children.map((child) => serializeBlockNode(child, state)).join("") || "<w:p/>";
+  return `<w:sdt>${propertiesXml}<w:sdtContent>${childrenXml}</w:sdtContent></w:sdt>`;
+}
+
+function serializeCustomXmlNode(
+  block: CustomXmlNode,
+  state: SerializationState,
+): string {
+  if (block.rawXml) {
+    return block.rawXml;
+  }
+  const attrs: string[] = [];
+  if (block.uri) {
+    attrs.push(`w:uri="${escapeAttribute(block.uri)}"`);
+  }
+  if (block.element) {
+    attrs.push(`w:element="${escapeAttribute(block.element)}"`);
+  }
+  const attrXml = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  const childrenXml = block.children.map((child) => serializeBlockNode(child, state)).join("");
+  return `<w:customXml${attrXml}>${childrenXml || "<w:p/>"}</w:customXml>`;
+}
+
+function serializeAltChunkNode(
+  block: AltChunkNode,
+): string {
+  return `<w:altChunk r:id="${escapeAttribute(block.relationshipId)}"/>`;
+}
+
+function buildSdtPropertiesXml(block: SdtNode): string {
+  const children: string[] = [];
+  if (block.properties.alias) {
+    children.push(`<w:alias w:val="${escapeAttribute(block.properties.alias)}"/>`);
+  }
+  if (block.properties.tag) {
+    children.push(`<w:tag w:val="${escapeAttribute(block.properties.tag)}"/>`);
+  }
+  if (block.properties.lock) {
+    children.push(`<w:lock w:val="${escapeAttribute(block.properties.lock)}"/>`);
+  }
+  if (block.properties.showingPlcHdr) {
+    children.push(`<w:showingPlcHdr/>`);
+  }
+  if (block.properties.checkbox) {
+    const cb = block.properties.checkbox;
+    const cbParts: string[] = [];
+    cbParts.push(`<w14:checked w14:val="${cb.checked ? "1" : "0"}"/>`);
+    if (cb.checkedChar) cbParts.push(`<w14:checkedState w14:val="${escapeAttribute(cb.checkedChar)}"/>`);
+    if (cb.uncheckedChar) cbParts.push(`<w14:uncheckedState w14:val="${escapeAttribute(cb.uncheckedChar)}"/>`);
+    children.push(`<w14:checkbox>${cbParts.join("")}</w14:checkbox>`);
+  } else if (block.properties.datePicker) {
+    const dp = block.properties.datePicker;
+    const dateAttrs = dp.fullDate ? ` w:fullDate="${escapeAttribute(dp.fullDate)}"` : "";
+    const dpParts: string[] = [];
+    if (dp.dateFormat) dpParts.push(`<w:dateFormat w:val="${escapeAttribute(dp.dateFormat)}"/>`);
+    if (dp.lid) dpParts.push(`<w:lid w:val="${escapeAttribute(dp.lid)}"/>`);
+    children.push(dpParts.length > 0 ? `<w:date${dateAttrs}>${dpParts.join("")}</w:date>` : `<w:date${dateAttrs}/>`);
+  } else if (block.properties.dropdownList) {
+    const items = block.properties.dropdownList.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:dropDownList>${items}</w:dropDownList>`);
+  } else if (block.properties.comboBox) {
+    const items = block.properties.comboBox.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:comboBox>${items}</w:comboBox>`);
+  } else if (block.properties.sdtType === "plainText") {
+    children.push(`<w:text/>`);
+  } else if (block.properties.sdtType === "richText") {
+    children.push(`<w:richText/>`);
+  } else if (block.properties.sdtType) {
+    children.push(`<w:${block.properties.sdtType}/>`);
+  }
+  return children.length > 0 ? `<w:sdtPr>${children.join("")}</w:sdtPr>` : "<w:sdtPr/>";
+}
+
+function serializeTableCellParagraph(
+  paragraph: ParagraphNode,
+  state: SerializationState,
+): string {
+  let xml = "<w:p>";
+  const paragraphPropertiesXml = buildParagraphPropertiesXml(paragraph);
+  if (paragraphPropertiesXml.length > 0) {
+    xml += paragraphPropertiesXml;
+  }
+  const childrenXml = paragraph.children.map((child) => serializeTableInlineNode(child, state)).join("");
+  xml += childrenXml || "<w:r><w:t></w:t></w:r>";
+  xml += "</w:p>";
+  return xml;
+}
+
+function serializeTableInlineNode(
+  node: InlineNode,
+  state: SerializationState,
+): string {
+  switch (node.type) {
+    case "text": {
+      const marks = node.marks;
+      const properties = serializeRunPropertiesFromMarks(marks);
+      const preserve = requiresPreservedSpace(node.text) ? ` xml:space="preserve"` : "";
+      return `<w:r>${properties}<w:t${preserve}>${escapeXml(node.text)}</w:t></w:r>`;
+    }
+    case "tab":
+      return "<w:r><w:tab/></w:r>";
+    case "column_break":
+      return "<w:r><w:br w:type=\"column\"/></w:r>";
+    case "hard_break":
+      return "<w:r><w:br/></w:r>";
+    case "symbol": {
+      const properties = serializeRunPropertiesFromMarks(node.marks);
+      const fontAttribute = node.font ? ` w:font="${escapeAttribute(node.font)}"` : "";
+      return `<w:r>${properties}<w:sym${fontAttribute} w:char="${escapeAttribute(node.char)}"/></w:r>`;
+    }
+    case "image":
+      return serializeImageNode(node, state);
+    case "opaque_inline":
+      return lookupOpaqueXml(node.fragmentId, state);
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+      return wrapInlineRawXml(node.rawXml);
+    case "hyperlink": {
+      const hyperlinkOpen = node.href.startsWith("#")
+        ? `<w:hyperlink w:anchor="${escapeAttribute(node.href.slice(1))}">`
+        : (() => {
+            const relationshipId = `rIdHyperlink${state.nextHyperlinkRelationshipIndex}`;
+            state.nextHyperlinkRelationshipIndex += 1;
+            state.relationships.push({
+              id: relationshipId,
+              type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+              target: node.href,
+              targetMode: "external",
+            });
+            state.retainedRelationshipIds.add(relationshipId);
+            return `<w:hyperlink r:id="${relationshipId}">`;
+          })();
+      const childrenXml = node.children.map((child) => serializeTableInlineNode(child, state)).join("");
+      return `${hyperlinkOpen}${childrenXml}</w:hyperlink>`;
+    }
+    case "field": {
+      if (node.children && node.children.length > 0) {
+        const childrenXml = node.children
+          .map((child) => serializeTableInlineNode(child, state))
+          .join("");
+        if (node.fieldType === "complex") {
+          return (
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve"> ${escapeXml(node.instruction)} </w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+            childrenXml +
+            `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+          );
+        }
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">${childrenXml}</w:fldSimple>`;
+      }
+      return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
+    }
+    case "bookmark_start":
+      return (
+        `<w:bookmarkStart w:id="${escapeAttribute(node.bookmarkId)}"` +
+        ` w:name="${escapeAttribute(node.name)}"/>`
+      );
+    case "bookmark_end":
+      return `<w:bookmarkEnd w:id="${escapeAttribute(node.bookmarkId)}"/>`;
+    case "footnote_ref": {
+      const refElement =
+        node.noteKind === "footnote"
+          ? `<w:footnoteReference w:id="${escapeAttribute(node.noteId)}"/>`
+          : `<w:endnoteReference w:id="${escapeAttribute(node.noteId)}"/>`;
+      const styleVal =
+        node.noteKind === "footnote"
+          ? "FootnoteReference"
+          : "EndnoteReference";
+      return `<w:r><w:rPr><w:rStyle w:val="${styleVal}"/></w:rPr>${refElement}</w:r>`;
+    }
+    default:
+      return "";
+  }
+}
+
+function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
+  const children: string[] = [];
+
+  if (paragraph.styleId) {
+    children.push(`<w:pStyle w:val="${escapeAttribute(paragraph.styleId)}"/>`);
+  }
+  if (paragraph.keepNext) {
+    children.push("<w:keepNext/>");
+  }
+  if (paragraph.keepLines) {
+    children.push("<w:keepLines/>");
+  }
+  if (paragraph.pageBreakBefore) {
+    children.push("<w:pageBreakBefore/>");
+  }
+  if (paragraph.widowControl) {
+    children.push("<w:widowControl/>");
+  }
+  if (paragraph.outlineLevel !== undefined) {
+    children.push(`<w:outlineLvl w:val="${paragraph.outlineLevel}"/>`);
+  }
+  if (paragraph.numbering) {
+    children.push(serializeParagraphNumberingProperties(paragraph.numbering));
+  }
+  if (paragraph.spacing) {
+    const s = paragraph.spacing;
+    const attrs: string[] = [];
+    if (s.before !== undefined) attrs.push(`w:before="${s.before}"`);
+    if (s.after !== undefined) attrs.push(`w:after="${s.after}"`);
+    if (s.line !== undefined) attrs.push(`w:line="${s.line}"`);
+    if (s.lineRule !== undefined) attrs.push(`w:lineRule="${s.lineRule}"`);
+    if (attrs.length > 0) children.push(`<w:spacing ${attrs.join(" ")}/>`);
+  }
+  if (paragraph.contextualSpacing !== undefined) {
+    children.push(
+      paragraph.contextualSpacing
+        ? "<w:contextualSpacing/>"
+        : `<w:contextualSpacing w:val="0"/>`,
+    );
+  }
+  if (paragraph.indentation) {
+    const ind = paragraph.indentation;
+    const attrs: string[] = [];
+    if (ind.left !== undefined) attrs.push(`w:left="${ind.left}"`);
+    if (ind.right !== undefined) attrs.push(`w:right="${ind.right}"`);
+    if (ind.firstLine !== undefined) attrs.push(`w:firstLine="${ind.firstLine}"`);
+    if (ind.hanging !== undefined) attrs.push(`w:hanging="${ind.hanging}"`);
+    if (attrs.length > 0) children.push(`<w:ind ${attrs.join(" ")}/>`);
+  }
+  if (paragraph.alignment) {
+    children.push(`<w:jc w:val="${paragraph.alignment}"/>`);
+  }
+  if (paragraph.borders) {
+    const bordersXml = serializeParagraphBorders(paragraph.borders);
+    if (bordersXml) {
+      children.push(bordersXml);
+    }
+  }
+  if (paragraph.shading) {
+    const shadingXml = serializeParagraphShading(paragraph.shading);
+    if (shadingXml) {
+      children.push(shadingXml);
+    }
+  }
+  if (paragraph.bidi) {
+    children.push("<w:bidi/>");
+  }
+  if (paragraph.suppressLineNumbers) {
+    children.push("<w:suppressLineNumbers/>");
+  }
+  if (paragraph.cnfStyle) {
+    children.push(`<w:cnfStyle w:val="${escapeAttribute(paragraph.cnfStyle)}"/>`);
+  }
+  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
+    const tabsXml = paragraph.tabStops.map((tab) => {
+      const leaderAttr = tab.leader ? ` w:leader="${tab.leader}"` : "";
+      return `<w:tab w:val="${tab.align}" w:pos="${tab.position}"${leaderAttr}/>`;
+    }).join("");
+    children.push(`<w:tabs>${tabsXml}</w:tabs>`);
+  }
+
+  if (children.length === 0) return "";
+  return `<w:pPr>${children.join("")}</w:pPr>`;
+}
+
+function buildTablePropertiesXml(table: TableNode): string {
+  return serializeTablePropertiesXml(table);
+}
+
+function serializeParagraphBorders(borders: ParagraphNode["borders"]): string {
+  if (!borders) {
+    return "";
+  }
+  const parts: string[] = [];
+  for (const [name, border] of [
+    ["top", borders.top],
+    ["left", borders.left],
+    ["bottom", borders.bottom],
+    ["right", borders.right],
+    ["bar", borders.bar],
+    ["between", borders.between],
+  ] as const) {
+    const xml = serializeBorder(name, border);
+    if (xml) {
+      parts.push(xml);
+    }
+  }
+  return parts.length > 0 ? `<w:pBdr>${parts.join("")}</w:pBdr>` : "";
+}
+
+function serializeBorder(name: string, border: BorderSpec | undefined): string {
+  if (!border) {
+    return "";
+  }
+  const attrs: string[] = [];
+  if (border.value) attrs.push(`w:val="${escapeAttribute(border.value)}"`);
+  if (border.size !== undefined) attrs.push(`w:sz="${border.size}"`);
+  if (border.space !== undefined) attrs.push(`w:space="${border.space}"`);
+  if (border.color) attrs.push(`w:color="${escapeAttribute(border.color)}"`);
+  return attrs.length > 0 ? `<w:${name} ${attrs.join(" ")}/>` : "";
+}
+
+function serializeParagraphShading(shading: ParagraphNode["shading"]): string {
+  if (!shading) {
+    return "";
+  }
+  const attrs: string[] = [];
+  if (shading.val) attrs.push(`w:val="${escapeAttribute(shading.val)}"`);
+  if (shading.color) attrs.push(`w:color="${escapeAttribute(shading.color)}"`);
+  if (shading.fill) attrs.push(`w:fill="${escapeAttribute(shading.fill)}"`);
+  return attrs.length > 0 ? `<w:shd ${attrs.join(" ")}/>` : "";
+}
+
+function serializeRunPropertiesFromMarks(marks: TextMark[] | undefined): string {
+  return serializeRunProperties(marks);
+}
+
+function serializeParagraph(
+  paragraph: ParagraphNode,
+  state: SerializationState,
+  cursor: number,
+  paragraphIndex: number,
+): ParagraphSerializationResult {
+  let xml = "<w:p>";
+  const boundaries = new Map<number, number>();
+  const paragraphStart = 0;
+  const paragraphStartTagEnd = xml.length;
+  boundaries.set(cursor, paragraphStartTagEnd);
+
+  let paragraphPropertiesStart: number | undefined;
+  let paragraphPropertiesEnd: number | undefined;
+
+  const paragraphPropertiesXml = buildParagraphPropertiesXml(paragraph);
+  if (paragraphPropertiesXml.length > 0) {
+    paragraphPropertiesStart = xml.length;
+    xml += paragraphPropertiesXml;
+    paragraphPropertiesEnd = xml.length;
+  }
+
+  const children = serializeParagraphChildren(paragraph.children, state, cursor, xml.length);
+  xml += children.xml;
+  const contentEmpty = children.xml.length === 0;
+  if (contentEmpty) {
+    xml += "<w:r><w:t></w:t></w:r>";
+  }
+  const paragraphEndTagStart = xml.length;
+  xml += "</w:p>";
+
+  if (!children.boundaries.has(children.cursor)) {
+    children.boundaries.set(children.cursor, paragraphEndTagStart);
+  }
+
+  return {
+    xml,
+    nextCursor: children.cursor,
+    boundary: {
+      paragraphIndex,
+      start: cursor,
+      end: children.cursor,
+      boundaries: children.boundaries,
+      paragraphStart,
+      paragraphStartTagEnd,
+      paragraphEndTagStart,
+      paragraphEnd: xml.length,
+      ...(paragraphPropertiesStart !== undefined
+        ? { paragraphPropertiesStart }
+        : {}),
+      ...(paragraphPropertiesEnd !== undefined ? { paragraphPropertiesEnd } : {}),
+    },
+  };
+}
+
+function serializeParagraphChildren(
+  children: InlineNode[],
+  state: SerializationState,
+  cursor: number,
+  xmlOffset: number,
+): InlineSerializationResult {
+  const pieces: string[] = [];
+  const boundaries = new Map<number, number>();
+  let nextCursor = cursor;
+  let nextOffset = xmlOffset;
+  boundaries.set(nextCursor, nextOffset);
+
+  for (const child of children) {
+    const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+    pieces.push(result.xml);
+    for (const [position, index] of result.boundaries) {
+      boundaries.set(position, index);
+    }
+    nextCursor = result.cursor;
+    nextOffset += result.xml.length;
+  }
+
+  return {
+    xml: pieces.join(""),
+    cursor: nextCursor,
+    boundaries,
+  };
+}
+
+type RunPiece =
+  | { kind: "text"; text: string; marks?: TextMark[] }
+  | { kind: "tab" }
+  | { kind: "hard_break" };
+
+function serializeRunPiece(piece: RunPiece): string {
+  switch (piece.kind) {
+    case "text":
+      return serializeText(piece.text);
+    case "tab":
+      return "<w:tab/>";
+    case "hard_break":
+      return "<w:br/>";
+  }
+}
+
+function serializeText(text: string): string {
+  const preserve = requiresPreservedSpace(text) ? ` xml:space="preserve"` : "";
+  return `<w:t${preserve}>${escapeXml(text)}</w:t>`;
+}
+
+function serializeInlineNode(
+  node: InlineNode,
+  state: SerializationState,
+  cursor: number,
+  xmlOffset: number,
+): InlineSerializationResult {
+  switch (node.type) {
+    case "text": {
+      const xml = serializeRun({
+        kind: "text",
+        text: node.text,
+        ...(node.marks && node.marks.length > 0 ? { marks: node.marks } : {}),
+      });
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + Array.from(node.text).length, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + Array.from(node.text).length,
+        boundaries,
+      };
+    }
+    case "tab": {
+      const xml = serializeRun({ kind: "tab" });
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "column_break": {
+      const xml = `<w:r><w:br w:type="column"/></w:r>`;
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "hard_break": {
+      const xml = serializeRun({ kind: "hard_break" });
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "symbol": {
+      const xml = serializeTableInlineNode(node, state);
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "image": {
+      const xml = serializeImageNode(node, state);
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "opaque_inline": {
+      const xml = lookupOpaqueXml(node.fragmentId, state);
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape": {
+      // Reattach original XML unchanged for lossless round-trip.
+      const xml = wrapInlineRawXml(node.rawXml);
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "hyperlink": {
+      const hyperlinkOpen = node.href.startsWith("#")
+        ? `<w:hyperlink w:anchor="${escapeAttribute(node.href.slice(1))}">`
+        : (() => {
+            const relationshipId = `rIdHyperlink${state.nextHyperlinkRelationshipIndex}`;
+            state.nextHyperlinkRelationshipIndex += 1;
+            state.relationships.push({
+              id: relationshipId,
+              type: HYPERLINK_RELATIONSHIP_TYPE,
+              target: node.href,
+              targetMode: "external",
+            });
+            state.retainedRelationshipIds.add(relationshipId);
+            return `<w:hyperlink r:id="${relationshipId}">`;
+          })();
+      const hyperlinkClose = "</w:hyperlink>";
+      const boundaries = new Map<number, number>();
+      let nextCursor = cursor;
+      let nextOffset = xmlOffset + hyperlinkOpen.length;
+      boundaries.set(cursor, nextOffset);
+      const children: string[] = [];
+
+      for (const child of node.children) {
+        const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+        children.push(result.xml);
+        for (const [position, index] of result.boundaries) {
+          boundaries.set(position, index);
+        }
+        nextCursor = result.cursor;
+        nextOffset += result.xml.length;
+      }
+
+      boundaries.set(nextCursor, nextOffset);
+      return {
+        xml: `${hyperlinkOpen}${children.join("")}${hyperlinkClose}`,
+        cursor: nextCursor,
+        boundaries,
+      };
+    }
+    case "field": {
+      if (node.children && node.children.length > 0) {
+        const boundaries = new Map<number, number>();
+        boundaries.set(cursor, xmlOffset);
+        let nextCursor = cursor;
+        let nextOffset = xmlOffset;
+
+        if (node.fieldType === "complex") {
+          const beginXml =
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve"> ${escapeXml(node.instruction)} </w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>`;
+          nextOffset += beginXml.length;
+
+          const children: string[] = [beginXml];
+          for (const child of node.children) {
+            const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+            children.push(result.xml);
+            for (const [position, index] of result.boundaries) {
+              boundaries.set(position, index);
+            }
+            nextCursor = result.cursor;
+            nextOffset += result.xml.length;
+          }
+          const endXml = `<w:r><w:fldChar w:fldCharType="end"/></w:r>`;
+          children.push(endXml);
+          nextOffset += endXml.length;
+          boundaries.set(nextCursor, nextOffset);
+          return { xml: children.join(""), cursor: nextCursor, boundaries };
+        }
+
+        // Simple field with children
+        const openXml = `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">`;
+        nextOffset += openXml.length;
+        const children: string[] = [openXml];
+        for (const child of node.children) {
+          const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+          children.push(result.xml);
+          for (const [position, index] of result.boundaries) {
+            boundaries.set(position, index);
+          }
+          nextCursor = result.cursor;
+          nextOffset += result.xml.length;
+        }
+        children.push("</w:fldSimple>");
+        nextOffset += "</w:fldSimple>".length;
+        boundaries.set(nextCursor, nextOffset);
+        return { xml: children.join(""), cursor: nextCursor, boundaries };
+      }
+
+      const xml = `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    case "bookmark_start": {
+      const xml =
+        `<w:bookmarkStart w:id="${escapeAttribute(node.bookmarkId)}"` +
+        ` w:name="${escapeAttribute(node.name)}"/>`;
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor, xmlOffset + xml.length);
+      return { xml, cursor, boundaries };
+    }
+    case "bookmark_end": {
+      const xml = `<w:bookmarkEnd w:id="${escapeAttribute(node.bookmarkId)}"/>`;
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor, xmlOffset + xml.length);
+      return { xml, cursor, boundaries };
+    }
+    case "footnote_ref": {
+      const refElement =
+        node.noteKind === "footnote"
+          ? `<w:footnoteReference w:id="${escapeAttribute(node.noteId)}"/>`
+          : `<w:endnoteReference w:id="${escapeAttribute(node.noteId)}"/>`;
+      const styleVal =
+        node.noteKind === "footnote"
+          ? "FootnoteReference"
+          : "EndnoteReference";
+      const xml = `<w:r><w:rPr><w:rStyle w:val="${styleVal}"/></w:rPr>${refElement}</w:r>`;
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
+    default: {
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      return { xml: "", cursor, boundaries };
+    }
+  }
+}
+
+function serializeImageNode(
+  node: Extract<InlineNode, { type: "image" }>,
+  state: SerializationState,
+): string {
+  const placementXml = typeof node.placementXml === "string" ? node.placementXml.trim() : "";
+  if (placementXml.length > 0) {
+    return placementXml.startsWith("<w:r") ? placementXml : `<w:r>${placementXml}</w:r>`;
+  }
+
+  const mediaItem = state.media.items[node.mediaId];
+  if (mediaItem?.relationshipId && state.existingRelationshipMap.has(mediaItem.relationshipId)) {
+    const altText = node.altText ?? mediaItem.altText ?? mediaItem.filename;
+    return `<w:r><w:drawing><wp:inline 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"><wp:extent cx="9525" cy="9525"/><wp:docPr id="1" name="${escapeAttribute(mediaItem.filename)}" descr="${escapeAttribute(altText ?? "")}"/><wp:cNvGraphicFramePr/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name="${escapeAttribute(mediaItem.filename)}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${escapeAttribute(mediaItem.relationshipId)}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="9525" cy="9525"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>`;
+  }
+
+  return serializeRun({
+    kind: "text",
+    text: node.altText ?? "[Image]",
+  });
+}
+
+function serializeRun(piece: RunPiece): string {
+  const marks = piece.kind === "text" ? piece.marks : undefined;
+  const properties = serializeRunProperties(marks);
+  const content = serializeRunPiece(piece);
+  return `<w:r>${properties}${content}</w:r>`;
+}
+
+function serializeRunProperties(marks: TextMark[] | undefined): string {
+  if (!marks || marks.length === 0) {
+    return "";
+  }
+
+  const markParts: string[] = [];
+  for (const mark of marks) {
+    switch (mark.type) {
+      case "bold":
+        markParts.push("<w:b/>");
+        break;
+      case "italic":
+        markParts.push("<w:i/>");
+        break;
+      case "underline":
+        markParts.push(`<w:u w:val="single"/>`);
+        break;
+      case "strikethrough":
+        markParts.push("<w:strike/>");
+        break;
+      case "doubleStrikethrough":
+        markParts.push("<w:dstrike/>");
+        break;
+      case "vanish":
+        markParts.push("<w:vanish/>");
+        break;
+      case "lang":
+        markParts.push(`<w:lang w:val="${escapeAttribute(mark.val)}"/>`);
+        break;
+      case "highlight":
+        markParts.push(`<w:highlight w:val="${escapeAttribute(mark.val)}"/>`);
+        break;
+      case "backgroundColor":
+        markParts.push(
+          `<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttribute(mark.color)}"/>`,
+        );
+        break;
+      case "charSpacing":
+        markParts.push(`<w:spacing w:val="${mark.val}"/>`);
+        break;
+      case "kerning":
+        markParts.push(`<w:kern w:val="${mark.val}"/>`);
+        break;
+      case "emboss":
+        markParts.push("<w:emboss/>");
+        break;
+      case "imprint":
+        markParts.push("<w:imprint/>");
+        break;
+      case "shadow":
+        markParts.push("<w:shadow/>");
+        break;
+      case "position":
+        markParts.push(`<w:position w:val="${mark.val}"/>`);
+        break;
+      case "textFill":
+        markParts.push(mark.xml);
+        break;
+      case "fontFamily":
+        markParts.push(`<w:rFonts w:ascii="${escapeAttribute(mark.val)}" w:hAnsi="${escapeAttribute(mark.val)}"/>`);
+        break;
+      case "fontSize":
+        markParts.push(`<w:sz w:val="${mark.val}"/>`);
+        break;
+      case "textColor":
+        markParts.push(`<w:color w:val="${escapeAttribute(mark.color)}"/>`);
+        break;
+      case "smallCaps":
+        markParts.push("<w:smallCaps/>");
+        break;
+      case "allCaps":
+        markParts.push("<w:caps/>");
+        break;
+    }
+  }
+
+  const children = markParts.join("");
+  return children.length > 0 ? `<w:rPr>${children}</w:rPr>` : "";
+}
+
+function requiresPreservedSpace(text: string): boolean {
+  return /^\s/.test(text) || /\s$/.test(text) || text.includes("  ");
+}
+
+function lookupOpaqueXml(fragmentId: string, state: SerializationState): string {
+  const fragment = getOpaqueFragment(state.preservation, fragmentId);
+  if (!fragment || fragment.payloadKind !== "xml-subtree") {
+    throw new Error(`Missing preserved OOXML fragment ${fragmentId} during serialization.`);
+  }
+
+  retainRelationshipsForFragment(
+    fragment,
+    state.relationships,
+    state.existingRelationshipMap,
+    state.retainedRelationshipIds,
+  );
+  return fragment.payloadReference;
+}
+
+function cloneRelationship(relationship: OpcRelationship): OpcRelationship {
+  return { ...relationship };
+}
+
+function looksLikeSectionPropertiesXml(xml: string): boolean {
+  return /^<[^>]*:?sectPr(?:\s|>|\/)/.test(xml.trim());
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+function escapeAttribute(value: string): string {
+  return escapeXml(value).replace(/"/g, "&quot;");
+}
+
+function offsetParagraphBoundary(
+  boundary: RevisionParagraphBoundary,
+  offset: number,
+): RevisionParagraphBoundary {
+  return {
+    ...boundary,
+    boundaries: new Map(
+      [...boundary.boundaries.entries()].map(([position, index]) => [
+        position,
+        index + offset,
+      ]),
+    ),
+    paragraphStart: boundary.paragraphStart + offset,
+    paragraphStartTagEnd: boundary.paragraphStartTagEnd + offset,
+    paragraphEndTagStart: boundary.paragraphEndTagStart + offset,
+    paragraphEnd: boundary.paragraphEnd + offset,
+    ...(boundary.paragraphPropertiesStart !== undefined
+      ? { paragraphPropertiesStart: boundary.paragraphPropertiesStart + offset }
+      : {}),
+    ...(boundary.paragraphPropertiesEnd !== undefined
+      ? { paragraphPropertiesEnd: boundary.paragraphPropertiesEnd + offset }
+      : {}),
+    ...(boundary.paragraphRunPropertiesStart !== undefined
+      ? { paragraphRunPropertiesStart: boundary.paragraphRunPropertiesStart + offset }
+      : {}),
+    ...(boundary.paragraphRunPropertiesEnd !== undefined
+      ? { paragraphRunPropertiesEnd: boundary.paragraphRunPropertiesEnd + offset }
+      : {}),
+  };
+}
+
+function serializeDocumentAttributes(
+  attributes: Record<string, string> | undefined,
+  content?: DocumentRootNode,
+): string {
+  const merged = {
+    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    ...(content && documentNeedsW14Namespace(content)
+      ? { "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml" }
+      : {}),
+    ...(attributes ?? {}),
+  };
+
+  return Object.entries(merged)
+    .map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`)
+    .join("");
+}
+
+export function serializeSectionPropertiesXml(props: SectionProperties): string {
+  const children: string[] = [];
+
+  // Header references
+  if (props.headerReferences) {
+    for (const ref of props.headerReferences) {
+      children.push(`<w:headerReference w:type="${escapeAttribute(ref.variant)}" r:id="${escapeAttribute(ref.relationshipId)}"/>`);
+    }
+  }
+
+  // Footer references
+  if (props.footerReferences) {
+    for (const ref of props.footerReferences) {
+      children.push(`<w:footerReference w:type="${escapeAttribute(ref.variant)}" r:id="${escapeAttribute(ref.relationshipId)}"/>`);
+    }
+  }
+
+  // Section type
+  if (props.sectionType) {
+    children.push(`<w:type w:val="${escapeAttribute(props.sectionType)}"/>`);
+  }
+
+  // Page size
+  if (props.pageSize) {
+    let pgSz = `<w:pgSz w:w="${props.pageSize.width}" w:h="${props.pageSize.height}"`;
+    if (props.pageSize.orientation) {
+      pgSz += ` w:orient="${props.pageSize.orientation}"`;
+    }
+    pgSz += "/>";
+    children.push(pgSz);
+  }
+
+  // Page margins
+  if (props.pageMargins) {
+    let pgMar = `<w:pgMar w:top="${props.pageMargins.top}" w:right="${props.pageMargins.right}" w:bottom="${props.pageMargins.bottom}" w:left="${props.pageMargins.left}"`;
+    if (props.pageMargins.header !== undefined) pgMar += ` w:header="${props.pageMargins.header}"`;
+    if (props.pageMargins.footer !== undefined) pgMar += ` w:footer="${props.pageMargins.footer}"`;
+    if (props.pageMargins.gutter !== undefined) pgMar += ` w:gutter="${props.pageMargins.gutter}"`;
+    pgMar += "/>";
+    children.push(pgMar);
+  }
+
+  // Columns
+  if (props.columns) {
+    let cols = "<w:cols";
+    if (props.columns.count !== undefined) cols += ` w:num="${props.columns.count}"`;
+    if (props.columns.space !== undefined) cols += ` w:space="${props.columns.space}"`;
+    if (props.columns.equalWidth !== undefined) cols += ` w:equalWidth="${props.columns.equalWidth ? "1" : "0"}"`;
+    if (props.columns.separator) cols += ` w:sep="1"`;
+    if (props.columns.columns && props.columns.columns.length > 0) {
+      cols += ">";
+      for (const col of props.columns.columns) {
+        let colXml = `<w:col w:w="${col.width}"`;
+        if (col.space !== undefined) colXml += ` w:space="${col.space}"`;
+        colXml += "/>";
+        cols += colXml;
+      }
+      cols += "</w:cols>";
+    } else {
+      cols += "/>";
+    }
+    children.push(cols);
+  }
+
+  // Page numbering
+  if (props.pageNumbering) {
+    let pgNum = "<w:pgNumType";
+    if (props.pageNumbering.format) pgNum += ` w:fmt="${escapeAttribute(props.pageNumbering.format)}"`;
+    if (props.pageNumbering.start !== undefined) pgNum += ` w:start="${props.pageNumbering.start}"`;
+    if (props.pageNumbering.chapStyle) pgNum += ` w:chapStyle="${escapeAttribute(props.pageNumbering.chapStyle)}"`;
+    if (props.pageNumbering.chapSep) pgNum += ` w:chapSep="${escapeAttribute(props.pageNumbering.chapSep)}"`;
+    pgNum += "/>";
+    children.push(pgNum);
+  }
+
+  if (props.lineNumbering) {
+    let lineNumbering = "<w:lnNumType";
+    if (props.lineNumbering.countBy !== undefined) {
+      lineNumbering += ` w:countBy="${props.lineNumbering.countBy}"`;
+    }
+    if (props.lineNumbering.start !== undefined) {
+      lineNumbering += ` w:start="${props.lineNumbering.start}"`;
+    }
+    if (props.lineNumbering.distance !== undefined) {
+      lineNumbering += ` w:distance="${props.lineNumbering.distance}"`;
+    }
+    if (props.lineNumbering.restart) {
+      lineNumbering += ` w:restart="${escapeAttribute(props.lineNumbering.restart)}"`;
+    }
+    lineNumbering += "/>";
+    children.push(lineNumbering);
+  }
+
+  if (props.pageBorders) {
+    const attrs: string[] = [];
+    if (props.pageBorders.offsetFrom) {
+      attrs.push(`w:offsetFrom="${escapeAttribute(props.pageBorders.offsetFrom)}"`);
+    }
+    if (props.pageBorders.display) {
+      attrs.push(`w:display="${escapeAttribute(props.pageBorders.display)}"`);
+    }
+    if (props.pageBorders.zOrder) {
+      attrs.push(`w:zOrder="${escapeAttribute(props.pageBorders.zOrder)}"`);
+    }
+    const borderXml = [
+      serializeBorder("top", props.pageBorders.top),
+      serializeBorder("left", props.pageBorders.left),
+      serializeBorder("bottom", props.pageBorders.bottom),
+      serializeBorder("right", props.pageBorders.right),
+    ].filter((entry) => entry.length > 0);
+    if (attrs.length > 0 || borderXml.length > 0) {
+      children.push(
+        `<w:pgBorders${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${borderXml.join("")}</w:pgBorders>`,
+      );
+    }
+  }
+
+  // Title page
+  if (props.titlePage) {
+    children.push("<w:titlePg/>");
+  }
+
+  if (props.documentGrid) {
+    const attrs: string[] = [];
+    if (props.documentGrid.type) {
+      attrs.push(`w:type="${escapeAttribute(props.documentGrid.type)}"`);
+    }
+    if (props.documentGrid.linePitch !== undefined) {
+      attrs.push(`w:linePitch="${props.documentGrid.linePitch}"`);
+    }
+    if (props.documentGrid.charSpace !== undefined) {
+      attrs.push(`w:charSpace="${props.documentGrid.charSpace}"`);
+    }
+    if (attrs.length > 0) {
+      children.push(`<w:docGrid ${attrs.join(" ")}/>`);
+    }
+  }
+
+  if (children.length === 0) {
+    return "<w:sectPr/>";
+  }
+
+  return `<w:sectPr>${children.join("")}</w:sectPr>`;
+}
+
+function wrapInlineRawXml(rawXml: string): string {
+  const trimmed = rawXml.trimStart();
+  return trimmed.startsWith("<w:r") ? rawXml : `<w:r>${rawXml}</w:r>`;
+}
+
+function documentNeedsW14Namespace(content: DocumentRootNode): boolean {
+  return content.children.some(blockNeedsW14Namespace);
+}
+
+function blockNeedsW14Namespace(block: DocumentRootNode["children"][number]): boolean {
+  switch (block.type) {
+    case "paragraph":
+      return block.children.some(inlineNodeNeedsW14Namespace);
+    case "table":
+      return block.rows.some((row) =>
+        row.cells.some((cell) => cell.children.some(blockNeedsW14Namespace)),
+      );
+    case "sdt":
+      return Boolean(block.properties.checkbox) || block.children.some(blockNeedsW14Namespace);
+    case "custom_xml":
+      return block.children.some(blockNeedsW14Namespace);
+    default:
+      return false;
+  }
+}
+
+function inlineNodeNeedsW14Namespace(node: InlineNode): boolean {
+  switch (node.type) {
+    case "text":
+    case "symbol":
+      return Boolean(node.marks?.some((mark) => mark.type === "textFill"));
+    case "hyperlink":
+    case "field":
+      return node.children.some(inlineNodeNeedsW14Namespace);
+    default:
+      return false;
+  }
+}