@beyondwork/docx-react-component 1.0.103 → 1.0.105

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

@@ -0,0 +1,1268 @@
+/**
+ * PE2 geometry index substrate.
+ *
+ * Layer 05 owns a renderer-neutral index of the geometry already projected
+ * for the current page frame. The current adapter consumes `RenderFrame`
+ * because that is the runtime's materialized page-slice view; the output is
+ * intentionally limited to geometry facts and precision/status metadata.
+ */
+
+import type {
+  EditorStoryTarget,
+} from "../../api/public-types.ts";
+import type {
+  BlockNode,
+  CanonicalDocument,
+} from "../../model/canonical-document.ts";
+import {
+  collectCanonicalLayoutInputs,
+  collectStoryBlockContexts,
+  createHeaderFooterStoryKey,
+  createNoteStoryKey,
+  MAIN_STORY_KEY,
+  type CanonicalAnchorLayoutInput,
+  type CanonicalLayoutInputs,
+  type CanonicalScopeLayoutInput,
+  type CanonicalTableLayoutInput,
+  type CanonicalTableCellLayoutInput,
+  type CanonicalTableRowLayoutInput,
+} from "../../model/canonical-layout-inputs.ts";
+import type {
+  RenderFrame,
+  RenderFrameRect,
+  RenderBlock,
+  RenderPage,
+  RenderStoryRegion,
+} from "../render/index.ts";
+import type {
+  AnchorGeometry,
+  GeometryHitTarget,
+  GeometryIndex,
+  GeometryIndexCoverage,
+  GeometryIndexLine,
+  GeometryIndexPage,
+  GeometryIndexRegion,
+  GeometryIndexSlice,
+  GeometryObjectHandleEntry,
+  GeometryPrecision,
+  GeometryPrecisionCounts,
+  GeometryRect,
+  GeometryRehydrationStatus,
+  GeometryReplacementEnvelopeEntry,
+  GeometrySourceIdentity,
+  SemanticDisplayEntry,
+} from "./geometry-types.ts";
+import { buildObjectHandleRectsFromRect } from "./object-handles.ts";
+
+export interface GeometryIndexProjectionOptions {
+  readonly canonicalDocument?: CanonicalDocument | null;
+  readonly layoutInputs?: CanonicalLayoutInputs | null;
+}
+
+export function createUnavailableGeometryCoverage(): GeometryIndexCoverage {
+  return {
+    status: "unavailable",
+    pageCount: 0,
+    regionCount: 0,
+    sliceCount: 0,
+    lineCount: 0,
+    anchorCount: 0,
+    hitTargetCount: 0,
+    semanticEntryCount: 0,
+    replacementEnvelopeCount: 0,
+    objectHandleCount: 0,
+    precision: createPrecisionCounts(),
+  };
+}
+
+export function projectGeometryIndexFromFrame(
+  frame: RenderFrame | null,
+  options?: GeometryIndexProjectionOptions,
+): GeometryIndex | null {
+  if (!frame) return null;
+
+  const identities = createIdentityLookup(options);
+  const pages: GeometryIndexPage[] = [];
+  const regions: GeometryIndexRegion[] = [];
+  const slices: GeometryIndexSlice[] = [];
+  const lines: GeometryIndexLine[] = [];
+  const anchors: AnchorGeometry[] = [];
+  const hitTargets: GeometryHitTarget[] = [];
+  const semanticEntries: SemanticDisplayEntry[] = [];
+  const replacementEnvelopes: GeometryReplacementEnvelopeEntry[] = [];
+  const objectHandleEntries = new Map<string, MutableObjectHandleEntry>();
+  const projectedBlocksByStory = new Map<string, ProjectedScopeBlock[]>();
+  const precision = createPrecisionCounts();
+
+  for (const page of frame.pages) {
+    const regionEntries = collectRegionEntries(page);
+    const regionIds: string[] = [];
+
+    for (const [region, ordinal] of regionEntries) {
+      const regionId = makeRegionId(page, region, ordinal);
+      const storyKey =
+        identities?.storyKeyForTarget(region.storyTarget) ??
+        canonicalStoryKeyFromTarget(region.storyTarget);
+      regionIds.push(regionId);
+      const sliceIds: string[] = [];
+
+      for (const block of region.blocks) {
+        const sliceId = makeSliceId(regionId, block.fragment.fragmentId);
+        const sliceIdentity = identities?.sliceIdentity(
+          storyKey,
+          block.fragment.blockId,
+        );
+        sliceIds.push(sliceId);
+        const lineIds: string[] = [];
+
+        for (const line of block.lines) {
+          const lineId = makeLineId(
+            regionId,
+            block.fragment.fragmentId,
+            line.line.lineIndex,
+          );
+          lineIds.push(lineId);
+          const anchorIds: string[] = [];
+
+          for (let index = 0; index < line.anchors.length; index += 1) {
+            const anchor = line.anchors[index]!;
+            const anchorId = makeAnchorId(lineId, index);
+            const anchorIdentity = identities?.anchorIdentity(
+              storyKey,
+              anchor.blockId ?? block.fragment.blockId,
+            );
+            anchorIds.push(anchorId);
+            anchors.push({
+              anchorId,
+              pageId: page.page.pageId,
+              pageIndex: page.page.pageIndex,
+              regionId,
+              regionKind: region.region.kind,
+              blockId: anchor.blockId,
+              fragmentId: anchor.fragmentId,
+              lineId,
+              runtimeOffset: anchor.runtimeOffset,
+              rect: toGeometryRect(anchor.frame),
+              precision: "exact",
+              ...(anchorIdentity ? { sourceIdentity: anchorIdentity } : {}),
+            });
+            recordPrecision(precision, "exact");
+          }
+
+          lines.push({
+            lineId,
+            pageId: page.page.pageId,
+            pageIndex: page.page.pageIndex,
+            regionId,
+            regionKind: region.region.kind,
+            blockId: block.fragment.blockId,
+            fragmentId: block.fragment.fragmentId,
+            lineIndex: line.line.lineIndex,
+            rect: toGeometryRect(line.frame),
+            anchorIds,
+          });
+          recordPrecision(precision, "exact");
+          hitTargets.push({
+            targetId: `hit:${lineId}`,
+            pageId: page.page.pageId,
+            pageIndex: page.page.pageIndex,
+            regionId,
+            regionKind: region.region.kind,
+            blockId: block.fragment.blockId,
+            fragmentId: block.fragment.fragmentId,
+            lineIndex: line.line.lineIndex,
+            rect: toGeometryRect(line.frame),
+            precision: "exact",
+          });
+          recordPrecision(precision, "exact");
+          semanticEntries.push({
+            entryId: `semantic:text-line:${lineId}`,
+            kind: "text-line",
+            pageId: page.page.pageId,
+            pageIndex: page.page.pageIndex,
+            regionId,
+            regionKind: region.region.kind,
+            sliceId,
+            lineId,
+            blockId: block.fragment.blockId,
+            fragmentId: block.fragment.fragmentId,
+            rect: toGeometryRect(line.frame),
+            status: "realized",
+            precision: "exact",
+          });
+          recordPrecision(precision, "exact");
+        }
+
+        slices.push({
+          sliceId,
+          pageId: page.page.pageId,
+          pageIndex: page.page.pageIndex,
+          regionId,
+          regionKind: region.region.kind,
+          blockId: block.fragment.blockId,
+          fragmentId: block.fragment.fragmentId,
+          kind: block.kind,
+          rect: toGeometryRect(block.frame),
+          lineIds,
+          ...(sliceIdentity ? { sourceIdentity: sliceIdentity } : {}),
+        });
+        recordPrecision(precision, "exact");
+        recordProjectedScopeBlock(projectedBlocksByStory, {
+          storyKey,
+          blockId: block.fragment.blockId,
+          blockPath: identities?.blockPathForBlockId(
+            storyKey,
+            block.fragment.blockId,
+          ),
+          pageId: page.page.pageId,
+          rect: toGeometryRect(block.frame),
+        });
+        appendCanonicalObjectHandleEntries({
+          frame,
+          page,
+          block,
+          identities,
+          storyKey,
+          entries: objectHandleEntries,
+          precision,
+        });
+        appendBlockSemanticEntries({
+          page,
+          region,
+          regionId,
+          sliceId,
+          block,
+          identities,
+          storyKey,
+          entries: semanticEntries,
+          projectedBlocksByStory,
+          precision,
+        });
+      }
+
+      regions.push({
+        regionId,
+        pageId: page.page.pageId,
+        pageIndex: page.page.pageIndex,
+        kind: region.region.kind,
+        ordinal,
+        rect: toGeometryRect(region.frame),
+        sliceIds,
+      });
+      recordPrecision(precision, "exact");
+    }
+
+    pages.push({
+      pageId: page.page.pageId,
+      pageIndex: page.page.pageIndex,
+      rect: toGeometryRect(page.frame),
+      regionIds,
+    });
+    recordPrecision(precision, "exact");
+  }
+
+  appendScopeReplacementEnvelopeEntries({
+    identities,
+    projectedBlocksByStory,
+    entries: replacementEnvelopes,
+    precision,
+  });
+
+  const objectHandles = finalizeObjectHandleEntries(objectHandleEntries);
+  const coverage: GeometryIndexCoverage = {
+    status: "realized",
+    pageCount: pages.length,
+    regionCount: regions.length,
+    sliceCount: slices.length,
+    lineCount: lines.length,
+    anchorCount: anchors.length,
+    hitTargetCount: hitTargets.length,
+    semanticEntryCount: semanticEntries.length,
+    replacementEnvelopeCount: replacementEnvelopes.length,
+    objectHandleCount: objectHandles.length,
+    precision,
+  };
+
+  return {
+    source: "render-frame-adapter",
+    revision: frame.revision,
+    measurementFidelity: frame.measurementFidelity,
+    activeStory: frame.activeStory,
+    pages,
+    regions,
+    slices,
+    lines,
+    anchors,
+    hitTargets,
+    semanticEntries,
+    replacementEnvelopes,
+    objectHandles,
+    coverage,
+  };
+}
+
+export function summarizeGeometryCoverageFromFrame(
+  frame: RenderFrame | null,
+): GeometryIndexCoverage {
+  if (!frame) return createUnavailableGeometryCoverage();
+
+  const precision = createPrecisionCounts();
+  let pageCount = 0;
+  let regionCount = 0;
+  let sliceCount = 0;
+  let lineCount = 0;
+  let anchorCount = 0;
+  let hitTargetCount = 0;
+  let semanticEntryCount = 0;
+
+  for (const page of frame.pages) {
+    pageCount += 1;
+    recordPrecision(precision, "exact");
+    for (const [region] of collectRegionEntries(page)) {
+      regionCount += 1;
+      recordPrecision(precision, "exact");
+      for (const block of region.blocks) {
+        sliceCount += 1;
+        recordPrecision(precision, "exact");
+        for (const line of block.lines) {
+          lineCount += 1;
+          hitTargetCount += 1;
+          recordPrecision(precision, "exact"); // line rect
+          recordPrecision(precision, "exact"); // matching hit-target rect
+          semanticEntryCount += 1;
+          recordPrecision(precision, "exact"); // text-line semantic entry
+          anchorCount += line.anchors.length;
+          for (let i = 0; i < line.anchors.length; i += 1) {
+            recordPrecision(precision, "exact");
+          }
+        }
+        const blockSemantic = countBlockSemanticEntries(block);
+        semanticEntryCount += blockSemantic.exact;
+        semanticEntryCount += blockSemantic["within-tolerance"];
+        semanticEntryCount += blockSemantic.heuristic;
+        precision.exact += blockSemantic.exact;
+        precision["within-tolerance"] += blockSemantic["within-tolerance"];
+        precision.heuristic += blockSemantic.heuristic;
+      }
+    }
+  }
+
+  return {
+    status: "realized",
+    pageCount,
+    regionCount,
+    sliceCount,
+    lineCount,
+    anchorCount,
+    hitTargetCount,
+    semanticEntryCount,
+    replacementEnvelopeCount: 0,
+    objectHandleCount: 0,
+    precision,
+  };
+}
+
+function appendBlockSemanticEntries(input: {
+  page: RenderPage;
+  region: RenderStoryRegion;
+  regionId: string;
+  sliceId: string;
+  block: RenderBlock;
+  identities: GeometryIdentityLookup | null;
+  storyKey: string;
+  entries: SemanticDisplayEntry[];
+  projectedBlocksByStory: Map<string, ProjectedScopeBlock[]>;
+  precision: GeometryPrecisionCounts;
+}): void {
+  const {
+    page,
+    region,
+    regionId,
+    sliceId,
+    block,
+    identities,
+    storyKey,
+    entries,
+    projectedBlocksByStory,
+    precision,
+  } = input;
+  const tableIdentity = identities?.tableIdentity(
+    storyKey,
+    block.fragment.blockId,
+  );
+  const base = {
+    pageId: page.page.pageId,
+    pageIndex: page.page.pageIndex,
+    regionId,
+    regionKind: region.region.kind,
+    sliceId,
+    blockId: block.fragment.blockId,
+    fragmentId: block.fragment.fragmentId,
+  } as const;
+
+  if (block.kind === "table") {
+    entries.push({
+      ...base,
+      entryId: `semantic:table-frame:${sliceId}`,
+      kind: "table-frame",
+      rect: toGeometryRect(block.frame),
+      status: "realized",
+      precision: "exact",
+      ...(tableIdentity
+        ? { sourceIdentity: tableSourceIdentity(tableIdentity) }
+        : {}),
+    });
+    recordPrecision(precision, "exact");
+
+    const plan = block.tablePlan;
+    if (!plan) return;
+    if (tableIdentity) {
+      recordTableCellScopeBlocks({
+        table: tableIdentity,
+        block,
+        pageId: page.page.pageId,
+        storyKey,
+        identities,
+        projectedBlocksByStory,
+      });
+    }
+    const rowCount = resolveTableRowCount(block);
+    const rowHeightPx =
+      rowCount > 0 ? block.frame.heightPx / rowCount : block.frame.heightPx;
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+      entries.push({
+        ...base,
+        entryId: `semantic:table-row:${sliceId}:${rowIndex}`,
+        kind: "table-row",
+        rowIndex,
+        rect: {
+          leftPx: block.frame.leftPx,
+          topPx: block.frame.topPx + rowIndex * rowHeightPx,
+          widthPx: block.frame.widthPx,
+          heightPx: rowHeightPx,
+          space: "frame",
+          precision: "within-tolerance",
+        },
+        status: "realized",
+        precision: "within-tolerance",
+        ...(tableIdentity
+          ? { sourceIdentity: tableRowSourceIdentity(tableIdentity, rowIndex) }
+          : {}),
+      });
+      recordPrecision(precision, "within-tolerance");
+    }
+
+    for (const cell of plan.bandClasses.cells) {
+      const rect = pageFrameCellRect(block, cell.rowIndex, cell.columnIndex);
+      if (!rect) continue;
+      entries.push({
+        ...base,
+        entryId: `semantic:table-cell:${sliceId}:${cell.rowIndex}:${cell.columnIndex}`,
+        kind: "table-cell",
+        rowIndex: cell.rowIndex,
+        columnIndex: cell.columnIndex,
+        rect: {
+          ...toGeometryRect(rect),
+          precision: "within-tolerance",
+        },
+        status: "realized",
+        precision: "within-tolerance",
+        ...(tableIdentity
+          ? {
+              sourceIdentity: tableCellSourceIdentity(
+                tableIdentity,
+                cell.rowIndex,
+                cell.columnIndex,
+              ),
+            }
+          : {}),
+      });
+      recordPrecision(precision, "within-tolerance");
+    }
+    return;
+  }
+
+  if (block.kind === "image-float") {
+    entries.push({
+      ...base,
+      entryId: `semantic:floating-object:${sliceId}`,
+      kind: "floating-object",
+      rect: {
+        ...toGeometryRect(block.frame),
+        precision: "heuristic",
+      },
+      status: "realized",
+      precision: "heuristic",
+    });
+    recordPrecision(precision, "heuristic");
+    return;
+  }
+
+  if (block.kind === "opaque") {
+    entries.push({
+      ...base,
+      entryId: `semantic:placeholder:${sliceId}`,
+      kind: "placeholder",
+      rect: toGeometryRect(block.frame),
+      status: "realized",
+      precision: "exact",
+    });
+    recordPrecision(precision, "exact");
+    return;
+  }
+
+  if (block.kind === "synthetic") {
+    entries.push({
+      ...base,
+      entryId: `semantic:debug-classification:${sliceId}`,
+      kind: "debug-classification",
+      rect: toGeometryRect(block.frame),
+      status: "realized",
+      precision: "exact",
+    });
+    recordPrecision(precision, "exact");
+  }
+}
+
+function countBlockSemanticEntries(block: RenderBlock): GeometryPrecisionCounts {
+  const counts = createPrecisionCounts();
+  if (block.kind === "table") {
+    counts.exact += 1;
+    if (block.tablePlan) {
+      counts["within-tolerance"] += resolveTableRowCount(block);
+      counts["within-tolerance"] += block.tablePlan.bandClasses.cells.length;
+    }
+  } else if (block.kind === "image-float") {
+    counts.heuristic += 1;
+  } else if (block.kind === "opaque" || block.kind === "synthetic") {
+    counts.exact += 1;
+  }
+  return counts;
+}
+
+function resolveTableRowCount(block: RenderBlock): number {
+  const plan = block.tablePlan;
+  if (!plan) return 0;
+  return Math.max(
+    1,
+    plan.bandClasses.rows.length ||
+      plan.bandClasses.cells.reduce(
+        (max, c) => Math.max(max, c.rowIndex + 1),
+        0,
+      ),
+  );
+}
+
+function pageFrameCellRect(
+  block: RenderBlock,
+  rowIndex: number,
+  columnIndex: number,
+): RenderFrameRect | null {
+  const plan = block.tablePlan;
+  if (!plan || plan.columnsTwips.length === 0) return null;
+  const columnCount = plan.columnsTwips.length;
+  const totalWidthTwips = plan.columnsTwips.reduce(
+    (sum, value) => sum + Math.max(0, value),
+    0,
+  );
+  const pxPerTwip =
+    totalWidthTwips > 0 ? block.frame.widthPx / totalWidthTwips : 0;
+  let leftPx = block.frame.leftPx;
+  for (let i = 0; i < columnIndex; i += 1) {
+    leftPx += (plan.columnsTwips[i] ?? 0) * pxPerTwip;
+  }
+  const sameRow = plan.bandClasses.cells
+    .filter((cell) => cell.rowIndex === rowIndex)
+    .sort((a, b) => a.columnIndex - b.columnIndex);
+  const currentIndex = sameRow.findIndex(
+    (cell) => cell.columnIndex === columnIndex,
+  );
+  const next = sameRow[currentIndex + 1];
+  const columnSpan = Math.max(
+    1,
+    (next?.columnIndex ?? columnCount) - columnIndex,
+  );
+  let widthPx = 0;
+  for (let i = columnIndex; i < columnIndex + columnSpan; i += 1) {
+    widthPx += (plan.columnsTwips[i] ?? 0) * pxPerTwip;
+  }
+  const rowCount = resolveTableRowCount(block);
+  const rowHeightPx =
+    rowCount > 0 ? block.frame.heightPx / rowCount : block.frame.heightPx;
+  return {
+    leftPx,
+    topPx: block.frame.topPx + rowIndex * rowHeightPx,
+    widthPx,
+    heightPx: rowHeightPx,
+  };
+}
+
+interface GeometryIdentityLookup {
+  storyKeyForTarget(target: EditorStoryTarget): string;
+  sliceIdentity(storyKey: string, blockId: string): GeometrySourceIdentity | undefined;
+  tableIdentity(storyKey: string, blockId: string): CanonicalTableLayoutInput | undefined;
+  anchorIdentity(storyKey: string, blockId: string): GeometrySourceIdentity | undefined;
+  objectAnchors(storyKey: string, blockId: string): readonly CanonicalAnchorLayoutInput[];
+  blockIdForPath(storyKey: string, blockPath: string): string | undefined;
+  blockPathForBlockId(storyKey: string, blockId: string): string | undefined;
+  scopeInputs(): readonly CanonicalScopeLayoutInput[];
+}
+
+function createIdentityLookup(
+  options: GeometryIndexProjectionOptions | undefined,
+): GeometryIdentityLookup | null {
+  const layoutInputs =
+    options?.layoutInputs ??
+    (options?.canonicalDocument
+      ? collectCanonicalLayoutInputs(options.canonicalDocument)
+      : null);
+  if (!layoutInputs) return null;
+
+  const storyKeys = new Set(layoutInputs.stories.map((story) => story.storyKey));
+  const blockIdByPath = options?.canonicalDocument
+    ? collectProjectedBlockIdsByPath(options.canonicalDocument)
+    : new Map<string, string>();
+  const tableByStoryBlockId = new Map<string, CanonicalTableLayoutInput>();
+  const tableOrdinalByStory = new Map<string, number>();
+  for (const table of layoutInputs.tables) {
+    const blockId =
+      blockIdByPath.get(storyPathKey(table.storyKey, table.blockPath)) ??
+      nextTableBlockId(tableOrdinalByStory, table.storyKey);
+    tableByStoryBlockId.set(storyBlockKey(table.storyKey, blockId), table);
+  }
+
+  const blockPathByStoryBlockId = new Map<string, string>();
+  for (const [pathKey, blockId] of blockIdByPath) {
+    const splitAt = pathKey.indexOf("\u0000");
+    if (splitAt <= 0) continue;
+    const storyKey = pathKey.slice(0, splitAt);
+    const blockPath = pathKey.slice(splitAt + 1);
+    blockPathByStoryBlockId.set(storyBlockKey(storyKey, blockId), blockPath);
+  }
+
+  const anchorsByStoryBlockId = new Map<string, CanonicalAnchorLayoutInput[]>();
+  for (const anchor of layoutInputs.anchors) {
+    const blockId = blockIdByPath.get(
+      storyPathKey(anchor.storyKey, anchor.blockPath),
+    );
+    if (!blockId) continue;
+    const key = storyBlockKey(anchor.storyKey, blockId);
+    const list = anchorsByStoryBlockId.get(key);
+    if (list) {
+      list.push(anchor);
+    } else {
+      anchorsByStoryBlockId.set(key, [anchor]);
+    }
+  }
+
+  return {
+    storyKeyForTarget(target) {
+      return resolveCanonicalStoryKeyForTarget(target, storyKeys);
+    },
+    sliceIdentity(storyKey, blockId) {
+      const table = tableByStoryBlockId.get(storyBlockKey(storyKey, blockId));
+      if (table) return tableSourceIdentity(table);
+      const blockPath = blockPathByStoryBlockId.get(storyBlockKey(storyKey, blockId));
+      return blockPath
+        ? { storyKey, blockPath, joinKind: "direct" }
+        : undefined;
+    },
+    tableIdentity(storyKey, blockId) {
+      return tableByStoryBlockId.get(storyBlockKey(storyKey, blockId));
+    },
+    anchorIdentity(storyKey, blockId) {
+      const key = storyBlockKey(storyKey, blockId);
+      const anchors = anchorsByStoryBlockId.get(key);
+      if (!anchors || anchors.length === 0) return undefined;
+      const blockPath = blockPathByStoryBlockId.get(key) ?? anchors[0]!.blockPath;
+      if (anchors.length !== 1) {
+        return {
+          storyKey,
+          blockPath,
+          joinKind: "block-scoped",
+        };
+      }
+      const anchor = anchors[0]!;
+      return anchorSourceIdentity(anchor, "block-scoped");
+    },
+    objectAnchors(storyKey, blockId) {
+      return anchorsByStoryBlockId.get(storyBlockKey(storyKey, blockId)) ?? [];
+    },
+    blockIdForPath(storyKey, blockPath) {
+      return blockIdByPath.get(storyPathKey(storyKey, blockPath));
+    },
+    blockPathForBlockId(storyKey, blockId) {
+      return blockPathByStoryBlockId.get(storyBlockKey(storyKey, blockId));
+    },
+    scopeInputs() {
+      return layoutInputs.scopes;
+    },
+  };
+}
+
+interface MutableObjectHandleEntry {
+  objectId: string;
+  pageIds: string[];
+  rects: GeometryRect[];
+  status: GeometryRehydrationStatus;
+  precision: GeometryPrecision;
+  sourceIdentity?: GeometrySourceIdentity;
+}
+
+function appendCanonicalObjectHandleEntries(input: {
+  frame: RenderFrame;
+  page: RenderPage;
+  block: RenderBlock;
+  identities: GeometryIdentityLookup | null;
+  storyKey: string;
+  entries: Map<string, MutableObjectHandleEntry>;
+  precision: GeometryPrecisionCounts;
+}): void {
+  const { frame, page, block, identities, storyKey, entries, precision } = input;
+  if (!identities) return;
+
+  for (const anchor of identities.objectAnchors(
+    storyKey,
+    block.fragment.blockId,
+  )) {
+    if (anchor.hidden === true) continue;
+    const exactObjectRect = frame.anchorIndex.byObjectId(anchor.objectKey);
+    const rect = exactObjectRect ?? block.frame;
+    const entryPrecision: GeometryPrecision = exactObjectRect
+      ? "within-tolerance"
+      : "heuristic";
+    const status: GeometryRehydrationStatus = exactObjectRect
+      ? "realized"
+      : "requires-rehydration";
+    const handleRects = buildObjectHandleRectsFromRect(rect, entryPrecision);
+    const existing = entries.get(anchor.objectKey);
+    if (existing) {
+      appendUnique(existing.pageIds, page.page.pageId);
+      existing.rects.push(...handleRects);
+      if (existing.precision !== "heuristic" && entryPrecision === "heuristic") {
+        existing.precision = "heuristic";
+        existing.status = "requires-rehydration";
+        existing.sourceIdentity = anchorSourceIdentity(anchor, "block-scoped");
+      }
+      continue;
+    }
+
+    entries.set(anchor.objectKey, {
+      objectId: anchor.objectKey,
+      pageIds: [page.page.pageId],
+      rects: [...handleRects],
+      status,
+      precision: entryPrecision,
+      sourceIdentity: anchorSourceIdentity(
+        anchor,
+        exactObjectRect ? "direct" : "block-scoped",
+      ),
+    });
+    recordPrecision(precision, entryPrecision);
+  }
+}
+
+function finalizeObjectHandleEntries(
+  entries: ReadonlyMap<string, MutableObjectHandleEntry>,
+): GeometryObjectHandleEntry[] {
+  return Array.from(entries.values()).map((entry) => ({
+    objectId: entry.objectId,
+    pageIds: entry.pageIds,
+    rects: entry.rects,
+    status: entry.status,
+    precision: entry.precision,
+    ...(entry.sourceIdentity ? { sourceIdentity: entry.sourceIdentity } : {}),
+  }));
+}
+
+function appendUnique(target: string[], value: string): void {
+  if (!target.includes(value)) target.push(value);
+}
+
+function resolveCanonicalStoryKeyForTarget(
+  target: EditorStoryTarget,
+  storyKeys: ReadonlySet<string>,
+): string {
+  const exact = canonicalStoryKeyFromTarget(target);
+  if (storyKeys.has(exact)) return exact;
+  if (
+    (target.kind === "header" || target.kind === "footer") &&
+    target.sectionIndex !== undefined
+  ) {
+    const unscoped = createHeaderFooterStoryKey({
+      kind: target.kind,
+      relationshipId: target.relationshipId,
+      variant: target.variant,
+    });
+    if (storyKeys.has(unscoped)) return unscoped;
+  }
+  return exact;
+}
+
+interface ProjectedScopeBlock {
+  readonly storyKey: string;
+  readonly blockId: string;
+  readonly blockPath?: string;
+  readonly pageId: string;
+  readonly rect: GeometryRect;
+}
+
+function recordProjectedScopeBlock(
+  blocksByStory: Map<string, ProjectedScopeBlock[]>,
+  block: ProjectedScopeBlock,
+): void {
+  const list = blocksByStory.get(block.storyKey);
+  if (list) {
+    list.push(block);
+  } else {
+    blocksByStory.set(block.storyKey, [block]);
+  }
+}
+
+function recordTableCellScopeBlocks(input: {
+  table: CanonicalTableLayoutInput;
+  block: RenderBlock;
+  pageId: string;
+  storyKey: string;
+  identities: GeometryIdentityLookup | null;
+  projectedBlocksByStory: Map<string, ProjectedScopeBlock[]>;
+}): void {
+  const {
+    table,
+    block,
+    pageId,
+    storyKey,
+    identities,
+    projectedBlocksByStory,
+  } = input;
+  if (!identities) return;
+
+  for (const row of table.rows) {
+    for (const cell of row.cells) {
+      const rect = pageFrameCellRect(block, row.rowIndex, cell.gridColumnStart);
+      if (!rect) continue;
+      for (let blockIndex = 0; blockIndex < cell.blockCount; blockIndex += 1) {
+        const blockPath =
+          `${table.blockPath}/row[${row.rowIndex}]/cell[${cell.cellIndex}]` +
+          `/block[${blockIndex}]`;
+        const blockId = identities.blockIdForPath(storyKey, blockPath);
+        if (!blockId) continue;
+        recordProjectedScopeBlock(projectedBlocksByStory, {
+          storyKey,
+          blockId,
+          blockPath,
+          pageId,
+          rect: {
+            ...toGeometryRect(rect),
+            precision: "within-tolerance",
+          },
+        });
+      }
+    }
+  }
+}
+
+function appendScopeReplacementEnvelopeEntries(input: {
+  identities: GeometryIdentityLookup | null;
+  projectedBlocksByStory: ReadonlyMap<string, readonly ProjectedScopeBlock[]>;
+  entries: GeometryReplacementEnvelopeEntry[];
+  precision: GeometryPrecisionCounts;
+}): void {
+  const { identities, projectedBlocksByStory, entries, precision } = input;
+  if (!identities) return;
+
+  for (const scope of identities.scopeInputs()) {
+    const entry = projectScopeReplacementEnvelopeEntry(
+      scope,
+      identities,
+      projectedBlocksByStory.get(scope.storyKey) ?? [],
+    );
+    entries.push(entry);
+    recordPrecision(precision, entry.precision);
+  }
+}
+
+function projectScopeReplacementEnvelopeEntry(
+  scope: CanonicalScopeLayoutInput,
+  identities: GeometryIdentityLookup,
+  storyBlocks: readonly ProjectedScopeBlock[],
+): GeometryReplacementEnvelopeEntry {
+  const startBlockId = scope.start
+    ? identities.blockIdForPath(scope.storyKey, scope.start.blockPath)
+    : undefined;
+  const endBlockId = scope.end
+    ? identities.blockIdForPath(scope.storyKey, scope.end.blockPath)
+    : undefined;
+
+  let blocks: readonly ProjectedScopeBlock[] = [];
+  let status: GeometryReplacementEnvelopeEntry["status"] = "unavailable";
+  let precision: GeometryReplacementEnvelopeEntry["precision"] = "heuristic";
+
+  if (scope.status === "paired" && startBlockId && endBlockId) {
+    blocks = blocksInCanonicalPathRange(scope, storyBlocks);
+    if (blocks.length === 0) {
+      const startIndex = firstBlockIndex(storyBlocks, startBlockId);
+      const endIndex = lastBlockIndex(storyBlocks, endBlockId);
+      if (startIndex >= 0 && endIndex >= 0) {
+        const from = Math.min(startIndex, endIndex);
+        const to = Math.max(startIndex, endIndex);
+        blocks = storyBlocks.slice(from, to + 1);
+      }
+    }
+    if (blocks.length > 0) {
+      status = "realized";
+      precision = "within-tolerance";
+    }
+  }
+
+  if (blocks.length === 0) {
+    const fallbackBlockId = startBlockId ?? endBlockId;
+    if (fallbackBlockId) {
+      blocks = storyBlocks.filter((block) => block.blockId === fallbackBlockId);
+      if (blocks.length > 0) status = "requires-rehydration";
+    }
+  }
+
+  return {
+    scopeId: scope.scopeId,
+    pageIds: uniquePageIds(blocks),
+    rects: blocks.map((block) => ({
+      ...block.rect,
+      precision,
+    })),
+    status,
+    precision,
+    sourceIdentity: scopeSourceIdentity(scope),
+  };
+}
+
+function blocksInCanonicalPathRange(
+  scope: CanonicalScopeLayoutInput,
+  storyBlocks: readonly ProjectedScopeBlock[],
+): readonly ProjectedScopeBlock[] {
+  if (!scope.start || !scope.end) return [];
+  const orderByPath = new Map<string, number>();
+  for (const block of storyBlocks) {
+    if (!block.blockPath || orderByPath.has(block.blockPath)) continue;
+    orderByPath.set(block.blockPath, orderByPath.size);
+  }
+  const startOrder = orderByPath.get(scope.start.blockPath);
+  const endOrder = orderByPath.get(scope.end.blockPath);
+  if (startOrder === undefined || endOrder === undefined) return [];
+
+  const from = Math.min(startOrder, endOrder);
+  const to = Math.max(startOrder, endOrder);
+  return storyBlocks.filter((block) => {
+    if (!block.blockPath) return false;
+    const order = orderByPath.get(block.blockPath);
+    return order !== undefined && order >= from && order <= to;
+  });
+}
+
+function firstBlockIndex(
+  blocks: readonly ProjectedScopeBlock[],
+  blockId: string,
+): number {
+  return blocks.findIndex((block) => block.blockId === blockId);
+}
+
+function lastBlockIndex(
+  blocks: readonly ProjectedScopeBlock[],
+  blockId: string,
+): number {
+  for (let index = blocks.length - 1; index >= 0; index -= 1) {
+    if (blocks[index]?.blockId === blockId) return index;
+  }
+  return -1;
+}
+
+function uniquePageIds(
+  blocks: readonly ProjectedScopeBlock[],
+): readonly string[] {
+  const ids: string[] = [];
+  const seen = new Set<string>();
+  for (const block of blocks) {
+    if (seen.has(block.pageId)) continue;
+    seen.add(block.pageId);
+    ids.push(block.pageId);
+  }
+  return ids;
+}
+
+function scopeSourceIdentity(
+  scope: CanonicalScopeLayoutInput,
+): GeometrySourceIdentity {
+  const marker = scope.start ?? scope.end;
+  return {
+    storyKey: scope.storyKey,
+    ...(marker ? { blockPath: marker.blockPath } : {}),
+    scopeKey: scope.scopeKey,
+    scopeId: scope.scopeId,
+    joinKind: "block-scoped",
+  };
+}
+
+function anchorSourceIdentity(
+  anchor: CanonicalAnchorLayoutInput,
+  joinKind: GeometrySourceIdentity["joinKind"],
+): GeometrySourceIdentity {
+  return {
+    storyKey: anchor.storyKey,
+    blockPath: anchor.blockPath,
+    objectKey: anchor.objectKey,
+    inlinePath: anchor.inlinePath,
+    objectKind: anchor.objectKind,
+    editPosture: anchor.editPosture,
+    joinKind,
+  };
+}
+
+function nextTableBlockId(
+  ordinalByStory: Map<string, number>,
+  storyKey: string,
+): string {
+  const ordinal = ordinalByStory.get(storyKey) ?? 0;
+  ordinalByStory.set(storyKey, ordinal + 1);
+  return `table-${ordinal}`;
+}
+
+function tableSourceIdentity(
+  table: CanonicalTableLayoutInput,
+): GeometrySourceIdentity {
+  return {
+    storyKey: table.storyKey,
+    blockPath: table.blockPath,
+    tableKey: table.tableKey,
+    joinKind: "direct",
+  };
+}
+
+function tableRowSourceIdentity(
+  table: CanonicalTableLayoutInput,
+  rowIndex: number,
+): GeometrySourceIdentity {
+  const row = table.rows.find((entry) => entry.rowIndex === rowIndex);
+  return {
+    ...tableSourceIdentity(table),
+    ...(row ? { rowKey: row.rowKey } : {}),
+  };
+}
+
+function tableCellSourceIdentity(
+  table: CanonicalTableLayoutInput,
+  rowIndex: number,
+  gridColumnStart: number,
+): GeometrySourceIdentity {
+  const row = table.rows.find((entry) => entry.rowIndex === rowIndex);
+  const cell = findCanonicalCellByGridColumn(row, gridColumnStart);
+  return {
+    ...tableRowSourceIdentity(table, rowIndex),
+    ...(cell ? { cellKey: cell.cellKey } : {}),
+  };
+}
+
+function findCanonicalCellByGridColumn(
+  row: CanonicalTableRowLayoutInput | undefined,
+  gridColumnStart: number,
+): CanonicalTableCellLayoutInput | undefined {
+  if (!row) return undefined;
+  return row.cells.find((cell) => cell.gridColumnStart === gridColumnStart);
+}
+
+function collectProjectedBlockIdsByPath(
+  document: CanonicalDocument,
+): Map<string, string> {
+  const result = new Map<string, string>();
+  for (const context of collectStoryBlockContexts(document)) {
+    const counters = {
+      paragraph: 0,
+      table: 0,
+      sdt: 0,
+      customXml: 0,
+      altChunk: 0,
+      opaque: 0,
+    };
+    collectProjectedBlockIdsForBlocks(
+      context.blocks,
+      context.storyKey,
+      context.basePath,
+      counters,
+      result,
+    );
+  }
+  return result;
+}
+
+function collectProjectedBlockIdsForBlocks(
+  blocks: readonly BlockNode[],
+  storyKey: string,
+  basePath: string,
+  counters: {
+    paragraph: number;
+    table: number;
+    sdt: number;
+    customXml: number;
+    altChunk: number;
+    opaque: number;
+  },
+  result: Map<string, string>,
+): void {
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
+    if (!block) continue;
+    const blockPath = `${basePath}/block[${blockIndex}]`;
+    if (block.type === "paragraph") {
+      result.set(storyPathKey(storyKey, blockPath), `paragraph-${counters.paragraph}`);
+      counters.paragraph += 1;
+      continue;
+    }
+    if (block.type === "table") {
+      result.set(storyPathKey(storyKey, blockPath), `table-${counters.table}`);
+      counters.table += 1;
+      for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+        const row = block.rows[rowIndex];
+        if (!row) continue;
+        for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+          const cell = row.cells[cellIndex];
+          if (!cell) continue;
+          collectProjectedBlockIdsForBlocks(
+            cell.children,
+            storyKey,
+            `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`,
+            counters,
+            result,
+          );
+        }
+      }
+      continue;
+    }
+    if (block.type === "sdt") {
+      counters.sdt += 1;
+      collectProjectedBlockIdsForBlocks(
+        block.children,
+        storyKey,
+        blockPath,
+        counters,
+        result,
+      );
+      continue;
+    }
+    if (block.type === "custom_xml") {
+      counters.customXml += 1;
+      continue;
+    }
+    if (block.type === "alt_chunk") {
+      counters.altChunk += 1;
+      continue;
+    }
+    if (block.type === "opaque_block" || block.type === "section_break") {
+      counters.opaque += 1;
+    }
+  }
+}
+
+function canonicalStoryKeyFromTarget(target: EditorStoryTarget): string {
+  switch (target.kind) {
+    case "main":
+      return MAIN_STORY_KEY;
+    case "header":
+      return createHeaderFooterStoryKey({
+        kind: "header",
+        relationshipId: target.relationshipId,
+        variant: target.variant,
+        ...(target.sectionIndex !== undefined
+          ? { sectionIndex: target.sectionIndex }
+          : {}),
+      });
+    case "footer":
+      return createHeaderFooterStoryKey({
+        kind: "footer",
+        relationshipId: target.relationshipId,
+        variant: target.variant,
+        ...(target.sectionIndex !== undefined
+          ? { sectionIndex: target.sectionIndex }
+          : {}),
+      });
+    case "footnote":
+      return createNoteStoryKey("footnote", target.noteId);
+    case "endnote":
+      return createNoteStoryKey("endnote", target.noteId);
+  }
+}
+
+function storyBlockKey(storyKey: string, blockId: string): string {
+  return `${storyKey}\u0000${blockId}`;
+}
+
+function storyPathKey(storyKey: string, blockPath: string): string {
+  return `${storyKey}\u0000${blockPath}`;
+}
+
+function collectRegionEntries(
+  page: RenderPage,
+): Array<[RenderStoryRegion, number]> {
+  const entries: Array<[RenderStoryRegion, number]> = [];
+  const push = (region: RenderStoryRegion | undefined) => {
+    if (!region) return;
+    const ordinal = entries.filter(
+      ([entry]) => entry.region.kind === region.region.kind,
+    ).length;
+    entries.push([region, ordinal]);
+  };
+  push(page.regions.body);
+  push(page.regions.header);
+  push(page.regions.footer);
+  for (const region of page.regions.columns ?? []) push(region);
+  push(page.regions.footnoteArea);
+  for (const region of page.regions.footnotes ?? []) push(region);
+  return entries;
+}
+
+function toGeometryRect(rect: RenderFrameRect): GeometryRect {
+  return {
+    leftPx: rect.leftPx,
+    topPx: rect.topPx,
+    widthPx: rect.widthPx,
+    heightPx: rect.heightPx,
+    space: "frame",
+  };
+}
+
+function makeRegionId(
+  page: RenderPage,
+  region: RenderStoryRegion,
+  ordinal: number,
+): string {
+  return `${page.page.pageId}:${region.region.kind}:${ordinal}`;
+}
+
+function makeSliceId(regionId: string, fragmentId: string): string {
+  return `${regionId}:slice:${fragmentId}`;
+}
+
+function makeLineId(
+  regionId: string,
+  fragmentId: string,
+  lineIndex: number,
+): string {
+  return `${regionId}:line:${fragmentId}:${lineIndex}`;
+}
+
+function makeAnchorId(lineId: string, index: number): string {
+  return `${lineId}:anchor:${index}`;
+}
+
+function createPrecisionCounts(): GeometryPrecisionCounts {
+  return {
+    exact: 0,
+    "within-tolerance": 0,
+    heuristic: 0,
+  };
+}
+
+function recordPrecision(
+  counts: GeometryPrecisionCounts,
+  precision: keyof GeometryPrecisionCounts,
+): void {
+  counts[precision] += 1;
+}