@beyondwork/docx-react-component 1.0.103 → 1.0.104

package/src/model/layout/index.ts

@@ -59,6 +59,12 @@
 export type {
   RuntimePageRegions,
   RuntimePageRegion,
+  RuntimeTwipsRect,
+  RuntimeResolvedRegions,
+  RuntimeExclusionZone,
+  RuntimeLayoutDivergenceKind,
+  RuntimeLayoutDivergence,
+  RuntimePageFrame,
   RuntimeBlockFragment,
   RuntimeLineBox,
   RuntimeNoteAllocation,

package/src/model/layout/page-graph-types.ts

@@ -48,6 +48,17 @@ export interface RuntimePageRegions {
   footnotes?: RuntimePageRegion[];
 }
 
+export interface RuntimeTwipsRect {
+  /** Twips offset from the physical page left edge. */
+  xTwips: number;
+  /** Twips offset from the physical page top edge. */
+  yTwips: number;
+  /** Width in twips. */
+  widthTwips: number;
+  /** Height in twips. */
+  heightTwips: number;
+}
+
 export interface RuntimePageRegion {
   kind: "body" | "header" | "footer" | "column" | "footnote-area";
   /** Twips offset from page top (header) or similar region-specific origin. */
@@ -56,10 +67,60 @@ export interface RuntimePageRegion {
   widthTwips: number;
   /** Height in twips. */
   heightTwips: number;
+  /**
+   * PE2 Slice 2 — explicit twips-space frame for this region.
+   * This is semantic layout geometry, not rendered pixel geometry.
+   */
+  rectTwips?: RuntimeTwipsRect;
   /** IDs of block fragments rendered in this region, in order. */
   fragmentIds: string[];
 }
 
+export interface RuntimeResolvedRegions {
+  body: RuntimePageRegion;
+  header?: RuntimePageRegion;
+  footer?: RuntimePageRegion;
+  columns?: RuntimePageRegion[];
+  footnotes?: RuntimePageRegion[];
+  exclusionZones: RuntimeExclusionZone[];
+}
+
+export interface RuntimeExclusionZone {
+  rectTwips: RuntimeTwipsRect;
+  objectId: string;
+  wrapMode: string;
+  layoutInCell?: boolean;
+}
+
+export type RuntimeLayoutDivergenceKind =
+  | "frame-collision"
+  | "intentional-overflow"
+  | "unsupported-wrap"
+  | "stale-field-label"
+  | "preserve-only-placeholder";
+
+export interface RuntimeLayoutDivergence {
+  divergenceId: string;
+  kind: RuntimeLayoutDivergenceKind;
+  source: "runtime";
+  severity: "info" | "warning" | "error";
+  message: string;
+  regionKinds?: RuntimePageRegion["kind"][];
+  fragmentIds?: string[];
+}
+
+export interface RuntimePageFrame {
+  frameId: string;
+  pageId: string;
+  pageIndex: number;
+  sectionIndex: number;
+  displayPageNumber: number;
+  physicalBoundsTwips: RuntimeTwipsRect;
+  regions: RuntimeResolvedRegions;
+  divergenceIds: string[];
+  signature: string;
+}
+
 // ---------------------------------------------------------------------------
 // Fragment types
 // ---------------------------------------------------------------------------

package/src/model/layout/runtime-page-graph-types.ts

@@ -16,9 +16,11 @@
 
 import type {
   RuntimeBlockFragment,
+  RuntimeLayoutDivergence,
   RuntimeLineBox,
   RuntimeNoteAllocation,
   RuntimePageAnchor,
+  RuntimePageFrame,
   RuntimePageRegions,
 } from "./page-graph-types.ts";
 import type {
@@ -63,6 +65,14 @@ export interface RuntimePageNode {
   stories: ResolvedPageStories;
   /** Sub-regions on the page. */
   regions: RuntimePageRegions;
+  /**
+   * PE2 Slice 2 — page-level frame record for consumers that need a
+   * single immutable twips-space layout payload instead of reconstructing
+   * it from `layout` + `regions`.
+   */
+  frame?: RuntimePageFrame;
+  /** Typed layout limitations or overlaps detected while building this page. */
+  divergences?: RuntimeLayoutDivergence[];
   /** Line boxes rendered in the body region. */
   lineBoxes: RuntimeLineBox[];
   /** Footnote allocations reserved at the bottom of the page. */

package/src/runtime/collab/runtime-collab-sync.ts

@@ -473,11 +473,11 @@ export function createRuntimeCollabSync(
   // For a late joiner it may already be populated — the seed ensures the
   // runtime reflects pre-existing shared state at attach time (i.e. if a
   // peer already set `lockedMode`, the new peer starts out locked).
-  runtime.setSharedWorkflowState(workflowShared.get());
+  runtime.setSharedWorkflowState(workflowShared.get(), { source: "collab" });
 
   const workflowUnsub = workflowShared.subscribe((state) => {
     if (readOnly) return; // don't propagate while in read-only (post-mismatch)
-    runtime.setSharedWorkflowState(state);
+    runtime.setSharedWorkflowState(state, { source: "collab" });
   });
 
   const unsubscribeCommandApplied = commandAppliedBridge.subscribe((command, _transaction, context, meta) => {
@@ -607,7 +607,7 @@ export function createRuntimeCollabSync(
       yCheckpoints.unobserve(onCheckpointsChange);
       workflowUnsub();
       workflowShared.destroy();
-      runtime.setSharedWorkflowState(null);
+      runtime.setSharedWorkflowState(null, { source: "runtime" });
       listeners.clear();
       // R3 — abort the current remote-activity signal so any lingering
       // idle consumers detect the shutdown.

package/src/runtime/debug/build-debug-inspector-snapshot.ts

@@ -576,13 +576,23 @@ function projectLayout(
   runtime: DocumentRuntime,
   fallbacks: string[],
 ): DebugInspectorLayoutSection {
-  const pageLayout = safeCall(
+  const graphPageCount = safeCall(
     runtime,
-    (r) => r.getPageLayoutSnapshot(),
+    (r) => r.getLayoutFacet().getPageCount(),
     null,
     fallbacks,
-    "page-layout-summary",
+    "layout-page-count",
   );
+  const pageLayout =
+    graphPageCount === null
+      ? safeCall(
+          runtime,
+          (r) => r.getPageLayoutSnapshot(),
+          null,
+          fallbacks,
+          "page-layout-summary",
+        )
+      : null;
   const sections = safeCall(runtime, (r) => r.getSections(), [], fallbacks, "sections");
   const stories = safeCall(
     runtime,
@@ -592,7 +602,10 @@ function projectLayout(
     "document-text-stream",
   );
   return {
-    pageCount: (pageLayout as { pages?: unknown[] } | null)?.pages?.length ?? null,
+    pageCount:
+      graphPageCount ??
+      (pageLayout as { pages?: unknown[] } | null)?.pages?.length ??
+      null,
     sectionCount: sections.length,
     storyCount: stories.length,
   };

package/src/runtime/document-runtime.ts

@@ -82,6 +82,7 @@ import type {
   WorkflowCandidateRange,
   WorkflowCandidateRangeOptions,
   WorkflowBlockedCommandReason,
+  WorkflowEventOrigin,
   WorkflowMetadataDefinition,
   OverlayKind,
   OverlayVisibilityPolicy,
@@ -764,7 +765,10 @@ export interface DocumentRuntime {
   setWorkflowOverlay(overlay: WorkflowOverlay): void;
   clearWorkflowOverlay(): void;
   getWorkflowOverlay(): WorkflowOverlay | null;
-  setSharedWorkflowState(state: SharedWorkflowState | null): void;
+  setSharedWorkflowState(
+    state: SharedWorkflowState | null,
+    origin?: WorkflowEventOrigin,
+  ): void;
   getWorkflowScopeSnapshot(): WorkflowScopeSnapshot | null;
   getInteractionGuardSnapshot(): InteractionGuardSnapshot;
   getWorkflowMarkupSnapshot(): WorkflowMarkupSnapshot;
@@ -1880,6 +1884,19 @@ export function createDocumentRuntime(
     nextActiveStory: EditorStoryTarget,
   ): DocumentNavigationSnapshot {
     const activeStoryKey = storyTargetKey(nextActiveStory);
+    const buildSnapshot = (): DocumentNavigationSnapshot =>
+      layoutEngine.getNavigationSnapshot(
+        {
+          document: nextState.document,
+          viewState: {
+            activeStory: nextActiveStory,
+            workspaceMode: viewState.workspaceMode,
+            zoomLevel: viewState.zoomLevel,
+          },
+        },
+        nextState.selection,
+        nextActiveStory,
+      );
     if (
       cachedNavigation &&
       cachedNavigation.revisionToken === nextState.revisionToken &&
@@ -1889,11 +1906,7 @@ export function createDocumentRuntime(
         return cachedNavigation.snapshot;
       }
 
-      const snapshot = createDocumentNavigationSnapshot(
-        nextState.document,
-        nextState.selection.head,
-        nextActiveStory,
-      );
+      const snapshot = buildSnapshot();
       if (
         snapshot.activePageIndex === cachedNavigation.snapshot.activePageIndex &&
         snapshot.activeSectionIndex === cachedNavigation.snapshot.activeSectionIndex
@@ -1915,11 +1928,7 @@ export function createDocumentRuntime(
       return snapshot;
     }
 
-    const snapshot = createDocumentNavigationSnapshot(
-      nextState.document,
-      nextState.selection.head,
-      nextActiveStory,
-    );
+    const snapshot = buildSnapshot();
     recordPerfSample("snapshot.navigation");
     incrementInvalidationCounter("runtime.snapshot.navigationMisses");
     cachedNavigation = {
@@ -4560,6 +4569,7 @@ export function createDocumentRuntime(
         // P5 — TOC entries print Word's display number (honors page-
         // number restarts), not the raw 0-based pageIndex+1.
         (pageIndex: number) => layoutFacet.getDisplayPageNumber(pageIndex),
+        getCachedDocumentNavigationSnapshot(state, activeStory),
       );
       if (refreshed.changed) {
         this.dispatch({
@@ -4709,8 +4719,8 @@ export function createDocumentRuntime(
     getWorkflowOverlay() {
       return workflowCoordinator.getWorkflowOverlay();
     },
-    setSharedWorkflowState(sharedState) {
-      workflowCoordinator.setSharedWorkflowState(sharedState);
+    setSharedWorkflowState(sharedState, origin) {
+      workflowCoordinator.setSharedWorkflowState(sharedState, origin);
     },
     getWorkflowScopeSnapshot() {
       return workflowCoordinator.getWorkflowScopeSnapshot();
@@ -5935,6 +5945,7 @@ export function createDocumentRuntime(
         activeStory,
         undefined,
         (pageIndex: number) => layoutFacet.getDisplayPageNumber(pageIndex),
+        getCachedDocumentNavigationSnapshot(state, activeStory),
       );
       perfCounters.increment("toc.autoRefresh.us", Math.round((performance.now() - t) * 1000));
       if (!refreshed.changed) {
@@ -6144,6 +6155,9 @@ export function createDocumentRuntime(
       case "story_changed":
       case "workflow_overlay_changed":
       case "workflow_active_work_item_changed":
+      case "workflow_shared_state_changed":
+      case "workflow_visibility_policy_changed":
+      case "workflow_markup_mode_policy_changed":
       case "change_authored":
       case "change_accepted":
       case "change_rejected":
@@ -7482,6 +7496,7 @@ function refreshDocumentTableOfContents(
   activeStory: EditorStoryTarget,
   options?: TocRefreshOptions,
   resolveDisplayPageNumber?: (pageIndex: number) => number | null,
+  navigationSnapshot?: DocumentNavigationSnapshot,
 ): {
   document: CanonicalDocumentEnvelope;
   result: TocRefreshResult;
@@ -7511,7 +7526,8 @@ function refreshDocumentTableOfContents(
     };
   }
 
-  const navigation = createDocumentNavigationSnapshot(document, selectionHead, activeStory);
+  const navigation =
+    navigationSnapshot ?? createDocumentNavigationSnapshot(document, selectionHead, activeStory);
   // Build a single O(N) map from paragraph offset → bookmark name so the
   // per-heading lookup below is O(1) instead of O(N) per heading.
   const bookmarkNameByOffset = new Map<number, string>();

package/src/runtime/event-refresh-hints.ts

@@ -25,6 +25,9 @@ export function describeEventImpact(
       };
     case "workflow_overlay_changed":
     case "workflow_active_work_item_changed":
+    case "workflow_shared_state_changed":
+    case "workflow_visibility_policy_changed":
+    case "workflow_markup_mode_policy_changed":
       return {
         invalidate: [
           "workflowScope",

package/src/runtime/formatting/formatting-context.ts

@@ -46,6 +46,7 @@ import type {
   TableStyleConditionalRegion,
   Mutable,
 } from "../../model/canonical-document.ts";
+import { collectCanonicalFieldRegionIdentities } from "../../model/canonical-layout-inputs.ts";
 import type { FieldPageGraph, FieldResolver, ResolvedField } from "./field/resolver.ts";
 import { createFieldResolver } from "./field/resolver.ts";
 import { ThemeColorResolver, concretizeThemeColors } from "./theme-color.ts";
@@ -68,13 +69,21 @@ import type {
   EffectiveNumbering,
   EffectiveParagraphFormatting,
   EffectiveRunFormatting,
+  RevisionDisplayFlags,
 } from "./formatting-types.ts";
 import {
+  buildEffectiveLayoutFormatting,
+  buildRevisionLayoutPosture,
   collectFieldLayoutInputs,
+  mergeLayoutTabStops,
   toFieldLayoutInput,
+  toLayoutTabStops,
   toNumberingLayoutInput,
+  type EffectiveLayoutFormatting,
   type FieldLayoutInput,
+  type LayoutTabStopInput,
   type NumberingLayoutInput,
+  type RevisionLayoutPosture,
 } from "./layout-inputs.ts";
 
 /**
@@ -342,6 +351,23 @@ export interface FormattingContext {
   /** Resolve every field/TOC registry entry into PE2 field-layout inputs. */
   collectFieldLayoutInputs(): readonly FieldLayoutInput[];
 
+  /** Resolve paragraph tab stops into L04-ready twip/leader inputs. */
+  resolveParagraphTabStops(para: ParagraphNode): readonly LayoutTabStopInput[];
+
+  /**
+   * Consolidated PE2 paragraph formatting bundle. This is the L03-owned
+   * handoff shape for L04 measurement: paragraph cascade, run formatting,
+   * numbering input, paragraph/numbering tabs, compatibility flags, revision
+   * posture, and a stable structural hash are resolved in one context call.
+   */
+  resolveParagraphLayoutFormatting(input: {
+    readonly paragraph: ParagraphNode;
+    readonly runs?: readonly EffectiveRunFormatting[];
+    readonly revisionDisplays?: readonly RevisionDisplayFlags[];
+    readonly revisionMode?: RevisionLayoutPosture["mode"];
+    readonly compatFlags?: readonly string[];
+  }): EffectiveLayoutFormatting;
+
   /** Resolve the effective font family for a run following
    *  ECMA-376 §17.3.2.26 precedence + theme-minor fallback. */
   resolveFontFamily(input: RunResolveInput, themeMinorFont?: string): string | undefined;
@@ -637,9 +663,54 @@ class FormattingContextImpl implements FormattingContext {
   collectFieldLayoutInputs(): readonly FieldLayoutInput[] {
     return collectFieldLayoutInputs(this.doc.fieldRegistry, (entry) =>
       this.resolveField(entry),
+      collectCanonicalFieldRegionIdentities(this.doc),
     );
   }
 
+  resolveParagraphTabStops(para: ParagraphNode): readonly LayoutTabStopInput[] {
+    return toLayoutTabStops(this.resolveParagraphCascade(para).tabStops, "paragraph");
+  }
+
+  resolveParagraphLayoutFormatting(input: {
+    readonly paragraph: ParagraphNode;
+    readonly runs?: readonly EffectiveRunFormatting[];
+    readonly revisionDisplays?: readonly RevisionDisplayFlags[];
+    readonly revisionMode?: RevisionLayoutPosture["mode"];
+    readonly compatFlags?: readonly string[];
+  }): EffectiveLayoutFormatting {
+    const numberingDetail = this.resolveParagraphNumbering(input.paragraph, { advance: true });
+    const numbering = toNumberingLayoutInput(numberingDetail);
+    const paragraph = buildEffectiveParagraphFormatting(
+      this.resolveParagraphCascade(input.paragraph),
+      numberingDetail,
+      this.theme,
+    );
+    const runs = input.runs ?? [];
+    const revisionDisplays =
+      input.revisionDisplays ??
+      runs
+        .map((run) => run.revisionDisplay)
+        .filter((display): display is RevisionDisplayFlags => display !== undefined);
+    const revisionMode = input.revisionMode ?? revisionDisplays[0]?.markupMode;
+    const revisionPosture = revisionMode
+      ? buildRevisionLayoutPosture(revisionMode, revisionDisplays)
+      : undefined;
+    return buildEffectiveLayoutFormatting({
+      paragraph,
+      runs,
+      ...(numbering ? { numbering } : {}),
+      tabs: mergeLayoutTabStops(
+        this.resolveParagraphTabStops(input.paragraph),
+        numbering?.associatedTabStops,
+      ),
+      compatFlags: mergeCompatFlags(
+        collectParagraphCompatFlags(paragraph),
+        input.compatFlags ?? [],
+      ),
+      ...(revisionPosture ? { revisionPosture } : {}),
+    });
+  }
+
   resolveFontFamily(
     input: RunResolveInput,
     themeMinorFont?: string,
@@ -655,17 +726,11 @@ class FormattingContextImpl implements FormattingContext {
 
   resolveParagraph(para: ParagraphNode): EffectiveParagraphFormatting {
     const cascade = this.resolveParagraphCascade(para);
-    const numbering = buildEffectiveNumbering(
+    return buildEffectiveParagraphFormatting(
+      cascade,
       this.resolveParagraphNumbering(para, { advance: true }),
+      this.theme,
     );
-    const paragraphMarkRun = cascade.paragraphMarkRunProperties && this.theme
-      ? (concretizeThemeColors(cascade.paragraphMarkRunProperties, this.theme) as EffectiveRunFormatting)
-      : (cascade.paragraphMarkRunProperties as EffectiveRunFormatting | undefined);
-    return {
-      ...cascade,
-      ...(numbering ? { numbering } : {}),
-      ...(paragraphMarkRun ? { paragraphMarkRun } : {}),
-    };
   }
 
   resolveRunWithProvenance(input: {
@@ -910,6 +975,42 @@ function buildEffectiveNumbering(
   return result;
 }
 
+function buildEffectiveParagraphFormatting(
+  cascade: CanonicalParagraphFormatting,
+  numberingDetail: NumberingResolution | null,
+  theme: ThemeColorResolver | undefined,
+): EffectiveParagraphFormatting {
+  const numbering = buildEffectiveNumbering(numberingDetail);
+  const paragraphMarkRun = cascade.paragraphMarkRunProperties && theme
+    ? (concretizeThemeColors(cascade.paragraphMarkRunProperties, theme) as EffectiveRunFormatting)
+    : (cascade.paragraphMarkRunProperties as EffectiveRunFormatting | undefined);
+  return {
+    ...cascade,
+    ...(numbering ? { numbering } : {}),
+    ...(paragraphMarkRun ? { paragraphMarkRun } : {}),
+  };
+}
+
+function collectParagraphCompatFlags(
+  paragraph: EffectiveParagraphFormatting,
+): readonly string[] {
+  const flags: string[] = [];
+  if (paragraph.keepNext === true) flags.push("keepNext");
+  if (paragraph.keepLines === true) flags.push("keepLines");
+  if (paragraph.pageBreakBefore === true) flags.push("pageBreakBefore");
+  if (paragraph.contextualSpacing === true) flags.push("contextualSpacing");
+  if (paragraph.widowControl === false) flags.push("widowControlDisabled");
+  if (paragraph.bidi === true) flags.push("bidi");
+  if (paragraph.suppressLineNumbers === true) flags.push("suppressLineNumbers");
+  return flags;
+}
+
+function mergeCompatFlags(
+  ...groups: readonly (readonly string[] | undefined)[]
+): readonly string[] {
+  return [...new Set(groups.flatMap((group) => group ?? []))].sort();
+}
+
 // Type-only re-export of HyperlinkNode so callers can type their walk.
 export type { HyperlinkNode, InlineNode };
 

package/src/runtime/formatting/index.ts

@@ -109,7 +109,9 @@ export {
   buildRevisionLayoutPosture,
   collectFieldLayoutInputs,
   createStructuralHash,
+  mergeLayoutTabStops,
   normalizeNumberingMarkerSuffix,
+  toMeasuredRevisionLayoutPosture,
   toFieldLayoutInput,
   toLayoutTabStops,
   toNumberingLayoutInput,

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,