@beyondwork/docx-react-component 1.0.47 → 1.0.49

package/src/io/ooxml/parse-block-structure.ts

@@ -0,0 +1,99 @@
+/**
+ * L7 Phase 2.5 Plan B B.7 — shallow structural probe for `word/document.xml`.
+ *
+ * Emits the ordered (kind, blockId) list for top-level body children without
+ * building the canonical-document model. Used by `customxml-probe` to verify
+ * that a cached laycache envelope's `structuralHash` still matches the
+ * document the envelope was written against.
+ *
+ * **Correctness requirement.** The output must match what
+ * `surface-projection.ts:createSurfaceBlock` emits when walking a
+ * canonical document produced by the full parse pipeline. Specifically:
+ *   - Paragraph blockIds use a GLOBAL counter incremented on every
+ *     `<w:p>` encountered ANYWHERE in the tree (top-level or nested
+ *     inside a table cell). The top-level paragraph's blockId is
+ *     `paragraph-${counter_at_time_of_encounter}`.
+ *   - Table blockIds use a GLOBAL counter incremented on every
+ *     `<w:tbl>` at any depth.
+ *   - Other top-level elements (`<w:sdt>`, `<w:altChunk>`, `<w:sectPr>`)
+ *     are NOT emitted by this probe.
+ *
+ * **Known limitation (2026-04-19 shipping state).** The full parse
+ * promotes certain `<w:p>` elements to `opaque_block` based on their
+ * content — e.g. paragraphs containing structured content controls
+ * (`<w:sdt>`), floating drawings (`<w:drawing>` with `<wp:anchor>`),
+ * or `<mc:AlternateContent>` markup-compat wrappers. The shallow probe
+ * cannot detect these patterns without a deeper walk, so it counts such
+ * paragraphs as plain `paragraph` blocks. On docs where this triggers
+ * (~20% of F-series fixtures; 2 of 3 CCEP templates), the probe's
+ * structural hash diverges from the envelope's → cache is rejected →
+ * safe fallback to the full-parse open path. Plan B warm-cache opt-in
+ * is "clean docs only" under this probe.
+ *
+ * Future improvement: refine the probe to detect `<w:sdt>`,
+ * `<w:drawing w:anchor>`, and `<mc:AlternateContent>` inside top-level
+ * paragraphs and classify them accordingly. Deferred unless real-world
+ * hit rates prove insufficient.
+ *
+ * **Cost budget.** <30 ms on extra-large CCEP (~2.7 MB document.xml).
+ * Single regex walk, O(bytes). No DOM, no full XML parse.
+ *
+ * **Fidelity gate.** `test/io/parse-block-structure.test.ts` compares
+ * probe output against full-parse blockIds on representative fixtures
+ * (F01/F02/F05/F48 for paragraph + table patterns, plus a clean CCEP
+ * template). Docs with opaque-promoting features are covered by a
+ * separate "safe fallback" test rather than the strict match.
+ */
+
+export interface BlockStructureProbe {
+  readonly kind: "paragraph" | "table";
+  readonly blockId: string;
+}
+
+const BODY_RE = /<w:body\b[^>]*>([\s\S]*?)<\/w:body>/u;
+const TAG_RE = /<(\/?)w:(p|tbl)\b[^>]*?(\/?)>/gu;
+
+export function parseBlockStructure(documentXml: string): BlockStructureProbe[] {
+  const bodyMatch = BODY_RE.exec(documentXml);
+  if (!bodyMatch) return [];
+  const body = bodyMatch[1] ?? "";
+
+  const results: BlockStructureProbe[] = [];
+  let paragraphCounter = 0;
+  let tableCounter = 0;
+  let depth = 0;
+
+  TAG_RE.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = TAG_RE.exec(body)) !== null) {
+    const closing = match[1] === "/";
+    const tag = match[2] as "p" | "tbl";
+    const selfClose = match[3] === "/";
+
+    if (closing) {
+      depth -= 1;
+      continue;
+    }
+
+    if (depth === 0) {
+      if (tag === "p") {
+        results.push({ kind: "paragraph", blockId: `paragraph-${paragraphCounter}` });
+      } else {
+        results.push({ kind: "table", blockId: `table-${tableCounter}` });
+      }
+    }
+
+    // Global counter bumps (all depths, including top-level).
+    if (tag === "p") {
+      paragraphCounter += 1;
+    } else {
+      tableCounter += 1;
+    }
+
+    if (!selfClose) {
+      depth += 1;
+    }
+  }
+
+  return results;
+}

package/src/io/ooxml/parse-complex-content.ts

@@ -11,12 +11,22 @@
 
 import type { OpcRelationship } from "./part-manifest.ts";
 import { normalizePartPath, resolveRelationshipTarget } from "./part-manifest.ts";
+import { parseChartSpace } from "./chart/parse-chart-space.ts";
+import type { ChartModel } from "./chart/types.ts";
 
 export interface InlineMediaPart {
   path: string;
   contentType: string;
 }
 
+/**
+ * Callback that resolves a chart relationship id (the `r:id` on a
+ * `<c:chart>` reference) to the chart-part XML body. Returning undefined
+ * skips ChartModel population — the drawing still parses as a
+ * `ParsedChartContent` with `rawXml`, just without `parsedData`.
+ */
+export type ChartPartLookup = (rId: string) => string | undefined;
+
 export interface ParsedChartContent {
   type: "chart_preview";
   /** Media ID of the fallback preview image, if one is present in mc:Fallback. */
@@ -25,6 +35,17 @@ export interface ParsedChartContent {
   previewPackagePartName?: string;
   /** MIME type of the preview media (e.g. `image/png`, `image/svg+xml`). */
   previewContentType?: string;
+  /**
+   * Stage 1 typed chart model, when the chart part XML resolved and
+   * parsed cleanly. Undefined when no chart-part lookup was supplied, the
+   * lookup returned undefined, or `parseChartSpace` threw / returned an
+   * `UnsupportedChartModel` with reason="parse-error".
+   *
+   * A successful `UnsupportedChartModel{reason: "not-yet-implemented"}`
+   * IS attached — the renderer decides whether to fall back; preserve-
+   * only rawXml always survives export.
+   */
+  parsedData?: ChartModel;
   /** Original drawing XML slice for lossless round-trip export. */
   rawXml: string;
 }
@@ -60,6 +81,7 @@ export function parseComplexContentXml(
   relationships: readonly OpcRelationship[],
   mediaParts: ReadonlyMap<string, InlineMediaPart> = new Map(),
   sourcePartPath = "/word/document.xml",
+  chartPartLookup?: ChartPartLookup,
 ): ParsedComplexContent | null {
   const root = parseXml(drawingXml);
   const relationshipMap = new Map(relationships.map((r) => [r.id, r]));
@@ -67,7 +89,14 @@ export function parseComplexContentXml(
   // Look for mc:AlternateContent at any depth
   const altContent = findFirstDescendant(root, "AlternateContent");
   if (altContent) {
-    return parseAlternateContent(altContent, drawingXml, relationshipMap, mediaParts, sourcePartPath);
+    return parseAlternateContent(
+      altContent,
+      drawingXml,
+      relationshipMap,
+      mediaParts,
+      sourcePartPath,
+      chartPartLookup,
+    );
   }
 
   // No mc:AlternateContent — look for direct graphic data
@@ -78,7 +107,13 @@ export function parseComplexContentXml(
 
   const uri = graphicData.attributes.uri ?? graphicData.attributes["uri"] ?? "";
   if (isChartUri(uri)) {
-    return { type: "chart_preview", rawXml: drawingXml };
+    const parsedData = maybeParseChart(root, chartPartLookup);
+    const node: ParsedChartContent = {
+      type: "chart_preview",
+      ...(parsedData ? { parsedData } : {}),
+      rawXml: drawingXml,
+    };
+    return node;
   }
   if (isSmartArtUri(uri)) {
     return { type: "smartart_preview", rawXml: drawingXml };
@@ -87,12 +122,43 @@ export function parseComplexContentXml(
   return null;
 }
 
+/**
+ * Attempt to parse the referenced chart part into a ChartModel.
+ *
+ * Walks the drawing for a `<c:chart r:id="…"/>` reference, hands the id to
+ * the lookup callback, and if the callback returns chart-part XML,
+ * invokes `parseChartSpace`. Returns undefined on any failure — the
+ * caller still emits a valid `ParsedChartContent` with `rawXml`, just
+ * without `parsedData`.
+ */
+function maybeParseChart(
+  drawingRoot: XmlElementNode,
+  chartPartLookup: ChartPartLookup | undefined,
+): ChartModel | undefined {
+  if (!chartPartLookup) return undefined;
+  const chartRef = findFirstDescendant(drawingRoot, "chart");
+  if (!chartRef) return undefined;
+  const rId =
+    chartRef.attributes["r:id"] ??
+    chartRef.attributes["id"] ??
+    chartRef.attributes["r:embed"];
+  if (!rId) return undefined;
+  const chartXml = chartPartLookup(rId);
+  if (!chartXml) return undefined;
+  try {
+    return parseChartSpace(chartXml);
+  } catch {
+    return undefined;
+  }
+}
+
 function parseAlternateContent(
   altContent: XmlElementNode,
   fullDrawingXml: string,
   relationshipMap: Map<string, OpcRelationship>,
   mediaParts: ReadonlyMap<string, InlineMediaPart>,
   sourcePartPath: string,
+  chartPartLookup: ChartPartLookup | undefined,
 ): ParsedComplexContent | null {
   const choice = findFirstChild(altContent, "Choice");
   const fallback = findFirstChild(altContent, "Fallback");
@@ -150,6 +216,28 @@ function parseAlternateContent(
     }
   }
 
+  // For chart_preview, try to populate parsedData from the referenced
+  // chart part. parseAlternateContent is called with the AlternateContent
+  // subtree; the <c:chart> reference typically lives in the Choice branch,
+  // so we search from the altContent root (captures both Choice and any
+  // nested graphicData paths).
+  let parsedData: ChartModel | undefined;
+  if (contentType === "chart_preview") {
+    parsedData = maybeParseChart(altContent, chartPartLookup);
+  }
+
+  if (contentType === "chart_preview") {
+    const node: ParsedChartContent = {
+      type: "chart_preview",
+      ...(previewMediaId ? { previewMediaId } : {}),
+      ...(previewPackagePartName ? { previewPackagePartName } : {}),
+      ...(previewContentType ? { previewContentType } : {}),
+      ...(parsedData ? { parsedData } : {}),
+      rawXml: fullDrawingXml,
+    };
+    return node;
+  }
+
   return {
     type: contentType,
     ...(previewMediaId ? { previewMediaId } : {}),

package/src/io/ooxml/parse-main-document.ts

@@ -26,12 +26,13 @@ import type {
   SectionPageBorders,
 } from "../../model/canonical-document.ts";
 import type { OpcRelationship } from "./part-manifest.ts";
+import { SCOPE_MARKER_BOOKMARK_PREFIX } from "./parse-scope-markers.ts";
 import {
   parseInlineMediaXml,
   type InlineMediaPart,
 } from "./parse-inline-media.ts";
 import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
-import { parseComplexContentXml } from "./parse-complex-content.ts";
+import { parseComplexContentXml, type ChartPartLookup } from "./parse-complex-content.ts";
 import { parseShapeXml, parseVmlXml } from "./parse-shapes.ts";
 import { classifyFieldInstruction } from "./parse-fields.ts";
 import { resolveHighlightColor } from "./highlight-colors.ts";
@@ -66,6 +67,37 @@ import {
   readTableStyleId as readSharedTableStyleId,
   readTableWidth as readSharedTableWidth,
 } from "./parse-tables.ts";
+import {
+  buildGrabBagSourceChildFromParsed,
+  capturePropertyGrabBag,
+  type PropertyGrabBagDescriptor,
+} from "./property-grab-bag.ts";
+
+/**
+ * Modelled direct children of `<w:sectPr>` that `parseSectionPropertiesFromElement`
+ * below dispatches into typed fields on `SectionProperties`. Anything else
+ * becomes a grab-bag entry so a parse→serialize round-trip preserves
+ * extension-namespace section properties and Word-internal knobs the
+ * canonical model doesn't understand. Mirrors Slice 1/2 pPr/rPr coverage.
+ */
+const SECT_PR_MODELLED_CHILDREN: ReadonlySet<string> = new Set([
+  "cols",
+  "docGrid",
+  "footerReference",
+  "headerReference",
+  "lnNumType",
+  "pgBorders",
+  "pgMar",
+  "pgNumType",
+  "pgSz",
+  "titlePg",
+  "type",
+]);
+
+const SECT_PR_GRAB_BAG_DESCRIPTOR: PropertyGrabBagDescriptor = {
+  modelledChildNames: SECT_PR_MODELLED_CHILDREN,
+  modelledChildAttributes: new Map(),
+};
 
 export interface ParsedMainDocument {
   blocks: ParsedBlockNode[];
@@ -213,6 +245,9 @@ export interface ParsedChartPreviewNode {
   previewMediaId?: string;
   previewPackagePartName?: string;
   previewContentType?: string;
+  /** Typed chart data parsed from the c:chartSpace part. See
+   *  `src/io/ooxml/parse-complex-content.ts` for semantics. */
+  parsedData?: import("./chart/types.ts").ChartModel;
   rawXml: string;
 }
 
@@ -429,11 +464,38 @@ interface MarksParseResult {
 const HYPERLINK_RELATIONSHIP_TYPE =
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 
+/**
+ * Request-scoped chart-part lookup. Set by `parseMainDocumentXml` for
+ * the duration of a single top-level parse; read by `parseRun` where
+ * the `<w:drawing>` → `parseComplexContentXml` call site lives. Using a
+ * module variable instead of threading the callback through ~8
+ * intermediate function signatures keeps the call sites readable; the
+ * try/finally in `parseMainDocumentXml` ensures the variable never
+ * leaks across concurrent parses (Node.js is single-threaded; no
+ * re-entrancy since the parser is fully synchronous).
+ */
+let activeChartPartLookup: ChartPartLookup | undefined;
+
 export function parseMainDocumentXml(
   xml: string,
   relationships: readonly OpcRelationship[] = [],
   mediaParts: ReadonlyMap<string, InlineMediaPart> = new Map(),
   sourcePartPath = "/word/document.xml",
+  chartPartLookup?: ChartPartLookup,
+): ParsedMainDocument {
+  activeChartPartLookup = chartPartLookup;
+  try {
+    return parseMainDocumentXmlInner(xml, relationships, mediaParts, sourcePartPath);
+  } finally {
+    activeChartPartLookup = undefined;
+  }
+}
+
+function parseMainDocumentXmlInner(
+  xml: string,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
 ): ParsedMainDocument {
   const root = parseXml(xml);
   const documentElement = findChildElement(root, "document");
@@ -457,9 +519,91 @@ export function parseMainDocumentXml(
     }
   }
 
+  rewriteScopeMarkerBookmarks(blocks);
+
   return { blocks, finalSectionProperties };
 }
 
+/**
+ * S1 — post-process the parsed block tree in place, converting bookmark
+ * pairs whose `name` starts with `bw:scope:` into `scope_marker_*` inline
+ * nodes. The `bookmarkId` is used to pair start+end; the `scopeId` is
+ * taken from the name after the prefix. Unmatched bookmarks (start without
+ * end or vice versa) stay as regular bookmarks — S1 markers are always
+ * emitted in pairs on export, so an orphan implies upstream corruption
+ * that we preserve rather than drop.
+ */
+function rewriteScopeMarkerBookmarks(blocks: ParsedBlockNode[]): void {
+  const scopeBookmarkIds = new Map<string, string>();
+
+  const scanForStarts = (nodes: readonly { type?: string; [key: string]: unknown }[]): void => {
+    for (const node of nodes) {
+      if (!node || typeof node !== "object") continue;
+      if (node.type === "bookmark_start") {
+        const name = (node as { name?: string }).name ?? "";
+        if (name.startsWith(SCOPE_MARKER_BOOKMARK_PREFIX)) {
+          const bkId = (node as { bookmarkId?: string }).bookmarkId ?? "";
+          const scopeId = name.slice(SCOPE_MARKER_BOOKMARK_PREFIX.length);
+          if (bkId && scopeId) {
+            scopeBookmarkIds.set(bkId, scopeId);
+          }
+        }
+      }
+      const children = (node as { children?: unknown }).children;
+      if (Array.isArray(children)) scanForStarts(children);
+      const rows = (node as { rows?: unknown }).rows;
+      if (Array.isArray(rows)) scanForStarts(rows);
+      const cells = (node as { cells?: unknown }).cells;
+      if (Array.isArray(cells)) scanForStarts(cells);
+    }
+  };
+
+  const rewriteInPlace = (nodes: { type?: string; [key: string]: unknown }[]): void => {
+    for (let i = 0; i < nodes.length; i += 1) {
+      const node = nodes[i]!;
+      if (!node || typeof node !== "object") continue;
+
+      if (node.type === "bookmark_start") {
+        const bkId = (node as { bookmarkId?: string }).bookmarkId ?? "";
+        const scopeId = scopeBookmarkIds.get(bkId);
+        if (scopeId !== undefined) {
+          nodes[i] = { type: "scope_marker_start", scopeId } as typeof node;
+          continue;
+        }
+      }
+
+      if (node.type === "bookmark_end") {
+        const bkId = (node as { bookmarkId?: string }).bookmarkId ?? "";
+        const scopeId = scopeBookmarkIds.get(bkId);
+        if (scopeId !== undefined) {
+          nodes[i] = { type: "scope_marker_end", scopeId } as typeof node;
+          continue;
+        }
+      }
+
+      const children = (node as { children?: unknown }).children;
+      if (Array.isArray(children)) {
+        rewriteInPlace(children as { type?: string; [key: string]: unknown }[]);
+      }
+      const rows = (node as { rows?: unknown }).rows;
+      if (Array.isArray(rows)) {
+        rewriteInPlace(rows as { type?: string; [key: string]: unknown }[]);
+      }
+      const cells = (node as { cells?: unknown }).cells;
+      if (Array.isArray(cells)) {
+        rewriteInPlace(cells as { type?: string; [key: string]: unknown }[]);
+      }
+    }
+  };
+
+  // Two passes: collect all scope-prefixed start IDs, then rewrite both
+  // start + end occurrences. Pairing by id — scope_marker_end may appear
+  // in a later paragraph than its matching scope_marker_start.
+  scanForStarts(blocks as unknown as readonly { [key: string]: unknown }[]);
+  if (scopeBookmarkIds.size === 0) return;
+  rewriteInPlace(blocks as unknown as { [key: string]: unknown }[]);
+}
+
 function parseBodyChild(
   node: XmlElementNode,
   sourceXml: string,
@@ -1911,6 +2055,7 @@ function parseRun(
             relationships,
             mediaParts,
             sourcePartPath,
+            activeChartPartLookup,
           );
           if (complexContent) {
             result.push(complexContent);
@@ -3056,6 +3201,16 @@ export function parseSectionPropertiesFromElement(
     }
   }
 
+  // Grab-bag capture for unmodelled <w:sectPr> children (O2 Slice 4).
+  const sourceChildren = node.children
+    .filter((child): child is XmlElementNode => child.type === "element")
+    .map((child) => buildGrabBagSourceChildFromParsed(child));
+  const unknown = capturePropertyGrabBag(
+    sourceChildren,
+    SECT_PR_GRAB_BAG_DESCRIPTOR,
+  );
+  if (unknown) props.unknownPropertyChildren = unknown;
+
   return props;
 }
 

package/src/io/ooxml/parse-paragraph-formatting.ts

@@ -17,6 +17,42 @@ import type {
 import { readRunProperties } from "./parse-run-formatting.ts";
 import { findChildOptional, localName, readIntAttr, readIntVal, readOnOff } from "./xml-attr-helpers.ts";
 import type { XmlElementNode } from "./xml-element.ts";
+import {
+  buildGrabBagSourceChildFromParsed,
+  capturePropertyGrabBag,
+  type PropertyGrabBagDescriptor,
+} from "./property-grab-bag.ts";
+
+/**
+ * Modelled direct children of `<w:pPr>` that `readParagraphProperties` below
+ * dispatches into typed fields on `CanonicalParagraphFormatting`. Anything
+ * else becomes a grab-bag entry so a parse→serialize round-trip preserves
+ * extension-namespace properties like `<w15:collapsed>` or Word-internal
+ * knobs like `<w:kinsoku>` that our canonical model doesn't understand.
+ */
+const PPR_MODELLED_CHILDREN: ReadonlySet<string> = new Set([
+  "spacing",
+  "ind",
+  "jc",
+  "pBdr",
+  "shd",
+  "tabs",
+  "keepNext",
+  "keepLines",
+  "widowControl",
+  "pageBreakBefore",
+  "contextualSpacing",
+  "bidi",
+  "suppressLineNumbers",
+  "suppressAutoHyphens",
+  "outlineLvl",
+  "rPr",
+]);
+
+const PPR_GRAB_BAG_DESCRIPTOR: PropertyGrabBagDescriptor = {
+  modelledChildNames: PPR_MODELLED_CHILDREN,
+  modelledChildAttributes: new Map(),
+};
 
 function readSpacing(node: XmlElementNode): ParagraphSpacing | undefined {
   const out: ParagraphSpacing = {};
@@ -184,5 +220,15 @@ export function readParagraphProperties(
   const markRpr = readRunProperties(rPrNode);
   if (markRpr) out.paragraphMarkRunProperties = markRpr;
 
+  // Capture any unmodelled direct children of <w:pPr> so a parse→serialize
+  // round-trip does not silently drop extension-namespace properties
+  // (w15:collapsed, w16cex:..., w:kinsoku, etc.). See Lane 3 O2 plan +
+  // src/io/ooxml/property-grab-bag.ts for the pattern.
+  const sourceChildren = node.children
+    .filter((child): child is XmlElementNode => child.type === "element")
+    .map((child) => buildGrabBagSourceChildFromParsed(child));
+  const unknown = capturePropertyGrabBag(sourceChildren, PPR_GRAB_BAG_DESCRIPTOR);
+  if (unknown) out.unknownPropertyChildren = unknown;
+
   return Object.keys(out).length > 0 ? out : undefined;
 }

package/src/io/ooxml/parse-run-formatting.ts

@@ -1,6 +1,42 @@
 import type { CanonicalRunFormatting } from "../../model/canonical-document.ts";
 import { findChildOptional, readIntVal, readOnOff, readStringAttr } from "./xml-attr-helpers.ts";
 import type { XmlElementNode } from "./xml-element.ts";
+import {
+  buildGrabBagSourceChildFromParsed,
+  capturePropertyGrabBag,
+  type PropertyGrabBagDescriptor,
+} from "./property-grab-bag.ts";
+
+/**
+ * Modelled direct children of `<w:rPr>` that `readRunProperties` dispatches
+ * into typed fields on `CanonicalRunFormatting`. Anything else goes through
+ * the grab-bag helper so a parse→serialize round-trip preserves extension-
+ * namespace properties (e.g. `<w14:textOutline>`, `<w:em>`, `<w:kern>`).
+ */
+const RPR_MODELLED_CHILDREN: ReadonlySet<string> = new Set([
+  "b",
+  "i",
+  "strike",
+  "dstrike",
+  "vanish",
+  "caps",
+  "smallCaps",
+  "u",
+  "vertAlign",
+  "rFonts",
+  "sz",
+  "szCs",
+  "color",
+  "highlight",
+  "spacing",
+  "rStyle",
+  "lang",
+]);
+
+const RPR_GRAB_BAG_DESCRIPTOR: PropertyGrabBagDescriptor = {
+  modelledChildNames: RPR_MODELLED_CHILDREN,
+  modelledChildAttributes: new Map(),
+};
 
 /**
  * Read `<w:rPr>` (run properties) into a `CanonicalRunFormatting` value.
@@ -101,8 +137,14 @@ export function readRunProperties(
     const val = color.attributes["w:val"] ?? color.attributes["val"];
     const theme =
       color.attributes["w:themeColor"] ?? color.attributes["themeColor"];
+    const tint =
+      color.attributes["w:themeTint"] ?? color.attributes["themeTint"];
+    const shade =
+      color.attributes["w:themeShade"] ?? color.attributes["themeShade"];
     if (val) rPr.colorHex = val;
     if (theme) rPr.colorThemeSlot = theme;
+    if (tint) rPr.colorThemeTint = tint;
+    if (shade) rPr.colorThemeShade = shade;
   }
 
   const highlight = findChildOptional(node, "highlight");
@@ -125,5 +167,12 @@ export function readRunProperties(
     if (val) rPr.languageCode = val;
   }
 
+  // Grab-bag capture: unmodelled <w:rPr> children survive round-trip.
+  const sourceChildren = node.children
+    .filter((child): child is XmlElementNode => child.type === "element")
+    .map((child) => buildGrabBagSourceChildFromParsed(child));
+  const unknown = capturePropertyGrabBag(sourceChildren, RPR_GRAB_BAG_DESCRIPTOR);
+  if (unknown) rPr.unknownPropertyChildren = unknown;
+
   return Object.keys(rPr).length > 0 ? rPr : undefined;
 }