@beyondwork/docx-react-component 1.0.58 → 1.0.59

package/src/io/export/serialize-ffdata.ts

@@ -0,0 +1,89 @@
+import type { LegacyFormFieldNode } from "../../model/canonical-document.ts";
+
+/**
+ * Phase V.a — Regenerate `<w:ffData>…</w:ffData>` XML from a typed
+ * `LegacyFormFieldNode`.
+ *
+ * Used when typed-field mutations (via `setLegacyFormFieldValue`) need to be
+ * reflected in the serialized output. When no mutation has occurred, the
+ * preserved `legacyFormField.rawXml` is emitted verbatim for lossless
+ * round-trip — this helper is only invoked on the mutation path.
+ *
+ * Output is intentionally minimal: only the fields present on the typed
+ * node are emitted. Unknown-shape preservation (e.g. w:format, w:helpText,
+ * w:statusText) is handled by the rawXml passthrough path; once a consumer
+ * mutates the field, those unknown fields are lost unless the host
+ * re-populates them. This is the documented trade-off.
+ */
+export function regenerateFFDataRawXml(node: LegacyFormFieldNode): string {
+  const parts: string[] = ["<w:ffData>"];
+
+  if (node.name !== undefined) {
+    parts.push(`<w:name w:val="${escapeXmlAttribute(node.name)}"/>`);
+  }
+  if (node.enabled !== undefined) {
+    parts.push(node.enabled ? "<w:enabled/>" : `<w:enabled w:val="0"/>`);
+  }
+  if (node.calcOnExit !== undefined) {
+    parts.push(node.calcOnExit ? "<w:calcOnExit/>" : `<w:calcOnExit w:val="0"/>`);
+  }
+
+  switch (node.kind) {
+    case "textInput": {
+      const ti = node.textInput;
+      parts.push("<w:textInput>");
+      if (ti?.default !== undefined) {
+        parts.push(`<w:default w:val="${escapeXmlAttribute(ti.default)}"/>`);
+      }
+      if (ti?.maxLength !== undefined) {
+        parts.push(`<w:maxLength w:val="${ti.maxLength}"/>`);
+      }
+      if (ti?.format !== undefined) {
+        parts.push(`<w:format w:val="${escapeXmlAttribute(ti.format)}"/>`);
+      }
+      parts.push("</w:textInput>");
+      break;
+    }
+    case "checkBox": {
+      const cb = node.checkBox;
+      parts.push("<w:checkBox>");
+      if (cb?.size !== undefined) {
+        parts.push(`<w:size w:val="${cb.size}"/>`);
+      }
+      if (cb?.default !== undefined) {
+        parts.push(`<w:default w:val="${cb.default ? "1" : "0"}"/>`);
+      }
+      if (cb?.checked !== undefined) {
+        parts.push(`<w:checked w:val="${cb.checked ? "1" : "0"}"/>`);
+      }
+      parts.push("</w:checkBox>");
+      break;
+    }
+    case "ddList": {
+      const dd = node.ddList;
+      parts.push("<w:ddList>");
+      if (dd?.default !== undefined) {
+        parts.push(`<w:default w:val="${dd.default}"/>`);
+      }
+      if (dd?.listEntry) {
+        for (const entry of dd.listEntry) {
+          parts.push(`<w:listEntry w:val="${escapeXmlAttribute(entry)}"/>`);
+        }
+      }
+      parts.push("</w:ddList>");
+      break;
+    }
+  }
+
+  parts.push("</w:ffData>");
+  return parts.join("");
+}
+
+function escapeXmlAttribute(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}

package/src/io/export/serialize-headers-footers.ts

@@ -263,6 +263,11 @@ function serializeInlineNode(node: InlineNode): string {
     case "wordart":
     case "vml_shape":
       return wrapInlineRawXml(node.rawXml);
+    case "ole_embed":
+      // OLE in header/footer is rare but legal in OOXML. Relationship
+      // tracking for sub-parts is not wired; emit rawXml verbatim
+      // (preserve-only contract — same fallback as vml_shape above).
+      return wrapInlineRawXml(node.rawXml);
     case "opaque_inline":
       throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
     case "image":

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

@@ -5,6 +5,7 @@ import type {
   DocumentRootNode,
   FootnoteProperties,
   InlineNode,
+  LegacyFormFieldNode,
   MediaCatalog,
   ParagraphNode,
   PreservationStore,
@@ -14,6 +15,7 @@ import type {
   TableCellNode,
   TextMark,
 } from "../../model/canonical-document.ts";
+import { regenerateFFDataRawXml } from "./serialize-ffdata.ts";
 import type { OpcRelationship } from "../ooxml/part-manifest.ts";
 import type { RevisionParagraphBoundary } from "../ooxml/revision-boundaries.ts";
 import { SCOPE_MARKER_BOOKMARK_PREFIX } from "../ooxml/parse-scope-markers.ts";
@@ -28,10 +30,27 @@ import {
 import { twip } from "./twip.ts";
 import { escapeXmlAttribute } from "./escape-xml-attribute.ts";
 import { emitPropertyGrabBag } from "../ooxml/property-grab-bag.ts";
+import { type NamespaceFlavor, nsUris } from "./ooxml-namespaces.ts";
 
 const HYPERLINK_RELATIONSHIP_TYPE =
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 
+/**
+ * Phase V.a — decide which ffData XML to emit for a FieldNode's legacyFormField.
+ *
+ * - Un-mutated (or missing): emit preserved `rawXml` verbatim for lossless
+ *   round-trip (Phase O contract).
+ * - Mutated (after `setLegacyFormFieldValue`): regenerate fresh XML from
+ *   the typed fields via `regenerateFFDataRawXml`. Unknown-shape fields
+ *   (helpText/statusText/format) that the typed model doesn't cover are
+ *   dropped on the mutation path — documented tradeoff.
+ */
+function resolveFFDataXml(legacyFormField: LegacyFormFieldNode | undefined): string {
+  if (!legacyFormField) return "";
+  if (legacyFormField.mutated) return regenerateFFDataRawXml(legacyFormField);
+  return legacyFormField.rawXml ?? "";
+}
+
 export interface SerializedMainDocument {
   documentXml: string;
   relationships: OpcRelationship[];
@@ -42,6 +61,8 @@ export interface SerializeMainDocumentOptions {
   documentAttributes?: Record<string, string>;
   media?: MediaCatalog;
   finalSectionProperties?: SectionProperties;
+  /** Defaults to "transitional". Pass "strict" to emit ISO 29500 Strict namespace URIs. */
+  namespaceFlavor?: NamespaceFlavor;
 }
 
 interface SerializationState {
@@ -51,6 +72,13 @@ interface SerializationState {
   retainedRelationshipIds: Set<string>;
   media: MediaCatalog;
   preservation: PreservationStore;
+  namespaceFlavor: NamespaceFlavor;
+  /**
+   * Phase 3.1 B2 — monotonic counter for minted `wp:docPr` ids on reconstructed
+   * DrawingFrameNode pictures that lack `content.rawXml`. Starts at 10000 to
+   * avoid collision with Word-authored ids (which are typically small ints).
+   */
+  nextDrawingFrameReconstructId: number;
   /**
    * A.7: per-body-context dedupe sets for w14:paraId / w14:textId.
    * Every paragraph emitted into the same document part must carry a
@@ -100,6 +128,8 @@ export function serializeMainDocument(
     ),
     media: options.media ?? { items: {} },
     preservation,
+    namespaceFlavor: options.namespaceFlavor ?? "transitional",
+    nextDrawingFrameReconstructId: 10000,
     usedParaIds: new Set<string>(),
     usedTextIds: new Set<string>(),
     mintedParaIdCounter: 0,
@@ -214,6 +244,7 @@ export function serializeMainDocument(
     options.documentAttributes,
     content,
     extensionAliases,
+    options.namespaceFlavor ?? "transitional",
   )}>`;
   const prefix = [
     `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
@@ -532,7 +563,17 @@ function serializeTableInlineNode(
     case "vml_shape":
       return wrapInlineRawXml(node.rawXml);
     case "drawing_frame":
-      return serializeDrawingFrameNode(node);
+      return serializeDrawingFrameNode(node, state);
+    case "ole_embed":
+      // Lane 7c Slice 7c.1 — emit rawXml verbatim and retain the
+      // embedding relationship. Defensive: the serialize-state
+      // constructor pre-seeds retainedRelationshipIds with every
+      // pre-existing non-hyperlink relationship, so the embedding
+      // binary part is already preserved via collectPreservedPackageParts.
+      // This .add() guards against a future constructor tightening
+      // that narrows the pre-seed set.
+      state.retainedRelationshipIds.add(node.relationshipId);
+      return wrapInlineRawXml(node.rawXml);
     case "hyperlink": {
       const hyperlinkOpen = node.href.startsWith("#")
         ? `<w:hyperlink w:anchor="${escapeXmlAttribute(node.href.slice(1))}">`
@@ -557,8 +598,17 @@ function serializeTableInlineNode(
           .map((child) => serializeTableInlineNode(child, state))
           .join("");
         if (node.fieldType === "complex") {
+          // Invariant (Phase T): legacyFormField.rawXml is the authoritative
+          // form-field markup. Mutating legacyFormField.{textInput.default |
+          // checkBox.checked | ddList.selected} without regenerating rawXml
+          // will desync the serialized output. Phase V will add a regeneration
+          // path via `setLegacyFormFieldValue` + `regenerateFFDataRawXml`.
+          const ffDataXml = resolveFFDataXml(node.legacyFormField);
+          const beginRun = ffDataXml
+            ? `<w:r><w:fldChar w:fldCharType="begin">${ffDataXml}</w:fldChar></w:r>`
+            : `<w:r><w:fldChar w:fldCharType="begin"/></w:r>`;
           return (
-            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            beginRun +
             `<w:r><w:instrText xml:space="preserve"> ${escapeXml(node.instruction)} </w:instrText></w:r>` +
             `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
             childrenXml +
@@ -567,6 +617,18 @@ function serializeTableInlineNode(
         }
         return `<w:fldSimple w:instr="${escapeXmlAttribute(node.instruction)}">${childrenXml}</w:fldSimple>`;
       }
+      if (node.fieldType === "complex") {
+        const ffDataXml = resolveFFDataXml(node.legacyFormField);
+        const beginRun = ffDataXml
+          ? `<w:r><w:fldChar w:fldCharType="begin">${ffDataXml}</w:fldChar></w:r>`
+          : `<w:r><w:fldChar w:fldCharType="begin"/></w:r>`;
+        return (
+          beginRun +
+          `<w:r><w:instrText xml:space="preserve"> ${escapeXml(node.instruction)} </w:instrText></w:r>` +
+          `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+          `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+        );
+      }
       return `<w:fldSimple w:instr="${escapeXmlAttribute(node.instruction)}"/>`;
     }
     case "bookmark_start":
@@ -970,7 +1032,22 @@ function serializeInlineNode(
       // variant retains the original w:drawing slice on its content or is
       // a picture that also keeps the slice on its parent). Matches the
       // same "rawXml preservation" contract as shape/chart/smartart above.
-      const xml = serializeDrawingFrameNode(node);
+      const xml = serializeDrawingFrameNode(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 "ole_embed": {
+      // Lane 7c Slice 7c.1 — emit rawXml verbatim and retain the
+      // embedding relationship. Defensive — see the matching branch
+      // in the run dispatcher above for the pre-seed rationale.
+      state.retainedRelationshipIds.add(node.relationshipId);
+      const xml = wrapInlineRawXml(node.rawXml);
       const boundaries = new Map<number, number>();
       boundaries.set(cursor, xmlOffset);
       boundaries.set(cursor + 1, xmlOffset + xml.length);
@@ -1027,8 +1104,12 @@ function serializeInlineNode(
         let nextOffset = xmlOffset;
 
         if (node.fieldType === "complex") {
+          const ffDataXml = resolveFFDataXml(node.legacyFormField);
+          const beginRun = ffDataXml
+            ? `<w:r><w:fldChar w:fldCharType="begin">${ffDataXml}</w:fldChar></w:r>`
+            : `<w:r><w:fldChar w:fldCharType="begin"/></w:r>`;
           const beginXml =
-            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            beginRun +
             `<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;
@@ -1069,6 +1150,22 @@ function serializeInlineNode(
         return { xml: children.join(""), cursor: nextCursor, boundaries };
       }
 
+      if (node.fieldType === "complex") {
+        const ffDataXml = resolveFFDataXml(node.legacyFormField);
+        const beginRun = ffDataXml
+          ? `<w:r><w:fldChar w:fldCharType="begin">${ffDataXml}</w:fldChar></w:r>`
+          : `<w:r><w:fldChar w:fldCharType="begin"/></w:r>`;
+        const xml =
+          beginRun +
+          `<w:r><w:instrText xml:space="preserve"> ${escapeXml(node.instruction)} </w:instrText></w:r>` +
+          `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+          `<w:r><w:fldChar w:fldCharType="end"/></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 };
+      }
+
       const xml = `<w:fldSimple w:instr="${escapeXmlAttribute(node.instruction)}"/>`;
       const boundaries = new Map<number, number>();
       boundaries.set(cursor, xmlOffset);
@@ -1144,41 +1241,128 @@ function serializeInlineNode(
 }
 
 /**
- * CO4 F4.1 — serialize a DrawingFrameNode by emitting the preserved rawXml.
+ * Serialize a DrawingFrameNode.
+ *
+ * Primary path: emit preserved `content.rawXml` unchanged — byte-stable
+ * round-trip. Every typed content variant (picture, shape, chart_preview,
+ * smartart_preview, opaque) carries rawXml when the parser produced it.
  *
- * Every DrawingFrame variant carries a lossless original-XML reference:
- * - shape, chart_preview, smartart_preview, opaque → `content.rawXml`
- * - picture → the parse layer stores the containing drawing XML on the outer
- *   DrawingFrame's context; for the MVP we reconstruct from the anchor +
- *   blipRef if needed. In practice picture content also originates from a
- *   larger drawingXml slice — the parent `w:drawing` substring — which we
- *   don't retain explicitly yet. When `content.rawXml` is absent we emit a
- *   minimal wp:inline/wp:anchor envelope preserving extent + relationship id.
+ * Reconstruction fallback (picture only): when a DrawingFrameNode lacks
+ * rawXml (produced programmatically in memory — not yet a supported author
+ * path, but possible), synthesise a schema-valid wp:inline or wp:anchor
+ * envelope from the parsed AnchorGeometry + PictureContent fields.
  *
- * For the round-trip v1 contract: if any `rawXml` is present, round-trip is
- * byte-stable modulo whitespace. If the picture-content path has no rawXml,
- * a reconstructed minimal drawing is emitted.
+ * Schema-validity rules for reconstruction (Phase 3.1 B2+B3):
+ * - Every `wp:docPr` gets a unique id — either the parsed `anchor.docPr.id`
+ *   or a fresh id minted from `state.nextDrawingFrameReconstructId`.
+ * - Floating reconstruction (wp:anchor) emits the required children:
+ *   `wp:simplePos`, `wp:positionH`, `wp:positionV`, `wp:extent`,
+ *   `wp:effectExtent`, `wp:wrap*` — refuses reconstruction if positionH
+ *   or positionV is missing (returns empty string = defensive fail-loud).
+ * - Inline reconstruction (wp:inline) needs only `wp:extent`, `wp:docPr`,
+ *   `wp:cNvGraphicFramePr`, `a:graphic`.
+ *
+ * Non-picture content (shape/chart/smartart/opaque) without rawXml returns
+ * empty string — no reconstructor for those variants. In practice the parser
+ * always sets rawXml for those; this is a defensive fail-loud path.
  */
 function serializeDrawingFrameNode(
   node: Extract<InlineNode, { type: "drawing_frame" }>,
+  state: SerializationState,
 ): string {
   const content = node.content;
   if ("rawXml" in content && typeof content.rawXml === "string" && content.rawXml.length > 0) {
     return wrapInlineRawXml(content.rawXml);
   }
-  // Picture content with no rawXml — reconstruct a minimal inline image so the
-  // round-trip doesn't silently drop the image. Use the blipRef + anchor extent.
   if (content.type === "picture") {
-    const { widthEmu, heightEmu } = node.anchor.extent;
-    const embed = escapeXmlAttribute(content.blipRef);
-    const envelope = node.anchor.display === "floating" ? "wp:anchor" : "wp:inline";
-    return `<w:r><w:drawing><${envelope} 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="${widthEmu}" cy="${heightEmu}"/><wp:docPr id="1" name=""/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name=""/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${embed}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${widthEmu}" cy="${heightEmu}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></${envelope}></w:drawing></w:r>`;
+    return reconstructPictureFrame(node, content, state);
   }
-  // Shape/chart/smartart/opaque without rawXml — nothing to emit. Should not
-  // happen in practice since the parser always sets rawXml.
+  // Shape/chart/smartart/opaque without rawXml — no reconstructor; emit nothing.
   return "";
 }
 
+function reconstructPictureFrame(
+  node: Extract<InlineNode, { type: "drawing_frame" }>,
+  content: Extract<AnchorGeometryContent, { type: "picture" }>,
+  state: SerializationState,
+): string {
+  const { widthEmu, heightEmu } = node.anchor.extent;
+  const embed = escapeXmlAttribute(content.blipRef);
+
+  // docPr uniqueness (B2): use parsed id; otherwise mint a fresh one.
+  const parsedDocPr = node.anchor.docPr;
+  const docPrId = parsedDocPr?.id ?? String(state.nextDrawingFrameReconstructId++);
+  const docPrNameAttr = parsedDocPr?.name
+    ? ` name="${escapeXmlAttribute(parsedDocPr.name)}"`
+    : ` name=""`;
+  const docPrDescrAttr = parsedDocPr?.descr
+    ? ` descr="${escapeXmlAttribute(parsedDocPr.descr)}"`
+    : "";
+  const docPrXml = `<wp:docPr id="${escapeXmlAttribute(docPrId)}"${docPrNameAttr}${docPrDescrAttr}/>`;
+
+  const ns = nsUris(state.namespaceFlavor);
+  const graphicXml = `<a:graphic><a:graphicData uri="${ns.pic}"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name=""/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${embed}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${widthEmu}" cy="${heightEmu}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic>`;
+
+  const drawingNs = `xmlns:a="${ns.a}" xmlns:pic="${ns.pic}" xmlns:wp="${ns.wp}"`;
+
+  if (node.anchor.display === "inline") {
+    const extent = `<wp:extent cx="${widthEmu}" cy="${heightEmu}"/>`;
+    return `<w:r><w:drawing><wp:inline ${drawingNs}>${extent}${docPrXml}<wp:cNvGraphicFramePr/>${graphicXml}</wp:inline></w:drawing></w:r>`;
+  }
+
+  // Floating (wp:anchor): refuse reconstruction if required children missing.
+  // Fail-loud: return empty string so consumer sees the picture was dropped
+  // rather than Word seeing schema-invalid XML and rejecting / renumbering.
+  if (!node.anchor.positionH || !node.anchor.positionV) return "";
+
+  const simplePos = `<wp:simplePos x="0" y="0"/>`;
+  const positionH = buildPositionAxisXml("positionH", node.anchor.positionH);
+  const positionV = buildPositionAxisXml("positionV", node.anchor.positionV);
+  const extent = `<wp:extent cx="${widthEmu}" cy="${heightEmu}"/>`;
+  const distMargins = node.anchor.distMargins ?? { top: 0, bottom: 0, left: 0, right: 0 };
+  const effectExtent = `<wp:effectExtent l="${distMargins.left ?? 0}" t="${distMargins.top ?? 0}" r="${distMargins.right ?? 0}" b="${distMargins.bottom ?? 0}"/>`;
+  const wrap = buildWrapElementXml(node.anchor.wrapMode);
+
+  const anchorAttrs = [
+    `distT="${distMargins.top ?? 0}"`,
+    `distB="${distMargins.bottom ?? 0}"`,
+    `distL="${distMargins.left ?? 0}"`,
+    `distR="${distMargins.right ?? 0}"`,
+    `simplePos="${node.anchor.simplePos ? 1 : 0}"`,
+    `relativeHeight="${node.anchor.relativeHeight ?? 0}"`,
+    `behindDoc="${node.anchor.behindDoc ? 1 : 0}"`,
+    `locked="0"`,
+    `layoutInCell="${(node.anchor.layoutInCell ?? true) ? 1 : 0}"`,
+    `allowOverlap="${(node.anchor.allowOverlap ?? true) ? 1 : 0}"`,
+  ].join(" ");
+
+  return `<w:r><w:drawing><wp:anchor ${drawingNs} ${anchorAttrs}>${simplePos}${positionH}${positionV}${extent}${effectExtent}${wrap}${docPrXml}<wp:cNvGraphicFramePr/>${graphicXml}</wp:anchor></w:drawing></w:r>`;
+}
+
+function buildPositionAxisXml(
+  kind: "positionH" | "positionV",
+  axis: { relativeFrom: string; align?: string; offset?: number },
+): string {
+  const body = axis.align
+    ? `<wp:align>${escapeXmlAttribute(axis.align)}</wp:align>`
+    : `<wp:posOffset>${axis.offset ?? 0}</wp:posOffset>`;
+  return `<wp:${kind} relativeFrom="${escapeXmlAttribute(axis.relativeFrom || "column")}">${body}</wp:${kind}>`;
+}
+
+function buildWrapElementXml(mode: "none" | "square" | "tight" | "through" | "topAndBottom"): string {
+  switch (mode) {
+    case "none": return `<wp:wrapNone/>`;
+    case "square": return `<wp:wrapSquare wrapText="bothSides"/>`;
+    case "tight": return `<wp:wrapTight wrapText="bothSides"/>`;
+    case "through": return `<wp:wrapThrough wrapText="bothSides"/>`;
+    case "topAndBottom": return `<wp:wrapTopAndBottom/>`;
+  }
+}
+
+// Narrow helper type used only in the reconstruction signature.
+type AnchorGeometryContent =
+  Extract<InlineNode, { type: "drawing_frame" }>["content"];
+
 function serializeImageNode(
   node: Extract<InlineNode, { type: "image" }>,
   state: SerializationState,
@@ -1191,7 +1375,8 @@ function serializeImageNode(
   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="${escapeXmlAttribute(mediaItem.filename)}" descr="${escapeXmlAttribute(altText ?? "")}"/><wp:cNvGraphicFramePr/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name="${escapeXmlAttribute(mediaItem.filename)}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${escapeXmlAttribute(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>`;
+    const ins = nsUris(state.namespaceFlavor);
+    return `<w:r><w:drawing><wp:inline xmlns:a="${ins.a}" xmlns:pic="${ins.pic}" xmlns:wp="${ins.wp}"><wp:extent cx="9525" cy="9525"/><wp:docPr id="1" name="${escapeXmlAttribute(mediaItem.filename)}" descr="${escapeXmlAttribute(altText ?? "")}"/><wp:cNvGraphicFramePr/><a:graphic><a:graphicData uri="${ins.pic}"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name="${escapeXmlAttribute(mediaItem.filename)}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${escapeXmlAttribute(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({
@@ -1458,26 +1643,31 @@ function serializeDocumentAttributes(
   attributes: Record<string, string> | undefined,
   content?: DocumentRootNode,
   extensionAliases: readonly string[] = [],
+  flavor: NamespaceFlavor = "transitional",
 ): string {
+  const ns = nsUris(flavor);
+  // Extension namespaces are Transitional-only (Microsoft-specific w14/w15/w16*).
+  // In Strict mode they are omitted — any w14/w15 content in preserved XML
+  // is technically non-conformant to ISO 29500 Strict anyway.
   const extensionXmlns: Record<string, string> = {};
-  for (const alias of extensionAliases) {
-    const uri = EXTENSION_NAMESPACE_URIS[alias];
-    if (uri) extensionXmlns[`xmlns:${alias}`] = uri;
+  if (flavor !== "strict") {
+    for (const alias of extensionAliases) {
+      const uri = EXTENSION_NAMESPACE_URIS[alias];
+      if (uri) extensionXmlns[`xmlns:${alias}`] = uri;
+    }
   }
 
   const merged: Record<string, string> = {
-    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-    "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    "xmlns:r": ns.r,
+    "xmlns:w": ns.w,
     ...extensionXmlns,
     ...(attributes ?? {}),
   };
 
   // mc:Ignorable declares extension-namespace aliases that downstream readers
   // may skip without dropping the document. Only emit when aliases are in play.
-  if (extensionAliases.length > 0) {
-    merged["xmlns:mc"] =
-      merged["xmlns:mc"] ??
-      "http://schemas.openxmlformats.org/markup-compatibility/2006";
+  if (flavor !== "strict" && extensionAliases.length > 0) {
+    merged["xmlns:mc"] = merged["xmlns:mc"] ?? ns.mc;
     merged["mc:Ignorable"] = extensionAliases.join(" ");
   }
 

package/src/io/export/serialize-numbering.ts

@@ -11,6 +11,16 @@ export const WORD_NUMBERING_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
 
 export function serializeNumberingXml(catalog: NumberingCatalog): string {
+  // ECMA-376 §17.9.19 — <w:numPicBullet> entries precede <w:abstractNum> and
+  // <w:num> in the numbering part. Emit verbatim rawXml so picture bullet data
+  // round-trips byte-for-byte regardless of VML vs DrawingML variant.
+  const picBullets = catalog.numPicBullets
+    ? Object.values(catalog.numPicBullets)
+        .sort((a, b) => a.numPicBulletId.localeCompare(b.numPicBulletId, "en", { numeric: true }))
+        .map((b) => b.rawXml)
+        .join("")
+    : "";
+
   const abstractDefinitions = Object.values(catalog.abstractDefinitions)
     .filter((definition) => !isSyntheticDocxNullAbstractDefinition(definition))
     .sort((left, right) =>
@@ -23,6 +33,7 @@ export function serializeNumberingXml(catalog: NumberingCatalog): string {
     );
 
   const body = [
+    picBullets,
     ...abstractDefinitions.map((definition) => serializeAbstractDefinition(definition)),
     ...instances.map((instance) => serializeInstance(instance)),
   ].join("");
@@ -35,6 +46,7 @@ export function serializeNumberingXml(catalog: NumberingCatalog): string {
 
 export function hasSerializableNumberingEntries(catalog: NumberingCatalog): boolean {
   return (
+    (catalog.numPicBullets !== undefined && Object.keys(catalog.numPicBullets).length > 0) ||
     Object.values(catalog.abstractDefinitions).some(
       (definition) => !isSyntheticDocxNullAbstractDefinition(definition),
     ) ||
@@ -112,13 +124,17 @@ function serializeLevel(
   const isLegal = level.isLegalNumbering ? "<w:isLgl/>" : "";
   const suffix = level.suffix ? `<w:suff w:val="${escapeXmlAttribute(level.suffix)}"/>` : "";
   const lvlText = `<w:lvlText w:val="${escapeXmlAttribute(level.text)}"/>`;
+  // ECMA-376 CT_Lvl: lvlPicBulletId follows lvlText, precedes lvlJc.
+  const picBulletId = level.picBulletId
+    ? `<w:lvlPicBulletId w:val="${escapeXmlAttribute(level.picBulletId)}"/>`
+    : "";
   const justification = level.paragraphGeometry?.justification
     ? `<w:lvlJc w:val="${escapeXmlAttribute(level.paragraphGeometry.justification)}"/>`
     : "";
   const paragraphProperties = serializeLevelParagraphGeometry(level.paragraphGeometry);
   const runProperties = buildRunPropertiesXml(level.runProperties);
 
-  return `<w:lvl w:ilvl="${clampIlvl(serializedLevel)}">${start}${numFmt}${lvlRestart}${paragraphStyle}${isLegal}${suffix}${lvlText}${justification}${paragraphProperties}${runProperties}</w:lvl>`;
+  return `<w:lvl w:ilvl="${clampIlvl(serializedLevel)}">${start}${numFmt}${lvlRestart}${paragraphStyle}${isLegal}${suffix}${lvlText}${picBulletId}${justification}${paragraphProperties}${runProperties}</w:lvl>`;
 }
 
 function serializeLevelOverride(
@@ -158,12 +174,16 @@ function serializeLevelOverride(
   const text = level.text !== undefined
     ? `<w:lvlText w:val="${escapeXmlAttribute(level.text)}"/>`
     : "";
+  // ECMA-376 CT_Lvl: lvlPicBulletId follows lvlText, precedes lvlJc.
+  const picBulletId = level.picBulletId
+    ? `<w:lvlPicBulletId w:val="${escapeXmlAttribute(level.picBulletId)}"/>`
+    : "";
   const justification = level.paragraphGeometry?.justification
     ? `<w:lvlJc w:val="${escapeXmlAttribute(level.paragraphGeometry.justification)}"/>`
     : "";
   const paragraphProperties = serializeLevelParagraphGeometry(level.paragraphGeometry);
   const runProperties = buildRunPropertiesXml(level.runProperties);
-  const body = `${start}${format}${lvlRestart}${paragraphStyle}${isLegal}${suffix}${text}${justification}${paragraphProperties}${runProperties}`;
+  const body = `${start}${format}${lvlRestart}${paragraphStyle}${isLegal}${suffix}${text}${picBulletId}${justification}${paragraphProperties}${runProperties}`;
 
   return body.length > 0
     ? `<w:lvl w:ilvl="${clampIlvl(serializedLevel)}">${body}</w:lvl>`