@beyondwork/docx-react-component 1.0.104 → 1.0.105

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

@@ -22,6 +22,7 @@ import {
   MAIN_STORY_KEY,
   type CanonicalAnchorLayoutInput,
   type CanonicalLayoutInputs,
+  type CanonicalScopeLayoutInput,
   type CanonicalTableLayoutInput,
   type CanonicalTableCellLayoutInput,
   type CanonicalTableRowLayoutInput,
@@ -43,12 +44,15 @@ import type {
   GeometryIndexRegion,
   GeometryIndexSlice,
   GeometryObjectHandleEntry,
+  GeometryPrecision,
   GeometryPrecisionCounts,
   GeometryRect,
+  GeometryRehydrationStatus,
   GeometryReplacementEnvelopeEntry,
   GeometrySourceIdentity,
   SemanticDisplayEntry,
 } from "./geometry-types.ts";
+import { buildObjectHandleRectsFromRect } from "./object-handles.ts";
 
 export interface GeometryIndexProjectionOptions {
   readonly canonicalDocument?: CanonicalDocument | null;
@@ -86,7 +90,8 @@ export function projectGeometryIndexFromFrame(
   const hitTargets: GeometryHitTarget[] = [];
   const semanticEntries: SemanticDisplayEntry[] = [];
   const replacementEnvelopes: GeometryReplacementEnvelopeEntry[] = [];
-  const objectHandles: GeometryObjectHandleEntry[] = [];
+  const objectHandleEntries = new Map<string, MutableObjectHandleEntry>();
+  const projectedBlocksByStory = new Map<string, ProjectedScopeBlock[]>();
   const precision = createPrecisionCounts();
 
   for (const page of frame.pages) {
@@ -95,7 +100,9 @@ export function projectGeometryIndexFromFrame(
 
     for (const [region, ordinal] of regionEntries) {
       const regionId = makeRegionId(page, region, ordinal);
-      const storyKey = canonicalStoryKeyFromTarget(region.storyTarget);
+      const storyKey =
+        identities?.storyKeyForTarget(region.storyTarget) ??
+        canonicalStoryKeyFromTarget(region.storyTarget);
       regionIds.push(regionId);
       const sliceIds: string[] = [];
 
@@ -200,6 +207,25 @@ export function projectGeometryIndexFromFrame(
           ...(sliceIdentity ? { sourceIdentity: sliceIdentity } : {}),
         });
         recordPrecision(precision, "exact");
+        recordProjectedScopeBlock(projectedBlocksByStory, {
+          storyKey,
+          blockId: block.fragment.blockId,
+          blockPath: identities?.blockPathForBlockId(
+            storyKey,
+            block.fragment.blockId,
+          ),
+          pageId: page.page.pageId,
+          rect: toGeometryRect(block.frame),
+        });
+        appendCanonicalObjectHandleEntries({
+          frame,
+          page,
+          block,
+          identities,
+          storyKey,
+          entries: objectHandleEntries,
+          precision,
+        });
         appendBlockSemanticEntries({
           page,
           region,
@@ -209,6 +235,7 @@ export function projectGeometryIndexFromFrame(
           identities,
           storyKey,
           entries: semanticEntries,
+          projectedBlocksByStory,
           precision,
         });
       }
@@ -234,6 +261,14 @@ export function projectGeometryIndexFromFrame(
     recordPrecision(precision, "exact");
   }
 
+  appendScopeReplacementEnvelopeEntries({
+    identities,
+    projectedBlocksByStory,
+    entries: replacementEnvelopes,
+    precision,
+  });
+
+  const objectHandles = finalizeObjectHandleEntries(objectHandleEntries);
   const coverage: GeometryIndexCoverage = {
     status: "realized",
     pageCount: pages.length,
@@ -336,6 +371,7 @@ function appendBlockSemanticEntries(input: {
   identities: GeometryIdentityLookup | null;
   storyKey: string;
   entries: SemanticDisplayEntry[];
+  projectedBlocksByStory: Map<string, ProjectedScopeBlock[]>;
   precision: GeometryPrecisionCounts;
 }): void {
   const {
@@ -347,6 +383,7 @@ function appendBlockSemanticEntries(input: {
     identities,
     storyKey,
     entries,
+    projectedBlocksByStory,
     precision,
   } = input;
   const tableIdentity = identities?.tableIdentity(
@@ -379,6 +416,16 @@ function appendBlockSemanticEntries(input: {
 
     const plan = block.tablePlan;
     if (!plan) return;
+    if (tableIdentity) {
+      recordTableCellScopeBlocks({
+        table: tableIdentity,
+        block,
+        pageId: page.page.pageId,
+        storyKey,
+        identities,
+        projectedBlocksByStory,
+      });
+    }
     const rowCount = resolveTableRowCount(block);
     const rowHeightPx =
       rowCount > 0 ? block.frame.heightPx / rowCount : block.frame.heightPx;
@@ -551,9 +598,14 @@ function pageFrameCellRect(
 }
 
 interface GeometryIdentityLookup {
+  storyKeyForTarget(target: EditorStoryTarget): string;
   sliceIdentity(storyKey: string, blockId: string): GeometrySourceIdentity | undefined;
   tableIdentity(storyKey: string, blockId: string): CanonicalTableLayoutInput | undefined;
   anchorIdentity(storyKey: string, blockId: string): GeometrySourceIdentity | undefined;
+  objectAnchors(storyKey: string, blockId: string): readonly CanonicalAnchorLayoutInput[];
+  blockIdForPath(storyKey: string, blockPath: string): string | undefined;
+  blockPathForBlockId(storyKey: string, blockId: string): string | undefined;
+  scopeInputs(): readonly CanonicalScopeLayoutInput[];
 }
 
 function createIdentityLookup(
@@ -566,6 +618,7 @@ function createIdentityLookup(
       : null);
   if (!layoutInputs) return null;
 
+  const storyKeys = new Set(layoutInputs.stories.map((story) => story.storyKey));
   const blockIdByPath = options?.canonicalDocument
     ? collectProjectedBlockIdsByPath(options.canonicalDocument)
     : new Map<string, string>();
@@ -603,6 +656,9 @@ function createIdentityLookup(
   }
 
   return {
+    storyKeyForTarget(target) {
+      return resolveCanonicalStoryKeyForTarget(target, storyKeys);
+    },
     sliceIdentity(storyKey, blockId) {
       const table = tableByStoryBlockId.get(storyBlockKey(storyKey, blockId));
       if (table) return tableSourceIdentity(table);
@@ -627,16 +683,337 @@ function createIdentityLookup(
         };
       }
       const anchor = anchors[0]!;
-      return {
-        storyKey,
-        blockPath: anchor.blockPath,
-        objectKey: anchor.objectKey,
-        inlinePath: anchor.inlinePath,
-        objectKind: anchor.objectKind,
-        editPosture: anchor.editPosture,
-        joinKind: "block-scoped",
-      };
+      return anchorSourceIdentity(anchor, "block-scoped");
+    },
+    objectAnchors(storyKey, blockId) {
+      return anchorsByStoryBlockId.get(storyBlockKey(storyKey, blockId)) ?? [];
+    },
+    blockIdForPath(storyKey, blockPath) {
+      return blockIdByPath.get(storyPathKey(storyKey, blockPath));
+    },
+    blockPathForBlockId(storyKey, blockId) {
+      return blockPathByStoryBlockId.get(storyBlockKey(storyKey, blockId));
     },
+    scopeInputs() {
+      return layoutInputs.scopes;
+    },
+  };
+}
+
+interface MutableObjectHandleEntry {
+  objectId: string;
+  pageIds: string[];
+  rects: GeometryRect[];
+  status: GeometryRehydrationStatus;
+  precision: GeometryPrecision;
+  sourceIdentity?: GeometrySourceIdentity;
+}
+
+function appendCanonicalObjectHandleEntries(input: {
+  frame: RenderFrame;
+  page: RenderPage;
+  block: RenderBlock;
+  identities: GeometryIdentityLookup | null;
+  storyKey: string;
+  entries: Map<string, MutableObjectHandleEntry>;
+  precision: GeometryPrecisionCounts;
+}): void {
+  const { frame, page, block, identities, storyKey, entries, precision } = input;
+  if (!identities) return;
+
+  for (const anchor of identities.objectAnchors(
+    storyKey,
+    block.fragment.blockId,
+  )) {
+    if (anchor.hidden === true) continue;
+    const exactObjectRect = frame.anchorIndex.byObjectId(anchor.objectKey);
+    const rect = exactObjectRect ?? block.frame;
+    const entryPrecision: GeometryPrecision = exactObjectRect
+      ? "within-tolerance"
+      : "heuristic";
+    const status: GeometryRehydrationStatus = exactObjectRect
+      ? "realized"
+      : "requires-rehydration";
+    const handleRects = buildObjectHandleRectsFromRect(rect, entryPrecision);
+    const existing = entries.get(anchor.objectKey);
+    if (existing) {
+      appendUnique(existing.pageIds, page.page.pageId);
+      existing.rects.push(...handleRects);
+      if (existing.precision !== "heuristic" && entryPrecision === "heuristic") {
+        existing.precision = "heuristic";
+        existing.status = "requires-rehydration";
+        existing.sourceIdentity = anchorSourceIdentity(anchor, "block-scoped");
+      }
+      continue;
+    }
+
+    entries.set(anchor.objectKey, {
+      objectId: anchor.objectKey,
+      pageIds: [page.page.pageId],
+      rects: [...handleRects],
+      status,
+      precision: entryPrecision,
+      sourceIdentity: anchorSourceIdentity(
+        anchor,
+        exactObjectRect ? "direct" : "block-scoped",
+      ),
+    });
+    recordPrecision(precision, entryPrecision);
+  }
+}
+
+function finalizeObjectHandleEntries(
+  entries: ReadonlyMap<string, MutableObjectHandleEntry>,
+): GeometryObjectHandleEntry[] {
+  return Array.from(entries.values()).map((entry) => ({
+    objectId: entry.objectId,
+    pageIds: entry.pageIds,
+    rects: entry.rects,
+    status: entry.status,
+    precision: entry.precision,
+    ...(entry.sourceIdentity ? { sourceIdentity: entry.sourceIdentity } : {}),
+  }));
+}
+
+function appendUnique(target: string[], value: string): void {
+  if (!target.includes(value)) target.push(value);
+}
+
+function resolveCanonicalStoryKeyForTarget(
+  target: EditorStoryTarget,
+  storyKeys: ReadonlySet<string>,
+): string {
+  const exact = canonicalStoryKeyFromTarget(target);
+  if (storyKeys.has(exact)) return exact;
+  if (
+    (target.kind === "header" || target.kind === "footer") &&
+    target.sectionIndex !== undefined
+  ) {
+    const unscoped = createHeaderFooterStoryKey({
+      kind: target.kind,
+      relationshipId: target.relationshipId,
+      variant: target.variant,
+    });
+    if (storyKeys.has(unscoped)) return unscoped;
+  }
+  return exact;
+}
+
+interface ProjectedScopeBlock {
+  readonly storyKey: string;
+  readonly blockId: string;
+  readonly blockPath?: string;
+  readonly pageId: string;
+  readonly rect: GeometryRect;
+}
+
+function recordProjectedScopeBlock(
+  blocksByStory: Map<string, ProjectedScopeBlock[]>,
+  block: ProjectedScopeBlock,
+): void {
+  const list = blocksByStory.get(block.storyKey);
+  if (list) {
+    list.push(block);
+  } else {
+    blocksByStory.set(block.storyKey, [block]);
+  }
+}
+
+function recordTableCellScopeBlocks(input: {
+  table: CanonicalTableLayoutInput;
+  block: RenderBlock;
+  pageId: string;
+  storyKey: string;
+  identities: GeometryIdentityLookup | null;
+  projectedBlocksByStory: Map<string, ProjectedScopeBlock[]>;
+}): void {
+  const {
+    table,
+    block,
+    pageId,
+    storyKey,
+    identities,
+    projectedBlocksByStory,
+  } = input;
+  if (!identities) return;
+
+  for (const row of table.rows) {
+    for (const cell of row.cells) {
+      const rect = pageFrameCellRect(block, row.rowIndex, cell.gridColumnStart);
+      if (!rect) continue;
+      for (let blockIndex = 0; blockIndex < cell.blockCount; blockIndex += 1) {
+        const blockPath =
+          `${table.blockPath}/row[${row.rowIndex}]/cell[${cell.cellIndex}]` +
+          `/block[${blockIndex}]`;
+        const blockId = identities.blockIdForPath(storyKey, blockPath);
+        if (!blockId) continue;
+        recordProjectedScopeBlock(projectedBlocksByStory, {
+          storyKey,
+          blockId,
+          blockPath,
+          pageId,
+          rect: {
+            ...toGeometryRect(rect),
+            precision: "within-tolerance",
+          },
+        });
+      }
+    }
+  }
+}
+
+function appendScopeReplacementEnvelopeEntries(input: {
+  identities: GeometryIdentityLookup | null;
+  projectedBlocksByStory: ReadonlyMap<string, readonly ProjectedScopeBlock[]>;
+  entries: GeometryReplacementEnvelopeEntry[];
+  precision: GeometryPrecisionCounts;
+}): void {
+  const { identities, projectedBlocksByStory, entries, precision } = input;
+  if (!identities) return;
+
+  for (const scope of identities.scopeInputs()) {
+    const entry = projectScopeReplacementEnvelopeEntry(
+      scope,
+      identities,
+      projectedBlocksByStory.get(scope.storyKey) ?? [],
+    );
+    entries.push(entry);
+    recordPrecision(precision, entry.precision);
+  }
+}
+
+function projectScopeReplacementEnvelopeEntry(
+  scope: CanonicalScopeLayoutInput,
+  identities: GeometryIdentityLookup,
+  storyBlocks: readonly ProjectedScopeBlock[],
+): GeometryReplacementEnvelopeEntry {
+  const startBlockId = scope.start
+    ? identities.blockIdForPath(scope.storyKey, scope.start.blockPath)
+    : undefined;
+  const endBlockId = scope.end
+    ? identities.blockIdForPath(scope.storyKey, scope.end.blockPath)
+    : undefined;
+
+  let blocks: readonly ProjectedScopeBlock[] = [];
+  let status: GeometryReplacementEnvelopeEntry["status"] = "unavailable";
+  let precision: GeometryReplacementEnvelopeEntry["precision"] = "heuristic";
+
+  if (scope.status === "paired" && startBlockId && endBlockId) {
+    blocks = blocksInCanonicalPathRange(scope, storyBlocks);
+    if (blocks.length === 0) {
+      const startIndex = firstBlockIndex(storyBlocks, startBlockId);
+      const endIndex = lastBlockIndex(storyBlocks, endBlockId);
+      if (startIndex >= 0 && endIndex >= 0) {
+        const from = Math.min(startIndex, endIndex);
+        const to = Math.max(startIndex, endIndex);
+        blocks = storyBlocks.slice(from, to + 1);
+      }
+    }
+    if (blocks.length > 0) {
+      status = "realized";
+      precision = "within-tolerance";
+    }
+  }
+
+  if (blocks.length === 0) {
+    const fallbackBlockId = startBlockId ?? endBlockId;
+    if (fallbackBlockId) {
+      blocks = storyBlocks.filter((block) => block.blockId === fallbackBlockId);
+      if (blocks.length > 0) status = "requires-rehydration";
+    }
+  }
+
+  return {
+    scopeId: scope.scopeId,
+    pageIds: uniquePageIds(blocks),
+    rects: blocks.map((block) => ({
+      ...block.rect,
+      precision,
+    })),
+    status,
+    precision,
+    sourceIdentity: scopeSourceIdentity(scope),
+  };
+}
+
+function blocksInCanonicalPathRange(
+  scope: CanonicalScopeLayoutInput,
+  storyBlocks: readonly ProjectedScopeBlock[],
+): readonly ProjectedScopeBlock[] {
+  if (!scope.start || !scope.end) return [];
+  const orderByPath = new Map<string, number>();
+  for (const block of storyBlocks) {
+    if (!block.blockPath || orderByPath.has(block.blockPath)) continue;
+    orderByPath.set(block.blockPath, orderByPath.size);
+  }
+  const startOrder = orderByPath.get(scope.start.blockPath);
+  const endOrder = orderByPath.get(scope.end.blockPath);
+  if (startOrder === undefined || endOrder === undefined) return [];
+
+  const from = Math.min(startOrder, endOrder);
+  const to = Math.max(startOrder, endOrder);
+  return storyBlocks.filter((block) => {
+    if (!block.blockPath) return false;
+    const order = orderByPath.get(block.blockPath);
+    return order !== undefined && order >= from && order <= to;
+  });
+}
+
+function firstBlockIndex(
+  blocks: readonly ProjectedScopeBlock[],
+  blockId: string,
+): number {
+  return blocks.findIndex((block) => block.blockId === blockId);
+}
+
+function lastBlockIndex(
+  blocks: readonly ProjectedScopeBlock[],
+  blockId: string,
+): number {
+  for (let index = blocks.length - 1; index >= 0; index -= 1) {
+    if (blocks[index]?.blockId === blockId) return index;
+  }
+  return -1;
+}
+
+function uniquePageIds(
+  blocks: readonly ProjectedScopeBlock[],
+): readonly string[] {
+  const ids: string[] = [];
+  const seen = new Set<string>();
+  for (const block of blocks) {
+    if (seen.has(block.pageId)) continue;
+    seen.add(block.pageId);
+    ids.push(block.pageId);
+  }
+  return ids;
+}
+
+function scopeSourceIdentity(
+  scope: CanonicalScopeLayoutInput,
+): GeometrySourceIdentity {
+  const marker = scope.start ?? scope.end;
+  return {
+    storyKey: scope.storyKey,
+    ...(marker ? { blockPath: marker.blockPath } : {}),
+    scopeKey: scope.scopeKey,
+    scopeId: scope.scopeId,
+    joinKind: "block-scoped",
+  };
+}
+
+function anchorSourceIdentity(
+  anchor: CanonicalAnchorLayoutInput,
+  joinKind: GeometrySourceIdentity["joinKind"],
+): GeometrySourceIdentity {
+  return {
+    storyKey: anchor.storyKey,
+    blockPath: anchor.blockPath,
+    objectKey: anchor.objectKey,
+    inlinePath: anchor.inlinePath,
+    objectKind: anchor.objectKind,
+    editPosture: anchor.editPosture,
+    joinKind,
   };
 }
 

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

@@ -147,6 +147,8 @@ export interface GeometrySourceIdentity {
   tableKey?: string;
   rowKey?: string;
   cellKey?: string;
+  scopeKey?: string;
+  scopeId?: string;
   objectKey?: string;
   inlinePath?: string;
   objectKind?: string;
@@ -288,16 +290,20 @@ export interface SemanticDisplayEntry {
 
 export interface GeometryReplacementEnvelopeEntry {
   scopeId: string;
+  pageIds?: readonly string[];
   rects: readonly GeometryRect[];
   status: GeometryRehydrationStatus;
   precision: GeometryPrecision;
+  sourceIdentity?: GeometrySourceIdentity;
 }
 
 export interface GeometryObjectHandleEntry {
   objectId: string;
+  pageIds?: readonly string[];
   rects: readonly GeometryRect[];
   status: GeometryRehydrationStatus;
   precision: GeometryPrecision;
+  sourceIdentity?: GeometrySourceIdentity;
 }
 
 // ---------------------------------------------------------------------------

package/src/runtime/geometry/object-handles.ts

@@ -27,7 +27,7 @@
  */
 
 import type { RenderFrame, RenderFrameRect } from "../render/index.ts";
-import type { GeometryRect } from "./geometry-types.ts";
+import type { GeometryPrecision, GeometryRect } from "./geometry-types.ts";
 
 const ROTATE_HANDLE_OFFSET_PX = 20;
 
@@ -38,10 +38,13 @@ export function resolveObjectHandles(
   if (!frame) return [];
   const bbox = frame.anchorIndex.byObjectId(objectId);
   if (!bbox) return [];
-  return buildHandles(bbox);
+  return buildObjectHandleRectsFromRect(bbox);
 }
 
-function buildHandles(bbox: RenderFrameRect): readonly GeometryRect[] {
+export function buildObjectHandleRectsFromRect(
+  bbox: RenderFrameRect,
+  precision: GeometryPrecision = "heuristic",
+): readonly GeometryRect[] {
   const { leftPx, topPx, widthPx, heightPx } = bbox;
   const right = leftPx + widthPx;
   const bottom = topPx + heightPx;
@@ -61,7 +64,7 @@ function buildHandles(bbox: RenderFrameRect): readonly GeometryRect[] {
     widthPx: 0,
     heightPx: 0,
     space: "frame",
-    precision: "heuristic",
+    precision,
   });
   return [
     point(leftPx, topPx), // 0 top-left

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

@@ -490,6 +490,7 @@ export function createLayoutEngine(
       fragmentsByPageIndex,
       lineBoxesByPageIndex,
       noteAllocationsByPageIndex: pageStack.noteAllocationsByPageIndex,
+      subParts: document.subParts,
     });
 
     // Field dirtiness diff from previous graph
@@ -669,6 +670,7 @@ export function createLayoutEngine(
       fragmentsByPageIndex: freshFragmentsByPageIndex,
       lineBoxesByPageIndex: freshLineBoxesByPageIndex,
       noteAllocationsByPageIndex: freshResult.noteAllocationsByPageIndex,
+      subParts: document.subParts,
     });
     const freshNodes = freshGraph.pages;
 

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

@@ -1046,8 +1046,36 @@
  *   Existing `regions` remain the compatibility surface, but cache envelopes
  *   from v63 invalidate because the page graph payload shape changed.
  *   Shipped via pe2 commit `24a316af2`.
+ *
+ *  65 — PE2 Slice 2 page-local story instances (Layer 04). `RuntimePageFrame`
+ *   now carries stable header/footer `pageLocalStories` records with story
+ *   keys, variants, relationship ids, measured frame heights, and empty
+ *   field/object ledgers for later Slice 2/4 population. Cache envelopes
+ *   from v64 invalidate because the page-frame payload shape changed again.
+ *   Shipped via pe2 commit `06fe6f692`.
+ *
+ *  66 — PE2 Slice 2 page-local field ledgers (Layer 04). Page graph
+ *   construction now walks canonical header/footer subparts for each
+ *   page-local story instance and records resolved PAGE / NUMPAGES /
+ *   SECTIONPAGES display text in the story's `resolvedFields` ledger.
+ *   Cache envelopes from v65 invalidate because page-frame story payloads
+ *   now carry field-resolution data. Shipped via pe2 commit `a3a42bec9`.
+ *
+ *  67 — PE2 Slice 2 page-local object ledgers (Layer 04). Header/footer
+ *   page-local story instances now record canonical image/drawing/preserve-only
+ *   objects as twips/plain anchored-object ledger rows and emit typed
+ *   unsupported-wrap / preserve-only-placeholder divergences. Cache envelopes
+ *   from v66 invalidate because page-frame story payloads and divergence ids
+ *   can change. Shipped via pe2 commit `7d8bb94ac`.
+ *
+ *  68 — PE2 Slice 3 typed continuation cursors (Layer 04). Paragraph and
+ *   table slice fragments now carry a twips/plain continuation cursor with
+ *   sequence position, line/row range, continuation direction, repeated
+ *   table header rows, and vertical-merge carry metadata. Cache envelopes
+ *   from v67 invalidate because fragment payloads can now include
+ *   continuation state. Shipped via pe2 commit `33fbf45ac`.
  */
-export const LAYOUT_ENGINE_VERSION = 64 as const;
+export const LAYOUT_ENGINE_VERSION = 68 as const;
 
 /**
  * Serialization schema version for the LayCache payload (the cache envelope