@beyondwork/docx-react-component 1.0.103 → 1.0.105

package/src/runtime/formatting/layout-inputs.ts

@@ -7,6 +7,10 @@ import type {
   FieldRegistryEntry,
   TabStop,
 } from "../../model/canonical-document.ts";
+import {
+  MAIN_STORY_KEY,
+  type CanonicalFieldRegionIdentity,
+} from "../../model/canonical-layout-inputs.ts";
 import type { ResolvedField } from "./field/resolver.ts";
 import type {
   EffectiveParagraphFormatting,
@@ -43,7 +47,11 @@ export interface NumberingLayoutInput {
 
 export interface FieldLayoutInput {
   readonly fieldId: string;
+  readonly regionId: string;
+  readonly regionKind: "field" | "toc-region";
+  readonly storyKey: string;
   readonly fieldIndex: number;
+  readonly paragraphIndex: number;
   readonly family: FieldFamily;
   readonly instruction: string;
   readonly cachedText: string;
@@ -58,6 +66,11 @@ export interface FieldLayoutInput {
 
 export interface RevisionLayoutPosture {
   readonly mode: "clean" | "simple" | "all" | "original" | "no-markup";
+  /**
+   * True only when the active revision display changes measured text
+   * for the paragraph. Paint-only redline posture is compositor data,
+   * not an L04 measurement input.
+   */
   readonly affectsMeasuredText: boolean;
   readonly hiddenRevisionIds: readonly string[];
   readonly visibleRevisionIds: readonly string[];
@@ -100,6 +113,27 @@ export function toLayoutTabStops(
     .sort((a, b) => a.positionTwips - b.positionTwips);
 }
 
+export function mergeLayoutTabStops(
+  ...groups: readonly (readonly LayoutTabStopInput[] | undefined)[]
+): readonly LayoutTabStopInput[] {
+  const byKey = new Map<string, LayoutTabStopInput>();
+  for (const group of groups) {
+    for (const tabStop of group ?? []) {
+      const key = [
+        tabStop.source,
+        tabStop.positionTwips,
+        tabStop.align,
+        tabStop.leader ?? "",
+      ].join(":");
+      byKey.set(key, tabStop);
+    }
+  }
+  return [...byKey.values()].sort((a, b) => {
+    if (a.positionTwips !== b.positionTwips) return a.positionTwips - b.positionTwips;
+    return a.source.localeCompare(b.source);
+  });
+}
+
 export function toNumberingLayoutInput(
   numbering: NumberingPrefixResult | null | undefined,
 ): NumberingLayoutInput | undefined {
@@ -138,10 +172,15 @@ export function toNumberingLayoutInput(
 export function toFieldLayoutInput(
   entry: FieldRegistryEntry,
   resolved?: ResolvedField,
+  region?: CanonicalFieldRegionIdentity,
 ): FieldLayoutInput {
   return {
     fieldId: `field-${entry.fieldIndex}`,
+    regionId: region?.regionId ?? `field:${entry.fieldIndex}`,
+    regionKind: region?.kind ?? "field",
+    storyKey: region?.storyKey ?? entry.storyKey ?? MAIN_STORY_KEY,
     fieldIndex: entry.fieldIndex,
+    paragraphIndex: region?.paragraphIndex ?? entry.paragraphIndex,
     family: entry.fieldFamily,
     instruction: entry.instruction,
     cachedText: entry.displayText,
@@ -156,20 +195,32 @@ export function toFieldLayoutInput(
 export function collectFieldLayoutInputs(
   registry: FieldRegistry | undefined,
   resolve?: (entry: FieldRegistryEntry) => ResolvedField | undefined,
+  regions: readonly CanonicalFieldRegionIdentity[] = [],
 ): readonly FieldLayoutInput[] {
   if (!registry) return [];
   const inputs: FieldLayoutInput[] = [];
   const entries = [...registry.supported, ...registry.preserveOnly];
+  const fieldRegions = new Map(
+    regions
+      .filter((region) => region.kind === "field")
+      .map((region) => [region.fieldIndex, region]),
+  );
+  const tocRegions = new Map(
+    regions
+      .filter((region) => region.kind === "toc-region" && region.tocId !== undefined)
+      .map((region) => [region.tocId!, region]),
+  );
   for (const entry of entries) {
-    inputs.push(toFieldLayoutInput(entry, resolve?.(entry)));
+    inputs.push(toFieldLayoutInput(entry, resolve?.(entry), fieldRegions.get(entry.fieldIndex)));
   }
   for (const region of registry.tocRegions ?? []) {
     const source = registry.supported.find(
       (entry) => entry.fieldIndex === region.sourceFieldIndex,
     );
     if (!source) continue;
+    const identity = tocRegions.get(region.tocId);
     inputs.push({
-      ...toFieldLayoutInput(source, resolve?.(source)),
+      ...toFieldLayoutInput(source, resolve?.(source), identity),
       fieldId: `toc-${region.tocId}`,
       family: "TOC",
       instruction: region.instruction.raw,
@@ -200,6 +251,18 @@ export function buildRevisionLayoutPosture(
   };
 }
 
+export function toMeasuredRevisionLayoutPosture(
+  posture: RevisionLayoutPosture | undefined,
+): RevisionLayoutPosture | undefined {
+  if (!posture?.affectsMeasuredText || posture.hiddenRevisionIds.length === 0) {
+    return undefined;
+  }
+  return {
+    ...posture,
+    visibleRevisionIds: [],
+  };
+}
+
 export function buildEffectiveLayoutFormatting(input: {
   readonly paragraph?: EffectiveParagraphFormatting;
   readonly runs?: readonly EffectiveRunFormatting[];
@@ -213,6 +276,7 @@ export function buildEffectiveLayoutFormatting(input: {
   readonly compatFlags?: readonly string[];
   readonly revisionPosture?: RevisionLayoutPosture;
 }): EffectiveLayoutFormatting {
+  const revisionPosture = toMeasuredRevisionLayoutPosture(input.revisionPosture);
   const withoutHash = {
     ...(input.paragraph ? { paragraph: input.paragraph } : {}),
     runs: input.runs ?? [],
@@ -221,7 +285,7 @@ export function buildEffectiveLayoutFormatting(input: {
     ...(input.numbering ? { numbering: input.numbering } : {}),
     tabs: input.tabs ?? [],
     compatFlags: input.compatFlags ?? [],
-    ...(input.revisionPosture ? { revisionPosture: input.revisionPosture } : {}),
+    ...(revisionPosture ? { revisionPosture } : {}),
   };
   return {
     ...withoutHash,

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,28 @@ 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();
+      const frame = kernel.getRenderFrame();
+      const canonicalDocument = input.getCanonicalDocument?.() ?? null;
+      if (canonicalDocument) {
+        return (
+          projectGeometryIndexFromFrame(frame, { canonicalDocument })?.coverage ??
+          createUnavailableGeometryCoverage()
+        );
+      }
+      return summarizeGeometryCoverageFromFrame(frame);
+    },
+
     hitTest(point) {
       // Slice 6 wrapper-deletion (2026-04-22): the layout-facet fallback
       // was deleted. `hitTest` now resolves only through the render-kernel