@beyondwork/docx-react-component 1.0.106 → 1.0.108

package/src/runtime/layout/project-block-fragments.ts

@@ -24,14 +24,22 @@ import type {
   EditorSurfaceSnapshot,
   SurfaceBlockSnapshot,
 } from "../../api/public-types";
+import type {
+  CanonicalFieldRegionIdentity,
+} from "../../model/canonical-layout-inputs.ts";
 import type { RuntimeBlockFragment } from "./page-graph.ts";
-import type { RuntimeLineBox } from "../../model/layout/page-graph-types.ts";
+import type {
+  RuntimeFieldRegionLayoutFacts,
+  RuntimeLineBox,
+  RuntimeNumberingLayoutFacts,
+} from "../../model/layout/page-graph-types.ts";
 import type {
   BlockSplits,
   FragmentMeasurement,
   ParagraphLineSlice,
   TableRowSlice,
 } from "./paginated-layout-engine.ts";
+import { collectSplitRowCarryForPage } from "./table-row-continuation-contract.ts";
 
 type FragmentWithoutPageId = Omit<RuntimeBlockFragment, "pageId">;
 
@@ -41,9 +49,11 @@ export function projectSurfaceBlocksToPageFragments(
   splits?: BlockSplits,
   columnByBlockIdByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, number>>,
   fragmentMeasurementsByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, FragmentMeasurement>>,
+  fieldRegions: readonly CanonicalFieldRegionIdentity[] = [],
 ): Map<number, FragmentWithoutPageId[]> {
   const byPage = new Map<number, FragmentWithoutPageId[]>();
   const perPageCounter = new Map<number, number>();
+  const fieldRegionsByParagraphIndex = buildFieldRegionsByParagraphIndex(fieldRegions);
 
   const pushFragment = (
     pageIndex: number,
@@ -74,7 +84,9 @@ export function projectSurfaceBlocksToPageFragments(
     fragmentMeasurementsByPageIndex?.get(pageIndex)?.get(blockId)?.heightTwips ??
     fallback;
 
-  for (const block of surface.blocks) {
+  for (let blockIndex = 0; blockIndex < surface.blocks.length; blockIndex += 1) {
+    const block = surface.blocks[blockIndex]!;
+    const blockPath = `main/block[${blockIndex}]`;
     // R3: table split across pages — emit one fragment per row slice.
     // Consumers read `tableRowRange` and prepend header rows when from > 0.
     if (block.kind === "table") {
@@ -93,9 +105,11 @@ export function projectSurfaceBlocksToPageFragments(
                 ? { columnIndex: fragment.columnIndex }
                 : columnIndex !== undefined
                   ? { columnIndex }
-                  : {}),
+                : {}),
             });
           },
+          fieldRegionsByParagraphIndex,
+          blockPath,
         );
         continue;
       }
@@ -116,6 +130,8 @@ export function projectSurfaceBlocksToPageFragments(
             ...(columnIndex !== undefined ? { columnIndex } : {}),
           });
         },
+        fieldRegionsByParagraphIndex,
+        blockPath,
       );
       continue;
     }
@@ -150,6 +166,8 @@ export function projectSurfaceBlocksToPageFragments(
         heightTwips,
         widthTwips,
         paginationRole: "whole",
+        fieldRegionsByParagraphIndex,
+        blockPath,
       }),
       ...(columnIndex !== undefined ? { columnIndex } : {}),
     };
@@ -232,6 +250,8 @@ function emitSlicedParagraph(
   block: SurfaceBlockSnapshot,
   slices: readonly ParagraphLineSlice[],
   emit: (pageIndex: number, fragment: FragmentWithoutPageId) => void,
+  fieldRegionsByParagraphIndex: ReadonlyMap<number, readonly CanonicalFieldRegionIdentity[]> = new Map(),
+  blockPath?: string,
 ): void {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i]!;
@@ -254,6 +274,8 @@ function emitSlicedParagraph(
         heightTwips,
         widthTwips: slice.widthTwips,
         paginationRole: slice.lineRange.from > 0 ? "continuation" : "slice",
+        fieldRegionsByParagraphIndex,
+        blockPath,
       }),
     };
     emit(slice.pageIndex, fragment);
@@ -297,6 +319,8 @@ function emitSlicedTable(
   block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
   slices: readonly TableRowSlice[],
   emit: (pageIndex: number, fragment: FragmentWithoutPageId) => void,
+  fieldRegionsByParagraphIndex: ReadonlyMap<number, readonly CanonicalFieldRegionIdentity[]> = new Map(),
+  blockPath?: string,
 ): void {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i]!;
@@ -312,12 +336,14 @@ function emitSlicedTable(
       ...deriveStyleMetadata(block),
       kind: "table-slice",
       tableRowRange: slice.rowRange,
-      continuation: buildTableContinuationCursor(block, slice, i, slices.length),
+      continuation: buildTableContinuationCursor(block, slices, i),
       layoutObject: buildFragmentLayoutObject({
         block,
         fragmentId: `fragment-${block.blockId}-rowslice-${i}`,
         heightTwips,
         paginationRole: slice.rowRange.from > 0 ? "continuation" : "slice",
+        fieldRegionsByParagraphIndex,
+        blockPath,
       }),
       ...(slice.columnIndex !== undefined ? { columnIndex: slice.columnIndex } : {}),
     };
@@ -327,14 +353,15 @@ function emitSlicedTable(
 
 function buildTableContinuationCursor(
   block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
-  slice: TableRowSlice,
+  slices: readonly TableRowSlice[],
   sequenceIndex: number,
-  sliceCount: number,
 ): NonNullable<RuntimeBlockFragment["continuation"]> {
+  const slice = slices[sequenceIndex]!;
+  const splitRowCarry = collectSplitRowCarryForPage(slices, sequenceIndex);
   return {
     kind: "table",
     sequenceIndex,
-    sliceCount,
+    sliceCount: slices.length,
     rowRange: slice.rowRange,
     continuesFromPreviousPage: slice.rowRange.from > 0,
     continuesToNextPage: slice.rowRange.to < slice.rowRange.totalRows,
@@ -342,6 +369,7 @@ function buildTableContinuationCursor(
       slice.rowRange.from > 0
         ? collectRepeatedHeaderRowIndexes(block, slice.rowRange.from)
         : [],
+    ...(splitRowCarry.length > 0 ? { splitRowCarry } : {}),
     verticalMergeCarry: collectVerticalMergeCarry(block, slice.rowRange.from),
   };
 }
@@ -423,9 +451,18 @@ function buildFragmentLayoutObject(input: {
   heightTwips: number;
   widthTwips?: number;
   paginationRole: NonNullable<RuntimeBlockFragment["layoutObject"]>["paginationRole"];
+  fieldRegionsByParagraphIndex?: ReadonlyMap<number, readonly CanonicalFieldRegionIdentity[]>;
+  blockPath?: string;
 }): NonNullable<RuntimeBlockFragment["layoutObject"]> {
   const fieldFamilies = collectFieldFamilies(input.block);
   const kind = resolveFragmentLayoutObjectKind(input.block, fieldFamilies);
+  const numberingRows = collectNumberingLayoutFactsForBlock(input.block, input.blockPath);
+  const numbering = input.block.kind === "paragraph" ? numberingRows[0] : undefined;
+  const fieldRegions = collectFieldRegionLayoutFacts(
+    input.block,
+    input.fragmentId,
+    input.fieldRegionsByParagraphIndex,
+  );
   return {
     objectId: `${kind}:${input.fragmentId}`,
     kind,
@@ -438,6 +475,9 @@ function buildFragmentLayoutObject(input: {
         : {}),
     },
     ...(fieldFamilies.length > 0 ? { fieldFamilies } : {}),
+    ...(fieldRegions.length > 0 ? { fieldRegions } : {}),
+    ...(numbering ? { numbering } : {}),
+    ...(numberingRows.length > 0 ? { numberingRows } : {}),
   };
 }
 
@@ -470,6 +510,224 @@ function collectFieldFamilies(block: SurfaceBlockSnapshot): string[] {
   return families;
 }
 
+function buildFieldRegionsByParagraphIndex(
+  regions: readonly CanonicalFieldRegionIdentity[],
+): Map<number, CanonicalFieldRegionIdentity[]> {
+  const byParagraph = new Map<number, CanonicalFieldRegionIdentity[]>();
+  for (const region of regions) {
+    const bucket = byParagraph.get(region.paragraphIndex);
+    if (bucket) bucket.push(region);
+    else byParagraph.set(region.paragraphIndex, [region]);
+  }
+  return byParagraph;
+}
+
+function collectFieldRegionLayoutFacts(
+  block: SurfaceBlockSnapshot,
+  fragmentId: string,
+  fieldRegionsByParagraphIndex:
+    | ReadonlyMap<number, readonly CanonicalFieldRegionIdentity[]>
+    | undefined,
+): RuntimeFieldRegionLayoutFacts[] {
+  if (!fieldRegionsByParagraphIndex || fieldRegionsByParagraphIndex.size === 0) {
+    return [];
+  }
+
+  const paragraphIndexes = collectParagraphIndexesForBlock(block);
+  if (paragraphIndexes.length === 0) return [];
+
+  const facts: RuntimeFieldRegionLayoutFacts[] = [];
+  const seen = new Set<string>();
+  for (const paragraphIndex of paragraphIndexes) {
+    for (const region of fieldRegionsByParagraphIndex.get(paragraphIndex) ?? []) {
+      const fieldRegionId = `field-region:${region.canonicalFieldId}`;
+      const key = `${fieldRegionId}:${fragmentId}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      facts.push(toRuntimeFieldRegionLayoutFacts(region, fieldRegionId));
+    }
+  }
+  return facts;
+}
+
+function collectParagraphIndexesForBlock(block: SurfaceBlockSnapshot): number[] {
+  const indexes: number[] = [];
+  visitParagraphBlocks(block, (paragraph) => {
+    const index = parseParagraphBlockIndex(paragraph.blockId);
+    if (index !== undefined) indexes.push(index);
+  });
+  return indexes;
+}
+
+function visitParagraphBlocks(
+  block: SurfaceBlockSnapshot,
+  visit: (
+    paragraph: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+    context: { readonly path?: string },
+  ) => void,
+  path?: string,
+): void {
+  switch (block.kind) {
+    case "paragraph":
+      visit(block, path !== undefined ? { path } : {});
+      return;
+    case "table":
+      for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+        const row = block.rows[rowIndex]!;
+        for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+          const cell = row.cells[cellIndex]!;
+          for (let childIndex = 0; childIndex < cell.content.length; childIndex += 1) {
+            const child = cell.content[childIndex]!;
+            visitParagraphBlocks(
+              child,
+              visit,
+              path !== undefined
+                ? `${path}/row[${rowIndex}]/cell[${cellIndex}]/block[${childIndex}]`
+                : undefined,
+            );
+          }
+        }
+      }
+      return;
+    case "sdt_block":
+      for (let childIndex = 0; childIndex < block.children.length; childIndex += 1) {
+        const child = block.children[childIndex]!;
+        visitParagraphBlocks(
+          child,
+          visit,
+          path !== undefined ? `${path}/block[${childIndex}]` : undefined,
+        );
+      }
+      return;
+    case "opaque_block":
+      return;
+  }
+}
+
+function parseParagraphBlockIndex(blockId: string): number | undefined {
+  const match = /^paragraph-(\d+)$/.exec(blockId);
+  return match ? Number(match[1]) : undefined;
+}
+
+function toRuntimeFieldRegionLayoutFacts(
+  region: CanonicalFieldRegionIdentity,
+  fieldRegionId: string,
+): RuntimeFieldRegionLayoutFacts {
+  return {
+    fieldRegionId,
+    regionId: region.regionId,
+    canonicalFieldId: region.canonicalFieldId,
+    regionKind: region.kind,
+    storyKey: region.storyKey,
+    fieldIndex: region.fieldIndex,
+    paragraphIndex: region.paragraphIndex,
+    fieldFamily: region.fieldFamily,
+    refreshStatus: region.refreshStatus,
+    ...(region.sourceRef !== undefined ? { sourceRef: { ...region.sourceRef } } : {}),
+    ...(region.fieldEvidence !== undefined
+      ? {
+          fieldEvidence: {
+            ...region.fieldEvidence,
+            ...(region.fieldEvidence.sourceRef !== undefined
+              ? { sourceRef: { ...region.fieldEvidence.sourceRef } }
+              : {}),
+          },
+        }
+      : {}),
+  };
+}
+
+function collectNumberingLayoutFacts(
+  block: SurfaceBlockSnapshot,
+): RuntimeNumberingLayoutFacts | undefined {
+  if (block.kind !== "paragraph") return undefined;
+  if (!block.numbering && !block.resolvedNumbering && block.numberingPrefix === undefined) {
+    return undefined;
+  }
+
+  const markerLane = block.resolvedNumbering?.geometry.markerLane;
+  const textColumn = block.resolvedNumbering?.geometry.textColumn;
+  const tabStops = block.resolvedNumbering?.geometry.tabStops;
+  return {
+    ...(block.numbering?.numberingInstanceId !== undefined
+      ? { numberingInstanceId: block.numbering.numberingInstanceId }
+      : {}),
+    ...(block.numbering?.level !== undefined ? { level: block.numbering.level } : {}),
+    ...(block.resolvedNumbering?.format !== undefined
+      ? { format: block.resolvedNumbering.format }
+      : {}),
+    ...(block.numberingPrefix !== undefined ? { markerText: block.numberingPrefix } : {}),
+    ...(block.numberingSuffix !== undefined ? { markerSuffix: block.numberingSuffix } : {}),
+    ...(block.resolvedNumbering?.geometry.markerJustification !== undefined
+      ? { markerJustification: block.resolvedNumbering.geometry.markerJustification }
+      : {}),
+    ...(markerLane
+      ? {
+          markerLane: {
+            startTwips: markerLane.start,
+            widthTwips: markerLane.width,
+            textStartTwips: markerLane.textStart,
+          },
+        }
+      : {}),
+    ...(textColumn
+      ? {
+          textColumn: {
+            startTwips: textColumn.start,
+            ...(textColumn.right !== undefined ? { rightTwips: textColumn.right } : {}),
+            ...(textColumn.firstLine !== undefined
+              ? { firstLineTwips: textColumn.firstLine }
+              : {}),
+            ...(textColumn.hanging !== undefined ? { hangingTwips: textColumn.hanging } : {}),
+          },
+        }
+      : {}),
+    ...(tabStops && tabStops.length > 0
+      ? {
+          tabStops: tabStops.map((tab) => ({
+            positionTwips: tab.pos,
+            ...(tab.val !== undefined ? { align: tab.val } : {}),
+            ...(tab.leader !== undefined ? { leader: tab.leader } : {}),
+          })),
+        }
+      : {}),
+  };
+}
+
+function collectNumberingLayoutFactsForBlock(
+  block: SurfaceBlockSnapshot,
+  blockPath?: string,
+): RuntimeNumberingLayoutFacts[] {
+  const rows: RuntimeNumberingLayoutFacts[] = [];
+  const seen = new Set<string>();
+  visitParagraphBlocks(block, (paragraph, context) => {
+    const numbering = collectNumberingLayoutFacts(paragraph);
+    if (!numbering) return;
+    const paragraphIndex = parseParagraphBlockIndex(paragraph.blockId);
+    const numberingKey =
+      context.path !== undefined ? `main:${context.path}:numbering` : undefined;
+    const numberingLayoutId =
+      numberingKey ??
+      [
+        "numbering",
+        paragraph.blockId,
+        numbering.numberingInstanceId ?? "unknown-instance",
+        numbering.level ?? "unknown-level",
+      ].join(":");
+    if (seen.has(numberingLayoutId)) return;
+    seen.add(numberingLayoutId);
+    rows.push({
+      numberingLayoutId,
+      ...(numberingKey !== undefined ? { numberingKey } : {}),
+      ...(context.path !== undefined ? { sourceBlockPath: context.path } : {}),
+      sourceBlockId: paragraph.blockId,
+      ...(paragraphIndex !== undefined ? { paragraphIndex } : {}),
+      ...numbering,
+    });
+  }, blockPath);
+  return rows;
+}
+
 function findPageIndexForOffset(
   pages: readonly DocumentPageSnapshot[],
   offset: number,

package/src/runtime/layout/public-facet.ts

@@ -91,6 +91,7 @@ import { resolvePageFieldDisplayText } from "./resolve-page-fields.ts";
 //    `runtime.workflow.*`; the layout facet supplies the page graph
 //    as input, not the rail output.
 import { collectLineBoxesForRegion } from "../geometry/project-fragments.ts";
+import { emitLayoutGuardWarning } from "../diagnostics/layout-guard-warning.ts";
 // `recordPerfSample` no longer imported — used only by the removed
 // `hitTest` wrapper to emit `chrome.hit_test` samples. Geometry facet
 // can add its own instrumentation at call site if needed.
@@ -112,26 +113,11 @@ export type { ScopeRailSegment };
 // Module-level warning emitter (D1 silent-success probes)
 // ---------------------------------------------------------------------------
 
-type LayoutWarningEmitter = (type: string, guard: string, inputs: Record<string, unknown>) => void;
-let _activeLayoutWarningEmitter: LayoutWarningEmitter | undefined;
-
-export function setActiveLayoutWarningEmitter(fn: LayoutWarningEmitter | undefined): void {
-  _activeLayoutWarningEmitter = fn;
-}
-
-/**
- * Exported so debug-infra D1 probes at layout-semantic guards that have
- * physically moved into `src/runtime/geometry/**` (Slice 2a+ of refactor/05)
- * can continue to emit through the same `setActiveLayoutWarningEmitter`
- * pipeline as the remaining in-facet probes. The emit surface is unchanged;
- * only the call-site location moved.
- */
-export function emitLayoutGuardWarning(
-  guard: string,
-  inputs: Record<string, unknown>,
-): void {
-  _activeLayoutWarningEmitter?.(`layout.guard.return-empty`, guard, inputs);
-}
+export {
+  emitLayoutGuardWarning,
+  setActiveLayoutWarningEmitter,
+  type LayoutWarningEmitter,
+} from "../diagnostics/layout-guard-warning.ts";
 
 // ---------------------------------------------------------------------------
 // Public read model types (shape-stable, cloned at the facet boundary)
@@ -152,6 +138,7 @@ export interface PublicLayoutDivergence {
   message: string;
   regionKinds?: readonly RuntimePageRegion["kind"][];
   fragmentIds?: readonly string[];
+  objectIds?: readonly string[];
 }
 
 export interface PublicPageFrame {
@@ -160,6 +147,7 @@ export interface PublicPageFrame {
   pageIndex: number;
   sectionIndex: number;
   displayPageNumber: number;
+  completeness: RuntimePageFrame["completeness"];
   physicalBoundsTwips: PublicTwipsRect;
   divergenceIds: readonly string[];
   signature: string;
@@ -180,20 +168,29 @@ export interface PublicPageLocalStoryInstance {
   variant: "default" | "first" | "even" | "odd";
   relationshipId: string;
   sectionIndex?: number;
+  resolvedFields: readonly PublicResolvedStoryField[];
   anchoredObjects: readonly PublicStoryAnchoredObject[];
   measuredFrameHeightTwips: number;
   signature: string;
 }
 
+export interface PublicResolvedStoryField {
+  fieldId: string;
+  family: string;
+  displayText: string;
+}
+
 export interface PublicStoryAnchoredObject {
   objectId: string;
   sourceType: RuntimeStoryAnchoredObject["sourceType"];
   display: RuntimeStoryAnchoredObject["display"];
+  wrapMode?: RuntimeStoryAnchoredObject["wrapMode"];
   extentTwips?: {
     widthTwips: number;
     heightTwips: number;
   };
   relationshipIds?: readonly string[];
+  mediaIds?: readonly string[];
   preserveOnly: boolean;
   divergenceIds: readonly string[];
 }
@@ -1503,6 +1500,7 @@ function toPublicPageFrame(frame: RuntimePageFrame): PublicPageFrame {
     pageIndex: frame.pageIndex,
     sectionIndex: frame.sectionIndex,
     displayPageNumber: frame.displayPageNumber,
+    completeness: frame.completeness,
     physicalBoundsTwips: toPublicTwipsRect(frame.physicalBoundsTwips),
     divergenceIds: [...frame.divergenceIds],
     signature: frame.signature,
@@ -1523,12 +1521,23 @@ function toPublicPageLocalStory(
     variant: story.variant,
     relationshipId: story.relationshipId,
     ...(story.sectionIndex !== undefined ? { sectionIndex: story.sectionIndex } : {}),
+    resolvedFields: story.resolvedFields.map(toPublicResolvedStoryField),
     anchoredObjects: story.anchoredObjects.map(toPublicStoryAnchoredObject),
     measuredFrameHeightTwips: story.measuredFrameHeightTwips,
     signature: story.signature,
   };
 }
 
+function toPublicResolvedStoryField(
+  field: RuntimePageFrame["pageLocalStories"][number]["resolvedFields"][number],
+): PublicResolvedStoryField {
+  return {
+    fieldId: field.fieldId,
+    family: field.family,
+    displayText: field.displayText,
+  };
+}
+
 function toPublicStoryAnchoredObject(
   object: RuntimeStoryAnchoredObject,
 ): PublicStoryAnchoredObject {
@@ -1536,6 +1545,7 @@ function toPublicStoryAnchoredObject(
     objectId: object.objectId,
     sourceType: object.sourceType,
     display: object.display,
+    ...(object.wrapMode !== undefined ? { wrapMode: object.wrapMode } : {}),
     ...(object.extentTwips
       ? {
           extentTwips: {
@@ -1545,6 +1555,7 @@ function toPublicStoryAnchoredObject(
         }
       : {}),
     ...(object.relationshipIds ? { relationshipIds: [...object.relationshipIds] } : {}),
+    ...(object.mediaIds ? { mediaIds: [...object.mediaIds] } : {}),
     preserveOnly: object.preserveOnly,
     divergenceIds: [...object.divergenceIds],
   };
@@ -1561,6 +1572,7 @@ function toPublicLayoutDivergence(
     message: divergence.message,
     ...(divergence.regionKinds !== undefined ? { regionKinds: [...divergence.regionKinds] } : {}),
     ...(divergence.fragmentIds !== undefined ? { fragmentIds: [...divergence.fragmentIds] } : {}),
+    ...(divergence.objectIds !== undefined ? { objectIds: [...divergence.objectIds] } : {}),
   };
 }
 
@@ -1644,6 +1656,9 @@ function cloneContinuationCursor(
     ...cursor,
     rowRange: { ...cursor.rowRange },
     repeatedHeaderRowIndexes: [...cursor.repeatedHeaderRowIndexes],
+    ...(cursor.splitRowCarry
+      ? { splitRowCarry: cursor.splitRowCarry.map((carry) => ({ ...carry })) }
+      : {}),
     verticalMergeCarry: cursor.verticalMergeCarry.map((carry) => ({ ...carry })),
   };
 }
@@ -1657,6 +1672,47 @@ function cloneFragmentLayoutObject(
     ...(layoutObject.fieldFamilies !== undefined
       ? { fieldFamilies: [...layoutObject.fieldFamilies] }
       : {}),
+    ...(layoutObject.fieldRegions !== undefined
+      ? {
+          fieldRegions: layoutObject.fieldRegions.map((region) => ({
+            ...region,
+            ...(region.sourceRef !== undefined ? { sourceRef: { ...region.sourceRef } } : {}),
+            ...(region.fieldEvidence !== undefined
+              ? {
+                  fieldEvidence: {
+                    ...region.fieldEvidence,
+                    ...(region.fieldEvidence.sourceRef !== undefined
+                      ? { sourceRef: { ...region.fieldEvidence.sourceRef } }
+                      : {}),
+                  },
+                }
+              : {}),
+          })),
+        }
+      : {}),
+    ...(layoutObject.numbering !== undefined
+      ? { numbering: cloneNumberingLayoutFacts(layoutObject.numbering) }
+      : {}),
+    ...(layoutObject.numberingRows !== undefined
+      ? { numberingRows: layoutObject.numberingRows.map(cloneNumberingLayoutFacts) }
+      : {}),
+  };
+}
+
+function cloneNumberingLayoutFacts(
+  numbering: NonNullable<NonNullable<RuntimeBlockFragment["layoutObject"]>["numbering"]>,
+): NonNullable<NonNullable<RuntimeBlockFragment["layoutObject"]>["numbering"]> {
+  return {
+    ...numbering,
+    ...(numbering.markerLane !== undefined
+      ? { markerLane: { ...numbering.markerLane } }
+      : {}),
+    ...(numbering.textColumn !== undefined
+      ? { textColumn: { ...numbering.textColumn } }
+      : {}),
+    ...(numbering.tabStops !== undefined
+      ? { tabStops: numbering.tabStops.map((tab) => ({ ...tab })) }
+      : {}),
   };
 }
 
@@ -1908,10 +1964,8 @@ function findPageForOffsetAndStory(
 // `src/runtime/geometry/project-anchors.ts` in refactor/05 Slice 2b. The
 // facet's `getLineBoxes` / `getScopeRailSegments` / `getAllScopeRailSegments`
 // / `getAllScopeCardModels` methods above now import from there. The D1
-// `emitLayoutGuardWarning` probes (including the
-// `collectScopeRailSegmentsForQuery` null-input probe) are ported alongside
-// via the exported `emitLayoutGuardWarning` symbol — they continue to
-// fire through `setActiveLayoutWarningEmitter`.
+// `emitLayoutGuardWarning` probes continue to fire through the shared
+// diagnostics helper behind `setActiveLayoutWarningEmitter`.
 //
 // Hit-test (`resolveHitTest`, `hitTestRegion`, `containsPoint`) and
 // anchor-rect resolution (`resolveAnchorRects`) were moved in Slice 2a.