@arbidocs/blocks 0.4.101 → 0.4.102

package/node_modules/@docx-editor.dev/core/dist/layout.d.ts

@@ -0,0 +1,3151 @@
+/**
+ * `@docx-editor.dev/core/layout` — DOM-free pagination, shaping, and hit testing.
+ *
+ * Text is measured through an injected `TextMeasurer` and shaped through an injected
+ * `TextShaper`, so the same code paginates in a browser and on a server. Points everywhere;
+ * twips convert at property-read boundaries.
+ *
+ * Incremental by construction: per-block cache keys and flow checkpoints mean a pass that
+ * changes nothing returns the previous pages by identity.
+ *
+ * @packageDocumentation
+ * @public
+ */
+import { s as NumberingLevel, t as NumberingIndex, S as SemanticLayout, b as LayoutBox, D as DrawingPoint, u as DrawingInsets, e as StyleSpanRecord, I as InlineDrawingRecord, M as ModelRange, v as TableBorderSide, w as TableFloatXSpec, x as TableFloatYSpec, P as ParagraphFragmentRecord, B as BlockFragmentRecord, A as AnchoredDrawingRecord, a as PageRecord, y as ResolvedListItem, z as RefFieldContext, T as TextMeasurer, E as InlineDrawingLayoutContext, G as CellBorderBox, J as TableBorderBox, K as TableCellStyleFormatting, O as TableFloatPosition, Q as StyleCascadeTable, C as ContentControlBoundaryRecord$1, m as FixedPointRoundingMode, U as FixedPoint, V as VersionedShapingLibrary, j as TextShaper, W as FontByteValidator, r as ShapedRun, L as LineRecord, X as SourceRange, Y as HyperlinkProjector, Z as FieldLinkProjector, _ as StoryPageFieldNeeds, $ as HyperlinkFieldSpec, a0 as SpanLinkRecord, f as SectionPageBorders, a1 as PageBorderFrameRecord, a2 as ParagraphBorderStrokeRecord, a3 as StrikeoutStrokePt } from './semantic-records-4B3WwFAi.js';
+export { a4 as AUTO_PARAGRAPH_SPACING_PT, a5 as AbstractNumDefinition, a6 as AnchoredDrawingLayoutFallback, a7 as BidiEmbeddingLevels, a8 as BorderGridGeometry, a9 as CascadedParagraphFormatting, aa as CjkTypographySettings, ab as ContentControlGeometryFragment, ac as ContentControlLevel, d as ContentControlLock, ad as ContentControlMappedType, ae as DEFAULT_RUN_STYLE, af as DEFAULT_TAB_INTERVAL_PT, ag as DEFAULT_TAB_INTERVAL_TWIPS, ah as DeclaredFontSubstitution, ai as DrawingClipFallback, aj as DrawingGeometry, ak as DrawingGroupPictureRecord, al as EMPTY_NUMBERING_INDEX, am as EMPTY_TAB_STOPS, an as EquationFractionGeometry, ao as EquationGeometry, ap as EquationNaryGeometry, aq as EquationRadicalGeometry, ar as EquationRowGeometry, as as EquationScriptGeometry, at as EquationSpanRecord, au as EquationTextGeometry, av as FieldAtomMarker, aw as FontFingerprintInputs, n as FontRequest, ax as FontResolutionError, ay as FontResolutionErrorCode, az as FontResourceDefinition, aA as FontResourceInstrumentation, F as FontResourceSnapshot, aB as FontResourceSnapshotOptions, aC as FontSlot, q as FontSubstitution, aD as FontValidationResult, aE as GlyphOutline, aF as GroupTextboxStoryRecord, aG as HARD_MAX_AGGREGATE_FONT_BYTES, aH as HARD_MAX_FONT_BYTES, aI as HARD_MAX_FONT_SOURCES, H as HeaderFooterStoryRecord, aJ as LevelOverride, aK as LineSpacingRule, aL as ListMarkerAlign, p as ListMarkerPictureRecord, aM as ListMarkerRecord, aN as ListSuffix, aO as MAX_BORDER_SPACE_PT, aP as MAX_BORDER_WIDTH_PT, aQ as MAX_LVL_OVERRIDES, aR as MAX_NUMBERING_DEFINITIONS, aS as MAX_PARAGRAPH_SPACING_PT, aT as MAX_SHAPING_CONTEXT, aU as MAX_STYLE_DEFINITIONS, aV as MAX_TABLE_BORDER_STROKES, aW as MAX_TAB_POSITION_TWIPS, aX as MAX_TAB_STOPS, l as NormalizationPolicy, N as NoteAreaRecord, c as NoteStoryRecord, aY as NumDefinition, aZ as NumberingLevelIndent, a_ as NumberingPictureBullet, a$ as PAGE_BORDER_SIDES, b0 as PARAGRAPH_BORDER_SIDES, b1 as PageBorderDisplay, b2 as PageBorderOffsetFrom, b3 as PageBorderSide, b4 as PageBorderStrokeRecord, b5 as PageBorderZOrder, b6 as PageRefCalibrationCell, b7 as PageRefFieldProjection, b8 as ParagraphAutoSpacingContext, b9 as ParagraphBorderEdge, ba as ParagraphBorderSide, bb as ParagraphBorders, bc as ParagraphBottomBorderRecord, bd as ParagraphIndent, be as ParagraphLayoutInputs, bf as ParagraphLineSpacing, bg as ParagraphSpacing, bh as RefFieldSpec, bi as RefNoteParts, bj as ResolvedCellBorders, k as ResolvedFont, bk as ResolvedPictureBullet, R as ResolvedRunStyle, bl as ResolvedTabStops, bm as ResolvedTableBorderEdge, bn as ResolvedTableBorderEdgeSegment, bo as ResolvedUnderline, bp as SINGLE_LINE_SPACING, bq as ScriptItem, br as SemanticArtifactRootStoryKind, bs as SemanticArtifactStoryKind, bt as SemanticCommentArtifactRecord, bu as SemanticReviewArtifactOccurrence, bv as SemanticReviewArtifactOccurrenceGeometry, bw as SemanticReviewArtifactPosition, o as SemanticReviewArtifactRecord, bx as SemanticReviewArtifactSource, by as SemanticTrackedChangeArtifactRecord, bz as ShapeInput, bA as ShapedCluster, bB as ShapedFontSpan, bC as ShapedGlyph, bD as ShapedRunComparatorInputs, bE as ShapedVerticalMetrics, bF as ShapingContext, bG as ShapingEnvironment, bH as ShapingEnvironmentFingerprintInputs, i as ShapingEnvironmentInput, bI as StyleDefinition, bJ as TAB_LEADER_GLYPH, bK as TabAlignment, bL as TabDestination, bM as TabLeader, bN as TabStop, bO as TableBorderSideName, bP as TableBorderStrokeRecord, h as TableCellFragmentRecord, bQ as TableFragmentRecord, g as TableRowFragmentRecord, bR as TextDirection, bS as TextboxStoryFallbackReason, bT as TextboxStoryLayout, bU as UnsupportedScriptError, bV as VerticalAlign, bW as appliedSpaceBefore, bX as applyLineSpacing, bY as baselineShiftPtOf, bZ as borderExtentPt, b_ as borderWeight, b$ as bottomBorderExtentPt, c0 as boundedStructuralFontValidator, c1 as buildNumberingIndex, c2 as buildStyleCascadeTable, c3 as cascadeParagraphFormatting, c4 as cascadeRunProperties, c5 as cascadedBottomBorder, c6 as cascadedParagraphBorders, c7 as cascadedTabStops, c8 as collapsedSpaceBefore, c9 as createFontResourceSnapshot, ca as createShapedRun, cb as createShapingEnvironment, cc as defaultTabIntervalFromSettings, cd as displayText, ce as fixedPoint, cf as fontRequestKey, cg as glyphSizeFactorOf, ch as isValidStyleId, ci as itemizeScriptFontSlots, cj as layoutEquation, ck as measureDisplayText, cl as mergeListIndent, cm as nextTabDestination, cn as pageBordersFingerprint, co as paragraphBorderExtentPt, cp as paragraphBorderStrokeWidthPt, cq as paragraphBorders, cr as paragraphBordersFingerprint, cs as paragraphBreaksBefore, ct as paragraphContextualSpacing, cu as paragraphLineSpacing, cv as paragraphSpacing, cw as paragraphTabStops, cx as parsePageBorders, cy as parseRefInstruction, cz as readBorderSide, cA as readCellBorders, cB as readNumPr, cC as readTableBorders, cD as resolveBorderConflict, cE as resolveNumberingLevel, cF as resolveParagraphLayoutInputs, cG as resolveRunStyle, cH as resolveStoryListItems, cI as resolveStoryRefFields, cJ as resolveTableCellBorderGrid, cK as runStylesEqual, cL as shapedRunComparatorInputs, cM as shapingEnvironmentFingerprint, cN as shapingEnvironmentFingerprintInputs, cO as styleForFontSlot, cP as tabAdvanceWidth, cQ as tabStopsFingerprint, cR as withDefaultTabInterval, cS as withNumberingStyleLinks, cT as withResolvedListItems } from './semantic-records-4B3WwFAi.js';
+export { C as CacheLookup, b as CacheMiss, c as CacheProvenance, e as LayoutEnvironmentShapedMeasurerOptions, f as LayoutFontConfiguration, g as LayoutFontSource, h as LayoutFontSubstitution, i as LayoutShapingConfigurationError, j as LayoutShapingEnvironment, L as LayoutShapingInstrumentation, a as LayoutShapingOptions, O as OperationSnapshot, k as OperationSnapshotField, l as OperationSnapshotGuard, P as PreparedLayoutFontConfiguration, R as ResolvedCache, m as ResourceDependencyProvenance, S as ShapedMeasurerOptions, n as captureOperationSnapshot, o as createLayoutShapedMeasurer, p as createLayoutShaping, q as createShapedMeasurer, d as disposeLayoutShaping, r as guardOperationSnapshot, s as layoutFontConfigurationFingerprint, t as prepareLayoutFontConfiguration } from './layout-shaping-BEyuiQOk.js';
+import { a as SemanticStoryKind, S as SemanticRootStoryKind, b as SemanticStoryVisit, T as TextboxOwnerRecord } from './semantic-record-queries-CBlZqZNa.js';
+export { c as SemanticDrawingLayer, d as SemanticDrawingVisit, e as StoryDrawingContext, f as StoryDrawingHost, g as StoryParagraphFragmentContext, h as contentControlsOfLayout, i as effectiveContentControlLock, j as forEachSemanticDrawing, k as forEachSemanticStory, l as forEachStoryParagraphFragment, m as fragmentsOfParagraph, n as lineAtPosition, o as linesOf, p as paragraphFragmentsOf, q as paragraphFragmentsOfBlocks, u as unionLayoutBoxes } from './semantic-record-queries-CBlZqZNa.js';
+import { ak as ImpactClass, N as OoxmlNode, X as OoxmlProperty, Z as OoxmlElement, O as OoxmlPart, W as TreeDocOp, Q as OoxmlPackage, b9 as ContentControlKind, ba as ContentControlLevel, bc as ContentControlLock, b6 as ContentControlDataBinding, a as ReviewItem } from './types-barrel-D3xCgQX6.js';
+export { b1 as CommentAnchor, b2 as CommentPosition, C as CommentRecord, aY as CommentThreadState, aK as DrawingAccessibility, aw as DrawingHorizontalReferenceFrame, aL as DrawingImageEffects, aM as DrawingTransform, ax as DrawingVerticalReferenceFrame, an as ImageWrapTarget, c as ReviewCommentItem, d as ReviewCustomItem, R as ReviewModelInput, e as ReviewPosition, f as ReviewRange, b as ReviewRevisionItem, g as ReviewRevisionKind, al as SourceCrop, aJ as TableBorderStyle, dB as VectorShapeComponent, aN as VectorShapeProjection, cs as W15_NAMESPACE_URI, dC as activeReviewItem, cW as firstReviewRange, ds as reviewItemKey, dD as reviewItemPositionRank, dt as reviewItemRanges, dE as reviewItemsAt, dF as reviewThreadRootOf } from './types-barrel-D3xCgQX6.js';
+import { D as DocumentProperties, H as HeadlessDocumentView, r as relationshipTargetIn } from './headless-document-view-qH331moE.js';
+import { o as RevisionAttribution, b as RevisionDisplayMode, c as RevisionAuthorFilter } from './revision-projection-DZ4kKVev.js';
+export { p as DEFAULT_REVISION_DISPLAY_MODE, q as RevisionFilter, s as RevisionKind, t as formatRevisionOf, u as markRevisionRemovesMark, v as paragraphMarkFormatRevisionOf, w as paragraphMarkRevisionOf, x as paragraphMarkRevisionsOf, y as revisionAuthorFilter, z as revisionsAreDeletion, A as revisionsVisible, B as shownMarkRevision } from './revision-projection-DZ4kKVev.js';
+import { b as ResolvedFootnoteProperties, R as ResolvedEndnoteProperties } from './note-properties-4Y9o6Gyk.js';
+import { e as TreeModelChange, N as NoteKind, aA as noteTypeOf, k as FieldResultsMode } from './tree-package-fragment-BeeKxDw8.js';
+import { P as PageGeometry, a as SectionColumns } from './semantic-cell-selection-D9D1KSXq.js';
+export { C as CellSelection, D as DEFAULT_PAGE_GEOMETRY, b as DEFAULT_SECTION_PROPERTIES, c as DEFAULT_VERTICAL_WEIGHT, d as DocumentSection, e as DocumentSectionsEnumeration, f as DrawingOverlayFrame, H as HitPoint, g as HitTestOptions, M as MAX_DOCUMENT_SECTIONS, h as PlacedCell, i as SectionBreakType, j as SectionColumnDefinition, k as SectionMargins, l as SectionPageNumbering, S as SectionProperties, m as SemanticHit, n as SemanticHitDrawing, T as TableCellAddress, o as TableCellContext, p as caretBoxOnLine, q as cellSelectionBetween, r as cellSelectionRects, s as cellSelectionText, t as contentControlAtPoint, u as enumerateDocumentSections, v as enumerateDocumentSectionsBounded, w as findDrawingOverlayFrameInLayout, x as geometryOfSection, y as hitTestPage, z as hitTestSheet, A as isFurniturePoint, B as lineEndOffset, E as pageAtY, F as paragraphSectionNode, G as paragraphsInCells, I as parsePageNumbering, J as parseSectionProperties, K as projectedSectionSourceIndexes, L as readSectionProperties, N as spanOffsetX, O as spansInCells, Q as tableContextAt } from './semantic-cell-selection-D9D1KSXq.js';
+export { M as MAX_SDT_NESTING, c as collectFlowBlocks, a as commentBodyText, b as commentInitials, j as contentControlContentChildren, i as isContentControl, f as isContentControlContent, p as paragraphOrderOfPart } from './review-paragraph-order-DT-n6ouC.js';
+import { S as SemanticPosition, b as SelectionRect, a as SemanticSelection, C as CaretGeometry } from './semantic-interaction-CIC-PooQ.js';
+export { c as CaretAtOptions, M as MoveCaretOptions, N as NavigationCommand, d as caretAt, e as caretStops, f as caretStopsForBlocks, g as compositionAnchor, h as contentControlsInLayout, i as deletedTextBoundaries, m as moveCaret, p as paragraphTextFromLayout, s as spansInSelection } from './semantic-interaction-CIC-PooQ.js';
+import './image-resources-BN-hUgCn.js';
+import './omml-equation-CuzBL5DD.js';
+import './editor-scope-OHPwVQ5l.js';
+
+/**
+ * The result of counting ONE list paragraph: the level that applied, the counter vector after it,
+ * and the marker text a reader sees.
+ *
+ * Counters are a vector across all nine levels, not a single number, because a deeper level
+ * restarting resets the ones below it while leaving those above intact.
+ */
+interface ListCounterAdvance {
+    /** Effective abstract numbering template for this num instance. */
+    readonly abstractNumId: string;
+    readonly numId: string;
+    readonly ilvl: number;
+    readonly level: NumberingLevel;
+    /** Counter vector after this item was counted (indices 0..8). */
+    readonly counters: readonly number[];
+    /** Expanded marker text (empty when vanished / empty lvlText). */
+    readonly markerText: string;
+}
+/**
+ * The running counters for one layout pass over one story.
+ *
+ * Stateful and order-dependent by nature: a list number is a function of every numbered paragraph
+ * before it, which is why markers are computed during layout and cannot be read off a paragraph
+ * in isolation.
+ */
+interface ListCounterState {
+    /**
+     * Advance counters for one list paragraph.
+     *
+     * Returns null when the numbering definition cannot be resolved — callers treat the
+     * paragraph as non-list (inert fallback).
+     */
+    advance(numId: string, ilvl: number): ListCounterAdvance | null;
+}
+/**
+ * Create a fresh counter bag for one story (body, or one header/footer part).
+ */
+declare function createListCounterState(index: NumberingIndex): ListCounterState;
+
+/** Synchronous platform-neutral SHA-256 used before font bytes cross into a shaping implementation. */
+declare const sha256FontBytes: (bytes: Uint8Array) => string;
+
+/**
+ * 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;
+
+interface PositionedTableAnchorSignal {
+    readonly anchorId: string;
+    readonly column: number;
+    readonly fragmentIndex: number;
+    readonly anchorY: number;
+}
+interface PendingPositionedTableTokens {
+    readonly token: string;
+    readonly previous: PendingPositionedTableTokens | undefined;
+    readonly length: number;
+    readonly signature: string;
+}
+
+/**
+ * What the BODY flow knows about page numbering while it MEASURES a page-field placeholder.
+ *
+ * The section's `w:pgNumType/@w:fmt` binds a PAGE field with no `\#` picture and no `\*`
+ * number format. A field that states either renders through it on every section.
+ */
+interface BodyPageFieldContext {
+    /** The section's `w:pgNumType/@w:fmt`; absent when the section authors none. */
+    readonly format?: string;
+}
+/**
+ * Page-field evaluation context for furniture projection.
+ *
+ * `pageNumber` is the displayed PAGE value after section `w:pgNumType/@w:start` (1-based).
+ * `pageCount` is document NUMPAGES. `sectionPageCount` is SECTIONPAGES for the attached
+ * section. `format` is the authored `w:pgNumType/@w:fmt` applied only to PAGE. `sheetNumber` is
+ * the 1-based physical sheet, which a restart does not renumber: it decides which margin an
+ * `inside` or `outside` header frame takes.
+ *
+ * A new field here must also join `sameFieldPageContext` below, or finalize compares two
+ * contexts that differ in it as equal and keeps a reused story's stale text.
+ */
+interface FieldPageContext {
+    /** Local character-style results for one physical page. @internal */
+    readonly characterStyleValues?: ReadonlyMap<string, string>;
+    readonly pageNumber: number;
+    readonly pageCount: number;
+    /** SECTIONPAGES; defaults to `pageCount` when omitted (single-section callers). */
+    readonly sectionPageCount?: number;
+    /** Authored ST_NumberFormat for PAGE; absent → decimal. */
+    readonly format?: string;
+    /** 1-based physical sheet; absent → `pageNumber` (single-section callers). */
+    readonly sheetNumber?: number;
+}
+/**
+ * Format a displayed PAGE value through the shared ST_NumberFormat resolver.
+ *
+ * Unknown / script-specific formats fall back to decimal (same convention as list markers).
+ * `none` / `bullet` are meaningless for page numbers and also fall back to decimal so a
+ * hostile fmt cannot blank the furniture.
+ */
+declare function formatPageNumber(value: number, format: string | undefined): string;
+
+type WrapTextSide = 'bothSides' | 'left' | 'right' | 'largest';
+interface WrapExclusionInput {
+    readonly mode: 'square' | 'tight' | 'through' | 'topAndBottom';
+    readonly contentBounds: LayoutBox;
+    readonly polygon: readonly DrawingPoint[] | null;
+    readonly clipPolygon: readonly DrawingPoint[] | null;
+    readonly wrapDistances: DrawingInsets;
+    readonly effectInsets: DrawingInsets;
+    readonly textSide: WrapTextSide;
+    readonly contentLeft: number;
+    readonly contentRight: number;
+}
+
+/** Paint layer relative to body text — not the OOXML wrap element. */
+type DrawingPaintLayer = 'behind' | 'inFront';
+/** The header or footer object a furniture exclusion zone comes from. */
+interface FurnitureZoneSource {
+    readonly partName: string;
+    readonly kind: 'drawing' | 'table';
+    readonly nodeId: string;
+}
+interface ExclusionZone {
+    /** Objects outside body drawing flow publish their exclusion directly instead of synthesizing it. */
+    readonly sourceKind?: 'table' | 'frame' | 'furniture';
+    /**
+     * Placed by an earlier section on the sheet a `continuous` section continues on. Its anchor
+     * is not in the continued section, so the zone reaches every line and column there.
+     */
+    readonly earlierSection?: boolean;
+    /**
+     * The header or footer object a `furniture` zone comes from. Node ids are unique only within
+     * one part, so a furniture zone is identified by its part, its kind, and its node together
+     * (see {@link exclusionZoneIdentity}), never by a composed id string.
+     */
+    readonly furnitureSource?: FurnitureZoneSource;
+    readonly drawingNodeId: string;
+    readonly anchorParagraphId: string;
+    /** UTF-16 model offset of the anchor atom — exclusions apply at/after this point in the paragraph. */
+    readonly anchorModelStart: number;
+    /**
+     * The band's vertical position is resolved against the page or a margin, not against the
+     * anchor's own flow position, so it cannot move when the text beside it reflows.
+     *
+     * Such a band excludes every line it crosses on its page, including lines that PRECEDE the
+     * anchor — a picture pinned to the top of the margin wraps the paragraphs above its anchor
+     * exactly as it wraps the ones below. Flow-relative bands (`paragraph`, `line`) stay
+     * forward-only: reaching back would move the anchor that positions them.
+     */
+    readonly pageFramedBand?: boolean;
+    readonly sourceOrder: number;
+    readonly paintLayer: DrawingPaintLayer;
+    readonly relativeHeight: number;
+    readonly allowOverlap: boolean;
+    /** Owning column index in a multi-column section — 0 for single-column and HF stories. */
+    readonly columnIndex: number;
+    /** Resolved top edge in page-content coordinates after overlap displacement. */
+    readonly y: number;
+    readonly verticalBand: LayoutBox;
+    readonly input: WrapExclusionInput;
+}
+
+type AutonumFieldKind = 'AUTONUM' | 'AUTONUMLGL' | 'AUTONUMOUT';
+/** One recognized AUTONUM-family instruction: the kind and its supported switches. */
+interface AutonumFieldSpec {
+    readonly kind: AutonumFieldKind;
+    /** ST_NumberFormat resolved from the `\*` switch; null paints decimal. */
+    readonly numFmt: string | null;
+    /** `\e`: display the number without its trailing period. */
+    readonly suppressPeriod: boolean;
+}
+/**
+ * Recognize `AUTONUM | AUTONUMLGL | AUTONUMOUT [\* <format>] [\e] [\* MERGEFORMAT]`, or null
+ * for anything else. Any unrecognized switch fails the parse so the field stays inert (paints
+ * nothing — its historical rendering), never the raw instruction, never a guessed number.
+ */
+declare function parseAutonumInstruction(raw: string): AutonumFieldSpec | null;
+
+/**
+ * Lookup of derived display marks keyed by {@link formatNoteScopeId}.
+ *
+ * `null` mark = customMarkFollows (no automatic digits). Absent key = dangling / unknown
+ * — fail-open with an empty display (model atom preserved).
+ */
+interface NoteMarkContext {
+    /**
+     * scopeId → formatted mark (or null when suppressed).
+     *
+     * IMMUTABLE once the context is built. `noteMarksCacheToken` memoizes on the context object
+     * and that token reaches every paragraph's cache key, so a later `marks.set` would pin the
+     * whole document to a token for marks it no longer has.
+     */
+    readonly marks: ReadonlyMap<string, string | null>;
+    /**
+     * When set, every automatic mark measures at least this string's width (eachPage
+     * reservation). The string is the widest-measuring candidate under the effective mark
+     * style (actual marks plus a bounded per-section value window) — not merely the longest
+     * by codepoint count. Display text may still be the real mark; measurement uses the wider
+     * of the two so digit-width / proportional-glyph feedback cannot oscillate.
+     */
+    readonly reservedMarkText?: string;
+    /**
+     * Scope id of the note story currently being laid out (`footnote:N` / `endnote:N`).
+     *
+     * Body `noteReference` atoms carry `@w:id`; note-body `noteRef` atoms do not — they
+     * inherit identity from the enclosing note via this key.
+     */
+    readonly activeNoteKey?: string;
+    /** Project separator markers as inline rules inside their authored stories. */
+    readonly measureSeparatorMarkers?: true;
+}
+/**
+ * The key one note's mark is stored under — `footnote:N` / `endnote:N`.
+ *
+ * The same encoding `EditorScope` uses for note ids, so a mark context and a scope address name
+ * the same note without a translation step.
+ */
+declare function noteMarkKey(noteKind: NoteKind, noteId: number): string;
+/**
+ * Navigation role for a projected note atom:
+ * - `to-note` — body `noteReference` jumps into the note story
+ * - `to-body` — note-body `noteRef` jumps back to the body citation
+ */
+type NoteNavDirection = 'to-note' | 'to-body';
+interface ProjectedNoteMark {
+    readonly noteSeparator?: 'separator' | 'continuationSeparator';
+    readonly text: string;
+    readonly measureText?: string;
+    readonly projected: boolean;
+    readonly kind: NoteKind | null;
+    readonly noteId: number | null;
+    readonly nav?: NoteNavDirection;
+    readonly scopeId?: string;
+}
+/** Resolve display text for a noteReference / noteRef node under a mark context. */
+declare function projectedNoteMarkText(node: OoxmlNode, context: NoteMarkContext | undefined): ProjectedNoteMark | null;
+
+/** A fingerprint over one paragraph's layout inputs. */
+type ParagraphLayoutKey = string;
+/** Cache counters, for asserting that incremental layout is actually reusing work. */
+interface LayoutCacheStats {
+    readonly hits: number;
+    readonly misses: number;
+    readonly evictions: number;
+    readonly size: number;
+}
+/**
+ * The per-paragraph measurement cache.
+ *
+ * Caches the BREAK only — where a paragraph's lines fall at a given width — never its placement.
+ * An edit high in a document still repaginates everything below it, while paragraphs nobody
+ * touched are never measured again.
+ */
+interface ParagraphLayoutCache<T> {
+    /**
+     * Whether values released after placement remain available to later layout passes.
+     *
+     * One-shot exporters set this false so producers may avoid defensive snapshots whose
+     * only purpose is protecting a value reused by a future pass.
+     */
+    readonly retainAcrossPasses?: boolean;
+    /**
+     * Derive a break key inside this cache's ownership scope.
+     *
+     * Export caches use this hook to release construction-only subtree fingerprints together
+     * with measured breaks. Optional so structural/custom cache implementations remain valid.
+     */
+    keyFor?(inputs: ParagraphKeyInputs): ParagraphLayoutKey;
+    get(key: ParagraphLayoutKey): T | undefined;
+    set(key: ParagraphLayoutKey, value: T): void;
+    /** Release a break after final placement when this cache was created for a one-shot pass. */
+    release?(key: ParagraphLayoutKey): void;
+    /** Drop entries for paragraphs a commit removed, so the cache cannot grow without bound. */
+    retain(keys: ReadonlySet<ParagraphLayoutKey>): void;
+    /**
+     * Whether THIS published pass should pay for a document-wide {@link retain} sweep.
+     *
+     * Retention only trims memory — the aging window tolerates deferral — while building the
+     * union of live keys costs real time on a large document, so callers ask per pass and
+     * sweep on a stride. Per cache instance, so one editor's cadence cannot starve another's.
+     * Optional for compatibility: a cache without it is retained on every pass.
+     */
+    retentionPassDue?(): boolean;
+    clear(): void;
+    readonly stats: LayoutCacheStats;
+}
+/**
+ * Everything that decides whether a cached paragraph break is still valid.
+ *
+ * `producer` is in the key because a font arriving after first paint changes every advance in the
+ * document while no content changes — without it the cache would serve the pre-font layout
+ * forever.
+ */
+interface ParagraphKeyInputs {
+    readonly paragraph: OoxmlNode;
+    readonly properties: readonly OoxmlProperty[];
+    /** Available width, which decides where the lines break. */
+    readonly width: number;
+    /**
+     * Who produced the measurements.
+     *
+     * Fonts loading after first paint change every advance while no content changes, so a
+     * cache keyed on content alone would serve the pre-font layout forever.
+     */
+    readonly producer: string;
+    /**
+     * Inline drawing projection/resource epoch for this paragraph.
+     *
+     * Pending→ready/refused transitions and extent/hidden changes must invalidate breaks even
+     * when paragraph text is unchanged.
+     */
+    readonly drawingToken?: string;
+    /** Paragraph-local semantic projection identity (links and live metadata fields). */
+    readonly projectionToken?: string;
+    /** Active page exclusion zones affecting this paragraph's break. */
+    readonly exclusionToken?: string;
+}
+/**
+ * The cache key for one paragraph's measured break.
+ *
+ * Folds in the content, the available width, and the measurement producer. Anything that changes
+ * where lines fall must be in here, or the cache serves a break taken under different conditions.
+ */
+declare function paragraphLayoutKey(inputs: ParagraphKeyInputs): ParagraphLayoutKey;
+/** How large the paragraph cache grows before least-recently-used eviction. */
+interface ParagraphLayoutCacheOptions {
+    /**
+     * Entries retained before the least recently used are dropped.
+     *
+     * The default has to exceed a realistic document, or a full pass evicts exactly what the
+     * next one needs and the cache costs more than it saves. Unset, an estimated byte budget
+     * bounds the cache instead, because one cached break can be a hundred times another.
+     */
+    readonly maxEntries?: number;
+    /** Keep placed breaks for later revisions. Default true; false bounds one-shot exporters. */
+    readonly retainAcrossPasses?: boolean;
+}
+
+/**
+ * A bounded least-recently-used cache with generation-scoped retention.
+ *
+ * Bounded because a long editing session touches far more paragraph states than a document
+ * contains — every keystroke mints a new key for the paragraph being typed in — and an
+ * unbounded cache would hold every intermediate state of the session.
+ *
+ * The bound never evicts the CURRENT working set: entries named by this generation's
+ * retain or touched since it began are skipped, and the cache grows past its soft budget
+ * when a document is larger than it — evicting live entries made every full pass on a
+ * 500-page document re-measure the whole document.
+ */
+declare function createParagraphLayoutCache<T>(options?: ParagraphLayoutCacheOptions): ParagraphLayoutCache<T>;
+
+interface TocLinkRange {
+    readonly start: number;
+    readonly end: number;
+}
+type TocLinkRanges = ReadonlyMap<string, readonly TocLinkRange[]>;
+
+interface FieldCodeRange {
+    readonly start: number;
+    readonly end: number;
+    readonly code?: string;
+    readonly sourceNodeId?: string;
+    readonly suppressParagraph: boolean;
+}
+type FieldCodeRanges = ReadonlyMap<string, readonly FieldCodeRange[]>;
+
+interface PendingLine {
+    readonly spans: StyleSpanRecord[];
+    readonly drawings: InlineDrawingRecord[];
+    readonly start: number;
+    end: number;
+    width: number;
+    height: number;
+    baseline: number;
+    /**
+     * Space ABOVE the glyph band inside {@link height}.
+     *
+     * Exact spacing can center the glyphs and move the baseline. Auto/atLeast spacing leaves
+     * this at zero and puts its extra depth below instead.
+     */
+    leading: number;
+    /**
+     * Auto/atLeast line-spacing depth below the painted glyph band.
+     *
+     * Word lets this external depth cross the bottom text margin when the glyphs themselves
+     * still fit. Pagination therefore budgets {@link height} minus this amount at a page
+     * bottom, while paint keeps the full box and padding.
+     */
+    trailingSpacing: number;
+    /** When true, layout must start a new page after this line is placed. */
+    pageBreakAfter?: boolean;
+    /** When true, layout must advance to the next authored section column. */
+    columnBreakAfter?: boolean;
+    /** An authored line break (`w:br` textWrapping or `w:cr`), never an automatic wrap. */
+    manualBreakAfter?: true;
+    /**
+     * The flow kept the paragraph's last word on this line by borrowing inter-word space.
+     * Alignment compresses a paragraph's last line only when this is set, never for another
+     * overflow such as hanging punctuation.
+     */
+    spaceShrink?: true;
+    /** Model ranges on this line covering deleted content; see {@link LineRecord.deletedRanges}. */
+    deletedRanges?: readonly ModelRange[];
+    /** Vertical gap inserted before this line to clear a drawing exclusion band. */
+    exclusionSkipBefore?: number;
+    /**
+     * The line follows a text wrapping break that clears floating objects (`w:br w:clear`).
+     * Placement keeps its skip even on a line before the paragraph's first anchor.
+     */
+    breakClearance?: true;
+    /** Clearance inherited by an empty anchor paragraph from other drawing bands. */
+    anchorClearanceBefore?: number;
+    /**
+     * The first-line offset this line was broken with: the paragraph's first line, and the
+     * first line after page breaks that open it ({@link holdsOnlyPageBreak}). Absent when zero.
+     */
+    firstLineOffset?: number;
+    /**
+     * The horizontal passage a float left this line, when that passage is narrower than the
+     * paragraph's measure and holds the whole line.
+     *
+     * `start` is where the line's content begins (after any first-line indent) and `end` is the
+     * passage's right edge, both in paragraph-local coordinates. Centring, right alignment and
+     * justification align INSIDE this passage: Word centres a heading between the two pictures
+     * beside it, not between the page margins, and stretches a justified line to the float's
+     * near edge rather than through it. Absent when no float shortens the line, when the line
+     * steps over a float into a later passage, or when the passage is the whole measure.
+     */
+    wrapSegment?: {
+        readonly start: number;
+        readonly end: number;
+    };
+    /** Tracked anchored-drawing attributions on this line; see {@link LineRecord.anchorRevisions}. */
+    anchorRevisions?: readonly RevisionAttribution[];
+    /** Revisions a resolved view answered on this line; see {@link LineRecord.changeSites}. */
+    changeSites?: readonly RevisionAttribution[];
+}
+
+/**
+ * What one cell side is before any ADJACENT cell has its say.
+ *
+ * - omitted → the table's own rule for that position (`tblBorders`, `insideH`/`insideV`)
+ * - edge → the cell wins outright; no weight fight with the table
+ * - none → an explicit `w:val="nil"`. Suppresses a matching table border on interior
+ *   and perimeter sides alike, so a table whose cells all declare none paints borderless
+ *   like Word even when `tblBorders` still carry `single` rules.
+ */
+declare function effectiveBorderSide(authored: TableBorderSide, tableSide: TableBorderSide, _options?: {
+    readonly interior?: boolean;
+}): TableBorderSide;
+
+/** Minimum stroke width for a compound (double/triple) band, in points. */
+declare const COMPOUND_BORDER_MIN_STROKE_PT = 0.25;
+/** Minimum gap between compound strokes, in points. */
+declare const COMPOUND_BORDER_MIN_GAP_PT = 0.25;
+/**
+ * How a multi-line border style (double, triple) is drawn: stroke width, gap, and total extent.
+ *
+ * Table stroke coordinates centre the painted band on the authored edge box.
+ * Content insets must also account for the portion that extends inward.
+ */
+interface CompoundBorderMetrics {
+    readonly strokePt: number;
+    readonly gapPt: number;
+    readonly extentPt: number;
+    /** Centers the compound band on the authored width; negative extends outward. */
+    readonly insetPt: number;
+}
+/**
+ * Double strokes use the authored width, with a quarter-point minimum.
+ * The complete band is centred on the authored edge box. Device pixel rounding
+ * belongs to rendering; these layout metrics remain in continuous points.
+ */
+declare function computeDoubleBorderMetricsPt(widthPt: number): CompoundBorderMetrics;
+
+/** Soft ceiling on fragments emitted for one authored row (hostile / runaway splits). */
+declare const MAX_TABLE_ROW_FRAGMENTS = 4096;
+/**
+ * Why a table could not be paginated as authored.
+ *
+ * Each is a bound: a row taller than a page, a row that cannot be split, or a row producing more
+ * fragments than the limit allows.
+ */
+type TablePaginationErrorCode = 'table-row-overheight' | 'table-row-split-unsupported' | 'table-row-fragment-limit';
+/**
+ * Bounded table pagination failure. Prefer this over emitting a fragment that overflows
+ * the page content box.
+ */
+declare class TablePaginationError extends Error {
+    readonly code: TablePaginationErrorCode;
+    constructor(code: TablePaginationErrorCode, message: string);
+}
+
+type ParagraphFrameHeightRule = 'auto' | 'atLeast' | 'exact';
+type ParagraphFrameWrap = 'auto' | 'around' | 'tight' | 'through' | 'none' | 'notBeside';
+/** Bounded text-frame properties resolved for semantic layout. */
+interface ParagraphFrame {
+    /** Explicit-size drop cap aligned against this many lines of its anchor paragraph. */
+    readonly dropCapLines?: number;
+    readonly dropCap?: 'drop' | 'margin';
+    readonly dropCapRtl?: boolean;
+    readonly x: number;
+    readonly y: number;
+    /** Zero until the containing text width resolves an omitted `w:w`. */
+    readonly width: number;
+    readonly autoWidth: boolean;
+    /** Authored exact or minimum height. Absent for `hRule="auto"`. */
+    readonly height?: number;
+    readonly heightRule: ParagraphFrameHeightRule;
+    readonly horizontalAnchor: 'page' | 'margin' | 'text';
+    readonly verticalAnchor: 'page' | 'margin' | 'text';
+    readonly xAlign?: TableFloatXSpec;
+    readonly yAlign?: TableFloatYSpec;
+    readonly anchorLocked: boolean;
+    /** Equal authored frame properties group adjacent paragraphs into one frame. */
+    readonly token: string;
+    readonly wrap: ParagraphFrameWrap;
+    readonly hSpace: number;
+    readonly vSpace: number;
+}
+
+interface PendingParagraphFrame {
+    readonly frame: ParagraphFrame;
+    readonly fragment: ParagraphFragmentRecord;
+    readonly groupId: string;
+    readonly sourceOrder: number;
+}
+/** Immutable prefix shared by every checkpoint; one node per pending paragraph. */
+interface PendingParagraphFrames {
+    readonly item: PendingParagraphFrame;
+    readonly previous: PendingParagraphFrames | undefined;
+    readonly length: number;
+    readonly signature: string;
+}
+
+/** 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[];
+    /** Local frame paragraphs waiting for their next regular paragraph anchor. */
+    readonly pendingParagraphFrames?: PendingParagraphFrames;
+    /**
+     * 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>;
+    /** Sheet-positioned tables and zero-line anchors still owed by the open page. */
+    readonly pendingPositionedTableTokens?: PendingPositionedTableTokens;
+    readonly positionedTableAnchorSignals?: readonly PositionedTableAnchorSignal[];
+    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[];
+    /**
+     * The section-local pages this span's pass returned — identity evidence for reuse. (On a
+     * continuous section the host tail merges instead of remapping, so `remappedPages` covers
+     * only the overflow sheets while this list still holds every returned page.)
+     *
+     * A section can lay out more than once inside one document pass (a reserve re-run, a
+     * balancing probe), and the last run then reports "nothing placed" against its OWN session
+     * even though an earlier run this pass rebuilt the pages. Counts and stats cannot tell
+     * those apart; only these object identities can say the span still describes the pages the
+     * section just returned.
+     */
+    readonly sourcePages: readonly PageRecord[];
+    /** The blank parity sheet published in front of the section, kept for identity reuse. */
+    readonly paritySheet?: PageRecord;
+}
+/** Orchestrator state for multi-section incremental layout. */
+interface MultiSectionLayoutState {
+    structureKey: string;
+    /** Each section's part of {@link structureKey}, so an added section keeps the others. */
+    sectionKeys: readonly string[];
+    sections: LayoutSession[];
+    spans: SectionStackSpan[];
+    previousRemapped: readonly PageRecord[];
+    previousFinalized: SemanticLayout | null;
+    previousPageCount: number;
+    /**
+     * The PAGEREF assignment token of the pages behind `previousFinalized`. A target can move
+     * sheets while the TOC page's own remapped record stays identity-unchanged, so the finalized
+     * restore must compare this before handing back a previously substituted sheet.
+     */
+    previousPageRefToken: string;
+}
+/**
+ * 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 flow context of the previous pass; a change forces a full pass. */
+    context: string;
+    /**
+     * Producer of the previous pass, compared beside {@link context} rather than embedded in
+     * it: the producer carries the content-control token, which runs to kilobytes on a
+     * control-heavy document, and embedding it copied that token into every section's context
+     * string on every pass. Identity-stable when unchanged, so the comparison is a pointer
+     * check.
+     *
+     * Optional so a session literal built before this field existed still type-checks; an
+     * absent producer never matches and forces a conservative full pass.
+     */
+    producer?: 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;
+
+/** Collect story paragraphs, preserving table depth limits across immutable row reuse. */
+declare function walkStoryParagraphs(blocks: readonly OoxmlElement[], maxTableDepth?: number): OoxmlElement[];
+
+/**
+ * Horizontal marker box inside the first-line indent slot.
+ *
+ * Coordinates are relative to the same origin as paragraph content (`indent.left` is the
+ * text start). Returns null when there is nothing to paint.
+ *
+ * `w:hanging` and a positive `w:firstLine` are one mutually exclusive slot
+ * (§17.3.1.10, §17.3.1.12), so the marker has two placements, not an interaction:
+ * a hanging level puts the marker BEFORE the text start (`left - hanging`); a
+ * positive-firstLine level puts it AFTER (`left + firstLine`) — the standard legal
+ * shape `w:ind w:left="0" w:firstLine="720"` numbers at 0.5" while continuation
+ * lines return to the margin. Reading only the hanging model painted every such
+ * marker at the left margin.
+ */
+declare function listMarkerBox(item: ResolvedListItem, markerWidth: number, lineY: number, lineHeight: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+
+/** Soft ceiling on `basedOn` chain length — enough for real templates, refuses hostile graphs. */
+declare const MAX_STYLE_BASED_ON_DEPTH = 32;
+
+/** Far above anything Word authors (its UI caps at 63) while keeping allocation bounded. */
+declare const MAX_TABLE_COLUMNS = 1024;
+
+/**
+ * `w:tblW` / `w:tcW` / `w:wBefore` (CT_TblWidth, 17.4.63 / 17.4.71 / 17.4.86): a PREFERRED
+ * width plus the unit it is stated in. Preferred is the operative word — it is what the
+ * producer asked for, not what the table resolved to.
+ *
+ * `pct` is stated in fiftieths of a percent (5000 = 100%) by Word, and in the `"50%"`
+ * string form of `ST_Percentage` by others; both are read. `auto` and `nil` carry no width.
+ */
+type PreferredWidthType = 'dxa' | 'pct' | 'auto' | 'nil';
+/**
+ * `w:tblW` / `w:tcW` — a requested width, whose UNIT depends on its type.
+ *
+ * Points for `dxa`, percent for `pct`, and zero for `auto`/`nil`. Reading `value` without `type`
+ * is always wrong.
+ */
+interface PreferredWidth {
+    readonly type: PreferredWidthType;
+    /** POINTS for `dxa`, PERCENT for `pct` (0–100, or up to 655.34 for a table), 0 otherwise. */
+    readonly value: number;
+}
+/** The frozen "no preferred width" value — what a table or cell that declares none resolves to. */
+declare const AUTO_PREFERRED_WIDTH: PreferredWidth;
+
+/**
+ * The uniform 3 pt (60 twip) inset this lane used to apply on every side.
+ *
+ * Word's defaults are not uniform — see {@link DEFAULT_CELL_MARGINS} — so nothing resolves
+ * against this any more. Kept because it is published.
+ */
+declare const CELL_PAD = 3;
+/** Resolved cell padding in points, after the table default and any per-cell override. */
+interface CellMarginsPt {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+/**
+ * Traditional default table-style padding: 0 vertical, 108 twips horizontal.
+ *
+ * Kept as a published constant. Authored styles can supply these values; omitted
+ * margins instead resolve to a 10-twip horizontal application fallback.
+ */
+declare const DEFAULT_CELL_MARGINS: CellMarginsPt;
+
+/** `w:vAlign` — where a cell's content sits when the row is taller than the content. */
+type CellVerticalAlign = 'top' | 'center' | 'bottom';
+
+/**
+ * What autofit needs from layout to measure each cell the way layout paints it.
+ * @public
+ */
+interface TableAutofitContext {
+    /** Measures text exactly as line breaking does. */
+    readonly measurer: TextMeasurer;
+    /** List items by paragraph id: a list level indents its paragraph. */
+    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
+    /** Resolves inline pictures, so a picture column keeps the width the picture paints at. */
+    readonly inlineDrawingLayout?: InlineDrawingLayoutContext;
+    /** Field and note context, so the minimum measures the text layout paints. */
+    readonly fields?: AutofitFieldContext;
+    /** The document's default tab interval, where an unwrapped line's tabs advance to. */
+    readonly defaultTabStopPt?: number;
+    /**
+     * A token that changes whenever a paragraph's projected text can change: the same tokens
+     * the paragraph break cache keys on. Minimums are cached only when this and
+     * {@link TableAutofitContext.passToken} are both given.
+     */
+    readonly paragraphToken?: (paragraph: OoxmlElement) => string;
+    /**
+     * A token over every other input the minimum reads: the drawing context and every member of
+     * {@link TableAutofitContext.fields}. It must change when any of them changes. List state is
+     * not part of it: {@link TableAutofitContext.paragraphToken} must carry each paragraph's
+     * list tokens.
+     */
+    readonly passToken?: string;
+}
+/**
+ * The field and note context cell layout projects paragraphs with.
+ * @public
+ */
+interface AutofitFieldContext {
+    /** The page a header or footer paints on, for its PAGE and NUMPAGES results. */
+    readonly pageContext?: FieldPageContext;
+    /** Footnote and endnote reference marks, as numbered for this pass. Treated as immutable. */
+    readonly noteMarks?: NoteMarkContext;
+    /** Package properties that AUTHOR, TITLE, and similar fields paint. */
+    readonly documentProperties?: DocumentProperties;
+    /** Body page-field placeholders; `false` paints cached results instead. */
+    readonly bodyPageFields?: BodyPageFieldContext | false;
+    /** Refreshed cross-reference results. */
+    readonly refFields?: RefFieldContext;
+    /** Paint field instructions instead of results. */
+    readonly showFieldCodes?: boolean;
+    /** Field-code ranges by paragraph id, when instructions are shown. */
+    readonly fieldCodeRanges?: FieldCodeRanges;
+    /** Table-of-contents link styling by paragraph id. */
+    readonly tocLinkStyleRanges?: TocLinkRanges;
+}
+
+/**
+ * Where a table's left edge sits inside the box that contains it.
+ *
+ * Ordinary left-aligned tables start at their indent, which may be negative and is not
+ * limited to the remaining width. Centered and right-aligned left-to-right tables use the
+ * remaining width and ignore the indent. `outerRuleOffsetPt` then moves the grid inward by
+ * half the outer side rule where the table puts that rule's outer edge on the aligned edge.
+ * For a supported mode-14 fixed table, that offset instead aligns the first cell's content.
+ * A legacy content-aligned table instead puts the content edge of its leading or trailing
+ * cell on the aligned edge of the text column; its indent still applies from the leading edge.
+ */
+declare function tableOriginX(structure: SemanticTableStructure, containerWidthPt: number): number;
+
+/**
+ * Layout-time nesting ceiling. Parse-time depth (MAX_DEPTH = 256 XML levels) alone still
+ * admits ~80 levels of `w:tbl` recursion into the layout walk; deeper tables render as an
+ * empty cell box rather than recursing.
+ */
+declare const MAX_TABLE_NESTING = 16;
+/**
+ * Soft ceiling on an authored `w:trHeight` (~22"). Hostile `w:val` otherwise becomes a
+ * multi-page row that every pagination preflight and cell box inherits.
+ */
+declare const MAX_TABLE_ROW_HEIGHT_PT: number;
+/**
+ * `w:trPr/w:trHeight` (17.4.81) resolved for layout. Points leave the reader already —
+ * twips convert once here, matching every other table geometry boundary.
+ *
+ * Word quirk (matches Form025U and Word's UI export): a present `@w:val` with an omitted
+ * `@w:hRule` is treated as `atLeast`, not ECMA's `auto`. Explicit `auto` still ignores val.
+ */
+type TableRowHeightRule = 'auto' | 'atLeast' | 'exact';
+/**
+ * `w:trHeight` — a row's height rule and its value.
+ *
+ * `auto` carries no value at all, which is why this is a union rather than a rule plus an
+ * optional number.
+ */
+type TableRowHeight = {
+    readonly rule: 'auto';
+} | {
+    readonly rule: 'atLeast' | 'exact';
+    readonly valuePt: number;
+};
+/** `w:tblPr/w:jc` (17.4.29, ST_JcTable): where the table sits within the text column. */
+type TableAlignment = 'left' | 'center' | 'right';
+/**
+ * One cell in the resolved table structure.
+ *
+ * `gridSpan` is clamped at READ time and layout never re-derives it — the value comes from a file
+ * and would otherwise be a loop bound an attacker controls.
+ */
+interface SemanticTableCell {
+    readonly revisionShading?: 'inserted' | 'deleted' | 'merged' | 'split';
+    readonly revisionShadingAuthor?: string;
+    readonly id: string;
+    /** Derived content-edge geometry for a verified legacy percentage-width parent table. */
+    readonly legacyContentAlignment?: true;
+    /** Resolved simple side rules centered on a legacy absolute-width table grid. */
+    readonly centeredSideRules?: true;
+    /** Simple side rules painted centered on the grid line, without moving the content edge. */
+    readonly centeredSidePaint?: true;
+    /** Clamped to [1, MAX_TABLE_COLUMNS] at read time; layout never re-derives it. */
+    readonly gridSpan: number;
+    /** Physical grid column after width/style resolution and the bidiVisual projection. */
+    readonly gridColumn: number;
+    /** Stored grid index when bidiVisual maps this cell into a physical RTL grid. */
+    readonly logicalGridColumn?: number;
+    /** Canonical `w:gridCol` node id for this cell's start column, when the grid is authored. */
+    readonly gridColumnId?: string;
+    /** A vMerge cell that is not the restart continues the cell above: box, no content. */
+    readonly vMergeContinue: boolean;
+    /** `w:hideMark` excludes the end-of-cell glyph from row sizing. */
+    readonly hideEndMark?: boolean;
+    /** `w:vAlign` — defaults to top when omitted/unrecognised. */
+    readonly vAlign: CellVerticalAlign;
+    /** `w:textDirection`; unsupported values keep horizontal layout. */
+    readonly textDirection: 'horizontal' | 'btLr';
+    /** Resolved per-side margins (tcMar over tblCellMar over the table style over Word's default). */
+    readonly margins: CellMarginsPt;
+    /** Three-state authored `tcBorders` (omitted / none / edge). */
+    readonly borders: CellBorderBox;
+    /** The row's `w:tblPrEx` table borders, which replace the table's own for this cell. */
+    readonly rowTableBorders?: TableBorderBox;
+    /** Resolved incident edges used for content clearance, preserving authored border provenance. */
+    readonly contentBorders?: CellBorderBox;
+    /** The resolved cell (including a vertical merge) ends at the authored table bottom. */
+    readonly contentBottomIsOuter?: boolean;
+    /** Clearance this AUTHORED ROW reserves above its content for its own top rule, in points. */
+    readonly topBandClearancePt?: number;
+    /** The CELL declares `w:tcBorders/w:top` as `nil`, rather than a table style doing so. */
+    readonly suppressesTopBand?: true;
+    /** Row-local clearance in points for authored minima, before vMerge combines content boxes. */
+    readonly minimumContentInsets?: {
+        readonly top: number;
+        readonly bottom: number;
+    };
+    /** Validated 6-hex shading fill, absent for none/auto. */
+    readonly shading?: string;
+    /**
+     * `w:tcW` — the width this cell asked for, as authored.
+     *
+     * Published for consumers that need the cell's own statement (a column-resize handle has
+     * to write back to it). Column geometry is NOT derived from this field: the resolver works
+     * from a flat claim list built in the same pass, because resolving a column means looking
+     * at every cell that covers it across every row, not at one cell at a time. Read
+     * `columnWidthsPt` for what the table actually laid out.
+     */
+    readonly preferredWidth: PreferredWidth;
+    /**
+     * What the table style says about this cell's paragraphs and runs (17.7.6.6) — a header
+     * row's bold and centring live here, not in the cell's own properties.
+     */
+    readonly styleFormatting: TableCellStyleFormatting;
+    /** Block children in reading order, with content-control wrappers flattened. */
+    readonly blocks: readonly OoxmlElement[];
+}
+/** One row in the resolved structure: its cells, its height rule, and any row-level revision. */
+interface SemanticTableRow {
+    readonly id: string;
+    /** Pending Word row insertion/deletion authored in `w:trPr`. */
+    readonly revisionKind?: 'insert' | 'delete';
+    /**
+     * The `w:trPr/w:ins|w:del` attribution, carried with the kind so a painted row can say
+     * WHOSE pending decision it is — the review model addresses the decision by exactly this
+     * `(id, author, date)` triple, and a surface with only the kind could highlight the row
+     * but never open its card.
+     */
+    readonly revisionId?: string;
+    readonly revisionAuthor?: string;
+    readonly revisionDate?: string;
+    /** The row insertion a resolved view kept the row through; see the fragment record. */
+    readonly changeSites?: readonly RevisionAttribution[];
+    /** `w:trPr/w:tblHeader` — the row repeats atop each page the table continues onto. */
+    readonly isHeader: boolean;
+    /**
+     * `w:trPr/w:cantSplit` — the row must stay on one page. When no page can hold it, the
+     * row starts on a fresh page and splits there, so its content is kept.
+     */
+    readonly cantSplit: boolean;
+    /** `w:trPr/w:trHeight` — auto / atLeast floor / exact (clipped) row height. */
+    readonly height: TableRowHeight;
+    readonly cells: readonly SemanticTableCell[];
+}
+/**
+ * A table resolved into a rectangular grid: column widths, rows, and the widths it asked for.
+ *
+ * The grid is normalized here so layout never has to reconcile `w:gridCol` against actual cell
+ * spans — vertical merges and column spans are already accounted for.
+ */
+interface SemanticTableStructure {
+    /** Whether stored columns and horizontal table properties display right to left. */
+    readonly bidiVisual?: true;
+    readonly columnWidthsPt: readonly number[];
+    readonly rows: readonly SemanticTableRow[];
+    /** Verified pre-2013 percentage-width inline table; derived, never serialized. */
+    readonly legacyContentAlignment?: true;
+    /** A legacy content-aligned table whose outer trailing edge, not its content, meets the
+     * trailing text edge: a top-level table in a text box. Derived, never serialized. */
+    readonly legacyTrailingOuterEdge?: true;
+    /**
+     * Derived, never serialized: how far the grid moves from the aligned table edge, in points.
+     * A supported mode-14 fixed table shifts by its leading cell margin in the other direction.
+     * A compatibility-mode-15 left- or right-aligned table puts the outer edge of its side rule
+     * on that edge, so its first grid line sits half a rule inward. Positive moves right.
+     */
+    readonly outerRuleOffsetPt?: number;
+    /** `w:tblPr/w:tblW` — the width the table asked for. */
+    readonly tableWidth: PreferredWidth;
+    /**
+     * `w:tblInd` (17.4.50) in points — "this indentation should shift the table into the text
+     * margin by the specified amount". Applies to a left-aligned table; `w:jc` decides the
+     * placement outright for the other two. Negative on a top-level table, which the indent
+     * pulls into the leading margin; never negative on a nested table.
+     */
+    readonly indentPt: number;
+    /** `w:tblPr/w:jc` (17.4.29) — where the table sits in the text column. */
+    readonly alignment: TableAlignment;
+    /**
+     * `w:tblPr/w:tblpPr` (17.4.57) — present when the table is positioned against an anchor
+     * box. Placement then comes from {@link tableFloatOriginX} rather than `w:jc`/`w:tblInd`.
+     */
+    readonly float?: TableFloatPosition;
+    /**
+     * `w:tblCellSpacing` (17.4.45) in points: the space on each side of every cell. Cells sit
+     * twice this apart and from the table edge; the gaps come out of the table width, and each
+     * column gives up its share in proportion (`table-cell-spacing.ts`). Rows do not yet get
+     * the matching gaps above and below them, so a spaced table's rows stay as tall as they
+     * would be without it.
+     */
+    readonly cellSpacingPt: number;
+    /**
+     * `w:tblPr/w:tblLayout/@w:type="fixed"` (17.4.52 — 17.4.53 is the `w:tblPrEx` exception
+     * variant, not this element). Fixed layout takes the grid as final;
+     * anything else is autofit, which in Word never renders wider than the text column.
+     */
+    readonly layoutFixed: boolean;
+    /** Table-level `tblBorders` (three-state, including insideH/insideV). */
+    readonly tableBorders: TableBorderBox;
+    /** Table-level `tblCellMar` defaults (per-side, Word's own default when a side is omitted). */
+    readonly defaultMargins: CellMarginsPt;
+}
+/**
+ * Read one typed table node into a bounded structure, or null when the node is not a
+ * typed table or sits beyond the nesting ceiling.
+ */
+declare function readTableStructure(table: OoxmlNode, contentWidthPt: number, depth: number, styleCascade?: StyleCascadeTable, 
+/** Which revisions the view resolves away; only the proposed result performs the join. */
+displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter, compatibilityMode?: number, 
+/** Widens autofit columns to their content minimums; layout passes its measurer. */
+autofit?: TableAutofitContext, 
+/** The table is a top-level table of a text box story. */
+textBox?: boolean): SemanticTableStructure | null;
+
+/** 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 physical rectangles covering a selection, including disjoint bands within bidi lines.
+ *
+ * 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[], 
+/**
+ * For EXACT edge x positions inside a span. Layout no longer publishes eager per-character
+ * caret edges, so without a measurer an intra-span boundary interpolates across the span's
+ * advance — visibly wrong in a proportional face. Pass the layout's measurer.
+ */
+measurer?: TextMeasurer): SelectionRect[];
+/** A model range to highlight, and the key the caller knows it by. */
+interface KeyedRange {
+    readonly key: string;
+    readonly from: SemanticPosition;
+    readonly to: SemanticPosition;
+}
+/**
+ * Rectangles for MANY ranges in ONE pass over the lines.
+ *
+ * Not `selectionRects` in a loop. That walks every page, fragment and line per range, and a
+ * contract with two hundred comments would re-walk the whole document two hundred times on
+ * every layout — the highlight would cost more than the layout it decorates. One pass tests
+ * each line against every range instead, which is the same work a single selection does.
+ */
+declare function keyedRangeRects(layout: SemanticLayout, ranges: readonly KeyedRange[], 
+/**
+ * Pages to measure, or every page when absent.
+ *
+ * A band that is not on screen is not painted, so measuring it is pure cost — and it is
+ * cost paid per keystroke, because an edit republishes the layout. Bounding this to the
+ * materialized pages is what keeps typing in a heavily reviewed document as fast as
+ * typing in a clean one.
+ */
+pages?: ReadonlySet<number>, 
+/** For exact intra-span edge positions (see {@link selectionRects}). */
+measurer?: TextMeasurer): Map<string, SelectionRect[]>;
+
+/**
+ * The next word boundary from `offset`, in `direction`.
+ *
+ * Word-LEFT skips any whitespace immediately behind the caret and then the word behind that,
+ * which makes repeated presses walk words rather than alternate with the preceding space.
+ *
+ * `stops` are offsets a word may not run THROUGH even when the characters either side are
+ * word characters. They exist because the text this walks is what the VIEW is showing, and a
+ * view can show two versions of the document side by side: struck text and the text proposed
+ * to replace it abut with no separator, so `ALL CAPS` deleted and `fsdfsd` inserted read as
+ * the single word `CAPSfsdfsd`. Those characters are never adjacent in any one version, and a
+ * double-click that took both selected across a decision the reader had not made. See
+ * `deletedTextBoundaries`.
+ */
+declare function wordBoundary(text: string, offset: number, direction: -1 | 1, stops?: ReadonlySet<number>): number;
+
+/**
+ * Where an INSERT aimed at this position actually lands: past any deletion it sits inside.
+ *
+ * The caret may rest anywhere in struck text — Word's rule, and the tracked lane's
+ * (`tree-op-tracked.ts`): all-markup shows the words, so the reader can put the caret
+ * between two of them. What may NOT happen is new content landing inside the `w:del`,
+ * where it would serialize as `w:t` under a wrapper that requires `w:delText` and be taken
+ * down by an accept of someone else's deletion. A deletion stays contiguous, so the words
+ * go after it — the order a replacement reads in.
+ *
+ * RANGE endpoints are not this function's business: a drag may legitimately cover deleted
+ * text, so callers adjust only collapsed insertion points.
+ */
+declare function positionPastDeletion(layout: SemanticLayout, position: SemanticPosition): SemanticPosition;
+
+/**
+ * The caret position nearest a point, in PAGE-CONTENT coordinates.
+ *
+ * Never returns null for a point inside the document: a click in the margin, past the end of
+ * a line, or below the last line still has an obvious intended caret, and refusing to answer
+ * would make those clicks do nothing.
+ *
+ * The rules live in `semantic-hit-test.ts`, which answers with the cell address and the
+ * on-glyphs flag a pointer controller needs too; this keeps the geometry-only shape for
+ * callers that want nothing else.
+ */
+declare function hitTestSemantic(layout: SemanticLayout, point: {
+    readonly x: number;
+    readonly y: number;
+    readonly pageIndex?: number;
+}): CaretGeometry | null;
+/**
+ * Innermost content-control boundary at a page-content point, or null outside every control.
+ *
+ * Prefers the deepest nesting depth when nested boundaries share geometry.
+ */
+declare function contentControlAtSemantic(layout: SemanticLayout, point: {
+    readonly x: number;
+    readonly y: number;
+    readonly pageIndex?: number;
+}): ContentControlBoundaryRecord$1 | null;
+
+/**
+ * Rewrite private-use symbol-font codepoints to their Unicode equivalents.
+ *
+ * Applies only to a known symbol-encoded family, only to the U+F020–U+F0FF range, and only
+ * to codepoints with an exact Unicode counterpart — anything else is returned untouched, so
+ * an unrecognised glyph is never replaced by a wrong one. Returns the input string by
+ * identity when nothing changes.
+ *
+ * `isFamilyAvailable` is the escape hatch: a host that KNOWS the authored font is present
+ * should return true, and the file's own codepoint is kept so the real typeface draws it.
+ * Absent, the fallback applies, because an unmapped PUA codepoint renders as a tofu box in
+ * every font that is not the symbol-encoded original.
+ *
+ * Called without the oracle it is also the EXTRACTION answer: the text a symbol glyph should
+ * read as when the drawn glyph stays the authored one. A PDF exporter maps the drawn private
+ * codepoint back through this for its `ToUnicode` table, so copying a Word bullet out of the
+ * page yields a bullet rather than a private-use character.
+ *
+ * @public
+ */
+declare function mapSymbolPuaText(text: string, fontFamily: string | null | undefined, isFamilyAvailable?: (family: string) => boolean): string;
+
+/** Convert signed font units by an exact rational multiplier using the declared tie rule. */
+declare const roundFontUnitToFixedPoint: (fontUnits: number, denominator: number, numerator: number, mode: FixedPointRoundingMode) => FixedPoint;
+
+/**
+ * The exact HarfBuzz build this engine shapes against.
+ *
+ * Pinned and verified at load: a runtime reporting a different version is REFUSED rather than
+ * used, because glyph positioning can change between releases and a cached measurement taken
+ * under one build must not be trusted under another.
+ */
+declare const HARFBUZZ_SHAPING_LIBRARY: VersionedShapingLibrary;
+/** Load and verify the HarfBuzz WASM runtime without adding top-level await to import graphs. */
+declare function initializeHarfBuzz(): Promise<void>;
+/** Whether the WASM runtime is loaded and shaping can proceed synchronously. */
+declare function isHarfBuzzInitialized(): boolean;
+/**
+ * Why shaping refused.
+ *
+ * Mostly RESOURCE limits, because every input here derives from a file: text length, codepoint
+ * count, glyph count and outline size are all attacker-influenced, and an unbounded shape call is
+ * a denial-of-service vector rather than a rendering bug.
+ */
+type HarfBuzzShapingErrorCode = 'notInitialized' | 'wasmUnavailable' | 'unsupportedRuntime' | 'fontOverLimit' | 'malformedFont' | 'textOverLimit' | 'codepointsOverLimit' | 'glyphOverLimit' | 'outlineOverLimit' | 'shapedRunOverLimit' | 'unsupportedVariationAxes' | 'unsupportedFallback' | 'unsupportedColorFont' | 'unsupportedNormalization' | 'invalidBidiLevel' | 'shapingLibraryMismatch' | 'disposed';
+/**
+ * A shaping call that was refused, carrying the limit it exceeded where there was one.
+ *
+ * Thrown rather than returned: unlike a missing font, a run that cannot be shaped has no sensible
+ * fallback measurement, and continuing would lay text out at made-up widths.
+ */
+declare class HarfBuzzShapingError extends Error {
+    readonly name = "HarfBuzzShapingError";
+    readonly code: HarfBuzzShapingErrorCode;
+    readonly limit?: number;
+    readonly actual?: number;
+    readonly diagnostic?: string;
+    constructor(code: HarfBuzzShapingErrorCode, details?: {
+        readonly limit?: number;
+        readonly actual?: number;
+        readonly diagnostic?: string;
+        readonly cause?: unknown;
+    });
+}
+/**
+ * Resource budgets and cache sizes for one shaper. Every field optional.
+ *
+ * The caches exist because shaping is the expensive step: a face is opened once and reused, and
+ * identical runs return their previous result. The caps exist because file-derived input decides
+ * how much work is asked for.
+ */
+interface HarfBuzzTextShaperOptions {
+    readonly maxFontBytes?: number;
+    readonly maxInputUtf16?: number;
+    readonly maxCodepoints?: number;
+    readonly maxGlyphs?: number;
+    readonly maxCachedFaces?: number;
+    /** Aggregate retained native font bytes; oversized faces are shaped without retention. */
+    readonly maxCachedFontBytes?: number;
+    readonly maxCachedShapes?: number;
+    readonly maxOutlineBytes?: number;
+    readonly maxCachedOutlineBytes?: number;
+    readonly maxShapedRunBytes?: number;
+    readonly maxCachedShapeBytes?: number;
+    readonly instrumentation?: HarfBuzzTextShaperInstrumentation;
+}
+/** One face-cache transition, for instrumentation. */
+interface HarfBuzzFaceCacheEvent {
+    readonly kind: 'created' | 'hit' | 'evicted';
+    readonly identity: string;
+}
+/**
+ * Optional counters for the work a shaper is expected to do rarely.
+ *
+ * Exists so tests can assert the ABSENCE of work — re-opening a face or re-copying its bytes per
+ * shape call would not change any output, only make typing slow, which no rendering assertion
+ * would catch.
+ */
+interface HarfBuzzTextShaperInstrumentation {
+    readonly onFaceCacheEvent?: (event: HarfBuzzFaceCacheEvent) => void;
+    readonly onShapeCacheEvent?: (event: HarfBuzzShapeCacheEvent) => void;
+    readonly onByteCopy?: () => void;
+    readonly onTableScan?: () => void;
+    readonly onShapeCall?: () => void;
+    readonly onOutlinePathCall?: () => void;
+    readonly onOutlineCacheEvent?: (event: HarfBuzzOutlineCacheEvent) => void;
+}
+/** One shape-cache transition, for instrumentation. */
+interface HarfBuzzShapeCacheEvent {
+    readonly kind: 'hit' | 'miss' | 'stored' | 'evicted' | 'skipped' | 'cleared';
+    readonly retainedBytes: number;
+}
+/** One outline-cache transition, for instrumentation. */
+interface HarfBuzzOutlineCacheEvent {
+    readonly kind: 'created' | 'hit' | 'evicted' | 'skipped' | 'cleared';
+    readonly retainedBytes: number;
+}
+/**
+ * A {@link TextShaper} backed by HarfBuzz, holding WASM resources.
+ *
+ * {@link HarfBuzzTextShaper.dispose} is not optional housekeeping: the cached faces are WASM
+ * allocations that garbage collection cannot reclaim, so a shaper outliving its editor leaks
+ * until the page goes away.
+ */
+interface HarfBuzzTextShaper extends TextShaper {
+    dispose(): void;
+}
+/** Structural sfnt validation that does not construct native HarfBuzz objects. */
+declare const harfBuzzFontValidator: FontByteValidator;
+/**
+ * Build a HarfBuzz-backed shaper.
+ *
+ * Requires `initializeHarfBuzz()` to have resolved — shaping is synchronous, so the WASM runtime
+ * must already be loaded. Dispose the result when the editor goes away, or its cached faces leak.
+ */
+declare const createHarfBuzzTextShaper: (options?: HarfBuzzTextShaperOptions) => HarfBuzzTextShaper;
+
+/**
+ * Point the text shaper at an externally hosted copy of `harfbuzz.wasm`.
+ *
+ * Needed only under bundlers that do not emit `new URL(..., import.meta.url)`
+ * assets. esbuild and Bun are the common ones, and so is any build that inlines
+ * dynamic imports, such as a library bundle. There, the build succeeds and the
+ * shaper fails at runtime with an `EditorFontError` whose code is
+ * `wasmUnavailable`; this function is the fix. Webpack, Turbopack and Vite emit
+ * the binary on their own, and passing a URL there simply overrides theirs.
+ *
+ * ```ts
+ * import { setHarfBuzzWasmUrl } from '@docx-editor.dev/core/layout';
+ * setHarfBuzzWasmUrl('/static/harfbuzz.wasm');
+ * ```
+ *
+ * Pass a URL your application controls. It is fetched and instantiated as
+ * WebAssembly, so never derive it from user input, a query parameter, or remote
+ * configuration. Serving it cross-origin needs that origin in your `connect-src`
+ * CSP directive, and WebAssembly needs `wasm-unsafe-eval` in `script-src` either
+ * way.
+ *
+ * Call it before the first editor is created. The runtime reads the location once
+ * and caches the result, so a call afterwards warns and does nothing: fix the
+ * call site and reload. The file to serve is exported as
+ * `@docx-editor.dev/core/harfbuzz.wasm`, and it must be the copy from the
+ * installed package version, because the runtime refuses a version mismatch at
+ * load rather than shaping with unverified metrics.
+ *
+ * @public
+ */
+declare function setHarfBuzzWasmUrl(url: string | URL): void;
+
+/** UTF-16 boundaries that are both whole-grapheme and HarfBuzz cluster edges. */
+declare function shapedHorizontalBoundaries(run: ShapedRun): readonly number[];
+/**
+ * Whether an offset is a real caret position: both a grapheme boundary and a shaped cluster edge.
+ *
+ * Both conditions, because they disagree. A ligature is one cluster spanning two graphemes, and
+ * an offset inside it has no geometry the shaper can answer for — placing a caret there would
+ * mean inventing an x coordinate.
+ */
+declare function isWholeGraphemeHorizontalBoundary(run: ShapedRun, utf16Offset: number): boolean;
+/** Every published shaped boundary has exact geometry from the shaping result. */
+declare function isGeometryTrustedCaretOffset(run: ShapedRun, utf16Offset: number): boolean;
+/**
+ * Whether the distance from a line's start to an offset can be trusted as exact.
+ *
+ * Requires BOTH ends to be shaped boundaries: accumulating advances across an offset the shaper
+ * cannot place would produce a caret x that drifts further along the line.
+ */
+declare function isCumulativeGeometryTrustedFromLineOrigin(run: ShapedRun, lineStartUtf16Offset: number, utf16Offset: number): boolean;
+/** Grapheme offsets corresponding to exact shaped boundaries. */
+declare function semanticHorizontalBoundaries(run: ShapedRun): readonly number[];
+
+/**
+ * One user-perceived character, and the UTF-16 range that encodes it.
+ *
+ * The unit a caret moves by. An emoji with a skin-tone modifier is ONE segment spanning several
+ * UTF-16 code units, so stepping by code unit would put the caret inside it.
+ */
+interface GraphemeSegment {
+    readonly index: number;
+    readonly text: string;
+    readonly utf16From: number;
+    readonly utf16To: number;
+}
+/**
+ * The replaceable segmentation strategy.
+ *
+ * An explicit seam rather than a direct `Intl.Segmenter` call, so tests can install a
+ * deterministic boundary and a runtime without `Intl.Segmenter` can be given one.
+ */
+interface GraphemeBoundary {
+    segment(text: string): readonly GraphemeSegment[];
+}
+/** Invariant locale for deterministic cross-runtime grapheme boundaries. */
+declare const GRAPHEME_SEGMENTER_LOCALE: 'und';
+/** Whether this runtime provides `Intl.Segmenter`, which the default boundary requires. */
+declare function isIntlSegmenterAvailable(): boolean;
+/**
+ * The default boundary, over `Intl.Segmenter` at the invariant `und` locale.
+ *
+ * Locale-invariant on purpose: grapheme boundaries must not vary with the user's locale, or the
+ * same document would paginate differently for different readers.
+ */
+declare const intlGraphemeBoundary: GraphemeBoundary;
+/** Current boundary generation, for callers that cache segmentation-derived answers. */
+declare function graphemeBoundaryEpoch(): number;
+/**
+ * Split text into graphemes through the active boundary.
+ *
+ * Memoized on the last texts seen, because paragraph layout asks about the same string
+ * repeatedly and a full segmentation pass per call made layout quadratic in paragraph length.
+ */
+declare function segmentGraphemes(text: string): readonly GraphemeSegment[];
+/**
+ * Install a different segmentation strategy, invalidating the memo.
+ *
+ * For tests and for runtimes lacking `Intl.Segmenter`. Call {@link resetGraphemeBoundary} to
+ * restore the default.
+ */
+declare function setGraphemeBoundary(boundary: GraphemeBoundary): void;
+/** Restore the default `Intl.Segmenter` boundary and clear the memo. */
+declare function resetGraphemeBoundary(): void;
+/** How many user-perceived characters the text holds. */
+declare function graphemeCount(text: string): number;
+/**
+ * The grapheme index containing a UTF-16 offset. Clamps rather than throwing.
+ *
+ * Backed by a single-entry index cache: this runs once per character during paragraph layout, and
+ * re-segmenting per call is what made a 20,000-character paragraph take minutes to open. One
+ * entry rather than a map, because the keys are file-derived strings of unbounded size.
+ */
+declare function utf16OffsetToGrapheme(text: string, utf16Offset: number): number;
+/** The UTF-16 offset a grapheme index starts at. Clamps rather than throwing. */
+declare function graphemeOffsetToUtf16(text: string, graphemeOffset: number): number;
+
+/**
+ * One word-segmentation span. `wordLike` separates words from the whitespace and punctuation
+ * between them, which is what double-click selection needs to skip.
+ */
+interface WordSegment {
+    readonly utf16From: number;
+    readonly utf16To: number;
+    readonly wordLike: boolean;
+}
+/**
+ * The replaceable word-segmentation strategy.
+ *
+ * Falls back to a BOUNDED grapheme-safe splitter where `Intl.Segmenter` is absent — bounded
+ * because the input is file-derived, and grapheme-safe so a fallback never splits inside an
+ * emoji.
+ */
+interface WordBoundary {
+    segment(text: string): readonly WordSegment[];
+}
+/** Invariant locale for deterministic cross-runtime word boundaries. */
+declare const WORD_SEGMENTER_LOCALE: 'und';
+/** Whether this runtime provides word-granularity `Intl.Segmenter`. */
+declare function isIntlWordSegmenterAvailable(): boolean;
+/** Intl.Segmenter word boundary for the invariant locale. */
+declare function createIntlWordBoundary(): WordBoundary;
+/** Bounded deterministic fallback — not full UAX #29 word conformance. */
+declare function boundedFallbackWordSegments(text: string): readonly WordSegment[];
+/** Explicit bounded fallback boundary (grapheme-safe, narrower than Intl). */
+declare function createBoundedFallbackWordBoundary(): WordBoundary;
+/** Injection points for {@link createDefaultWordBoundary}, so tests can force either path. */
+interface WordBoundaryResolverDeps {
+    readonly isIntlAvailable?: () => boolean;
+    readonly createIntlBoundary?: () => WordBoundary;
+    readonly createFallbackBoundary?: () => WordBoundary;
+}
+/** Resolve production word boundary: Intl when available/construction succeeds, else bounded fallback. */
+declare function createDefaultWordBoundary(deps?: WordBoundaryResolverDeps): WordBoundary;
+/** Cached immutable production boundary (first resolved instance only). */
+declare function resolveDefaultWordBoundary(): WordBoundary;
+/** Split text into word segments through the given boundary, or the resolved default. */
+declare function segmentWords(text: string, boundary?: WordBoundary): readonly WordSegment[];
+/**
+ * A word span expressed in GRAPHEME offsets rather than UTF-16 ones.
+ *
+ * What selection actually uses: a range whose ends are UTF-16 offsets could land inside a
+ * grapheme, and selecting half an emoji is not a word.
+ */
+interface GraphemeWordSegmentRecord {
+    readonly graphemeFrom: number;
+    readonly graphemeTo: number;
+    readonly wordLike: boolean;
+}
+/** Map UTF-16 word segments to grapheme-safe half-open ranges within one paragraph. */
+declare function wordSegmentsToGraphemeRecords(text: string, segments: readonly WordSegment[]): readonly GraphemeWordSegmentRecord[];
+
+/** One span in the engine's published story order. @public */
+interface SemanticSpanVisit {
+    readonly page: PageRecord;
+    readonly story: SemanticStoryKind;
+    /** Root story from which textbox descent began; equal to `story` outside textboxes. */
+    readonly rootStory: SemanticRootStoryKind;
+    /** Precise root host and absolute origin for story-relative geometry. */
+    readonly root: SemanticStoryVisit;
+    /** Absolute origin of the immediate root or textbox story containing this span. */
+    readonly storyOrigin: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    /** Absolute laid-out span bounds in page-stack coordinates. */
+    readonly absoluteBox: LayoutBox;
+    /** Owning note scope/area where applicable; null for body and page furniture. */
+    readonly noteScopeId: string | null;
+    readonly noteAreaKind: SemanticStoryVisit['noteAreaKind'];
+    /** Zero outside a textbox, otherwise its bounded nesting depth. */
+    readonly textboxDepth: number;
+    /** Immediate textbox-owning drawing, anchored or inline, or null in the root story. */
+    readonly textboxOwner: TextboxOwnerRecord | null;
+    /** Root-to-leaf textbox owners, preserving drawing identity for future exporters. */
+    readonly textboxPath: readonly TextboxOwnerRecord[];
+    /** Enclosing published fragment; use paragraphId for the authored span owner. */
+    readonly paragraph: ParagraphFragmentRecord;
+    /** Authored paragraph owning this span, including spans merged into another fragment. */
+    readonly paragraphId: string;
+    readonly line: LineRecord;
+    readonly span: StyleSpanRecord;
+    /**
+     * Model address for authored text. Projected atoms intentionally return null even though
+     * their geometry record carries a range used internally by layout.
+     */
+    readonly sourceRange: SourceRange | null;
+}
+/** Return the model address exporters may use, excluding layout-projected atoms. @public */
+declare function exportSourceRangeOf(span: StyleSpanRecord): SourceRange | null;
+/**
+ * Visit every published span in page/story order without consulting the source package.
+ * @public
+ */
+declare function forEachSemanticSpan(layout: SemanticLayout, visitor: (visit: SemanticSpanVisit) => void): void;
+
+/**
+ * The part of a line that belongs to ONE paragraph.
+ *
+ * A line normally belongs to one paragraph outright, and then this is the whole of it — the
+ * same object every caller read before, so nothing about an ordinary document takes a new
+ * path. A resolved display mode merges paragraphs that a tracked decision merges, and the line
+ * carrying the join holds spans from two of them. Offsets there are ambiguous by themselves:
+ * both paragraphs start at zero, so an offset means nothing without the paragraph it counts in.
+ */
+interface LineSegment {
+    readonly paragraphId: string;
+    readonly start: number;
+    readonly end: number;
+    readonly spans: readonly StyleSpanRecord[];
+    readonly drawings: readonly InlineDrawingRecord[];
+}
+/** Every paragraph a line carries, in visual order. One entry for an ordinary line. */
+declare function lineSegments(line: LineRecord): readonly LineSegment[];
+
+/**
+ * The box a painter clips a vector shape to: `bounds` grown on each side where a stroked
+ * outline reaches past the drawing extent.
+ *
+ * An outline is centred on its geometry and is not cut at the extent, a text column, or a cell
+ * edge that meets the extent: a rule at x=0 of a group with `wp:effectExtent l="0"` keeps
+ * its full width. The reach comes from butt-capped segments and miter joins, measured
+ * only on the part of each segment inside the extent, so geometry outside the extent stays
+ * clipped and a side grows by at most the miter reach. A line-end triangle on a line that
+ * ends inside the extent grows it too. A side stays as it is when a layout region or a
+ * negative effect extent cut into the shape itself, and a drawing clipped to nothing stays
+ * empty.
+ *
+ * Only the paint clip grows. Collisions, hit testing, and pointer targets keep `paintBounds`,
+ * so a painter clips with this box without making it clickable.
+ *
+ * `bounds` is the drawing's `paintBounds` in any translation: the record's own, or the
+ * absolute paint bounds of an export visit.
+ *
+ * @public
+ */
+declare function vectorShapeInkClip(drawing: InlineDrawingRecord | AnchoredDrawingRecord, bounds: LayoutBox): LayoutBox;
+
+/** Memoized style inputs shared by every story in one document view. @public */
+interface DocumentStyleDependencies {
+    readonly styleCascade: () => StyleCascadeTable | undefined;
+    readonly defaultTabStopPt: () => number;
+    readonly compatibilityMode?: () => number | undefined;
+    readonly numberingIndex: () => NumberingIndex;
+}
+/** Build the cascade and numbering projections layout consumes. @public */
+declare function createDocumentStyleDependencies(view: HeadlessDocumentView): DocumentStyleDependencies;
+
+/** Paired projector/cache identities shared by browser, exporters, and future story hosts. */
+interface StoryProjectionDependencies {
+    readonly tokenForParagraphForPart: (partName: string, paragraph: OoxmlNode) => string;
+    /** Memoized aggregate for every paragraph in an immutable table subtree. */
+    readonly tokenForTableForPart: (partName: string, table: OoxmlNode) => string;
+    readonly epochForPart: (partName: string) => string;
+}
+
+/**
+ * Sanitized projectors paired with the cache identities required to use them safely.
+ *
+ * Keep this object intact when passing it to a document composition helper. Projected text and
+ * its dependency tokens are one contract: accepting either half independently permits stale
+ * paragraph caches after relationship- or property-only revisions.
+ * @public
+ */
+interface DocumentLinkProjectors extends StoryProjectionDependencies {
+    readonly projectLink: HyperlinkProjector;
+    readonly projectLinkForPart: (partName: string) => HyperlinkProjector;
+}
+/** Sanitized body and per-part link projectors over one neutral document view. @public */
+declare function createDocumentLinkProjectors(view: HeadlessDocumentView): DocumentLinkProjectors;
+
+/** 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;
+    /** `w:pgMar/@w:header` for a header, `@w:footer` for a footer: the story edge's distance. */
+    readonly storyDistance?: number;
+}
+/** Per-sheet geometry needed to resolve header/footer anchors before wrap and clipping. */
+interface HeaderFooterLayoutPageContext extends FieldPageContext {
+    /** Effective content-box inset after this page's header/footer reserves are applied. */
+    readonly contentInsetTop?: number;
+    /** Effective bottom content-box inset after footer reserve. */
+    readonly contentInsetBottom?: number;
+    /** Story-box top measured from the physical sheet top. */
+    readonly storyTop?: number;
+}
+interface HeaderFooterStoryLayout {
+    readonly partName: string;
+    /**
+     * 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.
+     */
+    readonly part?: OoxmlPart;
+    /** 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;
+    /** Snapshot identity for projected links and live document-property fields in this story. */
+    readonly projectionEpoch?: 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 page-field and optional attached-page geometry 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: HeaderFooterLayoutPageContext) => 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 {
+    readonly compatibilityMode?: number;
+    /**
+     * `numbering.xml`, so a `w:numPr` paragraph in this story resolves a marker — directly or
+     * inside an anchored text box, which lays out with its own per-box counters.
+     *
+     * Absent, the story lays out exactly as before: no marker record, and no numbering indent
+     * merged into the paragraph's own.
+     */
+    readonly numberingIndex?: NumberingIndex;
+    /** Sanitized hyperlink seams scoped to this header/footer part. */
+    readonly projectLink?: HyperlinkProjector;
+    readonly projectFieldLink?: FieldLinkProjector;
+    /** @internal */
+    readonly showFieldCodes?: boolean;
+    /** Per-paragraph identity for links and live document-property projection. */
+    readonly projectionTokenForParagraph?: (paragraph: OoxmlNode) => string;
+    /** Memoized aggregate projection identity for table subtrees. */
+    readonly projectionTokenForTable?: (table: OoxmlNode) => string;
+    /** Aggregate identity of link and live-field projections for furniture reuse keys. */
+    readonly projectionEpoch?: string;
+    /** Reviewers whose changes project as accepted in this story. */
+    readonly revisionAuthorFilter?: RevisionAuthorFilter;
+}
+/**
+ * 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 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;
+
+/** Which header/footer variant a page shows (ECMA-376 §17.10.5). */
+type HeaderFooterVariantName = 'default' | 'first' | 'even';
+/**
+ * Pre-laid page furniture, supplied by the host (phase 2).
+ *
+ * Baseline stories are laid out once per variant (`layoutHeaderFooterStory`) for furniture
+ * height. Stories that actually contain allowlisted PAGE/NUMPAGES fields attach a projector
+ * so document-level finalize can re-layout under the known page count; field-free furniture
+ * reuses the baseline on every sheet.
+ */
+interface PageFurniture {
+    readonly titlePage: boolean;
+    readonly evenAndOddHeaders: boolean;
+    readonly headers: ReadonlyMap<HeaderFooterVariantName, HeaderFooterStoryLayout>;
+    readonly footers: ReadonlyMap<HeaderFooterVariantName, HeaderFooterStoryLayout>;
+}
+
+/** Page furniture supplied to semantic layout. @public */
+interface DocumentFurnitureSource {
+    furniture(): PageFurniture | undefined;
+    sectionFurniture(): readonly (PageFurniture | undefined)[];
+}
+/** Inputs that remain valid for the lifetime of one furniture source. @public */
+interface CreateDocumentFurnitureSourceOptions {
+    readonly view: HeadlessDocumentView;
+    readonly measurer: TextMeasurer;
+    readonly producer: string;
+    readonly cache: ParagraphLayoutCache<readonly PendingLine[]>;
+    readonly styleCascade?: () => StyleCascadeTable | undefined;
+    readonly numberingIndex?: () => NumberingIndex;
+    readonly defaultTabStopPt?: () => number;
+    readonly compatibilityMode?: () => number | undefined;
+    readonly displayMode?: RevisionDisplayMode;
+    readonly revisionAuthorFilter?: RevisionAuthorFilter;
+    readonly inlineDrawingLayoutForPart?: (partName: string) => InlineDrawingLayoutContext | undefined;
+    readonly drawingLayoutTokenForPart?: (partName: string) => string;
+    readonly drawingTokenForParagraphForPart?: (partName: string, paragraph: OoxmlNode) => string;
+    /** Link/property projection and its inseparable cache identities. */
+    readonly linkProjectors: DocumentLinkProjectors;
+    readonly projectFieldLink?: FieldLinkProjector;
+    /** Field-code inspection projection. @internal */
+    readonly showFieldCodes?: boolean;
+}
+/** Build section-aware header/footer layout from a neutral document view. @public */
+declare function createDocumentFurnitureSource(options: CreateDocumentFurnitureSourceOptions): DocumentFurnitureSource;
+
+/**
+ * Where one note is referenced from — what per-page and per-section restart rules are computed
+ * against.
+ */
+interface NoteReferenceSite {
+    /** Stable note id (`w:id`). */
+    readonly noteId: number;
+    /** Section index of the reference (0-based). */
+    readonly sectionIndex: number;
+    /**
+     * Page index of the reference when known (0-based). Required for `eachPage` restart;
+     * when omitted, `eachPage` behaves like `continuous` for that site.
+     */
+    readonly pageIndex?: number;
+    /** When true, consumes no automatic number (`customMarkFollows`). */
+    readonly customMarkFollows?: boolean;
+}
+/**
+ * The mark a note reference paints.
+ *
+ * `null` where `w:customMarkFollows` suppresses it: the document supplies its own glyph, and
+ * painting an automatic number too would show the note twice.
+ */
+interface NoteDisplayMark {
+    readonly noteId: number;
+    /** Formatted mark, or `null` when suppressed by customMarkFollows. */
+    readonly mark: string | null;
+    /** 1-based automatic sequence number when assigned; absent when suppressed. */
+    readonly displayNumber?: number;
+}
+type ResolvedNoteProperties = ResolvedFootnoteProperties | ResolvedEndnoteProperties;
+/**
+ * Derive display marks for references of one note kind in document order.
+ *
+ * Restart rules:
+ * - `continuous` — single sequence across the document from `numStart`
+ * - `eachSect` — restart at `numStart` when `sectionIndex` changes
+ * - `eachPage` — restart when `pageIndex` changes (falls back to continuous if unknown)
+ *
+ * IDs are stable; only display numbers change. Non-mutating.
+ */
+declare function deriveNoteDisplayMarks(noteKind: NoteKind, references: readonly NoteReferenceSite[], properties: ResolvedNoteProperties): readonly NoteDisplayMark[];
+/**
+ * Derive marks using per-reference-section resolved properties (`numFmt` / `numStart` /
+ * `numRestart`). Restart rules consult each site's own section props.
+ */
+declare function deriveNoteDisplayMarksResolved(_noteKind: NoteKind, references: readonly NoteReferenceSite[], resolveProps: (sectionIndex: number) => ResolvedNoteProperties): readonly NoteDisplayMark[];
+/** Map noteId → formatted mark for quick lookup (last site wins if duplicated). */
+declare function noteDisplayMarkMap(marks: readonly NoteDisplayMark[]): ReadonlyMap<number, string | null>;
+
+/** Hard ceiling on notes laid out in one pass (fail closed beyond). */
+declare const MAX_NOTES_LAID_OUT = 10000;
+/** Hard ceiling on fragments emitted for one note (split / continuation). */
+declare const MAX_NOTE_FRAGMENTS = 512;
+/**
+ * Why note layout stopped short and fell back.
+ *
+ * Every one is a BOUND rather than a bug: note counts, fragment counts and heights all come from
+ * a file, and a document can ask for more note area than a page has. Falling back with a reason
+ * keeps the document open instead of failing to lay out.
+ */
+type NoteLayoutFallbackReason = 'note-count-limit' | 'note-fragment-limit' | 'note-reflow-exhausted' | 'note-height-cap'
+/** Authored separator/continuationSeparator taller than the content column. */
+ | 'note-separator-height-cap' | 'note-continuation-notice-height-cap' | 'missing-note-body' | 'dangling-note-reference';
+/**
+ * One note's body laid out as its own story, in story-relative coordinates.
+ *
+ * Relative rather than page-absolute because a note moves between pages during pagination — the
+ * page it lands on is decided after its content is measured.
+ */
+interface NoteStoryLayout {
+    readonly noteKind: NoteKind;
+    readonly noteId: number;
+    /** `footnote:N` / `endnote:N` — matches EditorScope note id encoding. */
+    readonly scopeId: string;
+    readonly noteType: ReturnType<typeof noteTypeOf>;
+    /** Story-relative fragments; origin at the story box's top-left. */
+    readonly fragments: readonly BlockFragmentRecord[];
+    /** Height the blocks flow to (points). */
+    readonly flowHeight: number;
+    /** True when layout hit a named bound and returned a truncated / empty story. */
+    readonly fallbackReason?: NoteLayoutFallbackReason;
+}
+/** Paint style for Word-default / marker-only separator rules (not CSS inventing content). */
+type NoteSeparatorRuleStyle = 'single' | 'double';
+/**
+ * The rule between body text and the note area.
+ *
+ * Synthesized when the document declares none, because Word draws one regardless — a document
+ * without an authored separator still shows the line a reader expects.
+ */
+interface NoteSeparatorLayout {
+    readonly kind: 'separator' | 'continuationSeparator';
+    readonly fragments: readonly BlockFragmentRecord[];
+    readonly flowHeight: number;
+    /** True when the engine synthesized a default rule (document had none). */
+    readonly synthetic: boolean;
+    /**
+     * Layout-owned rule when the separator is marker-only (`w:separator` /
+     * `w:continuationSeparator`) or fully synthetic. Absent when an authored separator
+     * story has real paragraph/run/border content that paint should render as fragments.
+     */
+    readonly ruleStyle?: NoteSeparatorRuleStyle;
+    /** Marker rule geometry inside the measured separator story. */
+    readonly ruleBox?: LayoutBox;
+    /** Resolved marker-run color; null/absent uses automatic black. */
+    readonly ruleColor?: string | null;
+    /** Set when an oversize authored separator was replaced with a synthetic rule. */
+    readonly fallbackReason?: NoteLayoutFallbackReason;
+}
+/**
+ * Inline drawing support for ONE notes part.
+ *
+ * A note lives in `/word/footnotes.xml` or `/word/endnotes.xml`, not in the body part, so its
+ * pictures resolve against that part's relationships — the same per-part shape header/footer
+ * furniture uses. Without it a note paragraph flows with no drawing context at all and a
+ * picture inside it contributes no record: no image, and no placeholder either.
+ */
+interface NoteStoryDrawings {
+    readonly inlineDrawingLayout: InlineDrawingLayoutContext;
+    /**
+     * Per-paragraph projection + RESOURCE token for the break cache key.
+     *
+     * Image resources settle asynchronously, and the authored extent does not move when one
+     * does — so without the resource in the key the cached `pending` lines are served forever
+     * and a decoded picture never reaches the page.
+     */
+    readonly drawingTokenForParagraph?: (paragraph: OoxmlNode) => string;
+}
+interface LayoutNoteStoryOptions {
+    readonly measurer: TextMeasurer;
+    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;
+    readonly compatibilityMode?: number;
+    /**
+     * The active line-grid pitch of the section that owns the note, in points. Note lines snap
+     * to it like body lines do; absent means no grid.
+     */
+    readonly lineGridPitchPt?: number;
+    readonly displayMode?: RevisionDisplayMode;
+    readonly revisionAuthorFilter?: RevisionAuthorFilter;
+    /**
+     * Same projector seams the BODY walk uses. Without them a `w:hyperlink` or a HYPERLINK
+     * field inside a note painted as plain text — measured, but carrying no link record for
+     * paint to anchor and navigation to activate.
+     */
+    readonly projectLink?: HyperlinkProjector;
+    /**
+     * Per-part projector, preferred over `projectLink` when `ownerPartName` names the part.
+     *
+     * A `w:hyperlink` in `/word/footnotes.xml` declares its `r:id` in `footnotes.xml.rels`,
+     * so it must resolve there — the body projector answers from the body part's
+     * relationships, and when the two parts assign one id to different targets the footnote
+     * link navigated to the body's target. Same per-part rule pictures follow through
+     * {@link drawingsForPart}.
+     */
+    readonly projectLinkForPart?: (ownerPartName: string) => HyperlinkProjector | undefined;
+    readonly projectFieldLink?: FieldLinkProjector;
+    /** Field-code inspection projection. @internal */
+    readonly showFieldCodes?: boolean;
+    readonly projectionTokenForParagraphForPart?: (ownerPartName: string, paragraph: OoxmlNode) => string;
+    readonly projectionTokenForTableForPart?: (ownerPartName: string, table: OoxmlNode) => string;
+    /** Document properties for a document-property field inside a note story. */
+    readonly documentProperties?: DocumentProperties;
+    /**
+     * The document's resolved REF inputs, so a footnote's cross-reference paints the live
+     * value the body paints. The flow folds each paragraph's resolved values into its break
+     * key, which is what repaints a note after a renumbering edit it cannot otherwise see.
+     */
+    readonly refFields?: RefFieldContext;
+    /** Derived display marks for noteRef projection inside the note body. */
+    readonly noteMarks?: NoteMarkContext;
+    /**
+     * Cap on flow height for a single note story (points). Hostile notes must not allocate
+     * unbounded page fragments; overflow is split by the pagination layer, not here.
+     */
+    readonly maxFlowHeightPt?: number;
+    /** Resolves inline drawing support for the notes part a story lives in. */
+    readonly drawingsForPart?: (ownerPartName: string) => NoteStoryDrawings | undefined;
+    /**
+     * Notes part the story being laid out came from. Set by {@link layoutNoteById} /
+     * {@link layoutNoteSeparator}, which are the callers that hold the part.
+     */
+    readonly ownerPartName?: string;
+}
+/**
+ * Stable line-id namespace for one note. Body line counters compare these as opaque strings
+ * and must not collide with `line-N` / `hf-…` ids.
+ */
+declare function noteLineIdPrefix(noteKind: NoteKind, noteId: number): string;
+/** Collect normal (body) notes from a notes part, bounded. */
+declare function normalNotesOf(part: OoxmlPart | null | undefined): readonly OoxmlElement[];
+/** Find separator / continuationSeparator note body in a notes part. */
+declare function findSeparatorNote(part: OoxmlPart | null | undefined, kind: 'separator' | 'continuationSeparator'): OoxmlElement | undefined;
+/**
+ * Lay one note node out at `contentWidth`.
+ *
+ * Does not paginate. Callers that need splits ask for fragments and cut at paragraph/line
+ * boundaries in the note-pagination layer.
+ */
+declare function layoutNoteStory(note: OoxmlNode, contentWidth: number, options: LayoutNoteStoryOptions): NoteStoryLayout | null;
+/** Layout a note by id from a notes part; null when missing. */
+declare function layoutNoteById(part: OoxmlPart | null | undefined, noteId: number, contentWidth: number, options: LayoutNoteStoryOptions): NoteStoryLayout | null;
+/**
+ * Word-default paint style for a separator marker.
+ *
+ * Footnote and endnote separators both use a short single rule. A full-width double
+ * border on a body heading (e.g. the comprehensive fixture’s end banner) is ordinary
+ * paragraph `w:pBdr` ownership and must not transfer onto the note separator record.
+ * Authored separator stories with real paragraph/run/border content bypass this via
+ * fragment paint.
+ */
+declare function defaultNoteSeparatorRuleStyle(_noteKind: NoteKind, _kind: 'separator' | 'continuationSeparator'): NoteSeparatorRuleStyle;
+/**
+ * True when a separator note contains only OOXML separator markers (and empty noteRef
+ * atoms Word often authors beside them) — no measurable text or paragraph borders.
+ */
+declare function isMarkerOnlySeparatorNote(note: OoxmlNode, displayMode?: RevisionDisplayMode, revisionAuthorFilter?: RevisionAuthorFilter): boolean;
+/**
+ * Layout the document's separator note, or synthesize a short horizontal rule.
+ *
+ * Single-marker / missing separators emit no paragraph fragments — paint draws the rule
+ * from {@link NoteSeparatorLayout.ruleStyle} + box geometry. Authored separators with
+ * real paragraph/run/border content keep their fragment story (including `w:pBdr`).
+ * Explicitly empty stories and hidden markers do not acquire a default rule.
+ *
+ * When `maxFlowHeightPt` is set and an authored separator exceeds it, the engine fails
+ * closed to a short synthetic rule ({@link note-separator-height-cap}) so note pagination
+ * cannot burn the overflow budget on zero-progress separator-only pages.
+ */
+declare function layoutNoteSeparator(part: OoxmlPart | null | undefined, kind: 'separator' | 'continuationSeparator', contentWidth: number, options: LayoutNoteStoryOptions, noteKind: NoteKind, maxFlowHeightPt?: number): NoteSeparatorLayout;
+/** Default rule geometry for a synthetic / marker-only separator, story-relative. */
+declare function syntheticSeparatorBox(contentWidth: number, flowHeight: number, kind?: 'separator' | 'continuationSeparator'): LayoutBox;
+/** Absolute separator box: short rule for marker/synthetic, full width for authored stories. */
+declare function noteSeparatorAreaBox(separator: NoteSeparatorLayout, contentX: number, contentWidth: number, areaTop: number): LayoutBox;
+
+interface PageRefHit {
+    readonly noteKind: NoteKind;
+    readonly noteId: number;
+    readonly paragraphId: string;
+    /** Canonical UTF-16 atom offset within the paragraph. */
+    readonly atomOffset: number;
+    readonly customMarkFollows: boolean;
+    readonly sectionIndex: number;
+}
+
+/**
+ * Bound on reflow attempts for an UNSEEDED document layout pass (cold open).
+ *
+ * Sized for a cold open of a reference-dense document: adoption is a forward fixed-point
+ * iteration whose settled prefix extends a few pages per round, so a legal document with a
+ * hundred footnotes converges in tens of rounds (a 53-page/108-note fixture took 24).
+ * Orbits exit earlier through the fingerprint/envelope checks below, so the cap is a
+ * safety bound, not the expected cost.
+ */
+declare const MAX_NOTE_REFLOW_ATTEMPTS = 64;
+/** Cap on empty pages created solely to drain footnote/endnote overflow. */
+declare const MAX_NOTE_OVERFLOW_PAGES = 256;
+/**
+ * Cap on synthetic eachPage mark candidates measured per section (plus actual marks).
+ *
+ * eachPage sequences restart every page, so a page almost never carries more than a
+ * handful of auto-numbered notes. Measuring `numStart .. numStart + N - 1` covers
+ * single→double digit decimal growth and typical roman width peaks (e.g. `viii` vs `ix`)
+ * without scanning hostile `numStart` ranges unboundedly. Derived marks already assigned
+ * for the pass are always included in addition to this window.
+ */
+declare const MAX_EACH_PAGE_MARK_CANDIDATES = 12;
+/**
+ * Why note PAGINATION fell back, widening {@link NoteLayoutFallbackReason} with the reasons that
+ * only arise while distributing notes across pages.
+ */
+type NotePaginationFallbackReason = NoteLayoutFallbackReason | 'note-reflow-exhausted' | 'note-area-fragment-limit' | 'note-overflow-page-limit'
+/**
+ * Overflow/drain iteration placed zero note stories while carry/pending remained —
+ * abort rather than minting blank separator-only sheets up to the page budget.
+ */
+ | 'note-overflow-stalled'
+/** A single note line exceeds the full content column; content is not placed overflowing. */
+ | 'note-line-exceeds-page';
+/**
+ * Everything note pagination needs: the note parts, and the per-section properties governing
+ * them.
+ *
+ * Per-SECTION because numbering, restart rules and placement are all section properties — one
+ * document can restart footnote numbering at every section and end notes at the document end.
+ */
+interface NotesLayoutInput {
+    readonly footnotesPart: OoxmlPart | null;
+    readonly endnotesPart: OoxmlPart | null;
+    /** Per-section resolved footnote properties (index-aligned with document sections). */
+    readonly footnotePropsBySection: readonly ResolvedFootnoteProperties[];
+    /** Per-section resolved endnote properties. */
+    readonly endnotePropsBySection: readonly ResolvedEndnoteProperties[];
+    /** Document-level defaults (section 0 fallback). */
+    readonly documentFootnoteProps: ResolvedFootnoteProperties;
+    readonly documentEndnoteProps: ResolvedEndnoteProperties;
+    readonly measurer: TextMeasurer;
+    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;
+    /** Per-section active line-grid pitch in points; note lines snap to their section's grid. */
+    readonly lineGridPitchBySection?: readonly (number | undefined)[];
+    readonly defaultTabStopPt?: number;
+    readonly compatibilityMode?: number;
+    readonly displayMode?: RevisionDisplayMode;
+    readonly revisionAuthorFilter?: RevisionAuthorFilter;
+    /**
+     * Link projector seams, same as the body walk's. Normally injected by `semantic-layout`
+     * from its own options, so a note's `w:hyperlink` / HYPERLINK field carries the same
+     * sanitized record a body one does instead of painting dead text.
+     */
+    readonly projectLink?: HyperlinkProjector;
+    /**
+     * Per notes-part link projector, preferred over `projectLink`: a `w:hyperlink` inside
+     * `/word/footnotes.xml` or `/word/endnotes.xml` declares its `r:id` in that part's own
+     * `.rels`, not the body part's. The surface supplies this; the inherited body projector
+     * remains only a fallback for callers without per-part resolution.
+     */
+    readonly projectLinkForPart?: (ownerPartName: string) => HyperlinkProjector | undefined;
+    /**
+     * Content token over the notes parts' relationship records, standing in for
+     * {@link projectLinkForPart}'s closure in the notes-pass memo. The projector reads
+     * relationship state the pinned part identity cannot see move: a replicated rels-only
+     * change lands without splicing the notes part, so only a content token catches it.
+     * Required whenever `projectLinkForPart` is supplied — without it the memo is disabled,
+     * the same fail-closed rule `drawingsForPart` follows through `drawingLayoutEpoch`.
+     */
+    readonly linkRelsEpoch?: string;
+    /** Per-notes-part paragraph identity for projected links and metadata fields. */
+    readonly projectionTokenForParagraphForPart?: (ownerPartName: string, paragraph: OoxmlNode) => string;
+    /** Memoized table aggregate counterpart to `projectionTokenForParagraphForPart`. */
+    readonly projectionTokenForTableForPart?: (ownerPartName: string, table: OoxmlNode) => string;
+    /** Combined notes-part freshness signal; outer memo only, never a paragraph producer. */
+    readonly projectionEpoch?: string;
+    readonly projectFieldLink?: FieldLinkProjector;
+    /** Field-code inspection projection. @internal */
+    readonly showFieldCodes?: boolean;
+    /** Document properties for a document-property field inside a note story. */
+    readonly documentProperties?: DocumentProperties;
+    /**
+     * The document's resolved REF inputs, so a footnote's cross-reference paints the live
+     * value the body paints. Normally injected by `semantic-layout` from the context it built
+     * over the body and note stories; its values token joins the notes-pass fingerprint so a
+     * renumbering edit repaints the notes that cite the renumbered target.
+     */
+    readonly refFields?: RefFieldContext;
+    /**
+     * Inline drawing support per notes part. Absent means note paragraphs flow without
+     * drawing records, which is what a headless caller with no image port wants.
+     */
+    readonly drawingsForPart?: (ownerPartName: string) => NoteStoryDrawings | undefined;
+    /**
+     * Part-level drawing epoch covering the notes parts, standing in for
+     * {@link drawingsForPart}'s closure in the notes-pass memo (the closure is rebuilt per
+     * pass, so only an epoch can say "the drawing state did not move"). A caller that
+     * supplies `drawingsForPart` without this keeps the rebuild path.
+     */
+    readonly drawingLayoutEpoch?: string;
+}
+/**
+ * The layout with notes attached, plus any fallbacks taken and the mark context used.
+ *
+ * The marks come back because they feed the body's incremental cache tokens: a note number that
+ * changed must invalidate the paragraph that references it.
+ */
+interface NotesAttachResult {
+    readonly layout: SemanticLayout;
+    readonly fallbackReasons: readonly NotePaginationFallbackReason[];
+    /** Mark context used for the final body projection (for incremental cache tokens). */
+    readonly noteMarks: NoteMarkContext;
+}
+/**
+ * Whether a paragraph fragment owns a note atom at `atomOffset`.
+ *
+ * Fragment ranges are half-open for content ownership: `[start, end)`. The shared
+ * boundary offset belongs to the later fragment (downstream affinity), matching line
+ * splits where `fragmentStart = previous.range.end`.
+ */
+declare function fragmentOwnsAtomOffset(fragment: ParagraphFragmentRecord, atomOffset: number): boolean;
+/** Paragraph-id → refs index for linear {@link filterRefsOnPage} over a layout pass. */
+type PageRefIndex = ReadonlyMap<string, readonly PageRefHit[]>;
+/** Build a reusable paragraph-id index (document order preserved per paragraph). */
+declare function buildPageRefIndex(allRefs: readonly PageRefHit[]): PageRefIndex;
+/**
+ * Collect note references that appear in laid-out body fragments on a page.
+ * Matches {@link ParagraphFragmentRecord.range} ownership (half-open + boundary affinity).
+ *
+ * Pass {@link buildPageRefIndex} result as `refIndex` for O(fragments + matching refs)
+ * instead of scanning every document ref against every page fragment.
+ */
+declare function filterRefsOnPage(page: PageRecord, allRefs: readonly PageRefHit[], refIndex?: PageRefIndex): readonly PageRefHit[];
+/**
+ * Compute per-page bottom reserves (points) needed for footnotes given a provisional layout.
+ * Used by the bounded reflow loop before final attach.
+ *
+ * Height is measured against a column-derived note budget (not leftover body slack). Measuring
+ * from slack makes `stable` true on the first pass and never shrinks the body — references and
+ * notes then compete for the same band. Oversized notes still split/continue within the budget;
+ * {@link MIN_FOOTNOTE_BODY_BAND_PT} keeps a body band so reflow cannot chase blank sheets.
+ *
+ * Answers under the STRICT co-location policy: every footnote starts on the page that
+ * references it. The bounded orphan-pair refinement is a second phase of the internal
+ * reflow loop, which owns the strict fixed point the refinement needs as its starting
+ * point and as its fallback, so a single call from outside that loop cannot reach it.
+ */
+declare function computeFootnoteReserves(layout: SemanticLayout, allRefs: readonly PageRefHit[], input: NotesLayoutInput, noteMarks: NoteMarkContext, 
+/** Session-carried notes memo (opaque; owned by this module). */
+passMemo?: unknown, 
+/**
+ * The reserve map `layout` was laid under. Feeds the hold-out's observed-refusal test
+ * (a block the body pass declined to split under a known budget only moves whole);
+ * absent, the hold-out releases the ambiguous cases — a caller outside the reflow loop
+ * must not manufacture holds the loop never observed.
+ */
+previousReserves?: ReadonlyMap<number, number>): {
+    readonly reserves: ReadonlyMap<number, number>;
+    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;
+
+/** Inputs for projecting notes through the same semantic layout pass. @public */
+interface CreateDocumentNotesInputOptions {
+    readonly view: HeadlessDocumentView;
+    readonly measurer: TextMeasurer;
+    readonly producer: string;
+    readonly cache: Parameters<typeof layoutHeaderFooterStory>[4];
+    readonly styleCascade?: () => StyleCascadeTable | undefined;
+    readonly numberingIndex?: () => NumberingIndex;
+    readonly defaultTabStopPt?: number;
+    readonly compatibilityMode?: number;
+    readonly inlineDrawingLayoutForPart?: (partName: string) => InlineDrawingLayoutContext | undefined;
+    readonly drawingTokenForParagraphForPart?: (partName: string, paragraph: OoxmlNode) => string;
+    readonly drawingLayoutEpochForPart?: (partName: string) => string;
+    /** Link/property projection and its inseparable cache identities. */
+    readonly linkProjectors: DocumentLinkProjectors;
+    readonly projectFieldLink?: NotesLayoutInput['projectFieldLink'];
+    /** Field-code inspection projection. @internal */
+    readonly showFieldCodes?: boolean;
+    readonly displayMode?: RevisionDisplayMode;
+    readonly revisionAuthorFilter?: RevisionAuthorFilter;
+}
+/** Build note layout input from the neutral package view, or undefined when unused. @public */
+declare function createDocumentNotesInput(options: CreateDocumentNotesInputOptions): NotesLayoutInput | undefined;
+/** Resolve a relationship in a non-body story for shared link projection. @public */
+declare function documentRelationshipTargetIn(view: HeadlessDocumentView, partName: string, relationshipId: string): ReturnType<typeof relationshipTargetIn>;
+
+/** Sanitized field link retained for interactive consumers. @public */
+interface RegisteredFieldLink {
+    readonly id: string;
+    readonly paragraphId: '';
+    readonly start: 0;
+    readonly end: 0;
+    readonly text: '';
+    readonly kind: 'external' | 'internal' | 'unresolved';
+    readonly href: string | null;
+    readonly authored: string;
+    readonly anchor?: string;
+    readonly tooltip?: string;
+}
+/** Per-layout registry for projected HYPERLINK fields. @public */
+interface FieldLinkRegistry {
+    project(spec: HyperlinkFieldSpec): SpanLinkRecord | null;
+    linkById(linkId: string): RegisteredFieldLink | null;
+    clear(): void;
+}
+/** Create a bounded, content-keyed field-link registry. @public */
+declare function createFieldLinkRegistry(): FieldLinkRegistry;
+
+/**
+ * Strict hex fill: exactly six hex digits. Rejects `auto`, `nil`, and any non-hex payload
+ * (CSS functions, URLs, short hex, theme tokens).
+ */
+declare function resolveStrictHexFill(raw: string | undefined): string | undefined;
+/**
+ * Resolve a `w:shd` attribute bag to a validated RRGGBB fill, or undefined.
+ *
+ * `w:themeFill` is a REFERENCE, and Word always writes the value it resolved to alongside
+ * it: `<w:shd w:val="clear" w:fill="D9E2F3" w:themeFill="accent1" w:themeFillTint="33"/>`.
+ * Reading `w:fill` in that case is not inventing a colour from the theme — it is reading
+ * the colour the producer computed. Dropping the fill because a theme reference sat next
+ * to it left every accent-shaded cell and paragraph unpainted.
+ *
+ * `val="nil"` clears shading. Pattern vals are not rendered; a valid solid `fill` still
+ * paints as a clear fill until pattern support lands. A theme reference with no usable
+ * `w:fill` still resolves to nothing rather than a guess.
+ */
+declare function resolveOoxmlShadingFill(attributes: Readonly<Record<string, string>> | undefined): string | undefined;
+/** Read `w:shd` from a typed/generic element (table `tcPr`, nested `pPr`, …). */
+declare function shadingFillFromElement(shd: OoxmlElement | undefined): string | undefined;
+/**
+ * Resolve paragraph shading from cascaded flat `w:pPr` properties.
+ *
+ * Later `w:shd` entries win (defaults → style → direct), matching spacing/border cascade.
+ */
+declare function paragraphShading(props: readonly OoxmlProperty[]): string | undefined;
+/**
+ * Page-content box for paragraph shading: union of this fragment's line boxes.
+ *
+ * Excludes collapsed before/after spacing and bottom-border extent so the painted band
+ * matches Word's content-area fill (character shading height on a single line).
+ */
+declare function paragraphShadingBox(lines: readonly {
+    readonly box: LayoutBox;
+}[], x: number, width: number): LayoutBox | undefined;
+
+/**
+ * Everything a layout pass needs beyond the document itself.
+ *
+ * `measurer` is the only required field — layout is DOM-free and measures through whatever is
+ * injected here, which is what lets the same code paginate on a server and in a browser.
+ */
+interface SemanticLayoutOptions {
+    readonly geometry?: PageGeometry;
+    readonly measurer: TextMeasurer;
+    /**
+     * Reuse of measured-and-broken paragraphs across revisions (task 9.2).
+     *
+     * Only the BREAK is cached. Placement — y, fragments, page cuts — is always redone, so
+     * an edit high in the document still repaginates everything below it while paragraphs
+     * nobody touched are never measured again.
+     */
+    readonly cache?: ParagraphLayoutCache<readonly PendingLine[]>;
+    /**
+     * Collector for the cache keys a pass wants retained, instead of retaining directly.
+     * Supplied by the multi-section orchestrator, which retains once over the union —
+     * retaining per section evicted every other section's entries. `false` skips retention
+     * for this pass entirely (the orchestrator strides sweeps). See
+     * `retainLiveBreakKeys`.
+     */
+    readonly retainKeys?: Set<string> | false;
+    /**
+     * Part-level drawing projection/resource epoch for the section prepass memo.
+     *
+     * Moves whenever any drawing projection or resource state in the part does, standing in
+     * for the per-paragraph drawing tokens the memo would otherwise have to recompute to
+     * validate. A caller that supplies `drawingTokenForParagraph` without this epoch keeps
+     * the recompute path — the memo must never miss a token move it cannot see.
+     */
+    readonly drawingLayoutEpoch?: string;
+    /** Part-level freshness signal for paragraph-local semantic projection tokens. */
+    readonly projectionEpoch?: string;
+    /**
+     * Who produced the measurements, folded into every cache key.
+     *
+     * A font arriving after first paint changes every advance in the document while no
+     * content changes; without this the cache would serve the pre-font layout forever.
+     */
+    readonly producer?: string;
+    /**
+     * Incremental placement across revisions (task 9.3).
+     *
+     * Holds the previous complete layout and a flow checkpoint per paragraph, so a pass can
+     * resume just before the first affected paragraph instead of re-placing the document from
+     * the top, and can stop early when the flow reconverges with the previous run.
+     *
+     * Multi-section documents keep per-section child sessions on {@link LayoutSession.multi}.
+     */
+    readonly session?: LayoutSession;
+    /** Header/footer stories to attach per page; absent means no furniture. */
+    readonly furniture?: PageFurniture;
+    /**
+     * Which tracked revisions this pass resolves away (ECMA-376 §17.13).
+     *
+     * `all-markup` (the default) lays out both halves of every change. `proposed` lays out what
+     * the document becomes if every change is accepted; `original` what it was before any of
+     * them. Both are LAYOUT INPUTS: neither applies a `TreeDocOp` nor publishes a `ModelChange`,
+     * so a user who switches to the proposed result, saves, and sends the file has not silently
+     * accepted every proposal in it.
+     */
+    readonly displayMode?: RevisionDisplayMode;
+    /** Reviewers whose revisions render as their accepted projection. */
+    readonly revisionAuthorFilter?: RevisionAuthorFilter;
+    /**
+     * Per-section furniture, index-aligned with `enumerateDocumentSections`.
+     *
+     * When present, multi-section layout attaches each section's own headers/footers (after
+     * OOXML inheritance). `furniture` remains the single-section / last-section fallback.
+     */
+    readonly sectionFurniture?: readonly (PageFurniture | undefined)[];
+    /**
+     * `w:evenAndOddHeaders` from settings.xml. A section that restarts its page numbering then
+     * starts on a sheet whose position has the parity of the restarted number. When absent,
+     * layout reads the flag from the section furniture.
+     */
+    readonly evenAndOddHeaders?: boolean;
+    /** Authored column count/gap for anchored `relativeFrom="column"` frame resolution. */
+    readonly sectionColumns?: SectionColumns;
+    /** Active section line-grid pitch: line-unit margins and line snapping. Absent: no grid. */
+    readonly paragraphLineUnitPt?: number;
+    /**
+     * This section's resolved `w:pgBorders`, for the frame each of its sheets publishes.
+     *
+     * Section-scoped, not document-scoped: `w:display="firstPage"` means the first page of THIS
+     * section, and multi-section layout hands each pass its own.
+     */
+    readonly sectionPageBorders?: SectionPageBorders;
+    /**
+     * Styles-part cascade table (docDefaults + `w:style` last-wins). Absent keeps direct
+     * formatting only — the pre-cascade behaviour, used by unit tests that never open a
+     * package.
+     */
+    readonly styleCascade?: StyleCascadeTable;
+    /**
+     * Projection of `/word/numbering.xml`. Absent keeps pre-list behaviour (no markers /
+     * level indents). The index is immutable for a session; list counter state is derived
+     * per layout pass from document order.
+     */
+    readonly numberingIndex?: NumberingIndex;
+    /**
+     * Optional precomputed list items for the body story. When absent and
+     * {@link numberingIndex} is set, layout walks the full body (including table cells)
+     * once so counters continue across section boundaries and table document order.
+     */
+    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
+    /**
+     * `w:settings/w:defaultTabStop` in points (ECMA-376 §17.15.1.25); absent keeps the 0.5"
+     * schema default.
+     *
+     * It arrives as an option because the paragraph cascade cannot see `settings.xml`. A
+     * metric-locale template declares 1134 twips (2cm) and every default-interval tab in the
+     * document belongs on that grid. Constant for a session — the settings part is immutable
+     * here — which is why the prepared-block memo does not key on it.
+     */
+    readonly defaultTabStopPt?: number;
+    /** Explicit Word compatibility mode; absent retains existing geometry. */
+    readonly compatibilityMode?: number;
+    /**
+     * Turns a typed `w:hyperlink` into the SANITIZED record its spans carry.
+     *
+     * An option because resolving `r:id` needs the package's relationships, which layout — a
+     * per-part walk — cannot see. Absent means link runs still measure, break and paint;
+     * they simply carry no link, so nothing is clickable and no text is lost. That is the
+     * degradation a headless test or a furniture-only pass gets, and it is the safe one.
+     */
+    readonly projectLink?: HyperlinkProjector;
+    /**
+     * Turns a parsed HYPERLINK field instruction into the SANITIZED record its result carries.
+     *
+     * An option for the same reason as {@link projectLink}: the raw target must cross the
+     * surface's href trust boundary, which layout cannot see. Absent means the field's cached
+     * result still measures, breaks and paints — it simply is not clickable.
+     */
+    readonly projectFieldLink?: FieldLinkProjector;
+    /** Field-code inspection projection. @internal */
+    readonly showFieldCodes?: boolean;
+    /**
+     * How the pass addresses saved field results (DATE, MERGEFIELD, HYPERLINK display text, see
+     * `FieldResultsMode`). `atomic` (the default) lays every field out as one model unit.
+     * `editable` lays a saved result out as ordinary text at the offsets the store's editable
+     * mode addresses, so a caret, a hit, and a selection inside it land on its characters. The
+     * mode is folded into every cache key.
+     */
+    readonly fieldResults?: FieldResultsMode;
+    /** @internal */
+    readonly fieldCodeRanges?: FieldCodeRanges;
+    /** @internal Word TOC character-style suppression. */
+    readonly tocLinkStyleRanges?: TocLinkRanges;
+    /**
+     * The document's parsed metadata, for document-property fields (TITLE, AUTHOR, …). Read once
+     * by the surface and shared across body, table, note and header/footer flows.
+     */
+    readonly documentProperties?: DocumentProperties;
+    /**
+     * Footnote/endnote layout input. When present, body layout projects note marks and a
+     * post-pass attaches note areas (with bounded reflow for pageBottom reservation).
+     */
+    readonly notes?: NotesLayoutInput;
+    /**
+     * Per-page bottom reserves (points) subtracted from content height before line placement,
+     * keyed by DOCUMENT page index. A section's pass reads its own slice through
+     * `pageIndexStart`. Produced by the note reflow loop; absent means full content column.
+     */
+    readonly pageBottomReserves?: ReadonlyMap<number, number>;
+    /** Derived note marks for body/note projection (provisional or final). */
+    readonly noteMarks?: NoteMarkContext;
+    /** Inline drawing projection for typed `w:drawing` / `wp:inline` nodes. */
+    readonly inlineDrawingLayout?: InlineDrawingLayoutContext;
+    /** Per-paragraph drawing projection/resource token for break cache keys. */
+    readonly drawingTokenForParagraph?: (paragraph: OoxmlNode) => string;
+    /** Per-paragraph identity for projected links and live document-property text. */
+    readonly projectionTokenForParagraph?: (paragraph: OoxmlNode) => string;
+    /** Memoized aggregate projection identity for an immutable table subtree. */
+    readonly projectionTokenForTable?: (table: OoxmlNode) => string;
+    /** @deprecated Prefer {@link drawingTokenForParagraph}. */
+    readonly drawingLayoutToken?: string;
+    /** Internal: reflow pass index; negative values establish anchor pages before backward wrap. */
+    readonly drawingExclusionPass?: number;
+    /** Internal: converged exclusion zones — skips the reflow loop when set with zones. */
+    readonly drawingExclusionConverged?: boolean;
+    /** Internal: exclusion zones from the prior reflow pass, keyed by page index. */
+    readonly drawingExclusionZonesByPage?: ReadonlyMap<number, readonly ExclusionZone[]>;
+    /** Canonical drawing traversal order within the owner story part. */
+    readonly drawingSourceOrder?: ReadonlyMap<string, number>;
+    /**
+     * TOC instruction-only opening and ending chrome paragraph ids. Empty chrome suppresses
+     * its placeholder line; opening paragraph marks after a separator remain visible result lines.
+     * Tree nodes stay intact for refresh/save.
+     */
+    readonly tocFieldChromeParagraphIds?: ReadonlySet<string>;
+    /**
+     * Begin-paragraph ids of empty TOCs. These keep one layout line so paint can host an
+     * identifiable empty-TOC furniture placeholder (overrides chrome suppression).
+     */
+    readonly emptyTocPlaceholderParagraphIds?: ReadonlySet<string>;
+    /**
+     * Empty result-paragraph ids inside empty TOCs. Suppressed like field chrome so blank
+     * cached rows do not stack under the empty placeholder.
+     */
+    readonly emptyTocSuppressedResultParagraphIds?: ReadonlySet<string>;
+    /**
+     * Lay out only the first `bodyBlockLimit` body blocks. A large open lays out a growing
+     * prefix in separate tasks, each pass resuming from the last, so the page stays
+     * responsive; the final pass has no limit. @internal
+     */
+    readonly bodyBlockLimit?: number;
+}
+
+/**
+ * A deterministic measurer for tests and headless use.
+ *
+ * Monospace by construction: every character is the same width and every line the same
+ * height, scaled by `w:sz` when present. Real shaping is the HarfBuzz path; this exists so
+ * layout behaviour can be asserted without a font stack deciding the answer.
+ */
+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;
+
+/**
+ * Lay one story part out into pages.
+ *
+ * The engine's layout entry point. Walks body, header, footer and note roots, flattens block
+ * SDTs, paginates tables with header-row repeats and vertical merges, and resolves every
+ * paragraph through the style cascade.
+ *
+ * Incremental when given a {@link LayoutSession}: per-block cache keys plus flow checkpoints mean
+ * a pass that changes nothing returns the previous pages by identity.
+ */
+declare function layoutSemanticDocument(part: OoxmlPart, revision: number, options: SemanticLayoutOptions): SemanticLayout;
+
+/** Soft ceiling on an expanded marker string (codepoints). */
+declare const MAX_MARKER_TEXT_LENGTH = 64;
+/** Soft ceiling on authored `w:lvlText` before expansion. */
+declare const MAX_LVL_TEXT_LENGTH = 64;
+/** Clamp a list counter into a safe non-negative integer Word can format. */
+declare function clampListValue(value: number): number;
+/** `decimal` (§17.18.59). Clamped, because the counter derives from file-declared restarts. */
+declare function formatDecimal(value: number): string;
+/** `decimalZero` (§17.18.59): single digits zero-padded to two. */
+declare function formatDecimalZero(value: number): string;
+/**
+ * `upperRoman` (§17.18.59). Saturates at 3999, the largest value classical Roman numerals
+ * express — beyond it there is nothing correct to emit, so it stops rather than inventing
+ * notation.
+ */
+declare function formatUpperRoman(value: number): string;
+/** `lowerRoman` (§17.18.59). */
+declare function formatLowerRoman(value: number): string;
+/**
+ * Excel-style letter sequence: 1→A … 26→Z, 27→AA.
+ * Caps length so a hostile counter cannot grow without bound.
+ */
+declare function formatUpperLetter(value: number): string;
+/** `lowerLetter` (§17.18.59): the {@link formatUpperLetter} sequence, lower-cased. */
+declare function formatLowerLetter(value: number): string;
+/**
+ * Format one counter for a `w:numFmt` value (ST_NumberFormat, §17.18.59).
+ *
+ * `none` prints NOTHING — it is the format Word uses for a level that contributes only
+ * literal text, and formatting it as decimal invents a number the document never had.
+ * `bullet` is not formatted here — callers use the literal `lvlText`.
+ *
+ * The remaining enumerants (`japaneseCounting`, `thaiNumbers`, `ganada`, …) are
+ * per-script numeral sequences we do not carry glyph tables for. They fall back to decimal
+ * deliberately: the ORDINAL is still the authored one, only the script differs, which reads
+ * as a number in the wrong alphabet rather than as a missing or wrong marker.
+ */
+declare function formatNumFmt(numFmt: string, value: number): string;
+/**
+ * Expand `w:lvlText` placeholders `%1`…`%9` using per-level counters and formats.
+ *
+ * `formats[i]` / `counters[i]` correspond to ilvl `i`. Missing slots use decimal / 1.
+ * Literal percent signs that are not `%1`…`%9` are kept. Output is hard-capped.
+ */
+declare function expandLvlText(lvlText: string, counters: readonly number[], formats: readonly string[]): string;
+
+/**
+ * The stack used when a run names no font (or names one the sink refuses).
+ *
+ * Paint only sets `font-family` when `w:rFonts` supplies a validated name, so an unstyled
+ * run inherits the surrounding face. Measuring one stack and painting another drifts every
+ * advance; this is the Word-like Latin fallback the canvas path measures against.
+ */
+declare const DEFAULT_CANVAS_FONT_STACK = "Calibri, Carlito, Helvetica, Arial, sans-serif";
+/**
+ * The canvas text-metrics surface the editor injects.
+ *
+ * Structural subset of `CanvasRenderingContext2D` — declared here so the layout lane stays
+ * off the DOM lib. Hosts pass a real 2d context; tests pass a controllable mock.
+ */
+interface CanvasTextMetrics {
+    readonly width: number;
+    readonly actualBoundingBoxLeft?: number;
+    readonly actualBoundingBoxRight?: number;
+    readonly fontBoundingBoxAscent?: number;
+    readonly fontBoundingBoxDescent?: number;
+}
+/**
+ * The slice of a 2D canvas context measurement needs.
+ *
+ * A structural subset rather than `CanvasRenderingContext2D`, so layout stays DOM-free and a test
+ * can supply a deterministic stub.
+ */
+interface CanvasTextContext {
+    font: string;
+    /** Optional browser kerning control; older contexts retain their native behavior. */
+    fontKerning?: 'auto' | 'normal' | 'none';
+    textAlign?: 'left' | 'right' | 'center' | 'start' | 'end';
+    direction?: 'ltr' | 'rtl' | 'inherit';
+    measureText(text: string): CanvasTextMetrics;
+}
+/**
+ * How the canvas measurer resolves fonts, scales, and bounds its caches. Every field optional.
+ *
+ * Layout never creates a canvas itself: without a `context` this measurer does not exist and the
+ * surface falls back to fixed metrics.
+ */
+interface CanvasMeasurerOptions {
+    /**
+     * Layout units to CSS pixels — the same value the painter uses.
+     *
+     * Measuring at the layout size and multiplying afterwards is not the same as measuring at
+     * the painted size: font metrics are hinted per pixel size. Everything here measures at
+     * the painted size and converts back.
+     */
+    readonly scale?: number;
+    readonly fallbackFamily?: string;
+    /**
+     * The engine-minted family a document-embedded face was registered under, if any.
+     *
+     * Paint prefers this alias over the declared family, so measurement has to as well: a
+     * document whose face is embedded rather than installed would otherwise be measured
+     * against the fallback and painted with the embedded glyphs, and every advance, wrap
+     * point and page break would be taken from a font the reader never sees.
+     */
+    readonly fontAlias?: (family: string) => string | undefined;
+    /**
+     * Injected 2d text context from the editor/browser seam.
+     *
+     * `undefined` or `null` makes {@link tryCreateCanvasMeasurer} return null so the surface
+     * falls back to the fixed measurer. Layout never creates a canvas element itself.
+     */
+    readonly context?: CanvasTextContext | null;
+    /**
+     * Unique `(font, text)` width entries retained before LRU eviction.
+     *
+     * Long editing sessions measure many transient paragraph states; bounding this cache keeps
+     * memory predictable without changing layout output.
+     */
+    readonly maxWidthEntries?: number;
+    /** Distinct font-shorthand line metrics retained before LRU eviction. */
+    readonly maxMetricsEntries?: number;
+}
+/**
+ * The measurer a surface ended up with, plus the identity its cache keys must include.
+ *
+ * The `producer` string is load-bearing: the same canvas measuring against document-embedded
+ * faces produces DIFFERENT advances, so the two must not share a cache key space or a document
+ * would keep its pre-font pagination after the font arrived.
+ */
+interface ResolvedSurfaceMeasurer {
+    readonly measurer: TextMeasurer;
+    /**
+     * Cache-invalidation identity when the caller did not supply `producer`.
+     *
+     * `canvas-measurer+embedded` is the canvas measurer resolving document-embedded faces:
+     * the same canvas, different advances, so it must not share a cache key space.
+     */
+    readonly producer: 'canvas-measurer' | 'canvas-measurer+embedded' | 'fixed-measurer';
+}
+/**
+ * Whether an injected canvas text context is usable for measurement.
+ *
+ * Availability is decided by the editor seam (which alone may create a canvas). Layout
+ * never probes `document` — a missing context is simply "unavailable".
+ */
+declare function isCanvasMeasurementAvailable(context?: CanvasTextContext | null | undefined): boolean;
+/**
+ * Build a canvas-backed measurer, or `null` when no 2d context was injected.
+ *
+ * Prefer {@link resolveDefaultSurfaceMeasurer} at the editor surface: that keeps the
+ * fixed fallback for SSR/tests in one place.
+ */
+declare function tryCreateCanvasMeasurer(options?: CanvasMeasurerOptions): TextMeasurer | null;
+/**
+ * The surface's default measurer: canvas when a 2d context was injected, otherwise fixed.
+ *
+ * Host-supplied and shaping measurers override this entirely — call only when the options
+ * did not already name one. The editor seam is responsible for creating the canvas context.
+ */
+declare function resolveDefaultSurfaceMeasurer(scale?: number, options?: CanvasMeasurerOptions): ResolvedSurfaceMeasurer;
+
+type RefreshFieldResultsOp = Extract<TreeDocOp, {
+    op: 'refreshFieldResults';
+}>;
+
+interface RefFieldRefreshOptions {
+    /**
+     * The package the part belongs to, for the note-part half of the resolution context —
+     * the same context paint uses, so a body REF that targets a footnote bookmark computes
+     * the same value both places. Absent narrows resolution to body-declared bookmarks.
+     */
+    readonly package?: OoxmlPackage;
+    readonly styleCascade?: StyleCascadeTable;
+    readonly numberingIndex?: NumberingIndex;
+    /** The mode the surface painted under, so the saved values match the painted ones. */
+    readonly displayMode?: RevisionDisplayMode;
+    /**
+     * The DISPLAYED page number of one paragraph in the current finalized layout, or null when
+     * it is not placed. PAGEREF results ride the plan through this: the value is pagination's,
+     * so only a caller holding the laid-out pages can answer, and a plan without it keeps every
+     * PAGEREF result as loaded. The same calibration verdict paint took gates each rewrite.
+     */
+    readonly pageRefPageNumberOf?: (targetParagraphId: string) => string | null;
+}
+/**
+ * A {@link RefFieldRefreshOptions.pageRefPageNumberOf} source over one finalized layout.
+ *
+ * Builds the target → host-page index once, on first demand, and answers every field from
+ * it — the same walk finalize substitution takes, so the saved number is the painted one.
+ */
+declare function pageRefPageNumbersFromLayout(layout: SemanticLayout): (targetParagraphId: string) => string | null;
+/**
+ * Plan the refresh for one body part, or null when every supported REF result is already
+ * fresh (the no-op save path — no transaction, no revision bump, no undo entry).
+ */
+declare function planRefFieldResultRefresh(part: OoxmlPart, options: RefFieldRefreshOptions): RefreshFieldResultsOp | null;
+
+/**
+ * Return story blocks in document order, flattening block-level content controls.
+ * Compatible hidden paragraph marks join in body stories using the supplied styles and numbering.
+ * Repeated calls with the same part and projection inputs share one array. Treat it as read-only.
+ *
+ * @public
+ */
+declare function storyBlocks(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter, styles?: StyleCascadeTable, numberingIndex?: NumberingIndex): OoxmlElement[];
+/**
+ * Blocks of one typed footnote/endnote node — a separate semantic story root.
+ *
+ * The footnotes/endnotes part root is never a story; each note is laid out independently
+ * so line ids and incremental convergence stay namespaced by note identity.
+ */
+declare function noteStoryBlocks(note: OoxmlNode, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): OoxmlElement[];
+
+/** TOC boundary paragraphs whose empty instruction/chrome lines are suppressed. */
+declare function tocFieldChromeParagraphIds(part: OoxmlPart): ReadonlySet<string>;
+/**
+ * Begin-paragraph ids of TOCs that have no visible cached result rows.
+ *
+ * Layout keeps a single caret-height line on these ids so paint can host an identifiable
+ * empty-TOC furniture placeholder; ordinary field chrome on the same ids stays suppressed.
+ */
+declare function emptyTocPlaceholderParagraphIds(part: OoxmlPart): ReadonlySet<string>;
+/**
+ * Empty result-paragraph ids inside an empty TOC.
+ *
+ * Suppressed like field chrome so blank cached rows do not stack under the empty placeholder.
+ */
+declare function emptyTocSuppressedResultParagraphIds(part: OoxmlPart): ReadonlySet<string>;
+
+/** One page-local rectangle covering the part of a control that sits on that page. */
+interface ContentControlFragmentRecord extends LayoutBox {
+    readonly pageIndex: number;
+}
+/**
+ * Everything a consumer needs to point at one control without walking the tree.
+ *
+ * `controlId` is the canonical NODE id — the identity `w:id` cannot provide, because the file
+ * may omit it and may repeat it. `id` is the file's own `w:id` where it wrote one, carried as
+ * metadata for a caller that has to speak to something outside this engine.
+ */
+interface ContentControlBoundaryRecord {
+    readonly controlId: string;
+    readonly type: ContentControlKind;
+    readonly level: ContentControlLevel;
+    /** 0 for a top-level control; the nesting depth otherwise. */
+    readonly depth: number;
+    readonly lock: ContentControlLock;
+    /** The lock in force here, including every lock an enclosing control imposes. */
+    readonly effectiveLock: ContentControlLock;
+    readonly showingPlaceholder: boolean;
+    readonly temporary: boolean;
+    readonly tag?: string;
+    readonly alias?: string;
+    readonly id?: number;
+    /** Preserved `w:dataBinding` metadata. Present means value writes are refused as bound. */
+    readonly dataBinding?: ContentControlDataBinding;
+    /** Paragraphs the control's content holds, in reading order. */
+    readonly paragraphIds: readonly string[];
+    /** One rectangle per page the content reaches, in the page's own coordinate space. */
+    readonly fragments: readonly ContentControlFragmentRecord[];
+}
+/**
+ * Derive one boundary record per control the part declares, in document order.
+ *
+ * A control whose content the layout never placed — one inside a story this layout is not of,
+ * or one holding nothing — answers no fragments rather than a zero-sized box at the origin: a
+ * rectangle nothing painted is a rectangle a hit test would match.
+ */
+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 frame for one sheet, or undefined when this page does not carry one.
+ *
+ * `isFirstPageOfSection` is the SECTION's first page, not the document's: `w:display` is a
+ * section property, so in a three-section document a `firstPage` frame draws three times.
+ *
+ * The four rules close a rectangle rather than each spanning its own side. Word draws one box,
+ * and horizontal rules that stopped at the text column while the verticals sat outside it read
+ * as two rules with two detached bars beside them — the same thing `w:pBdr` gets right by
+ * spanning from the left rule's outer edge to the right rule's.
+ */
+declare function pageBorderFrame(borders: SectionPageBorders | undefined, geometry: PageGeometry, isFirstPageOfSection: boolean): PageBorderFrameRecord | undefined;
+
+/** 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. */
+    readonly top: number;
+    readonly height: number;
+}
+/**
+ * Which pages to build in detail.
+ *
+ * A page left out keeps its size and position but no content, so the document's height and page
+ * count are unchanged and scrolling to it reveals it rather than reflowing everything below.
+ */
+interface MaterializationInput {
+    readonly layout: SemanticLayout;
+    /** Omitted means "no viewport": everything is materialized, which is the honest default. */
+    readonly viewport?: ViewportWindow;
+    /** Extra pages kept ready either side of the visible band. */
+    readonly overscanPages?: number;
+    /** Pages that must be built wherever they are — caret, selection, a search hit. */
+    readonly pinnedPages?: Iterable<number>;
+}
+/**
+ * The page indices to build in detail.
+ *
+ * Returns indices rather than records so a caller can compare cheaply against what it
+ * already has mounted, and so the decision can be made without touching the layout.
+ */
+declare function pagesToMaterialize(input: MaterializationInput): Set<number>;
+
+/** Character border geometry from placed spans, shared by screen and export painters. */
+declare function runBorderStrokesForLine(line: LineRecord): readonly ParagraphBorderStrokeRecord[];
+
+/**
+ * `w:pPr/w:rPr/w:del` or `w:moveFrom` — a tracked revision REMOVES the paragraph mark.
+ *
+ * Both say the break goes away once the decision is taken: a deletion outright, a `moveFrom`
+ * because the paragraph left this place for another. Read from the paragraph-mark run
+ * properties only. A `w:del` anywhere else in the paragraph deletes run content, which is a
+ * different statement entirely.
+ */
+declare function paragraphMarkDeleted(paragraph: OoxmlNode): boolean;
+/**
+ * True when a tracked revision has removed this paragraph from the rendered document, so
+ * layout should emit no box for it at all.
+ */
+declare function revisionRemovesParagraph(paragraph: OoxmlNode, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): boolean;
+
+/**
+ * Fit complete leader advances to one shared horizontal grid.
+ *
+ * `startPt` is measured from the paper's left edge, or the local textbox frame.
+ * Offsets remain relative to the supplied gap. No glyph is clipped at either end,
+ * and lines in the same face share their dot columns regardless of preceding text.
+ * @public
+ */
+declare function tabLeaderPattern(startPt: number, widthPt: number, advancePt: number): {
+    readonly offsetPt: number;
+    readonly count: number;
+};
+
+/**
+ * Story-relative rule box for a measured separator span.
+ *
+ * Word paints `w:separator` as a strikeout stroke, so `stroke` carries the face's `OS/2`
+ * `yStrikeoutPosition` and `yStrikeoutSize` at the run's size. Without a resolved face the
+ * box keeps the legacy quarter-em offset and hairline thickness.
+ * @public
+ */
+declare function noteSeparatorRuleBox(span: StyleSpanRecord, line: LineRecord, stroke?: StrikeoutStrokePt): LayoutBox;
+
+export { AUTO_PREFERRED_WIDTH, AnchoredDrawingRecord, BlockFragmentRecord, CELL_PAD, COMPOUND_BORDER_MIN_GAP_PT, COMPOUND_BORDER_MIN_STROKE_PT, CaretGeometry, CellBorderBox, ContentControlBoundaryRecord$1 as ContentControlBoundaryRecord, DEFAULT_CANVAS_FONT_STACK, DEFAULT_CELL_MARGINS, DrawingInsets, DrawingPoint, FieldLinkProjector, FixedPoint, FixedPointRoundingMode, FontByteValidator, GRAPHEME_SEGMENTER_LOCALE, HARFBUZZ_SHAPING_LIBRARY, HarfBuzzShapingError, HyperlinkFieldSpec, HyperlinkProjector, InlineDrawingRecord, LayoutBox, LineRecord, MAX_EACH_PAGE_MARK_CANDIDATES, MAX_LVL_TEXT_LENGTH, MAX_MARKER_TEXT_LENGTH, MAX_NOTES_LAID_OUT, MAX_NOTE_FRAGMENTS, MAX_NOTE_OVERFLOW_PAGES, MAX_NOTE_REFLOW_ATTEMPTS, MAX_STYLE_BASED_ON_DEPTH, MAX_TABLE_COLUMNS, MAX_TABLE_NESTING, MAX_TABLE_ROW_FRAGMENTS, MAX_TABLE_ROW_HEIGHT_PT, NumberingIndex, NumberingLevel, PageBorderFrameRecord, PageGeometry, PageRecord, ParagraphBorderStrokeRecord, ParagraphFragmentRecord, RefFieldContext, ResolvedListItem, ReviewItem, RevisionAttribution, RevisionAuthorFilter, RevisionDisplayMode, SectionColumns, SectionPageBorders, SelectionRect, SemanticLayout, SemanticPosition, SemanticRootStoryKind, SemanticSelection, SemanticStoryKind, SemanticStoryVisit, ShapedRun, SourceRange, SpanLinkRecord, StrikeoutStrokePt, StyleCascadeTable, StyleSpanRecord, TableBorderBox, TableBorderSide, TableCellStyleFormatting, TablePaginationError, TextMeasurer, TextShaper, TextboxOwnerRecord, VersionedShapingLibrary, WORD_SEGMENTER_LOCALE, anchorLineY, attachNotesToLayout, boundedFallbackWordSegments, buildPageRefIndex, clampListValue, computeDoubleBorderMetricsPt, computeFootnoteReserves, contentControlAtSemantic, contentControlBoundaries, contentControlHoldingParagraph, contentControlRecordsInPart, createBoundedFallbackWordBoundary, createDefaultWordBoundary, createDocumentFurnitureSource, createDocumentLinkProjectors, createDocumentNotesInput, createDocumentStyleDependencies, createFieldLinkRegistry, createFixedMeasurer, createHarfBuzzTextShaper, createIntlWordBoundary, createLayoutScheduler, createLayoutSession, createListCounterState, createParagraphLayoutCache, defaultNoteSeparatorRuleStyle, deriveNoteDisplayMarks, deriveNoteDisplayMarksResolved, documentOrder, documentRelationshipTargetIn, effectiveBorderSide, emptyTocPlaceholderParagraphIds, emptyTocSuppressedResultParagraphIds, everyStoryOrder, expandLvlText, exportSourceRangeOf, filterRefsOnPage, findSeparatorNote, forEachSemanticSpan, formatDecimal, formatDecimalZero, formatLowerLetter, formatLowerRoman, formatNumFmt, formatPageNumber, formatUpperLetter, formatUpperRoman, fragmentOwnsAtomOffset, graphemeBoundaryEpoch, graphemeCount, graphemeOffsetToUtf16, harfBuzzFontValidator, hitTestSemantic, initializeHarfBuzz, intlGraphemeBoundary, isCanvasMeasurementAvailable, isCumulativeGeometryTrustedFromLineOrigin, isGeometryTrustedCaretOffset, isHarfBuzzInitialized, isIntlSegmenterAvailable, isIntlWordSegmenterAvailable, isMarkerOnlySeparatorNote, isWholeGraphemeHorizontalBoundary, keyedRangeRects, layoutHeaderFooterStory, layoutNoteById, layoutNoteSeparator, layoutNoteStory, layoutSemanticDocument, lineSegments, listMarkerBox, mapSymbolPuaText, normalNotesOf, noteDisplayMarkMap, noteLineIdPrefix, noteMarkKey, noteSeparatorAreaBox, noteSeparatorRuleBox, noteStoryBlocks, pageBorderFrame, pageRefPageNumbersFromLayout, pagesToMaterialize, paragraphLayoutKey, paragraphMarkDeleted, paragraphShading, paragraphShadingBox, parseAutonumInstruction, planRefFieldResultRefresh, positionPastDeletion, projectedNoteMarkText, provisionalNoteMarks, readTableStructure, resetGraphemeBoundary, resolveDefaultSurfaceMeasurer, resolveDefaultWordBoundary, resolveOoxmlShadingFill, resolveStrictHexFill, reviewAnchorIndex, reviewItemGeometry, revisionRemovesParagraph, roundFontUnitToFixedPoint, runBorderStrokesForLine, segmentGraphemes, segmentWords, selectionRects, semanticHorizontalBoundaries, setGraphemeBoundary, setHarfBuzzWasmUrl, sha256FontBytes, shadingFillFromElement, shapedHorizontalBoundaries, storyBlocks, syntheticSeparatorBox, tabLeaderPattern, tableOriginX, tocFieldChromeParagraphIds, tryCreateCanvasMeasurer, utf16OffsetToGrapheme, vectorShapeInkClip, walkStoryParagraphs, wordBoundary, wordSegmentsToGraphemeRecords };
+export type { AutofitFieldContext, AutonumFieldKind, AutonumFieldSpec, CanvasMeasurerOptions, CanvasTextContext, CanvasTextMetrics, CellMarginsPt, CellVerticalAlign, CompoundBorderMetrics, ContentControlFragmentRecord, CreateDocumentFurnitureSourceOptions, CreateDocumentNotesInputOptions, DocumentFurnitureSource, DocumentLinkProjectors, DocumentStyleDependencies, FieldLinkRegistry, GraphemeBoundary, GraphemeSegment, GraphemeWordSegmentRecord, HarfBuzzFaceCacheEvent, HarfBuzzOutlineCacheEvent, HarfBuzzShapeCacheEvent, HarfBuzzShapingErrorCode, HarfBuzzTextShaper, HarfBuzzTextShaperInstrumentation, HarfBuzzTextShaperOptions, HeaderFooterVariantName, KeyedRange, LayoutCacheStats, LayoutScheduler, LayoutSchedulerOptions, LayoutScope, LayoutSession, LayoutSessionStats, LineSegment, ListCounterAdvance, ListCounterState, MaterializationInput, NoteDisplayMark, NoteLayoutFallbackReason, NoteMarkContext, NotePaginationFallbackReason, NoteReferenceSite, NoteSeparatorLayout, NoteSeparatorRuleStyle, NoteStoryDrawings, NoteStoryLayout, NotesAttachResult, NotesLayoutInput, PageFurniture, PageRefIndex, ParagraphKeyInputs, ParagraphLayoutCache, ParagraphLayoutCacheOptions, PreferredWidth, PreferredWidthType, RefFieldRefreshOptions, RegisteredFieldLink, ResolvedSurfaceMeasurer, ReviewParagraphAnchor, SemanticLayoutOptions, SemanticSpanVisit, SemanticTableCell, SemanticTableRow, SemanticTableStructure, StoryProjectionDependencies, TableAlignment, TableAutofitContext, TablePaginationErrorCode, TableRowHeight, TableRowHeightRule, ViewportWindow, WordBoundary, WordBoundaryResolverDeps, WordSegment };