@beyondwork/docx-react-component 1.0.103 → 1.0.105

package/src/model/layout/index.ts

@@ -59,6 +59,15 @@
 export type {
   RuntimePageRegions,
   RuntimePageRegion,
+  RuntimeTwipsRect,
+  RuntimeResolvedRegions,
+  RuntimeExclusionZone,
+  RuntimeLayoutDivergenceKind,
+  RuntimeLayoutDivergence,
+  RuntimePageFrame,
+  RuntimePageLocalStoryInstance,
+  RuntimeResolvedStoryField,
+  RuntimeStoryAnchoredObject,
   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,141 @@ 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[];
+  objectIds?: string[];
+}
+
+export interface RuntimePageFrame {
+  frameId: string;
+  pageId: string;
+  pageIndex: number;
+  sectionIndex: number;
+  displayPageNumber: number;
+  physicalBoundsTwips: RuntimeTwipsRect;
+  regions: RuntimeResolvedRegions;
+  pageLocalStories: RuntimePageLocalStoryInstance[];
+  divergenceIds: string[];
+  signature: string;
+}
+
+export interface RuntimePageLocalStoryInstance {
+  instanceId: string;
+  storyKey: string;
+  pageId: string;
+  kind: "header" | "footer";
+  variant: "default" | "first" | "even" | "odd";
+  relationshipId: string;
+  sectionIndex?: number;
+  resolvedFields: RuntimeResolvedStoryField[];
+  anchoredObjects: RuntimeStoryAnchoredObject[];
+  measuredFrameHeightTwips: number;
+  signature: string;
+}
+
+export interface RuntimeResolvedStoryField {
+  fieldId: string;
+  family: string;
+  displayText: string;
+}
+
+export interface RuntimeStoryAnchoredObject {
+  objectId: string;
+  sourceType:
+    | "image"
+    | "drawing-frame"
+    | "chart-preview"
+    | "smartart-preview"
+    | "shape"
+    | "wordart"
+    | "vml-shape"
+    | "ole-embed"
+    | "opaque-inline";
+  display: "inline" | "floating" | "unknown";
+  extentTwips?: {
+    widthTwips: number;
+    heightTwips: number;
+  };
+  relationshipIds?: readonly string[];
+  preserveOnly: boolean;
+  divergenceIds: string[];
+}
+
+export type RuntimeLayoutContinuationCursor =
+  | RuntimeParagraphContinuationCursor
+  | RuntimeTableContinuationCursor;
+
+export interface RuntimeParagraphContinuationCursor {
+  kind: "paragraph";
+  sequenceIndex: number;
+  sliceCount: number;
+  lineRange: {
+    from: number;
+    to: number;
+    totalLines: number;
+  };
+  continuesFromPreviousPage: boolean;
+  continuesToNextPage: boolean;
+}
+
+export interface RuntimeTableContinuationCursor {
+  kind: "table";
+  sequenceIndex: number;
+  sliceCount: number;
+  rowRange: {
+    from: number;
+    to: number;
+    totalRows: number;
+  };
+  continuesFromPreviousPage: boolean;
+  continuesToNextPage: boolean;
+  repeatedHeaderRowIndexes: readonly number[];
+  verticalMergeCarry: readonly RuntimeTableVerticalMergeCarry[];
+}
+
+export interface RuntimeTableVerticalMergeCarry {
+  columnIndex: number;
+  restartRowIndex: number;
+}
+
 // ---------------------------------------------------------------------------
 // Fragment types
 // ---------------------------------------------------------------------------
@@ -115,6 +257,14 @@ export interface RuntimeBlockFragment {
     to: number;
     totalRows: number;
   };
+  /**
+   * PE2 Slice 3 — typed continuation cursor for fragments that render a
+   * logical block over multiple page/column frames. Existing slice fields
+   * remain for compatibility; this cursor makes repeated-header,
+   * line/row-range, and vertical-merge carry explicit for debug/render
+   * consumers without reading DOM or canonical tables again.
+   */
+  continuation?: RuntimeLayoutContinuationCursor;
   /**
    * Slice 5 — opaque style-chain ref derived from the block's `styleId`.
    * Used by `analyzeStylesChange` to bound invalidation to the first page

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

@@ -14,11 +14,17 @@
  * layer (`src/runtime/layout/page-graph.ts`).
  */
 
+import type {
+  FooterDocument,
+  HeaderDocument,
+} from "../canonical-document.ts";
 import type {
   RuntimeBlockFragment,
+  RuntimeLayoutDivergence,
   RuntimeLineBox,
   RuntimeNoteAllocation,
   RuntimePageAnchor,
+  RuntimePageFrame,
   RuntimePageRegions,
 } from "./page-graph-types.ts";
 import type {
@@ -63,6 +69,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. */
@@ -105,4 +119,13 @@ export interface BuildPageGraphInput {
    * `page-${revision}-${index}` pageId in advance.
    */
   noteAllocationsByPageIndex?: ReadonlyMap<number, RuntimeNoteAllocation[]>;
+  /**
+   * Optional canonical header/footer parts. When present, `buildPageGraph`
+   * resolves page-instance fields inside page-local header/footer story
+   * records without making render/UI consumers re-walk subparts.
+   */
+  subParts?: {
+    headers?: ReadonlyArray<HeaderDocument>;
+    footers?: ReadonlyArray<FooterDocument>;
+  };
 }

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,8 @@ export function describeEventImpact(
       };
     case "workflow_overlay_changed":
     case "workflow_active_work_item_changed":
+    case "workflow_shared_state_changed":
+    case "workflow_markup_mode_policy_changed":
       return {
         invalidate: [
           "workflowScope",
@@ -37,9 +39,27 @@ export function describeEventImpact(
         staleTargets: ["anchors"],
         changeKinds: ["workflow"],
       };
+    case "workflow_visibility_policy_changed":
+      return {
+        invalidate: [
+          "workflowScope",
+          "workflowMarkup",
+          "reviewWork",
+          "chunks",
+          "contextAnalytics",
+        ],
+        staleTargets: ["none"],
+        changeKinds: ["workflow"],
+      };
     case "workflow_metadata_changed":
       return {
-        invalidate: ["workflowMarkup", "render", "locations", "reviewWork", "chunks"],
+        invalidate: [
+          "workflowMarkup",
+          "locations",
+          "reviewWork",
+          "chunks",
+          "contextAnalytics",
+        ],
         staleTargets: ["anchors"],
         changeKinds: ["workflow"],
       };
@@ -47,10 +67,6 @@ export function describeEventImpact(
     case "change_accepted":
     case "change_rejected":
     case "suggestion_authored":
-    case "suggestion_updated":
-    case "comment_added":
-    case "comment_resolved":
-    case "comments_changed":
       return {
         invalidate: [
           "render",
@@ -69,6 +85,20 @@ export function describeEventImpact(
         staleTargets: ["search_results", "anchors"],
         changeKinds: ["content", "review", "structure"],
       };
+    case "suggestion_updated":
+      return {
+        invalidate: ["trackedChanges", "reviewWork", "chunks", "contextAnalytics"],
+        staleTargets: ["none"],
+        changeKinds: ["review"],
+      };
+    case "comment_added":
+    case "comment_resolved":
+    case "comments_changed":
+      return {
+        invalidate: ["comments", "reviewWork", "chunks", "contextAnalytics"],
+        staleTargets: ["none"],
+        changeKinds: ["review"],
+      };
     case "warning_added":
     case "warning_cleared":
     case "error":

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,