@beyondwork/docx-react-component 1.0.109 → 1.0.111

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

@@ -209,6 +209,14 @@ export interface PageStackResultWithSplits {
   fragmentMeasurementsByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, FragmentMeasurement>>;
 }
 
+export interface PageStackPaginationOptions {
+  /**
+   * Stop after this many global pages have been emitted. Used by L04 lazy
+   * pagination so viewport reads can avoid walking the whole document tail.
+   */
+  maxPageCount?: number;
+}
+
 // ---------------------------------------------------------------------------
 // Facade
 // ---------------------------------------------------------------------------
@@ -248,6 +256,7 @@ export function buildPageStackWithSplits(
   sections: ResolvedDocumentSection[],
   mainSurface: EditorSurfaceSnapshot,
   measurementProvider?: LayoutMeasurementProvider,
+  options?: PageStackPaginationOptions,
 ): PageStackResultWithSplits {
   const defaultTabInterval = document.subParts?.settings?.defaultTabStop ?? 720;
   // Theme-font fallback for L04 dominant-font resolution. Threaded into
@@ -288,8 +297,15 @@ export function buildPageStackWithSplits(
   // reuses heights.  The WeakMap frees memory automatically when the block
   // snapshots go out of scope at the end of the call.
   const cache = createMeasurementCache();
+  const maxPageCount =
+    options?.maxPageCount !== undefined
+      ? Math.max(1, Math.floor(options.maxPageCount))
+      : undefined;
+  const hasReachedMaxPageCount = (): boolean =>
+    maxPageCount !== undefined && globalPageIndex >= maxPageCount;
 
   for (let sectionIdx = 0; sectionIdx < sections.length; sectionIdx++) {
+    if (hasReachedMaxPageCount()) break;
     const section = sections[sectionIdx]!;
     const layout = buildPageLayoutSnapshot(
       section.index,
@@ -347,6 +363,7 @@ export function buildPageStackWithSplits(
 
     if (breakType === "evenPage" && globalPageIndex > 0) {
       if (nextDisplayPage % 2 !== 0) {
+        if (hasReachedMaxPageCount()) break;
         const prevLayout = pages[pages.length - 1]?.layout ?? layout;
         pages.push({
           pageIndex: globalPageIndex,
@@ -360,6 +377,7 @@ export function buildPageStackWithSplits(
       }
     } else if (breakType === "oddPage" && globalPageIndex > 0) {
       if (nextDisplayPage % 2 === 0) {
+        if (hasReachedMaxPageCount()) break;
         const prevLayout = pages[pages.length - 1]?.layout ?? layout;
         pages.push({
           pageIndex: globalPageIndex,
@@ -383,6 +401,9 @@ export function buildPageStackWithSplits(
       defaultTabInterval,
       nextColumnSeed,
       themeFonts,
+      maxPageCount !== undefined
+        ? { maxPageCount: Math.max(1, maxPageCount - globalPageIndex) }
+        : undefined,
     );
     const paginated = paginatedResult.pages;
 
@@ -421,6 +442,7 @@ export function buildPageStackWithSplits(
         }
         continue;
       }
+      if (hasReachedMaxPageCount()) break;
       pageInSectionToGlobal.set(page.pageInSection, globalPageIndex);
       pages.push({
         ...page,
@@ -1612,6 +1634,7 @@ export function paginateSectionBlocksWithSplits(
    * `subParts.resolvedTheme` — threaded from `buildPageStackWithSplits`.
    */
   themeFonts?: LayoutThemeFonts,
+  options?: PageStackPaginationOptions,
 ): SectionPaginationResult {
   if (blocks.length === 0) {
     return {
@@ -1633,6 +1656,11 @@ export function paginateSectionBlocksWithSplits(
   }
 
   const pages: Omit<DocumentPageSnapshot, "pageIndex">[] = [];
+  const maxPageCount =
+    options?.maxPageCount !== undefined
+      ? Math.max(1, Math.floor(options.maxPageCount))
+      : undefined;
+  let reachedPageLimit = false;
   const splitsByBlock = new Map<string, SectionLocalSlice[]>();
   const tableSplitsByBlock = new Map<string, SectionLocalTableSlice[]>();
   const fragmentMeasurementsByPageInSection = new Map<number, Map<string, FragmentMeasurement>>();
@@ -1850,6 +1878,7 @@ export function paginateSectionBlocksWithSplits(
   };
 
   const pushPage = (endOffset: number): void => {
+    if (reachedPageLimit) return;
     const boundedEnd = Math.max(pageStart, Math.min(endOffset, section.end));
     if (boundedEnd === pageStart && pages.length > 0) {
       return;
@@ -1877,12 +1906,17 @@ export function paginateSectionBlocksWithSplits(
     pendingNoteKeys.clear();
     pendingNoteBlockFroms.clear();
     pendingNoteColumnWidths.clear();
+    if (maxPageCount !== undefined && pages.length >= maxPageCount) {
+      reachedPageLimit = true;
+    }
   };
 
   for (let index = 0; index < blocks.length; index += 1) {
+    if (reachedPageLimit) break;
     const block = blocks[index]!;
     const nextBoundary = blocks[index + 1]?.from ?? section.end;
     while (true) {
+      if (reachedPageLimit) break;
       const columnWidth =
         columnMetrics[Math.min(columnIndex, columnMetrics.length - 1)]?.width ??
         getUsableColumnWidth(layout);

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

@@ -23,6 +23,7 @@ import type {
   DocumentPageSnapshot,
   EditorSurfaceSnapshot,
   SurfaceBlockSnapshot,
+  SurfaceInlineSegment,
 } from "../../api/public-types";
 import type {
   CanonicalFieldRegionIdentity,
@@ -31,7 +32,9 @@ import type { RuntimeBlockFragment } from "./page-graph.ts";
 import type {
   RuntimeFieldRegionLayoutFacts,
   RuntimeLineBox,
+  RuntimeLineRunAnchor,
   RuntimeNumberingLayoutFacts,
+  RuntimeTwipsRect,
 } from "../../model/layout/page-graph-types.ts";
 import type {
   BlockSplits,
@@ -185,8 +188,12 @@ export function projectLineBoxesForPageFragments(
     ReadonlyArray<Omit<RuntimeBlockFragment, "pageId">>
   >,
   fragmentMeasurementsByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, FragmentMeasurement>>,
+  surface?: EditorSurfaceSnapshot,
 ): Map<number, RuntimeLineBox[]> {
   const byPage = new Map<number, RuntimeLineBox[]>();
+  const blocksById = surface
+    ? new Map(surface.blocks.map((block) => [block.blockId, block] as const))
+    : new Map<string, SurfaceBlockSnapshot>();
   for (const page of pages) {
     const fragments = [...(fragmentsByPageIndex.get(page.pageIndex) ?? [])]
       .filter((fragment) => fragment.regionKind === "body")
@@ -224,12 +231,33 @@ export function projectLineBoxesForPageFragments(
             page.layout.gutter,
         );
       for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+        const lineTopTwips = cursorTwips + lineIndex * lineHeight;
+        const rectTwips = lineRectForFragment(page, fragment, lineTopTwips, widthTwips, lineHeight);
+        const baselinePageYTwips = rectTwips.yTwips + Math.round(lineHeight * 0.8);
+        const block = blocksById.get(fragment.blockId);
+        const direction = block?.kind === "paragraph" && block.bidi === true ? "rtl" : "ltr";
         lines.push({
           fragmentId: fragment.fragmentId,
           lineIndex,
-          baselineTwips: cursorTwips + lineIndex * lineHeight,
+          baselineTwips: lineTopTwips,
+          baselinePageYTwips,
           heightTwips: lineHeight,
           widthTwips,
+          rectTwips,
+          direction,
+          ...(block?.kind === "paragraph"
+            ? {
+                runAnchors: buildRunAnchorsForLine({
+                  block,
+                  fragment,
+                  lineIndex,
+                  lineCount,
+                  rectTwips,
+                  baselinePageYTwips,
+                  direction,
+                }),
+              }
+            : {}),
         });
       }
       cursorTwips += Math.max(0, fragment.heightTwips);
@@ -241,6 +269,121 @@ export function projectLineBoxesForPageFragments(
   return byPage;
 }
 
+function lineRectForFragment(
+  page: DocumentPageSnapshot,
+  fragment: Omit<RuntimeBlockFragment, "pageId">,
+  lineTopTwips: number,
+  widthTwips: number,
+  heightTwips: number,
+): RuntimeTwipsRect {
+  const bodyX = page.layout.marginLeft + page.layout.gutter;
+  const bodyY = page.layout.marginTop;
+  const columnIndex = Math.max(0, fragment.columnIndex ?? 0);
+  const columnOffset = columnIndex > 0 ? columnIndex * Math.max(0, widthTwips) : 0;
+  return {
+    xTwips: bodyX + columnOffset,
+    yTwips: bodyY + lineTopTwips,
+    widthTwips: Math.max(0, widthTwips),
+    heightTwips: Math.max(0, heightTwips),
+  };
+}
+
+function buildRunAnchorsForLine(input: {
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>;
+  fragment: Omit<RuntimeBlockFragment, "pageId">;
+  lineIndex: number;
+  lineCount: number;
+  rectTwips: RuntimeTwipsRect;
+  baselinePageYTwips: number;
+  direction: "ltr" | "rtl";
+}): RuntimeLineRunAnchor[] {
+  const textSegments = input.block.segments.filter(
+    (segment): segment is Extract<SurfaceInlineSegment, { kind: "text" }> =>
+      segment.kind === "text" && segment.text.length > 0,
+  );
+  if (textSegments.length === 0) return [];
+
+  const totalChars = Math.max(
+    1,
+    textSegments.reduce((sum, segment) => sum + Array.from(segment.text).length, 0),
+  );
+  const totalLineCount =
+    input.fragment.kind === "paragraph-slice" && input.fragment.paragraphLineRange
+      ? Math.max(1, input.fragment.paragraphLineRange.totalLines)
+      : Math.max(1, input.lineCount);
+  const globalLineIndex =
+    (input.fragment.kind === "paragraph-slice" && input.fragment.paragraphLineRange
+      ? input.fragment.paragraphLineRange.from
+      : 0) + input.lineIndex;
+  const charsPerLine = Math.max(1, Math.ceil(totalChars / totalLineCount));
+  const lineCharStart = globalLineIndex * charsPerLine;
+  const lineCharEnd = Math.min(totalChars, lineCharStart + charsPerLine);
+  if (lineCharEnd <= lineCharStart) return [];
+
+  const charWidth = Math.max(1, input.rectTwips.widthTwips / charsPerLine);
+  const anchors: RuntimeLineRunAnchor[] = [];
+  let charCursor = 0;
+  for (const segment of textSegments) {
+    const segmentLength = Array.from(segment.text).length;
+    const segmentStart = charCursor;
+    const segmentEnd = charCursor + segmentLength;
+    charCursor = segmentEnd;
+
+    const overlapStart = Math.max(segmentStart, lineCharStart);
+    const overlapEnd = Math.min(segmentEnd, lineCharEnd);
+    if (overlapEnd <= overlapStart) continue;
+
+    const startInLine = overlapStart - lineCharStart;
+    const glyphCount = Math.max(1, overlapEnd - overlapStart);
+    const runWidthTwips = Math.max(1, Math.round(glyphCount * charWidth));
+    const startOffsetTwips = Math.round(startInLine * charWidth);
+    const xTwips =
+      input.direction === "rtl"
+        ? input.rectTwips.xTwips + input.rectTwips.widthTwips - startOffsetTwips - runWidthTwips
+        : input.rectTwips.xTwips + startOffsetTwips;
+    const glyphWidthTwips = Math.max(1, Math.round(charWidth));
+    const runRectTwips: RuntimeTwipsRect = {
+      xTwips,
+      yTwips: input.rectTwips.yTwips,
+      widthTwips: runWidthTwips,
+      heightTwips: input.rectTwips.heightTwips,
+    };
+    const firstGlyphRectTwips: RuntimeTwipsRect =
+      input.direction === "rtl"
+        ? {
+            ...runRectTwips,
+            xTwips: xTwips + Math.max(0, runWidthTwips - glyphWidthTwips),
+            widthTwips: glyphWidthTwips,
+          }
+        : { ...runRectTwips, widthTwips: glyphWidthTwips };
+    const lastGlyphRectTwips: RuntimeTwipsRect =
+      input.direction === "rtl"
+        ? { ...runRectTwips, widthTwips: glyphWidthTwips }
+        : {
+            ...runRectTwips,
+            xTwips: xTwips + Math.max(0, runWidthTwips - glyphWidthTwips),
+            widthTwips: glyphWidthTwips,
+          };
+    const runId = `${input.block.blockId}:${segment.segmentId}`;
+    anchors.push({
+      anchorId: `${input.fragment.fragmentId}:line-${input.lineIndex}:${segment.segmentId}`,
+      runId,
+      segmentId: segment.segmentId,
+      blockId: input.block.blockId,
+      fragmentId: input.fragment.fragmentId,
+      lineIndex: input.lineIndex,
+      direction: input.direction,
+      baselinePageYTwips: input.baselinePageYTwips,
+      lineRectTwips: { ...input.rectTwips },
+      firstGlyphRectTwips,
+      lastGlyphRectTwips,
+      runRectTwips,
+      precision: "layout-estimate",
+    });
+  }
+  return anchors;
+}
+
 /**
  * Emit one fragment per slice for a paragraph that pagination split across
  * pages. The source `block` offset range stays intact on every slice; the

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

@@ -34,6 +34,7 @@ import type {
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
+  RuntimeLineRunAnchor,
   RuntimeStoryAnchoredObject,
   RuntimeTwipsRect,
 } from "./page-graph.ts";
@@ -189,6 +190,7 @@ export interface PublicStoryAnchoredObject {
     widthTwips: number;
     heightTwips: number;
   };
+  anchorRectTwips?: PublicTwipsRect;
   relationshipIds?: readonly string[];
   mediaIds?: readonly string[];
   preserveOnly: boolean;
@@ -204,6 +206,8 @@ export interface PublicPageNode {
   endOffset: number;
   /** Whether this page is a blank filler (e.g. from evenPage/oddPage). */
   isBlankFiller: boolean;
+  /** Whether L04 has measured this page or it is a lazy-pagination placeholder. */
+  materialization: NonNullable<RuntimePageNode["materialization"]>;
   /** Resolved display page number (1-based, honors section restarts). */
   displayPageNumber: number;
   /** Whether this is treated as the first page of its section (title page). */
@@ -323,8 +327,28 @@ export interface PublicLineBox {
   fragmentId: string;
   lineIndex: number;
   baselineTwips: number;
+  baselinePageYTwips?: number;
   heightTwips: number;
   widthTwips: number;
+  rectTwips?: PublicTwipsRect;
+  direction?: "ltr" | "rtl";
+  runAnchors?: readonly PublicLineRunAnchor[];
+}
+
+export interface PublicLineRunAnchor {
+  anchorId: string;
+  runId: string;
+  segmentId: string;
+  blockId: string;
+  fragmentId: string;
+  lineIndex: number;
+  direction: "ltr" | "rtl";
+  baselinePageYTwips: number;
+  lineRectTwips: PublicTwipsRect;
+  firstGlyphRectTwips: PublicTwipsRect;
+  lastGlyphRectTwips: PublicTwipsRect;
+  runRectTwips: PublicTwipsRect;
+  precision: RuntimeLineRunAnchor["precision"];
 }
 
 export interface PublicNoteAllocation {
@@ -348,6 +372,36 @@ export interface PublicPageSpan {
   pageCount: number;
 }
 
+export interface PublicPagePaginationTelemetry {
+  pageId: string;
+  pageIndex: number;
+  startOffset: number;
+  endOffset: number;
+  isBlankFiller: boolean;
+  materialization: NonNullable<RuntimePageNode["materialization"]>;
+  bodyFragmentCount: number;
+  /**
+   * Unique body block ids referenced by this page. Split blocks count once
+   * on each page they occupy, which makes this the useful page-window
+   * estimator for block-index based viewport callers.
+   */
+  bodyBlockReferenceCount: number;
+  lineBoxCount: number;
+  noteAllocationCount: number;
+}
+
+export interface PublicPaginationTelemetry {
+  revision: number;
+  pageCount: number;
+  materializedPageCount: number;
+  unpaginatedPageCount: number;
+  bodyFragmentCount: number;
+  bodyBlockReferenceCount: number;
+  averageBodyFragmentsPerMaterializedPage: number;
+  averageBodyBlockReferencesPerMaterializedPage: number;
+  pages: readonly PublicPagePaginationTelemetry[];
+}
+
 export interface PublicSectionNode {
   sectionIndex: number;
   startOffset: number;
@@ -556,6 +610,13 @@ export interface WordReviewEditorLayoutFacet {
    */
   getStoryRegionsOnPage(pageIndex: number): readonly PublicPageRegion[];
   getFragmentsForPage(pageIndex: number): PublicBlockFragment[];
+  /**
+   * Per-page materialization and body block/fragment counts derived from the
+   * current page graph. Consumers that only have block-index viewport ranges
+   * can use this to estimate page windows from the actual document instead
+   * of hardcoded blocks-per-page constants.
+   */
+  getPaginationTelemetry(): PublicPaginationTelemetry;
 
   /**
    * P8 — Returns per-region block snapshots for a page.  Body resolves the
@@ -1229,6 +1290,10 @@ export function createLayoutFacet(
         .map((f) => toPublicBlockFragment(f, graph));
     },
 
+    getPaginationTelemetry() {
+      return toPublicPaginationTelemetry(currentGraph());
+    },
+
     getResolvedFormatting(blockId) {
       const state = currentFormatting();
       const formatting = state.paragraphs.get(blockId);
@@ -1446,6 +1511,7 @@ function toPublicPageNode(
     startOffset: node.startOffset,
     endOffset: node.endOffset,
     isBlankFiller: node.isBlankFiller,
+    materialization: node.materialization ?? "paginated",
     displayPageNumber: node.stories.displayPageNumber,
     isFirstPage: node.stories.isFirstPage,
     isEvenPage: node.stories.isEvenPage,
@@ -1554,6 +1620,9 @@ function toPublicStoryAnchoredObject(
           },
         }
       : {}),
+    ...(object.anchorRectTwips
+      ? { anchorRectTwips: toPublicTwipsRect(object.anchorRectTwips) }
+      : {}),
     ...(object.relationshipIds ? { relationshipIds: [...object.relationshipIds] } : {}),
     ...(object.mediaIds ? { mediaIds: [...object.mediaIds] } : {}),
     preserveOnly: object.preserveOnly,
@@ -1643,6 +1712,76 @@ function toPublicBlockFragment(
   };
 }
 
+function bodyFragmentsForPage(
+  node: RuntimePageNode,
+  graph: RuntimePageGraph,
+): RuntimeBlockFragment[] {
+  const bodyFragmentIds = new Set(node.regions.body.fragmentIds);
+  return graph.fragments.filter((fragment) =>
+    bodyFragmentIds.has(fragment.fragmentId),
+  );
+}
+
+function toPublicPagePaginationTelemetry(
+  node: RuntimePageNode,
+  graph: RuntimePageGraph,
+): PublicPagePaginationTelemetry {
+  const bodyFragments = bodyFragmentsForPage(node, graph);
+  const bodyBlockIds = new Set(bodyFragments.map((fragment) => fragment.blockId));
+  return {
+    pageId: node.pageId,
+    pageIndex: node.pageIndex,
+    startOffset: node.startOffset,
+    endOffset: node.endOffset,
+    isBlankFiller: node.isBlankFiller,
+    materialization: node.materialization ?? "paginated",
+    bodyFragmentCount: bodyFragments.length,
+    bodyBlockReferenceCount: bodyBlockIds.size,
+    lineBoxCount: node.lineBoxes.length,
+    noteAllocationCount: node.noteAllocations.length,
+  };
+}
+
+function average(count: number, divisor: number): number {
+  return divisor > 0 ? count / divisor : 0;
+}
+
+function toPublicPaginationTelemetry(
+  graph: RuntimePageGraph,
+): PublicPaginationTelemetry {
+  const pages = graph.pages.map((node) =>
+    toPublicPagePaginationTelemetry(node, graph),
+  );
+  const materializedPages = pages.filter(
+    (page) => page.materialization === "paginated",
+  );
+  const bodyFragmentCount = materializedPages.reduce(
+    (total, page) => total + page.bodyFragmentCount,
+    0,
+  );
+  const bodyBlockReferenceCount = materializedPages.reduce(
+    (total, page) => total + page.bodyBlockReferenceCount,
+    0,
+  );
+  return {
+    revision: graph.revision,
+    pageCount: pages.length,
+    materializedPageCount: materializedPages.length,
+    unpaginatedPageCount: pages.length - materializedPages.length,
+    bodyFragmentCount,
+    bodyBlockReferenceCount,
+    averageBodyFragmentsPerMaterializedPage: average(
+      bodyFragmentCount,
+      materializedPages.length,
+    ),
+    averageBodyBlockReferencesPerMaterializedPage: average(
+      bodyBlockReferenceCount,
+      materializedPages.length,
+    ),
+    pages,
+  };
+}
+
 function cloneContinuationCursor(
   cursor: RuntimeLayoutContinuationCursor,
 ): RuntimeLayoutContinuationCursor {
@@ -1721,8 +1860,32 @@ function toPublicLineBox(box: RuntimeLineBox): PublicLineBox {
     fragmentId: box.fragmentId,
     lineIndex: box.lineIndex,
     baselineTwips: box.baselineTwips,
+    ...(box.baselinePageYTwips !== undefined
+      ? { baselinePageYTwips: box.baselinePageYTwips }
+      : {}),
     heightTwips: box.heightTwips,
     widthTwips: box.widthTwips,
+    ...(box.rectTwips ? { rectTwips: toPublicTwipsRect(box.rectTwips) } : {}),
+    ...(box.direction ? { direction: box.direction } : {}),
+    ...(box.runAnchors ? { runAnchors: box.runAnchors.map(toPublicLineRunAnchor) } : {}),
+  };
+}
+
+function toPublicLineRunAnchor(anchor: RuntimeLineRunAnchor): PublicLineRunAnchor {
+  return {
+    anchorId: anchor.anchorId,
+    runId: anchor.runId,
+    segmentId: anchor.segmentId,
+    blockId: anchor.blockId,
+    fragmentId: anchor.fragmentId,
+    lineIndex: anchor.lineIndex,
+    direction: anchor.direction,
+    baselinePageYTwips: anchor.baselinePageYTwips,
+    lineRectTwips: toPublicTwipsRect(anchor.lineRectTwips),
+    firstGlyphRectTwips: toPublicTwipsRect(anchor.firstGlyphRectTwips),
+    lastGlyphRectTwips: toPublicTwipsRect(anchor.lastGlyphRectTwips),
+    runRectTwips: toPublicTwipsRect(anchor.runRectTwips),
+    precision: anchor.precision,
   };
 }
 
@@ -2178,6 +2341,10 @@ function resolveHeaderFooterRegionBlocks(
         blockSnapshot,
         node,
         graph,
+        {
+          ledger: findPageLocalStoryFieldLedger(node, regionKind, storyTarget),
+          ordinal: 0,
+        },
       );
       return {
         blockId: blockSnapshot.blockId,
@@ -2201,6 +2368,33 @@ const PAGE_INSTANCE_FIELD_FAMILIES = new Set([
   "SECTIONPAGES",
 ]);
 
+type PageLocalFieldLedger = readonly {
+  readonly family: string;
+  readonly displayText: string;
+}[];
+
+interface PageScopedFieldState {
+  readonly ledger: PageLocalFieldLedger | undefined;
+  ordinal: number;
+}
+
+function findPageLocalStoryFieldLedger(
+  page: RuntimePageNode,
+  regionKind: "header" | "footer",
+  storyTarget: EditorStoryTarget,
+): PageLocalFieldLedger | undefined {
+  if (storyTarget.kind !== regionKind) return undefined;
+  const pageLocalStory = page.frame?.pageLocalStories.find(
+    (story) =>
+      story.kind === storyTarget.kind &&
+      story.relationshipId === storyTarget.relationshipId &&
+      story.variant === storyTarget.variant &&
+      (storyTarget.sectionIndex === undefined ||
+        story.sectionIndex === storyTarget.sectionIndex),
+  );
+  return pageLocalStory?.resolvedFields;
+}
+
 function resolvePageScopedFieldsInBlocks(
   blocks: readonly SurfaceBlockSnapshot[],
   page: RuntimePageNode,
@@ -2208,7 +2402,10 @@ function resolvePageScopedFieldsInBlocks(
 ): readonly SurfaceBlockSnapshot[] {
   let changed = false;
   const resolvedBlocks = blocks.map((block) => {
-    const resolved = resolvePageInstanceFieldsInBlock(block, page, graph);
+    const resolved = resolvePageInstanceFieldsInBlock(block, page, graph, {
+      ledger: undefined,
+      ordinal: 0,
+    });
     if (resolved !== block) changed = true;
     return resolved;
   });
@@ -2219,10 +2416,16 @@ function resolvePageInstanceFieldsInBlock(
   block: SurfaceBlockSnapshot,
   page: RuntimePageNode,
   graph: RuntimePageGraph,
+  fieldState: PageScopedFieldState,
 ): SurfaceBlockSnapshot {
   switch (block.kind) {
     case "paragraph": {
-      const segments = resolvePageInstanceFieldsInSegments(block.segments, page, graph);
+      const segments = resolvePageInstanceFieldsInSegments(
+        block.segments,
+        page,
+        graph,
+        fieldState,
+      );
       return segments === block.segments ? block : { ...block, segments };
     }
     case "table": {
@@ -2232,7 +2435,12 @@ function resolvePageInstanceFieldsInBlock(
         const cells = row.cells.map((cell) => {
           let cellChanged = false;
           const content = cell.content.map((child) => {
-            const resolved = resolvePageInstanceFieldsInBlock(child, page, graph);
+            const resolved = resolvePageInstanceFieldsInBlock(
+              child,
+              page,
+              graph,
+              fieldState,
+            );
             if (resolved !== child) cellChanged = true;
             return resolved;
           });
@@ -2249,7 +2457,12 @@ function resolvePageInstanceFieldsInBlock(
     case "sdt_block": {
       let changed = false;
       const children = block.children.map((child) => {
-        const resolved = resolvePageInstanceFieldsInBlock(child, page, graph);
+        const resolved = resolvePageInstanceFieldsInBlock(
+          child,
+          page,
+          graph,
+          fieldState,
+        );
         if (resolved !== child) changed = true;
         return resolved;
       });
@@ -2264,17 +2477,23 @@ function resolvePageInstanceFieldsInSegments(
   segments: SurfaceInlineSegment[],
   page: RuntimePageNode,
   graph: RuntimePageGraph,
+  fieldState: PageScopedFieldState,
 ): SurfaceInlineSegment[] {
   let changed = false;
   const resolvedSegments = segments.map((segment) => {
     if (segment.kind !== "field_ref" || !PAGE_INSTANCE_FIELD_FAMILIES.has(segment.fieldFamily)) {
       return segment;
     }
-    const displayText = resolvePageFieldDisplayText(
-      segment.fieldFamily,
-      segment.displayText ?? segment.label,
-      { page, graph },
-    );
+    const ledgerField = fieldState.ledger?.[fieldState.ordinal];
+    fieldState.ordinal += 1;
+    const displayText =
+      ledgerField?.family === segment.fieldFamily
+        ? ledgerField.displayText
+        : resolvePageFieldDisplayText(
+            segment.fieldFamily,
+            segment.displayText ?? segment.label,
+            { page, graph },
+          );
     if (segment.displayText === displayText && segment.refreshStatus === "current") {
       return segment;
     }