@beyondwork/docx-react-component 1.0.56 → 1.0.57

package/src/io/ooxml/parse-anchor.ts

@@ -0,0 +1,182 @@
+import type { AnchorGeometry } from "../../model/canonical-document.ts";
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+export function parseAnchorGeometry(container: XmlElementNode): AnchorGeometry {
+  const tag = localName(container.name);
+  const display: "inline" | "floating" = tag === "anchor" ? "floating" : "inline";
+
+  const extent = readExtent(container);
+
+  const wrapMode = readWrapMode(container);
+
+  const positionHEl = findFirstChild(container, "positionH");
+  const positionVEl = findFirstChild(container, "positionV");
+
+  const effectExtentEl = findFirstChild(container, "effectExtent");
+  const distMargins = effectExtentEl
+    ? {
+        top: readIntAttr(effectExtentEl, "t") ?? 0,
+        bottom: readIntAttr(effectExtentEl, "b") ?? 0,
+        left: readIntAttr(effectExtentEl, "l") ?? 0,
+        right: readIntAttr(effectExtentEl, "r") ?? 0,
+      }
+    : undefined;
+
+  const relativeHeight =
+    display === "floating" ? readIntAttr(container, "relativeHeight") : undefined;
+
+  const behindDoc =
+    display === "floating" ? readBoolAttr(container, "behindDoc") : undefined;
+  const layoutInCell =
+    display === "floating" ? readBoolAttr(container, "layoutInCell") : undefined;
+  const allowOverlap =
+    display === "floating" ? readBoolAttr(container, "allowOverlap") : undefined;
+  const simplePos =
+    display === "floating" ? readBoolAttr(container, "simplePos") : undefined;
+
+  const docPrEl = findFirstChild(container, "docPr");
+  const docPr = docPrEl
+    ? {
+        id: docPrEl.attributes.id ?? "",
+        ...(docPrEl.attributes.name ? { name: docPrEl.attributes.name } : {}),
+        ...(docPrEl.attributes.descr ? { descr: docPrEl.attributes.descr } : {}),
+      }
+    : undefined;
+
+  const geometry: AnchorGeometry = {
+    display,
+    extent,
+    wrapMode,
+  };
+
+  if (positionHEl) geometry.positionH = readAxisPosition(positionHEl);
+  if (positionVEl) geometry.positionV = readAxisPosition(positionVEl);
+  if (distMargins) geometry.distMargins = distMargins;
+  if (relativeHeight !== undefined) geometry.relativeHeight = relativeHeight;
+  if (behindDoc !== undefined) geometry.behindDoc = behindDoc;
+  if (layoutInCell !== undefined) geometry.layoutInCell = layoutInCell;
+  if (allowOverlap !== undefined) geometry.allowOverlap = allowOverlap;
+  if (simplePos !== undefined) geometry.simplePos = simplePos;
+  if (docPr) geometry.docPr = docPr;
+
+  return geometry;
+}
+
+function readExtent(container: XmlElementNode): AnchorGeometry["extent"] {
+  const extentEl = findFirstChild(container, "extent");
+  if (extentEl) {
+    return {
+      widthEmu: readIntAttr(extentEl, "cx") ?? 0,
+      heightEmu: readIntAttr(extentEl, "cy") ?? 0,
+    };
+  }
+
+  const transform = findFirstDescendant(container, "xfrm");
+  const shapeExtent = transform ? findFirstDescendant(transform, "ext") : undefined;
+  return {
+    widthEmu: shapeExtent ? readIntAttr(shapeExtent, "cx") ?? 0 : 0,
+    heightEmu: shapeExtent ? readIntAttr(shapeExtent, "cy") ?? 0 : 0,
+  };
+}
+
+function readWrapMode(
+  container: XmlElementNode,
+): AnchorGeometry["wrapMode"] {
+  for (const child of container.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+    if (name === "wrapNone") return "none";
+    if (name === "wrapSquare") return "square";
+    if (name === "wrapTight") return "tight";
+    if (name === "wrapThrough") return "through";
+    if (name === "wrapTopAndBottom") return "topAndBottom";
+  }
+  return "none";
+}
+
+function readAxisPosition(
+  el: XmlElementNode,
+): { relativeFrom: string; align?: string; offset?: number } {
+  const relativeFrom =
+    el.attributes.relativeFrom ?? el.attributes["wp:relativeFrom"] ?? "";
+  const alignEl = findFirstChild(el, "align");
+  const posOffsetEl = findFirstChild(el, "posOffset");
+
+  const result: { relativeFrom: string; align?: string; offset?: number } = {
+    relativeFrom,
+  };
+  if (alignEl) {
+    const text = extractText(alignEl).trim();
+    if (text) result.align = text;
+  }
+  if (posOffsetEl) {
+    const val = parseInt(extractText(posOffsetEl).trim(), 10);
+    if (Number.isFinite(val)) result.offset = val;
+  }
+  return result;
+}
+
+function findFirstChild(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type === "element" && localName(child.name) === local) return child;
+  }
+  return undefined;
+}
+
+function findFirstDescendant(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName(child.name) === local) return child;
+    const found = findFirstDescendant(child, local);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+function localName(name: string): string {
+  const i = name.indexOf(":");
+  return i >= 0 ? name.slice(i + 1) : name;
+}
+
+function extractText(node: XmlElementNode): string {
+  return node.children
+    .map((c) => (c.type === "text" ? c.text : extractText(c as XmlElementNode)))
+    .join("");
+}
+
+function readIntAttr(node: XmlElementNode, name: string): number | undefined {
+  const v = node.attributes[name] ?? node.attributes[`wp:${name}`];
+  if (v === undefined) return undefined;
+  const n = parseInt(v, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function readBoolAttr(node: XmlElementNode, name: string): boolean | undefined {
+  const v =
+    node.attributes[name] ??
+    node.attributes[`wp:${name}`] ??
+    node.attributes[`w:${name}`];
+  if (v === undefined) return undefined;
+  return v !== "0" && v !== "false";
+}
+
+export { type XmlElementNode as AnchorXmlElement };

package/src/io/ooxml/parse-drawing.ts

@@ -0,0 +1,319 @@
+import type { OpcRelationship } from "./part-manifest.ts";
+import { normalizePartPath, resolveRelationshipTarget } from "./part-manifest.ts";
+import type { InlineMediaPart } from "./parse-inline-media.ts";
+import type { ChartPartLookup } from "./parse-complex-content.ts";
+import type { DrawingFrameNode, AnchorGeometry } from "../../model/canonical-document.ts";
+import { parseAnchorGeometry } from "./parse-anchor.ts";
+import { parsePicture, type PictureXmlElement } from "./parse-picture.ts";
+import { parseShapeContent, type TxbxBlockParser } from "./parse-shapes.ts";
+
+const PICTURE_GRAPHIC_URI =
+  "http://schemas.openxmlformats.org/drawingml/2006/picture";
+const CHART_GRAPHIC_URI =
+  "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const CHART_GRAPHIC_URI_ALT =
+  "http://schemas.microsoft.com/office/drawing/2007/8/2/chart";
+const SMARTART_GRAPHIC_URI =
+  "http://schemas.microsoft.com/office/drawing/2007/8/2/diagram";
+const SMARTART_GRAPHIC_URI_ALT =
+  "http://schemas.openxmlformats.org/drawingml/2006/diagram";
+const WPS_SHAPE_GRAPHIC_URI =
+  "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+
+export interface ParseDrawingOpts {
+  relationships: readonly OpcRelationship[];
+  mediaParts?: ReadonlyMap<string, InlineMediaPart>;
+  sourcePartPath?: string;
+  chartPartLookup?: ChartPartLookup;
+  /**
+   * CO4 F3.3 — optional recursive parser for `w:txbxContent`. When supplied,
+   * parseDrawingFrame forwards it to parseShapeContent so shape text-boxes
+   * get fully-parsed block structure on `ShapeContent.txbxBlocks`. Without it
+   * only `txbxContentXml` raw preservation is populated.
+   */
+  blockParser?: TxbxBlockParser;
+}
+
+export function parseDrawingFrame(
+  drawingXml: string,
+  opts: ParseDrawingOpts,
+): DrawingFrameNode | null {
+  const root = parseXml(drawingXml);
+
+  // F3.1: unwrap mc:AlternateContent to its Choice branch (preferred) or Fallback.
+  // Real-world Word output wraps nearly every w:drawing in AlternateContent. The
+  // branch we pick determines which anchor/graphicData we descend into.
+  const searchRoot = pickAlternateContentBranch(root);
+
+  // Find wp:anchor or wp:inline in the chosen branch
+  const anchor = findFirstDescendant(searchRoot, "anchor");
+  const inline = findFirstDescendant(searchRoot, "inline");
+  const container = anchor ?? inline;
+  if (!container) return null;
+
+  const geometry: AnchorGeometry = parseAnchorGeometry(container as never);
+
+  // Locate a:graphicData to determine content type
+  const graphicData = findFirstDescendant(searchRoot, "graphicData");
+  const uri = graphicData?.attributes.uri ?? "";
+
+  // F3.5: if we don't recognise the graphicData URI, return null and let the
+  // legacy parse chain (parseComplexContentXml / parseShapeXml / parseVmlXml /
+  // parseInlineMediaXml) handle it. The new DrawingFrameNode path only
+  // short-circuits for known URIs.
+  if (!isKnownUri(uri)) return null;
+  // WordArt remains on the dedicated legacy `wordart` node path. Only
+  // non-WordArt WPS drawings are promoted into DrawingFrame shape content.
+  if (uri === WPS_SHAPE_GRAPHIC_URI && isWordArtGraphicData(graphicData)) return null;
+
+  const content = resolveContent(uri, graphicData, drawingXml, opts);
+
+  return { type: "drawing_frame", anchor: geometry, content };
+}
+
+function isKnownUri(uri: string): boolean {
+  return (
+    uri === PICTURE_GRAPHIC_URI ||
+    uri === CHART_GRAPHIC_URI ||
+    uri === CHART_GRAPHIC_URI_ALT ||
+    uri === SMARTART_GRAPHIC_URI ||
+    uri === SMARTART_GRAPHIC_URI_ALT ||
+    uri === WPS_SHAPE_GRAPHIC_URI
+  );
+}
+
+function isWordArtGraphicData(graphicData: XmlElementNode | undefined): boolean {
+  if (!graphicData) return false;
+  const wsp = findFirstDescendant(graphicData, "wsp");
+  const spPr = wsp ? findFirstChild(wsp, "spPr") : undefined;
+  const prstGeom = spPr ? findFirstChild(spPr, "prstGeom") : undefined;
+  const geometry = prstGeom?.attributes.prst ?? "";
+  return /^text/i.test(geometry);
+}
+
+/**
+ * If the drawing is wrapped in mc:AlternateContent, return the chosen branch
+ * subtree. Prefer Choice (richer content); use Fallback only when Choice
+ * contains no graphicData we can parse.
+ */
+function pickAlternateContentBranch(root: XmlElementNode): XmlElementNode {
+  const alt = findFirstDescendant(root, "AlternateContent");
+  if (!alt) return root;
+
+  const choice = findFirstChild(alt, "Choice");
+  const fallback = findFirstChild(alt, "Fallback");
+
+  if (choice) {
+    const choiceGraphicData = findFirstDescendant(choice, "graphicData");
+    const choiceUri = choiceGraphicData?.attributes.uri ?? "";
+    if (isKnownUri(choiceUri)) return choice;
+  }
+
+  if (fallback) {
+    const fallbackGraphicData = findFirstDescendant(fallback, "graphicData");
+    const fallbackUri = fallbackGraphicData?.attributes.uri ?? "";
+    if (isKnownUri(fallbackUri)) return fallback;
+  }
+
+  // Neither branch has a known URI — return Choice (if any) so caller can emit
+  // opaque preservation; otherwise the original root.
+  return choice ?? fallback ?? root;
+}
+
+function resolveContent(
+  uri: string,
+  graphicData: XmlElementNode | undefined,
+  rawXml: string,
+  opts: ParseDrawingOpts,
+): DrawingFrameNode["content"] {
+  if (uri === PICTURE_GRAPHIC_URI) {
+    if (graphicData) {
+      const pic = parsePicture(graphicData as PictureXmlElement);
+      if (pic) {
+        // Resolve mediaId from the relationship map
+        const relMap = new Map(opts.relationships.map((r) => [r.id, r]));
+        const rel = relMap.get(pic.blipRef);
+        if (rel?.type.endsWith("/image")) {
+          const partPath = normalizePartPath(
+            resolveRelationshipTarget(opts.sourcePartPath ?? "/word/document.xml", rel),
+          );
+          pic.packagePartName = partPath;
+          pic.mediaId = `media:${partPath.slice(1)}`;
+        }
+        // F4.1 — preserve outer drawing XML for lossless round-trip serialization
+        pic.rawXml = rawXml;
+        return pic;
+      }
+    }
+    return { type: "opaque", rawXml };
+  }
+  if (uri === CHART_GRAPHIC_URI || uri === CHART_GRAPHIC_URI_ALT) {
+    return { type: "chart_preview", rawXml };
+  }
+  if (uri === SMARTART_GRAPHIC_URI || uri === SMARTART_GRAPHIC_URI_ALT) {
+    return { type: "smartart_preview", rawXml };
+  }
+  if (uri === WPS_SHAPE_GRAPHIC_URI) {
+    if (graphicData) {
+      const shape = parseShapeContent(
+        graphicData as PictureXmlElement,
+        rawXml,
+        opts.blockParser,
+      );
+      if (shape) return shape;
+    }
+    return { type: "opaque", rawXml };
+  }
+  void graphicData;
+  return { type: "opaque", rawXml };
+}
+
+// ── Minimal self-contained XML parser ──────────────────────────────────────
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+function findFirstChild(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type === "element" && localName(child.name) === local) return child;
+  }
+  return undefined;
+}
+
+function findFirstDescendant(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName(child.name) === local) return child;
+    const found = findFirstDescendant(child, local);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+function localName(name: string): string {
+  const i = name.indexOf(":");
+  return i >= 0 ? name.slice(i + 1) : name;
+}
+
+function parseXml(xml: string): XmlElementNode {
+  const root: XmlElementNode = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+  };
+  const stack: XmlElementNode[] = [root];
+  let cursor = 0;
+
+  while (cursor < xml.length) {
+    if (xml.startsWith("<!--", cursor)) {
+      const end = xml.indexOf("-->", cursor);
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+    if (xml.startsWith("<?", cursor)) {
+      const end = xml.indexOf("?>", cursor);
+      cursor = end >= 0 ? end + 2 : xml.length;
+      continue;
+    }
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeEntities(xml.slice(cursor, end));
+      if (text) stack[stack.length - 1]?.children.push({ type: "text", text });
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      stack.pop();
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
+    const el: XmlElementNode = { type: "element", name, attributes, children: [] };
+    stack[stack.length - 1]?.children.push(el);
+    if (!selfClosing) stack.push(el);
+    cursor = tagEnd + 1;
+  }
+
+  return root;
+}
+
+function findTagEnd(xml: string, start: number): number {
+  let cursor = start + 1;
+  let quote: string | null = null;
+  while (cursor < xml.length) {
+    const ch = xml[cursor];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === `"` || ch === `'`) {
+      quote = ch;
+    } else if (ch === ">") {
+      return cursor;
+    }
+    cursor++;
+  }
+  return xml.length - 1;
+}
+
+function parseTag(body: string): { name: string; attributes: Record<string, string> } {
+  let i = 0;
+  while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+  const nameStart = i;
+  while (i < body.length && !/\s/.test(body[i] ?? "")) i++;
+  const name = body.slice(nameStart, i);
+  const attributes: Record<string, string> = {};
+  while (i < body.length) {
+    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+    if (i >= body.length) break;
+    const kStart = i;
+    while (i < body.length && !/[\s=]/.test(body[i] ?? "")) i++;
+    const key = body.slice(kStart, i);
+    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+    if (body[i] !== "=") { attributes[key] = ""; continue; }
+    i++;
+    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+    const q = body[i];
+    if (q !== `"` && q !== `'`) throw new Error(`Bad attr ${key}`);
+    i++;
+    const vStart = i;
+    while (i < body.length && body[i] !== q) i++;
+    attributes[key] = decodeEntities(body.slice(vStart, i));
+    i++;
+  }
+  return { name, attributes };
+}
+
+function decodeEntities(s: string): string {
+  return s.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (_, e) => {
+    if (e === "amp") return "&";
+    if (e === "lt") return "<";
+    if (e === "gt") return ">";
+    if (e === "quot") return `"`;
+    if (e === "apos") return "'";
+    if (e.startsWith("#x")) return String.fromCodePoint(parseInt(e.slice(2), 16));
+    if (e.startsWith("#")) return String.fromCodePoint(parseInt(e.slice(1), 10));
+    return `&${e};`;
+  });
+}

package/src/io/ooxml/parse-fields.ts

@@ -146,6 +146,117 @@ export function extractBookmarksFromBodyXml(bodyXml: string): ParsedBookmarkNode
   return results;
 }
 
+// ─── FieldGroup stream walker ─────────────────────────────────────────────────
+
+/**
+ * A fully-parsed fldChar triad: begin → instrText* → separate → display → end.
+ * Unlike `ParsedComplexFieldNode`, this captures cross-paragraph triads by
+ * walking the body-level run list flattened across all block elements.
+ *
+ * Fail-closed: an incomplete triad (begin with no end) is silently discarded.
+ */
+export interface FieldGroup {
+  /** Joined instrText content (trimmed). */
+  instruction: string;
+  /** Raw XML of all runs between the separate and end fldChar runs. */
+  displayContent: string;
+  /** Byte offset in sourceXml where the begin run starts. */
+  start: number;
+  /** Byte offset (exclusive) where the end run ends. */
+  end: number;
+}
+
+/**
+ * Stream-walk all block elements in a body XML string and emit one
+ * `FieldGroup` per complete fldChar triad.  Handles cross-paragraph
+ * triads (e.g., TOC fields that span multiple <w:p> siblings).
+ *
+ * Fail-closed: a begin with no matching end is silently dropped.
+ */
+export function streamWalkFieldGroups(bodyXml: string): FieldGroup[] {
+  const root = parseXml(bodyXml);
+  const bodyEl =
+    findFirstChild(root, "body") ??
+    findFirstChild(root, "document") ??
+    root;
+
+  const allRuns: XmlElementNode[] = [];
+  collectRunsDeep(bodyEl, allRuns);
+
+  return extractFieldGroupsFromRuns(allRuns, bodyXml);
+}
+
+function collectRunsDeep(node: XmlElementNode, out: XmlElementNode[]): void {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName(child.name) === "r") {
+      out.push(child);
+    } else {
+      collectRunsDeep(child, out);
+    }
+  }
+}
+
+function extractFieldGroupsFromRuns(
+  runs: XmlElementNode[],
+  sourceXml: string,
+): FieldGroup[] {
+  type State = "idle" | "in-instr" | "in-content";
+  let state: State = "idle";
+  let instrParts: string[] = [];
+  let fieldStart = -1;
+  let contentStart = -1;
+  const results: FieldGroup[] = [];
+
+  for (const run of runs) {
+    const fldChar = findFirstChildEl(run, "fldChar");
+    const instrText = findFirstChildEl(run, "instrText");
+
+    if (fldChar) {
+      const charType = (
+        fldChar.attributes["w:fldCharType"] ??
+        fldChar.attributes.fldCharType ??
+        ""
+      ).toLowerCase();
+
+      if (charType === "begin") {
+        state = "in-instr";
+        instrParts = [];
+        fieldStart = run.start;
+        contentStart = -1;
+      } else if (charType === "separate" && state === "in-instr") {
+        state = "in-content";
+        contentStart = run.end;
+      } else if (charType === "end") {
+        if (state === "in-content" || state === "in-instr") {
+          const displayContent =
+            contentStart >= 0 && contentStart <= run.start
+              ? sourceXml.slice(contentStart, run.start)
+              : "";
+          results.push({
+            instruction: instrParts.join("").trim(),
+            displayContent,
+            start: fieldStart,
+            end: run.end,
+          });
+        }
+        state = "idle";
+        instrParts = [];
+        fieldStart = -1;
+        contentStart = -1;
+      }
+    } else if (instrText && state === "in-instr") {
+      const text = instrText.children
+        .filter((c): c is XmlTextNode => c.type === "text")
+        .map((c) => c.text)
+        .join("");
+      instrParts.push(text);
+    }
+  }
+
+  return results;
+}
+
 // ─── Element-level parsers (exported for unit testing) ────────────────────────
 
 export function parseFldSimple(
@@ -309,7 +420,7 @@ export function buildFieldRegistry(
     paragraphIndex = pIdx;
     if (node.type === "field") {
       const classification = node.fieldFamily
-        ? { family: node.fieldFamily, supported: isSupportedFieldFamily(node.fieldFamily), target: node.fieldTarget }
+        ? { family: node.fieldFamily, supported: isSupportedFieldFamily(node.fieldFamily), target: node.fieldTarget, switches: node.switches }
         : classifyFieldInstruction(node.instruction);
       const displayText = flattenFieldText(node.children);
       const entry: FieldRegistryEntry = {
@@ -321,6 +432,7 @@ export function buildFieldRegistry(
         displayText,
         paragraphIndex,
         refreshStatus: node.refreshStatus ?? (classification.supported ? "stale" : "preserve-only"),
+        ...(classification.switches ? { switches: classification.switches } : {}),
       };
       if (classification.supported) {
         supported.push(entry);
@@ -338,7 +450,7 @@ export function buildFieldRegistry(
       paragraphIndex = pIdx;
       if (node.type === "field") {
         const classification = node.fieldFamily
-          ? { family: node.fieldFamily, supported: isSupportedFieldFamily(node.fieldFamily), target: node.fieldTarget }
+          ? { family: node.fieldFamily, supported: isSupportedFieldFamily(node.fieldFamily), target: node.fieldTarget, switches: node.switches }
           : classifyFieldInstruction(node.instruction);
         const displayText = flattenFieldText(node.children);
         const entry: FieldRegistryEntry = {
@@ -350,6 +462,7 @@ export function buildFieldRegistry(
           displayText,
           paragraphIndex,
           refreshStatus: node.refreshStatus ?? (classification.supported ? "stale" : "preserve-only"),
+          ...(classification.switches ? { switches: classification.switches } : {}),
         };
         if (classification.supported) {
           supported.push(entry);