@docx-editor.dev/core 2.14.0 → 2.15.0

package/dist/semantic-records-92UnKeU_.d.ts

@@ -1,2821 +0,0 @@
-import { a as OoxmlNode, s as OoxmlProperty, g as OoxmlElement, O as OoxmlPart, x as ImageResourceState, U as DrawingAccessibility, S as SourceCrop, W as DrawingTransform, X as VectorShapeProjection, z as DrawingHorizontalReferenceFrame, A as DrawingVerticalReferenceFrame, u as ImageWrapTarget, Y as DrawingProjection, Z as OoxmlDrawingNode, _ as TableBorderStyle } from './tree-op-types-D6HzlPR4.js';
-import { b as RevisionAttribution } from './revision-projection-BeXVrSSV.js';
-import { O as OmmlEquationProjection } from './omml-equation-BY49UOIF.js';
-
-/**
- * Whether a paragraph must start a new page (`w:pageBreakBefore`).
- *
- * LAST WINS, like every other toggle read off the cascade (`paragraphKeeps` does the same
- * for `w:keepNext`). An any-wins `.some()` cannot be switched off: a Chapter or Heading style
- * carries `w:pageBreakBefore`, and Word writes `w:val="0"` on the one instance whose author
- * unchecked the box — that paragraph still broke, so the document grew a blank page and every
- * page number after it was wrong.
- *
- * An absent `w:val` is on (§17.17.4), and the off vocabulary is the whole of it — `off` is a
- * spelling too, which {@link isOn} beside this already accepts.
- */
-declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
-/**
- * Soft ceiling matching the spike's resolved-style limit (31_680 twips ≈ 22"). Beyond
- * that an attacker-authored spacing would push pagination into pathological page counts.
- */
-declare const MAX_PARAGRAPH_SPACING_PT: number;
-/** Soft ceiling on border width (96 eighths = 12pt). Word's UI tops out well below this. */
-declare const MAX_BORDER_WIDTH_PT = 12;
-/** Soft ceiling on border-to-text gap (`w:space`, already in points). */
-declare const MAX_BORDER_SPACE_PT = 3168;
-/**
- * A paragraph's resolved space before and after, in points.
- *
- * Already collapsed against `w:contextualSpacing`, so adjacent same-style paragraphs that suppress
- * their gap arrive here with it removed rather than leaving that to whoever stacks them.
- */
-interface ParagraphSpacing {
-    /** `w:spacing/@before`, in points. */
-    readonly before: number;
-    /** `w:spacing/@after`, in points. */
-    readonly after: number;
-}
-/**
- * The gap Word substitutes when `w:beforeAutospacing` / `w:afterAutospacing` is on
- * (ECMA-376 §17.3.1.33, the `w:spacing` clause both attributes belong to).
- *
- * The attribute means "the consumer decides", and the authored `@before` / `@after` beside it
- * is IGNORED rather than used as the value. Word's answer is HTML's default `<p>` margin,
- * 14pt, which is what a document round-tripped through Word's HTML filter carries — and this
- * one is everywhere, because Word writes `w:before="100" w:beforeAutospacing="1"` for it. Reading
- * only the literal 100 twips lays every such paragraph out 9pt tight, which moves page breaks.
- */
-declare const AUTO_PARAGRAPH_SPACING_PT = 14;
-/**
- * Where a paragraph sits, for the two contexts in which Word's auto spacing resolves to 0
- * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
- *
- * Both come from the HTML model the attribute emulates: a `<li>` and a `<td>` collapse the
- * paragraph margin, a bare `<p>` does not. A caller that says nothing gets the body answer.
- */
-interface ParagraphAutoSpacingContext {
-    /** The paragraph participates in numbering (`w:numPr`), i.e. it is a list item. */
-    readonly inList?: boolean;
-    /** The paragraph lives in a table cell. */
-    readonly inTableCell?: boolean;
-}
-/**
- * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
- *
- * `auto` is the interesting one: `@line` is 240ths of a line, so 240 is single, 360 is
- * one-and-a-half, 480 is double — and Word's own Normal style since 2013 is 259, i.e.
- * 1.08. A document laid out at a flat single spacing is ~8% tight on EVERY line, which
- * moves every page break, so this is not a cosmetic detail.
- *
- * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
- * does. `atLeast` uses it as a floor.
- */
-type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
-/**
- * Resolved line spacing: the rule, and the value it applies.
- *
- * `value` means different things per rule — 240ths of a line under `auto`, points under `exact`
- * and `atLeast` — which is why the two travel together and neither is useful alone.
- */
-interface ParagraphLineSpacing {
-    readonly rule: LineSpacingRule;
-    /** `auto`: the 240ths-of-a-line multiplier numerator. Otherwise points. */
-    readonly value: number;
-}
-/** Single spacing: what a paragraph that says nothing gets. */
-declare const SINGLE_LINE_SPACING: ParagraphLineSpacing;
-/**
- * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
- *
- * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
- * unbounded border width becomes a layout dimension.
- */
-interface ParagraphBorderEdge {
-    /** Authored `ST_Border` value (`single`, `dashed`, …). */
-    readonly val: string;
-    /** RRGGBB, or null when auto/missing (paint defaults to black). */
-    readonly color: string | null;
-    /** Border thickness in points (`w:sz` is eighths of a point). */
-    readonly widthPt: number;
-    /** Gap from text to the rule, in points (`w:space`). */
-    readonly spacePt: number;
-    /**
-     * `w:shadow` — Word offsets a drop shadow behind the rule.
-     *
-     * Present only when authored true, so an edge that says nothing keeps the shape earlier
-     * fixtures assert. Resolved and carried; drawing it is deferred.
-     */
-    readonly shadow?: true;
-}
-/** The six `CT_PBdr` children, in schema order (ECMA-376 §17.3.1.24). */
-declare const PARAGRAPH_BORDER_SIDES: readonly ["top", "left", "bottom", "right", "between", "bar"];
-/**
- * Which of the six `CT_PBdr` edges.
- *
- * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
- * consecutive paragraphs share a border definition.
- */
-type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
-/**
- * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
- *
- * `top`/`left`/`bottom`/`right` are the four physical edges of the box. The other two are
- * group-relative: `between` draws at a boundary INSIDE a run of consecutive paragraphs whose
- * border settings are identical, and `bar` is the vertical change-bar rule beside the
- * paragraph, drawn whether or not the paragraph groups with its neighbours.
- */
-interface ParagraphBorders {
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-    readonly between?: ParagraphBorderEdge;
-    readonly bar?: ParagraphBorderEdge;
-}
-/**
- * Resolve `w:spacing` before/after from flat paragraph properties.
- *
- * Line spacing (`w:line` / `w:lineRule`) is a separate concern — it changes measured line
- * height, not the gap between paragraphs — and is not resolved here.
- *
- * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
- * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
- */
-declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
-/**
- * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
- *
- * Merged per attribute for the same reason as before/after: `w:spacing` is one element
- * carrying independent attributes, and a style that states only `@line` must not reset the
- * rule an earlier entry in the cascade set.
- */
-declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
-/**
- * Apply resolved line spacing to a line's natural (glyph-derived) box.
- *
- * Word places `auto` / `atLeast` extras BELOW the line (the last line's multiple spacing
- * still separates it from the next paragraph). Putting that delta above inverted cover-page
- * rhythm: `w:line="460"` on "between" opened a large gap above the word and almost none
- * before "MERIDIAN". `exact` taller than the glyphs centers the text (ECMA-376 17.3.1.33).
- * An `exact` box smaller than the glyphs keeps the baseline inside so clipped text still
- * sits on it.
- */
-declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
-    height: number;
-    baseline: number;
-};
-/**
- * `w:contextualSpacing` (17.3.1.9): drop before/after between paragraphs of the SAME
- * style. Word's built-in `ListParagraph` sets it, so every list authored in Word gets a
- * paragraph gap between items without this.
- */
-declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
-/**
- * Resolve `w:pBdr` from the paragraph-properties node.
- *
- * Nested — every edge is a child of `pBdr`, not an attribute — so this reads the typed tree
- * rather than the flattened `OoxmlProperty[]` bag `propertiesOf` builds for leaf props.
- */
-declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
-/**
- * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
- *
- * Word does not merge edges across the cascade. A style that states only `w:bottom` discards
- * the box its `basedOn` ancestor declared, so folding edge by edge would leave a lone
- * underline surrounded by a box no one authored. Absence inherits; `nil`/`none` clear.
- */
-declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
-/**
- * Visual stroke thickness layout publishes for one edge (points).
- *
- * Compound `ST_Border` values (`double`, …) use the shared inflated band so a thin
- * `w:sz="3"` double still occupies a visible double-line box — matching table borders.
- */
-declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
-/**
- * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
- *
- * Vertically that is flow height — a top rule pushes the first line down, a bottom rule holds
- * the page open below the last one — so pagination has to see it. Horizontally it is
- * publish-only: Word draws left/right paragraph rules OUTSIDE the text column and never
- * re-breaks the lines, which is why adding a box to a paragraph in Word does not reflow it.
- */
-declare function paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
-/** Vertical extent a bottom border adds below the last line (gap + rule). */
-declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
-/**
- * Identity of a paragraph's border set, for the `w:between` group rule.
- *
- * Word treats consecutive paragraphs whose border settings are IDENTICAL as ONE bordered
- * block: the top rule draws above the first, the bottom rule below the last, and each
- * interior boundary gets `w:between` or nothing (§17.3.1.24). That is why applying a box to
- * three selected paragraphs in Word draws one box and not three.
- *
- * Empty string means "no borders", which never groups with anything.
- */
-declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
-/**
- * Gap to insert before a paragraph once the previous paragraph's `after` is already in the
- * flow cursor — Word takes the larger of the two rather than summing them.
- */
-declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
-/**
- * Applied before-spacing for placement (Word 2013+ / compat mode 15).
- *
- * Adjacent before/after still collapse to the larger gap, but before is dropped entirely when
- * the paragraph begins at the top of a page mid-section. The first paragraph of a document or
- * section retains before. Callers publish this applied value on the fragment so shading, borders,
- * selection, and paint share one geometry.
- */
-declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, firstParagraphOfSection: boolean): number;
-
-/** Soft ceiling matching Word's practical custom-tab UI limit. */
-declare const MAX_TAB_STOPS = 64;
-/**
- * Soft ceiling on a tab position (31_680 twips ≈ 22"), matching paragraph-spacing bounds so
- * a hostile stop cannot shove layout into pathological widths.
- */
-declare const MAX_TAB_POSITION_TWIPS = 31680;
-/** OOXML / Word default when `w:settings/w:defaultTabStop` is absent: 720 twips = 0.5". */
-declare const DEFAULT_TAB_INTERVAL_TWIPS = 720;
-/** The default tab interval in points — {@link DEFAULT_TAB_INTERVAL_TWIPS} converted. */
-declare const DEFAULT_TAB_INTERVAL_PT: number;
-/**
- * How a tab stop positions the text that follows it.
- *
- * Only `left` is a plain cursor jump. The other three size the tab glyph from the MEASURED
- * following segment, so its end, centre or decimal point lands on the stop.
- */
-type TabAlignment = 'left' | 'center' | 'right' | 'decimal';
-/**
- * `w:tab/@w:leader` (ECMA-376 §17.3.1.38, ST_TabTlc): the character repeated across the
- * space a tab reserves. `none` is the default and is represented by an absent leader.
- *
- * This is the difference between a Word table of contents and a column of headings floating
- * next to a column of page numbers, so it is carried through layout to paint rather than
- * dropped as a geometry-irrelevant attribute.
- */
-type TabLeader = 'dot' | 'hyphen' | 'underscore' | 'heavy' | 'middleDot';
-/**
- * The character each leader repeats (§17.3.1.38, ST_TabTlc).
- *
- * Lives with the type rather than with the painter because LAYOUT has to measure it: a
- * leader is the same character typed over and over, and the only way to space it the way
- * typing it would is to ask the measurer how wide it actually is.
- */
-declare const TAB_LEADER_GLYPH: ReadonlyMap<TabLeader, string>;
-/** One authored `w:tab`: where it sits, how it aligns, and what fills the gap. */
-interface TabStop {
-    /** Position from the paragraph content origin, in points. */
-    readonly positionPt: number;
-    readonly alignment: TabAlignment;
-    /** Absent for `none` — the schema default and the overwhelming majority of stops. */
-    readonly leader?: TabLeader;
-}
-/**
- * A paragraph's tab stops after the style cascade, with the default interval that applies past
- * the last explicit one.
- */
-interface ResolvedTabStops {
-    /** Custom stops sorted by ascending position. */
-    readonly stops: readonly TabStop[];
-    /** Default-tab interval in points (always positive and bounded). */
-    readonly defaultIntervalPt: number;
-}
-/** The frozen "no custom stops" value, so a paragraph without tabs mints no object. */
-declare const EMPTY_TAB_STOPS: ResolvedTabStops;
-/**
- * Resolve tab stops from cascaded `w:pPr` nodes (docDefaults → style chain → direct).
- *
- * Each `w:tabs` merges with `clear` support; absence inherits. The leader travels with the
- * stop that declared it — a `clear` at the same position discards both together.
- */
-declare function cascadedTabStops(paragraphPropertyNodes: readonly OoxmlNode[]): ResolvedTabStops;
-/** Direct `w:pPr` only — used when no style cascade table is present. */
-declare function paragraphTabStops(pPr: OoxmlNode | undefined): ResolvedTabStops;
-/**
- * Republish stops under a document-wide default-tab interval (`w:defaultTabStop`).
- *
- * The cascade resolves stops from the paragraph's own property chain, which cannot see
- * `settings.xml`; the interval is a document constant that arrives from the session. Returns
- * the input unchanged when nothing moves, so a cache-key fingerprint stays stable.
- */
-declare function withDefaultTabInterval(tabs: ResolvedTabStops, defaultIntervalPt: number | undefined): ResolvedTabStops;
-/**
- * Read `w:settings/w:defaultTabStop` (ECMA-376 §17.15.1.25), in points.
- *
- * Word's own interval, not a constant: a metric-locale template writes `w:val="1134"` (2cm)
- * and every default-interval tab in the document lands on that grid instead of the 0.5"
- * one. The value is FILE-DERIVED, so a non-integer, non-positive or out-of-range `val` falls
- * back to the schema default rather than being trusted into layout arithmetic.
- *
- * `ST_TwipsMeasure` also admits a universal measure (`"2cm"`); Word writes plain twips, and
- * the spelled form falls back to the default rather than being parsed here.
- */
-declare function defaultTabIntervalFromSettings(settings: OoxmlNode | null | undefined): number;
-/** Where one tab character lands: the resolved x, and the stop that decided it. */
-interface TabDestination {
-    readonly positionPt: number;
-    readonly alignment: TabAlignment;
-    /** Leader of the stop that was reached; absent for `none` and for default-interval tabs. */
-    readonly leader?: TabLeader;
-}
-/**
- * Next tab destination strictly past `currentX`, preferring custom stops then the default
- * interval. Destination is clamped to `rightEdge` so stops cannot escape the content box.
- */
-declare function nextTabDestination(tabs: ResolvedTabStops, currentX: number, rightEdge: number): TabDestination;
-/**
- * Width of a tab glyph so the following segment lands on the destination.
- *
- * `segmentWidth` / `decimalOffset` are already measured in points. Decimal offset is the
- * advance from the segment start to the decimal point (0 when none — treated like right).
- */
-declare function tabAdvanceWidth(alignment: TabAlignment, currentX: number, destinationX: number, segmentWidth: number, decimalOffset: number): number;
-/**
- * Stable fingerprint for layout cache keys — nested `w:tabs` are not in flat `OoxmlProperty`
- * bags, so style-inherited stops must be named explicitly or breaks would collide.
- */
-declare function tabStopsFingerprint(tabs: ResolvedTabStops): string;
-
-/**
- * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
- * within.
- *
- * The level is EXACT, not a direction: its parity gives direction, but the numeric value is what
- * reordering needs, and collapsing it early loses nested isolates.
- */
-interface BidiEmbeddingLevels {
-    readonly levels: Uint8Array;
-    readonly paragraphs: readonly {
-        readonly start: number;
-        readonly end: number;
-        readonly level: number;
-    }[];
-}
-
-/**
- * A face, as something asks for it: family plus the two axes this engine admits.
- *
- * Only static weights and slants. Variable-font axes are deliberately outside this vocabulary —
- * the shaper refuses variation axes, and a variable file admitted here would render bold at
- * regular weight.
- */
-interface FontRequest {
-    readonly family: string;
-    readonly weight: number;
-    readonly style: 'normal' | 'italic';
-}
-/**
- * A request that was answered by a DIFFERENT face than the one asked for.
- *
- * Recorded rather than silently applied, because a substitution changes measurement: it is part
- * of the shaping fingerprint, so a cached run shaped against a substitute is never reused for the
- * real face.
- */
-interface FontSubstitution {
-    readonly requested: FontRequest;
-    readonly resolved: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
-}
-declare const RESOLVED_FONT_BRAND: unique symbol;
-/**
- * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
- * a font.
- *
- * Branded, so a `ResolvedFont` cannot be constructed by an object literal. Holding one is proof
- * the checks ran — which is what lets shaping skip re-validating on every call.
- */
-interface ResolvedFont {
-    readonly [RESOLVED_FONT_BRAND]: true;
-    readonly id: string;
-    readonly identity: string;
-    readonly request: FontRequest;
-    readonly family: string;
-    /** Owned byte length, available without creating a defensive byte copy. */
-    readonly byteLength: number;
-    readonly bytes: Uint8Array;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly substitution: FontSubstitution | null;
-}
-/**
- * Largest single face this engine will ever admit, whatever a caller configures.
- *
- * A CEILING, not a default: a host may set a smaller `maxFontBytes`, but nothing can raise it
- * past this. Font bytes come from files, and an unbounded face is a memory-exhaustion vector.
- */
-declare const HARD_MAX_FONT_BYTES: number;
-/** Most faces one snapshot may hold, whatever a caller configures. */
-declare const HARD_MAX_FONT_SOURCES = 256;
-/** Most bytes all admitted faces may total, whatever a caller configures. */
-declare const HARD_MAX_AGGREGATE_FONT_BYTES: number;
-/**
- * Why a face was not admitted.
- *
- * `forbidden` and `hashMismatch` are adversarial signals rather than ordinary failures: the first
- * is a face the host declared off-limits, the second is bytes that are not what their source
- * claimed.
- */
-type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
-/**
- * A face that could not be admitted, carrying whatever evidence the refusal produced.
- *
- * RETURNED rather than thrown by `FontResourceSnapshot.resolve`, because a missing face is an
- * ordinary condition — layout falls back and carries on. It extends `Error` so a caller that
- * would rather throw can.
- */
-declare class FontResolutionError extends Error {
-    readonly name = "FontResolutionError";
-    readonly request: FontRequest;
-    readonly code: FontResolutionErrorCode;
-    readonly limit?: number;
-    readonly actual?: number;
-    readonly diagnostic?: string;
-    readonly expectedHash?: string;
-    readonly actualHash?: string;
-    constructor(code: FontResolutionErrorCode, request: FontRequest, details?: {
-        readonly limit?: number;
-        readonly actual?: number;
-        readonly diagnostic?: string;
-        readonly expectedHash?: string;
-        readonly actualHash?: string;
-    });
-}
-/**
- * One face offered to a snapshot, before admission.
- *
- * `hash` is checked against the bytes, so a source cannot claim a face it did not supply. Setting
- * `availability` to `forbidden` declares a face that exists but must not be used, which resolves
- * as a typed refusal rather than as "missing".
- */
-interface FontResourceDefinition {
-    readonly request: FontRequest;
-    readonly id: string;
-    readonly bytes: Uint8Array;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly availability?: 'available' | 'forbidden';
-}
-/**
- * A host-declared redirect: requests for `from` resolve to `to`.
- *
- * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
- * without the document being rewritten.
- */
-interface DeclaredFontSubstitution {
-    readonly from: FontRequest;
-    readonly to: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
-}
-/** Whether bytes parse as a usable font, with a diagnostic when they do not. */
-type FontValidationResult = {
-    readonly valid: true;
-} | {
-    readonly valid: false;
-    readonly diagnostic: string;
-};
-/**
- * The injected check that bytes really are a font.
- *
- * Injected because it is the shaper that knows — HarfBuzz can open a face and read its tables,
- * and this layer must not duplicate that judgement. Every byte reaching it is file input.
- */
-type FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;
-/**
- * An immutable set of admitted faces, and the only way to reach one.
- *
- * `epoch` identifies the snapshot: fonts change by REPLACING it, never by mutation, so a layout
- * pass holds one snapshot for its whole run and cannot observe a face appearing or vanishing
- * midway.
- */
-interface FontResourceSnapshot {
-    readonly epoch: number;
-    /** The admitted face, or a typed refusal. Never throws. */
-    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
-}
-/**
- * How a snapshot is built: which faces, under what limits, validated how.
- *
- * `maxFontBytes` is clamped to {@link HARD_MAX_FONT_BYTES} — a caller may tighten the budget but
- * never widen it past the engine's own ceiling.
- */
-interface FontResourceSnapshotOptions {
-    readonly epoch: number;
-    readonly maxFontBytes: number;
-    readonly resources: readonly FontResourceDefinition[];
-    readonly substitutions?: readonly DeclaredFontSubstitution[];
-    readonly validateFont: FontByteValidator;
-    readonly instrumentation?: FontResourceInstrumentation;
-}
-/**
- * Optional counters for the operations font admission is expected to do RARELY.
- *
- * Exists so tests can assert the absence of work: hashing and byte-copying a 64 MB face on every
- * resolve would not be visible in output, only in a stalled document, so the checks assert these
- * fire once rather than per call.
- */
-interface FontResourceInstrumentation {
-    readonly onOwnedByteCopy?: () => void;
-    readonly onHash?: () => void;
-    readonly onTableScan?: () => void;
-    readonly onAdmission?: () => void;
-}
-/**
- * The canonical string identifying one face request.
- *
- * Case- and whitespace-normalized, so `"Times New Roman"` and `"times new roman"` are one key —
- * a document may name a family either way and both must reach the same face.
- */
-declare const fontRequestKey: (request: FontRequest) => string;
-/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
-declare const boundedStructuralFontValidator: FontByteValidator;
-/**
- * Admit a set of faces and return the immutable snapshot layout resolves against.
- *
- * Admission is the trust boundary for font bytes: counts and sizes are checked against the hard
- * ceilings, each face's hash is re-derived and compared, and the bytes are handed to the injected
- * validator. A face failing any of these is recorded as a typed refusal rather than dropped, so
- * `resolve` can explain itself instead of answering "missing".
- */
-declare const createFontResourceSnapshot: (options: FontResourceSnapshotOptions) => FontResourceSnapshot;
-
-declare const FIXED_POINT: unique symbol;
-/** Fixed-point coordinates are safe integers in units declared by ShapingEnvironment.fixedPointScale. */
-type FixedPoint = number & {
-    readonly [FIXED_POINT]: true;
-};
-/**
- * Brand a safe integer as a {@link FixedPoint} coordinate.
- *
- * Fixed point rather than float throughout shaping so that two runs shaped identically compare
- * EQUAL — float accumulation would make the same text measure differently depending on how it was
- * split, and pagination is decided on those measurements.
- *
- * @throws RangeError when the value is not a safe integer.
- */
-declare const fixedPoint: (value: number) => FixedPoint;
-/** Which way a run reads. The parity projection of its bidi embedding level. */
-type TextDirection = 'ltr' | 'rtl';
-/** How fixed-point conversion breaks ties. Part of the shaping fingerprint. */
-type FixedPointRoundingMode = 'halfAwayFromZero' | 'halfToEven' | 'towardZero';
-/** Which Unicode normalization is applied before shaping, if any. */
-type NormalizationPolicy = 'none' | 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
-/**
- * The shaping library and its exact version.
- *
- * Versioned because a library upgrade can change glyph positioning, and a cached measurement
- * taken under the old one must not be reused under the new one.
- */
-interface VersionedShapingLibrary {
-    readonly name: string;
-    readonly version: string;
-}
-/**
- * Everything that determines how text shapes — the complete input to a
- * {@link ShapingEnvironment}.
- *
- * Exhaustive on purpose. Any field that could change a glyph's position belongs here, because the
- * environment's fingerprint is what decides whether a cached shaped run may be reused.
- */
-interface ShapingEnvironmentInput {
-    readonly font: ResolvedFont;
-    readonly variationAxes: Readonly<Record<string, number>>;
-    readonly shapingLibrary: VersionedShapingLibrary;
-    readonly unicodeDataVersion: string;
-    readonly normalization: NormalizationPolicy;
-    readonly script: string;
-    readonly language: string;
-    readonly direction: TextDirection;
-    readonly features: Readonly<Record<string, number>>;
-    readonly fallbackOrder: readonly ResolvedFont[];
-    readonly fixedPointScale: number;
-    readonly roundingMode: FixedPointRoundingMode;
-}
-/**
- * A validated {@link ShapingEnvironmentInput} — build one with `createShapingEnvironment`.
- *
- * Structurally identical to its input, but the nominal distinction is the point: holding one
- * means the tags, axes and fonts inside it have already been checked.
- */
-interface ShapingEnvironment extends ShapingEnvironmentInput {
-}
-/** One shaping call: the text, its size, its bidi level, and the environment to shape it in. */
-interface ShapeInput {
-    readonly text: string;
-    readonly fontSizeHalfPoints: number;
-    /** Exact UAX #9 embedding/isolate level; direction is its parity projection. */
-    readonly bidiLevel: number;
-    readonly environment: ShapingEnvironment;
-}
-/**
- * One positioned glyph.
- *
- * `id` is a glyph index in its FACE, not a character — a ligature is one glyph spanning several
- * characters, and a single character may produce several glyphs. Use `cluster` to get back to
- * text.
- */
-interface ShapedGlyph {
-    readonly id: number;
-    /** UTF-16 text offset identifying the cluster that produced this glyph. */
-    readonly cluster: number;
-    /** Pen origin before this glyph's shaping offsets, in fixed-point run coordinates. */
-    readonly originX: FixedPoint;
-    readonly originY: FixedPoint;
-    readonly advanceX: FixedPoint;
-    readonly advanceY: FixedPoint;
-    readonly offsetX: FixedPoint;
-    readonly offsetY: FixedPoint;
-    /** Exact monochrome outline returned by the admitted HarfBuzz face. */
-    readonly outline: GlyphOutline;
-}
-/** A glyph's outline as SVG path data, in font design units. */
-interface GlyphOutline {
-    readonly path: string;
-    /** Design units per em — divide by this to scale the path to a point size. */
-    readonly unitsPerEm: number;
-}
-/**
- * One cluster: the smallest indivisible text-to-glyph correspondence.
- *
- * The unit the CARET moves by. A cluster may be several characters (a ligature) or several glyphs
- * (a decomposed mark), so neither a character index nor a glyph index is a valid caret position —
- * `caretEdges` is, and it includes both endpoints.
- */
-interface ShapedCluster {
-    /** Half-open logical UTF-16 range in ShapedRun.text. */
-    readonly textStart: number;
-    readonly textEnd: number;
-    /** Half-open visual glyph range in ShapedRun.glyphs. */
-    readonly glyphStart: number;
-    readonly glyphEnd: number;
-    readonly advance: FixedPoint;
-    /** Fixed-point edges from this cluster's visual origin, including both endpoints. */
-    readonly caretEdges: readonly FixedPoint[];
-    /** Index into ShapedRun.fontSpans, preserving the exact fallback choice. */
-    readonly fontSpan: number;
-}
-/** A run's vertical metrics, from the face that shaped it. Drives line height and baseline. */
-interface ShapedVerticalMetrics {
-    readonly ascent: FixedPoint;
-    readonly descent: FixedPoint;
-    readonly lineGap: FixedPoint;
-}
-/**
- * A stretch of glyphs that came from ONE face.
- *
- * A run whose text needed fallback has several of these. Recording the exact face per span is
- * what lets a re-shape reproduce the same result rather than re-running fallback selection and
- * possibly choosing differently.
- */
-interface ShapedFontSpan {
-    readonly glyphStart: number;
-    readonly glyphEnd: number;
-    readonly font: ResolvedFont;
-    /** null denotes the primary font; otherwise this is the environment fallback-order index. */
-    readonly fallbackIndex: number | null;
-}
-/**
- * One shaped run: text turned into positioned glyphs, with everything needed to measure it, paint
- * it, and put a caret in it.
- *
- * The engine's measurement unit. Layout never measures characters — it measures these.
- */
-interface ShapedRun {
-    readonly text: string;
-    readonly direction: TextDirection;
-    readonly bidiLevel: number;
-    readonly glyphs: readonly ShapedGlyph[];
-    readonly clusters: readonly ShapedCluster[];
-    readonly fontSpans: readonly ShapedFontSpan[];
-    readonly metrics: ShapedVerticalMetrics;
-}
-/**
- * A {@link ShapedRun} reduced to the fields two shaping results must agree on to be considered
- * identical.
- *
- * Fonts appear as {@link FontFingerprintInputs} rather than whole `ResolvedFont` objects, so the
- * comparison is over VALUES and does not depend on object identity — which is what makes it work
- * across a reload or a worker boundary.
- */
-interface ShapedRunComparatorInputs {
-    readonly text: string;
-    readonly direction: TextDirection;
-    readonly script: string;
-    readonly language: string;
-    readonly bidiLevel: number;
-    readonly glyphs: readonly ShapedGlyph[];
-    readonly clusters: readonly ShapedCluster[];
-    readonly fontSpans: readonly {
-        readonly glyphStart: number;
-        readonly glyphEnd: number;
-        readonly fallbackIndex: number | null;
-        readonly font: FontFingerprintInputs;
-    }[];
-    readonly metrics: ShapedVerticalMetrics;
-}
-/**
- * The one thing layout needs from a shaping backend.
- *
- * Injected rather than imported, which is what keeps layout DOM-free and testable: a fixed-metric
- * shaper measures deterministically in a test, HarfBuzz measures for real in a browser, and
- * layout cannot tell the difference.
- */
-interface TextShaper {
-    shape(input: ShapeInput): ShapedRun;
-}
-/**
- * A font reduced to the values that identify it for fingerprinting.
- *
- * Includes the content `hash` and `faceIndex`, so two faces with the same family name but
- * different bytes fingerprint differently — which is what stops a cached measurement being reused
- * against a substituted face.
- */
-interface FontFingerprintInputs {
-    readonly identity: string;
-    readonly id: string;
-    readonly family: string;
-    readonly request: FontRequest;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly byteLength: number;
-    readonly substitution: FontSubstitution | null;
-}
-/**
- * A {@link ShapingEnvironment} reduced to comparable values.
- *
- * Records and axis maps become SORTED entry arrays, because two environments differing only in
- * key insertion order must fingerprint the same — otherwise a cache would miss on a difference
- * that changes no glyph.
- */
-interface ShapingEnvironmentFingerprintInputs {
-    readonly font: FontFingerprintInputs;
-    readonly variationAxes: readonly (readonly [string, number])[];
-    readonly shapingLibrary: VersionedShapingLibrary;
-    readonly unicodeDataVersion: string;
-    readonly normalization: NormalizationPolicy;
-    readonly script: string;
-    readonly language: string;
-    readonly direction: TextDirection;
-    readonly features: readonly (readonly [string, number])[];
-    readonly fallbackOrder: readonly FontFingerprintInputs[];
-    readonly fixedPointScale: number;
-    readonly roundingMode: FixedPointRoundingMode;
-}
-/**
- * Validate and freeze a shaping environment.
- *
- * Checks every field that could silently corrupt a measurement: OpenType tags must be four ASCII
- * bytes, script and language must be non-blank and control-character free, fonts must already be
- * validated. Throws rather than coercing — a bad tag that shapes anyway produces a document that
- * measures wrong everywhere and looks fine.
- *
- * @throws TypeError on a malformed tag, name, or axis value.
- */
-declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
-/**
- * Reduce an environment to its comparable form, with records sorted so key order cannot affect
- * the result.
- */
-declare const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
-/** Canonical serialization of every shaping variable, including byte hash and provenance. */
-declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
-/**
- * Validate and freeze a shaped run against the environment that produced it.
- *
- * Checks the internal consistency a shaper must satisfy: direction matches the environment,
- * cluster ranges tile the text without gaps or overlap, glyph ranges stay in bounds, font spans
- * cover every glyph, and caret edges are monotonic. A shaper that violates any of these produces
- * a caret that lands in the wrong place, which is far harder to diagnose downstream than here.
- *
- * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
- */
-declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
-/**
- * Reduce a shaped run to its comparable form, validating it on the way through.
- *
- * What the D9 determinism oracles compare: two shaping runs of the same text in the same
- * environment must produce byte-identical structures here.
- */
-declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
-
-/** `w:vertAlign` — script position, which also scales the run's effective size. */
-type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
-/** A resolved underline: its variant, and its colour when it does not follow the text. */
-interface ResolvedUnderline {
-    /** The authored `ST_Underline` variant. */
-    readonly variant: string;
-    /** RRGGBB, or null when the underline follows the text colour. */
-    readonly color: string | null;
-}
-/**
- * A run's character properties after the full cascade, in the units layout works in.
- *
- * Points rather than half-points, RRGGBB rather than theme references — everything already
- * resolved, so measurement and paint never re-run the cascade per glyph.
- */
-interface ResolvedRunStyle {
-    readonly fontFamily: string | null;
-    /**
-     * The `eastAsia` slot's typeface (`w:rFonts w:eastAsia`/`w:eastAsiaTheme`), or null when
-     * no level authors one.
-     *
-     * OOXML picks a run's face per SCRIPT: `fontFamily` covers the ascii/hAnsi slots, and
-     * ideographic/kana/hangul text resolves through this one instead. Kept beside — not
-     * folded into — `fontFamily`, because a mixed run needs both at once and the split into
-     * slot-homogeneous pieces happens downstream (`piecesOfParagraph`).
-     */
-    readonly fontFamilyEastAsia: string | null;
-    /** Points. `w:sz` is half-points, so 22 becomes 11. */
-    readonly fontSizePt: number;
-    /** RRGGBB, or null for the inherited/automatic colour. */
-    readonly color: string | null;
-    readonly bold: boolean;
-    readonly italic: boolean;
-    readonly underline: ResolvedUnderline | null;
-    readonly strike: boolean;
-    readonly doubleStrike: boolean;
-    /** An `ST_HighlightColor` name, or null. */
-    readonly highlight: string | null;
-    /**
-     * Character shading fill (`w:rPr/w:shd`), validated RRGGBB, or null.
-     *
-     * Paint applies this as the glyph-box background; a recognised highlight overrides it.
-     * Measurement ignores shading.
-     */
-    readonly shading: string | null;
-    readonly verticalAlign: VerticalAlign;
-    /** `w:position`, in points. Positive raises the baseline. */
-    readonly baselineShiftPt: number;
-    readonly caps: boolean;
-    readonly smallCaps: boolean;
-    /** `w:spacing`, in points. Added to every advance. */
-    readonly characterSpacingPt: number;
-    /** `w:w`, as a percentage. 100 is unscaled. */
-    readonly horizontalScalePercent: number;
-    /** `w:kern`, in points: the size at or above which kerning applies. 0 disables it. */
-    readonly kerningMinPt: number;
-    /**
-     * `w:vanish` (ECMA-376 §17.3.2.45): the run is hidden text.
-     *
-     * Word does not draw it AND does not paginate it — hidden index or comment text takes no
-     * space at all. So this cannot be a paint-time opacity: a hidden run that is still measured
-     * pushes every following line, and every following page break, to the wrong place. Layout
-     * drops the content instead (see `piecesOfParagraph`).
-     *
-     * `w:specVanish` (§17.3.2.36) is a different property — an always-hidden paragraph mark on
-     * a heading — and never sets this.
-     */
-    readonly hidden: boolean;
-}
-/** The style a run inherits when it authors nothing. */
-declare const DEFAULT_RUN_STYLE: ResolvedRunStyle;
-/**
- * The theme part's typefaces, for resolving `w:rFonts` theme attributes.
- *
- * Structurally identical to the binding lane's `DocumentThemeFonts` and assignable from it.
- * Declared here so this lane reads validated strings rather than the theme tree.
- */
-interface ThemeFonts {
-    /** `a:majorFont` latin typeface — headings. */
-    readonly major: string | null;
-    /** `a:minorFont` latin typeface — body text. */
-    readonly minor: string | null;
-    /** `a:majorFont` east asian typeface (`a:ea`) — headings. Optional for back-compat. */
-    readonly majorEastAsia?: string | null;
-    /** `a:minorFont` east asian typeface (`a:ea`) — body text. Optional for back-compat. */
-    readonly minorEastAsia?: string | null;
-}
-/**
- * Resolve one run's direct formatting.
- *
- * Unrecognised values are DROPPED rather than guessed: a `w:sz` of `"large"` leaves the
- * default size rather than inventing one, because a wrong measurement moves every glyph
- * after it and a missing one is visible immediately.
- *
- * `themeFonts` resolves `w:rFonts` theme references. Absent, a theme-only `rFonts` leaves
- * the family inherited — which is what every run of a theme-fonted document does, so the
- * whole document falls back to the surface default face.
- */
-declare function resolveRunStyle(props: readonly OoxmlProperty[], themeFonts?: ThemeFonts): ResolvedRunStyle;
-/** The text as it is DRAWN, after case transforms. Measurement must use this, not the source. */
-declare function displayText(text: string, style: ResolvedRunStyle): string;
-/** Measure run text the way layout breaks lines and paints glyphs (caps/small-caps aware). */
-declare function measureDisplayText(text: string, style: ResolvedRunStyle, measurer: TextMeasurer): number;
-/** Whether two resolved styles are identical, for span merging and cache keys. */
-declare function runStylesEqual(a: ResolvedRunStyle, b: ResolvedRunStyle): boolean;
-/**
- * How far a run's glyphs are lifted off the line's baseline, in points. Positive is up.
- *
- * Super and subscript move the GLYPHS without moving the run's box, so the box keeps tiling
- * the line and the selection band stays continuous. Anything drawing at the glyphs — the
- * painter, and the caret — has to apply this itself, and from one place, or the two drift.
- */
-declare function baselineShiftPtOf(style: ResolvedRunStyle): number;
-
-/**
- * Which `w:rFonts` slot a character resolves its face through.
- *
- * OOXML gives a run up to four faces and picks between them by SCRIPT, so one run of mixed Latin
- * and CJK text uses two different fonts without saying so anywhere in its properties.
- */
-type FontSlot = 'ascii' | 'hAnsi' | 'eastAsia' | 'cs';
-/**
- * A run of text sharing one script, direction and font slot — the unit handed to the shaper.
- *
- * Shaping cannot span a script change: Arabic and Latin in one call would produce wrong joining
- * behaviour, so a run is itemized into these first.
- */
-interface ScriptItem {
-    readonly from: number;
-    readonly to: number;
-    readonly direction: TextDirection;
-    readonly bidiLevel: number;
-    readonly script: 'Zyyy' | 'Latn' | 'Grek' | 'Cyrl' | 'Hani' | 'Hebr' | 'Arab' | 'Deva' | 'Beng' | 'Thai' | 'Khmr';
-    readonly slot: FontSlot;
-}
-/**
- * A code point whose script this engine does not itemize.
- *
- * Carries the offending `codePoint` so the caller can report which character stopped it, rather
- * than failing anonymously somewhere in the middle of a paragraph.
- */
-declare class UnsupportedScriptError extends Error {
-    readonly name = "UnsupportedScriptError";
-    readonly code = "unsupportedScript";
-    readonly codePoint: number;
-    constructor(codePoint: number);
-}
-/**
- * Split text into shapeable runs by script, bidi level and font slot.
- *
- * Consumes the bidi levels rather than re-deriving direction, so itemization and reordering agree
- * by construction instead of by two implementations happening to match.
- */
-declare function itemizeScriptFontSlots(text: string, paragraphOffset: number, embedding: BidiEmbeddingLevels): readonly ScriptItem[];
-/**
- * The style a piece's text is MEASURED AND PAINTED in, given the font slot it carries.
- *
- * This is the measurer-boundary resolution: pieces and spans keep the run's real resolved
- * style — with `fontFamily` and `fontFamilyEastAsia` both intact, so formatting readback
- * and the format painter see the run as authored — and every consumer that turns text into
- * geometry or ink resolves the face through here. The derived object is memoized per
- * (style, family) by {@link withFontFamily}, so measurers amortizing over style identity
- * keep their caches.
- */
-declare function styleForFontSlot(style: ResolvedRunStyle, slot: FontSlot | undefined): ResolvedRunStyle;
-
-type AllowlistedPageField = 'PAGE' | 'NUMPAGES' | 'SECTIONPAGES';
-/**
- * Which allowlisted page fields a header/footer story actually contains.
- *
- * Drives layout reuse: no fields → one baseline; NUMPAGES only → one layout per page count;
- * SECTIONPAGES only → one layout per section page count; PAGE (alone or combined) → per
- * distinct evaluated values with a bounded cache. Counts both complex markers and
- * `w:fldSimple` (including an allowlisted page field nested inside a non-page simple field).
- */
-interface StoryPageFieldNeeds {
-    readonly hasPage: boolean;
-    readonly hasNumPages: boolean;
-    readonly hasSectionPages: boolean;
-}
-
-/** One recognized REF instruction: the target name and the supported switches, nothing else. */
-interface RefFieldSpec {
-    readonly bookmark: string;
-    /** `r` / `w` paint the target's number; `n` the same without context; null the range text. */
-    readonly numberSwitch: 'r' | 'w' | 'n' | null;
-    /** `\h` parsed and inert — the reference paints; navigation is a follow-up. */
-    readonly hyperlink: boolean;
-}
-/**
- * Recognize `REF <bookmark> [\r|\w|\n] [\t] [\h] [\* MERGEFORMAT]` or
- * `NOTEREF <bookmark> [\h] [\* MERGEFORMAT]`, or null for anything else.
- *
- * The keyword matches case-insensitively; the bookmark name keeps its authored case (it is a
- * lookup key into a Map, never an object property, so hostile names like `__proto__` are just
- * names that resolve to nothing). Any unrecognized switch fails the parse so the field falls
- * back to its cached result — never the raw instruction, never a guess. NOTEREF's `\p`
- * (above/below position text) and `\f` (note-style formatting) are unrecognized on purpose.
- */
-declare function parseRefInstruction(raw: string): RefFieldSpec | null;
-
-/** Soft ceiling on abstractNum / num entries read from one part. */
-declare const MAX_NUMBERING_DEFINITIONS = 512;
-/** Soft ceiling on override entries per `w:num`. */
-declare const MAX_LVL_OVERRIDES = 9;
-/** `w:suff` — what separates a list marker from the text after it. */
-type ListSuffix = 'tab' | 'space' | 'nothing';
-/** `w:lvlJc` — how a list marker aligns within its own indent. */
-type ListMarkerAlign = 'left' | 'center' | 'right';
-/**
- * One level's indent, plus which parts the level actually AUTHORED.
- *
- * The provenance matters: `w:ind` cascades per-attribute, so a level that authored only `left`
- * must not overwrite an inherited `hanging` with a synthesized zero.
- */
-interface NumberingLevelIndent {
-    readonly left: number;
-    readonly right: number;
-    readonly hanging: number;
-    readonly firstLine: number;
-    /**
-     * Which of these the LEVEL actually authored.
-     *
-     * A level's `w:pPr/w:ind` sits between the paragraph style and direct formatting, so the
-     * merge has to tell "the level says left = 0" from "the level says nothing about left and
-     * the style's value stands". Absent (the default) reads as "says nothing", which is what a
-     * hand-built level in a test means.
-     */
-    readonly stated?: {
-        readonly left: boolean;
-        readonly right: boolean;
-        /** `w:hanging`/`w:firstLine` are one mutually exclusive slot (§17.3.1.10, §17.3.1.12). */
-        readonly firstLineOffset: boolean;
-    };
-}
-/** One `w:lvl`: how this depth numbers, what its marker looks like, and how it indents. */
-interface NumberingLevel {
-    readonly ilvl: number;
-    readonly start: number;
-    readonly numFmt: string;
-    readonly lvlText: string;
-    readonly lvlJc: ListMarkerAlign;
-    readonly suff: ListSuffix;
-    readonly indent: NumberingLevelIndent;
-    /**
-     * `w:lvlRestart` one-based trigger level, or `0` when the level never restarts.
-     * Omitted in XML → restart when the previous level (or any earlier level) is used.
-     */
-    readonly lvlRestart?: number;
-    /**
-     * `w:isLgl` (§17.9.9): render EVERY level referenced by this level's `w:lvlText` in
-     * decimal, whatever number format those levels declare for themselves.
-     */
-    readonly isLgl: boolean;
-    /** Level `w:rPr` as flat properties (for marker face / vanish). */
-    readonly runProperties: readonly OoxmlProperty[];
-    /** True when level run props request vanish — marker must not paint. */
-    readonly vanish: boolean;
-}
-/**
- * One `w:lvlOverride` on a `w:num`: a restart value, a replacement level, or both.
- *
- * How two lists share an abstract definition while numbering independently.
- */
-interface LevelOverride {
-    readonly startOverride?: number;
-    /** Full level replacement when `w:lvl` is present under the override. */
-    readonly level?: NumberingLevel;
-}
-/**
- * One `w:abstractNum` — the shape of a list, without being a list.
- *
- * Never referenced by a paragraph directly. Paragraphs name a {@link NumDefinition}, which names
- * one of these, so several lists can share a definition and still count separately.
- */
-interface AbstractNumDefinition {
-    readonly abstractNumId: string;
-    readonly levels: ReadonlyMap<number, NumberingLevel>;
-    /**
-     * `w:numStyleLink` (§17.9.21): this definition carries no levels of its own — the numbering
-     * lives on the named style. Word follows the link; resolve it with
-     * {@link resolveNumberingStyleLinks} before reading levels, or every paragraph on this
-     * abstract renders with NO marker at all.
-     */
-    readonly numStyleLink?: string;
-    /**
-     * `w:styleLink` (§17.9.23): the definition side of the same pair — this abstract IS the
-     * numbering of the named style. Kept so a link can be verified rather than assumed.
-     */
-    readonly styleLink?: string;
-}
-/**
- * One `w:num` — the thing a paragraph's `w:numId` actually names.
- *
- * Points at an {@link AbstractNumDefinition} and may override any of its levels.
- */
-interface NumDefinition {
-    readonly numId: string;
-    readonly abstractNumId: string;
-    readonly overrides: ReadonlyMap<number, LevelOverride>;
-}
-/**
- * The bounded projection of `numbering.xml` that list layout resolves against.
- *
- * Projection ONLY — never a mutation or serialization authority. Hostile values are dropped or
- * clamped, and a missing definition resolves to "no list" rather than a guess.
- */
-interface NumberingIndex {
-    readonly abstractNums: ReadonlyMap<string, AbstractNumDefinition>;
-    readonly nums: ReadonlyMap<string, NumDefinition>;
-}
-/**
- * Build a numbering index from the root of a numbering part (`w:numbering`).
- *
- * Empty / missing roots yield an empty index. Duplicate ids keep the first definition.
- */
-/**
- * Project `numbering.xml` into the bounded index.
- *
- * Every ceiling here exists because the input is file-derived: definition counts, override
- * counts, indent magnitudes and style-link hop depth are all capped, and nothing from the file
- * becomes a loop bound or an allocation size.
- */
-declare function buildNumberingIndex(root: OoxmlElement | null | undefined): NumberingIndex;
-/** Resolve the effective level for a `numId` + `ilvl`, applying overrides. */
-/**
- * The effective level for one paragraph's numbering reference, after overrides and style links.
- *
- * Answers null for a reference the index cannot resolve — a paragraph naming a definition the
- * file never declared is an unnumbered paragraph, not an error.
- */
-declare function resolveNumberingLevel(index: NumberingIndex, numId: string, ilvl: number): {
-    readonly abstractNumId: string;
-    readonly level: NumberingLevel;
-    readonly startOverride?: number;
-} | null;
-/** Empty index for tests / documents without numbering. */
-declare const EMPTY_NUMBERING_INDEX: NumberingIndex;
-
-interface DrawingPoint {
-    readonly x: number;
-    readonly y: number;
-}
-interface DrawingInsets {
-    readonly top: number;
-    readonly right: number;
-    readonly bottom: number;
-    readonly left: number;
-}
-type DrawingClipFallback = 'none' | 'unsupported-preset';
-interface DrawingGeometry {
-    readonly contentBounds: LayoutBox;
-    readonly paintBounds: LayoutBox;
-    readonly hitBounds: LayoutBox;
-    readonly transformedCorners: readonly DrawingPoint[];
-    readonly clipPolygon: readonly DrawingPoint[] | null;
-    readonly clipFallback: DrawingClipFallback;
-    readonly effectInsets: DrawingInsets;
-}
-
-/** Horizontal alignment of a paragraph (`w:jc`, ECMA-376 §17.3.1.13). */
-type Alignment = 'left' | 'center' | 'right' | 'both';
-
-/** Soft ceiling on `basedOn` chain length — enough for real templates, refuses hostile graphs. */
-declare const MAX_STYLE_BASED_ON_DEPTH = 32;
-/** Soft ceiling on style definitions read from one styles part. */
-declare const MAX_STYLE_DEFINITIONS = 4096;
-/** One `w:style` as the cascade reads it: its properties, and the style it is based on. */
-interface StyleDefinition {
-    readonly styleId: string;
-    readonly type: string;
-    readonly basedOn: string | null;
-    /**
-     * `w:next` — the style Word gives the paragraph that FOLLOWS one in this style.
-     *
-     * Nothing in layout reads it: it is a rule about authoring, not about painting. It is
-     * read here because this is the one place `styles.xml` is parsed, and a second reader
-     * would be a second answer to what a style id means.
-     */
-    readonly next: string | null;
-    readonly paragraphProperties: readonly OoxmlProperty[];
-    readonly runProperties: readonly OoxmlProperty[];
-    /** The style's `w:pPr` node, when present — needed for nested `w:pBdr`. */
-    readonly paragraphPropertiesNode: OoxmlElement | undefined;
-    /** The style's `w:tblPr`, for a `w:type="table"` style. */
-    readonly tablePropertiesNode: OoxmlElement | undefined;
-    /**
-     * `w:tblStylePr` conditional formats by `w:type` (`firstRow`, `band1Horz`, …).
-     *
-     * Word puts a table's real appearance here: `Table Grid` carries its grid in the style's
-     * `w:tblBorders`, and the banded/​header looks live in these. A document states only
-     * `<w:tblStyle w:val="TableGrid"/>`.
-     */
-    readonly conditionalTableFormats: ReadonlyMap<string, OoxmlElement>;
-}
-/**
- * The whole styles part, indexed and ready to resolve against.
- *
- * `cacheToken` is load-bearing: it folds into layout cache producers so breaks measured under one
- * styles part are never reused under another.
- */
-interface StyleCascadeTable {
-    /**
-     * Bounded fingerprint folded into layout cache producers so a different styles part cannot
-     * reuse breaks measured under another cascade. Computed once per table (FNV-1a hex).
-     */
-    readonly cacheToken: string;
-    readonly docDefaultsRun: readonly OoxmlProperty[];
-    readonly docDefaultsParagraph: readonly OoxmlProperty[];
-    readonly docDefaultsParagraphNode: OoxmlElement | undefined;
-    /** `w:style[@w:default='1'][@w:type='paragraph']` — last wins among defaults of that type. */
-    readonly defaultParagraphStyleId: string | null;
-    /** `w:style[@w:default='1'][@w:type='character']` — last wins among defaults of that type. */
-    readonly defaultCharacterStyleId: string | null;
-    /**
-     * `w:style[@w:default='1'][@w:type='table']` — last wins among defaults of that type.
-     *
-     * A `w:tbl` with no `w:tblStyle` still resolves against this one. Word's own
-     * `TableNormal` is where the 0/108/0/108 twip cell margins live, so skipping it gives
-     * every unstyled table padding the document says it does not have.
-     */
-    readonly defaultTableStyleId: string | null;
-    /**
-     * The theme part's typefaces, for `w:rFonts` theme references.
-     *
-     * Lives on the cascade because it is document-level style material with the same
-     * lifetime, and because every site that resolves run properties already holds this table.
-     */
-    readonly themeFonts: ThemeFonts;
-    readonly styles: ReadonlyMap<string, StyleDefinition>;
-}
-/**
- * A paragraph's properties after the cascade, plus the same list WITHOUT its own `w:pPr`.
- *
- * Both, because a writer needs to know what a paragraph INHERITS to decide whether setting a
- * value is a change or a no-op — and writing back an inherited value freezes it into the
- * paragraph as though the author had chosen it.
- */
-interface CascadedParagraphFormatting {
-    /** Flat paragraph properties in cascade order (defaults → bases → style → direct). */
-    readonly paragraphProperties: readonly OoxmlProperty[];
-    /**
-     * The same list WITHOUT the paragraph's own `w:pPr` — everything it inherits.
-     *
-     * Numbering needs the two tiers apart: a level's `w:pPr/w:ind` outranks the style's and is
-     * outranked by the paragraph's own, and a flattened list cannot say which is which.
-     */
-    readonly inheritedParagraphProperties: readonly OoxmlProperty[];
-    /** Matching `w:pPr` nodes for nested border resolution. */
-    readonly paragraphPropertyNodes: readonly OoxmlNode[];
-    /**
-     * Inherited run properties for CONTENT runs (before direct run `rPr`).
-     *
-     * Does NOT include direct `w:pPr/w:rPr` — that formats the paragraph MARK only
-     * (ECMA-376 §17.3.1.36). Folding mark `w:sz` into content made BodyText runs with no
-     * direct size paint at the mark's size (Selection Notice "or" alternative → 6.5pt).
-     */
-    readonly runProperties: readonly OoxmlProperty[];
-    /**
-     * Content cascade plus direct `w:pPr/w:rPr` — empty-line metrics and last-line mark height.
-     */
-    readonly markRunProperties: readonly OoxmlProperty[];
-    /**
-     * The style this paragraph resolved to, or null when it names none and there is no
-     * document default. `w:contextualSpacing` compares neighbours by exactly this.
-     */
-    readonly styleId: string | null;
-}
-/** Accepted style ids only — over-long, control-bearing, or dangerous keys are dropped. */
-declare function isValidStyleId(raw: string | undefined): raw is string;
-/**
- * What a table style contributes to the paragraphs of ONE cell: the style's whole-table
- * `w:pPr`/`w:rPr` followed by every `w:tblStylePr` the cell is under (17.7.6.6), weakest
- * first in the caller's condition order (banding, column, row, corner).
- *
- * This is how Word makes a header row bold and centred while the document states nothing
- * but `<w:tblStyle w:val="…"/>` on the table and plain runs in the cells.
- */
-interface TableCellStyleFormatting {
-    readonly paragraphProperties: readonly OoxmlProperty[];
-    /** Matching `w:pPr` nodes, for nested `w:pBdr` / `w:tabs` resolution. */
-    readonly paragraphPropertyNodes: readonly OoxmlElement[];
-    /** Inherited run properties for every run in the cell, before the paragraph style. */
-    readonly runProperties: readonly OoxmlProperty[];
-}
-/**
- * Build a cascade table from a styles part root.
- *
- * Only direct `w:style` children of the root participate (bounded count). Duplicate
- * `styleId` values keep the last definition, matching Word's reader for this fixture class.
- * Default paragraph/character style ids track `w:default="1"` with the same last-wins rule.
- */
-declare function buildStyleCascadeTable(stylesRoot: OoxmlElement | null, themeFonts?: ThemeFonts): StyleCascadeTable;
-/**
- * Cascade paragraph + inherited run properties for one paragraph's direct `w:pPr`.
- *
- * Order: `docDefaults` → table style → `basedOn` ancestors → paragraph style → direct
- * formatting, which is the style hierarchy of 17.7.2: a table style sits above the document
- * defaults and below the paragraph style a cell paragraph names for itself.
- * When `w:pStyle` is absent, the document's default paragraph style (`w:default="1"`) is used.
- * Direct formatting is last so it overrides inherited values inside the existing resolvers.
- */
-declare function cascadeParagraphFormatting(table: StyleCascadeTable, directPPr: OoxmlNode | undefined, tableCellStyle?: TableCellStyleFormatting): CascadedParagraphFormatting;
-/**
- * Bottom border after cascade: a later `w:pBdr` replaces an earlier one; absence inherits.
- * `nil`/`none` clear the edge via `paragraphBorders`.
- */
-declare function cascadedBottomBorder(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorderEdge | undefined;
-/**
- * Merge inherited paragraph-style run props with a run's direct `rPr` (direct last).
- *
- * When a cascade table is supplied, also resolves `w:rStyle` character styles (basedOn chain,
- * cycle/depth capped). Runs without an explicit `rStyle` pick up the default character style
- * (`w:default="1"`). Precedence: inherited → character style chain → direct formatting.
- *
- * PASS `inheritedRunProperties` BY IDENTITY. It must be an array
- * {@link cascadeParagraphFormatting} returned — `runProperties` or `markRunProperties` — and
- * not a copy of one. A toggle property (ECMA-376 §17.7.3) resolves per level of the style
- * hierarchy, and the levels below the character style resolve to more than a true or a false:
- * whether the document defaults' short circuit is still standing decides what the character
- * style's own toggle does next, and no single `w:b` element can spell that. The paragraph
- * cascade attaches that state to the array it returns, so spreading, filtering or sorting the
- * list drops it. (`Object.freeze` returns the same object, so that one is safe.) A list
- * without it is read as one ordinary level, which is the most a bare property list can say
- * and is what a caller assembling its own list gets.
- */
-declare function cascadeRunProperties(inheritedRunProperties: readonly OoxmlProperty[], directRunProperties: readonly OoxmlProperty[], table?: StyleCascadeTable): readonly OoxmlProperty[];
-/** Everything the line breaker needs about one paragraph, already cascaded and converted. */
-interface ParagraphLayoutInputs {
-    readonly props: OoxmlProperty[];
-    readonly indent: {
-        left: number;
-        right: number;
-        hanging: number;
-        firstLine: number;
-    };
-    readonly available: number;
-    readonly alignment: Alignment;
-    readonly spacing: ParagraphSpacing;
-    /** Resolved `w:line` / `w:lineRule`; single spacing where the cascade says nothing. */
-    readonly lineSpacing: ParagraphLineSpacing;
-    /** `w:contextualSpacing`: drop before/after between same-style neighbours. */
-    readonly contextualSpacing: boolean;
-    /** Resolved paragraph style id, for the `w:contextualSpacing` neighbour comparison. */
-    readonly styleId: string | null;
-    readonly bottomBorder: ParagraphBorderEdge | undefined;
-    /**
-     * Every `CT_PBdr` edge after cascade, not just the bottom one.
-     *
-     * `bottomBorder` stays alongside it because the fragment signature and the table flow
-     * read that field by name; this is the whole box, so a cell paragraph gets the same
-     * frame a body paragraph does.
-     */
-    readonly borders: ParagraphBorders;
-    /** Validated 6-hex paragraph shading fill from cascaded `w:pPr/w:shd`, absent for none. */
-    readonly shading: string | undefined;
-    readonly inheritedRunProperties: readonly OoxmlProperty[];
-    /**
-     * Paragraph-mark cascade (`inheritedRunProperties` + direct `w:pPr/w:rPr`).
-     * Empty-line sizing and last-line mark height — never content-run face.
-     */
-    readonly markRunProperties: readonly OoxmlProperty[];
-    /** Cascaded custom tab stops + default interval for paragraph-flow breaking. */
-    readonly tabStops: ResolvedTabStops;
-    /**
-     * Fingerprint folded into the paragraph layout cache key — nested `w:tabs` are absent
-     * from flat property bags, so style-inherited stops must be named explicitly.
-     */
-    readonly tabStopsCacheToken: string;
-    /** Resolved list marker inputs when the paragraph participates in numbering. */
-    readonly listItem?: ResolvedListItem;
-}
-/**
- * Resolve every paragraph input semantic layout / table cells share: cascaded props when a
- * style table is present, otherwise direct formatting only.
- *
- * When `listItem` is provided, its merged level indent becomes the paragraph indent (list
- * hanging / left from `numbering.xml`), which is what Word uses for fixture list paragraphs
- * that author no direct `w:ind`.
- *
- * `tableCellStyle` carries what the enclosing table's style says about this cell's
- * paragraphs; body paragraphs pass nothing.
- *
- * `inTableCell` is asked for separately because a cell paragraph may have no table style to
- * inherit at all, and `w:beforeAutospacing` still needs to know it is in a cell.
- */
-declare function resolveParagraphLayoutInputs(paragraph: OoxmlElement, contentWidth: number, styleCascade: StyleCascadeTable | undefined, listItem?: ResolvedListItem, tableCellStyle?: TableCellStyleFormatting, inTableCell?: boolean): ParagraphLayoutInputs;
-
-/**
- * A paragraph's list membership fully resolved: definition, level, marker text and geometry.
- *
- * `markerText` is already expanded through the counter state, so it is the string a reader sees
- * rather than the `w:lvlText` template.
- */
-interface ResolvedListItem {
-    readonly numId: string;
-    readonly ilvl: number;
-    readonly abstractNumId: string;
-    /** `w:numFmt` of the resolved level — `bullet` or a numbering format. */
-    readonly numFmt: string;
-    readonly markerText: string;
-    readonly markerAlign: ListMarkerAlign;
-    readonly suffix: ListSuffix;
-    /** Effective indent after merging level + paragraph indents, in points. */
-    readonly indent: NumberingLevelIndent;
-    readonly markerStyle: ResolvedRunStyle;
-    /** Fingerprint for layout cache keys (indent, marker text, marker face). */
-    readonly cacheToken: string;
-}
-/**
- * Read `w:numPr` from cascaded paragraph-property nodes (lowest precedence first).
- *
- * Flat `OoxmlProperty[]` bags drop nested `ilvl`/`numId`, so this walks the tree nodes
- * the same way borders and tabs do.
- *
- * `w:ilvl` and `w:numId` inherit INDEPENDENTLY through the style chain and the direct
- * `w:pPr` (§17.3.1.19): a tier stating only the level keeps the id it inherits — Word's
- * standard Heading2–Heading9 shape, where only Heading1 names the `w:num` — and a tier
- * stating only the id keeps the inherited level. Treating each `w:numPr` node as a full
- * replacement dropped the id at every level-only tier and unnumbered the paragraph. A
- * stated `w:numId w:val="0"` (or an invalid value) still switches numbering off at that
- * tier even when a lower tier set one; a higher tier stating a valid id re-enables. A
- * level-only tier with no id inherited from below resolves to no numbering.
- */
-declare function readNumPr(paragraphPropertyNodes: readonly OoxmlNode[]): {
-    numId: string;
-    ilvl: number;
-} | null;
-/**
- * Resolve `w:numStyleLink` delegation using the document's styles (§17.9.21).
- *
- * Without a style table there is nothing to follow, so the index is returned unchanged —
- * and so it is when nothing delegates, which keeps layout cache identity.
- */
-declare function withNumberingStyleLinks(index: NumberingIndex, styleCascade: StyleCascadeTable | undefined): NumberingIndex;
-/**
- * The effective indent of a list paragraph: STYLE, then the numbering LEVEL, then DIRECT.
- *
- * Word applies a level's `w:pPr/w:ind` between the paragraph style and the paragraph's own
- * formatting, per attribute — and the ordering matters on real documents. A converted
- * agreement numbers its `(a)` items with a level stating `left=1512 hanging=738` under a
- * `ListParagraph` style stating `left=775 hanging=624`, and states only `hanging="737"` on
- * the paragraph itself. Reading the flattened cascade as "the paragraph's indent" gave the
- * STYLE's 775 to a level that had overridden it, so every lettered sub-item hung a full
- * indent step to the left of where Word puts it.
- *
- * `inherited` is the cascade WITHOUT the paragraph's own `w:pPr` (defaults, table cell style,
- * style chain); `direct` is that `w:pPr` alone.
- */
-declare function mergeListIndent(levelIndent: NumberingLevelIndent, inherited: readonly OoxmlProperty[], direct?: readonly OoxmlProperty[]): NumberingLevelIndent;
-/**
- * Collect paragraphs of a block list in document order, descending into tables.
- *
- * Caps nesting so a hostile nested-table document cannot recurse without bound.
- */
-declare function walkStoryParagraphs(blocks: readonly OoxmlElement[], maxTableDepth?: number): OoxmlElement[];
-/**
- * Resolve every list paragraph in a story to a {@link ResolvedListItem}, keyed by node id.
- *
- * Non-list paragraphs are absent from the map. Hostile / missing numbering resolves inertly
- * (paragraph omitted — laid out as ordinary text).
- */
-declare function resolveStoryListItems(blocks: readonly OoxmlElement[], index: NumberingIndex, styleCascade: StyleCascadeTable | undefined, isFontAvailable?: (family: string) => boolean): ReadonlyMap<string, ResolvedListItem>;
-/**
- * Attach a full-story list-item map to layout options.
- *
- * Resolves once over `blocks` (body story including table cells) so counters continue across
- * section boundaries. No-ops when numbering is absent.
- */
-declare function withResolvedListItems<T extends {
-    readonly numberingIndex?: NumberingIndex;
-    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
-    readonly styleCascade?: StyleCascadeTable;
-    readonly isFontAvailable?: (family: string) => boolean;
-}>(options: T, blocks: readonly OoxmlElement[]): T & {
-    readonly numberingIndex: NumberingIndex;
-    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
-};
-/**
- * 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;
-
-/**
- * The story's resolved REF inputs for one layout pass.
- *
- * Threaded as a runtime rider on the layout options (see `layoutSemanticDocument`) rather
- * than a `SemanticLayoutOptions` member, so the public options surface stays put. Absent
- * means every REF field paints its cached result — the pre-existing degradation, and the one
- * header/footer and text-box stories still take. Note stories receive the body's context
- * through `NotesLayoutInput.refFields`.
- */
-interface RefFieldContext {
-    /**
-     * Content token over every PAINTED REF output in the story, for the section prepass memo.
-     * A renumbering edit can move a REF value in a section whose own blocks and list map are
-     * identity-unchanged, and this token is the only validator that sees it. A field that
-     * failed calibration contributes its (session-constant) cached text, so the token still
-     * moves exactly when painted output moves.
-     */
-    readonly valuesToken: string;
-    /** The paragraph's REF outputs folded for its block cache key; `''` when it holds none. */
-    tokenForParagraph(paragraphId: string): string;
-    /**
-     * The live value ONE field paints, keyed by its begin / `w:fldSimple` node id, or null to
-     * keep the cached result (failed calibration, unresolvable, or an anchor this scan never
-     * saw). Anchor-keyed so the projection's paint and this context's token fold read the SAME
-     * calibration verdict, however each walk collected the field's cached text.
-     */
-    liveValueOf(anchorId: string, spec: RefFieldSpec): string | null;
-    /**
-     * The synthesized display of ONE AUTONUM-family field, keyed by its begin / `w:fldSimple`
-     * node id, or null to paint nothing (unsupported switches, or an anchor this scan never
-     * saw — both the field's historical rendering). These fields carry no cached result at
-     * all, so there is no calibration: the sequential value is the only display they have.
-     * Optional so hand-built contexts predating it stay valid.
-     */
-    autonumValueOf?(anchorId: string): string | null;
-    /**
-     * The deferred projection of ONE `PAGEREF` field, or null to keep the cached result
-     * (missing bookmark, unsupported switches, or an anchor this scan never saw).
-     *
-     * A `PAGEREF` value is a property of pagination, so the scan cannot compute it — it hands
-     * the projection the resolved TARGET and the calibration inputs instead, and document
-     * finalize (`finalizePageFieldProjection`) substitutes the page number the target's first
-     * fragment lands on. Optional so hand-built contexts predating it stay valid.
-     */
-    pageRefProjectionOf?(anchorId: string, spec: RefFieldSpec): PageRefFieldProjection | null;
-}
-/**
- * Sticky calibration identity for one `PAGEREF` field.
- *
- * An opaque frozen object rather than a mutable verdict holder because span markers are
- * serialized into fragment signatures — a verdict written into the marker would move a
- * signature that no painted output moved. The verdict itself lives beside the finalize pass
- * (`field-page-furniture.ts`), keyed weakly on this object; the registry below carries the
- * object across passes the same way REF verdicts are carried.
- */
-type PageRefCalibrationCell = Readonly<Record<never, never>>;
-/**
- * What a `PAGEREF` span carries to document finalize: the resolved target, the normalized
- * authored cache (the calibration oracle), and the sticky calibration identity.
- */
-interface PageRefFieldProjection {
-    /** Canonical id of the paragraph the bookmark names — first declaration wins. */
-    readonly targetParagraphId: string;
-    /** The authored cached result, whitespace-collapsed — what the computed number must reproduce. */
-    readonly cached: string;
-    readonly calibration: PageRefCalibrationCell;
-}
-/**
- * Note parts whose stories join the context: their REF fields resolve against the body's
- * bookmarks and numbering (a footnote citing "Section 1.2(c)" targets a body paragraph),
- * and their bookmark declarations become plain-REF targets. Number switches aimed AT a
- * note paragraph still fall back to the cached result — the list map is the body's.
- */
-interface RefNoteParts {
-    readonly footnotesPart: OoxmlPart | null;
-    readonly endnotesPart: OoxmlPart | null;
-}
-/**
- * Resolve the document's REF fields for one layout pass, or null when it has none.
- *
- * Bookmarks and REF fields resolve across the body story and (when `notes` is given) the
- * footnote/endnote stories, against ONE shared target index — a footnote REF finds the
- * body bookmark it cites. Header/footer and text-box stories are not given a context and
- * keep painting cached results.
- */
-declare function resolveStoryRefFields(blocks: readonly OoxmlElement[], listItems: ReadonlyMap<string, ResolvedListItem> | undefined, notes?: RefNoteParts): RefFieldContext | null;
-
-/**
- * Why textbox story layout stopped short.
- *
- * Every one is a BOUND rather than a bug: nesting depth, fragment counts and the extent all
- * come from a file. Falling back with a reason keeps the drawing rendered (clipped) instead
- * of failing the layout pass.
- */
-type TextboxStoryFallbackReason = 'textbox-nesting-limit' | 'textbox-fragment-limit'
-/** Flowed content is taller than the extent; trailing fragments were dropped. */
- | 'textbox-height-clip';
-/**
- * One text box's story laid out inside its extent, in content-box-relative coordinates.
- *
- * Fragments origin at the content box's top-left; paint places the content box at
- * `drawing origin + contentOffset` and clips to the extent.
- */
-interface TextboxStoryLayout {
-    /** Content-box-relative fragments (origin at the content box's top-left). */
-    readonly fragments: readonly BlockFragmentRecord[];
-    /** Height the blocks flow to (points), before vertical anchoring. */
-    readonly flowHeight: number;
-    /** Offset of the content box inside the drawing extent: insets plus vertical anchoring. */
-    readonly contentOffset: Readonly<{
-        x: number;
-        y: number;
-    }>;
-    /** Content box width (extent minus horizontal insets). */
-    readonly contentWidth: number;
-    /** Content box height (extent minus vertical insets). */
-    readonly contentHeight: number;
-    /** Solid fill of the hosting shape, painted behind the story; null for no fill. */
-    readonly fillHex: string | null;
-    /** Solid outline of the hosting shape; null for no outline. */
-    readonly strokeHex: string | null;
-    /** Outline width in points; 0 when absent. */
-    readonly strokeWidthPt: number;
-    /** True when layout hit a named bound and returned a truncated / empty story. */
-    readonly fallbackReason?: TextboxStoryFallbackReason;
-    /**
-     * Resource identities of the drawings the clip DROPPED, in flow order.
-     *
-     * The furniture invalidation token walks laid-out records, and a dropped fragment leaves
-     * none — while a `withPageContext` projection of the same story can wrap differently
-     * (PAGE digits) and keep the drawing. Without this a picture clipped out of the baseline
-     * but painted by a projection never reaches the session context, so its decode settling
-     * moves nothing and the unchanged-pass early exit reuses the placeholder pages forever
-     * (#467). Absent when the clip dropped no drawings, so the common story keys byte-for-byte
-     * as before.
-     */
-    readonly clippedResourceToken?: string;
-}
-
-interface InlineDrawingRecord {
-    readonly kind: 'inlineDrawing';
-    readonly drawingNodeId: string;
-    readonly paragraphId: string;
-    readonly ownerPartName: string;
-    readonly start: number;
-    /** Left edge of the extent box (slot + distL). */
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-    readonly distL: number;
-    readonly distR: number;
-    readonly distT: number;
-    readonly distB: number;
-    /** Caret/hit advance start (slot left, before distL). */
-    readonly advanceStart: number;
-    /** Caret/hit advance end (slot + totalWidth). */
-    readonly advanceEnd: number;
-    readonly baselineOffset: number;
-    readonly paintBounds: LayoutBox;
-    readonly hitBounds: LayoutBox;
-    readonly geometry: DrawingGeometry;
-    readonly resource: ImageResourceState;
-    readonly accessibility: DrawingAccessibility;
-    /** Sanitized external hyperlink projection; inert until an explicit gesture activates it. */
-    readonly hyperlinkHref: string | null;
-    readonly effects: Readonly<{
-        readonly grayscale: boolean;
-        readonly brightness: number;
-        readonly contrast: number;
-    }>;
-    readonly crop: SourceCrop;
-    readonly transform: DrawingTransform;
-    /** Fixed non-picture graphic kind for refusal labels (`chart`, `group`, …); null for pictures. */
-    readonly placeholderGraphicKind: string | null;
-    /** Typed solid-geometry payload for a renderable `wps:wsp` shape; null otherwise. */
-    readonly vectorShape: VectorShapeProjection | null;
-    /**
-     * The revision wrappers enclosing the owning run, outermost first — the same stack spans
-     * carry, so paint and review chrome give a tracked picture the same cues as tracked text.
-     * Absent when the drawing is untracked.
-     */
-    readonly revisions?: readonly RevisionAttribution[];
-}
-interface InlineDrawingLayoutContext {
-    readonly ownerPartName: string;
-    /** Precomputed run-level atom id (`w:drawing` or MC wrapper) → projection. */
-    readonly projectionForAtom?: (atomNodeId: string) => DrawingProjection | null;
-    readonly project: (drawing: OoxmlDrawingNode) => DrawingProjection | null;
-    readonly resourceOf: (projection: DrawingProjection) => ImageResourceState;
-}
-/** Named fallback when a positioning frame cannot be resolved (OpenSpec 4.6). */
-type AnchoredDrawingLayoutFallback = 'unresolvable-frame' | 'page-defer-exhausted';
-interface AnchoredDrawingRecord extends Omit<InlineDrawingRecord, 'kind' | 'baselineOffset' | 'advanceStart' | 'advanceEnd' | 'distL' | 'distR' | 'distT' | 'distB'> {
-    readonly kind: 'anchoredDrawing';
-    readonly anchorParagraphId: string;
-    readonly horizontalFrame: DrawingHorizontalReferenceFrame;
-    readonly verticalFrame: DrawingVerticalReferenceFrame;
-    readonly horizontalFrameOrigin: number;
-    readonly verticalFrameOrigin: number;
-    readonly behindDocument: boolean;
-    readonly allowOverlap: boolean;
-    readonly layoutInCell: boolean;
-    readonly relativeHeight: number;
-    readonly wrap: Exclude<ImageWrapTarget, 'inline'>;
-    readonly layoutFallback?: AnchoredDrawingLayoutFallback;
-    /** Canonical document traversal index within the owner story part. */
-    readonly sourceOrder?: number;
-    /**
-     * Laid-out textbox story for a `wps:txbx` drawing; paint renders it clipped inside the
-     * extent instead of a placeholder. Absent when the drawing carries no story or the host
-     * did not thread story layout (the record then degrades to the placeholder path).
-     */
-    readonly textboxStory?: TextboxStoryLayout;
-}
-
-/**
- * One parsed `HYPERLINK` instruction: the raw, unsanitized pieces.
- *
- * `target` and `anchor` are verbatim from the instruction — the projector at the trust
- * boundary decides what, if anything, they become in a DOM sink.
- */
-interface HyperlinkFieldSpec {
-    /** The target as authored (first quoted or bare non-switch token), or null. */
-    readonly target: string | null;
-    /** `\l` — a bookmark name in this document, or null. */
-    readonly anchor: string | null;
-    /** `\o` — the hover tooltip, or null. */
-    readonly tooltip: string | null;
-}
-
-/**
- * What a piece says about the FIELD result it came from, for Word's shading.
- *
- * Carried from layout rather than decided at paint time because only the walk knows an atom was
- * a field at all — by paint the result is just text. Whether the shading is actually drawn is a
- * view decision made downstream, so this states the fact and nothing about the appearance.
- */
-interface FieldAtomMarker {
-    /**
-     * A legacy form field: `w:fldChar/w:ffData` (FORMTEXT, FORMCHECKBOX, FORMDROPDOWN).
-     *
-     * Word shades these on a different rule from ordinary fields — always, unless the document
-     * turns it off — because they mark the blanks somebody is meant to fill in.
-     */
-    readonly formField: boolean;
-    /**
-     * A BODY PAGE / NUMPAGES / SECTIONPAGES atom whose value depends on pagination.
-     *
-     * The paragraph walk cannot know which page the field lands on — layout runs before the page
-     * count — so it paints a placeholder and records the field's kind here. Document finalize
-     * (`substituteBodyPageFields`) reads this marker and substitutes the real value per page.
-     * Absent in headers/footers, which evaluate live through their own per-page projector.
-     */
-    readonly pageField?: {
-        readonly kind: AllowlistedPageField;
-        /** The field's `\#` numeric picture, applied when finalize substitutes the value. */
-        readonly picture?: string;
-    };
-    /**
-     * A BODY `PAGEREF` atom whose value is the page number its bookmark target lands on.
-     *
-     * Deferred exactly like {@link pageField}: the paragraph walk paints the field's cached
-     * result (or the placeholder digit when the file cached none) and records the resolved
-     * target here; document finalize substitutes the number of the page hosting the target's
-     * first fragment, gated per field on the calibration verdict.
-     */
-    readonly pageRef?: PageRefFieldProjection;
-}
-/** A half-open model-offset range, in the paragraph's own UTF-16 offset space. */
-interface ModelRange {
-    readonly start: number;
-    readonly end: number;
-}
-/**
- * How layout turns a typed `w:hyperlink` node into the sanitized record spans carry.
- *
- * Injected rather than computed here because resolving `r:id` needs the PACKAGE's
- * relationships and this module only ever sees one part's tree. `null` means the caller
- * declined to project — the runs still measure and paint, they simply carry no link, which is
- * the right degradation: text is never lost for want of a target.
- */
-type HyperlinkProjector = (link: OoxmlNode) => SpanLinkRecord | null;
-/**
- * How layout turns a parsed HYPERLINK field instruction into the sanitized record spans carry.
- *
- * Injected for the same reason as {@link HyperlinkProjector}: the spec's raw target must cross
- * the surface's ONE href trust boundary, and layout owns no sanitization policy. `null` means
- * no link — the cached result still paints as plain text, which is the right degradation.
- */
-type FieldLinkProjector = (spec: HyperlinkFieldSpec) => SpanLinkRecord | null;
-
-/** Test-only mutable counters; omitted by production call sites. Not package-public. */
-interface TableBorderGridResolveWork {
-    /** Sparse intervals emitted (not dense column slots). */
-    ownershipSlotsWritten: number;
-    columnLookups: number;
-}
-/** Shared remaining interval budget for nested table finalization in one layout. */
-interface TableBorderOwnershipBudget {
-    intervalsRemaining: number;
-}
-
-/** Which physical edge of a box a border sits on. */
-type TableBorderSideName = 'top' | 'right' | 'bottom' | 'left';
-/**
- * One border edge in one of three states.
- *
- * `omitted` and `none` are NOT the same: an omitted edge inherits from the table style or the
- * neighbouring cell, while an explicit `none` wins the conflict and draws nothing. Collapsing
- * them would let a style's border reappear where the author removed it.
- */
-type TableBorderSide = {
-    readonly state: 'omitted';
-} | {
-    readonly state: 'none';
-} | {
-    readonly state: 'edge';
-    readonly style: TableBorderStyle;
-    /** Validated RRGGBB, or null for auto/missing (paint defaults to black). */
-    readonly color: string | null;
-    /** Thickness in points (`w:sz` is eighths of a point). */
-    readonly widthPt: number;
-};
-/** A table's six authored border edges: four outer, plus the two interior intervals. */
-interface TableBorderBox {
-    readonly top: TableBorderSide;
-    readonly left: TableBorderSide;
-    readonly bottom: TableBorderSide;
-    readonly right: TableBorderSide;
-    readonly insideH: TableBorderSide;
-    readonly insideV: TableBorderSide;
-}
-/** The four resolved edges of one cell, after conflict resolution against its neighbours. */
-interface CellBorderBox {
-    readonly top: TableBorderSide;
-    readonly left: TableBorderSide;
-    readonly bottom: TableBorderSide;
-    readonly right: TableBorderSide;
-}
-/** Final edge winner; absent means the side/interval is not drawn. */
-interface ResolvedTableBorderEdge {
-    readonly style: TableBorderStyle;
-    readonly color: string | null;
-    readonly widthPt: number;
-}
-/**
- * Conflict winner over one grid interval of a cell side.
- *
- * `gridStart`/`gridEnd` are absolute grid column indices for horizontal sides and absolute
- * row indices for vertical sides (half-open). `startPt`/`endPt` are cell-local along-axis
- * positions in layout points.
- */
-interface ResolvedTableBorderEdgeSegment {
-    readonly side: TableBorderSideName;
-    readonly gridStart: number;
-    readonly gridEnd: number;
-    readonly startPt: number;
-    readonly endPt: number;
-    readonly edge: ResolvedTableBorderEdge;
-}
-/**
- * One published stroke rectangle in cell-local layout points.
- *
- * Paint multiplies x/y/width/height by scale and draws — no metrics, gaps, or corner math.
- */
-interface TableBorderStrokeRecord {
-    readonly side: TableBorderSideName;
-    readonly role: 'outer' | 'inner' | 'middle' | 'edge';
-    readonly color: string | null;
-    /** CSS keyword for this stroke (compound strokes are always solid). */
-    readonly cssStyle: 'solid' | 'dashed' | 'dotted';
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-/**
- * Layout-owned cell borders after conflict resolution and compound expansion.
- *
- * Convenience `top`/`left`/`bottom`/`right` are set when that side has a single uniform
- * full-span winner (existing consumers / CSS simple edges). Multi-interval winners live
- * only on `edgeSegments`. Compound geometry is always on `strokes`.
- */
-interface ResolvedCellBorders {
-    readonly top?: ResolvedTableBorderEdge;
-    readonly left?: ResolvedTableBorderEdge;
-    readonly bottom?: ResolvedTableBorderEdge;
-    readonly right?: ResolvedTableBorderEdge;
-    readonly edgeSegments?: readonly ResolvedTableBorderEdgeSegment[];
-    readonly strokes?: readonly TableBorderStrokeRecord[];
-}
-/** Soft cap on published stroke rectangles per cell (security / pathological spans). */
-declare const MAX_TABLE_BORDER_STROKES = 256;
-/** Read one OOXML border child into the three-state model. */
-declare function readBorderSide(node: OoxmlElement | undefined): TableBorderSide;
-/**
- * Read a table's `w:tblBorders`, dropping or clamping hostile values.
- *
- * Widths and colours come from a file: an out-of-range `w:sz` becomes a layout dimension, so it is
- * bounded here rather than downstream.
- */
-declare function readTableBorders(tblPr: OoxmlElement | undefined): TableBorderBox;
-/** Read one cell's `w:tcBorders`, under the same bounds {@link readTableBorders} applies. */
-declare function readCellBorders(tcPr: OoxmlElement | undefined): CellBorderBox;
-/**
- * Conflict weight: the authored width in eighths of a point, and nothing else.
- *
- * Word-matching, not conformance — §17.4.39 (`w:tblBorders`) and §17.4.66 (`w:tcBorders`)
- * describe the elements and specify no conflict algorithm. Word picks the heavier RULE, so
- * a 6pt dashed rule beats a hairline single. Folding the style rank into the weight (an
- * `sz × border-number` product) made a 0.5pt double outrank a 1pt single and made every
- * dashed or dotted rule weigh 1 regardless of `w:sz`, which erased its width entirely.
- */
-declare function borderWeight(side: TableBorderSide): number;
-/**
- * Pick the winner between two candidates on a shared grid line (zero cell spacing).
- *
- * `none` loses to any edge; two `none`/omitted yield omitted (no paint). Width decides;
- * equal widths rank by style, then prefer the darker color, then `preferFirst`
- * (reading-order / first candidate).
- */
-declare function resolveBorderConflict(first: TableBorderSide, second: TableBorderSide, preferFirst?: boolean): TableBorderSide;
-interface BorderGridCell {
-    readonly gridColumn: number;
-    readonly gridSpan: number;
-    readonly vMergeContinue: boolean;
-    readonly borders: CellBorderBox;
-    /** Set on restart cells that visually span into later rows. */
-    readonly mergeRowSpan?: number;
-}
-/**
- * The absolute grid a table's borders are drawn on: column widths, and per-row tops and heights.
- *
- * Shared by every edge so adjacent cells resolve to the SAME line, rather than each computing its
- * own and leaving a hairline gap between them.
- */
-interface BorderGridGeometry {
-    /** Absolute column widths for the whole table (points). */
-    readonly columnWidthsPt: readonly number[];
-    /**
-     * Per laid-out row: absolute top and height in the same coordinate space as cell boxes
-     * (only relative differences matter for vertical edge segmentation).
-     */
-    readonly rowBands: readonly {
-        readonly y: number;
-        readonly height: number;
-    }[];
-    /** Per laid-out cell: width/height after vMerge expansion (cell-local stroke space). */
-    readonly cellBoxes: readonly (readonly {
-        readonly width: number;
-        readonly height: number;
-    }[])[];
-}
-/**
- * Resolve borders for every cell in a laid-out table fragment.
- *
- * Shared vertical edges: conflict(left.right, right.left) → assigned to the left cell,
- * segmented per row when a vMerge restart faces differing neighbors.
- * Shared horizontal edges: conflict(above.bottom, below.top) → assigned to the above cell,
- * segmented per grid column when a gridSpan cell faces differing below neighbors; vMerge
- * interior seams are suppressed per interval.
- *
- * When `geometry` is provided, compound edges expand into explicit stroke records with
- * corner-adjusted endpoints in cell-local points.
- */
-declare function resolveTableCellBorderGrid(rows: readonly (readonly BorderGridCell[])[], table: TableBorderBox, columnCount: number, geometry?: BorderGridGeometry, work?: TableBorderGridResolveWork, ownershipBudget?: TableBorderOwnershipBudget): ResolvedCellBorders[][];
-/** Width contribution of a resolved edge for content inset / row sizing. */
-declare function borderExtentPt(edge: ResolvedTableBorderEdge | TableBorderSide | undefined): number;
-
-interface EquationGeometryBase {
-    readonly box: LayoutBox;
-    /** Baseline measured from this node's top edge. */
-    readonly baseline: number;
-}
-interface EquationTextGeometry extends EquationGeometryBase {
-    readonly kind: 'text' | 'fallback';
-    readonly text: string;
-    readonly fontSizePt: number;
-}
-interface EquationRowGeometry extends EquationGeometryBase {
-    readonly kind: 'row';
-    readonly items: readonly EquationGeometry[];
-}
-interface EquationFractionGeometry extends EquationGeometryBase {
-    readonly kind: 'fraction';
-    readonly numerator: EquationGeometry;
-    readonly denominator: EquationGeometry;
-    readonly bar: LayoutBox;
-}
-interface EquationRadicalGeometry extends EquationGeometryBase {
-    readonly kind: 'radical';
-    readonly sign: EquationTextGeometry;
-    readonly radicand: EquationGeometry;
-    readonly degree?: EquationGeometry;
-    readonly bar: LayoutBox;
-}
-interface EquationScriptGeometry extends EquationGeometryBase {
-    readonly kind: 'script';
-    readonly base: EquationGeometry;
-    readonly subscript?: EquationGeometry;
-    readonly superscript?: EquationGeometry;
-}
-interface EquationNaryGeometry extends EquationGeometryBase {
-    readonly kind: 'nary';
-    readonly operator: EquationTextGeometry;
-    readonly body: EquationGeometry;
-    readonly lowerLimit?: EquationGeometry;
-    readonly upperLimit?: EquationGeometry;
-}
-type EquationGeometry = EquationTextGeometry | EquationRowGeometry | EquationFractionGeometry | EquationRadicalGeometry | EquationScriptGeometry | EquationNaryGeometry;
-/** Equation metadata carried by one atomic semantic span. */
-interface EquationSpanRecord {
-    readonly sourceNodeId: string;
-    readonly geometry: EquationGeometry;
-    readonly fallbackText: string;
-    readonly truncated: boolean;
-}
-/** Compose one bounded OMML projection into paint-ready point geometry. */
-declare function layoutEquation(projection: OmmlEquationProjection, measurer: TextMeasurer, style: ResolvedRunStyle): EquationSpanRecord;
-
-/** A half-open UTF-16 range inside one paragraph, addressed by its canonical node id. */
-interface SourceRange {
-    readonly paragraphId: string;
-    readonly start: number;
-    readonly end: number;
-}
-/**
- * A rectangle in layout POINTS.
- *
- * Points everywhere in this layer — twips convert at property-read boundaries and CSS pixels at
- * paint. A box carrying either of those would eventually be added to one carrying the other.
- */
-interface LayoutBox {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-/**
- * A bottom paragraph border as layout published it.
- *
- * `box` is the rule's geometry in the same coordinate space as the fragment (page-content
- * relative). Paint positions from this box and MUST NOT remeasure the border.
- */
-interface ParagraphBottomBorderRecord {
-    readonly edge: ParagraphBorderEdge;
-    readonly box: LayoutBox;
-}
-/**
- * One `w:pBdr` rule as layout published it.
- *
- * `box` is the STROKE rectangle in the same coordinate space as the fragment, so paint sets a
- * position and a colour and nothing else. It matters that paint cannot derive these itself:
- * Word draws the side rules OUTSIDE the text column, so `box.x` on a `left`/`bar` stroke is
- * left of the fragment box and a painter reasoning from the fragment alone would put it
- * inside the text.
- */
-interface ParagraphBorderStrokeRecord {
-    readonly side: ParagraphBorderSide;
-    readonly edge: ParagraphBorderEdge;
-    readonly box: LayoutBox;
-}
-/**
- * The hyperlink a span sits inside, as layout resolved it.
- *
- * Already SANITIZED: `href` is the runtime projection produced once at the trust boundary,
- * and `null` means the link is inert — a refused scheme, or a relationship the package does
- * not declare. Paint, hit-testing and the popover consume this and never the authored target,
- * so there is exactly one place a file-derived URL becomes something a browser can follow.
- *
- * `id` is the `w:hyperlink` node's canonical id, which is what makes the spans of one link
- * recognisable as one link across the several lines it wraps onto — and what an unlink or a
- * retarget addresses.
- */
-interface SpanLinkRecord {
-    readonly id: string;
-    readonly kind: 'external' | 'internal' | 'unresolved';
-    /** Sanitized runtime projection: an absolute URL, `#anchor`, or null when inert. */
-    readonly href: string | null;
-    /** Bookmark name for an internal link, so navigation need not re-parse the fragment. */
-    readonly anchor?: string;
-    /** `w:tooltip` — paint puts it on the anchor's `title`. */
-    readonly tooltip?: string;
-}
-/** A run of text on one line sharing identical resolved formatting. */
-interface StyleSpanRecord {
-    readonly range: SourceRange;
-    readonly text: string;
-    /** The run's authored properties, retained as evidence. */
-    readonly props: readonly OoxmlProperty[];
-    /**
-     * The same properties RESOLVED — one unit system, defaults applied.
-     *
-     * Carried on the span so the measurer, the span and the painter all read one resolution
-     * rather than each deriving its own. Two derivations that disagree by a fraction of a
-     * point put the caret where no glyph is.
-     */
-    readonly style: ResolvedRunStyle;
-    /**
-     * The `w:rFonts` slot this span's text resolves its face through; absent means the base
-     * (ascii/hAnsi) slots. {@link style} stays the run's full resolution — with both
-     * `fontFamily` and `fontFamilyEastAsia` — so formatting readback and the format painter
-     * see the run as authored; measurement, paint and hit-testing resolve the effective face
-     * with `styleForFontSlot(span.style, span.fontSlot)`.
-     */
-    readonly fontSlot?: FontSlot;
-    readonly box: LayoutBox;
-    /**
-     * Cumulative advances from {@link box}.x to each UTF-16 caret boundary in {@link text}.
-     *
-     * Length is `text.length + 1` (both endpoints). When PRESENT, these are the interaction
-     * authority: hit-testing and the caret read them instead of re-measuring. Layout does not
-     * publish them eagerly — measuring every character of every laid span dominated page
-     * repagination — so interactions measure prefixes on demand through the same measurer the
-     * span was laid with (memoized per span; see `prefixWidth` in semantic-hit-test.ts), and
-     * only interpolate across {@link box}.width when no measurer is supplied.
-     */
-    readonly caretEdges?: readonly number[];
-    /**
-     * `w:tab/@w:leader` of the stop a `\t` span advanced to (ECMA-376 §17.3.1.38).
-     *
-     * Only ever set on a tab span, and only for a non-`none` leader. Paint repeats the glyph
-     * across the advance THIS box already reserved — the leader adds no width of its own, so
-     * it can never move the text that follows it.
-     */
-    readonly tabLeader?: TabLeader;
-    /**
-     * Advance of ONE leader glyph in this run's face, in points, measured by layout.
-     *
-     * Paint cannot ask a font how wide a character is, so without this it had to guess and
-     * deliberately overfill, leaving the dots at whatever spacing an over-long string
-     * happened to produce. Measured, the leader is spaced exactly as the same character
-     * typed there would be — which is what Word draws.
-     */
-    readonly tabLeaderAdvancePt?: number;
-    /**
-     * The hyperlink this span belongs to, or absent for ordinary text.
-     *
-     * Carried on the SPAN rather than looked up at paint time because a link that wraps
-     * produces one set of spans per line, and paint has no paragraph to walk — only the line
-     * it was handed.
-     */
-    readonly link?: SpanLinkRecord;
-    /**
-     * Horizontal jump, in points, that a floating object's wrap zone forced before this span.
-     *
-     * A line that resumes on the far side of a float is still ONE line: its spans keep running
-     * model offsets and share a selection band. Only layout knows the jump is an obstacle
-     * rather than justification slack, so it publishes it here. Paint reserves it with an inert
-     * advance and excludes it from the word spacing it reconstructs — inferring the difference
-     * from the gap alone spread the float's whole width across every space on the line.
-     */
-    readonly wrapAdvanceBefore?: number;
-    /**
-     * The revision wrappers this text sits inside, outermost first, absent when untracked.
-     *
-     * Carried on the span for the same reason `style` is: paint and the review surface must read
-     * ONE attribution. A sidebar that re-derived which revision covers a span by walking the tree
-     * could disagree with what was painted, and the card would point at the wrong text.
-     */
-    readonly revisions?: readonly RevisionAttribution[];
-    /**
-     * Present when this span is a field's displayed RESULT, for the shading Word draws under one.
-     *
-     * `projected` cannot answer this: it is also set for note marks and inline drawings, so it
-     * says "layout owns these glyphs" rather than "this is a field". Word shades legacy form
-     * fields on a different rule from ordinary ones, which is why the marker distinguishes them.
-     *
-     * States the FACT, never the appearance — whether shading is drawn is a view decision, made
-     * downstream from a host option and the document's own `w:doNotShadeFormData`. Deciding it
-     * here would put the caret into layout's cache key and repaginate on every arrow press.
-     */
-    readonly fieldAtom?: FieldAtomMarker;
-    /**
-     * Live PAGE/NUMPAGES/SECTIONPAGES projection (layout-time evaluated text).
-     *
-     * Computed substitutions are not model-editable: paint treats these as atomic furniture
-     * and selection mapping refuses them the way it refuses markers.
-     */
-    readonly projected?: boolean;
-    /** Paint-ready geometry for one atomic Office Math equation. */
-    readonly equation?: EquationSpanRecord;
-    /**
-     * Footnote/endnote navigation metadata for projected note atoms.
-     *
-     * Paint tags body citations (`to-note`) and note-body marks (`to-body`) so React chrome
-     * can jump without owning layout logic.
-     */
-    readonly noteNav?: {
-        readonly scopeId: string;
-        readonly direction: 'to-note' | 'to-body';
-    };
-}
-/**
- * One laid-out line: its geometry, its baseline, and the styled spans it renders.
- *
- * The unit hit-testing and caret placement resolve against. Geometry comes from HERE, never from
- * the DOM, which is what lets an empty paragraph still get a caret.
- */
-interface LineRecord {
-    readonly id: string;
-    readonly range: SourceRange;
-    readonly spans: readonly StyleSpanRecord[];
-    readonly box: LayoutBox;
-    /**
-     * Where the line's content actually starts, after alignment and the first-line indent.
-     *
-     * {@link box} is the content BAND the line was broken against — its `x` is the indented
-     * column edge and its `width` the available measure, neither of which moves with
-     * `w:jc`. Alignment is otherwise expressed only as x offsets on the span boxes, so a line
-     * with no spans (an empty paragraph) had no aligned origin at all: paint, hit testing and
-     * the caret each fell back to `box.x` and drew a centred empty paragraph's caret hard
-     * against the left margin, where it stayed until the first character was typed.
-     *
-     * Equal to the first span's x whenever there is one, so it is the single origin every
-     * consumer can read without a spans-or-box fallback of its own.
-     */
-    readonly contentX: number;
-    /** Distance from the line box top to the text baseline. */
-    readonly baseline: number;
-    /**
-     * Space ABOVE the glyph band inside {@link box} (exact centering, not auto/atLeast).
-     *
-     * `auto` / `atLeast` extras grow the box BELOW the glyphs — paint puts that depth in
-     * padding-bottom. {@link baseline} is measured from the line top and already includes
-     * this above-band when present.
-     *
-     * Published by layout rather than recovered by paint: three paint sites each deriving it
-     * separately is how they came to disagree about where a line's text sits.
-     */
-    readonly leading: number;
-    /**
-     * Auto/atLeast line-spacing depth BELOW the glyph band, inside {@link box}.
-     *
-     * The complement of {@link leading}: exact spacing centres the glyphs and moves the
-     * baseline down, while auto/atLeast leave the band at the top and grow the box beneath it.
-     * So the band a consumer needs is `box.height - trailingSpacing - leading`, and
-     * subtracting `leading` alone is right only under the exact rule.
-     *
-     * A line WITH spans carries its band in the span heights too. An empty paragraph carries
-     * nothing, which is why the caret, paint's `padding-bottom` and the content-control
-     * boundary all need this published rather than recovered from the box.
-     *
-     * Zero under the exact rule and on lines holding drawings, where the box is authored.
-     * Absent on lines published before this was measured; treat as zero.
-     */
-    readonly trailingSpacing?: number;
-    /**
-     * Model ranges on this line covering DELETED content, absent when there is none.
-     *
-     * The caret steps over these rather than entering them: text typed inside a deletion exists
-     * in neither the original nor the proposal, and there is no valid tree for the result.
-     *
-     * Recorded even in display modes that lay the deletion out invisibly, because the offsets
-     * exist in the model in every mode and an offset-by-offset walk would otherwise stop at
-     * positions with no glyph.
-     */
-    readonly deletedRanges?: readonly ModelRange[];
-    /**
-     * Inline drawings on this line, absent when there are none.
-     *
-     * Each occupies one UTF-16 model unit at {@link InlineDrawingRecord.start}. Hidden drawings
-     * are omitted — they remain in the tree and projection but publish no geometry.
-     */
-    readonly drawings?: readonly InlineDrawingRecord[];
-    /**
-     * Revision attributions of tracked ANCHORED drawings whose anchor sits on this line,
-     * absent when there are none.
-     *
-     * An anchored drawing paints from the page layer and leaves no span or line drawing at its
-     * anchor offset, so this is the only carrier the margin change bar can read for it. Only
-     * attributions the display mode lays out are recorded, matching the published records.
-     */
-    readonly anchorRevisions?: readonly RevisionAttribution[];
-}
-/**
- * A paragraph's resolved indent in points, in the vocabulary `w:ind` uses.
- *
- * `left`/`right` are signed; `hanging` is not (`ST_TwipsMeasure`). `firstLine` is signed
- * even though the schema declares it unsigned, because Word's model keeps one signed
- * first-line indent and this engine follows it.
- */
-interface ParagraphIndent {
-    readonly left: number;
-    readonly right: number;
-    readonly firstLine: number;
-    readonly hanging: number;
-}
-/**
- * The part of one paragraph that sits on one page.
- *
- * A paragraph that crosses a page boundary produces several fragments that all name the SAME
- * `paragraphId`, which is what lets selection and hit-testing treat it as one paragraph while
- * pagination treats it as two boxes.
- */
-interface ParagraphFragmentRecord {
-    readonly kind: 'paragraph';
-    readonly id: string;
-    readonly paragraphId: string;
-    /** 0 for the first fragment of the paragraph, 1 for its continuation, and so on. */
-    readonly fragmentIndex: number;
-    readonly range: SourceRange;
-    readonly props: readonly OoxmlProperty[];
-    /**
-     * Before/after spacing applied to THIS fragment, in points.
-     *
-     * Continuations carry `before: 0`; only the final fragment carries `after`. The numbers
-     * already reflect Word's adjacent-collapse against the previous paragraph's after.
-     */
-    readonly spacing: ParagraphSpacing;
-    /**
-     * The paragraph's EFFECTIVE indent in points, cascade and numbering merge included.
-     *
-     * Published because it is not recoverable from anything else here. `props` carries the
-     * cascaded `w:ind`, but a list paragraph's indent comes from `numbering.xml` and is merged
-     * in after the cascade, so a numbered item that authors no `w:ind` reads zero there while
-     * its text sits indented. The geometry is no better an answer: `box.x` is cell-relative
-     * inside a table and is displaced by float zones.
-     *
-     * `firstLine` and `hanging` are kept as OOXML spells them. A consumer wanting the one
-     * signed first-line offset Word models takes `hanging > 0 ? -hanging : firstLine` —
-     * hanging WINS, it is not summed (ECMA-376 §17.3.1.12).
-     */
-    readonly indent: ParagraphIndent;
-    /** Bottom rule on the final fragment when `w:pBdr/w:bottom` resolves; absent otherwise. */
-    readonly bottomBorder?: ParagraphBottomBorderRecord;
-    /**
-     * Every `w:pBdr` rule this fragment draws, in paint order.
-     *
-     * A paragraph split across pages opens and closes exactly once: the `top` stroke rides the
-     * first fragment, the closing stroke the last. `bottomBorder` remains the bottom rule alone
-     * — a `between` rule closing a grouped paragraph is not one.
-     */
-    readonly borders?: readonly ParagraphBorderStrokeRecord[];
-    /**
-     * Validated 6-hex paragraph shading fill (`w:pPr/w:shd`), absent for none/auto.
-     *
-     * Paint fills {@link shadingBox}. Measurement ignores it.
-     */
-    readonly shading?: string;
-    /**
-     * Geometry of the paragraph shading band when {@link shading} is set. Absent when there
-     * is no fill.
-     *
-     * TWO SHAPES, because Word fills two different things. An UNBORDERED paragraph is filled
-     * across its line boxes (indent-aware width), and before/after spacing stays unfilled. A
-     * paragraph that publishes any {@link borders} stroke is filled across the rectangle those
-     * strokes draw instead — `w:space` padding and rule extent included — so a callout's fill
-     * reaches its frame rather than leaving a pale stripe floating inside an empty box. Paint
-     * draws the strokes after the fill, so the frame is never covered.
-     */
-    readonly shadingBox?: LayoutBox;
-    /**
-     * The revisions on this paragraph's own MARK (`w:pPr/w:rPr/w:ins|w:del`), absent when there
-     * are none.
-     *
-     * Carried on the fragment rather than on a span because they decorate no characters: the
-     * pilcrow was inserted or deleted, which is how a split or a merge is recorded. Only the
-     * FINAL fragment carries them — the mark lives at the end of the paragraph, so a paragraph
-     * split across pages must not draw two of them.
-     *
-     * A LIST because one mark can hold two decisions at once — an insertion by one author and
-     * a deletion of that insertion by the next. Published only in `all-markup`: the other two
-     * display modes answer what the document WOULD be, and a resolved view draws no
-     * attribution.
-     *
-     * Those two modes are ATTRIBUTION-resolved, not STRUCTURE-resolved. Taking a deleted mark
-     * in `proposed` merges the paragraph into the next one, and taking an inserted mark in
-     * `original` un-splits it, but `revision-visibility.ts` does that only for a paragraph that
-     * renders no text. So a resolved view still shows the break — it just no longer draws a
-     * coloured pilcrow beside it. The merge is the fix for that; suppressing the glyph is not,
-     * and must not be read as it.
-     */
-    readonly markRevisions?: readonly RevisionAttribution[];
-    /**
-     * The one decision a single-field reader sees, absent when there are none.
-     *
-     * Derived from {@link markRevisions} at publish time, never authored beside it, so the two
-     * cannot disagree: a deletion when the mark carries one, because that is where the pair
-     * lands once every decision is taken, and it is the face paint draws for the same reason.
-     *
-     * @deprecated Shows one of the decisions a mark can carry. Read {@link markRevisions}.
-     */
-    readonly markRevision?: RevisionAttribution;
-    /**
-     * The tracked FORMAT change on this paragraph's mark (`w:pPr/w:rPr/w:rPrChange`), absent
-     * when there is none. Final fragment only, and `all-markup` only, like the decisions above.
-     *
-     * Published without a glyph of its own on purpose. Word draws no pilcrow for a mark whose
-     * only change is its own formatting — the decision belongs to the review pane, which lists
-     * it either way. What was missing was GEOMETRY: with nothing on the fragment, a card had
-     * no place on the page to point at.
-     */
-    readonly markFormatRevision?: RevisionAttribution;
-    /**
-     * List marker painted in the hanging-indent slot of the FIRST fragment only.
-     *
-     * Not part of model text: no UTF-16 range, never contributes to caret/selection offsets,
-     * and must not be serialised back into the paragraph.
-     */
-    readonly marker?: ListMarkerRecord;
-    /**
-     * The paragraph's resolved tab stops — cascade included — and the default interval past
-     * the last of them.
-     *
-     * Published because it is not recoverable from `props`: `w:tabs` carries its meaning in
-     * `w:tab` CHILDREN and the flat property projection has none, so a control reading the
-     * cascade sees the element and not a single stop. A tab-stop editor that showed only what
-     * the paragraph authors would hide a style's stops and then leave them in force.
-     */
-    readonly tabStops: ResolvedTabStops;
-    readonly lines: readonly LineRecord[];
-    readonly box: LayoutBox;
-}
-/**
- * A numbering marker as layout published it.
- *
- * Geometry is in the same coordinate space as the fragment (page-content or cell-content
- * relative). Paint positions from this box and MUST NOT remeasure the marker.
- */
-interface ListMarkerRecord {
-    readonly text: string;
-    readonly style: ResolvedRunStyle;
-    readonly box: LayoutBox;
-    /**
-     * The `w:ilvl` this marker was resolved at, 0..8.
-     *
-     * Published because the level, not the geometry, is what Increase/Decrease Indent moves
-     * on a list paragraph — demoting an item re-resolves its format from `numbering.xml`,
-     * which is why a bullet becomes a hollow circle and a `1.` becomes an `a.`.
-     */
-    readonly level: number;
-    /**
-     * The `w:numId` this marker resolved through.
-     *
-     * Published with the level because the two together are what identifies a list: whether
-     * a demote is even possible depends on which levels THIS definition declares, and a
-     * document may hold several lists whose level 0 looks identical.
-     */
-    readonly numId: string;
-    /** `w:numFmt` of the resolved level — `bullet` or a numbering format. */
-    readonly numFmt: string;
-}
-/**
- * The part of one table that sits on one page.
- *
- * A table that crosses a page boundary produces one fragment per page it spans, which is
- * what lets it checkpoint like a paragraph: the flow loop places whole fragments, and
- * resuming after a table needs no knowledge of its interior.
- */
-interface TableFragmentRecord {
-    readonly kind: 'table';
-    readonly id: string;
-    /** Canonical node id of the `w:tbl`. */
-    readonly tableId: string;
-    /** 0 for the first page the table touches, 1 for its continuation, and so on. */
-    readonly fragmentIndex: number;
-    /** Nesting depth: 0 for body-level tables, increasing for nested tables. */
-    readonly nestingDepth: number;
-    /**
-     * Resolved column boundary x positions in table-local points, left edge through right edge.
-     * Length is column count + 1.
-     */
-    readonly columnEdges: readonly number[];
-    readonly rows: readonly TableRowFragmentRecord[];
-    readonly box: LayoutBox;
-}
-/**
- * One table row on one page.
- *
- * A FRAGMENT, not the row: a row split across a page break appears once per page it touches, and
- * a repeated header row appears on every page of its table.
- */
-interface TableRowFragmentRecord {
-    /** Canonical node id of the `w:tr`. */
-    readonly id: string;
-    /** Pending tracked row insertion/deletion, when authored in `w:trPr`. */
-    readonly revisionKind?: 'insert' | 'delete';
-    /**
-     * The `w:trPr/w:ins|w:del` attribution — the `(id, author, date)` triple the review model
-     * addresses this decision by, so painted rows can carry it the way revision spans do.
-     */
-    readonly revisionId?: string;
-    readonly revisionAuthor?: string;
-    readonly revisionDate?: string;
-    /** Authored row ordinal within the table; repeats share the original row's index. */
-    readonly rowIndex: number;
-    /**
-     * True for a `w:tblHeader` row RE-EMITTED at the top of a continuation page. Painted,
-     * but excluded from interaction walks so each caret stop exists exactly once.
-     */
-    readonly isHeaderRepeat: boolean;
-    /**
-     * True when this record continues a row that already emitted content on a prior page
-     * (cell content fragmented at a paragraph/line boundary). Same `id` as the lead fragment.
-     */
-    readonly isContinuation?: boolean;
-    readonly cells: readonly TableCellFragmentRecord[];
-    readonly box: LayoutBox;
-}
-/**
- * One table cell on one page, already resolved against the grid.
- *
- * `gridSpan` is clamped at read time, because it comes from a file and an unclamped span is a
- * loop bound an attacker controls. A vertical-merge continuation paints its box but holds no
- * blocks — its content belongs to the cell that started the merge.
- */
-interface TableCellFragmentRecord {
-    /** Canonical node id of the `w:tc`. */
-    readonly id: string;
-    /** First grid column this cell occupies. */
-    readonly gridColumn: number;
-    /** Canonical `w:gridCol` node id for this cell's start column, when authored. */
-    readonly gridColumnId?: string;
-    /** Grid columns spanned, already clamped at read time. */
-    readonly gridSpan: number;
-    /** A vertical-merge continuation paints its box but holds no blocks. */
-    readonly vMergeContinue: boolean;
-    /**
-     * When true, paint skips borders/fill/content for this cell (vMerge continue). Grid
-     * bookkeeping and the box remain so selection/geometry walks stay consistent.
-     */
-    readonly paintInert?: boolean;
-    /** Number of rows this restart cell visually spans (1 when not a vertical merge). */
-    readonly rowSpan?: number;
-    /** Validated 6-hex cell shading fill, absent for none/auto. */
-    readonly shading?: string;
-    /**
-     * Layout-owned resolved borders after collapsed conflict resolution.
-     *
-     * Includes convenience per-side edges, per-grid-interval winners, and explicit compound
-     * stroke rectangles in cell-local points. Paint only scales and draws — it must not
-     * invent stroke/gap/corner geometry.
-     */
-    readonly borders?: ResolvedCellBorders;
-    /** Nested blocks in reading order; recursion carries nested tables. */
-    readonly blocks: readonly BlockFragmentRecord[];
-    readonly box: LayoutBox;
-}
-/** A top-level (or cell-level) block fragment, discriminated by `kind`. */
-type BlockFragmentRecord = ParagraphFragmentRecord | TableFragmentRecord;
-/**
- * One header or footer story as it sits on one page.
- *
- * `box` is absolute (sheet coordinates) and sized to the story's FLOW height — never to
- * any anchored-object extent, which is the rule that keeps a decorated header's hit area
- * from covering the body. `fragments` are story-relative (origin at the box's top-left).
- * Baseline furniture may be shared across pages of the same variant when the story has no
- * allowlisted PAGE/NUMPAGES/SECTIONPAGES fields; after page-field finalize, projections are
- * per page (or per distinct field values for count-only stories).
- */
-interface HeaderFooterStoryRecord {
-    readonly kind: 'header' | 'footer';
-    readonly variant: 'default' | 'first' | 'even';
-    readonly partName: string;
-    /**
-     * The part this story was laid out from. See {@link HeaderFooterStoryLayout.part}.
-     *
-     * Present when the furniture source supplied it. A pass that needs the story's TREE — the
-     * content-control boundary derivation is the one — reads it here rather than resolving a
-     * name against a package it does not have.
-     */
-    readonly part?: OoxmlPart;
-    /**
-     * Main-document relationship id that resolves to this part (`EditorScope.rId`).
-     *
-     * Present when the furniture source could name the relationship; scoped editing binds
-     * on this id so shared parts stay one story across pages/sections.
-     */
-    readonly rId?: string;
-    readonly box: LayoutBox;
-    readonly fragments: readonly BlockFragmentRecord[];
-    /** Anchored drawings owned by this story, in story-relative coordinates. */
-    readonly anchoredDrawings?: readonly AnchoredDrawingRecord[];
-    /**
-     * Transient projector used between furniture attach and document-level page-field
-     * finalize. Absent on published layout records after finalize — but not dead: finalize
-     * retains it (with the context it last ran under) in a side table keyed on the published
-     * record (`strippedStoryProjections` in `field-page-furniture.ts`), so a reused sheet can
-     * re-project when the page count moves (#441). The retained closure keeps its minting
-     * pass's scope alive for as long as the sheet is reused, and anything that clones a
-     * published field-bearing story must carry the entry onto the clone
-     * (`carryStrippedPageFieldProjection`).
-     */
-    readonly pageFieldProjector?: (context: {
-        readonly pageNumber: number;
-        readonly pageCount: number;
-        readonly sectionPageCount?: number;
-        readonly format?: string;
-    }) => HeaderFooterStoryRecord;
-}
-/**
- * One footnote or endnote story as it sits on one page (or continuation page).
- *
- * Notes are ordinary editable stories — NOT `[data-docx-hf]` furniture. `box` is absolute
- * (sheet coordinates). `fragments` are story-relative. Separators are nonselectable paint
- * geometry owned by the parent {@link NoteAreaRecord}.
- */
-interface NoteStoryRecord {
-    readonly noteKind: 'footnote' | 'endnote';
-    readonly noteId: number;
-    /** `footnote:N` / `endnote:N` — EditorScope note id. */
-    readonly scopeId: string;
-    /** Derived display mark for this occurrence; null when customMarkFollows / continuation. */
-    readonly mark: string | null;
-    /** True when this is a continuation fragment (no leading mark). */
-    readonly continuation?: boolean;
-    readonly box: LayoutBox;
-    readonly fragments: readonly BlockFragmentRecord[];
-}
-/**
- * Footnote / endnote area on one page: separator + stacked note stories.
- *
- * `placement` records how the area was positioned. `fallbackReason` is set when the
- * bounded reflow loop exhausted and layout kept the reference with its note on a later
- * page (D12 named fallback).
- */
-interface NoteAreaRecord {
-    readonly kind: 'footnotes' | 'endnotes';
-    readonly placement: 'pageBottom' | 'beneathText' | 'sectEnd' | 'docEnd';
-    readonly box: LayoutBox;
-    /** Separator rule / authored separator story; absent when no notes on this page. */
-    readonly separator?: {
-        readonly kind: 'separator' | 'continuationSeparator';
-        readonly box: LayoutBox;
-        readonly fragments: readonly BlockFragmentRecord[];
-        readonly synthetic: boolean;
-        /** Layout-owned single/double rule when marker-only or synthetic; absent for authored stories. */
-        readonly ruleStyle?: 'single' | 'double';
-    };
-    readonly notes: readonly NoteStoryRecord[];
-    readonly fallbackReason?: string;
-}
-/**
- * Note-stream ownership for overflow sheets created by note pagination.
- *
- * - `footnote-drain`: continuation pages that exist only to finish pageBottom footnotes —
- *   not free body hosts for sectEnd/docEnd endnotes.
- * - `endnote-overflow`: sheets inserted to finish sectEnd/docEnd collections.
- */
-type PageNoteStream = 'footnote-drain' | 'endnote-overflow';
-/**
- * Raw `w:lock/@w:val` on one control, or `unlocked` when absent / unrecognised.
- *
- * Effective permissions across a nesting chain are the union of every ancestor's lock on two
- * axes (content edit / removal); see {@link ContentControlBoundaryRecord.effectiveLock}.
- */
-type ContentControlLock = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';
-/**
- * Mapped control type for layout / chrome — same members as the shipped public
- * `ContentControlType`. Untyped and preserved-only kinds report as `richText`.
- */
-type ContentControlMappedType = 'richText' | 'plainText' | 'checkbox' | 'dropdown' | 'comboBox' | 'date' | 'picture' | 'repeatingSection';
-/** Where the control sits in the tree relative to its content. */
-type ContentControlLevel = 'block' | 'inline' | 'row' | 'cell';
-/**
- * One piece of a control's content geometry.
- *
- * A block control that crosses a page break publishes one fragment per page rather than a
- * single rectangle covering the inter-page gap. An inline control publishes one fragment per
- * LINE it touches, covering the text's vertical extent (line-spacing leading excluded), so a
- * wrapped control never claims the words beside it. Coordinates match fragment boxes
- * (page-content space).
- */
-interface ContentControlGeometryFragment {
-    readonly pageIndex: number;
-    readonly box: LayoutBox;
-}
-/**
- * Layout-published boundary for one content control (`w:sdt` / typed `contentControl`).
- *
- * Chrome, lock feedback, and hit resolution read this record — never painted DOM. The wrapper
- * itself is not a layout box; `fragments` cover the content that already flowed in place.
- */
-interface ContentControlBoundaryRecord {
-    /** Canonical node id of the control wrapper — not `w:id`. */
-    readonly id: string;
-    readonly alias?: string;
-    readonly tag?: string;
-    readonly controlType: ContentControlMappedType;
-    /** This control's own `w:lock`, before ancestor union. */
-    readonly lock: ContentControlLock;
-    /**
-     * Nested lock union with every ancestor control, collapsed back to a single `ST_Lock`
-     * vocabulary value (both axes locked → `sdtContentLocked`).
-     */
-    readonly effectiveLock: ContentControlLock;
-    /** `w:showingPlcHdr` is present on the control's properties. */
-    readonly placeholder: boolean;
-    /** `w:dataBinding` is present — content edits are refused as bound. */
-    readonly bound: boolean;
-    /** 0 for a top-level control; increments through nested wrappers under the shared nesting bound. */
-    readonly nestingDepth: number;
-    readonly level: ContentControlLevel;
-    readonly fragments: readonly ContentControlGeometryFragment[];
-}
-/**
- * One laid-out page: the sheet, the content area, and everything that landed on it.
- *
- * Page identity is REUSED across incremental passes — a pass that changes nothing returns the
- * previous records by reference, which is what lets paint skip untouched pages entirely.
- */
-interface PageRecord {
-    readonly id: string;
-    readonly index: number;
-    /** The whole sheet. */
-    readonly box: LayoutBox;
-    /** The area inside the margins that content flows into. */
-    readonly contentBox: LayoutBox;
-    readonly fragments: readonly BlockFragmentRecord[];
-    /** Layout-owned vertical rules requested by `w:cols/@w:sep`, content-box relative. */
-    readonly columnSeparators?: readonly LayoutBox[];
-    /** Page-content anchored drawings on this sheet, absent when there are none. */
-    readonly anchoredDrawings?: readonly AnchoredDrawingRecord[];
-    /** Page furniture for this page's variant, absent when the document declares none. */
-    readonly header?: HeaderFooterStoryRecord;
-    readonly footer?: HeaderFooterStoryRecord;
-    /** Footnotes reserved on this page (pageBottom / beneathText / continuations). */
-    readonly footnotes?: NoteAreaRecord;
-    /** Endnotes collected on this page (sectEnd / docEnd). */
-    readonly endnotes?: NoteAreaRecord;
-    /**
-     * Ownership of note-only overflow sheets. Absent on ordinary body pages.
-     * Layout pagination sets this so endnote hosting does not treat footnote drain
-     * pages as free body space.
-     */
-    readonly noteStream?: PageNoteStream;
-    /**
-     * Section-local PAGE/SECTIONPAGES inputs for finalize. Absent → physical page index and
-     * document-wide section count (empty `w:pgNumType` behaviour).
-     */
-    readonly pageFieldSource?: {
-        readonly pageNumber: number;
-        readonly sectionPageCount: number;
-        readonly format?: string;
-    };
-    /**
-     * `true` when this page's body flow (or a body table) carries a PAGE/NUMPAGES/SECTIONPAGES
-     * placeholder that document finalize must substitute. Set when the page is assembled, so it
-     * rides the record through incremental reuse. `false` lets `finalizePageFieldProjection` skip
-     * the substitution walk; `undefined` (a page built by a path that does not stamp it) still
-     * walks, which is safe.
-     */
-    readonly hasBodyPageFields?: boolean;
-    /**
-     * Content-control boundaries whose geometry intersects this page.
-     *
-     * Carried on the page so a consumer that only holds a page record still sees current
-     * metadata; identity reuse of an unchanged page keeps the same array only when the
-     * control-context token matches.
-     */
-    readonly contentControls?: readonly ContentControlBoundaryRecord[];
-}
-/**
- * A complete layout pass: every page, plus the document-wide indexes derived alongside them.
- *
- * Stamped with the store `revision` it was laid out from, so anything holding geometry can tell
- * whether the document has moved underneath it — which is how stale pointer gestures and
- * overlays are refused rather than applied to coordinates that no longer describe anything.
- */
-interface SemanticLayout {
-    /** The store revision these records were laid out from. */
-    readonly revision: number;
-    readonly pages: readonly PageRecord[];
-    /**
-     * Every content-control boundary in document order, including multi-page fragment lists.
-     *
-     * Always recomputed when a document layout pass finishes, so incremental page-identity
-     * reuse cannot publish stale alias/tag/lock metadata.
-     */
-    readonly contentControls?: readonly ContentControlBoundaryRecord[];
-    /**
-     * Fingerprint of wrapper-only control metadata (alias, tag, lock, type, placeholder, binding).
-     *
-     * Folded into the layout producer / session context so a metadata-only edit invalidates
-     * reuse paths that would otherwise return previous pages by identity with stale boundaries.
-     */
-    readonly controlContextToken?: string;
-}
-/** Page geometry, in points. */
-interface PageGeometry {
-    readonly width: number;
-    readonly height: number;
-    readonly margin: {
-        readonly top: number;
-        readonly right: number;
-        readonly bottom: number;
-        readonly left: number;
-    };
-    /** `w:pgMar/@header` — sheet edge to header top, in points. Defaults to 36 (720 twips). */
-    readonly headerDistance?: number;
-    /** `w:pgMar/@footer` — sheet edge to footer bottom, in points. Defaults to 36. */
-    readonly footerDistance?: number;
-}
-/** US Letter with one-inch margins, in points. */
-declare const DEFAULT_PAGE_GEOMETRY: PageGeometry;
-/**
- * Text measurement, injected.
- *
- * A real implementation shapes with the resolved font; the tests supply a deterministic one.
- * Layout never reads the DOM, so this is the only way width and height enter it.
- */
-interface TextMeasurer {
-    /** Advance width of `text` in the resolved style. */
-    measure(text: string, style: ResolvedRunStyle): number;
-    /** Line height and baseline for the resolved style. */
-    lineMetrics(style: ResolvedRunStyle): {
-        height: number;
-        baseline: number;
-    };
-}
-
-export { type DeclaredFontSubstitution as $, type AnchoredDrawingRecord as A, type BlockFragmentRecord as B, type ContentControlBoundaryRecord as C, type DrawingPoint as D, AUTO_PARAGRAPH_SPACING_PT as E, type FontResourceSnapshot as F, type AbstractNumDefinition as G, type HyperlinkProjector as H, type InlineDrawingRecord as I, type BidiEmbeddingLevels as J, type BorderGridGeometry as K, type LineRecord as L, type ModelRange as M, type NormalizationPolicy as N, type CascadedParagraphFormatting as O, type PageGeometry as P, type ContentControlGeometryFragment as Q, type ResolvedRunStyle as R, type SemanticLayout as S, type TextMeasurer as T, type ContentControlLevel as U, type VersionedShapingLibrary as V, type ContentControlMappedType as W, DEFAULT_PAGE_GEOMETRY as X, DEFAULT_RUN_STYLE as Y, DEFAULT_TAB_INTERVAL_PT as Z, DEFAULT_TAB_INTERVAL_TWIPS as _, type StyleSpanRecord as a, type ResolvedUnderline as a$, EMPTY_NUMBERING_INDEX as a0, EMPTY_TAB_STOPS as a1, type EquationFractionGeometry as a2, type EquationGeometry as a3, type EquationNaryGeometry as a4, type EquationRadicalGeometry as a5, type EquationRowGeometry as a6, type EquationScriptGeometry as a7, type EquationSpanRecord as a8, type EquationTextGeometry as a9, MAX_PARAGRAPH_SPACING_PT as aA, MAX_STYLE_BASED_ON_DEPTH as aB, MAX_STYLE_DEFINITIONS as aC, MAX_TABLE_BORDER_STROKES as aD, MAX_TAB_POSITION_TWIPS as aE, MAX_TAB_STOPS as aF, type NumDefinition as aG, type NumberingLevelIndent as aH, PARAGRAPH_BORDER_SIDES as aI, type PageRefCalibrationCell as aJ, type PageRefFieldProjection as aK, type ParagraphAutoSpacingContext as aL, type ParagraphBorderEdge as aM, type ParagraphBorderSide as aN, type ParagraphBorderStrokeRecord as aO, type ParagraphBorders as aP, type ParagraphBottomBorderRecord as aQ, type ParagraphIndent as aR, type ParagraphLayoutInputs as aS, type ParagraphLineSpacing as aT, type ParagraphSpacing as aU, type RefFieldSpec as aV, type RefNoteParts as aW, type ResolvedCellBorders as aX, type ResolvedTabStops as aY, type ResolvedTableBorderEdge as aZ, type ResolvedTableBorderEdgeSegment as a_, type FieldAtomMarker as aa, type FontFingerprintInputs as ab, type FontRequest as ac, FontResolutionError as ad, type FontResolutionErrorCode as ae, type FontResourceDefinition as af, type FontResourceInstrumentation as ag, type FontResourceSnapshotOptions as ah, type FontSlot as ai, type FontSubstitution as aj, type FontValidationResult as ak, type GlyphOutline as al, HARD_MAX_AGGREGATE_FONT_BYTES as am, HARD_MAX_FONT_BYTES as an, HARD_MAX_FONT_SOURCES as ao, type HeaderFooterStoryRecord as ap, type HyperlinkFieldSpec as aq, type LevelOverride as ar, type LineSpacingRule as as, type ListMarkerAlign as at, type ListMarkerRecord as au, type ListSuffix as av, MAX_BORDER_SPACE_PT as aw, MAX_BORDER_WIDTH_PT as ax, MAX_LVL_OVERRIDES as ay, MAX_NUMBERING_DEFINITIONS as az, type TextShaper as b, parseRefInstruction as b$, SINGLE_LINE_SPACING as b0, type ScriptItem as b1, type ShapeInput as b2, type ShapedCluster as b3, type ShapedFontSpan as b4, type ShapedGlyph as b5, type ShapedRunComparatorInputs as b6, type ShapedVerticalMetrics as b7, type ShapingEnvironment as b8, type ShapingEnvironmentFingerprintInputs as b9, cascadedBottomBorder as bA, cascadedParagraphBorders as bB, cascadedTabStops as bC, collapsedSpaceBefore as bD, createFontResourceSnapshot as bE, createShapedRun as bF, createShapingEnvironment as bG, defaultTabIntervalFromSettings as bH, displayText as bI, fixedPoint as bJ, fontRequestKey as bK, isValidStyleId as bL, itemizeScriptFontSlots as bM, layoutEquation as bN, listMarkerBox as bO, measureDisplayText as bP, mergeListIndent as bQ, nextTabDestination as bR, paragraphBorderExtentPt as bS, paragraphBorderStrokeWidthPt as bT, paragraphBorders as bU, paragraphBordersFingerprint as bV, paragraphBreaksBefore as bW, paragraphContextualSpacing as bX, paragraphLineSpacing as bY, paragraphSpacing as bZ, paragraphTabStops as b_, type ShapingEnvironmentInput as ba, type SourceRange as bb, type SpanLinkRecord as bc, type StyleDefinition as bd, TAB_LEADER_GLYPH as be, type TabAlignment as bf, type TabDestination as bg, type TabLeader as bh, type TabStop as bi, type TableBorderSideName as bj, type TableBorderStrokeRecord as bk, type TableFragmentRecord as bl, type TextDirection as bm, UnsupportedScriptError as bn, type VerticalAlign as bo, appliedSpaceBefore as bp, applyLineSpacing as bq, baselineShiftPtOf as br, borderExtentPt as bs, borderWeight as bt, bottomBorderExtentPt as bu, boundedStructuralFontValidator as bv, buildNumberingIndex as bw, buildStyleCascadeTable as bx, cascadeParagraphFormatting as by, cascadeRunProperties as bz, type FixedPointRoundingMode as c, readBorderSide as c0, readCellBorders as c1, readNumPr as c2, readTableBorders as c3, resolveBorderConflict as c4, resolveNumberingLevel as c5, resolveParagraphLayoutInputs as c6, resolveRunStyle as c7, resolveStoryListItems as c8, resolveStoryRefFields as c9, resolveTableCellBorderGrid as ca, runStylesEqual as cb, shapedRunComparatorInputs as cc, shapingEnvironmentFingerprint as cd, shapingEnvironmentFingerprintInputs as ce, styleForFontSlot as cf, tabAdvanceWidth as cg, tabStopsFingerprint as ch, walkStoryParagraphs as ci, withDefaultTabInterval as cj, withNumberingStyleLinks as ck, withResolvedListItems as cl, type ResolvedFont as d, type TableRowFragmentRecord as e, type TableCellFragmentRecord as f, type NumberingLevel as g, type NumberingIndex as h, type LayoutBox as i, type DrawingInsets as j, type PageRecord as k, type TableBorderSide as l, type ContentControlLock as m, type ParagraphFragmentRecord as n, type FontByteValidator as o, type FixedPoint as p, type ShapedRun as q, type InlineDrawingLayoutContext as r, type StyleCascadeTable as s, type FieldLinkProjector as t, type RefFieldContext as u, type StoryPageFieldNeeds as v, type ResolvedListItem as w, type CellBorderBox as x, type TableCellStyleFormatting as y, type TableBorderBox as z };