@beyondwork/docx-react-component 1.0.67 → 1.0.70

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

@@ -56,11 +56,12 @@ import {
   type MarginPresetDefinition,
   type ActiveMarginPreset,
 } from "./margin-preset-catalog.ts";
-import {
-  attachScopeCardModel,
-  collectScopeRailSegments,
-  type ScopeRailSegment,
-} from "../workflow-rail-segments.ts";
+// ScopeRailSegment type is still re-exported from this module so
+// chrome/overlay consumers (`tw-scope-rail-layer.tsx` etc.) can
+// continue to import segment types via `../../runtime/layout`. Rail
+// composition itself is Layer-06 (see workflow/coordinator.ts +
+// runtime.workflow) — the layout facet only supplies the page graph.
+import type { ScopeRailSegment } from "../workflow/rail/compose.ts";
 import { createEditorSurfaceSnapshot } from "../surface-projection.ts";
 import { storyTargetKey } from "../story-targeting.ts";
 import { MAIN_STORY_TARGET } from "../../core/selection/mapping.ts";
@@ -68,9 +69,25 @@ import {
   createSelectionSnapshot,
   type CanonicalDocumentEnvelope,
 } from "../../core/state/editor-state.ts";
-import { resolveTableStyleResolution } from "../table-style-resolver.ts";
+// L03 production boundary: layout delegates every table-style cascade
+// through `FormattingContext.resolveTable` so the same hot-path entry is
+// used in surface-projection and here. Direct imports of the table-style
+// resolver from non-Layer-03 code are rejected by
+// `scripts/ci-check-formatting-production-boundary.mjs`.
+import { createFormattingContext } from "../formatting/formatting-context.ts";
+import type { ResolvedTableStyleResolution } from "../formatting/table-style-resolver.ts";
 import { buildTableRenderPlan } from "./table-render-plan.ts";
-import { recordPerfSample } from "../../ui-tailwind/editor-surface/perf-probe.ts";
+// Geometry helpers are no longer imported here:
+//  - `hitTest` + `getAnchorRects` moved to the geometry facet in the
+//    refactor/05 Slice 6 wrapper-deletion pass (2026-04-22).
+//  - `collectScopeRailSegmentsForQuery` is no longer needed because
+//    refactor/06 Slice 4C moved rail-segment composition to
+//    `runtime.workflow.*`; the layout facet supplies the page graph
+//    as input, not the rail output.
+import { collectLineBoxesForRegion } from "../geometry/project-fragments.ts";
+// `recordPerfSample` no longer imported — used only by the removed
+// `hitTest` wrapper to emit `chrome.hit_test` samples. Geometry facet
+// can add its own instrumentation at call site if needed.
 import type {
   SurfaceBlockSnapshot,
 } from "../../api/public-types";
@@ -84,6 +101,31 @@ export type {
 
 export type { ScopeRailSegment };
 
+// ---------------------------------------------------------------------------
+// Module-level warning emitter (D1 silent-success probes)
+// ---------------------------------------------------------------------------
+
+type LayoutWarningEmitter = (type: string, guard: string, inputs: Record<string, unknown>) => void;
+let _activeLayoutWarningEmitter: LayoutWarningEmitter | undefined;
+
+export function setActiveLayoutWarningEmitter(fn: LayoutWarningEmitter | undefined): void {
+  _activeLayoutWarningEmitter = fn;
+}
+
+/**
+ * Exported so debug-infra D1 probes at layout-semantic guards that have
+ * physically moved into `src/runtime/geometry/**` (Slice 2a+ of refactor/05)
+ * can continue to emit through the same `setActiveLayoutWarningEmitter`
+ * pipeline as the remaining in-facet probes. The emit surface is unchanged;
+ * only the call-site location moved.
+ */
+export function emitLayoutGuardWarning(
+  guard: string,
+  inputs: Record<string, unknown>,
+): void {
+  _activeLayoutWarningEmitter?.(`layout.guard.return-empty`, guard, inputs);
+}
+
 // ---------------------------------------------------------------------------
 // Public read model types (shape-stable, cloned at the facet boundary)
 // ---------------------------------------------------------------------------
@@ -397,6 +439,13 @@ export interface WordReviewEditorLayoutFacet {
   // Per-page semantic reads ---------------------------------------------
   getActiveStoriesOnPage(pageIndex: number): PublicResolvedPageStories | null;
   getDisplayPageNumber(pageIndex: number): number | null;
+  /**
+   * @deprecated Use `GeometryFacet.getLineBoxes` (refactor/05 layer 05).
+   * Both paths route through
+   * `src/runtime/geometry/project-fragments.ts::collectLineBoxesForRegion`;
+   * this wrapper is retained for back-compat and will be deleted after
+   * consumers migrate.
+   */
   getLineBoxes(
     pageIndex: number,
     options?: { region?: PublicPageRegion["kind"]; columnIndex?: number },
@@ -448,66 +497,31 @@ export interface WordReviewEditorLayoutFacet {
   getMarginPresetCatalog(): readonly MarginPresetDefinition[];
   getActiveMarginPreset(sectionIndex: number): ActiveMarginPreset | null;
 
-  // Render-frame access (R1) --------------------------------------------
-  /**
-   * Return the active `RenderFrame` produced by the runtime-owned render
-   * kernel.  Optional when the host runtime has not yet installed a kernel
-   * — returns `null` in that case so consumers can fall back to the page-
-   * graph reads above.
-   */
-  getRenderFrame?(
-    options?: import("../render/index.ts").RenderFrameQueryOptions,
-  ): import("../render/index.ts").RenderFrame | null;
-
-  /** Return the render-kernel zoom, if a kernel is installed. */
-  getRenderZoom?(): import("../render/index.ts").RenderZoom | null;
-
-  /**
-   * Hit-test a point in the mounted shell's coordinate space against the
-   * current render frame.  Returns the deepest matching region with runtime
-   * offset, block id, fragment id, and line index so chrome surfaces can
-   * turn mouse coordinates into canonical positions without consulting the
-   * DOM.  Returns `null` when no kernel is installed, or when the point
-   * falls outside every page.
-   */
-  hitTest?(
-    pointInRoot: import("../render/index.ts").RenderPoint,
-  ): import("../render/index.ts").RenderHitResult | null;
-
-  /**
-   * Resolve anchor rects for a `RenderAnchorQuery`.  Returns `[]` when the
-   * kernel is absent or the query does not match any anchor.  Chrome
-   * surfaces that need a single rect can read `getAnchorRects(q)[0]`;
-   * selection-spanning surfaces read the full list and union as needed.
-   */
-  getAnchorRects?(
-    query: import("../render/index.ts").RenderAnchorQuery,
-  ): readonly import("../render/index.ts").RenderFrameRect[];
-
-  // Scope rail segments (R3a) -------------------------------------------
-  /**
-   * Return workflow rail segments active on a given page.  Returns an empty
-   * list when the host runtime did not supply workflow data to the facet.
-   */
-  getScopeRailSegments(
-    pageIndex: number,
-  ): readonly import("../workflow-rail-segments.ts").ScopeRailSegment[];
-  /** Return every scope rail segment across the document. */
-  getAllScopeRailSegments(): readonly import("../workflow-rail-segments.ts").ScopeRailSegment[];
-
-  /**
-   * Scope-card projection consumed by the chrome overlay's card layer
-   * (scope-card-overlay P1).  Joins every unique scope segment with
-   * its attached issue metadata (R2 `ISSUE_METADATA_ID`), its
-   * work-item id, and its `primaryAnchorRect` via the render kernel's
-   * anchor index.  P2 fields (`suggestionGroupIds`,
-   * `reviewActionCount`, `agentPending`) are defaulted to empty /
-   * zero / false in P1 and populated by later phases.
-   *
-   * Returns an empty list when no workflow rail input has been wired
-   * or when no scopes are currently on the active story.
-   */
-  getAllScopeCardModels(): readonly import("../../api/public-types.ts").ScopeCardModel[];
+  // `getRenderFrame` + `getRenderZoom` — REMOVED from the layout facet
+  // in the refactor/05 cross-lane-coord §8.4–§8.6 pass (2026-04-22).
+  // Both are pure render-kernel passthroughs — architecturally
+  // geometry-layer concerns, not layout. Consumers must call them
+  // through `runtime.geometry.getRenderFrame` / `.getRenderZoom`.
+  // Post-deletion the layout facet exposes layout-only reads; all five
+  // UI chrome consumers (selection-anchor resolver, object-selection
+  // overlay, table-grip layer, scope-rail layer, PM surface) were
+  // migrated to `runtime.geometry` in the same pass.
+
+  // `hitTest` + `getAnchorRects` — REMOVED in the refactor/05 Slice 6
+  // wrapper-deletion pass (2026-04-22). Both operate on pixel rects
+  // projected from the render frame — pure Layer-05 concerns. Consumers
+  // must call them through `runtime.geometry.hitTest` /
+  // `runtime.geometry.getAnchorRects`. The pure helpers live at
+  // `src/runtime/geometry/hit-test.ts::resolveHitTest` and
+  // `src/runtime/geometry/project-anchors.ts::resolveAnchorRects`.
+
+  // Scope-rail / scope-card composition is Layer-06 owned (W7).
+  // Consume via `runtime.workflow.getRailSegments(pageIndex)` /
+  // `runtime.workflow.getAllRailSegments()` /
+  // `runtime.workflow.getAllScopeCardModels()`. Layer-06 Slice 4
+  // (rail-seam inversion, 2026-04-22) removed the deprecated shims
+  // that previously lived here. The layout facet supplies page-graph
+  // input only; it is not the consumer seam for workflow data.
 
   // Measurement exposure -------------------------------------------------
   getResolvedFormatting(blockId: string): PublicResolvedParagraphFormatting | null;
@@ -546,20 +560,6 @@ export interface WordReviewEditorLayoutFacet {
     pageIndex: number,
   ): import("./table-render-plan.ts").TableRenderPlan | null;
 
-  // Table render plan (P3e consumed by the render kernel, P4) ------------
-  /**
-   * Build a `TableRenderPlan` for a table block on a given page. Returns
-   * `null` when the blockId does not resolve to a table in the current
-   * surface. The plan carries columnsTwips, bandClasses, verticalMerges,
-   * repeatedHeaderRows, and columnResizeHandles so chrome can render
-   * band-aware cell styling and place column-resize grips without
-   * walking canonical state.
-   */
-  getTableRenderPlan(
-    blockId: string,
-    pageIndex: number,
-  ): import("./table-render-plan.ts").TableRenderPlan | null;
-
   /**
    * Returns the Y offset (in twips from the top of the page body) where this
    * table fragment starts on the given page. Computed by summing
@@ -612,30 +612,12 @@ export interface CreateLayoutFacetInput {
     | import("../render/index.ts").RenderKernel
     | null
     | undefined;
-  /**
-   * Optional workflow-segments accessor.  When supplied, the facet computes
-   * `getScopeRailSegments` / `getAllScopeRailSegments` by joining the host-
-   * supplied workflow state with the current page graph.  When omitted,
-   * both methods return empty arrays.
-   */
-  getWorkflowRailInput?: () =>
-    | Omit<
-        import("../workflow-rail-segments.ts").CollectScopeRailSegmentsInput,
-        "pageGraph"
-      >
-    | null
-    | undefined;
-  /**
-   * Optional workflow-metadata accessor for scope-card issue resolution
-   * (R2 / scope-card-overlay P1).  Returns the
-   * `WorkflowMarkupSnapshot.metadata` array so `getAllScopeCardModels`
-   * can attach issue values to their scopes.  Omit when the host does
-   * not push metadata entries.
-   */
-  getWorkflowMarkupMetadata?: () =>
-    | readonly import("../../api/public-types.ts").WorkflowMetadataMarkup[]
-    | null
-    | undefined;
+  // Scope-rail input accessors (`getWorkflowRailInput`,
+  // `getWorkflowMarkupMetadata`, `getSuggestionsSnapshot`) removed by
+  // Layer-06 Slice 4. Workflow rail / scope-card composition is now
+  // owned end-to-end by the coordinator + runtime.workflow facet; the
+  // layout facet only supplies the page graph as input, it does not
+  // consume workflow data.
   /**
    * L7 Phase 2 — optional viewport culling hooks wired from the owning
    * `DocumentRuntime`.  When supplied, `facet.setVisibleBlockRange` /
@@ -644,15 +626,6 @@ export interface CreateLayoutFacetInput {
    */
   setVisibleBlockRange?: (range: { start: number; end: number }) => void;
   requestViewportRefresh?: () => void;
-  /**
-   * R3 — optional suggestions snapshot accessor.  Used by
-   * `getAllScopeCardModels` to attach `SuggestionGroup` entries whose
-   * `issueId` matches the scope's issue.  Omit to skip group wiring.
-   */
-  getSuggestionsSnapshot?: () =>
-    | import("../../api/public-types.ts").SuggestionsSnapshot
-    | null
-    | undefined;
 }
 
 export function createLayoutFacet(
@@ -832,10 +805,20 @@ export function createLayoutFacet(
       return resolveFootnoteAreaRegionBlocks(node, document);
     }
     if (region === "column") {
-      // Multi-column body splitting is a P10 follow-up.  For now reuse
-      // the body fragments for the indexed column.
-      void columnIndex;
-      return resolveBodyRegionBlocks(node, graph, findBodyBlockById);
+      // Refactor/04 Slice 4 follow-up — resolve per-column fragment
+      // ids against the live `regions.columns[columnIndex].fragmentIds`
+      // populated by `buildRegions`. Single-column pages leave
+      // `regions.columns === undefined` (F01 + CCEP single-column
+      // regression preserved), so the column branch returns empty
+      // there. Out-of-range `columnIndex` also returns empty rather
+      // than wrapping or throwing — the caller's query was outside
+      // the published column count for this page.
+      return resolveColumnRegionBlocks(
+        node,
+        graph,
+        findBodyBlockById,
+        columnIndex ?? 0,
+      );
     }
     // endnote-area: empty per-page; document-end via getDocumentEndnoteBlocks.
     return Object.freeze([]);
@@ -931,7 +914,10 @@ export function createLayoutFacet(
     getLineBoxes(pageIndex, options) {
       const graph = currentGraph();
       const node = graph.pages[pageIndex];
-      if (!node) return [];
+      if (!node) {
+        emitLayoutGuardWarning("getLineBoxes", { pageIndex });
+        return [];
+      }
       const region = options?.region ?? "body";
       return collectLineBoxesForRegion(
         node,
@@ -944,7 +930,10 @@ export function createLayoutFacet(
     getLineBoxesForRegion(pageIndex, region, options) {
       const graph = currentGraph();
       const node = graph.pages[pageIndex];
-      if (!node) return [];
+      if (!node) {
+        emitLayoutGuardWarning("getLineBoxesForRegion", { pageIndex, region });
+        return [];
+      }
       return collectLineBoxesForRegion(
         node,
         region,
@@ -956,7 +945,10 @@ export function createLayoutFacet(
     getStoryRegionsOnPage(pageIndex) {
       const graph = currentGraph();
       const node = graph.pages[pageIndex];
-      if (!node) return [];
+      if (!node) {
+        emitLayoutGuardWarning("getStoryRegionsOnPage", { pageIndex });
+        return [];
+      }
       const result: PublicPageRegion[] = [];
       // Render order: header → body → columns → footer → footnote-area.
       if (node.regions.header) {
@@ -1089,75 +1081,20 @@ export function createLayoutFacet(
       });
     },
 
-    getRenderFrame(options) {
-      const kernel = input.renderKernel?.();
-      if (!kernel) return null;
-      return kernel.getRenderFrame(options);
-    },
-
-    getRenderZoom() {
-      const kernel = input.renderKernel?.();
-      if (!kernel) return null;
-      return kernel.getZoom();
-    },
-
-    hitTest(pointInRoot) {
-      const kernel = input.renderKernel?.();
-      if (!kernel) return null;
-      const t0 = typeof performance !== "undefined" ? performance.now() : 0;
-      const frame = kernel.getRenderFrame();
-      const result = resolveHitTest(frame, pointInRoot);
-      if (t0 > 0) recordPerfSample("chrome.hit_test", performance.now() - t0);
-      return result;
-    },
-
-    getAnchorRects(query) {
-      const kernel = input.renderKernel?.();
-      if (!kernel) return [];
-      const frame = kernel.getRenderFrame();
-      return resolveAnchorRects(frame, query);
-    },
-
-    getScopeRailSegments(pageIndex) {
-      return collectScopeRailSegmentsForQuery(
-        input.getWorkflowRailInput?.(),
-        currentGraph(),
-      ).filter((segment) => segment.pageIndex === pageIndex);
-    },
-
-    getAllScopeRailSegments() {
-      return collectScopeRailSegmentsForQuery(
-        input.getWorkflowRailInput?.(),
-        currentGraph(),
-      );
-    },
-
-    getAllScopeCardModels() {
-      const railInput = input.getWorkflowRailInput?.();
-      const segments = collectScopeRailSegmentsForQuery(railInput, currentGraph());
-      if (segments.length === 0) return [];
-      const kernel = input.renderKernel?.();
-      const anchorIndex = kernel?.getRenderFrame?.()?.anchorIndex ?? null;
-      const metadata = input.getWorkflowMarkupMetadata?.();
-      const suggestions = input.getSuggestionsSnapshot?.() ?? null;
-      // The workflow-markup entries carry BOTH issue and review-action
-      // metadata.  The projector filters to REVIEW_ACTION_METADATA_ID
-      // internally, so we can just pass the whole list.
-      return attachScopeCardModel({
-        segments,
-        scopes: railInput?.scopes ?? [],
-        metadata: metadata ?? undefined,
-        anchorIndex,
-        suggestions,
-        reviewActionMetadata: metadata ?? undefined,
-        candidates: railInput?.candidates ?? undefined,
-      });
-    },
+    // `getRenderFrame` + `getRenderZoom` — removed in refactor/05
+    // cross-lane-coord §8 pass. Geometry concerns; call through
+    // `runtime.geometry.getRenderFrame` / `.getRenderZoom`.
+    // `hitTest` + `getAnchorRects` — removed in refactor/05 Slice 6
+    // wrapper-deletion pass. Geometry concerns; call through
+    // `runtime.geometry.hitTest` / `runtime.geometry.getAnchorRects`.
 
     getFragmentsForPage(pageIndex) {
       const graph = currentGraph();
       const node = graph.pages[pageIndex];
-      if (!node) return [];
+      if (!node) {
+        emitLayoutGuardWarning("getFragmentsForPage", { pageIndex });
+        return [];
+      }
       return graph.fragments
         .filter((f) => f.pageId === node.pageId)
         .map((f) => toPublicBlockFragment(f, graph));
@@ -1659,257 +1596,22 @@ function findPageForOffsetAndStory(
   return null;
 }
 
-/**
- * Select line boxes that belong to a given region on a page.
- *
- * `body` returns the engine's per-page measured line boxes (one per
- * line of paginated body content).
- *
- * `header` / `footer` / `footnote-area` / `column` (P4): synthesizes
- * one line box per fragment in the region.  Header/footer fragments
- * aren't paginated themselves — the engine reserves space for the
- * entire header story per page — so per-line measurements are not
- * available.  The synthesized line box uses each fragment's
- * `heightTwips` as the line height with cumulative `baselineTwips`
- * from the region origin.  This gives consumers (page stack, P8
- * region rendering) a uniform iteration shape across regions.
- *
- * `endnote-area` always returns empty: endnote bodies are emitted at
- * the document end as a separate region whose layout sits outside
- * the per-page accounting.
- */
-function collectLineBoxesForRegion(
-  node: RuntimePageNode,
-  region: PublicPageRegion["kind"],
-  graph: RuntimePageGraph,
-  columnIndex: number | undefined,
-): readonly RuntimeLineBoxAlias[] {
-  if (region === "body") {
-    return node.lineBoxes;
-  }
-  // P4: synthesize line boxes from the region's fragments.
-  const regionEntry = resolveRegionEntry(node, region, columnIndex);
-  if (!regionEntry || regionEntry.fragmentIds.length === 0) {
-    return EMPTY_LINE_BOXES;
-  }
-  const fragmentsById = new Map(
-    graph.fragments.map((f) => [f.fragmentId, f] as const),
-  );
-  const result: RuntimeLineBoxAlias[] = [];
-  let cursorTwips = 0;
-  let lineIndex = 0;
-  for (const fragmentId of regionEntry.fragmentIds) {
-    const fragment = fragmentsById.get(fragmentId);
-    if (!fragment) continue;
-    const heightTwips = Math.max(1, fragment.heightTwips);
-    result.push({
-      fragmentId,
-      lineIndex: lineIndex++,
-      baselineTwips: cursorTwips + heightTwips,
-      heightTwips,
-      widthTwips: regionEntry.widthTwips,
-    });
-    cursorTwips += heightTwips;
-  }
-  return result;
-}
-
-function resolveRegionEntry(
-  node: RuntimePageNode,
-  region: PublicPageRegion["kind"],
-  columnIndex: number | undefined,
-): RuntimePageRegion | undefined {
-  switch (region) {
-    case "header":
-      return node.regions.header;
-    case "footer":
-      return node.regions.footer;
-    case "column": {
-      const columns = node.regions.columns ?? [];
-      if (columns.length === 0) return undefined;
-      const idx = columnIndex ?? 0;
-      return columns[idx];
-    }
-    case "footnote-area": {
-      // Footnote area sits at the bottom of the body region per
-      // OOXML.  `RuntimePageRegions.footnotes` is a stable seam
-      // declared by P4; the page-graph builder populates entries
-      // when P8 lands.  Returns the first footnote region (page
-      // layouts allocate one block of footnotes per page; multi-
-      // block layouts come later).
-      const footnoteRegionList = node.regions.footnotes;
-      if (footnoteRegionList && footnoteRegionList.length > 0) {
-        return footnoteRegionList[0];
-      }
-      return undefined;
-    }
-    default:
-      return undefined;
-  }
-}
-
-// Use a shared alias so the region helper doesn't import the runtime
-// `RuntimeLineBox` type redundantly (`lineBoxes` is already strongly typed on
-// `RuntimePageNode`).
-type RuntimeLineBoxAlias = RuntimePageNode["lineBoxes"][number];
-const EMPTY_LINE_BOXES: readonly RuntimeLineBoxAlias[] = Object.freeze([]);
-
-/**
- * Join the host-supplied workflow rail input with the current page graph.
- * Returns an empty array when no input is available so callers can always
- * iterate without null-checking.
- */
-function collectScopeRailSegmentsForQuery(
-  input:
-    | Omit<
-        import("../workflow-rail-segments.ts").CollectScopeRailSegmentsInput,
-        "pageGraph"
-      >
-    | null
-    | undefined,
-  graph: RuntimePageGraph,
-): ScopeRailSegment[] {
-  if (!input) return [];
-  return collectScopeRailSegments({ ...input, pageGraph: graph });
-}
-
-function resolveHitTest(
-  frame: import("../render/index.ts").RenderFrame | null,
-  point: import("../render/index.ts").RenderPoint,
-): import("../render/index.ts").RenderHitResult | null {
-  if (!frame) return null;
-  for (const page of frame.pages) {
-    if (!containsPoint(page.frame, point)) continue;
-    const regionHit = hitTestRegion(page, point, "body");
-    if (regionHit) return regionHit;
-    const header = hitTestRegion(page, point, "header");
-    if (header) return header;
-    const footer = hitTestRegion(page, point, "footer");
-    if (footer) return footer;
-  }
-  return null;
-}
-
-function hitTestRegion(
-  page: import("../render/index.ts").RenderPage,
-  point: import("../render/index.ts").RenderPoint,
-  kind: "body" | "header" | "footer",
-): import("../render/index.ts").RenderHitResult | null {
-  const region =
-    kind === "body"
-      ? page.regions.body
-      : kind === "header"
-        ? page.regions.header
-        : page.regions.footer;
-  if (!region) return null;
-  if (!containsPoint(region.frame, point)) return null;
-  for (const block of region.blocks) {
-    if (!containsPoint(block.frame, point)) continue;
-    let bestLineIndex = -1;
-    let bestLineDistance = Number.POSITIVE_INFINITY;
-    for (let i = 0; i < block.lines.length; i++) {
-      const line = block.lines[i]!;
-      const midY = line.frame.topPx + line.frame.heightPx / 2;
-      const distance = Math.abs(midY - point.yPx);
-      if (distance < bestLineDistance) {
-        bestLineDistance = distance;
-        bestLineIndex = i;
-      }
-    }
-    const lineIndex = bestLineIndex >= 0 ? bestLineIndex : 0;
-    const line = block.lines[lineIndex];
-    const runtimeOffset = line?.anchors[0]?.runtimeOffset ?? block.fragment.from;
-    return {
-      pageIndex: page.page.pageIndex,
-      regionKind: region.region.kind,
-      blockId: block.fragment.blockId,
-      fragmentId: block.fragment.fragmentId,
-      lineIndex,
-      runtimeOffset,
-    };
-  }
-  // Point fell inside the region but between blocks — snap to the nearest block.
-  let nearestBlock: import("../render/index.ts").RenderBlock | null = null;
-  let nearestDistance = Number.POSITIVE_INFINITY;
-  for (const block of region.blocks) {
-    const distance = Math.min(
-      Math.abs(point.yPx - block.frame.topPx),
-      Math.abs(point.yPx - (block.frame.topPx + block.frame.heightPx)),
-    );
-    if (distance < nearestDistance) {
-      nearestBlock = block;
-      nearestDistance = distance;
-    }
-  }
-  if (!nearestBlock) return null;
-  return {
-    pageIndex: page.page.pageIndex,
-    regionKind: region.region.kind,
-    blockId: nearestBlock.fragment.blockId,
-    fragmentId: nearestBlock.fragment.fragmentId,
-    lineIndex: 0,
-    runtimeOffset: nearestBlock.fragment.from,
-  };
-}
-
-function containsPoint(
-  rect: import("../render/index.ts").RenderFrameRect,
-  point: import("../render/index.ts").RenderPoint,
-): boolean {
-  return (
-    point.xPx >= rect.leftPx &&
-    point.xPx <= rect.leftPx + rect.widthPx &&
-    point.yPx >= rect.topPx &&
-    point.yPx <= rect.topPx + rect.heightPx
-  );
-}
-
-function resolveAnchorRects(
-  frame: import("../render/index.ts").RenderFrame | null,
-  query: import("../render/index.ts").RenderAnchorQuery,
-): readonly import("../render/index.ts").RenderFrameRect[] {
-  if (!frame) return [];
-  switch (query.kind) {
-    case "runtime-offset": {
-      const offset =
-        typeof query.value === "number" ? query.value : Number(query.value);
-      if (!Number.isFinite(offset)) return [];
-      const rect = frame.anchorIndex.byRuntimeOffset(offset, query.story);
-      return rect ? [rect] : [];
-    }
-    case "block-id": {
-      const rect = frame.anchorIndex.byBlockId(String(query.value));
-      return rect ? [rect] : [];
-    }
-    case "fragment-id": {
-      const rect = frame.anchorIndex.byFragmentId(String(query.value));
-      return rect ? [rect] : [];
-    }
-    case "page-index": {
-      const pageIndex =
-        typeof query.value === "number" ? query.value : Number(query.value);
-      if (!Number.isFinite(pageIndex)) return [];
-      const rect = frame.anchorIndex.byPageIndex(pageIndex);
-      return rect ? [rect] : [];
-    }
-    case "scope-id": {
-      return frame.anchorIndex.byScopeId(String(query.value));
-    }
-    case "comment-id": {
-      const rect = frame.anchorIndex.byCommentId(String(query.value));
-      return rect ? [rect] : [];
-    }
-    case "revision-id": {
-      const rect = frame.anchorIndex.byRevisionId(String(query.value));
-      return rect ? [rect] : [];
-    }
-    default: {
-      const exhaustive: never = query.kind;
-      void exhaustive;
-      return [];
-    }
-  }
-}
+// Line-box collection (`collectLineBoxesForRegion`, `resolveRegionEntry`,
+// `EMPTY_LINE_BOXES`, `RuntimeLineBoxAlias`) and workflow-rail query
+// (`collectScopeRailSegmentsForQuery`) moved to
+// `src/runtime/geometry/project-fragments.ts` +
+// `src/runtime/geometry/project-anchors.ts` in refactor/05 Slice 2b. The
+// facet's `getLineBoxes` / `getScopeRailSegments` / `getAllScopeRailSegments`
+// / `getAllScopeCardModels` methods above now import from there. The D1
+// `emitLayoutGuardWarning` probes (including the
+// `collectScopeRailSegmentsForQuery` null-input probe) are ported alongside
+// via the exported `emitLayoutGuardWarning` symbol — they continue to
+// fire through `setActiveLayoutWarningEmitter`.
+//
+// Hit-test (`resolveHitTest`, `hitTestRegion`, `containsPoint`) and
+// anchor-rect resolution (`resolveAnchorRects`) were moved in Slice 2a.
+// Deletion of the remaining layout-facet wrappers lands in Slice 6 once
+// consumers have flipped to the geometry facet.
 
 // ---------------------------------------------------------------------------
 // Table render plan helpers (P4)
@@ -1968,17 +1670,20 @@ function findTableBlockByBlockId(
 function resolveTableStyleResolutionForPlan(
   surfaceTable: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
   document: LayoutEngineQueryInput["document"],
-): ReturnType<typeof resolveTableStyleResolution> | null {
+): ResolvedTableStyleResolution | null {
   const canonicalTable = findCanonicalTableByBlockId(
     document.content.children,
     surfaceTable.blockId,
     { counter: { value: 0 } },
   );
   if (!canonicalTable) return null;
-  return resolveTableStyleResolution(
-    canonicalTable,
-    document.styles.tables ?? {},
-  );
+  // L03 boundary: delegate through a FormattingContext for this single
+  // call. The context is cheap to construct for a one-shot read; when
+  // `getTableRenderPlan` is called in a batch, the caller's own context
+  // would be preferable, but the current facet signature doesn't thread
+  // one through. Keeping this narrow keeps the production boundary
+  // consistent (no direct sub-resolver imports outside Layer 03).
+  return createFormattingContext(document).resolveTable(canonicalTable);
 }
 
 /**
@@ -2058,6 +1763,46 @@ function resolveBodyRegionBlocks(
   return Object.freeze(blocks);
 }
 
+function resolveColumnRegionBlocks(
+  node: RuntimePageNode,
+  graph: RuntimePageGraph,
+  findBodyBlockById: (blockId: string) => SurfaceBlockSnapshot | undefined,
+  columnIndex: number,
+): readonly PublicRegionBlock[] {
+  // Refactor/04 Slice 4 — per-column block resolution. Reads the live
+  // `regions.columns[columnIndex].fragmentIds` list that `buildRegions`
+  // partitions when the section paginated under a multi-column layout.
+  // Single-column pages leave `regions.columns` undefined; out-of-range
+  // `columnIndex` is a caller contract error we treat gracefully.
+  const columns = node.regions.columns;
+  if (!columns) return Object.freeze([]);
+  const column = columns[columnIndex];
+  if (!column) return Object.freeze([]);
+
+  const fragmentsById = new Map<string, RuntimeBlockFragment>();
+  for (const fragment of graph.fragments) {
+    fragmentsById.set(fragment.fragmentId, fragment);
+  }
+  const blocks: PublicRegionBlock[] = [];
+  for (const fragmentId of column.fragmentIds) {
+    const fragment = fragmentsById.get(fragmentId);
+    if (!fragment) continue;
+    const blockSnapshot = findBodyBlockById(fragment.blockId);
+    if (!blockSnapshot) continue;
+    blocks.push({
+      blockId: fragment.blockId,
+      fragmentId,
+      pageIndex: node.pageIndex,
+      regionKind: "column",
+      runtimeFromOffset: fragment.from,
+      runtimeToOffset: fragment.to,
+      heightTwips: fragment.heightTwips,
+      blockSnapshot,
+    });
+  }
+  return Object.freeze(blocks);
+}
+
 function resolveHeaderFooterRegionBlocks(
   pageIndex: number,
   regionKind: "header" | "footer",