@beyondwork/docx-react-component 1.0.103 → 1.0.104

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

@@ -37,6 +37,7 @@ import type { EditorStoryTarget } from "../../api/public-types";
 import type {
   RenderFrame,
   RenderFrameRect,
+  RenderStoryRegion,
 } from "../render/index.ts";
 import type {
   CaretGeometry,
@@ -86,12 +87,14 @@ export function resolveCaretGeometry(
  * Resolve `GeometryRect[]` for a selection range. Slice 4 produces:
  *   - an empty list when either endpoint can't be resolved
  *   - a single zero-width caret rect when `from === to`
+ *   - one line rect per covered render line when line ranges are available
  *   - a single union rect otherwise (via `frame.anchorIndex.bySelection`)
  *
- * When the kernel's per-line anchor projection matures (Slice 5+), this
- * function flips to emitting one rect per line. The single-rect fallback
- * keeps chrome surfaces that currently call `getAnchorRects({ kind:
- * "runtime-offset", … })[0]` in sync with the new selection API.
+ * The line-aware path still tags rects `within-tolerance`: without per-run
+ * anchors we can identify covered lines but not the first/last glyph bounds.
+ * The single-rect fallback keeps chrome surfaces that currently call
+ * `getAnchorRects({ kind: "runtime-offset", … })[0]` in sync with the
+ * selection API when a frame lacks line boxes.
  */
 export function resolveSelectionRects(
   frame: RenderFrame | null,
@@ -119,14 +122,11 @@ export function resolveSelectionRects(
     return [caret.rect];
   }
 
+  const lineRects = resolveLineSelectionRects(frame, lo, hi, range.story);
+  if (lineRects.length > 0) return lineRects;
+
   const union = frame.anchorIndex.bySelection(lo, hi, range.story);
   if (!union) return [];
-  // Slice 7b (2026-04-22): the substrate returns ONE union rect for any
-  // non-collapsed range. That rect is geometrically correct at the
-  // block level but loses per-line detail — tag it `within-tolerance`
-  // so callers can gate per-line chrome work. When the render kernel
-  // ships per-run anchors (refactor/05 Slice 7 Task 2), this site
-  // upgrades to multiple `"exact"` rects automatically.
   return [toGeometryRect(union, "within-tolerance")];
 }
 
@@ -151,6 +151,78 @@ function toGeometryRect(
   return out;
 }
 
+function resolveLineSelectionRects(
+  frame: RenderFrame,
+  from: number,
+  to: number,
+  story?: EditorStoryTarget,
+): readonly GeometryRect[] {
+  if (!Array.isArray(frame.pages)) return [];
+  const rects: GeometryRect[] = [];
+  for (const page of frame.pages) {
+    for (const region of collectRegions(page.regions)) {
+      if (!storyMatches(region.storyTarget, story)) continue;
+      for (const block of region.blocks) {
+        const blockFrom = block.fragment.from;
+        const blockTo = block.fragment.to;
+        if (blockTo <= from || blockFrom >= to) continue;
+        if (block.lines.length === 0) continue;
+        const lineCount = block.lines.length;
+        const span = Math.max(1, blockTo - blockFrom);
+        for (let i = 0; i < lineCount; i += 1) {
+          const line = block.lines[i]!;
+          const lineFrom =
+            blockFrom + Math.floor((span * i) / Math.max(1, lineCount));
+          const lineTo =
+            i === lineCount - 1
+              ? blockTo
+              : blockFrom +
+                Math.floor((span * (i + 1)) / Math.max(1, lineCount));
+          if (lineTo <= from || lineFrom >= to) continue;
+          rects.push(toGeometryRect(line.frame, "within-tolerance"));
+        }
+      }
+    }
+  }
+  return rects;
+}
+
+function collectRegions(
+  regions: RenderFrame["pages"][number]["regions"],
+): readonly RenderStoryRegion[] {
+  return [
+    regions.body,
+    regions.header,
+    regions.footer,
+    ...(regions.columns ?? []),
+    regions.footnoteArea,
+    ...(regions.footnotes ?? []),
+  ].filter((region): region is RenderStoryRegion => Boolean(region));
+}
+
+function storyMatches(
+  actual: EditorStoryTarget,
+  expected: EditorStoryTarget | undefined,
+): boolean {
+  if (!expected) return true;
+  if (actual.kind !== expected.kind) return false;
+  switch (expected.kind) {
+    case "main":
+      return true;
+    case "header":
+    case "footer":
+      return (
+        "relationshipId" in actual &&
+        actual.relationshipId === expected.relationshipId &&
+        actual.variant === expected.variant &&
+        actual.sectionIndex === expected.sectionIndex
+      );
+    case "footnote":
+    case "endnote":
+      return "noteId" in actual && actual.noteId === expected.noteId;
+  }
+}
+
 /**
  * Approximate the baseline offset within a line rect. The render frame
  * does not yet carry per-anchor baseline metadata, so Slice 4 uses a

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

@@ -37,6 +37,8 @@ import type {
   BlockGeometry,
   CaretGeometry,
   EnvelopeBundle,
+  GeometryIndex,
+  GeometryIndexCoverage,
   GeometryRect,
   HitTestPoint,
   HitTestResult,
@@ -51,6 +53,11 @@ import {
 import { resolveHitTest } from "./hit-test.ts";
 import { resolveObjectHandles } from "./object-handles.ts";
 import { resolveAnchorRects } from "./project-anchors.ts";
+import {
+  createUnavailableGeometryCoverage,
+  projectGeometryIndexFromFrame,
+  summarizeGeometryCoverageFromFrame,
+} from "./geometry-index.ts";
 import {
   resolveReplacementEnvelope,
   type ReplacementScope,
@@ -67,6 +74,21 @@ import { createViewport, type ViewportHandle } from "./viewport.ts";
 // ---------------------------------------------------------------------------
 
 export interface GeometryFacet {
+  // PE2 index / coverage -------------------------------------------------
+  /**
+   * Renderer-neutral geometry index for the current frame. This is the PE2
+   * Slice-1 substrate: pages, regions, slices, lines, anchors, hit targets,
+   * and coverage metadata. Returns null when no render kernel/frame is warm.
+   */
+  getGeometryIndex(): GeometryIndex | null;
+
+  /**
+   * Lightweight coverage summary for evidence/debug consumers. Unlike
+   * `getGeometryIndex`, this always returns a value; unwired/pre-paint states
+   * report `status: "unavailable"` with zero counts.
+   */
+  getGeometryCoverage(): GeometryIndexCoverage;
+
   // Hit-test -------------------------------------------------------------
   /**
    * Resolve a point in the shell's overlay coordinate space to a canonical
@@ -226,6 +248,20 @@ export function createGeometryFacet(
   const viewport = input.viewport ?? createViewport();
 
   return {
+    getGeometryIndex() {
+      const kernel = input.renderKernel?.();
+      if (!kernel) return null;
+      return projectGeometryIndexFromFrame(kernel.getRenderFrame(), {
+        canonicalDocument: input.getCanonicalDocument?.() ?? null,
+      });
+    },
+
+    getGeometryCoverage() {
+      const kernel = input.renderKernel?.();
+      if (!kernel) return createUnavailableGeometryCoverage();
+      return summarizeGeometryCoverageFromFrame(kernel.getRenderFrame());
+    },
+
     hitTest(point) {
       // Slice 6 wrapper-deletion (2026-04-22): the layout-facet fallback
       // was deleted. `hitTest` now resolves only through the render-kernel