@docx-editor.dev/core 2.7.0 → 2.9.0

package/dist/layout.d.ts

@@ -1,24 +1,25 @@
-import { V as VersionedShapingLibrary, T as TextShaper, F as FontByteValidator, a as FixedPointRoundingMode, b as FixedPoint, c as TextDirection, S as ShapedRun } from './shaped-measurer-CakZ7g1s.js';
-export { C as CacheLookup, d as CacheMiss, e as CacheProvenance, D as DeclaredFontSubstitution, f as FontFingerprintInputs, g as FontRequest, h as FontResolutionError, i as FontResolutionErrorCode, j as FontResourceDefinition, k as FontResourceInstrumentation, l as FontResourceSnapshot, m as FontResourceSnapshotOptions, n as FontSubstitution, o as FontValidationResult, G as GlyphOutline, H as HARD_MAX_AGGREGATE_FONT_BYTES, p as HARD_MAX_FONT_BYTES, q as HARD_MAX_FONT_SOURCES, L as LayoutShapingOptions, N as NormalizationPolicy, O as OperationSnapshot, r as OperationSnapshotField, s as OperationSnapshotGuard, R as ResolvedCache, t as ResolvedFont, u as ResourceDependencyProvenance, v as ShapeInput, w as ShapedCluster, x as ShapedFontSpan, y as ShapedGlyph, z as ShapedMeasurerOptions, A as ShapedRunComparatorInputs, B as ShapedVerticalMetrics, E as ShapingEnvironment, I as ShapingEnvironmentFingerprintInputs, J as ShapingEnvironmentInput, K as boundedStructuralFontValidator, M as captureOperationSnapshot, P as createFontResourceSnapshot, Q as createShapedMeasurer, U as createShapedRun, W as createShapingEnvironment, X as fixedPoint, Y as fontRequestKey, Z as guardOperationSnapshot, _ as sha256FontBytes, $ as shapedRunComparatorInputs, a0 as shapingEnvironmentFingerprint, a1 as shapingEnvironmentFingerprintInputs } from './shaped-measurer-CakZ7g1s.js';
-import { d as LayoutBox, D as DrawingPoint, e as DrawingInsets, a as StyleSpanRecord, I as InlineDrawingRecord, M as ModelRange, R as ResolvedRunStyle, f as ThemeFonts, g as ParagraphSpacing, h as ParagraphLineSpacing, i as ParagraphBorderEdge, j as ParagraphBorders, k as ResolvedTabStops, l as TableBorderSide, S as SemanticLayout, B as BlockFragmentRecord, m as InlineDrawingLayoutContext, T as TextMeasurer, H as HyperlinkProjector, F as FieldLinkProjector, n as PageRecord, o as ParagraphFragmentRecord, p as StoryPageFieldNeeds, A as AnchoredDrawingRecord, P as PageGeometry, q as CellBorderBox, r as TableBorderBox } from './semantic-records-DoW_xNgJ.js';
-export { s as AUTO_PARAGRAPH_SPACING_PT, t as BorderGridGeometry, C as ContentControlBoundaryRecord, u as ContentControlGeometryFragment, v as ContentControlLevel, w as ContentControlLock, x as ContentControlMappedType, y as DEFAULT_PAGE_GEOMETRY, z as DEFAULT_RUN_STYLE, E as DEFAULT_TAB_INTERVAL_PT, G as DEFAULT_TAB_INTERVAL_TWIPS, J as EMPTY_TAB_STOPS, K as FieldAtomMarker, N as HeaderFooterStoryRecord, O as HyperlinkFieldSpec, L as LineRecord, Q as LineSpacingRule, U as ListMarkerRecord, V as MAX_BORDER_SPACE_PT, W as MAX_BORDER_WIDTH_PT, X as MAX_PARAGRAPH_SPACING_PT, Y as MAX_TABLE_BORDER_STROKES, Z as MAX_TAB_POSITION_TWIPS, _ as MAX_TAB_STOPS, $ as PARAGRAPH_BORDER_SIDES, a0 as ParagraphAutoSpacingContext, a1 as ParagraphBorderSide, a2 as ParagraphBorderStrokeRecord, a3 as ParagraphBottomBorderRecord, a4 as ParagraphIndent, a5 as ResolvedCellBorders, a6 as ResolvedTableBorderEdge, a7 as ResolvedTableBorderEdgeSegment, a8 as ResolvedUnderline, a9 as SINGLE_LINE_SPACING, aa as SourceRange, ab as SpanLinkRecord, ac as TAB_LEADER_GLYPH, ad as TabAlignment, ae as TabDestination, af as TabLeader, ag as TabStop, ah as TableBorderSideName, ai as TableBorderStrokeRecord, c as TableCellFragmentRecord, aj as TableFragmentRecord, b as TableRowFragmentRecord, ak as VerticalAlign, al as appliedSpaceBefore, am as applyLineSpacing, an as baselineShiftPtOf, ao as borderExtentPt, ap as borderWeight, aq as bottomBorderExtentPt, ar as cascadedParagraphBorders, as as cascadedTabStops, at as collapsedSpaceBefore, au as contentControlsOfLayout, av as defaultTabIntervalFromSettings, aw as displayText, ax as effectiveContentControlLock, ay as fragmentsOfParagraph, az as lineAtPosition, aA as linesOf, aB as measureDisplayText, aC as nextTabDestination, aD as paragraphBorderExtentPt, aE as paragraphBorderStrokeWidthPt, aF as paragraphBorders, aG as paragraphBordersFingerprint, aH as paragraphBreaksBefore, aI as paragraphContextualSpacing, aJ as paragraphFragmentsOf, aK as paragraphFragmentsOfBlocks, aL as paragraphLineSpacing, aM as paragraphSpacing, aN as paragraphTabStops, aO as readBorderSide, aP as readCellBorders, aQ as readTableBorders, aR as resolveBorderConflict, aS as resolveRunStyle, aT as resolveTableCellBorderGrid, aU as runStylesEqual, aV as tabAdvanceWidth, aW as tabStopsFingerprint, aX as unionLayoutBoxes, aY as withDefaultTabInterval } from './semantic-records-DoW_xNgJ.js';
-import { O as OoxmlNode, a as OoxmlElement, e as OoxmlPart } from './ooxml-tree-BU0e3DVi.js';
-import { O as OoxmlProperty, C as ContentControlKind, n as ContentControlLevel, o as ContentControlLock, p as ContentControlDataBinding, I as ImpactClass } from './tree-op-types-fZgbrR5F.js';
-export { m as TableBorderStyle } from './tree-op-types-fZgbrR5F.js';
-import { N as NoteKind, n as noteTypeOf } from './note-nodes-BPSTVDMr.js';
-import { R as ResolvedFootnoteProperties, a as ResolvedEndnoteProperties } from './review-reads-C5E7u-pt.js';
-export { p as paragraphOrderOfPart } from './review-reads-C5E7u-pt.js';
-import { D as DocumentProperties, T as TreeModelChange } from './tree-store-Dy9FZ1pa.js';
-import { R as RevisionDisplayMode } from './revision-projection-UKqvPa4-.js';
-export { D as DEFAULT_REVISION_DISPLAY_MODE, a as RevisionAttribution, b as RevisionKind, f as formatRevisionOf, m as markRevisionRemovesMark, p as paragraphMarkFormatRevisionOf, c as paragraphMarkRevisionOf, d as paragraphMarkRevisionsOf, r as revisionsAreDeletion, e as revisionsVisible, s as shownMarkRevision } from './revision-projection-UKqvPa4-.js';
-import { a as SectionColumns } from './semantic-cell-selection-C8RC0VnN.js';
-export { C as CellSelection, D as DEFAULT_SECTION_PROPERTIES, b as DEFAULT_VERTICAL_WEIGHT, c as DocumentSection, d as DocumentSectionsEnumeration, e as DrawingOverlayFrame, H as HitPoint, f as HitTestOptions, M as MAX_DOCUMENT_SECTIONS, P as PlacedCell, g as SectionBreakType, h as SectionColumnDefinition, i as SectionMargins, j as SectionPageNumbering, S as SectionProperties, k as SemanticHit, l as SemanticHitDrawing, T as TableCellAddress, m as TableCellContext, n as caretBoxOnLine, o as cellSelectionBetween, p as cellSelectionRects, q as cellSelectionText, r as contentControlAtPoint, s as enumerateDocumentSections, t as enumerateDocumentSectionsBounded, u as findDrawingOverlayFrameInLayout, v as geometryOfSection, w as hitTestPage, x as hitTestSheet, y as isFurniturePoint, z as lineEndOffset, A as pageAtY, B as paragraphSectionNode, E as paragraphsInCells, F as parsePageNumbering, G as parseSectionProperties, I as readSectionProperties, J as spanOffsetX, K as spansInCells, L as tableContextAt } from './semantic-cell-selection-C8RC0VnN.js';
-export { M as MAX_SDT_NESTING, c as collectFlowBlocks, a as contentControlContentChildren, i as isContentControl, b as isContentControlContent } from './content-control-walk-D06GijR0.js';
-export { h as CommentAnchor, i as CommentPosition, C as CommentRecord, j as CommentThreadState, c as ReviewCommentItem, d as ReviewCustomItem, a as ReviewItem, R as ReviewModelInput, k as ReviewParagraphAnchor, e as ReviewPosition, f as ReviewRange, b as ReviewRevisionItem, g as ReviewRevisionKind, W as W15_NAMESPACE_URI, l as activeReviewItem, m as anchorLineY, n as commentBodyText, o as commentInitials, p as firstReviewRange, r as reviewAnchorIndex, q as reviewItemGeometry, s as reviewItemKey, t as reviewItemPositionRank, u as reviewItemRanges, v as reviewItemsAt, w as reviewThreadRootOf } from './review-support-Cr2n7f1-.js';
-import { S as SemanticPosition, b as SelectionRect, a as SemanticSelection } from './semantic-interaction-C45D_oG2.js';
-export { c as CaretAtOptions, C as CaretGeometry, M as MoveCaretOptions, N as NavigationCommand, d as caretAt, e as caretStops, f as caretStopsForBlocks, g as compositionAnchor, h as contentControlAtSemantic, i as contentControlsInLayout, j as hitTestSemantic, m as moveCaret, p as paragraphTextFromLayout, s as spansInSelection } from './semantic-interaction-C45D_oG2.js';
-import './image-resources-BWd5u-op.js';
-import './ooxml-package-D_CtywTW.js';
+import { V as VersionedShapingLibrary, T as TextShaper, F as FontByteValidator, a as FixedPointRoundingMode, b as FixedPoint, c as TextDirection, S as ShapedRun } from './shaped-measurer-CwlTPDJO.js';
+export { C as CacheLookup, d as CacheMiss, e as CacheProvenance, D as DeclaredFontSubstitution, f as FontFingerprintInputs, g as FontRequest, h as FontResolutionError, i as FontResolutionErrorCode, j as FontResourceDefinition, k as FontResourceInstrumentation, l as FontResourceSnapshot, m as FontResourceSnapshotOptions, n as FontSubstitution, o as FontValidationResult, G as GlyphOutline, H as HARD_MAX_AGGREGATE_FONT_BYTES, p as HARD_MAX_FONT_BYTES, q as HARD_MAX_FONT_SOURCES, L as LayoutShapingOptions, N as NormalizationPolicy, O as OperationSnapshot, r as OperationSnapshotField, s as OperationSnapshotGuard, R as ResolvedCache, t as ResolvedFont, u as ResourceDependencyProvenance, v as ShapeInput, w as ShapedCluster, x as ShapedFontSpan, y as ShapedGlyph, z as ShapedMeasurerOptions, A as ShapedRunComparatorInputs, B as ShapedVerticalMetrics, E as ShapingEnvironment, I as ShapingEnvironmentFingerprintInputs, J as ShapingEnvironmentInput, K as boundedStructuralFontValidator, M as captureOperationSnapshot, P as createFontResourceSnapshot, Q as createShapedMeasurer, U as createShapedRun, W as createShapingEnvironment, X as fixedPoint, Y as fontRequestKey, Z as guardOperationSnapshot, _ as shapedRunComparatorInputs, $ as shapingEnvironmentFingerprint, a0 as shapingEnvironmentFingerprintInputs } from './shaped-measurer-CwlTPDJO.js';
+import { d as LayoutBox, D as DrawingPoint, e as DrawingInsets, a as StyleSpanRecord, I as InlineDrawingRecord, M as ModelRange, S as SemanticLayout, B as BlockFragmentRecord, A as AnchoredDrawingRecord, f as PageRecord, R as ResolvedRunStyle, g as ThemeFonts, h as ParagraphSpacing, i as ParagraphLineSpacing, j as ParagraphBorderEdge, k as ParagraphBorders, l as ResolvedTabStops, m as TableBorderSide, C as ContentControlBoundaryRecord$1, n as ContentControlLock, o as ParagraphFragmentRecord, L as LineRecord, p as InlineDrawingLayoutContext, T as TextMeasurer, H as HyperlinkProjector, F as FieldLinkProjector, q as StoryPageFieldNeeds, P as PageGeometry, r as CellBorderBox, s as TableBorderBox } from './semantic-records-Cc1MJrhM.js';
+export { t as AUTO_PARAGRAPH_SPACING_PT, u as BorderGridGeometry, v as ContentControlGeometryFragment, w as ContentControlLevel, x as ContentControlMappedType, y as DEFAULT_PAGE_GEOMETRY, z as DEFAULT_RUN_STYLE, E as DEFAULT_TAB_INTERVAL_PT, G as DEFAULT_TAB_INTERVAL_TWIPS, J as EMPTY_TAB_STOPS, K as EquationFractionGeometry, N as EquationGeometry, O as EquationNaryGeometry, Q as EquationRadicalGeometry, U as EquationRowGeometry, V as EquationScriptGeometry, W as EquationSpanRecord, X as EquationTextGeometry, Y as FieldAtomMarker, Z as HeaderFooterStoryRecord, _ as HyperlinkFieldSpec, $ as LineSpacingRule, a0 as ListMarkerRecord, a1 as MAX_BORDER_SPACE_PT, a2 as MAX_BORDER_WIDTH_PT, a3 as MAX_PARAGRAPH_SPACING_PT, a4 as MAX_TABLE_BORDER_STROKES, a5 as MAX_TAB_POSITION_TWIPS, a6 as MAX_TAB_STOPS, a7 as PARAGRAPH_BORDER_SIDES, a8 as ParagraphAutoSpacingContext, a9 as ParagraphBorderSide, aa as ParagraphBorderStrokeRecord, ab as ParagraphBottomBorderRecord, ac as ParagraphIndent, ad as ResolvedCellBorders, ae as ResolvedTableBorderEdge, af as ResolvedTableBorderEdgeSegment, ag as ResolvedUnderline, ah as SINGLE_LINE_SPACING, ai as SourceRange, aj as SpanLinkRecord, ak as TAB_LEADER_GLYPH, al as TabAlignment, am as TabDestination, an as TabLeader, ao as TabStop, ap as TableBorderSideName, aq as TableBorderStrokeRecord, c as TableCellFragmentRecord, ar as TableFragmentRecord, b as TableRowFragmentRecord, as as VerticalAlign, at as appliedSpaceBefore, au as applyLineSpacing, av as baselineShiftPtOf, aw as borderExtentPt, ax as borderWeight, ay as bottomBorderExtentPt, az as cascadedParagraphBorders, aA as cascadedTabStops, aB as collapsedSpaceBefore, aC as defaultTabIntervalFromSettings, aD as displayText, aE as layoutEquation, aF as measureDisplayText, aG as nextTabDestination, aH as paragraphBorderExtentPt, aI as paragraphBorderStrokeWidthPt, aJ as paragraphBorders, aK as paragraphBordersFingerprint, aL as paragraphBreaksBefore, aM as paragraphContextualSpacing, aN as paragraphLineSpacing, aO as paragraphSpacing, aP as paragraphTabStops, aQ as readBorderSide, aR as readCellBorders, aS as readTableBorders, aT as resolveBorderConflict, aU as resolveRunStyle, aV as resolveTableCellBorderGrid, aW as runStylesEqual, aX as tabAdvanceWidth, aY as tabStopsFingerprint, aZ as withDefaultTabInterval } from './semantic-records-Cc1MJrhM.js';
+import { a as OoxmlNode, b as OoxmlElement, O as OoxmlPart } from './ooxml-package-CdEy9ufK.js';
+import { O as OoxmlProperty, I as ImpactClass, C as ContentControlKind, n as ContentControlLevel, o as ContentControlLock$1, p as ContentControlDataBinding } from './tree-op-types-XMVsJSpe.js';
+export { m as TableBorderStyle } from './tree-op-types-XMVsJSpe.js';
+import { N as NoteKind, n as noteTypeOf } from './note-nodes-BNCANoGN.js';
+import { R as ResolvedFootnoteProperties, a as ResolvedEndnoteProperties } from './note-properties-jvnw_DGG.js';
+import { T as TreeModelChange, D as DocumentProperties } from './tree-store-ClA-qng4.js';
+import { R as RevisionDisplayMode } from './revision-projection-CILpvv4M.js';
+export { D as DEFAULT_REVISION_DISPLAY_MODE, a as RevisionAttribution, b as RevisionKind, f as formatRevisionOf, m as markRevisionRemovesMark, p as paragraphMarkFormatRevisionOf, c as paragraphMarkRevisionOf, d as paragraphMarkRevisionsOf, r as revisionsAreDeletion, e as revisionsVisible, s as shownMarkRevision } from './revision-projection-CILpvv4M.js';
+import { a as SectionColumns } from './semantic-cell-selection-BWhVAk5B.js';
+export { C as CellSelection, D as DEFAULT_SECTION_PROPERTIES, b as DEFAULT_VERTICAL_WEIGHT, c as DocumentSection, d as DocumentSectionsEnumeration, e as DrawingOverlayFrame, H as HitPoint, f as HitTestOptions, M as MAX_DOCUMENT_SECTIONS, P as PlacedCell, g as SectionBreakType, h as SectionColumnDefinition, i as SectionMargins, j as SectionPageNumbering, S as SectionProperties, k as SemanticHit, l as SemanticHitDrawing, T as TableCellAddress, m as TableCellContext, n as caretBoxOnLine, o as cellSelectionBetween, p as cellSelectionRects, q as cellSelectionText, r as contentControlAtPoint, s as enumerateDocumentSections, t as enumerateDocumentSectionsBounded, u as findDrawingOverlayFrameInLayout, v as geometryOfSection, w as hitTestPage, x as hitTestSheet, y as isFurniturePoint, z as lineEndOffset, A as pageAtY, B as paragraphSectionNode, E as paragraphsInCells, F as parsePageNumbering, G as parseSectionProperties, I as readSectionProperties, J as spanOffsetX, K as spansInCells, L as tableContextAt } from './semantic-cell-selection-BWhVAk5B.js';
+export { M as MAX_SDT_NESTING, c as collectFlowBlocks, a as commentBodyText, b as commentInitials, d as contentControlContentChildren, i as isContentControl, e as isContentControlContent, p as paragraphOrderOfPart } from './review-reads-B2Ji3fVU.js';
+import { a as ReviewItem } from './review-items-D5SPFtsO.js';
+export { i as CommentAnchor, j as CommentPosition, C as CommentRecord, h as CommentThreadState, c as ReviewCommentItem, d as ReviewCustomItem, R as ReviewModelInput, e as ReviewPosition, f as ReviewRange, b as ReviewRevisionItem, g as ReviewRevisionKind, W as W15_NAMESPACE_URI, k as activeReviewItem, l as firstReviewRange, r as reviewItemKey, m as reviewItemPositionRank, n as reviewItemRanges, o as reviewItemsAt, p as reviewThreadRootOf } from './review-items-D5SPFtsO.js';
+import { S as SemanticPosition, b as SelectionRect, a as SemanticSelection } from './semantic-interaction-Cca1-X_a.js';
+export { c as CaretAtOptions, C as CaretGeometry, M as MoveCaretOptions, N as NavigationCommand, d as caretAt, e as caretStops, f as caretStopsForBlocks, g as compositionAnchor, h as contentControlAtSemantic, i as contentControlsInLayout, j as hitTestSemantic, m as moveCaret, p as paragraphTextFromLayout, s as spansInSelection } from './semantic-interaction-Cca1-X_a.js';
+import './image-resources-eZqD_-vC.js';
+import './omml-equation-Dd3mBep-.js';
+import './contracts/types.js';
 
 /**
  * Page-field evaluation context for furniture projection.
@@ -398,6 +399,246 @@ declare function resolveNumberingLevel(index: NumberingIndex, numId: string, ilv
 /** Empty index for tests / documents without numbering. */
 declare const EMPTY_NUMBERING_INDEX: NumberingIndex;
 
+/**
+ * What a batch of commits can affect.
+ *
+ * `paragraphIds` is the set the commits touched directly. What that set MEANS depends on
+ * `impact`: for a local impact it bounds the work, for a structural one it only says where
+ * the reflow starts.
+ */
+interface LayoutScope {
+    readonly impact: ImpactClass;
+    /** Node ids touched directly by the coalesced commits. */
+    readonly paragraphIds: ReadonlySet<string>;
+    /** Ids the commits created — no previous layout exists for these. */
+    readonly created: ReadonlySet<string>;
+    /** Ids the commits removed — any retained layout for these must be released. */
+    readonly deleted: ReadonlySet<string>;
+    /** Cache keys the commits invalidated (styles, numbering, fonts). */
+    readonly dependencyKeys: ReadonlySet<string>;
+    /** True when the block SEQUENCE changed, so ids alone cannot bound the reflow. */
+    readonly structural: boolean;
+    /** The revision this scope describes — the layout result must carry the same one. */
+    readonly revision: number;
+}
+/** How the scheduler produces layouts and when it publishes them. */
+interface LayoutSchedulerOptions {
+    /**
+     * Produce a complete layout for the CURRENT model state.
+     *
+     * Given the accumulated scope so an incremental implementation can use it. It must tag
+     * the result with the revision it actually read, which is what makes staleness detectable
+     * rather than assumed.
+     */
+    readonly run: (scope: LayoutScope) => SemanticLayout;
+    /** The model's revision right now. Read at publish time, never cached. */
+    readonly currentRevision: () => number;
+    /** Called with a layout that is known current. Never called with a stale one. */
+    readonly publish: (layout: SemanticLayout, scope: LayoutScope) => void;
+    /**
+     * Defer work to a later turn, returning a canceller.
+     *
+     * Injected rather than assumed: the browser wants an animation frame, tests want to step
+     * the queue by hand, and a server has neither.
+     */
+    readonly schedule?: (run: () => void) => () => void;
+    /**
+     * Run a layout in slices instead of in one call (task 9.5).
+     *
+     * Optional: without it `run` is used and completes in one turn, which is right for a
+     * document small enough that slicing costs more than it saves.
+     */
+    readonly runCooperatively?: (scope: LayoutScope) => CooperativeRun;
+}
+interface CooperativeRun {
+    /**
+     * Advance the work. Returns the finished layout, or null to be called again.
+     *
+     * Split so a global relayout does not hold the main thread for the whole document: the
+     * scheduler yields between slices and a newer revision can cancel the run mid-flight
+     * rather than the user waiting for work whose result is already stale.
+     */
+    step(): SemanticLayout | null;
+    /** Abandon the run. Nothing partial is ever published. */
+    cancel(): void;
+}
+/**
+ * Coalesces commits into layout passes.
+ *
+ * A keystroke is one commit but must not be one full layout pass, so changes accumulate into a
+ * scope and are laid out together. Every published layout is tagged with the revision it actually
+ * read, which is what makes a stale result detectable rather than merely late.
+ */
+interface LayoutScheduler {
+    /** Record a commit. Coalesces with anything already pending. */
+    notify(change: TreeModelChange): void;
+    /** Request a relayout for a reason the store did not report (page size, zoom, fonts). */
+    invalidateAll(revision: number, reason?: string): void;
+    /** Run any pending work now, synchronously. Returns whether a layout was published. */
+    flush(): boolean;
+    /** The scope that would be used if `flush` ran now, or null when nothing is pending. */
+    pending(): LayoutScope | null;
+    /** Drop pending work without publishing — for teardown. */
+    cancel(): void;
+    /** How many layouts were discarded for being stale. Diagnostics, and a test hook. */
+    readonly staleDiscards: number;
+    /** How many cooperative runs were abandoned because a newer revision arrived. */
+    readonly cancelledRuns: number;
+}
+/**
+ * Build the scheduler that turns a stream of commits into coalesced layout passes.
+ *
+ * Keystrokes arrive faster than a document can be laid out, so changes accumulate into one scope
+ * and are laid out together rather than once per commit.
+ */
+declare function createLayoutScheduler(options: LayoutSchedulerOptions): LayoutScheduler;
+
+/** The flow state as it stood immediately before one block was placed. */
+interface FlowCheckpoint {
+    /** Completed pages at this point. The prefix of the previous layout that still stands. */
+    readonly pageCount: number;
+    /** Fragments already on the page being built. */
+    readonly pageFragments: readonly BlockFragmentRecord[];
+    /** Anchored drawings already collected for the open page. */
+    readonly pendingAnchoredDrawings: readonly AnchoredDrawingRecord[];
+    /**
+     * Anchored drawings overlap resolution pushed onto the NEXT page, and how many times each
+     * drawing has been pushed.
+     *
+     * Flow state like the rest of this record, and carried for the same reason: a resume that
+     * started with an empty list dropped a drawing that the previous pass had deferred but not
+     * yet placed, and a convergence that did not compare them accepted a flow that still owed
+     * the next page a drawing as equal to one that owed it nothing.
+     */
+    readonly deferredAnchoredDrawings: readonly AnchoredDrawingRecord[];
+    readonly anchorPageDeferCounts: ReadonlyMap<string, number>;
+    readonly cursorY: number;
+    readonly lineCounter: number;
+    /** Trailing paragraph spacing participating in adjacent-spacing collapse. */
+    readonly previousSpaceAfter: number;
+    /** Active column index when the section uses multiple columns. */
+    readonly flowColumnIndex: number;
+}
+/**
+ * What the last layout pass actually did — the observable evidence that incremental layout is
+ * working.
+ *
+ * `reusedPages` and `fullPasses` are the ones that matter: a typing keystroke that rebuilds every
+ * page produces identical output and unusable performance, so the tests assert on these rather
+ * than on the rendered result.
+ */
+interface LayoutSessionStats {
+    /** Paragraphs placed by the last pass, against the number in the document. */
+    readonly placed: number;
+    readonly total: number;
+    /** Pages carried over from the previous layout without being rebuilt. */
+    readonly reusedPages: number;
+    /** Passes that could not resume and laid the document out from the top. */
+    readonly fullPasses: number;
+}
+/** One section's place on the previous document sheet stack. */
+interface SectionStackSpan {
+    readonly startIndex: number;
+    readonly pageCount: number;
+    readonly sheetY: number;
+    /** Remapped pages (projectors intact) from the last pass for this section. */
+    readonly remappedPages: readonly PageRecord[];
+}
+/** Orchestrator state for multi-section incremental layout. */
+interface MultiSectionLayoutState {
+    structureKey: string;
+    sections: LayoutSession[];
+    spans: SectionStackSpan[];
+    previousRemapped: readonly PageRecord[];
+    previousFinalized: SemanticLayout | null;
+    previousPageCount: number;
+}
+/**
+ * Carried-over state that makes layout incremental.
+ *
+ * A caller creates one and hands the SAME object back each pass. It holds the previous pages, the
+ * per-block cache keys and the flow checkpoints a pass resumes from, so an edit low in a document
+ * re-lays only what follows it. A no-change pass returns the previous pages by identity.
+ */
+interface LayoutSession {
+    /** @internal Mutable across passes; a caller only creates one and passes it back. */
+    previous: SemanticLayout | null;
+    checkpoints: FlowCheckpoint[];
+    keys: string[];
+    /** Geometry and producer of the previous pass; a change to either forces a full pass. */
+    context: string;
+    /**
+     * Whether the previous pass read page PARITY: even/odd header variants, or an anchored
+     * drawing positioned against an inside/outside frame or alignment.
+     *
+     * The document page index is not part of {@link context} — page numbers re-project at
+     * finalize and page shells renumber at remap — so parity is the only page-position input
+     * that can invalidate a section's layout. Tracked separately so the common document pays
+     * nothing for a start-index shift.
+     */
+    parityDependent: boolean;
+    /** Parity (0/1) of the document page index this session's layout started on. */
+    startPageParity: number;
+    /**
+     * The section's memoized prepass (prepared blocks, cache keys, flow keys, document
+     * order), reused verbatim while its inputs are unchanged. Opaque here: the shape is
+     * owned by `semantic-layout.ts`, which is the only reader and writer.
+     */
+    prepass: unknown;
+    /**
+     * The notes pass's memoized state (reference hits, mark contexts, per-page attach
+     * results), reused while its inputs are unchanged. Opaque here: the shape is owned by
+     * `note-pagination.ts`, which is the only reader and writer.
+     */
+    notes: unknown;
+    /** Line counter at the start of the previous pass, for translating reused section counts. */
+    startLineCounter: number;
+    /**
+     * Line counter after the last block of the previous pass.
+     *
+     * Multi-section orchestration threads a global line counter across sections; early-exit
+     * paths (unchanged / converged) must report this rather than the resume cursor.
+     */
+    endLineCounter: number;
+    /**
+     * Flow state after the last block of the previous pass, for a section that CONTINUES
+     * onto this one's last sheet (`w:type="continuous"`).
+     *
+     * `endCursorY` is the used height of that sheet's content column; `endSpaceAfter` is the
+     * trailing paragraph spacing still eligible for adjacent-spacing collapse. Reported by
+     * the early-exit paths (unchanged / converged) for the same reason as
+     * {@link endLineCounter}: the resume cursor is not the end of the flow.
+     */
+    endCursorY: number;
+    endSpaceAfter: number;
+    /** Whether the last page of that pass was still open (no trailing page break). */
+    endsOpenPage: boolean;
+    stats: LayoutSessionStats;
+    /**
+     * Column-height limit chosen by the last balanced multi-column pass, or null when the
+     * last pass did not balance.
+     *
+     * Lets the next pass try the remembered limit FIRST: an unchanged balanced section
+     * early-exits on that single attempt instead of re-running the natural pass and the
+     * whole balance search every time.
+     */
+    balanceLimit: number | null;
+    /** Present when the last pass was multi-section; child sessions live here. */
+    multi: MultiSectionLayoutState | null;
+    /**
+     * Page-bottom footnote reserves from the last published notes layout.
+     *
+     * Seeded into the next {@link layoutSemanticDocumentWithNotes} call so the first body
+     * pass already matches the reserved context key — without this, every notes document
+     * starts empty, mismatches, and throws away the session on reflow.
+     */
+    notePageBottomReserves: ReadonlyMap<number, number> | null;
+}
+/**
+ * A layout session, retained across revisions by the caller.
+ */
+declare function createLayoutSession(): LayoutSession;
+
 /**
  * A paragraph's list membership fully resolved: definition, level, marker text and geometry.
  *
@@ -416,7 +657,7 @@ interface ResolvedListItem {
     /** Effective indent after merging level + paragraph indents, in points. */
     readonly indent: NumberingLevelIndent;
     readonly markerStyle: ResolvedRunStyle;
-    /** Fingerprint for layout cache keys (indent + level identity, not ordinal). */
+    /** Fingerprint for layout cache keys (indent, marker text, marker face). */
     readonly cacheToken: string;
 }
 /**
@@ -474,15 +715,6 @@ declare function withResolvedListItems<T extends {
     readonly numberingIndex?: NumberingIndex;
     readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
     readonly styleCascade?: StyleCascadeTable;
-    /**
-     * Host oracle for "is this font family really loaded". Supplied, a Symbol/Wingdings
-     * bullet keeps the file's own private-use codepoint so the authored typeface draws it;
-     * absent, it falls back to the Unicode equivalent rather than a tofu box.
-     *
-     * The resolve is memoized on this function's IDENTITY: a host whose answers change
-     * over time (a font finished loading) must supply a new closure at that point, or the
-     * memo will keep serving marker glyphs computed from the old answers.
-     */
     readonly isFontAvailable?: (family: string) => boolean;
 }>(options: T, blocks: readonly OoxmlElement[]): T & {
     readonly numberingIndex: NumberingIndex;
@@ -737,11 +969,76 @@ interface CompoundBorderMetrics {
  */
 declare function computeDoubleBorderMetricsPt(widthPt: number): CompoundBorderMetrics;
 
+/**
+ * Depth-first paragraph fragments of one page, in reading order.
+ *
+ * Table interiors flatten through rows and cells; header-repeat rows are skipped unless
+ * asked for, so interaction sees each caret stop exactly once while paint sees everything.
+ */
+declare function paragraphFragmentsOf(page: PageRecord, includeHeaderRepeats?: boolean): ParagraphFragmentRecord[];
+declare function paragraphFragmentsOfBlocks(blocks: readonly BlockFragmentRecord[], includeHeaderRepeats?: boolean): ParagraphFragmentRecord[];
+/** Every line in a layout, in reading order — the order caret navigation walks. */
+declare function linesOf(layout: SemanticLayout): LineRecord[];
+/** Every fragment belonging to one paragraph, in order, across page boundaries. */
+declare function fragmentsOfParagraph(layout: SemanticLayout, paragraphId: string): ParagraphFragmentRecord[];
+/** The line containing a model position, or null when the position is not laid out. */
+declare function lineAtPosition(layout: SemanticLayout, paragraphId: string, offset: number, 
+/** Lines to test, when the caller already knows which ones can carry the paragraph. */
+candidates?: Iterable<LineRecord>): LineRecord | null;
+/** Every content-control boundary on a layout, preferring the layout-level list. */
+declare function contentControlsOfLayout(layout: SemanticLayout): readonly ContentControlBoundaryRecord$1[];
+/**
+ * Axis-aligned union of boxes, or null when the list is empty.
+ *
+ * Used when a control's content spans several fragments or spans on one page.
+ */
+declare function unionLayoutBoxes(boxes: readonly LayoutBox[]): LayoutBox | null;
+/** Collapse raw + ancestor locks into one `ST_Lock` vocabulary value. */
+declare function effectiveContentControlLock(locks: readonly ContentControlLock[]): ContentControlLock;
+
 /** Paragraph ids in document order, deduplicated across fragments. */
 declare function documentOrder(layout: SemanticLayout): string[];
+/**
+ * Paragraph ids of EVERY story the layout paints, in the order they sit on the page.
+ *
+ * Body, then each page's header and footer, then its note areas — per page, so a story's own
+ * paragraphs stay adjacent and in reading order. That is all any caller needs: a selection
+ * cannot span two stories (the engine refuses one), so only the order WITHIN a story is ever
+ * compared, and this gets that right for all of them at once.
+ *
+ * What a caller passes when it has no story in hand — `selectionRects` and
+ * `spansInSelection` both REQUIRE an order rather than defaulting to one, deliberately.
+ * {@link documentOrder} is the body alone, and
+ * using it as a default is what let selection reads silently answer about the wrong story —
+ * two paragraphs selected in a header both ranked -1, the walk gave up, and the run properties
+ * came back short. A caller that DOES know its story should still pass that story's order:
+ * it is smaller, and it cannot match a paragraph the caret is not among.
+ */
+declare function everyStoryOrder(layout: SemanticLayout): string[];
 
-/** The rectangles covering a selection, one per line it spans. */
-declare function selectionRects(layout: SemanticLayout, selection: SemanticSelection): SelectionRect[];
+/**
+ * The rectangles covering a selection, one per line it spans.
+ *
+ * BODY fragments only, and a selection outside the body paints nothing. That is a real gap —
+ * a retained pin in a header shows no highlight, and a comment anchored in one draws no band
+ * even though the review queue lists it — but it is the honest shape of what this can answer
+ * today. Widening the walk to the other stories is not enough on its own: header and footer
+ * fragments carry positions relative to their own story box, note fragments relative to their
+ * note area, and one header story object is attached to EVERY page it applies to. Fed straight
+ * into a page-content-relative rect, those produce a band per page, at coordinates belonging
+ * to a different box. Measured, that put a header comment's band on all six pages of a
+ * document at the top-left of the body text. Painting nothing is wrong; painting over the
+ * wrong words is worse, so the walk stays here until the geometry is carried with it.
+ */
+declare function selectionRects(layout: SemanticLayout, selection: SemanticSelection, 
+/**
+ * Reading order of the ACTIVE story.
+ *
+ * REQUIRED, for the reason `spansInSelection` gives: any default is one story's order, and
+ * it is wrong for every caret outside that story. A caller with no story in hand passes
+ * {@link everyStoryOrder}.
+ */
+order: readonly string[]): SelectionRect[];
 /** A model range to highlight, and the key the caller knows it by. */
 interface KeyedRange {
     readonly key: string;
@@ -790,6 +1087,9 @@ declare function wordBoundary(text: string, offset: number, direction: -1 | 1):
  */
 declare function positionPastDeletion(layout: SemanticLayout, position: SemanticPosition): SemanticPosition;
 
+/** Synchronous platform-neutral SHA-256 used before font bytes cross into a shaping implementation. */
+declare const sha256FontBytes: (bytes: Uint8Array) => string;
+
 /**
  * The exact HarfBuzz build this engine shapes against.
  *
@@ -1298,6 +1598,13 @@ interface LayoutNoteStoryOptions {
     readonly producer: string;
     readonly cache?: ParagraphLayoutCache<readonly PendingLine[]>;
     readonly styleCascade?: StyleCascadeTable;
+    /**
+     * `numbering.xml`, so a `w:numPr` paragraph inside a note resolves a marker.
+     *
+     * Per story, like every other: `createListCounterState` is fresh per walk, so a numbered
+     * list in a footnote starts at `w:start` rather than continuing the body's sequence.
+     */
+    readonly numberingIndex?: NumberingIndex;
     readonly defaultTabStopPt?: number;
     /**
      * Same projector seams the BODY walk uses. Without them a `w:hyperlink` or a HYPERLINK
@@ -1420,6 +1727,8 @@ interface NotesLayoutInput {
     readonly producer: string;
     readonly cache?: ParagraphLayoutCache<readonly PendingLine[]>;
     readonly styleCascade?: StyleCascadeTable;
+    /** `numbering.xml`, so a `w:numPr` paragraph inside a note resolves a marker. */
+    readonly numberingIndex?: NumberingIndex;
     readonly defaultTabStopPt?: number;
     /**
      * Link projector seams, same as the body walk's. Normally injected by `semantic-layout`
@@ -1501,232 +1810,114 @@ passMemo?: unknown): {
     readonly stable: boolean;
     readonly reasons: readonly NotePaginationFallbackReason[];
 };
-/**
- * Attach footnote/endnote areas onto a body layout. Does not re-paginate — callers that
- * need reservation must re-run body layout with {@link pageBottomReserves} first.
- */
-declare function attachNotesToLayout(layout: SemanticLayout, allRefs: readonly PageRefHit[], input: NotesLayoutInput, options?: {
-    readonly fallbackReasons?: readonly NotePaginationFallbackReason[];
-    readonly paragraphSectionIndex?: ReadonlyMap<string, number>;
-    /**
-     * Session-carried notes memo, already validated against `allRefs` and `input`.
-     * Opaque at this boundary; the shape is owned by this module.
-     */
-    readonly memo?: unknown;
-}): NotesAttachResult;
-/**
- * Build a continuous (pre-page) mark context for the first body layout pass.
- * eachPage reserves digit width; {@link reprojectBodyNoteMarks} publishes final marks
- * onto body citations after page assignment in {@link attachNotesToLayout}.
- */
-declare function provisionalNoteMarks(refs: readonly PageRefHit[], input: NotesLayoutInput): NoteMarkContext;
-
-/** Page geometry for header/footer anchored frame resolution (story-relative layout space). */
-interface HeaderFooterPageContext {
-    readonly pageNumber: number;
-    readonly pageWidth: number;
-    readonly pageHeight: number;
-    readonly marginLeft: number;
-    readonly marginRight: number;
-    readonly marginTop: number;
-    readonly marginBottom: number;
-}
-interface HeaderFooterStoryLayout {
-    readonly partName: string;
-    /** Main-document relationship id when the furniture source knows it. */
-    readonly rId?: string;
-    /**
-     * Bounded identity of the story's canonical OOXML content.
-     *
-     * Furniture cache keys must not rely on {@link flowHeight} alone: equal-height A→B edits
-     * would otherwise reuse stale page furniture. Derived as a 16-hex FNV-1a over the part's
-     * canonical fingerprint — never DOM identity or unbounded raw serialization in the key.
-     * PAGE/NUMPAGES/SECTIONPAGES projection shares this key; page context is cached separately.
-     */
-    readonly contentKey: string;
-    /** Story-relative fragments; origin at the story box's top-left. */
-    readonly fragments: readonly BlockFragmentRecord[];
-    /** The height the blocks actually flow to — what sizes the box on every page. */
-    readonly flowHeight: number;
-    /**
-     * Allowlisted complex PAGE / NUMPAGES / SECTIONPAGES presence detected for this story.
-     *
-     * Callers use this to skip attaching a page-field projector when the baseline is enough.
-     */
-    readonly pageFieldNeeds: StoryPageFieldNeeds;
-    /** Anchored drawings owned by this story, in story-relative coordinates. */
-    readonly anchoredDrawings?: readonly AnchoredDrawingRecord[];
-    /**
-     * Re-layout this story under a page-field context.
-     *
-     * Field-free stories return `this`. Count-only stories cache by the counts they read.
-     * PAGE stories cache by the distinct evaluated values (including format) with a bounded LRU.
-     */
-    readonly withPageContext: (ctx: FieldPageContext) => HeaderFooterStoryLayout;
-}
-/**
- * Lay one header/footer part out at `contentWidth`.
- *
- * Line ids are namespaced by part so the body's `line-N` counter — which incremental
- * convergence compares — never moves because a header changed.
- *
- * When `pageContext` is set, allowlisted PAGE/NUMPAGES/SECTIONPAGES instructions project
- * live values; otherwise those fields contribute only cached result text (often empty).
- * Field-free stories ignore `pageContext` and share one baseline layout.
- *
- * `defaultTabStopPt` is the document's `w:settings/w:defaultTabStop` (ECMA-376 §17.15.1.25)
- * in points; absent keeps the 0.5" schema default. Furniture tabs on the SAME grid as the
- * body — a page-number tab in a metric-locale footer belongs on the document's interval, not
- * on a constant. It sits at the tail because the parameters ahead of it are already
- * positional; new callers should keep passing `undefined` for what they do not set.
- */
-declare function layoutHeaderFooterStory(part: OoxmlPart, contentWidth: number, measurer: TextMeasurer, producer: string, cache?: ParagraphLayoutCache<readonly PendingLine[]>, styleCascade?: StyleCascadeTable, pageContext?: FieldPageContext, maxPageContextEntries?: number, defaultTabStopPt?: number, displayMode?: RevisionDisplayMode, inlineDrawingLayout?: InlineDrawingLayoutContext, drawingTokenForParagraph?: (paragraph: OoxmlNode) => string, drawingLayoutToken?: string, hfPageContext?: HeaderFooterPageContext, documentProperties?: DocumentProperties): HeaderFooterStoryLayout;
-
-/** The flow state as it stood immediately before one block was placed. */
-interface FlowCheckpoint {
-    /** Completed pages at this point. The prefix of the previous layout that still stands. */
-    readonly pageCount: number;
-    /** Fragments already on the page being built. */
-    readonly pageFragments: readonly BlockFragmentRecord[];
-    /** Anchored drawings already collected for the open page. */
-    readonly pendingAnchoredDrawings: readonly AnchoredDrawingRecord[];
-    /**
-     * Anchored drawings overlap resolution pushed onto the NEXT page, and how many times each
-     * drawing has been pushed.
-     *
-     * Flow state like the rest of this record, and carried for the same reason: a resume that
-     * started with an empty list dropped a drawing that the previous pass had deferred but not
-     * yet placed, and a convergence that did not compare them accepted a flow that still owed
-     * the next page a drawing as equal to one that owed it nothing.
-     */
-    readonly deferredAnchoredDrawings: readonly AnchoredDrawingRecord[];
-    readonly anchorPageDeferCounts: ReadonlyMap<string, number>;
-    readonly cursorY: number;
-    readonly lineCounter: number;
-    /** Trailing paragraph spacing participating in adjacent-spacing collapse. */
-    readonly previousSpaceAfter: number;
-    /** Active column index when the section uses multiple columns. */
-    readonly flowColumnIndex: number;
-}
-/**
- * What the last layout pass actually did — the observable evidence that incremental layout is
- * working.
- *
- * `reusedPages` and `fullPasses` are the ones that matter: a typing keystroke that rebuilds every
- * page produces identical output and unusable performance, so the tests assert on these rather
- * than on the rendered result.
- */
-interface LayoutSessionStats {
-    /** Paragraphs placed by the last pass, against the number in the document. */
-    readonly placed: number;
-    readonly total: number;
-    /** Pages carried over from the previous layout without being rebuilt. */
-    readonly reusedPages: number;
-    /** Passes that could not resume and laid the document out from the top. */
-    readonly fullPasses: number;
-}
-/** One section's place on the previous document sheet stack. */
-interface SectionStackSpan {
-    readonly startIndex: number;
-    readonly pageCount: number;
-    readonly sheetY: number;
-    /** Remapped pages (projectors intact) from the last pass for this section. */
-    readonly remappedPages: readonly PageRecord[];
-}
-/** Orchestrator state for multi-section incremental layout. */
-interface MultiSectionLayoutState {
-    structureKey: string;
-    sections: LayoutSession[];
-    spans: SectionStackSpan[];
-    previousRemapped: readonly PageRecord[];
-    previousFinalized: SemanticLayout | null;
-    previousPageCount: number;
-}
-/**
- * Carried-over state that makes layout incremental.
- *
- * A caller creates one and hands the SAME object back each pass. It holds the previous pages, the
- * per-block cache keys and the flow checkpoints a pass resumes from, so an edit low in a document
- * re-lays only what follows it. A no-change pass returns the previous pages by identity.
+/**
+ * Attach footnote/endnote areas onto a body layout. Does not re-paginate — callers that
+ * need reservation must re-run body layout with {@link pageBottomReserves} first.
  */
-interface LayoutSession {
-    /** @internal Mutable across passes; a caller only creates one and passes it back. */
-    previous: SemanticLayout | null;
-    checkpoints: FlowCheckpoint[];
-    keys: string[];
-    /** Geometry and producer of the previous pass; a change to either forces a full pass. */
-    context: string;
-    /**
-     * Whether the previous pass read page PARITY: even/odd header variants, or an anchored
-     * drawing positioned against an inside/outside frame or alignment.
-     *
-     * The document page index is not part of {@link context} — page numbers re-project at
-     * finalize and page shells renumber at remap — so parity is the only page-position input
-     * that can invalidate a section's layout. Tracked separately so the common document pays
-     * nothing for a start-index shift.
-     */
-    parityDependent: boolean;
-    /** Parity (0/1) of the document page index this session's layout started on. */
-    startPageParity: number;
+declare function attachNotesToLayout(layout: SemanticLayout, allRefs: readonly PageRefHit[], input: NotesLayoutInput, options?: {
+    readonly fallbackReasons?: readonly NotePaginationFallbackReason[];
+    readonly paragraphSectionIndex?: ReadonlyMap<string, number>;
     /**
-     * The section's memoized prepass (prepared blocks, cache keys, flow keys, document
-     * order), reused verbatim while its inputs are unchanged. Opaque here: the shape is
-     * owned by `semantic-layout.ts`, which is the only reader and writer.
+     * Session-carried notes memo, already validated against `allRefs` and `input`.
+     * Opaque at this boundary; the shape is owned by this module.
      */
-    prepass: unknown;
+    readonly memo?: unknown;
+}): NotesAttachResult;
+/**
+ * Build a continuous (pre-page) mark context for the first body layout pass.
+ * eachPage reserves digit width; {@link reprojectBodyNoteMarks} publishes final marks
+ * onto body citations after page assignment in {@link attachNotesToLayout}.
+ */
+declare function provisionalNoteMarks(refs: readonly PageRefHit[], input: NotesLayoutInput): NoteMarkContext;
+
+/** Page geometry for header/footer anchored frame resolution (story-relative layout space). */
+interface HeaderFooterPageContext {
+    readonly pageNumber: number;
+    readonly pageWidth: number;
+    readonly pageHeight: number;
+    readonly marginLeft: number;
+    readonly marginRight: number;
+    readonly marginTop: number;
+    readonly marginBottom: number;
+}
+interface HeaderFooterStoryLayout {
+    readonly partName: string;
     /**
-     * The notes pass's memoized state (reference hits, mark contexts, per-page attach
-     * results), reused while its inputs are unchanged. Opaque here: the shape is owned by
-     * `note-pagination.ts`, which is the only reader and writer.
+     * The part this story was laid out from.
+     *
+     * Carried because a derivation that runs over the finished layout cannot reach it otherwise:
+     * the layout receives furniture as fragments plus a NAME, and a name is not a tree. The
+     * content-control boundary pass needs the tree to know which controls exist at all.
      */
-    notes: unknown;
-    /** Line counter at the start of the previous pass, for translating reused section counts. */
-    startLineCounter: number;
+    readonly part?: OoxmlPart;
+    /** Main-document relationship id when the furniture source knows it. */
+    readonly rId?: string;
     /**
-     * Line counter after the last block of the previous pass.
+     * Bounded identity of the story's canonical OOXML content.
      *
-     * Multi-section orchestration threads a global line counter across sections; early-exit
-     * paths (unchanged / converged) must report this rather than the resume cursor.
+     * Furniture cache keys must not rely on {@link flowHeight} alone: equal-height A→B edits
+     * would otherwise reuse stale page furniture. Derived as a 16-hex FNV-1a over the part's
+     * canonical fingerprint — never DOM identity or unbounded raw serialization in the key.
+     * PAGE/NUMPAGES/SECTIONPAGES projection shares this key; page context is cached separately.
      */
-    endLineCounter: number;
+    readonly contentKey: string;
+    /** Story-relative fragments; origin at the story box's top-left. */
+    readonly fragments: readonly BlockFragmentRecord[];
+    /** The height the blocks actually flow to — what sizes the box on every page. */
+    readonly flowHeight: number;
     /**
-     * Flow state after the last block of the previous pass, for a section that CONTINUES
-     * onto this one's last sheet (`w:type="continuous"`).
+     * Allowlisted complex PAGE / NUMPAGES / SECTIONPAGES presence detected for this story.
      *
-     * `endCursorY` is the used height of that sheet's content column; `endSpaceAfter` is the
-     * trailing paragraph spacing still eligible for adjacent-spacing collapse. Reported by
-     * the early-exit paths (unchanged / converged) for the same reason as
-     * {@link endLineCounter}: the resume cursor is not the end of the flow.
+     * Callers use this to skip attaching a page-field projector when the baseline is enough.
      */
-    endCursorY: number;
-    endSpaceAfter: number;
-    /** Whether the last page of that pass was still open (no trailing page break). */
-    endsOpenPage: boolean;
-    stats: LayoutSessionStats;
+    readonly pageFieldNeeds: StoryPageFieldNeeds;
+    /** Anchored drawings owned by this story, in story-relative coordinates. */
+    readonly anchoredDrawings?: readonly AnchoredDrawingRecord[];
     /**
-     * Column-height limit chosen by the last balanced multi-column pass, or null when the
-     * last pass did not balance.
+     * Re-layout this story under a page-field context.
      *
-     * Lets the next pass try the remembered limit FIRST: an unchanged balanced section
-     * early-exits on that single attempt instead of re-running the natural pass and the
-     * whole balance search every time.
+     * Field-free stories return `this`. Count-only stories cache by the counts they read.
+     * PAGE stories cache by the distinct evaluated values (including format) with a bounded LRU.
      */
-    balanceLimit: number | null;
-    /** Present when the last pass was multi-section; child sessions live here. */
-    multi: MultiSectionLayoutState | null;
+    readonly withPageContext: (ctx: FieldPageContext) => HeaderFooterStoryLayout;
+}
+/**
+ * Story-level inputs the body path has always had and furniture never did.
+ *
+ * A BAG, not more positional parameters. The signature below already carries fifteen, and its
+ * own doc comment used to tell new callers to "keep passing `undefined` for what they do not
+ * set" — which is why `numberingIndex` was never added and a numbered paragraph in a header
+ * painted no marker for as long as headers have been editable. Everything new goes here.
+ */
+interface HeaderFooterStoryInputs {
     /**
-     * Page-bottom footnote reserves from the last published notes layout.
+     * `numbering.xml`, so a `w:numPr` paragraph in this story resolves a marker.
      *
-     * Seeded into the next {@link layoutSemanticDocumentWithNotes} call so the first body
-     * pass already matches the reserved context key — without this, every notes document
-     * starts empty, mismatches, and throws away the session on reflow.
+     * Absent, the story lays out exactly as before: no marker record, and no numbering indent
+     * merged into the paragraph's own.
      */
-    notePageBottomReserves: ReadonlyMap<number, number> | null;
+    readonly numberingIndex?: NumberingIndex;
 }
 /**
- * A layout session, retained across revisions by the caller.
+ * Lay one header/footer part out at `contentWidth`.
+ *
+ * Line ids are namespaced by part so the body's `line-N` counter — which incremental
+ * convergence compares — never moves because a header changed.
+ *
+ * When `pageContext` is set, allowlisted PAGE/NUMPAGES/SECTIONPAGES instructions project
+ * live values; otherwise those fields contribute only cached result text (often empty).
+ * Field-free stories ignore `pageContext` and share one baseline layout.
+ *
+ * `defaultTabStopPt` is the document's `w:settings/w:defaultTabStop` (ECMA-376 §17.15.1.25)
+ * in points; absent keeps the 0.5" schema default. Furniture tabs on the SAME grid as the
+ * body — a page-number tab in a metric-locale footer belongs on the document's interval, not
+ * on a constant. It sits at the tail because the parameters ahead of it are already
+ * positional; new callers should keep passing `undefined` for what they do not set.
+ *
+ * NEW inputs belong in {@link HeaderFooterStoryInputs}, the trailing bag, rather than as a
+ * sixteenth position. Fifteen is what stopped `numberingIndex` being threaded here at all.
  */
-declare function createLayoutSession(): LayoutSession;
+declare function layoutHeaderFooterStory(part: OoxmlPart, contentWidth: number, measurer: TextMeasurer, producer: string, cache?: ParagraphLayoutCache<readonly PendingLine[]>, styleCascade?: StyleCascadeTable, pageContext?: FieldPageContext, maxPageContextEntries?: number, defaultTabStopPt?: number, displayMode?: RevisionDisplayMode, inlineDrawingLayout?: InlineDrawingLayoutContext, drawingTokenForParagraph?: (paragraph: OoxmlNode) => string, drawingLayoutToken?: string, hfPageContext?: HeaderFooterPageContext, documentProperties?: DocumentProperties, inputs?: HeaderFooterStoryInputs): HeaderFooterStoryLayout;
 
 /**
  * A deterministic measurer for tests and headless use.
@@ -1737,6 +1928,31 @@ declare function createLayoutSession(): LayoutSession;
  */
 declare function createFixedMeasurer(charWidth?: number, lineHeight?: number): TextMeasurer;
 
+/**
+ * Every content control a part declares, in document order, WITHOUT geometry.
+ *
+ * For callers that want the ROSTER rather than the rectangles — the Tab walk through form
+ * fields is the one, and it needs story order, not boxes. `fragments` comes back empty here
+ * by design; a caller that needs geometry reads `layout.contentControls`, which covers every
+ * story the layout draws.
+ */
+declare function contentControlRecordsInPart(part: OoxmlPart, 
+/**
+ * Keep only controls holding one of these paragraphs.
+ *
+ * For a notes PART, which holds every note in the document rather than one story. Rostered
+ * whole, Tab walked out of the open footnote and into the next one, and the keystrokes after
+ * it landed in a note the reader was not in.
+ */
+withinParagraphs?: ReadonlySet<string>): readonly ContentControlBoundaryRecord$1[];
+/**
+ * The innermost content control holding `paragraphId`, in `part`.
+ *
+ * Deepest wins, matching the geometry path's innermost-by-nesting rule: a control inside a
+ * control is the one the caret is actually in.
+ */
+declare function contentControlHoldingParagraph(part: OoxmlPart, paragraphId: string): ContentControlBoundaryRecord$1 | null;
+
 /** Which header/footer variant a page shows (ECMA-376 §17.10.5). */
 type HeaderFooterVariantName = 'default' | 'first' | 'even';
 /**
@@ -2173,9 +2389,9 @@ interface ContentControlBoundaryRecord {
     readonly level: ContentControlLevel;
     /** 0 for a top-level control; the nesting depth otherwise. */
     readonly depth: number;
-    readonly lock: ContentControlLock;
+    readonly lock: ContentControlLock$1;
     /** The lock in force here, including every lock an enclosing control imposes. */
-    readonly effectiveLock: ContentControlLock;
+    readonly effectiveLock: ContentControlLock$1;
     readonly showingPlaceholder: boolean;
     readonly temporary: boolean;
     readonly tag?: string;
@@ -2197,6 +2413,93 @@ interface ContentControlBoundaryRecord {
  */
 declare function contentControlBoundaries(part: OoxmlPart, layout: SemanticLayout): readonly ContentControlBoundaryRecord[];
 
+/** Where one paragraph sits, resolved once so a card is an O(1) lookup. */
+interface ReviewParagraphAnchor {
+    readonly pageIndex: number;
+    /** Sheet-absolute y of the page's content box. */
+    readonly contentY: number;
+    /** The fragment's own y, measured from that content box. */
+    readonly fragmentY: number;
+    readonly lines?: readonly {
+        readonly range: {
+            readonly end: number;
+        };
+        readonly box: {
+            readonly y: number;
+        };
+        /**
+         * Present on a real line. A merged fragment's join line carries spans from two
+         * paragraphs, and its `range` can only name one of them, so the OTHER paragraph's extent
+         * on that line is readable here and nowhere else.
+         */
+        readonly spans?: readonly {
+            readonly range: {
+                readonly paragraphId: string;
+                readonly end: number;
+            };
+        }[];
+    }[];
+}
+/**
+ * The y of the line a position sits on, measured from the anchor's own origin.
+ *
+ * An ordinary line answers from its own range, exactly as it always did. On a merged
+ * fragment's join line the range names one of the two paragraphs, so an offset compared
+ * against it either overshot — putting a card in the absorbed half beside the wrong line —
+ * or matched the first line every time.
+ */
+declare function anchorLineY(anchor: ReviewParagraphAnchor, paragraphId: string, offset: number): number;
+/**
+ * Paragraph id to its place on the page, in ONE pass over the layout.
+ *
+ * Built once per layout and reused by every card. The straightforward version — scan the
+ * pages until the paragraph turns up, per card — is a full-document walk per card, and a
+ * contract with two hundred comments walked the document two hundred times every time the
+ * caret moved. Toggling the pane was visibly slow for exactly that reason.
+ */
+declare function reviewAnchorIndex<TPage extends {
+    readonly index: number;
+    readonly contentBox: {
+        readonly y: number;
+    };
+}>(layout: {
+    readonly pages: readonly TPage[];
+}, paragraphFragments: (page: TPage) => readonly {
+    readonly paragraphId: string;
+    readonly box: {
+        readonly y: number;
+    };
+    readonly lines?: readonly {
+        readonly range: {
+            readonly end: number;
+        };
+        readonly box: {
+            readonly y: number;
+        };
+        /** Present on a real line; a merged one carries spans from more than one paragraph. */
+        readonly spans?: readonly {
+            readonly range: {
+                readonly paragraphId: string;
+                readonly end: number;
+            };
+        }[];
+    }[];
+}[]): Map<string, ReviewParagraphAnchor>;
+/**
+ * Where a card belongs beside the page, from LAYOUT RECORDS.
+ *
+ * The one question the tree cannot answer, and the one a surface must not answer for itself:
+ * measuring painted DOM puts the sidebar a repaint behind the document and breaks outright
+ * while pagination is in flight.
+ *
+ * Returns null when the item has no resolvable range, or when its paragraph is not in this
+ * layout — a comment anchored in a header belongs to a story the body layout never saw.
+ */
+declare function reviewItemGeometry(item: ReviewItem, index: ReadonlyMap<string, ReviewParagraphAnchor>): {
+    readonly pageIndex: number;
+    readonly y: number;
+} | null;
+
 /** The visible band of the document, in layout units. */
 interface ViewportWindow {
     /** Distance from the top of the document to the top of the visible area, in layout units. */
@@ -2226,100 +2529,6 @@ interface MaterializationInput {
  */
 declare function pagesToMaterialize(input: MaterializationInput): Set<number>;
 
-/**
- * What a batch of commits can affect.
- *
- * `paragraphIds` is the set the commits touched directly. What that set MEANS depends on
- * `impact`: for a local impact it bounds the work, for a structural one it only says where
- * the reflow starts.
- */
-interface LayoutScope {
-    readonly impact: ImpactClass;
-    /** Node ids touched directly by the coalesced commits. */
-    readonly paragraphIds: ReadonlySet<string>;
-    /** Ids the commits created — no previous layout exists for these. */
-    readonly created: ReadonlySet<string>;
-    /** Ids the commits removed — any retained layout for these must be released. */
-    readonly deleted: ReadonlySet<string>;
-    /** Cache keys the commits invalidated (styles, numbering, fonts). */
-    readonly dependencyKeys: ReadonlySet<string>;
-    /** True when the block SEQUENCE changed, so ids alone cannot bound the reflow. */
-    readonly structural: boolean;
-    /** The revision this scope describes — the layout result must carry the same one. */
-    readonly revision: number;
-}
-/** How the scheduler produces layouts and when it publishes them. */
-interface LayoutSchedulerOptions {
-    /**
-     * Produce a complete layout for the CURRENT model state.
-     *
-     * Given the accumulated scope so an incremental implementation can use it. It must tag
-     * the result with the revision it actually read, which is what makes staleness detectable
-     * rather than assumed.
-     */
-    readonly run: (scope: LayoutScope) => SemanticLayout;
-    /** The model's revision right now. Read at publish time, never cached. */
-    readonly currentRevision: () => number;
-    /** Called with a layout that is known current. Never called with a stale one. */
-    readonly publish: (layout: SemanticLayout, scope: LayoutScope) => void;
-    /**
-     * Defer work to a later turn, returning a canceller.
-     *
-     * Injected rather than assumed: the browser wants an animation frame, tests want to step
-     * the queue by hand, and a server has neither.
-     */
-    readonly schedule?: (run: () => void) => () => void;
-    /**
-     * Run a layout in slices instead of in one call (task 9.5).
-     *
-     * Optional: without it `run` is used and completes in one turn, which is right for a
-     * document small enough that slicing costs more than it saves.
-     */
-    readonly runCooperatively?: (scope: LayoutScope) => CooperativeRun;
-}
-interface CooperativeRun {
-    /**
-     * Advance the work. Returns the finished layout, or null to be called again.
-     *
-     * Split so a global relayout does not hold the main thread for the whole document: the
-     * scheduler yields between slices and a newer revision can cancel the run mid-flight
-     * rather than the user waiting for work whose result is already stale.
-     */
-    step(): SemanticLayout | null;
-    /** Abandon the run. Nothing partial is ever published. */
-    cancel(): void;
-}
-/**
- * Coalesces commits into layout passes.
- *
- * A keystroke is one commit but must not be one full layout pass, so changes accumulate into a
- * scope and are laid out together. Every published layout is tagged with the revision it actually
- * read, which is what makes a stale result detectable rather than merely late.
- */
-interface LayoutScheduler {
-    /** Record a commit. Coalesces with anything already pending. */
-    notify(change: TreeModelChange): void;
-    /** Request a relayout for a reason the store did not report (page size, zoom, fonts). */
-    invalidateAll(revision: number, reason?: string): void;
-    /** Run any pending work now, synchronously. Returns whether a layout was published. */
-    flush(): boolean;
-    /** The scope that would be used if `flush` ran now, or null when nothing is pending. */
-    pending(): LayoutScope | null;
-    /** Drop pending work without publishing — for teardown. */
-    cancel(): void;
-    /** How many layouts were discarded for being stale. Diagnostics, and a test hook. */
-    readonly staleDiscards: number;
-    /** How many cooperative runs were abandoned because a newer revision arrived. */
-    readonly cancelledRuns: number;
-}
-/**
- * Build the scheduler that turns a stream of commits into coalesced layout passes.
- *
- * Keystrokes arrive faster than a document can be laid out, so changes accumulate into one scope
- * and are laid out together rather than once per commit.
- */
-declare function createLayoutScheduler(options: LayoutSchedulerOptions): LayoutScheduler;
-
 /** Far above anything Word authors (its UI caps at 63) while keeping allocation bounded. */
 declare const MAX_TABLE_COLUMNS = 1024;
 
@@ -2588,4 +2797,4 @@ declare class TablePaginationError extends Error {
     constructor(code: TablePaginationErrorCode, message: string);
 }
 
-export { AUTO_PREFERRED_WIDTH, type AbstractNumDefinition, type BidiEmbeddingLevels, BlockFragmentRecord, CELL_PAD, COMPOUND_BORDER_MIN_GAP_PT, COMPOUND_BORDER_MIN_STROKE_PT, type CanvasMeasurerOptions, type CanvasTextContext, type CanvasTextMetrics, type CascadedParagraphFormatting, CellBorderBox, type CellMarginsPt, type CellVerticalAlign, type CompoundBorderMetrics, type ContentControlFragmentRecord, DEFAULT_CANVAS_FONT_STACK, DEFAULT_CELL_MARGINS, EMPTY_NUMBERING_INDEX, FieldLinkProjector, FixedPoint, FixedPointRoundingMode, FontByteValidator, type FontSlot, GRAPHEME_SEGMENTER_LOCALE, type GraphemeBoundary, type GraphemeSegment, type GraphemeWordSegmentRecord, HARFBUZZ_SHAPING_LIBRARY, type HarfBuzzFaceCacheEvent, type HarfBuzzOutlineCacheEvent, type HarfBuzzShapeCacheEvent, HarfBuzzShapingError, type HarfBuzzShapingErrorCode, type HarfBuzzTextShaper, type HarfBuzzTextShaperInstrumentation, type HarfBuzzTextShaperOptions, type HeaderFooterVariantName, HyperlinkProjector, type KeyedRange, LayoutBox, type LayoutCacheStats, type LayoutScheduler, type LayoutSchedulerOptions, type LayoutScope, type LayoutSession, type LayoutSessionStats, type LevelOverride, type ListCounterAdvance, type ListCounterState, type ListMarkerAlign, type ListSuffix, MAX_EACH_PAGE_MARK_CANDIDATES, MAX_LVL_OVERRIDES, MAX_LVL_TEXT_LENGTH, MAX_MARKER_TEXT_LENGTH, MAX_NOTES_LAID_OUT, MAX_NOTE_FRAGMENTS, MAX_NOTE_OVERFLOW_PAGES, MAX_NOTE_REFLOW_ATTEMPTS, MAX_NUMBERING_DEFINITIONS, MAX_STYLE_BASED_ON_DEPTH, MAX_STYLE_DEFINITIONS, MAX_TABLE_COLUMNS, MAX_TABLE_NESTING, MAX_TABLE_ROW_FRAGMENTS, MAX_TABLE_ROW_HEIGHT_PT, type MaterializationInput, type NoteDisplayMark, type NoteLayoutFallbackReason, type NoteMarkContext, type NotePaginationFallbackReason, type NoteReferenceSite, type NoteSeparatorLayout, type NoteSeparatorRuleStyle, type NoteStoryDrawings, type NoteStoryLayout, type NotesAttachResult, type NotesLayoutInput, type NumDefinition, type NumberingIndex, type NumberingLevel, type NumberingLevelIndent, type PageFurniture, PageGeometry, PageRecord, type PageRefIndex, ParagraphBorderEdge, ParagraphBorders, ParagraphFragmentRecord, type ParagraphKeyInputs, type ParagraphLayoutCache, type ParagraphLayoutCacheOptions, type ParagraphLayoutInputs, ParagraphLineSpacing, ParagraphSpacing, type PreferredWidth, type PreferredWidthType, type ResolvedListItem, ResolvedRunStyle, type ResolvedSurfaceMeasurer, ResolvedTabStops, RevisionDisplayMode, type ScriptItem, SectionColumns, SelectionRect, SemanticLayout, type SemanticLayoutOptions, SemanticPosition, SemanticSelection, type SemanticTableCell, type SemanticTableRow, type SemanticTableStructure, ShapedRun, type StyleCascadeTable, type StyleDefinition, StyleSpanRecord, type TableAlignment, TableBorderBox, TableBorderSide, type TableCellStyleFormatting, TablePaginationError, type TablePaginationErrorCode, type TableRowHeight, type TableRowHeightRule, TextDirection, TextMeasurer, TextShaper, UnsupportedScriptError, VersionedShapingLibrary, type ViewportWindow, WORD_SEGMENTER_LOCALE, type WordBoundary, type WordBoundaryResolverDeps, type WordSegment, attachNotesToLayout, boundedFallbackWordSegments, buildNumberingIndex, buildPageRefIndex, buildStyleCascadeTable, cascadeParagraphFormatting, cascadeRunProperties, cascadedBottomBorder, clampListValue, computeDoubleBorderMetricsPt, computeFootnoteReserves, contentControlBoundaries, createBoundedFallbackWordBoundary, createDefaultWordBoundary, createFixedMeasurer, createHarfBuzzTextShaper, createIntlWordBoundary, createLayoutScheduler, createLayoutSession, createListCounterState, createParagraphLayoutCache, defaultNoteSeparatorRuleStyle, deriveNoteDisplayMarks, deriveNoteDisplayMarksResolved, documentOrder, effectiveBorderSide, emptyTocPlaceholderParagraphIds, emptyTocSuppressedResultParagraphIds, expandLvlText, filterRefsOnPage, findSeparatorNote, formatDecimal, formatDecimalZero, formatLowerLetter, formatLowerRoman, formatNumFmt, formatPageNumber, formatUpperLetter, formatUpperRoman, fragmentOwnsAtomOffset, graphemeBoundaryEpoch, graphemeCount, graphemeOffsetToUtf16, harfBuzzFontValidator, initializeHarfBuzz, intlGraphemeBoundary, isCanvasMeasurementAvailable, isCumulativeGeometryTrustedFromLineOrigin, isGeometryTrustedCaretOffset, isHarfBuzzInitialized, isIntlSegmenterAvailable, isIntlWordSegmenterAvailable, isMarkerOnlySeparatorNote, isValidStyleId, isWholeGraphemeHorizontalBoundary, itemizeScriptFontSlots, keyedRangeRects, layoutHeaderFooterStory, layoutNoteById, layoutNoteSeparator, layoutNoteStory, layoutSemanticDocument, listMarkerBox, mergeListIndent, normalNotesOf, noteDisplayMarkMap, noteLineIdPrefix, noteMarkKey, noteSeparatorAreaBox, noteStoryBlocks, pagesToMaterialize, paragraphLayoutKey, paragraphMarkDeleted, paragraphShading, paragraphShadingBox, positionPastDeletion, projectedNoteMarkText, provisionalNoteMarks, readNumPr, readTableStructure, resetGraphemeBoundary, resolveDefaultSurfaceMeasurer, resolveDefaultWordBoundary, resolveNumberingLevel, resolveOoxmlShadingFill, resolveParagraphLayoutInputs, resolveStoryListItems, resolveStrictHexFill, revisionRemovesParagraph, roundFontUnitToFixedPoint, segmentGraphemes, segmentWords, selectionRects, semanticHorizontalBoundaries, setGraphemeBoundary, setHarfBuzzWasmUrl, shadingFillFromElement, shapedHorizontalBoundaries, storyBlocks, syntheticSeparatorBox, tableOriginX, tocFieldChromeParagraphIds, tryCreateCanvasMeasurer, utf16OffsetToGrapheme, walkStoryParagraphs, withNumberingStyleLinks, withResolvedListItems, wordBoundary, wordSegmentsToGraphemeRecords };
+export { AUTO_PREFERRED_WIDTH, type AbstractNumDefinition, type BidiEmbeddingLevels, BlockFragmentRecord, CELL_PAD, COMPOUND_BORDER_MIN_GAP_PT, COMPOUND_BORDER_MIN_STROKE_PT, type CanvasMeasurerOptions, type CanvasTextContext, type CanvasTextMetrics, type CascadedParagraphFormatting, CellBorderBox, type CellMarginsPt, type CellVerticalAlign, type CompoundBorderMetrics, ContentControlBoundaryRecord$1 as ContentControlBoundaryRecord, type ContentControlFragmentRecord, ContentControlLock, DEFAULT_CANVAS_FONT_STACK, DEFAULT_CELL_MARGINS, EMPTY_NUMBERING_INDEX, FieldLinkProjector, FixedPoint, FixedPointRoundingMode, FontByteValidator, type FontSlot, GRAPHEME_SEGMENTER_LOCALE, type GraphemeBoundary, type GraphemeSegment, type GraphemeWordSegmentRecord, HARFBUZZ_SHAPING_LIBRARY, type HarfBuzzFaceCacheEvent, type HarfBuzzOutlineCacheEvent, type HarfBuzzShapeCacheEvent, HarfBuzzShapingError, type HarfBuzzShapingErrorCode, type HarfBuzzTextShaper, type HarfBuzzTextShaperInstrumentation, type HarfBuzzTextShaperOptions, type HeaderFooterVariantName, HyperlinkProjector, type KeyedRange, LayoutBox, type LayoutCacheStats, type LayoutScheduler, type LayoutSchedulerOptions, type LayoutScope, type LayoutSession, type LayoutSessionStats, type LevelOverride, LineRecord, type ListCounterAdvance, type ListCounterState, type ListMarkerAlign, type ListSuffix, MAX_EACH_PAGE_MARK_CANDIDATES, MAX_LVL_OVERRIDES, MAX_LVL_TEXT_LENGTH, MAX_MARKER_TEXT_LENGTH, MAX_NOTES_LAID_OUT, MAX_NOTE_FRAGMENTS, MAX_NOTE_OVERFLOW_PAGES, MAX_NOTE_REFLOW_ATTEMPTS, MAX_NUMBERING_DEFINITIONS, MAX_STYLE_BASED_ON_DEPTH, MAX_STYLE_DEFINITIONS, MAX_TABLE_COLUMNS, MAX_TABLE_NESTING, MAX_TABLE_ROW_FRAGMENTS, MAX_TABLE_ROW_HEIGHT_PT, type MaterializationInput, type NoteDisplayMark, type NoteLayoutFallbackReason, type NoteMarkContext, type NotePaginationFallbackReason, type NoteReferenceSite, type NoteSeparatorLayout, type NoteSeparatorRuleStyle, type NoteStoryDrawings, type NoteStoryLayout, type NotesAttachResult, type NotesLayoutInput, type NumDefinition, type NumberingIndex, type NumberingLevel, type NumberingLevelIndent, type PageFurniture, PageGeometry, PageRecord, type PageRefIndex, ParagraphBorderEdge, ParagraphBorders, ParagraphFragmentRecord, type ParagraphKeyInputs, type ParagraphLayoutCache, type ParagraphLayoutCacheOptions, type ParagraphLayoutInputs, ParagraphLineSpacing, ParagraphSpacing, type PreferredWidth, type PreferredWidthType, type ResolvedListItem, ResolvedRunStyle, type ResolvedSurfaceMeasurer, ResolvedTabStops, ReviewItem, type ReviewParagraphAnchor, RevisionDisplayMode, type ScriptItem, SectionColumns, SelectionRect, SemanticLayout, type SemanticLayoutOptions, SemanticPosition, SemanticSelection, type SemanticTableCell, type SemanticTableRow, type SemanticTableStructure, ShapedRun, type StyleCascadeTable, type StyleDefinition, StyleSpanRecord, type TableAlignment, TableBorderBox, TableBorderSide, type TableCellStyleFormatting, TablePaginationError, type TablePaginationErrorCode, type TableRowHeight, type TableRowHeightRule, TextDirection, TextMeasurer, TextShaper, UnsupportedScriptError, VersionedShapingLibrary, type ViewportWindow, WORD_SEGMENTER_LOCALE, type WordBoundary, type WordBoundaryResolverDeps, type WordSegment, anchorLineY, attachNotesToLayout, boundedFallbackWordSegments, buildNumberingIndex, buildPageRefIndex, buildStyleCascadeTable, cascadeParagraphFormatting, cascadeRunProperties, cascadedBottomBorder, clampListValue, computeDoubleBorderMetricsPt, computeFootnoteReserves, contentControlBoundaries, contentControlHoldingParagraph, contentControlRecordsInPart, contentControlsOfLayout, createBoundedFallbackWordBoundary, createDefaultWordBoundary, createFixedMeasurer, createHarfBuzzTextShaper, createIntlWordBoundary, createLayoutScheduler, createLayoutSession, createListCounterState, createParagraphLayoutCache, defaultNoteSeparatorRuleStyle, deriveNoteDisplayMarks, deriveNoteDisplayMarksResolved, documentOrder, effectiveBorderSide, effectiveContentControlLock, emptyTocPlaceholderParagraphIds, emptyTocSuppressedResultParagraphIds, everyStoryOrder, expandLvlText, filterRefsOnPage, findSeparatorNote, formatDecimal, formatDecimalZero, formatLowerLetter, formatLowerRoman, formatNumFmt, formatPageNumber, formatUpperLetter, formatUpperRoman, fragmentOwnsAtomOffset, fragmentsOfParagraph, graphemeBoundaryEpoch, graphemeCount, graphemeOffsetToUtf16, harfBuzzFontValidator, initializeHarfBuzz, intlGraphemeBoundary, isCanvasMeasurementAvailable, isCumulativeGeometryTrustedFromLineOrigin, isGeometryTrustedCaretOffset, isHarfBuzzInitialized, isIntlSegmenterAvailable, isIntlWordSegmenterAvailable, isMarkerOnlySeparatorNote, isValidStyleId, isWholeGraphemeHorizontalBoundary, itemizeScriptFontSlots, keyedRangeRects, layoutHeaderFooterStory, layoutNoteById, layoutNoteSeparator, layoutNoteStory, layoutSemanticDocument, lineAtPosition, linesOf, listMarkerBox, mergeListIndent, normalNotesOf, noteDisplayMarkMap, noteLineIdPrefix, noteMarkKey, noteSeparatorAreaBox, noteStoryBlocks, pagesToMaterialize, paragraphFragmentsOf, paragraphFragmentsOfBlocks, paragraphLayoutKey, paragraphMarkDeleted, paragraphShading, paragraphShadingBox, positionPastDeletion, projectedNoteMarkText, provisionalNoteMarks, readNumPr, readTableStructure, resetGraphemeBoundary, resolveDefaultSurfaceMeasurer, resolveDefaultWordBoundary, resolveNumberingLevel, resolveOoxmlShadingFill, resolveParagraphLayoutInputs, resolveStoryListItems, resolveStrictHexFill, reviewAnchorIndex, reviewItemGeometry, revisionRemovesParagraph, roundFontUnitToFixedPoint, segmentGraphemes, segmentWords, selectionRects, semanticHorizontalBoundaries, setGraphemeBoundary, setHarfBuzzWasmUrl, sha256FontBytes, shadingFillFromElement, shapedHorizontalBoundaries, storyBlocks, syntheticSeparatorBox, tableOriginX, tocFieldChromeParagraphIds, tryCreateCanvasMeasurer, unionLayoutBoxes, utf16OffsetToGrapheme, walkStoryParagraphs, withNumberingStyleLinks, withResolvedListItems, wordBoundary, wordSegmentsToGraphemeRecords };