@beyondwork/docx-react-component 1.0.103 → 1.0.104

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

@@ -24,7 +24,10 @@
  */
 
 import type { EditorStoryTarget } from "../../api/public-types";
-import type { PublicPageRegion } from "../layout/public-facet.ts";
+import type {
+  PublicMeasurementFidelity,
+  PublicPageRegion,
+} from "../layout/public-facet.ts";
 
 // ---------------------------------------------------------------------------
 // G5 · Coordinate space tags
@@ -75,6 +78,11 @@ export type GeometrySpace = "twips" | "frame" | "overlay";
  */
 export type GeometryPrecision = "exact" | "within-tolerance" | "heuristic";
 
+export type GeometryRehydrationStatus =
+  | "realized"
+  | "requires-rehydration"
+  | "unavailable";
+
 // ---------------------------------------------------------------------------
 // Core rect shape
 // ---------------------------------------------------------------------------
@@ -98,6 +106,200 @@ export interface GeometryRect {
   precision?: GeometryPrecision;
 }
 
+// ---------------------------------------------------------------------------
+// PE2 geometry index (Slice 1 · page-slice projection substrate)
+// ---------------------------------------------------------------------------
+
+export interface GeometryPrecisionCounts {
+  exact: number;
+  "within-tolerance": number;
+  heuristic: number;
+}
+
+export interface GeometryIndexCoverage {
+  status: GeometryRehydrationStatus;
+  pageCount: number;
+  regionCount: number;
+  sliceCount: number;
+  lineCount: number;
+  anchorCount: number;
+  hitTargetCount: number;
+  semanticEntryCount: number;
+  replacementEnvelopeCount: number;
+  objectHandleCount: number;
+  precision: GeometryPrecisionCounts;
+}
+
+export type GeometrySourceIdentityJoinKind = "direct" | "block-scoped";
+
+/**
+ * Stable canonical identity joined onto projected geometry when the current
+ * substrate can prove the correspondence without consulting renderer state.
+ *
+ * `joinKind: "direct"` means the geometry node maps to the named canonical
+ * table/row/cell. `joinKind: "block-scoped"` means the geometry rect still
+ * belongs to the enclosing rendered block/line; object fields identify the
+ * canonical object carried by that block, not a true object bbox.
+ */
+export interface GeometrySourceIdentity {
+  storyKey: string;
+  blockPath?: string;
+  tableKey?: string;
+  rowKey?: string;
+  cellKey?: string;
+  objectKey?: string;
+  inlinePath?: string;
+  objectKind?: string;
+  editPosture?: string;
+  joinKind: GeometrySourceIdentityJoinKind;
+}
+
+export interface GeometryIndex {
+  /**
+   * Source adapter for this index. PE2's target input is L04 page slices; the
+   * current substrate projects the render frame because it is the runtime's
+   * already materialized page-slice view.
+   */
+  source: "render-frame-adapter";
+  revision: number;
+  measurementFidelity: PublicMeasurementFidelity;
+  activeStory: EditorStoryTarget;
+  pages: readonly GeometryIndexPage[];
+  regions: readonly GeometryIndexRegion[];
+  slices: readonly GeometryIndexSlice[];
+  lines: readonly GeometryIndexLine[];
+  anchors: readonly AnchorGeometry[];
+  hitTargets: readonly GeometryHitTarget[];
+  semanticEntries: readonly SemanticDisplayEntry[];
+  replacementEnvelopes: readonly GeometryReplacementEnvelopeEntry[];
+  objectHandles: readonly GeometryObjectHandleEntry[];
+  coverage: GeometryIndexCoverage;
+}
+
+export interface GeometryIndexPage {
+  pageId: string;
+  pageIndex: number;
+  rect: GeometryRect;
+  regionIds: readonly string[];
+}
+
+export interface GeometryIndexRegion {
+  regionId: string;
+  pageId: string;
+  pageIndex: number;
+  kind: PublicPageRegion["kind"];
+  ordinal: number;
+  rect: GeometryRect;
+  sliceIds: readonly string[];
+}
+
+export interface GeometryIndexSlice {
+  sliceId: string;
+  pageId: string;
+  pageIndex: number;
+  regionId: string;
+  regionKind: PublicPageRegion["kind"];
+  blockId: string;
+  fragmentId: string;
+  kind: "paragraph" | "table" | "opaque" | "image-float" | "synthetic";
+  rect: GeometryRect;
+  lineIds: readonly string[];
+  sourceIdentity?: GeometrySourceIdentity;
+}
+
+export interface GeometryIndexLine {
+  lineId: string;
+  pageId: string;
+  pageIndex: number;
+  regionId: string;
+  regionKind: PublicPageRegion["kind"];
+  blockId: string;
+  fragmentId: string;
+  lineIndex: number;
+  rect: GeometryRect;
+  /** Baseline offset from the line rect's top, in frame pixels. */
+  baseline?: number;
+  baselinePrecision?: GeometryPrecision;
+  anchorIds: readonly string[];
+}
+
+export interface AnchorGeometry {
+  anchorId: string;
+  pageId: string;
+  pageIndex: number;
+  regionId: string;
+  regionKind: PublicPageRegion["kind"];
+  blockId?: string;
+  fragmentId?: string;
+  lineId?: string;
+  runtimeOffset?: number;
+  rect: GeometryRect;
+  precision: GeometryPrecision;
+  sourceIdentity?: GeometrySourceIdentity;
+}
+
+export interface GeometryHitTarget {
+  targetId: string;
+  pageId: string;
+  pageIndex: number;
+  regionId: string;
+  regionKind: PublicPageRegion["kind"];
+  blockId: string;
+  fragmentId: string;
+  lineIndex: number;
+  rect: GeometryRect;
+  precision: GeometryPrecision;
+}
+
+export type SemanticDisplayEntryKind =
+  | "text-line"
+  | "numbering-marker"
+  | "table-frame"
+  | "table-row"
+  | "table-cell"
+  | "toc-leader"
+  | "toc-page-label"
+  | "field-result"
+  | "inline-object"
+  | "floating-object"
+  | "placeholder"
+  | "background"
+  | "border"
+  | "debug-classification";
+
+export interface SemanticDisplayEntry {
+  entryId: string;
+  kind: SemanticDisplayEntryKind;
+  pageId: string;
+  pageIndex: number;
+  regionId?: string;
+  regionKind?: PublicPageRegion["kind"];
+  sliceId?: string;
+  lineId?: string;
+  blockId?: string;
+  fragmentId?: string;
+  rowIndex?: number;
+  columnIndex?: number;
+  rect: GeometryRect;
+  status: GeometryRehydrationStatus;
+  precision: GeometryPrecision;
+  sourceIdentity?: GeometrySourceIdentity;
+}
+
+export interface GeometryReplacementEnvelopeEntry {
+  scopeId: string;
+  rects: readonly GeometryRect[];
+  status: GeometryRehydrationStatus;
+  precision: GeometryPrecision;
+}
+
+export interface GeometryObjectHandleEntry {
+  objectId: string;
+  rects: readonly GeometryRect[];
+  status: GeometryRehydrationStatus;
+  precision: GeometryPrecision;
+}
+
 // ---------------------------------------------------------------------------
 // Per-granularity geometry nodes (read models; Slice 2+ populates them)
 // ---------------------------------------------------------------------------
@@ -200,6 +402,14 @@ export interface AnchorQuery {
 
 export type EnvelopeConfidence = "exact" | "medium" | "detached";
 
+export interface EnvelopeContinuationState {
+  pageIds: readonly string[];
+  pageCount: number;
+  crossesPageBoundary: boolean;
+  continuedFromPreviousPage: boolean;
+  continuesToNextPage: boolean;
+}
+
 export interface EnvelopeBundle {
   /**
    * Rect coverage for the resolved scope. Slice-5 substrate produces
@@ -211,6 +421,10 @@ export interface EnvelopeBundle {
    * walk if the count is lower than expected.
    */
   scopeRects: readonly GeometryRect[];
+  /** Page ids whose projected page frames intersect `scopeRects`. */
+  pageIds: readonly string[];
+  /** Continuation metadata for multi-page / partial-page replacement scopes. */
+  continuation: EnvelopeContinuationState;
   /** Anchor point consumers attach chrome to (top-left of first rect). */
   attachPoint: { xPx: number; yPx: number; space: GeometrySpace };
   /**
@@ -227,6 +441,12 @@ export interface EnvelopeBundle {
    * layer-05 closure.
    */
   linesCrossed: number;
+  /**
+   * Realized for live range scopes. Detached scopes are projected from a
+   * last-known range and are marked `requires-rehydration` so callers do not
+   * mistake the geometry for current document truth.
+   */
+  rehydrationStatus: GeometryRehydrationStatus;
   /**
    * Precision tag. `"exact"` when the envelope collapsed to a caret rect
    * (single anchor position); `"within-tolerance"` when the envelope is

package/src/runtime/geometry/index.ts

@@ -13,7 +13,24 @@
 
 export type {
   GeometrySpace,
+  GeometryPrecision,
   GeometryRect,
+  GeometryRehydrationStatus,
+  GeometryPrecisionCounts,
+  GeometrySourceIdentityJoinKind,
+  GeometrySourceIdentity,
+  GeometryIndexCoverage,
+  GeometryIndex,
+  GeometryIndexPage,
+  GeometryIndexRegion,
+  GeometryIndexSlice,
+  GeometryIndexLine,
+  AnchorGeometry,
+  GeometryHitTarget,
+  SemanticDisplayEntryKind,
+  SemanticDisplayEntry,
+  GeometryReplacementEnvelopeEntry,
+  GeometryObjectHandleEntry,
   PageGeometry,
   BlockGeometry,
   LineGeometry,
@@ -24,11 +41,20 @@ export type {
   AnchorQueryKind,
   AnchorQuery,
   EnvelopeConfidence,
+  EnvelopeContinuationState,
   EnvelopeBundle,
   Viewport,
   ViewportListener,
 } from "./geometry-types.ts";
 
+export {
+  createUnavailableGeometryCoverage,
+  projectGeometryIndexFromFrame,
+  summarizeGeometryCoverageFromFrame,
+} from "./geometry-index.ts";
+
+export type { GeometryIndexProjectionOptions } from "./geometry-index.ts";
+
 export type {
   GeometryFacet,
   CreateGeometryFacetInput,

package/src/runtime/geometry/inert-geometry-facet.ts

@@ -10,6 +10,7 @@
 
 import type { GeometryFacet } from "./geometry-facet.ts";
 import type { Viewport } from "./geometry-types.ts";
+import { createUnavailableGeometryCoverage } from "./geometry-index.ts";
 
 const INERT_VIEWPORT: Viewport = Object.freeze({
   scrollLeftPx: 0,
@@ -20,6 +21,8 @@ const INERT_VIEWPORT: Viewport = Object.freeze({
 
 export function createInertGeometryFacet(): GeometryFacet {
   return {
+    getGeometryIndex: () => null,
+    getGeometryCoverage: () => createUnavailableGeometryCoverage(),
     hitTest: () => null,
     getAnchorRects: () => [],
     getAnchor: () => null,

package/src/runtime/geometry/replacement-envelope.ts

@@ -75,7 +75,7 @@ export function resolveReplacementEnvelope(
     if (!Number.isFinite(from) || !Number.isFinite(to)) return null;
     const rects = resolveSelectionRects(frame, { from, to, story });
     if (rects.length === 0) return null;
-    return buildBundle(rects, "exact");
+    return buildBundle(frame, rects, "exact");
   }
 
   // Detached: project the last-known range and tag confidence as such.
@@ -83,10 +83,11 @@ export function resolveReplacementEnvelope(
   if (!Number.isFinite(from) || !Number.isFinite(to)) return null;
   const rects = resolveSelectionRects(frame, { from, to, story });
   if (rects.length === 0) return null;
-  return buildBundle(rects, "detached");
+  return buildBundle(frame, rects, "detached");
 }
 
 function buildBundle(
+  frame: RenderFrame,
   rects: readonly GeometryRect[],
   confidence: EnvelopeBundle["confidence"],
 ): EnvelopeBundle {
@@ -104,8 +105,17 @@ function buildBundle(
   const rectPrecision = coarsestRectPrecision(rects);
   const envelopePrecision: EnvelopeBundle["precision"] =
     confidence === "detached" ? "heuristic" : rectPrecision;
+  const pageIds = resolveIntersectingPageIds(frame, rects);
   return {
     scopeRects: rects,
+    pageIds,
+    continuation: {
+      pageIds,
+      pageCount: pageIds.length,
+      crossesPageBoundary: pageIds.length > 1,
+      continuedFromPreviousPage: false,
+      continuesToNextPage: false,
+    },
     attachPoint: {
       xPx: first.leftPx,
       yPx: first.topPx,
@@ -113,10 +123,39 @@ function buildBundle(
     },
     confidence,
     linesCrossed: rects.length,
+    rehydrationStatus:
+      confidence === "detached" ? "requires-rehydration" : "realized",
     precision: envelopePrecision,
   };
 }
 
+function resolveIntersectingPageIds(
+  frame: RenderFrame,
+  rects: readonly GeometryRect[],
+): readonly string[] {
+  if (!Array.isArray(frame.pages)) return [];
+  const ids: string[] = [];
+  for (const page of frame.pages) {
+    if (rects.some((rect) => intersects(rect, page.frame))) {
+      ids.push(page.page.pageId);
+    }
+  }
+  return ids;
+}
+
+function intersects(rect: GeometryRect, page: { leftPx: number; topPx: number; widthPx: number; heightPx: number }): boolean {
+  const rectRight = rect.leftPx + rect.widthPx;
+  const rectBottom = rect.topPx + rect.heightPx;
+  const pageRight = page.leftPx + page.widthPx;
+  const pageBottom = page.topPx + page.heightPx;
+  return (
+    rect.leftPx <= pageRight &&
+    rectRight >= page.leftPx &&
+    rect.topPx <= pageBottom &&
+    rectBottom >= page.topPx
+  );
+}
+
 function coarsestRectPrecision(
   rects: readonly GeometryRect[],
 ): "exact" | "within-tolerance" | "heuristic" {

package/src/runtime/layout/layout-engine-version.ts

@@ -1031,8 +1031,23 @@
  *   content instead of checking only top-level paragraphs. This honors
  *   `<w:br w:type="page"/>` inside cover-page SDTs such as the CCEP SOW
  *   template, changing page assignment from the v61 cache shape.
+ *
+ *  63 — PE2 geometry-projection substrate (Layer 05). Adds the new
+ *   geometry-index module (`src/runtime/geometry/geometry-index.ts`,
+ *   `geometry-facet.ts`, `caret-geometry.ts`, `replacement-envelope.ts`,
+ *   `inert-geometry-facet.ts`, `geometry-types.ts`, `index.ts`) and
+ *   advances the geometry projections that downstream caches consume.
+ *   Persisted layout caches keyed on the v62 geometry shape must
+ *   re-derive. Shipped via pe2 commits `957069161` + `1f36767d7`.
+ *
+ *  64 — PE2 Slice 2 page-frame graph substrate (Layer 04). `RuntimePageNode`
+ *   built by L04 now carries a twips-only `RuntimePageFrame` payload, explicit
+ *   `rectTwips` on resolved page regions, and typed layout divergence lists.
+ *   Existing `regions` remain the compatibility surface, but cache envelopes
+ *   from v63 invalidate because the page graph payload shape changed.
+ *   Shipped via pe2 commit `24a316af2`.
  */
-export const LAYOUT_ENGINE_VERSION = 62 as const;
+export const LAYOUT_ENGINE_VERSION = 64 as const;
 
 /**
  * Serialization schema version for the LayCache payload (the cache envelope

package/src/runtime/layout/page-graph.ts

@@ -48,6 +48,12 @@ import type { ResolvedDocumentSection } from "../document-layout.ts";
 export type {
   RuntimePageRegions,
   RuntimePageRegion,
+  RuntimeTwipsRect,
+  RuntimeResolvedRegions,
+  RuntimeExclusionZone,
+  RuntimeLayoutDivergenceKind,
+  RuntimeLayoutDivergence,
+  RuntimePageFrame,
   RuntimeBlockFragment,
   RuntimeLineBox,
   RuntimeNoteAllocation,
@@ -62,11 +68,15 @@ export type {
 
 import type {
   RuntimeBlockFragment,
+  RuntimeLayoutDivergence,
   RuntimeLineBox,
   RuntimeNoteAllocation,
   RuntimePageAnchor,
+  RuntimePageFrame,
   RuntimePageRegion,
   RuntimePageRegions,
+  RuntimeResolvedRegions,
+  RuntimeTwipsRect,
 } from "../../model/layout/page-graph-types.ts";
 import type {
   RuntimePageGraph,
@@ -164,6 +174,24 @@ export function buildPageGraph(
       input.noteAllocations?.get(pageId) ??
       [];
 
+    const frameId = buildPageFrameId(
+      page.pageIndex,
+      page.sectionIndex,
+      stories.displayPageNumber,
+    );
+    const regions = buildRegions(page.layout, bodyPageFragments, stories, pageNoteAllocations);
+    const divergences = detectFrameDivergences(frameId, regions);
+    const frame = buildPageFrame({
+      frameId,
+      pageId,
+      pageIndex: page.pageIndex,
+      sectionIndex: page.sectionIndex,
+      displayPageNumber: stories.displayPageNumber,
+      layout: page.layout,
+      regions,
+      divergences,
+    });
+
     const node: RuntimePageNode = {
       pageId,
       pageIndex: page.pageIndex,
@@ -173,7 +201,9 @@ export function buildPageGraph(
       endOffset: page.endOffset,
       layout: page.layout,
       stories,
-      regions: buildRegions(page.layout, bodyPageFragments, stories, pageNoteAllocations),
+      regions,
+      frame,
+      divergences,
       lineBoxes:
         input.lineBoxesByPageIndex?.get(page.pageIndex) ??
         input.lineBoxesByPageIndex?.get(index) ??
@@ -240,6 +270,12 @@ function buildRegions(
         originTwips: layout.pageHeight - layout.marginBottom - totalNoteHeight,
         widthTwips: Math.max(0, bodyWidth),
         heightTwips: Math.max(0, totalNoteHeight),
+        rectTwips: rect(
+          layout.marginLeft,
+          layout.pageHeight - layout.marginBottom - totalNoteHeight,
+          Math.max(0, bodyWidth),
+          Math.max(0, totalNoteHeight),
+        ),
         fragmentIds,
       };
       bodyHeight = Math.max(0, bodyHeight - totalNoteHeight);
@@ -251,6 +287,7 @@ function buildRegions(
     originTwips: layout.marginTop,
     widthTwips: Math.max(0, bodyWidth),
     heightTwips: Math.max(0, bodyHeight),
+    rectTwips: rect(layout.marginLeft, layout.marginTop, Math.max(0, bodyWidth), Math.max(0, bodyHeight)),
     fragmentIds: [...bodyFragmentIds],
   };
 
@@ -262,6 +299,12 @@ function buildRegions(
       originTwips: layout.headerMargin ?? 720,
       widthTwips: Math.max(0, bodyWidth),
       heightTwips: Math.max(0, layout.marginTop - (layout.headerMargin ?? 720)),
+      rectTwips: rect(
+        layout.marginLeft,
+        layout.headerMargin ?? 720,
+        Math.max(0, bodyWidth),
+        Math.max(0, layout.marginTop - (layout.headerMargin ?? 720)),
+      ),
       fragmentIds: [],
     };
   }
@@ -271,6 +314,12 @@ function buildRegions(
       originTwips: layout.pageHeight - layout.marginBottom,
       widthTwips: Math.max(0, bodyWidth),
       heightTwips: Math.max(0, layout.marginBottom - (layout.footerMargin ?? 720)),
+      rectTwips: rect(
+        layout.marginLeft,
+        layout.pageHeight - layout.marginBottom,
+        Math.max(0, bodyWidth),
+        Math.max(0, layout.marginBottom - (layout.footerMargin ?? 720)),
+      ),
       fragmentIds: [],
     };
   }
@@ -299,6 +348,12 @@ function buildRegions(
         originTwips: layout.marginTop,
         widthTwips: perColumnWidth,
         heightTwips: Math.max(0, bodyHeight),
+        rectTwips: rect(
+          layout.marginLeft + i * (perColumnWidth + gap),
+          layout.marginTop,
+          perColumnWidth,
+          Math.max(0, bodyHeight),
+        ),
         fragmentIds: perColumnIds[i]!,
       });
     }
@@ -312,6 +367,141 @@ function buildRegions(
   return regions;
 }
 
+function rect(
+  xTwips: number,
+  yTwips: number,
+  widthTwips: number,
+  heightTwips: number,
+): RuntimeTwipsRect {
+  return { xTwips, yTwips, widthTwips, heightTwips };
+}
+
+function buildPageFrame(input: {
+  frameId: string;
+  pageId: string;
+  pageIndex: number;
+  sectionIndex: number;
+  displayPageNumber: number;
+  layout: PageLayoutSnapshot;
+  regions: RuntimePageRegions;
+  divergences: readonly RuntimeLayoutDivergence[];
+}): RuntimePageFrame {
+  const regions: RuntimeResolvedRegions = {
+    body: input.regions.body,
+    exclusionZones: [],
+    ...(input.regions.header ? { header: input.regions.header } : {}),
+    ...(input.regions.footer ? { footer: input.regions.footer } : {}),
+    ...(input.regions.columns ? { columns: input.regions.columns } : {}),
+    ...(input.regions.footnotes ? { footnotes: input.regions.footnotes } : {}),
+  };
+  const divergenceIds = input.divergences.map((d) => d.divergenceId);
+  return {
+    frameId: input.frameId,
+    pageId: input.pageId,
+    pageIndex: input.pageIndex,
+    sectionIndex: input.sectionIndex,
+    displayPageNumber: input.displayPageNumber,
+    physicalBoundsTwips: rect(0, 0, input.layout.pageWidth, input.layout.pageHeight),
+    regions,
+    divergenceIds,
+    signature: buildPageFrameSignature(input, divergenceIds),
+  };
+}
+
+function buildPageFrameId(
+  pageIndex: number,
+  sectionIndex: number,
+  displayPageNumber: number,
+): string {
+  return `page-frame-${pageIndex}-section-${sectionIndex}-display-${displayPageNumber}`;
+}
+
+function buildPageFrameSignature(
+  input: {
+    pageIndex: number;
+    sectionIndex: number;
+    displayPageNumber: number;
+    layout: PageLayoutSnapshot;
+    regions: RuntimePageRegions;
+  },
+  divergenceIds: readonly string[],
+): string {
+  const regionParts = collectRegions(input.regions).map((region) => {
+    const r = region.rectTwips ?? rect(0, region.originTwips, region.widthTwips, region.heightTwips);
+    return [
+      region.kind,
+      r.xTwips,
+      r.yTwips,
+      r.widthTwips,
+      r.heightTwips,
+      region.fragmentIds.length,
+    ].join(":");
+  });
+  return [
+    "page-frame",
+    input.pageIndex,
+    input.sectionIndex,
+    input.displayPageNumber,
+    input.layout.pageWidth,
+    input.layout.pageHeight,
+    ...regionParts,
+    ...divergenceIds,
+  ].join("|");
+}
+
+function detectFrameDivergences(
+  frameId: string,
+  regions: RuntimePageRegions,
+): RuntimeLayoutDivergence[] {
+  const candidates = collectRegions(regions).filter((region) => region.rectTwips !== undefined);
+  const divergences: RuntimeLayoutDivergence[] = [];
+  for (let i = 0; i < candidates.length; i += 1) {
+    for (let j = i + 1; j < candidates.length; j += 1) {
+      const a = candidates[i]!;
+      const b = candidates[j]!;
+      if (!shouldDetectCollision(a, b)) continue;
+      if (!rectsOverlap(a.rectTwips!, b.rectTwips!)) continue;
+      const kinds = [a.kind, b.kind].sort();
+      divergences.push({
+        divergenceId: `${frameId}:frame-collision:${kinds.join("-")}`,
+        kind: "frame-collision",
+        source: "runtime",
+        severity: "warning",
+        message: `Resolved page regions overlap: ${kinds.join(" / ")}`,
+        regionKinds: kinds as RuntimeLayoutDivergence["regionKinds"],
+        fragmentIds: [...a.fragmentIds, ...b.fragmentIds],
+      });
+    }
+  }
+  return divergences;
+}
+
+function collectRegions(regions: RuntimePageRegions): RuntimePageRegion[] {
+  return [
+    regions.body,
+    ...(regions.header ? [regions.header] : []),
+    ...(regions.footer ? [regions.footer] : []),
+    ...(regions.columns ?? []),
+    ...(regions.footnotes ?? []),
+  ];
+}
+
+function shouldDetectCollision(a: RuntimePageRegion, b: RuntimePageRegion): boolean {
+  if (a.kind === "body" && b.kind === "column") return false;
+  if (a.kind === "column" && b.kind === "body") return false;
+  if (a.kind === "column" && b.kind === "column") return false;
+  return true;
+}
+
+function rectsOverlap(a: RuntimeTwipsRect, b: RuntimeTwipsRect): boolean {
+  return (
+    a.xTwips < b.xTwips + b.widthTwips &&
+    a.xTwips + a.widthTwips > b.xTwips &&
+    a.yTwips < b.yTwips + b.heightTwips &&
+    a.yTwips + a.heightTwips > b.yTwips
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Graph queries
 // ---------------------------------------------------------------------------