@beyondwork/docx-react-component 1.0.105 → 1.0.108

package/src/runtime/geometry/geometry-index.ts

@@ -44,12 +44,15 @@ import type {
   GeometryIndexRegion,
   GeometryIndexSlice,
   GeometryObjectHandleEntry,
+  GeometryPageFrameCompleteness,
+  GeometryPageFrameCompletenessCounts,
   GeometryPrecision,
   GeometryPrecisionCounts,
   GeometryRect,
   GeometryRehydrationStatus,
   GeometryReplacementEnvelopeEntry,
   GeometrySourceIdentity,
+  GeometryTableContinuation,
   SemanticDisplayEntry,
 } from "./geometry-types.ts";
 import { buildObjectHandleRectsFromRect } from "./object-handles.ts";
@@ -63,14 +66,18 @@ export function createUnavailableGeometryCoverage(): GeometryIndexCoverage {
   return {
     status: "unavailable",
     pageCount: 0,
+    pageFrameCompleteness: createPageFrameCompletenessCounts(),
     regionCount: 0,
     sliceCount: 0,
     lineCount: 0,
     anchorCount: 0,
     hitTargetCount: 0,
     semanticEntryCount: 0,
+    pageLocalFieldLedgerCount: 0,
     replacementEnvelopeCount: 0,
     objectHandleCount: 0,
+    layoutDivergenceObjectCount: 0,
+    splitRowCarryCount: 0,
     precision: createPrecisionCounts(),
   };
 }
@@ -93,8 +100,15 @@ export function projectGeometryIndexFromFrame(
   const objectHandleEntries = new Map<string, MutableObjectHandleEntry>();
   const projectedBlocksByStory = new Map<string, ProjectedScopeBlock[]>();
   const precision = createPrecisionCounts();
+  const pageFrameCompleteness = createPageFrameCompletenessCounts();
+  let pageLocalFieldLedgerCount = 0;
+  let layoutDivergenceObjectCount = 0;
+  let splitRowCarryCount = 0;
 
   for (const page of frame.pages) {
+    const pageMetadata = pageFrameMetadata(page);
+    pageFrameCompleteness[pageMetadata.frameCompleteness] += 1;
+    layoutDivergenceObjectCount += pageMetadata.layoutDivergenceObjectIds.length;
     const regionEntries = collectRegionEntries(page);
     const regionIds: string[] = [];
 
@@ -107,6 +121,7 @@ export function projectGeometryIndexFromFrame(
       const sliceIds: string[] = [];
 
       for (const block of region.blocks) {
+        splitRowCarryCount += countSplitRowCarry(block);
         const sliceId = makeSliceId(regionId, block.fragment.fragmentId);
         const sliceIdentity = identities?.sliceIdentity(
           storyKey,
@@ -142,7 +157,7 @@ export function projectGeometryIndexFromFrame(
               fragmentId: anchor.fragmentId,
               lineId,
               runtimeOffset: anchor.runtimeOffset,
-              rect: toGeometryRect(anchor.frame),
+              rect: { ...toGeometryRect(anchor.frame), precision: "exact" },
               precision: "exact",
               ...(anchorIdentity ? { sourceIdentity: anchorIdentity } : {}),
             });
@@ -158,7 +173,7 @@ export function projectGeometryIndexFromFrame(
             blockId: block.fragment.blockId,
             fragmentId: block.fragment.fragmentId,
             lineIndex: line.line.lineIndex,
-            rect: toGeometryRect(line.frame),
+            rect: { ...toGeometryRect(line.frame), precision: "exact" },
             anchorIds,
           });
           recordPrecision(precision, "exact");
@@ -171,7 +186,7 @@ export function projectGeometryIndexFromFrame(
             blockId: block.fragment.blockId,
             fragmentId: block.fragment.fragmentId,
             lineIndex: line.line.lineIndex,
-            rect: toGeometryRect(line.frame),
+            rect: { ...toGeometryRect(line.frame), precision: "exact" },
             precision: "exact",
           });
           recordPrecision(precision, "exact");
@@ -189,6 +204,7 @@ export function projectGeometryIndexFromFrame(
             rect: toGeometryRect(line.frame),
             status: "realized",
             precision: "exact",
+            frameCompleteness: pageMetadata.frameCompleteness,
           });
           recordPrecision(precision, "exact");
         }
@@ -237,6 +253,9 @@ export function projectGeometryIndexFromFrame(
           entries: semanticEntries,
           projectedBlocksByStory,
           precision,
+          frameCompleteness: pageMetadata.frameCompleteness,
+          layoutDivergenceIds: pageMetadata.layoutDivergenceIds,
+          layoutDivergenceObjectIds: pageMetadata.layoutDivergenceObjectIds,
         });
       }
 
@@ -257,8 +276,32 @@ export function projectGeometryIndexFromFrame(
       pageIndex: page.page.pageIndex,
       rect: toGeometryRect(page.frame),
       regionIds,
+      frameCompleteness: pageMetadata.frameCompleteness,
+      ...(pageMetadata.displayPageNumber !== undefined
+        ? { displayPageNumber: pageMetadata.displayPageNumber }
+        : {}),
+      ...(pageMetadata.layoutDivergenceIds.length > 0
+        ? { layoutDivergenceIds: pageMetadata.layoutDivergenceIds }
+        : {}),
+      ...(pageMetadata.layoutDivergenceObjectIds.length > 0
+        ? { layoutDivergenceObjectIds: pageMetadata.layoutDivergenceObjectIds }
+        : {}),
     });
     recordPrecision(precision, "exact");
+    pageLocalFieldLedgerCount += appendPageLocalFieldLedgerSemanticEntries({
+      page,
+      entries: semanticEntries,
+      precision,
+      frameCompleteness: pageMetadata.frameCompleteness,
+      layoutDivergenceIds: pageMetadata.layoutDivergenceIds,
+      layoutDivergenceObjectIds: pageMetadata.layoutDivergenceObjectIds,
+    });
+    appendPageLocalObjectHandleEntries({
+      page,
+      entries: objectHandleEntries,
+      precision,
+      divergenceIdsByObjectId: pageMetadata.divergenceIdsByObjectId,
+    });
   }
 
   appendScopeReplacementEnvelopeEntries({
@@ -272,14 +315,18 @@ export function projectGeometryIndexFromFrame(
   const coverage: GeometryIndexCoverage = {
     status: "realized",
     pageCount: pages.length,
+    pageFrameCompleteness,
     regionCount: regions.length,
     sliceCount: slices.length,
     lineCount: lines.length,
     anchorCount: anchors.length,
     hitTargetCount: hitTargets.length,
     semanticEntryCount: semanticEntries.length,
+    pageLocalFieldLedgerCount,
     replacementEnvelopeCount: replacementEnvelopes.length,
     objectHandleCount: objectHandles.length,
+    layoutDivergenceObjectCount,
+    splitRowCarryCount,
     precision,
   };
 
@@ -307,6 +354,7 @@ export function summarizeGeometryCoverageFromFrame(
   if (!frame) return createUnavailableGeometryCoverage();
 
   const precision = createPrecisionCounts();
+  const pageFrameCompleteness = createPageFrameCompletenessCounts();
   let pageCount = 0;
   let regionCount = 0;
   let sliceCount = 0;
@@ -314,14 +362,25 @@ export function summarizeGeometryCoverageFromFrame(
   let anchorCount = 0;
   let hitTargetCount = 0;
   let semanticEntryCount = 0;
+  let pageLocalFieldLedgerCount = 0;
+  let layoutDivergenceObjectCount = 0;
+  let splitRowCarryCount = 0;
 
   for (const page of frame.pages) {
+    const pageMetadata = pageFrameMetadata(page);
     pageCount += 1;
+    pageFrameCompleteness[pageMetadata.frameCompleteness] += 1;
+    layoutDivergenceObjectCount += pageMetadata.layoutDivergenceObjectIds.length;
     recordPrecision(precision, "exact");
+    const pageLocalFieldCount = countPageLocalFieldLedgers(page);
+    pageLocalFieldLedgerCount += pageLocalFieldCount;
+    semanticEntryCount += pageLocalFieldCount;
+    precision["within-tolerance"] += pageLocalFieldCount;
     for (const [region] of collectRegionEntries(page)) {
       regionCount += 1;
       recordPrecision(precision, "exact");
       for (const block of region.blocks) {
+        splitRowCarryCount += countSplitRowCarry(block);
         sliceCount += 1;
         recordPrecision(precision, "exact");
         for (const line of block.lines) {
@@ -350,18 +409,127 @@ export function summarizeGeometryCoverageFromFrame(
   return {
     status: "realized",
     pageCount,
+    pageFrameCompleteness,
     regionCount,
     sliceCount,
     lineCount,
     anchorCount,
     hitTargetCount,
     semanticEntryCount,
+    pageLocalFieldLedgerCount,
     replacementEnvelopeCount: 0,
     objectHandleCount: 0,
+    layoutDivergenceObjectCount,
+    splitRowCarryCount,
     precision,
   };
 }
 
+interface PageFrameMetadata {
+  frameCompleteness: GeometryPageFrameCompleteness;
+  displayPageNumber?: number;
+  layoutDivergenceIds: readonly string[];
+  layoutDivergenceObjectIds: readonly string[];
+  divergenceIdsByObjectId: ReadonlyMap<string, readonly string[]>;
+}
+
+function pageFrameMetadata(page: RenderPage): PageFrameMetadata {
+  const frame = page.page.frame;
+  const divergenceIds = frame?.divergenceIds ? [...frame.divergenceIds] : [];
+  const divergenceIdsByObjectId = new Map<string, string[]>();
+  for (const divergence of page.page.divergences ?? []) {
+    for (const objectId of divergence.objectIds ?? []) {
+      const list = divergenceIdsByObjectId.get(objectId);
+      if (list) {
+        appendUnique(list, divergence.divergenceId);
+      } else {
+        divergenceIdsByObjectId.set(objectId, [divergence.divergenceId]);
+      }
+    }
+  }
+  const objectIds = Array.from(divergenceIdsByObjectId.keys()).sort();
+  return {
+    frameCompleteness: frame?.completeness ?? "absent",
+    ...(frame?.displayPageNumber !== undefined
+      ? { displayPageNumber: frame.displayPageNumber }
+      : {}),
+    layoutDivergenceIds: divergenceIds,
+    layoutDivergenceObjectIds: objectIds,
+    divergenceIdsByObjectId,
+  };
+}
+
+function appendPageLocalFieldLedgerSemanticEntries(input: {
+  page: RenderPage;
+  entries: SemanticDisplayEntry[];
+  precision: GeometryPrecisionCounts;
+  frameCompleteness: GeometryPageFrameCompleteness;
+  layoutDivergenceIds: readonly string[];
+  layoutDivergenceObjectIds: readonly string[];
+}): number {
+  const {
+    page,
+    entries,
+    precision,
+    frameCompleteness,
+    layoutDivergenceIds,
+    layoutDivergenceObjectIds,
+  } = input;
+  let count = 0;
+  for (const story of page.page.frame?.pageLocalStories ?? []) {
+    if (story.resolvedFields.length === 0) continue;
+    const region =
+      story.kind === "header" ? page.regions.header : page.regions.footer;
+    if (!region) continue;
+    for (const field of story.resolvedFields) {
+      entries.push({
+        entryId: `semantic:page-local-field-ledger:${page.page.pageId}:${story.instanceId}:${field.fieldId}`,
+        kind: "page-local-field-ledger",
+        pageId: page.page.pageId,
+        pageIndex: page.page.pageIndex,
+        regionKind: region.region.kind,
+        pageLocalStoryId: story.instanceId,
+        pageLocalStoryKind: story.kind,
+        pageLocalStoryVariant: story.variant,
+        resolvedFieldId: field.fieldId,
+        resolvedFieldFamily: field.family,
+        resolvedFieldDisplayText: field.displayText,
+        frameCompleteness,
+        ...(layoutDivergenceIds.length > 0 ? { layoutDivergenceIds } : {}),
+        ...(layoutDivergenceObjectIds.length > 0
+          ? { layoutDivergenceObjectIds }
+          : {}),
+        rect: {
+          ...toGeometryRect(region.frame),
+          precision: "within-tolerance",
+        },
+        status: "realized",
+        precision: "within-tolerance",
+      });
+      recordPrecision(precision, "within-tolerance");
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function countPageLocalFieldLedgers(page: RenderPage): number {
+  let count = 0;
+  for (const story of page.page.frame?.pageLocalStories ?? []) {
+    const region =
+      story.kind === "header" ? page.regions.header : page.regions.footer;
+    if (!region) continue;
+    count += story.resolvedFields.length;
+  }
+  return count;
+}
+
+function countSplitRowCarry(block: RenderBlock): number {
+  return block.fragment.continuation?.kind === "table"
+    ? block.fragment.continuation.splitRowCarry?.length ?? 0
+    : 0;
+}
+
 function appendBlockSemanticEntries(input: {
   page: RenderPage;
   region: RenderStoryRegion;
@@ -373,6 +541,9 @@ function appendBlockSemanticEntries(input: {
   entries: SemanticDisplayEntry[];
   projectedBlocksByStory: Map<string, ProjectedScopeBlock[]>;
   precision: GeometryPrecisionCounts;
+  frameCompleteness: GeometryPageFrameCompleteness;
+  layoutDivergenceIds: readonly string[];
+  layoutDivergenceObjectIds: readonly string[];
 }): void {
   const {
     page,
@@ -385,11 +556,18 @@ function appendBlockSemanticEntries(input: {
     entries,
     projectedBlocksByStory,
     precision,
+    frameCompleteness,
+    layoutDivergenceIds,
+    layoutDivergenceObjectIds,
   } = input;
   const tableIdentity = identities?.tableIdentity(
     storyKey,
     block.fragment.blockId,
   );
+  const sliceIdentity = identities?.sliceIdentity(
+    storyKey,
+    block.fragment.blockId,
+  );
   const base = {
     pageId: page.page.pageId,
     pageIndex: page.page.pageIndex,
@@ -400,7 +578,19 @@ function appendBlockSemanticEntries(input: {
     fragmentId: block.fragment.fragmentId,
   } as const;
 
+  appendFragmentLayoutObjectSemanticEntries({
+    base,
+    block,
+    sourceIdentity: sliceIdentity,
+    entries,
+    precision,
+    frameCompleteness,
+    layoutDivergenceIds,
+    layoutDivergenceObjectIds,
+  });
+
   if (block.kind === "table") {
+    const tableContinuation = tableContinuationMetadata(block);
     entries.push({
       ...base,
       entryId: `semantic:table-frame:${sliceId}`,
@@ -408,6 +598,12 @@ function appendBlockSemanticEntries(input: {
       rect: toGeometryRect(block.frame),
       status: "realized",
       precision: "exact",
+      frameCompleteness,
+      ...(layoutDivergenceIds.length > 0 ? { layoutDivergenceIds } : {}),
+      ...(layoutDivergenceObjectIds.length > 0
+        ? { layoutDivergenceObjectIds }
+        : {}),
+      ...(tableContinuation ? { tableContinuation } : {}),
       ...(tableIdentity
         ? { sourceIdentity: tableSourceIdentity(tableIdentity) }
         : {}),
@@ -416,6 +612,7 @@ function appendBlockSemanticEntries(input: {
 
     const plan = block.tablePlan;
     if (!plan) return;
+    const visibleRows = resolveVisibleTableRows(block);
     if (tableIdentity) {
       recordTableCellScopeBlocks({
         table: tableIdentity,
@@ -424,20 +621,23 @@ function appendBlockSemanticEntries(input: {
         storyKey,
         identities,
         projectedBlocksByStory,
+        visibleRows,
       });
     }
-    const rowCount = resolveTableRowCount(block);
+    const visibleRowCount = visibleRows.length;
     const rowHeightPx =
-      rowCount > 0 ? block.frame.heightPx / rowCount : block.frame.heightPx;
-    for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+      visibleRowCount > 0
+        ? block.frame.heightPx / visibleRowCount
+        : block.frame.heightPx;
+    for (const row of visibleRows) {
       entries.push({
         ...base,
-        entryId: `semantic:table-row:${sliceId}:${rowIndex}`,
+        entryId: `semantic:table-row:${sliceId}:${row.rowIndex}`,
         kind: "table-row",
-        rowIndex,
+        rowIndex: row.rowIndex,
         rect: {
           leftPx: block.frame.leftPx,
-          topPx: block.frame.topPx + rowIndex * rowHeightPx,
+          topPx: block.frame.topPx + row.visualIndex * rowHeightPx,
           widthPx: block.frame.widthPx,
           heightPx: rowHeightPx,
           space: "frame",
@@ -445,15 +645,27 @@ function appendBlockSemanticEntries(input: {
         },
         status: "realized",
         precision: "within-tolerance",
+        frameCompleteness,
+        ...tableRowContinuationMetadata(block, row.rowIndex),
         ...(tableIdentity
-          ? { sourceIdentity: tableRowSourceIdentity(tableIdentity, rowIndex) }
+          ? {
+              sourceIdentity: tableRowSourceIdentity(
+                tableIdentity,
+                row.rowIndex,
+              ),
+            }
           : {}),
       });
       recordPrecision(precision, "within-tolerance");
     }
 
     for (const cell of plan.bandClasses.cells) {
-      const rect = pageFrameCellRect(block, cell.rowIndex, cell.columnIndex);
+      const rect = pageFrameCellRect(
+        block,
+        cell.rowIndex,
+        cell.columnIndex,
+        visibleRows,
+      );
       if (!rect) continue;
       entries.push({
         ...base,
@@ -467,6 +679,8 @@ function appendBlockSemanticEntries(input: {
         },
         status: "realized",
         precision: "within-tolerance",
+        frameCompleteness,
+        ...tableRowContinuationMetadata(block, cell.rowIndex),
         ...(tableIdentity
           ? {
               sourceIdentity: tableCellSourceIdentity(
@@ -493,6 +707,7 @@ function appendBlockSemanticEntries(input: {
       },
       status: "realized",
       precision: "heuristic",
+      frameCompleteness,
     });
     recordPrecision(precision, "heuristic");
     return;
@@ -506,6 +721,7 @@ function appendBlockSemanticEntries(input: {
       rect: toGeometryRect(block.frame),
       status: "realized",
       precision: "exact",
+      frameCompleteness,
     });
     recordPrecision(precision, "exact");
     return;
@@ -519,18 +735,189 @@ function appendBlockSemanticEntries(input: {
       rect: toGeometryRect(block.frame),
       status: "realized",
       precision: "exact",
+      frameCompleteness,
     });
     recordPrecision(precision, "exact");
   }
 }
 
+function appendFragmentLayoutObjectSemanticEntries(input: {
+  base: {
+    pageId: string;
+    pageIndex: number;
+    regionId: string;
+    regionKind: RenderStoryRegion["region"]["kind"];
+    sliceId: string;
+    blockId: string;
+    fragmentId: string;
+  };
+  block: RenderBlock;
+  sourceIdentity: GeometrySourceIdentity | undefined;
+  entries: SemanticDisplayEntry[];
+  precision: GeometryPrecisionCounts;
+  frameCompleteness: GeometryPageFrameCompleteness;
+  layoutDivergenceIds: readonly string[];
+  layoutDivergenceObjectIds: readonly string[];
+}): void {
+  const {
+    base,
+    block,
+    sourceIdentity,
+    entries,
+    precision,
+    frameCompleteness,
+    layoutDivergenceIds,
+    layoutDivergenceObjectIds,
+  } = input;
+  const layoutObject = block.fragment.layoutObject;
+  if (!layoutObject) return;
+
+  if (layoutObject.kind === "field-region") {
+    entries.push({
+      ...base,
+      entryId: `semantic:field-region:${base.sliceId}`,
+      kind: "field-region",
+      layoutObjectId: layoutObject.objectId,
+      ...(layoutObject.fieldFamilies !== undefined
+        ? { fieldFamilies: [...layoutObject.fieldFamilies] }
+        : {}),
+      rect: {
+        ...toGeometryRect(block.frame),
+        precision: "within-tolerance",
+      },
+      status: "realized",
+      precision: "within-tolerance",
+      frameCompleteness,
+      ...(layoutDivergenceIds.length > 0 ? { layoutDivergenceIds } : {}),
+      ...(layoutDivergenceObjectIds.length > 0
+        ? { layoutDivergenceObjectIds }
+        : {}),
+      ...(sourceIdentity ? { sourceIdentity } : {}),
+    });
+    recordPrecision(precision, "within-tolerance");
+    return;
+  }
+
+  if (layoutObject.kind === "numbered-paragraph") {
+    const markerProjection = resolveNumberingMarkerProjection(block);
+    entries.push({
+      ...base,
+      entryId: `semantic:numbering-marker:${base.sliceId}`,
+      kind: "numbering-marker",
+      layoutObjectId: layoutObject.objectId,
+      rect: markerProjection.rect,
+      status: markerProjection.status,
+      precision: markerProjection.precision,
+      frameCompleteness,
+      ...(sourceIdentity ? { sourceIdentity } : {}),
+    });
+    recordPrecision(precision, markerProjection.precision);
+  }
+}
+
+function resolveNumberingMarkerProjection(block: RenderBlock): {
+  rect: GeometryRect;
+  precision: GeometryPrecision;
+  status: GeometryRehydrationStatus;
+} {
+  const metadata = resolveNumberingMarkerProjectionMetadata(block);
+  const blockFrame = block.frame;
+  if (metadata.markerLane && metadata.measuredWidthTwips !== undefined) {
+    const markerLane = metadata.markerLane;
+    const pxPerTwip = blockFrame.widthPx / metadata.measuredWidthTwips;
+    const blockLeftPx = blockFrame.leftPx;
+    const blockRightPx = blockFrame.leftPx + Math.max(0, blockFrame.widthPx);
+    const rawLeftPx = blockFrame.leftPx + markerLane.startTwips * pxPerTwip;
+    const rawRightPx = rawLeftPx + markerLane.widthTwips * pxPerTwip;
+    const leftPx = clamp(rawLeftPx, blockLeftPx, blockRightPx);
+    const rightPx = clamp(rawRightPx, leftPx, blockRightPx);
+    return {
+      rect: {
+        leftPx,
+        topPx: blockFrame.topPx,
+        widthPx: rightPx - leftPx,
+        heightPx: blockFrame.heightPx,
+        space: "frame",
+        precision: metadata.precision,
+      },
+      precision: metadata.precision,
+      status: metadata.status,
+    };
+  }
+
+  const widthPx = Math.min(
+    Math.max(0, blockFrame.heightPx),
+    Math.max(0, blockFrame.widthPx),
+  );
+  return {
+    rect: {
+      leftPx: blockFrame.leftPx,
+      topPx: blockFrame.topPx,
+      widthPx,
+      heightPx: blockFrame.heightPx,
+      space: "frame",
+      precision: metadata.precision,
+    },
+    precision: metadata.precision,
+    status: metadata.status,
+  };
+}
+
+function resolveNumberingMarkerProjectionMetadata(block: RenderBlock): {
+  precision: GeometryPrecision;
+  status: GeometryRehydrationStatus;
+  markerLane?: {
+    readonly startTwips: number;
+    readonly widthTwips: number;
+  };
+  measuredWidthTwips?: number;
+} {
+  const blockFrame = block.frame;
+  const layoutObject = block.fragment.layoutObject;
+  const markerLane =
+    layoutObject?.kind === "numbered-paragraph"
+      ? layoutObject.numbering?.markerLane
+      : undefined;
+  const measuredWidthTwips = layoutObject?.measuredExtentTwips.widthTwips;
+  if (
+    markerLane &&
+    markerLane.widthTwips > 0 &&
+    measuredWidthTwips !== undefined &&
+    measuredWidthTwips > 0 &&
+    Number.isFinite(blockFrame.widthPx)
+  ) {
+    return {
+      precision: "within-tolerance",
+      status: "realized",
+      markerLane,
+      measuredWidthTwips,
+    };
+  }
+  return {
+    precision: "heuristic",
+    status: "requires-rehydration",
+  };
+}
+
 function countBlockSemanticEntries(block: RenderBlock): GeometryPrecisionCounts {
   const counts = createPrecisionCounts();
+  const layoutObject = block.fragment.layoutObject;
+  if (layoutObject?.kind === "field-region") {
+    counts["within-tolerance"] += 1;
+  } else if (layoutObject?.kind === "numbered-paragraph") {
+    counts[resolveNumberingMarkerProjectionMetadata(block).precision] += 1;
+  }
   if (block.kind === "table") {
     counts.exact += 1;
     if (block.tablePlan) {
-      counts["within-tolerance"] += resolveTableRowCount(block);
-      counts["within-tolerance"] += block.tablePlan.bandClasses.cells.length;
+      const visibleRows = resolveVisibleTableRows(block);
+      const visibleRowIndexes = new Set(
+        visibleRows.map((row) => row.rowIndex),
+      );
+      counts["within-tolerance"] += visibleRows.length;
+      counts["within-tolerance"] += block.tablePlan.bandClasses.cells.filter(
+        (cell) => visibleRowIndexes.has(cell.rowIndex),
+      ).length;
     }
   } else if (block.kind === "image-float") {
     counts.heuristic += 1;
@@ -553,13 +940,134 @@ function resolveTableRowCount(block: RenderBlock): number {
   );
 }
 
+interface VisibleTableRow {
+  rowIndex: number;
+  visualIndex: number;
+}
+
+function tableContinuationMetadata(
+  block: RenderBlock,
+): GeometryTableContinuation | null {
+  const continuation =
+    block.fragment.continuation?.kind === "table"
+      ? block.fragment.continuation
+      : null;
+  const rowRange = block.fragment.tableRowRange ?? continuation?.rowRange;
+  if (!continuation && !rowRange) return null;
+
+  return {
+    ...(continuation
+      ? {
+          sequenceIndex: continuation.sequenceIndex,
+          sliceCount: continuation.sliceCount,
+          continuesFromPreviousPage: continuation.continuesFromPreviousPage,
+          continuesToNextPage: continuation.continuesToNextPage,
+        }
+      : {}),
+    ...(rowRange ? { rowRange: { ...rowRange } } : {}),
+    ...(continuation?.repeatedHeaderRowIndexes.length
+      ? {
+          repeatedHeaderRowIndexes: [
+            ...continuation.repeatedHeaderRowIndexes,
+          ],
+        }
+      : {}),
+    ...(continuation?.splitRowCarry?.length
+      ? {
+          splitRowCarry: continuation.splitRowCarry.map((carry) => ({
+            ...carry,
+          })),
+        }
+      : {}),
+    ...(continuation?.verticalMergeCarry.length
+      ? {
+          verticalMergeCarry: continuation.verticalMergeCarry.map((carry) => ({
+            ...carry,
+          })),
+        }
+      : {}),
+  };
+}
+
+function tableRowContinuationMetadata(
+  block: RenderBlock,
+  rowIndex: number,
+): Pick<SemanticDisplayEntry, "tableContinuation"> {
+  const tableContinuation = tableContinuationMetadata(block);
+  if (!tableContinuation) return {};
+  const repeatedHeaderRowIndexes =
+    tableContinuation.repeatedHeaderRowIndexes?.includes(rowIndex) === true
+      ? [rowIndex]
+      : undefined;
+  const splitRowCarry = tableContinuation.splitRowCarry?.filter(
+    (carry) => carry.rowIndex === rowIndex,
+  );
+
+  if (
+    repeatedHeaderRowIndexes === undefined &&
+    (!splitRowCarry || splitRowCarry.length === 0)
+  ) {
+    return {};
+  }
+
+  return {
+    tableContinuation: {
+      ...(repeatedHeaderRowIndexes ? { repeatedHeaderRowIndexes } : {}),
+      ...(splitRowCarry && splitRowCarry.length > 0
+        ? { splitRowCarry: splitRowCarry.map((carry) => ({ ...carry })) }
+        : {}),
+    },
+  };
+}
+
+function resolveVisibleTableRows(block: RenderBlock): readonly VisibleTableRow[] {
+  const rowCount = resolveTableRowCount(block);
+  if (rowCount <= 0) return [];
+  const continuation =
+    block.fragment.continuation?.kind === "table"
+      ? block.fragment.continuation
+      : null;
+  const rowRange = block.fragment.tableRowRange ?? continuation?.rowRange;
+  if (!rowRange) {
+    return Array.from({ length: rowCount }, (_, rowIndex) => ({
+      rowIndex,
+      visualIndex: rowIndex,
+    }));
+  }
+
+  const start = Math.max(0, Math.min(rowCount, rowRange.from));
+  const end = Math.max(start, Math.min(rowCount, rowRange.to));
+  const rowIndexes: number[] = [];
+  const seenRowIndexes = new Set<number>();
+  const addRow = (rowIndex: number): void => {
+    if (rowIndex < 0 || rowIndex >= rowCount) return;
+    if (seenRowIndexes.has(rowIndex)) return;
+    seenRowIndexes.add(rowIndex);
+    rowIndexes.push(rowIndex);
+  };
+
+  for (const rowIndex of continuation?.repeatedHeaderRowIndexes ?? []) {
+    addRow(rowIndex);
+  }
+  for (let rowIndex = start; rowIndex < end; rowIndex += 1) {
+    addRow(rowIndex);
+  }
+
+  return rowIndexes.map((rowIndex, visualIndex) => ({ rowIndex, visualIndex }));
+}
+
 function pageFrameCellRect(
   block: RenderBlock,
   rowIndex: number,
   columnIndex: number,
+  visibleRows: readonly VisibleTableRow[] = resolveVisibleTableRows(block),
 ): RenderFrameRect | null {
   const plan = block.tablePlan;
   if (!plan || plan.columnsTwips.length === 0) return null;
+  const visualRowIndex = visibleRows.findIndex(
+    (row) => row.rowIndex === rowIndex,
+  );
+  if (visualRowIndex < 0) return null;
   const columnCount = plan.columnsTwips.length;
   const totalWidthTwips = plan.columnsTwips.reduce(
     (sum, value) => sum + Math.max(0, value),
@@ -586,12 +1094,12 @@ function pageFrameCellRect(
   for (let i = columnIndex; i < columnIndex + columnSpan; i += 1) {
     widthPx += (plan.columnsTwips[i] ?? 0) * pxPerTwip;
   }
-  const rowCount = resolveTableRowCount(block);
+  const rowCount = visibleRows.length;
   const rowHeightPx =
     rowCount > 0 ? block.frame.heightPx / rowCount : block.frame.heightPx;
   return {
     leftPx,
-    topPx: block.frame.topPx + rowIndex * rowHeightPx,
+    topPx: block.frame.topPx + visualRowIndex * rowHeightPx,
     widthPx,
     heightPx: rowHeightPx,
   };
@@ -706,6 +1214,7 @@ interface MutableObjectHandleEntry {
   rects: GeometryRect[];
   status: GeometryRehydrationStatus;
   precision: GeometryPrecision;
+  layoutDivergenceIds?: string[];
   sourceIdentity?: GeometrySourceIdentity;
 }
 
@@ -739,6 +1248,11 @@ function appendCanonicalObjectHandleEntries(input: {
     if (existing) {
       appendUnique(existing.pageIds, page.page.pageId);
       existing.rects.push(...handleRects);
+      appendDivergenceIdsForObject(
+        existing,
+        input.page,
+        anchor.objectKey,
+      );
       if (existing.precision !== "heuristic" && entryPrecision === "heuristic") {
         existing.precision = "heuristic";
         existing.status = "requires-rehydration";
@@ -753,6 +1267,7 @@ function appendCanonicalObjectHandleEntries(input: {
       rects: [...handleRects],
       status,
       precision: entryPrecision,
+      ...layoutDivergenceIdsForObject(input.page, anchor.objectKey),
       sourceIdentity: anchorSourceIdentity(
         anchor,
         exactObjectRect ? "direct" : "block-scoped",
@@ -762,6 +1277,80 @@ function appendCanonicalObjectHandleEntries(input: {
   }
 }
 
+function appendPageLocalObjectHandleEntries(input: {
+  page: RenderPage;
+  entries: Map<string, MutableObjectHandleEntry>;
+  precision: GeometryPrecisionCounts;
+  divergenceIdsByObjectId: ReadonlyMap<string, readonly string[]>;
+}): void {
+  const { page, entries, precision, divergenceIdsByObjectId } = input;
+  const stories = page.page.frame?.pageLocalStories ?? [];
+  const pxPerTwip =
+    page.page.layout.pageWidth > 0
+      ? page.frame.widthPx / page.page.layout.pageWidth
+      : 1;
+  for (const story of stories) {
+    const regionFrame =
+      story.kind === "header" ? page.regions.header?.frame : page.regions.footer?.frame;
+    if (!regionFrame) continue;
+    for (const object of story.anchoredObjects) {
+      const objectFrame = pageLocalObjectFrame(
+        regionFrame,
+        object.extentTwips,
+        pxPerTwip,
+      );
+      const handleRects = buildObjectHandleRectsFromRect(objectFrame, "heuristic");
+      const sourceIdentity: GeometrySourceIdentity = {
+        storyKey: story.storyKey,
+        objectKey: object.objectId,
+        objectKind: object.sourceType,
+        editPosture: object.preserveOnly ? "preserve-only" : "editable",
+        joinKind: "block-scoped",
+      };
+      const existing = entries.get(object.objectId);
+      if (existing) {
+        appendUnique(existing.pageIds, page.page.pageId);
+        existing.rects.push(...handleRects);
+        appendDivergenceIds(existing, divergenceIdsByObjectId.get(object.objectId));
+        if (existing.precision !== "heuristic") {
+          existing.precision = "heuristic";
+          existing.status = "requires-rehydration";
+          existing.sourceIdentity = sourceIdentity;
+        }
+        continue;
+      }
+      entries.set(object.objectId, {
+        objectId: object.objectId,
+        pageIds: [page.page.pageId],
+        rects: [...handleRects],
+        status: "requires-rehydration",
+        precision: "heuristic",
+        ...mutableLayoutDivergenceIds(divergenceIdsByObjectId.get(object.objectId)),
+        sourceIdentity,
+      });
+      recordPrecision(precision, "heuristic");
+    }
+  }
+}
+
+function pageLocalObjectFrame(
+  regionFrame: RenderFrameRect,
+  extentTwips:
+    | { readonly widthTwips: number; readonly heightTwips: number }
+    | undefined,
+  pxPerTwip: number,
+): RenderFrameRect {
+  if (!extentTwips) return regionFrame;
+  const widthPx = Math.max(0, extentTwips.widthTwips * pxPerTwip);
+  const heightPx = Math.max(0, extentTwips.heightTwips * pxPerTwip);
+  return {
+    leftPx: regionFrame.leftPx,
+    topPx: regionFrame.topPx,
+    widthPx: widthPx > 0 ? Math.min(widthPx, regionFrame.widthPx) : regionFrame.widthPx,
+    heightPx: heightPx > 0 ? Math.min(heightPx, regionFrame.heightPx) : regionFrame.heightPx,
+  };
+}
+
 function finalizeObjectHandleEntries(
   entries: ReadonlyMap<string, MutableObjectHandleEntry>,
 ): GeometryObjectHandleEntry[] {
@@ -771,6 +1360,9 @@ function finalizeObjectHandleEntries(
     rects: entry.rects,
     status: entry.status,
     precision: entry.precision,
+    ...(entry.layoutDivergenceIds && entry.layoutDivergenceIds.length > 0
+      ? { layoutDivergenceIds: [...entry.layoutDivergenceIds] }
+      : {}),
     ...(entry.sourceIdentity ? { sourceIdentity: entry.sourceIdentity } : {}),
   }));
 }
@@ -826,6 +1418,7 @@ function recordTableCellScopeBlocks(input: {
   storyKey: string;
   identities: GeometryIdentityLookup | null;
   projectedBlocksByStory: Map<string, ProjectedScopeBlock[]>;
+  visibleRows: readonly VisibleTableRow[];
 }): void {
   const {
     table,
@@ -834,12 +1427,18 @@ function recordTableCellScopeBlocks(input: {
     storyKey,
     identities,
     projectedBlocksByStory,
+    visibleRows,
   } = input;
   if (!identities) return;
 
   for (const row of table.rows) {
     for (const cell of row.cells) {
-      const rect = pageFrameCellRect(block, row.rowIndex, cell.gridColumnStart);
+      const rect = pageFrameCellRect(
+        block,
+        row.rowIndex,
+        cell.gridColumnStart,
+        visibleRows,
+      );
       if (!rect) continue;
       for (let blockIndex = 0; blockIndex < cell.blockCount; blockIndex += 1) {
         const blockPath =
@@ -1228,6 +1827,10 @@ function toGeometryRect(rect: RenderFrameRect): GeometryRect {
   };
 }
 
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
 function makeRegionId(
   page: RenderPage,
   region: RenderStoryRegion,
@@ -1260,6 +1863,48 @@ function createPrecisionCounts(): GeometryPrecisionCounts {
   };
 }
 
+function createPageFrameCompletenessCounts(): GeometryPageFrameCompletenessCounts {
+  return {
+    complete: 0,
+    partial: 0,
+    absent: 0,
+  };
+}
+
+function layoutDivergenceIdsForObject(
+  page: RenderPage,
+  objectId: string,
+): { readonly layoutDivergenceIds?: string[] } {
+  const ids = page.page.divergences
+    ?.filter((divergence) => divergence.objectIds?.includes(objectId) === true)
+    .map((divergence) => divergence.divergenceId);
+  return ids && ids.length > 0 ? { layoutDivergenceIds: ids } : {};
+}
+
+function mutableLayoutDivergenceIds(
+  ids: readonly string[] | undefined,
+): { readonly layoutDivergenceIds?: string[] } {
+  return ids && ids.length > 0 ? { layoutDivergenceIds: [...ids] } : {};
+}
+
+function appendDivergenceIdsForObject(
+  entry: MutableObjectHandleEntry,
+  page: RenderPage,
+  objectId: string,
+): void {
+  const ids = layoutDivergenceIdsForObject(page, objectId).layoutDivergenceIds;
+  appendDivergenceIds(entry, ids);
+}
+
+function appendDivergenceIds(
+  entry: MutableObjectHandleEntry,
+  ids: readonly string[] | undefined,
+): void {
+  if (!ids || ids.length === 0) return;
+  if (!entry.layoutDivergenceIds) entry.layoutDivergenceIds = [];
+  for (const id of ids) appendUnique(entry.layoutDivergenceIds, id);
+}
+
 function recordPrecision(
   counts: GeometryPrecisionCounts,
   precision: keyof GeometryPrecisionCounts,