@beyondwork/docx-react-component 1.0.104 → 1.0.105

package/src/runtime/layout/project-block-fragments.ts

@@ -235,11 +235,27 @@ function emitSlicedParagraph(
       ...deriveStyleMetadata(block),
       kind: "paragraph-slice",
       paragraphLineRange: slice.lineRange,
+      continuation: buildParagraphContinuationCursor(slice, i, slices.length),
     };
     emit(slice.pageIndex, fragment);
   }
 }
 
+function buildParagraphContinuationCursor(
+  slice: ParagraphLineSlice,
+  sequenceIndex: number,
+  sliceCount: number,
+): NonNullable<RuntimeBlockFragment["continuation"]> {
+  return {
+    kind: "paragraph",
+    sequenceIndex,
+    sliceCount,
+    lineRange: slice.lineRange,
+    continuesFromPreviousPage: slice.lineRange.from > 0,
+    continuesToNextPage: slice.lineRange.to < slice.lineRange.totalLines,
+  };
+}
+
 function estimateSliceHeightFromLines(lineRange: {
   from: number;
   to: number;
@@ -259,7 +275,7 @@ function estimateSliceHeightFromLines(lineRange: {
  * every continuation page.
  */
 function emitSlicedTable(
-  block: SurfaceBlockSnapshot,
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
   slices: readonly TableRowSlice[],
   emit: (pageIndex: number, fragment: FragmentWithoutPageId) => void,
 ): void {
@@ -276,12 +292,96 @@ function emitSlicedTable(
       ...deriveStyleMetadata(block),
       kind: "table-slice",
       tableRowRange: slice.rowRange,
+      continuation: buildTableContinuationCursor(block, slice, i, slices.length),
       ...(slice.columnIndex !== undefined ? { columnIndex: slice.columnIndex } : {}),
     };
     emit(slice.pageIndex, fragment);
   }
 }
 
+function buildTableContinuationCursor(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  slice: TableRowSlice,
+  sequenceIndex: number,
+  sliceCount: number,
+): NonNullable<RuntimeBlockFragment["continuation"]> {
+  return {
+    kind: "table",
+    sequenceIndex,
+    sliceCount,
+    rowRange: slice.rowRange,
+    continuesFromPreviousPage: slice.rowRange.from > 0,
+    continuesToNextPage: slice.rowRange.to < slice.rowRange.totalRows,
+    repeatedHeaderRowIndexes:
+      slice.rowRange.from > 0
+        ? collectRepeatedHeaderRowIndexes(block, slice.rowRange.from)
+        : [],
+    verticalMergeCarry: collectVerticalMergeCarry(block, slice.rowRange.from),
+  };
+}
+
+function collectRepeatedHeaderRowIndexes(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  startRow: number,
+): number[] {
+  const headerRows: number[] = [];
+  for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+    if (rowIndex >= startRow) break;
+    if (block.rows[rowIndex]?.isHeader === true) headerRows.push(rowIndex);
+  }
+  return headerRows;
+}
+
+function collectVerticalMergeCarry(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  startRow: number,
+): Array<{ columnIndex: number; restartRowIndex: number }> {
+  if (startRow <= 0) return [];
+
+  const activeByColumn = new Map<number, number>();
+  for (let rowIndex = 0; rowIndex < startRow; rowIndex += 1) {
+    visitRowCells(block.rows[rowIndex], (columnIndex, span, verticalMerge) => {
+      for (let column = columnIndex; column < columnIndex + span; column += 1) {
+        if (verticalMerge === "restart") {
+          activeByColumn.set(column, rowIndex);
+        } else if (verticalMerge !== "continue") {
+          activeByColumn.delete(column);
+        }
+      }
+    });
+  }
+
+  const carried = new Map<number, number>();
+  visitRowCells(block.rows[startRow], (columnIndex, span, verticalMerge) => {
+    if (verticalMerge !== "continue") return;
+    for (let column = columnIndex; column < columnIndex + span; column += 1) {
+      const restartRowIndex = activeByColumn.get(column);
+      if (restartRowIndex !== undefined) carried.set(column, restartRowIndex);
+    }
+  });
+
+  return [...carried]
+    .sort(([a], [b]) => a - b)
+    .map(([columnIndex, restartRowIndex]) => ({ columnIndex, restartRowIndex }));
+}
+
+function visitRowCells(
+  row: Extract<SurfaceBlockSnapshot, { kind: "table" }>["rows"][number] | undefined,
+  visit: (
+    columnIndex: number,
+    span: number,
+    verticalMerge: "restart" | "continue" | null,
+  ) => void,
+): void {
+  if (!row) return;
+  let columnIndex = Math.max(0, row.gridBefore ?? 0);
+  for (const cell of row.cells) {
+    const span = Math.max(1, cell.gridSpan || cell.colspan || 1);
+    visit(columnIndex, span, cell.verticalMerge);
+    columnIndex += span;
+  }
+}
+
 function estimateSliceHeightFromRows(rowRange: {
   from: number;
   to: number;

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

@@ -25,12 +25,16 @@ import type {
 } from "./page-story-resolver.ts";
 import type {
   RuntimeBlockFragment,
+  RuntimeLayoutContinuationCursor,
+  RuntimeLayoutDivergence,
   RuntimeLineBox,
   RuntimeNoteAllocation,
+  RuntimePageFrame,
   RuntimePageGraph,
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
+  RuntimeTwipsRect,
 } from "./page-graph.ts";
 import type {
   ResolvedFormattingState,
@@ -132,6 +136,40 @@ export function emitLayoutGuardWarning(
 // Public read model types (shape-stable, cloned at the facet boundary)
 // ---------------------------------------------------------------------------
 
+export interface PublicTwipsRect {
+  xTwips: number;
+  yTwips: number;
+  widthTwips: number;
+  heightTwips: number;
+}
+
+export interface PublicLayoutDivergence {
+  divergenceId: string;
+  kind: RuntimeLayoutDivergence["kind"];
+  source: RuntimeLayoutDivergence["source"];
+  severity: RuntimeLayoutDivergence["severity"];
+  message: string;
+  regionKinds?: readonly RuntimePageRegion["kind"][];
+  fragmentIds?: readonly string[];
+}
+
+export interface PublicPageFrame {
+  frameId: string;
+  pageId: string;
+  pageIndex: number;
+  sectionIndex: number;
+  displayPageNumber: number;
+  physicalBoundsTwips: PublicTwipsRect;
+  divergenceIds: readonly string[];
+  signature: string;
+  exclusionZoneCount: number;
+  regionFrames: readonly {
+    kind: RuntimePageRegion["kind"];
+    rectTwips?: PublicTwipsRect;
+    fragmentIds: readonly string[];
+  }[];
+}
+
 export interface PublicPageNode {
   pageId: string;
   pageIndex: number;
@@ -157,6 +195,10 @@ export interface PublicPageNode {
   lineBoxCount: number;
   /** Footnotes reserved at the bottom of the page, if any. */
   noteAllocations: readonly PublicNoteAllocation[];
+  /** PE2 page-frame graph projection, when emitted by the L04 graph. */
+  frame?: PublicPageFrame;
+  /** Typed layout divergences detected while building this page. */
+  divergences?: readonly PublicLayoutDivergence[];
 }
 
 export interface PublicResolvedPageStories {
@@ -187,6 +229,8 @@ export interface PublicPageRegion {
   widthTwips: number;
   heightTwips: number;
   fragmentCount: number;
+  /** PE2 semantic twips rect, when populated by the L04 page-frame graph. */
+  rectTwips?: PublicTwipsRect;
 }
 
 /**
@@ -208,8 +252,23 @@ export interface PublicBlockFragment {
   to: number;
   heightTwips: number;
   orderInRegion: number;
+  kind?: "whole" | "paragraph-slice" | "table-slice";
+  paragraphLineRange?: {
+    from: number;
+    to: number;
+    totalLines: number;
+  };
+  tableRowRange?: {
+    from: number;
+    to: number;
+    totalRows: number;
+  };
+  columnIndex?: number;
+  continuation?: PublicLayoutContinuationCursor;
 }
 
+export type PublicLayoutContinuationCursor = RuntimeLayoutContinuationCursor;
+
 /**
  * P8 — One block snapshot rendered into a region of a page.  Returned by
  * `WordReviewEditorLayoutFacet.getStoryBlocksForRegion` and
@@ -245,6 +304,7 @@ export interface PublicNoteAllocation {
   noteKind: "footnote" | "endnote";
   noteId: string;
   reservedHeightTwips: number;
+  fragmentId?: string;
 }
 
 export interface PublicPageAnchor {
@@ -1367,12 +1427,74 @@ function toPublicPageNode(
     regions: toPublicPageRegions(node.regions),
     lineBoxCount: node.lineBoxes.length,
     noteAllocations: node.noteAllocations.map(toPublicNoteAllocation),
+    ...(node.frame ? { frame: toPublicPageFrame(node.frame) } : {}),
+    ...(node.divergences && node.divergences.length > 0
+      ? { divergences: node.divergences.map(toPublicLayoutDivergence) }
+      : {}),
   };
   publicPageNodeCache.set(node, built);
   void graph; // reserved for future cross-page derivations
   return built;
 }
 
+function toPublicTwipsRect(rect: RuntimeTwipsRect): PublicTwipsRect {
+  return {
+    xTwips: rect.xTwips,
+    yTwips: rect.yTwips,
+    widthTwips: rect.widthTwips,
+    heightTwips: rect.heightTwips,
+  };
+}
+
+function frameRegionEntries(
+  frame: RuntimePageFrame,
+): PublicPageFrame["regionFrames"] {
+  const regions: PublicPageFrame["regionFrames"][number][] = [];
+  const push = (region: RuntimePageRegion | undefined) => {
+    if (!region) return;
+    regions.push({
+      kind: region.kind,
+      ...(region.rectTwips ? { rectTwips: toPublicTwipsRect(region.rectTwips) } : {}),
+      fragmentIds: [...region.fragmentIds],
+    });
+  };
+  push(frame.regions.header);
+  push(frame.regions.body);
+  for (const column of frame.regions.columns ?? []) push(column);
+  push(frame.regions.footer);
+  for (const footnote of frame.regions.footnotes ?? []) push(footnote);
+  return regions;
+}
+
+function toPublicPageFrame(frame: RuntimePageFrame): PublicPageFrame {
+  return {
+    frameId: frame.frameId,
+    pageId: frame.pageId,
+    pageIndex: frame.pageIndex,
+    sectionIndex: frame.sectionIndex,
+    displayPageNumber: frame.displayPageNumber,
+    physicalBoundsTwips: toPublicTwipsRect(frame.physicalBoundsTwips),
+    divergenceIds: [...frame.divergenceIds],
+    signature: frame.signature,
+    exclusionZoneCount: frame.regions.exclusionZones.length,
+    regionFrames: frameRegionEntries(frame),
+  };
+}
+
+function toPublicLayoutDivergence(
+  divergence: RuntimeLayoutDivergence,
+): PublicLayoutDivergence {
+  return {
+    divergenceId: divergence.divergenceId,
+    kind: divergence.kind,
+    source: divergence.source,
+    severity: divergence.severity,
+    message: divergence.message,
+    ...(divergence.regionKinds !== undefined ? { regionKinds: [...divergence.regionKinds] } : {}),
+    ...(divergence.fragmentIds !== undefined ? { fragmentIds: [...divergence.fragmentIds] } : {}),
+  };
+}
+
 function toPublicResolvedPageStories(
   stories: ResolvedPageStories,
 ): PublicResolvedPageStories {
@@ -1404,6 +1526,7 @@ function toPublicPageRegion(region: RuntimePageRegion): PublicPageRegion {
     widthTwips: region.widthTwips,
     heightTwips: region.heightTwips,
     fragmentCount: region.fragmentIds.length,
+    ...(region.rectTwips ? { rectTwips: toPublicTwipsRect(region.rectTwips) } : {}),
   };
 }
 
@@ -1422,6 +1545,34 @@ function toPublicBlockFragment(
     to: fragment.to,
     heightTwips: fragment.heightTwips,
     orderInRegion: fragment.orderInRegion,
+    ...(fragment.kind !== undefined ? { kind: fragment.kind } : {}),
+    ...(fragment.paragraphLineRange !== undefined
+      ? { paragraphLineRange: { ...fragment.paragraphLineRange } }
+      : {}),
+    ...(fragment.tableRowRange !== undefined
+      ? { tableRowRange: { ...fragment.tableRowRange } }
+      : {}),
+    ...(fragment.columnIndex !== undefined ? { columnIndex: fragment.columnIndex } : {}),
+    ...(fragment.continuation !== undefined
+      ? { continuation: cloneContinuationCursor(fragment.continuation) }
+      : {}),
+  };
+}
+
+function cloneContinuationCursor(
+  cursor: RuntimeLayoutContinuationCursor,
+): RuntimeLayoutContinuationCursor {
+  if (cursor.kind === "paragraph") {
+    return {
+      ...cursor,
+      lineRange: { ...cursor.lineRange },
+    };
+  }
+  return {
+    ...cursor,
+    rowRange: { ...cursor.rowRange },
+    repeatedHeaderRowIndexes: [...cursor.repeatedHeaderRowIndexes],
+    verticalMergeCarry: cursor.verticalMergeCarry.map((carry) => ({ ...carry })),
   };
 }
 
@@ -1440,6 +1591,7 @@ function toPublicNoteAllocation(note: RuntimeNoteAllocation): PublicNoteAllocati
     noteKind: note.noteKind,
     noteId: note.noteId,
     reservedHeightTwips: note.reservedHeightTwips,
+    ...(note.fragmentId !== undefined ? { fragmentId: note.fragmentId } : {}),
   };
 }
 

package/src/runtime/prerender/graph-canonicalize.ts

@@ -3,6 +3,7 @@ import type {
   RuntimePageAnchor,
   RuntimePageFrame,
   RuntimePageGraph,
+  RuntimePageLocalStoryInstance,
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
@@ -97,6 +98,9 @@ function rewriteFrame(
   return {
     ...frame,
     pageId: rewriteId(frame.pageId),
+    pageLocalStories: frame.pageLocalStories.map((story) =>
+      rewritePageLocalStoryInstance(story, rewriteId),
+    ),
     regions: {
       ...frame.regions,
       body: rewriteRegion(frame.regions.body, rewriteId),
@@ -116,6 +120,16 @@ function rewriteFrame(
   };
 }
 
+function rewritePageLocalStoryInstance(
+  story: RuntimePageLocalStoryInstance,
+  rewriteId: (id: string) => string,
+): RuntimePageLocalStoryInstance {
+  return {
+    ...story,
+    pageId: rewriteId(story.pageId),
+  };
+}
+
 function rewriteRegions(
   regions: RuntimePageRegions,
   rewriteId: (id: string) => string,

package/src/ui/ui-controller-factory.ts

@@ -54,6 +54,8 @@ import type {
   ChromePosture,
   GeometryRect,
   OverlayAnchorQuery,
+  UiOverlayLaneKind,
+  UiOverlayLaneSnapshot,
   UiController,
   UiControllerFactory,
   UiListener,
@@ -119,6 +121,13 @@ export interface ShellUiControllerDeps {
   readonly subscribeOverlays?: (
     listener: UiListener<OverlayAnchorQuery>,
   ) => UiUnsubscribe;
+  /** PE2 overlay-lane snapshot resolver. */
+  readonly getOverlayLane?: (kind: UiOverlayLaneKind) => UiOverlayLaneSnapshot;
+  /** PE2 overlay-lane subscription channel. */
+  readonly subscribeOverlayLane?: (
+    kind: UiOverlayLaneKind,
+    listener: UiListener<UiOverlayLaneSnapshot>,
+  ) => UiUnsubscribe;
 }
 
 /**
@@ -146,6 +155,8 @@ export function makeShellUiControllerFactory(
       ...(deps.getViewport ? { getViewport: deps.getViewport } : {}),
       ...(deps.subscribeViewport ? { subscribeViewport: deps.subscribeViewport } : {}),
       ...(deps.subscribeOverlays ? { subscribeOverlays: deps.subscribeOverlays } : {}),
+      ...(deps.getOverlayLane ? { getOverlayLane: deps.getOverlayLane } : {}),
+      ...(deps.subscribeOverlayLane ? { subscribeOverlayLane: deps.subscribeOverlayLane } : {}),
     };
     return controller;
   };