@beyondwork/docx-react-component 1.0.102 → 1.0.104

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

@@ -0,0 +1,891 @@
+/**
+ * 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 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,
+  GeometryPrecisionCounts,
+  GeometryRect,
+  GeometryReplacementEnvelopeEntry,
+  GeometrySourceIdentity,
+  SemanticDisplayEntry,
+} from "./geometry-types.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 objectHandles: GeometryObjectHandleEntry[] = [];
+  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 = 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");
+        appendBlockSemanticEntries({
+          page,
+          region,
+          regionId,
+          sliceId,
+          block,
+          identities,
+          storyKey,
+          entries: semanticEntries,
+          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");
+  }
+
+  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[];
+  precision: GeometryPrecisionCounts;
+}): void {
+  const {
+    page,
+    region,
+    regionId,
+    sliceId,
+    block,
+    identities,
+    storyKey,
+    entries,
+    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;
+    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 {
+  sliceIdentity(storyKey: string, blockId: string): GeometrySourceIdentity | undefined;
+  tableIdentity(storyKey: string, blockId: string): CanonicalTableLayoutInput | undefined;
+  anchorIdentity(storyKey: string, blockId: string): GeometrySourceIdentity | undefined;
+}
+
+function createIdentityLookup(
+  options: GeometryIndexProjectionOptions | undefined,
+): GeometryIdentityLookup | null {
+  const layoutInputs =
+    options?.layoutInputs ??
+    (options?.canonicalDocument
+      ? collectCanonicalLayoutInputs(options.canonicalDocument)
+      : null);
+  if (!layoutInputs) return null;
+
+  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 {
+    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 {
+        storyKey,
+        blockPath: anchor.blockPath,
+        objectKey: anchor.objectKey,
+        inlinePath: anchor.inlinePath,
+        objectKind: anchor.objectKind,
+        editPosture: anchor.editPosture,
+        joinKind: "block-scoped",
+      };
+    },
+  };
+}
+
+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;
+}