@arbidocs/blocks 0.4.100 → 0.4.102

package/node_modules/@docx-editor.dev/core/dist/semantic-records-4B3WwFAi.d.ts

@@ -0,0 +1,3532 @@
+import { o as RevisionAttribution, b as RevisionDisplayMode } from './revision-projection-DZ4kKVev.js';
+import { X as OoxmlProperty, Z as OoxmlElement, N as OoxmlNode, O as OoxmlPart, aJ as TableBorderStyle, aK as DrawingAccessibility, aL as DrawingImageEffects, al as SourceCrop, aM as DrawingTransform, aN as VectorShapeProjection, aw as DrawingHorizontalReferenceFrame, ax as DrawingVerticalReferenceFrame, an as ImageWrapTarget, a0 as DrawingProjection, aO as OoxmlDrawingNode } from './types-barrel-D3xCgQX6.js';
+import { b as ImageResourceState } from './image-resources-BN-hUgCn.js';
+import { O as OmmlEquationProjection } from './omml-equation-CuzBL5DD.js';
+
+/** A strikeout stroke at the drawn size, in points. `offsetPt` is the stroke TOP. @public */
+interface StrikeoutStrokePt {
+    /** Distance from the baseline UP to the top of the stroke. */
+    readonly offsetPt: number;
+    /** Stroke height. Always positive. */
+    readonly thicknessPt: number;
+}
+
+/**
+ * `w:tblpPr/@w:horzAnchor` (17.4.58) and `@w:vertAnchor` (17.4.66): the box a floated
+ * table's offsets are measured from. Absent means `text` for both.
+ */
+type TableFloatAnchor = 'text' | 'margin' | 'page';
+/** `w:tblpPr/@w:tblpXSpec` (17.4.63, ST_XAlign). */
+type TableFloatXSpec = 'left' | 'center' | 'right' | 'inside' | 'outside';
+/** `w:tblpPr/@w:tblpYSpec` (17.4.65, ST_YAlign). */
+type TableFloatYSpec = 'inline' | 'top' | 'center' | 'bottom' | 'inside' | 'outside';
+/**
+ * `w:tblPr/w:tblpPr` (17.4.57) — a table positioned against an anchor box rather than at
+ * the point in the text where it was authored.
+ *
+ * A spec (`tblpXSpec`/`tblpYSpec`) supersedes the matching offset when both are present:
+ * 17.4.57 states the alignment outright, and the offset only answers "how far from the
+ * anchor" for the case where no alignment was stated.
+ */
+interface TableFloatPosition {
+    readonly horzAnchor: TableFloatAnchor;
+    readonly vertAnchor: TableFloatAnchor;
+    readonly xSpec?: TableFloatXSpec;
+    /** `w:tblpX` in points; signed, so a table can be pulled into the margin. */
+    readonly xPt: number;
+    readonly ySpec?: TableFloatYSpec;
+    /** `w:tblpY` in points; signed. */
+    readonly yPt: number;
+    readonly distances?: {
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    };
+}
+
+/**
+ * One `w:numPicBullet`: the image a level draws instead of its `w:lvlText`.
+ *
+ * `relationshipId` is unresolved on purpose — it names a relationship of the numbering part,
+ * and resolving it is the image-resource lookup's job, under its own validation and caps.
+ * @public
+ */
+interface NumberingPictureBullet {
+    /** `w:numPicBulletId` — what a level's `w:lvlPicBulletId` names. */
+    readonly picBulletId: string;
+    /** `v:imagedata/@r:id`, relative to the NUMBERING part's relationships. */
+    readonly relationshipId: string;
+    /** Authored `v:shape` width in points. */
+    readonly width: number;
+    /** Authored `v:shape` height in points. */
+    readonly height: number;
+}
+/**
+ * A level's picture bullet with the size it is actually DRAWN at.
+ *
+ * Separate from {@link NumberingPictureBullet} because the authored `v:shape` extent is not
+ * the painted extent: Word scales it by the marker run's font size. Layout, hit testing and
+ * both paint sinks read `width` / `height`; `authored` is kept so the scale stays inspectable.
+ * @public
+ */
+interface ResolvedPictureBullet {
+    /** `v:imagedata/@r:id`, relative to the NUMBERING part's relationships. */
+    readonly relationshipId: string;
+    /** Painted width in points, after the marker font scale. */
+    readonly width: number;
+    /** Painted height in points, after the marker font scale. */
+    readonly height: number;
+    /** The `v:shape` extent exactly as the file authored it. */
+    readonly authored: NumberingPictureBullet;
+}
+
+/** 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 {
+    /**
+     * The sides as the level spells them, in points. `left` and `start` both name the leading
+     * indent, and `right` and `end` the trailing one; `left`/`right` below hold those two.
+     */
+    readonly authored?: {
+        readonly left?: number;
+        readonly right?: number;
+        readonly start?: number;
+        readonly end?: number;
+    };
+    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 formatting it outranks and the formatting that
+     * outranks it (`mergeListIndent`), 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;
+    /**
+     * `w:lvlPicBulletId` (§17.9.12): this level's marker is the `w:numPicBullet` of that id,
+     * drawn INSTEAD of `w:lvlText`. Absent on every ordinary level.
+     */
+    readonly picBulletId?: string;
+    /** 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>;
+    /**
+     * `w:numPicBullet` declarations keyed by `w:numPicBulletId` (§17.9.20).
+     *
+     * Optional so a hand-built index stays valid; absent reads as "this part declares none",
+     * which is what a level's `w:lvlPicBulletId` then falls back from.
+     */
+    readonly pictureBullets?: ReadonlyMap<string, NumberingPictureBullet>;
+}
+/**
+ * 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;
+
+/**
+ * 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;
+    /**
+     * Logical text around `text` that the shaper reads for contextual forms but never
+     * shapes: HarfBuzz pre- and post-context. A word split across two formatting runs joins
+     * across the split only when each half sees the other's letters. At most
+     * {@link MAX_SHAPING_CONTEXT} UTF-16 units each; glyphs and clusters cover `text` alone.
+     */
+    readonly context?: ShapingContext;
+}
+/** Pre- and post-context for one shaping call. See {@link ShapeInput.context}. @public */
+interface ShapingContext {
+    readonly before: string;
+    readonly after: string;
+}
+/** Longest context on either side, in UTF-16 units. Joining needs only the nearest letters. @public */
+declare const MAX_SHAPING_CONTEXT = 16;
+/**
+ * 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;
+    /** Optional synthetic glyph-size factor; positions and advances already include it. */
+    readonly drawScale?: 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;
+    /**
+     * The same horizontal advances as `glyphs[i].advanceX`, in the same fixed-point units, but
+     * BEFORE the per-glyph rounding to the fixed-point grid. Parallel to `glyphs`.
+     *
+     * Measurement and line breaking read `advanceX` and must keep doing so: pagination is decided
+     * on those numbers, and two runs shaped identically have to compare equal. A painter that
+     * gives every glyph its own absolute position sums the advances instead, and a sum of ROUNDED
+     * advances drifts by up to half a fixed-point unit per glyph — an error that only grows along
+     * a line. Summing these and rounding once, at the position actually written, does not.
+     *
+     * Absent on runs an assembly path cannot state exactly; a reader falls back to `originX`.
+     */
+    readonly exactAdvancesX?: readonly number[];
+}
+/**
+ * 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;
+
+/**
+ * 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 contexts in which Word's auto spacing resolves to 0
+ * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
+ *
+ * This resolves the interior list-item value. Body layout restores each outer list margin
+ * in `resolveListAutoSpacing`, where neighboring blocks are available. A caller that says
+ * nothing gets the body answer.
+ *
+ * A TABLE CELL is not such a context. Measured on a captured control at 10pt, where the
+ * line pitch is 11.52pt: the reference puts 26.16pt between two paragraphs in the body with
+ * auto spacing on, and the SAME 26.16pt between two paragraphs inside a cell. With an empty
+ * paragraph between them it is 52.32, exactly twice. Reading it as 0 in a cell lays every
+ * such paragraph 13.92pt tight, which is enough to pull a signature block back onto the
+ * previous page. See `.cache/pdf/claude-autospacing/`.
+ */
+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. Kept because callers describe position with it and
+     * list resolution reads it; it does NOT zero auto spacing.
+     */
+    readonly inTableCell?: boolean;
+    /** Section grid pitch in points; no grid uses Word's fixed 12pt line unit. */
+    readonly lineUnitPt?: number;
+    /**
+     * `w:doNotUseHTMLParagraphAutoSpacing` is on: automatic spacing outside a list resolves to
+     * the fixed 5pt before and 10pt after instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
+     */
+    readonly fixedAutoSpacing?: 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;
+    /** Legacy noExtraLineSpacing: retain the natural baseline within an exact-height box. */
+    readonly preserveExactBaseline?: true;
+    /**
+     * Active section line-grid pitch in points (`w:docGrid/@w:linePitch`). Present only when
+     * the paragraph snaps to the grid; only with `auto`. See `line-grid.ts`.
+     */
+    readonly gridPitch?: 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.
+ *
+ * `auto` places its extra 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".
+ *
+ * `atLeast` does the OPPOSITE: the box grows upward and the glyphs sit on its floor. A
+ * captured control settles it — Times New Roman 12 pt at `w:line="360" w:lineRule="atLeast"`
+ * puts the reference's baseline at 15.36 pt, which is `18 - descent` snapped to the device
+ * grid, where treating it like `auto` leaves the baseline at 11.28 and the text 4.08 pt too
+ * high. `w:line="240" atLeast` is below the natural line, falls through to the natural
+ * height, and is unaffected. See `.cache/pdf/claude-linerule/`.
+ *
+ * Exact-height boxes place their baseline at 80% of the height; the legacy
+ * noExtraLineSpacing switch instead preserves the face baseline within the box.
+ *
+ * An `auto` or `atLeast` line of a snapping paragraph under an active line grid takes whole
+ * pitches instead ({@link gridLineBox}); `trailing` then names the box below the glyphs.
+ */
+declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
+    height: number;
+    baseline: number;
+    trailing?: 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 naturally moves to the top of a page mid-section. An explicit page-break-before
+ * paragraph, or the first paragraph of a document/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, preserveAtPageStart: boolean): number;
+
+/** `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;
+    /**
+     * Present only on a `w:rtl` or `w:cs` run: the LATIN lane that the complex-script values
+     * replaced in `fontFamily`, `fontSizePt`, `bold` and `italic`. Nothing draws with it; it
+     * lets a copy of the formatting (the format painter) write each lane back separately.
+     */
+    readonly latinLane?: {
+        readonly fontFamily: string | null;
+        readonly fontFamilyEastAsia: string | null;
+        readonly fontSizePt: number;
+        readonly bold: boolean;
+        readonly italic: boolean;
+    };
+    /**
+     * The complex-script lane as the cascade states it, on every resolved run: the values a
+     * `w:rtl` or `w:cs` run draws with, and what a copy of the formatting writes to `w:bCs`,
+     * `w:iCs`, `w:szCs` and `w:rFonts/@w:cs`. `fontFamily` is null when no level names a face.
+     */
+    readonly complexLane?: {
+        readonly fontFamily: string | null;
+        readonly fontSizePt: number;
+        readonly bold: boolean;
+        readonly italic: boolean;
+    };
+    /** Script and paragraph-resolved direction for shaping and visual placement. */
+    readonly shaping?: {
+        readonly script: string;
+        readonly direction: 'ltr' | 'rtl';
+        readonly level: number;
+        readonly baseLevel: number;
+        /** Resolved w:rtl context; absent when authored Unicode controls govern the paragraph. */
+        readonly runDirection?: 'ltr' | 'rtl';
+        readonly wordSpacingPt?: number;
+        /** Neighbouring text a joining script reads across a formatting-run boundary. */
+        readonly context?: ShapingContext;
+    };
+    /** 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;
+    /** Opaque solid `w14:textOutline`, in points; paint only, never a font-weight change. */
+    readonly textOutline?: {
+        readonly widthPt: number;
+        readonly color: string;
+    };
+    /** Character border; adjacent runs with matching edges share one outline. */
+    readonly border?: ParagraphBorderEdge;
+    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. */
+    readonly kerningMinPt: number;
+    /** Explicit kerning selection; a zero threshold disables it. Absent uses a positive threshold. */
+    readonly kerningEnabled?: boolean;
+    /** Resolved optional OpenType substitutions; required script ligatures are independent. */
+    readonly ligatures?: {
+        readonly standard: boolean;
+        readonly contextual: boolean;
+        readonly historical: boolean;
+        readonly discretionary: boolean;
+    };
+    /**
+     * `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;
+    /** Complex-script heading and body theme faces. */
+    readonly majorBidi?: string | null;
+    readonly minorBidi?: string | null;
+    /** Language-specific theme faces, keyed by ISO 15924 script. */
+    readonly majorSupplemental?: Readonly<Record<string, string>>;
+    readonly minorSupplemental?: Readonly<Record<string, string>>;
+    /** Lower-cased font table names that declare a Chinese character set. */
+    readonly chineseFontTableFaces?: readonly string[];
+}
+/**
+ * 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;
+/**
+ * Shared glyph-size factor for baseline, superscript, and subscript text.
+ *
+ * The 65% script scale follows the common Word font metrics (Arial, Calibri, Times New
+ * Roman) and improves the saved Word reference at 10pt and 11pt. It is a uniform policy;
+ * per-face script metrics and Word's output-device rounding are not modeled here.
+ * Layout, surface paint, and exporters must apply the same factor to avoid caret drift.
+ * @public
+ */
+declare function glyphSizeFactorOf(style: ResolvedRunStyle): number;
+
+/** Horizontal alignment of a paragraph (`w:jc`, ECMA-376 §17.3.1.13). */
+type Alignment = 'left' | 'center' | 'right' | 'both';
+
+/** The number formats a page field's `\*` switch can select (ST_NumberFormat names). */
+type PageFieldNumberFormat = 'decimal' | 'lowerRoman' | 'upperRoman' | 'lowerLetter' | 'upperLetter' | 'numberInDash';
+
+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;
+    /**
+     * The story places something by the physical sheet's parity: a header frame aligned
+     * `inside` or `outside`. Set by the header/footer layout, never by field detection. The
+     * story then lays out once per sheet parity, with or without a page field.
+     */
+    readonly hasPageParity?: boolean;
+}
+
+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[];
+    /** Unclipped image corners for affine encoding; clipping must not stretch the image. */
+    readonly imageTransformCorners?: readonly DrawingPoint[];
+    readonly clipPolygon: readonly DrawingPoint[] | null;
+    readonly clipFallback: DrawingClipFallback;
+    readonly effectInsets: DrawingInsets;
+}
+
+/**
+ * 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;
+    }[];
+}
+
+/**
+ * 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;
+
+/**
+ * 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;
+}
+
+/** 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` marks a reference whose displayed result links to its bookmark. */
+    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;
+
+/**
+ * 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 each paragraph ID and its PAINTED REF outputs in the story, for the
+     * section prepass memo. IDs keep structural edits from moving an identical sequence of
+     * outputs between paragraphs while the aggregate falsely reports unchanged dependencies.
+     * 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 when painted output or its owning paragraph changes.
+     */
+    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;
+
+/**
+ * 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 legacy form CONTROL the reader can operate, with the state it paints.
+     *
+     * Checkboxes carry their checked state; dropdowns carry their declared entries and index.
+     * Paint supplies a matching hit target without parsing the displayed text back.
+     */
+    readonly formControl?: {
+        readonly kind: 'checkbox';
+        readonly checked: boolean;
+        /** Plain accessible name; omitted for fields containing macro references. */
+        readonly accessibleName?: string;
+    } | {
+        readonly kind: 'dropdown';
+        readonly entries: readonly string[];
+        readonly selectedIndex: number;
+        readonly accessibleName?: string;
+    };
+    /**
+     * 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;
+        /** The field's `\*` number format, applied when finalize substitutes the value. */
+        readonly numberFormat?: PageFieldNumberFormat;
+    };
+    /**
+     * 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;
+    /**
+     * The first model offset of the editable saved result this piece belongs to.
+     *
+     * Present only when saved results are laid out as text (`fieldResults: 'editable'`). The
+     * result is ordinary text then, so its pieces have their own offsets; every piece of one
+     * result shares this value, which keeps a multi-run link result one anchor and lets the
+     * caret find the whole result it is in.
+     */
+    readonly resultStart?: number;
+    /** The model offset just past the same result, beside {@link resultStart}. */
+    readonly resultEnd?: number;
+}
+/** 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;
+
+/** 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;
+    /** Legacy `num` stop: positions a numbering suffix, not a tab in ordinary text. */
+    readonly numberingOnly?: true;
+    /**
+     * Supplied at a hanging paragraph's text indent, not authored. It positions ordinary text
+     * tabs only: the numbering suffix treats the indent by its own rule.
+     */
+    readonly implied?: true;
+    /** 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;
+    /**
+     * `w:doNotUseIndentAsNumberingTabStop` (§17.15.3): a numbering suffix tab goes to the
+     * first authored stop past the marker, wherever it is, before it falls back to the indent.
+     */
+    readonly ignoreIndentAsNumberingTabStop?: true;
+}
+/** 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, forNumbering?: boolean): 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;
+
+/** Document-wide East Asian line-break and whitespace policy. @public */
+interface CjkTypographySettings {
+    /** Apply the strict Japanese small-kana and prolonged-sound-mark restrictions. */
+    readonly strict: boolean;
+    /** Whitespace compression selected by `w:characterSpacingControl`. */
+    readonly compression: 'doNotCompress' | 'compressPunctuation' | 'compressPunctuationAndJapaneseKana';
+    /** Custom no-line-start characters, keyed by normalized language tag. */
+    readonly before: Readonly<Record<string, string>>;
+    /** Custom no-line-end characters, keyed by normalized language tag. */
+    readonly after: Readonly<Record<string, string>>;
+}
+
+/** 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 edges inherit. Explicit no-border edges suppress their own inherited rule.
+ * An opposing edge can still win, including a rule inherited by the neighboring cell.
+ */
+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;
+/** Word's weighted border selection (MS-OI29500 §2.1.169, tcBorders).
+ * https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/7c791c5d-44c3-4fe8-abdd-8f136761bb93
+ */
+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 do not paint. Weighted widths decide;
+ * equal weights 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 row's `w:tblPrEx` table borders, which replace the table's own for this cell. */
+    readonly rowTableBorders?: TableBorderBox;
+}
+/**
+ * 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 {
+    /** Center simple horizontal strokes on collapsed row boundaries. */
+    readonly collapsedHorizontal?: boolean;
+    /** 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;
+        /** False when a split occurrence still reserves a shared bottom stroke. */
+        readonly outerBottomInsetReserved?: boolean;
+        /** Simple vertical strokes share the cell grid line with legacy padding. */
+        readonly centeredSideRules?: boolean;
+        /** Simple vertical strokes paint centered on the grid line. */
+        readonly centeredSidePaint?: boolean;
+    }[])[];
+}
+/**
+ * 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[][];
+/** Painted extent inward from the cell edge; existing padding may already clear it. */
+declare function borderExtentPt(edge: ResolvedTableBorderEdge | TableBorderSide | undefined): number;
+
+/**
+ * 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; the widest line when unwrapped). */
+    readonly contentWidth: number;
+    /**
+     * Box width (points) that unwrapped text sizes its shape to: the widest line plus the
+     * insets. Placement resolves the shape at this width. Absent when the extent width holds.
+     */
+    readonly extentWidth?: 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;
+}
+
+/** One laid-out group member story. */
+interface GroupTextboxStoryRecord {
+    /** Canonical node id of the member `wps:wsp`. */
+    readonly memberNodeId: string;
+    /** The member box in points, relative to the drawing extent's top-left corner. */
+    readonly box: LayoutBox;
+    /** The member's story, in content-box coordinates inside {@link box}. */
+    readonly story: TextboxStoryLayout;
+    /**
+     * Clockwise turn of the painted member about the center of {@link box}, in degrees. The
+     * story lays out upright; paint and export turn it. Hit testing never maps into it.
+     */
+    readonly rotationDegrees: number;
+}
+
+/** Clip `box` to a horizontal content band; preserves authored size, zeroes clipped axes. */
+/** How a drawing record holds the picture member of a shape group. */
+interface DrawingGroupPictureRecord {
+    /**
+     * Whether the group is the chosen branch of a run-level `mc:AlternateContent`. An output
+     * that cannot draw the picture leaves such a group out, as it leaves out other MC content
+     * it cannot draw. A group without it shows the output's unsupported-drawing result.
+     */
+    readonly alternateContent: boolean;
+}
+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: DrawingImageEffects;
+    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;
+    /**
+     * Present when the image is the picture member of a drawing group. The image then fills
+     * the bounds of `geometry.imageTransformCorners`, not `geometry.contentBounds`, and paints
+     * below `vectorShape`, which holds the group's other members. `placeholderGraphicKind`
+     * stays non-null, as for a vector shape, so image commands do not treat the group as a
+     * picture. The group paints whole or not at all: when the picture cannot paint, an output
+     * shows no part of the group.
+     */
+    readonly groupPicture?: DrawingGroupPictureRecord;
+    /**
+     * 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[];
+    /**
+     * The picture's resolved Unicode bidi level in a right-to-left or mixed-direction paragraph.
+     * An odd level reads right to left: its logical start is its right edge. Absent when the
+     * paragraph needed no bidi resolution.
+     */
+    readonly bidiLevel?: 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). An
+     * inline text box carries one too: its story sits inside the extent the line reserves.
+     */
+    readonly textboxStory?: TextboxStoryLayout;
+    /** Read-only stories of a group's text box members, each placed in its member box. */
+    readonly groupTextboxStories?: readonly GroupTextboxStoryRecord[];
+}
+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;
+    /**
+     * Resolve a numbering picture bullet's image by relationship id.
+     *
+     * The owner is the NUMBERING part, not this context's story part: `w:numPicBullet` lives in
+     * `numbering.xml` and its `r:id` names a relationship of that part. The resolver answers the
+     * owner it used so a sink can key the resource without assuming the part name. Absent on a
+     * context whose host resolves no image resources, which degrades a picture bullet to its
+     * level's `w:lvlText`.
+     */
+    readonly pictureBulletResource?: (relationshipId: string) => {
+        readonly ownerPartName: string;
+        readonly resource: ImageResourceState;
+    } | null;
+}
+/** 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;
+    /**
+     * Whether the object is laid out in the box it flows in. For an anchor in a table cell this
+     * is the layout's reading: `true` from compatibility mode 15, which ignores
+     * `layoutInCell="0"`. Everywhere else it is the authored `wp:anchor/@layoutInCell`.
+     */
+    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;
+}
+
+/**
+ * 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;
+    /** Counter value at this item's own level; absent for bullets. */
+    readonly ordinal?: number;
+    readonly markerAlign: ListMarkerAlign;
+    readonly suffix: ListSuffix;
+    /** Effective indent after merging level + paragraph indents, in points. */
+    readonly indent: NumberingLevelIndent;
+    readonly markerStyle: ResolvedRunStyle;
+    /**
+     * The image marker a `w:lvlPicBulletId` level resolved to, absent on every other item.
+     *
+     * Present means the marker is an IMAGE: it occupies `width` x `height` points in the
+     * hanging slot and `markerText` is only what a sink that cannot draw the image falls back
+     * to. The extent is the AUTHORED `v:shape` size scaled by the marker font size — see
+     * {@link resolvePictureBullet}, which also decides when the answer is no picture at all.
+     * Absent means the level declared none, named one the part does not declare, declared one
+     * this projection could not read, or resolved to a size nothing can paint.
+     */
+    readonly picBullet?: ResolvedPictureBullet;
+    /** 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: `inherited`, then the numbering LEVEL, then
+ * `direct`, per attribute.
+ *
+ * A level's `w:pPr/w:ind` applies per attribute between the two tiers, 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 what the level outranks and `direct` is what outranks it. When the
+ * paragraph's own `w:pPr` states a `w:numPr`, these are the style chain (after the document
+ * defaults) and that `w:pPr`. Otherwise the level sits directly below the nearest style that
+ * states a `w:numPr`: that style, the styles based on it and the paragraph's own `w:pPr` go
+ * in `direct`, and the defaults and that style's bases go in `inherited`.
+ */
+declare function mergeListIndent(levelIndent: NumberingLevelIndent, inherited: readonly OoxmlProperty[], direct?: readonly OoxmlProperty[]): NumberingLevelIndent;
+
+/**
+ * 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;
+    readonly measurer?: TextMeasurer;
+}>(options: T, blocks: readonly OoxmlElement[]): T & {
+    readonly numberingIndex: NumberingIndex;
+    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
+};
+
+interface StyleDefinition {
+    readonly styleId: string;
+    readonly name?: string;
+    readonly type: string;
+    readonly basedOn: string | null;
+    /** `w:next` — the authoring style for a following paragraph. */
+    readonly next: string | null;
+    readonly outlineLevel: number | null;
+    readonly paragraphProperties: readonly OoxmlProperty[];
+    readonly runProperties: readonly OoxmlProperty[];
+    readonly paragraphPropertiesNode: OoxmlElement | undefined;
+    readonly tablePropertiesNode: OoxmlElement | undefined;
+    readonly tableRowPropertiesNode: OoxmlElement | undefined;
+    readonly tableCellPropertiesNode?: OoxmlElement;
+    readonly conditionalTableFormats: ReadonlyMap<string, OoxmlElement>;
+}
+declare function isValidStyleId(raw: string | undefined): raw is string;
+
+/** Soft ceiling on style definitions read from one styles part. */
+declare const MAX_STYLE_DEFINITIONS = 4096;
+/**
+ * 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 {
+    /** Keep floating tables that fit a full page together under the compatibility flag. */
+    readonly doNotBreakWrappedTables?: true;
+    /** Legacy or explicitly disabled optional OpenType substitutions. */
+    readonly disableOptionalLigatures?: true;
+    /** Legacy noExtraLineSpacing behavior, included in the producer fingerprint. */
+    readonly preserveExactLineBaseline?: true;
+    /** `w:adjustLineHeightInTable`: cell paragraphs snap to the section line grid too. */
+    readonly adjustLineHeightInTable?: true;
+    /** `w:doNotUseIndentAsNumberingTabStop`, carried onto each paragraph's tab stops. */
+    readonly ignoreIndentAsNumberingTabStop?: true;
+    /**
+     * `w:doNotUseHTMLParagraphAutoSpacing`: adjacent paragraph spacing adds up, and automatic
+     * spacing is a fixed 5pt before and 10pt after.
+     */
+    readonly fixedParagraphSpacing?: true;
+    /**
+     * `w:doNotExpandShiftReturn`: a justified line ending in a manual line break keeps its
+     * natural spacing, as a last line does.
+     */
+    readonly unstretchedManualBreakLines?: true;
+    /**
+     * Legacy modes: a justified line ending in a page or column break stretches to the measure
+     * unless it is the last line of its paragraph.
+     */
+    readonly pageBreakLinesStretch?: true;
+    /** Explicit compatibility opt-in to the unmodified ISO table style hierarchy. */
+    readonly strictTableStyleHierarchy?: boolean;
+    readonly typography?: CjkTypographySettings;
+    /**
+     * 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. */
+    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 the mark's `w:pPr/w:rPr`, including its `w:rStyle` character style —
+     * empty-line metrics and the numbering marker. A line with content grows from the mark
+     * without that character style.
+     */
+    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;
+}
+/**
+ * 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, settingsRoot?: OoxmlElement | null): 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;
+    /** Resolved outline level, with 9/invalid values treated as body text. */
+    readonly outlineLevel: number | 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` + `w:pPr/w:rPr` and its `w:rStyle`).
+     * Empty-line sizing and last-line mark height (without the `w:rStyle`) — never content 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.
+ *
+ * `lineUnitPt` is the section's ACTIVE line-grid pitch. It sizes line-unit paragraph margins
+ * and snaps the paragraph's lines to the grid; absent means no grid and the fixed 12pt unit.
+ */
+declare function resolveParagraphLayoutInputs(paragraph: OoxmlElement, contentWidth: number, styleCascade: StyleCascadeTable | undefined, listItem?: ResolvedListItem, tableCellStyle?: TableCellStyleFormatting, inTableCell?: boolean, lineUnitPt?: number): ParagraphLayoutInputs;
+
+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;
+
+/**
+ * The four physical sides of `CT_PageBorders`.
+ *
+ * Four, not the six of `w:pBdr`: `w:between` and `w:bar` are paragraph-group rules and the
+ * page has no analogue for either.
+ */
+declare const PAGE_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right'];
+/** Which of the four page-frame edges. */
+type PageBorderSide = (typeof PAGE_BORDER_SIDES)[number];
+/**
+ * `w:offsetFrom` (`ST_PgBorderOffset`) — what `w:space` on each edge is measured from.
+ *
+ * The schema default is `text`, NOT `page`. Word's own UI opens on "Edge of page", which is
+ * why the wrong default is easy to assume and expensive to hold: at `text` the rule sits
+ * `w:space` points outside the TEXT, so its distance from the sheet edge is the margin minus
+ * the space — a number that moves whenever the margins do.
+ */
+type PageBorderOffsetFrom = 'page' | 'text';
+/** `w:display` (`ST_PgBorderDisplay`) — which pages of the section carry the frame. */
+type PageBorderDisplay = 'allPages' | 'firstPage' | 'notFirstPage';
+/** `w:zOrder` (`ST_PgBorderZOrder`) — whether the frame paints over the text or under it. */
+type PageBorderZOrder = 'front' | 'back';
+/**
+ * One section's resolved `w:pgBorders`.
+ *
+ * Resolved, not raw: every attribute the file omitted is filled in with the SCHEMA default,
+ * so a consumer never has to know which of the three were authored. An edge is present only
+ * when it paints — `nil` / `none` and art borders are already gone (see {@link parsePageBorders}).
+ */
+interface SectionPageBorders {
+    /** `w:offsetFrom`; absent attribute reads as `text` (§17.6.10). */
+    readonly offsetFrom: PageBorderOffsetFrom;
+    /** `w:display`; absent attribute reads as `allPages`. */
+    readonly display: PageBorderDisplay;
+    /** `w:zOrder`; absent attribute reads as `front`. */
+    readonly zOrder: PageBorderZOrder;
+    readonly top?: ParagraphBorderEdge;
+    readonly left?: ParagraphBorderEdge;
+    readonly bottom?: ParagraphBorderEdge;
+    readonly right?: ParagraphBorderEdge;
+}
+/**
+ * Parse `w:pgBorders` off one `w:sectPr`.
+ *
+ * Undefined when the element is absent AND when it paints nothing — every edge off, or every
+ * edge an art border. Unlike `w:pgNumType`, an empty-but-present element is not distinguished:
+ * these properties are a LAYOUT input, serialization re-emits the canonical tree, and a frame
+ * with no edges has exactly one meaning downstream.
+ */
+declare function parsePageBorders(sectPr: OoxmlNode): SectionPageBorders | undefined;
+/**
+ * Identity of one section's page frame, for incremental-layout context keys.
+ *
+ * A `w:pgBorders` edit changes nothing the flow measures — the frame is drawn beside the text,
+ * never through it — so no per-paragraph key moves and every reuse path would hand back the
+ * previous sheets with the previous frame. This token goes in the pass context so it does not.
+ */
+declare function pageBordersFingerprint(borders: SectionPageBorders | undefined): string;
+
+/** Published root story containing an artifact occurrence. @public */
+type SemanticArtifactRootStoryKind = 'body' | 'header' | 'footer' | 'footnote' | 'endnote' | 'note-separator';
+/** Exact story in which a review artifact's source anchor was laid out. @public */
+type SemanticArtifactStoryKind = SemanticArtifactRootStoryKind | 'textbox';
+/** One model position retained as exporter provenance. @public */
+interface SemanticReviewArtifactPosition {
+    readonly paragraphId: string;
+    readonly offset: number;
+}
+/**
+ * Package-relative snapshot provenance, not durable public identity.
+ *
+ * Engine-produced occurrences keep `start.paragraphId === end.paragraphId`. Cross-paragraph
+ * source ranges are sliced into per-paragraph occurrences before geometry attaches.
+ * @public
+ */
+interface SemanticReviewArtifactSource {
+    readonly partName: string;
+    readonly start: SemanticReviewArtifactPosition;
+    readonly end: SemanticReviewArtifactPosition;
+}
+/**
+ * Laid-out bounds for one review occurrence.
+ *
+ * `pageContent` uses the same space as line boxes. `pageStack` uses stacked page coordinates.
+ * A point occurrence publishes `width: 0`.
+ * @public
+ */
+interface SemanticReviewArtifactOccurrenceGeometry {
+    readonly pageContent: readonly LayoutBox[];
+    readonly pageStack: readonly LayoutBox[];
+}
+/** One physical occurrence of a comment or tracked-change source range. @public */
+interface SemanticReviewArtifactOccurrence {
+    readonly pageIndex: number;
+    readonly physicalPageNumber: number;
+    readonly story: SemanticArtifactStoryKind;
+    readonly rootStory: SemanticArtifactRootStoryKind;
+    /** Root-to-leaf drawing ids for a textbox occurrence; empty outside textboxes. */
+    readonly textboxPath: readonly string[];
+    readonly noteScopeId: string | null;
+    readonly noteAreaKind: 'footnotes' | 'endnotes' | null;
+    /** Replacement-half meaning for tracked-change occurrences; absent for comments. */
+    readonly revisionRole?: 'replaced' | 'replacement' | 'neutral';
+    readonly source: SemanticReviewArtifactSource;
+    /** Laid-out bounds when this occurrence can be measured; omitted otherwise. */
+    readonly geometry?: SemanticReviewArtifactOccurrenceGeometry;
+}
+/** Normalized change; ids are opaque and stable only within the source snapshot. @public */
+interface SemanticTrackedChangeArtifactRecord {
+    readonly kind: 'tracked-change';
+    readonly id: string;
+    readonly change: 'insert' | 'delete' | 'replace' | 'moveFrom' | 'moveTo' | 'format' | 'paragraphMark' | 'structural';
+    /** Structural changes represented by this review artifact. */
+    readonly structuralChanges?: readonly ('rowInsert' | 'rowDelete' | 'cellInsert' | 'cellDelete' | 'cellMerge' | 'numberingInsert')[];
+    readonly markDirection?: 'insert' | 'delete' | 'moveFrom' | 'moveTo';
+    readonly author: string;
+    readonly date?: string;
+    readonly text: string;
+    readonly replacedText: string;
+    /** Nested tracked-change depth, where the innermost decision is operative. */
+    readonly nesting: number;
+    /** Number of leading source ranges belonging to struck text in a replacement. */
+    readonly replacedRangeCount?: number;
+    readonly readOnly: boolean;
+    readonly pairedWith?: string;
+    readonly replyIds: readonly string[];
+    readonly occurrences: readonly SemanticReviewArtifactOccurrence[];
+}
+/** Normalized comment; all relation ids share the opaque snapshot-local id space. @public */
+interface SemanticCommentArtifactRecord {
+    readonly kind: 'comment';
+    readonly id: string;
+    readonly author: string;
+    readonly initials: string;
+    readonly date?: string;
+    readonly text: string;
+    readonly resolved: boolean;
+    readonly parentId?: string;
+    readonly parentRevisionId?: string;
+    readonly replyIds: readonly string[];
+    readonly orphaned: boolean;
+    readonly occurrences: readonly SemanticReviewArtifactOccurrence[];
+}
+/** Exporter-neutral review artifact normalized by core. @public */
+type SemanticReviewArtifactRecord = SemanticTrackedChangeArtifactRecord | SemanticCommentArtifactRecord;
+
+/** 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;
+}
+/**
+ * One `w:pgBorders` rule as layout published it.
+ *
+ * `box` is the stroke rectangle in PAGE-BOX-relative points — measured from the sheet's own
+ * top-left, not from the document-stacked absolute origin and not from the content box. That
+ * is what lets a reused sheet move down the stack (`remapPage`) without the frame being
+ * recomputed or shifted: the frame's place on the paper never depended on where the paper is.
+ *
+ * Paint MUST NOT re-derive the inset. `w:offsetFrom` decides whether `w:space` counts from the
+ * sheet edge or from the text, and resolving that needs the section margins, which is layout's
+ * to know — the same division `columnSeparators` already draws.
+ */
+interface PageBorderStrokeRecord {
+    readonly side: PageBorderSide;
+    readonly edge: ParagraphBorderEdge;
+    readonly box: LayoutBox;
+}
+/**
+ * The page frame on one sheet, already filtered by `w:display`.
+ *
+ * Present only on the pages that actually carry it, so a consumer holding a single page record
+ * needs no section context to know what to draw. `display` rides along because a sheet MINTED
+ * after layout (note overflow) has to decide whether it inherits its template's frame, and a
+ * `firstPage` frame is the one that must not be inherited.
+ */
+interface PageBorderFrameRecord {
+    readonly zOrder: PageBorderZOrder;
+    readonly display: PageBorderDisplay;
+    readonly strokes: readonly PageBorderStrokeRecord[];
+}
+/**
+ * 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 {
+    /**
+     * Horizontal ink displacement in points from box.x, before drawing the glyphs.
+     * CJK opening punctuation removes its left side bearing; its advance and caret
+     * boundaries remain box-based. Zero marks trailing-bearing compression with no
+     * ink displacement. Exporters must apply this offset to the ink origin.
+     */
+    readonly glyphOffsetPt?: number;
+    /** Measured face baseline for character-border geometry; span boxes remain selection bands. */
+    readonly borderBaselinePt?: number;
+    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;
+    /** Authored trailing spaces that layout may clip at the line's right edge. */
+    readonly lineEndWhitespace?: true;
+    /**
+     * An optional hyphen (`w:softHyphen`) where the line breaks. {@link text} stays U+00AD, one
+     * model character; {@link box} holds the advance of the visible hyphen that paint draws in
+     * its place. Absent for an optional hyphen inside a line, which draws nothing.
+     */
+    readonly optionalHyphenBreak?: true;
+    /**
+     * 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[];
+    /**
+     * The revisions a resolved view accepted into this text, which paints as ordinary text.
+     *
+     * Absent in All Markup, where {@link revisions} carries the markup instead, and absent for
+     * text no included revision touched. The Simple Markup change bar is its only reader; nothing
+     * inline draws from it.
+     */
+    readonly changeSites?: 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;
+    /** Authored inline separator rule; its advance belongs to one note atom. */
+    readonly noteSeparator?: 'separator' | 'continuationSeparator';
+    /** 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 {
+    /** An authored manual line break ends this line; optional display furniture can show ↵. */
+    readonly manualBreakAfter?: true;
+    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, and neither moves with `w:jc`. A line with no
+     * spans needs this aligned origin, or paint, hit testing and the caret fall back to `box.x`.
+     *
+     * The leftmost x of any span box or inline drawing `advanceStart`: one origin for every
+     * consumer. On a line that opens with a picture, the text starts at the leftmost span.
+     */
+    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, atLeast growth).
+     *
+     * `auto` 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 line-spacing depth BELOW the glyph band, inside {@link box}.
+     *
+     * The complement of {@link leading}: exact centres the glyphs and atLeast grows the box
+     * above them, while auto leaves the band at the top and grows the box beneath it.
+     * So the band a consumer needs is `box.height - trailingSpacing - leading`, and
+     * subtracting `leading` alone is right only under exact and atLeast.
+     *
+     * 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 exact and atLeast. On a line holding drawings, only an auto multiple above
+     * single spacing sets it: the multiple's extra text band below the drawings.
+     * 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[];
+    /**
+     * Revisions a resolved view answered on this line — content it kept as ordinary text and
+     * content it removed between the line's offsets — absent when there are none, and always
+     * absent in All Markup, where the spans carry the markup themselves.
+     *
+     * What Simple Markup's change bar draws beside the line. Nothing inline reads it: the view
+     * shows the document as accepting every change would leave it, and the bar in the margin is
+     * the one place that still says the line changed.
+     */
+    readonly changeSites?: 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;
+    /** This fragment contains the visible paragraph end. */
+    readonly paragraphEnd?: true;
+    /** Resolved paragraph-mark style when this fragment has no text spans, including picture-only fragments. */
+    readonly emptyParagraphStyle?: ResolvedRunStyle;
+    /** Font size of the paragraph mark, on the fragment that ends the paragraph; sizes ¶. */
+    readonly paragraphMarkSizePt?: number;
+    /** A fixed text frame clips its painted ink to this fragment's box; source ranges remain intact. */
+    readonly clipToBox?: true;
+    /**
+     * The fragment retains its source identity without consuming body flow height: a positioned
+     * text frame (with {@link ParagraphFragmentRecord.positionedFrame}), an empty section-mark
+     * paragraph before a continuous section, or the empty line in front of a paragraph's leading
+     * page break at the bottom of a full page. The last two paint nothing.
+     */
+    readonly outOfFlow?: true;
+    /** Placement and wrapping of one authored text-frame group, in page-content coordinates. */
+    readonly positionedFrame?: {
+        readonly dropCapLines?: number;
+        readonly anchorId: string;
+        readonly columnIndex: number;
+        readonly groupId: string;
+        readonly sourceOrder: number;
+        readonly wrap: 'auto' | 'around' | 'tight' | 'through' | 'none' | 'notBeside';
+        readonly hSpace: number;
+        readonly vSpace: number;
+        readonly box: LayoutBox;
+    };
+    readonly range: SourceRange;
+    readonly props: readonly OoxmlProperty[];
+    /** Resolved paragraph style after the style/default cascade, or null when none applies. */
+    readonly styleId: string | null;
+    /** Resolved Word outline level (0 = Heading 1), or null for body text. */
+    readonly outlineLevel: number | null;
+    /** Resolved `w:jc` alignment used by layout. */
+    readonly alignment: 'left' | 'center' | 'right' | 'both';
+    /**
+     * 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;
+    /**
+     * The decisions a resolved view answered on this paragraph's MARK: an inserted break it
+     * kept, a paragraph-property change or a mark-property change it accepted. Final fragment
+     * only, resolved views only; absent when there are none. A removed break merges its
+     * paragraph away and reports on the join line instead (see {@link LineRecord.changeSites}).
+     */
+    readonly markChangeSites?: readonly 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. With the level it identifies a list: whether
+     * a demote is possible depends on which levels THIS definition declares.
+     */
+    readonly numId: string;
+    /** `w:numFmt` of the resolved level — `bullet` or a numbering format. */
+    readonly numFmt: string;
+    /** Resolved counter at this marker's own level; absent for bullets. */
+    readonly ordinal?: number;
+    /**
+     * The IMAGE this marker draws instead of {@link ListMarkerRecord.text}, when the resolved
+     * level carries `w:lvlPicBulletId` (§17.9.12) and the referenced `w:numPicBullet` resolved.
+     *
+     * Absent on every ordinary marker, and absent when the picture bullet is missing, external,
+     * malformed or oversized — in which case `text` stands and the marker paints as the level's
+     * `w:lvlText` did before. A sink that cannot draw the resource paints `text` too, which is
+     * why both are published rather than one replacing the other.
+     */
+    readonly picture?: ListMarkerPictureRecord;
+    /**
+     * In a right-to-left paragraph: `text` in VISUAL order, one piece per direction run, each
+     * styled at its bidi level. Paint draws these instead of `text`, which stays logical.
+     */
+    readonly pieces?: readonly Pick<ListMarkerRecord, 'text' | 'style' | 'box'>[];
+}
+/**
+ * The picture a `w:lvlPicBulletId` marker paints, with its geometry already decided.
+ *
+ * Geometry is in the same coordinate space as {@link ListMarkerRecord.box}: paint positions
+ * from `box` and MUST NOT rescale it, neither from the resource's intrinsic pixels nor from
+ * the authored `v:shape` extent, which the marker font size has already scaled. The image
+ * sits with its BOTTOM on the first line's baseline, which is what makes the line tall
+ * enough for it.
+ *
+ * `resource` is the same validated-image projection an inline drawing carries, resolved
+ * through the numbering part's OWN relationships. A `ready` resource is the only one that
+ * can be drawn; every other state is a clean fall back to the marker text.
+ * @public
+ */
+interface ListMarkerPictureRecord {
+    /** The part whose relationships `relationshipId` belongs to — the numbering part. */
+    readonly ownerPartName: string;
+    /** `v:imagedata/@r:id` of the `w:numPicBullet` shape. */
+    readonly relationshipId: string;
+    /** Where the image paints, authored extent, in the marker's coordinate space. */
+    readonly box: LayoutBox;
+    /** Validated image state, or why there is none. */
+    readonly resource: ImageResourceState;
+}
+/**
+ * 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';
+    /** Source and positioning inputs needed to reconstruct wrapping on an incremental pass. */
+    readonly floatingWrap?: {
+        readonly anchorId: string;
+        readonly columnIndex: number;
+        readonly float: TableFloatPosition;
+        readonly sourceOrder: number;
+    };
+    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;
+    /**
+     * The row insertion a resolved view kept this row through, absent in All Markup (where
+     * {@link revisionKind} carries it) and for an untracked row. A removed row has no record.
+     */
+    readonly changeSites?: readonly RevisionAttribution[];
+    /** Authored row ordinal within the table; repeats share the original row's index. */
+    readonly rowIndex: number;
+    /** True when the authored row resolves `w:tblHeader`, including its first occurrence. */
+    readonly isHeaderRow: boolean;
+    /** True for a `w:tblHeader` row repeated atop a continuation page; not an interaction stop. */
+    readonly isHeaderRepeat: boolean;
+    /** True when this record continues a row split at a line boundary; same `id` as its head. */
+    readonly isContinuation?: boolean;
+    /** True when the rest of this row continues in the next fragment: the head of a split row. */
+    readonly hasContinuation?: boolean;
+    /** True for a `w:cantSplit` or exact-height row: it stays whole where a page holds it. */
+    readonly placesWhole?: 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 {
+    readonly revisionShading?: 'inserted' | 'deleted' | 'merged' | 'split';
+    /** Author of the visible cell revision, or its enclosing row revision. */
+    readonly revisionShadingAuthor?: string;
+    /** Canonical node id of the `w:tc`. */
+    readonly id: string;
+    /** First grid column this cell occupies. */
+    readonly gridColumn: number;
+    /** Stored grid index for an RTL cell; gridColumn indexes physical columnEdges. */
+    readonly logicalGridColumn?: 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;
+    /** Bottom-to-top cell content uses a rotated local inline axis. */
+    readonly textDirection?: 'btLr';
+    /**
+     * 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' | 'continuationNotice';
+        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';
+        /** Resolved marker-run color; null/absent uses automatic black. */
+        readonly ruleColor?: string | null;
+    };
+    /** Authored furniture below a note that continues on the next page. */
+    readonly continuationNotice?: NonNullable<NoteAreaRecord['separator']>;
+    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' | 'buildingBlockGallery' | '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[];
+    /** Layout-owned `w:pgBorders` frame for this sheet, page-box relative. Absent when none. */
+    readonly pageBorders?: PageBorderFrameRecord;
+    /** 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;
+    /** An empty sheet that gives the next section its page parity; SECTIONPAGES skips it. */
+    readonly parityBlank?: true;
+    /**
+     * 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;
+    /** Revision projection already applied to every published record. */
+    readonly displayMode?: RevisionDisplayMode;
+    readonly pages: readonly PageRecord[];
+    /**
+     * Normalized comments and tracked changes from the same package revision as these pages.
+     * Exporters consume this plain-data stream instead of re-reading OOXML or review state.
+     */
+    readonly reviewArtifacts?: readonly SemanticReviewArtifactRecord[];
+    /**
+     * 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;
+}
+
+/**
+ * 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;
+    /**
+     * Optional whole-span logical caret advances, indexed by UTF-16 offset. Values
+     * are nondecreasing, start at zero, and end at the measured advance. Ligature
+     * interiors may share an edge. Undefined selects a bounded approximate fallback.
+     */
+    caretAdvances?(text: string, style: ResolvedRunStyle): readonly number[] | undefined;
+    /**
+     * Optional conservative ink bounds for one grapheme, in points from its origin.
+     * Includes size and horizontal scale, but not trailing character spacing.
+     * Undefined keeps layout on the advance-only path.
+     */
+    inkBounds?(text: string, style: ResolvedRunStyle): {
+        left: number;
+        right: number;
+    } | undefined;
+    /** Whether line metrics use an admitted face instead of approximate fallback metrics. */
+    hasResolvedFont?(style: ResolvedRunStyle): boolean;
+    /**
+     * Optional `OS/2` strikeout stroke for the resolved face, at the drawn size. Word paints
+     * `w:separator` as a strikeout, so the note rule reads its thickness and offset here rather
+     * than assuming one face's numbers. Undefined keeps the caller's own default.
+     */
+    strikeoutMetrics?(style: ResolvedRunStyle): StrikeoutStrokePt | undefined;
+    /** Line metrics for the actual text faces; omitted text measures the primary face. */
+    lineMetrics(style: ResolvedRunStyle, text?: string): {
+        height: number;
+        baseline: number;
+    };
+}
+
+export { PAGE_BORDER_SIDES as a$, AUTO_PARAGRAPH_SPACING_PT as a4, HARD_MAX_AGGREGATE_FONT_BYTES as aG, HARD_MAX_FONT_BYTES as aH, HARD_MAX_FONT_SOURCES as aI, MAX_BORDER_SPACE_PT as aO, MAX_BORDER_WIDTH_PT as aP, MAX_LVL_OVERRIDES as aQ, MAX_NUMBERING_DEFINITIONS as aR, MAX_PARAGRAPH_SPACING_PT as aS, MAX_SHAPING_CONTEXT as aT, MAX_STYLE_DEFINITIONS as aU, MAX_TABLE_BORDER_STROKES as aV, MAX_TAB_POSITION_TWIPS as aW, MAX_TAB_STOPS as aX, DEFAULT_RUN_STYLE as ae, DEFAULT_TAB_INTERVAL_PT as af, DEFAULT_TAB_INTERVAL_TWIPS as ag, EMPTY_NUMBERING_INDEX as al, EMPTY_TAB_STOPS as am, FontResolutionError as ax, bottomBorderExtentPt as b$, PARAGRAPH_BORDER_SIDES as b0, TAB_LEADER_GLYPH as bJ, UnsupportedScriptError as bU, appliedSpaceBefore as bW, applyLineSpacing as bX, baselineShiftPtOf as bY, borderExtentPt as bZ, borderWeight as b_, SINGLE_LINE_SPACING as bp, boundedStructuralFontValidator as c0, buildNumberingIndex as c1, buildStyleCascadeTable as c2, cascadeParagraphFormatting as c3, cascadeRunProperties as c4, cascadedBottomBorder as c5, cascadedParagraphBorders as c6, cascadedTabStops as c7, collapsedSpaceBefore as c8, createFontResourceSnapshot as c9, readCellBorders as cA, readNumPr as cB, readTableBorders as cC, resolveBorderConflict as cD, resolveNumberingLevel as cE, resolveParagraphLayoutInputs as cF, resolveRunStyle as cG, resolveStoryListItems as cH, resolveStoryRefFields as cI, resolveTableCellBorderGrid as cJ, runStylesEqual as cK, shapedRunComparatorInputs as cL, shapingEnvironmentFingerprint as cM, shapingEnvironmentFingerprintInputs as cN, styleForFontSlot as cO, tabAdvanceWidth as cP, tabStopsFingerprint as cQ, withDefaultTabInterval as cR, withNumberingStyleLinks as cS, withResolvedListItems as cT, createShapedRun as ca, createShapingEnvironment as cb, defaultTabIntervalFromSettings as cc, displayText as cd, fixedPoint as ce, fontRequestKey as cf, glyphSizeFactorOf as cg, isValidStyleId as ch, itemizeScriptFontSlots as ci, layoutEquation as cj, measureDisplayText as ck, mergeListIndent as cl, nextTabDestination as cm, pageBordersFingerprint as cn, paragraphBorderExtentPt as co, paragraphBorderStrokeWidthPt as cp, paragraphBorders as cq, paragraphBordersFingerprint as cr, paragraphBreaksBefore as cs, paragraphContextualSpacing as ct, paragraphLineSpacing as cu, paragraphSpacing as cv, paragraphTabStops as cw, parsePageBorders as cx, parseRefInstruction as cy, readBorderSide as cz };
+export type { HyperlinkFieldSpec as $, AnchoredDrawingRecord as A, BlockFragmentRecord as B, ContentControlBoundaryRecord as C, DrawingPoint as D, InlineDrawingLayoutContext as E, FontResourceSnapshot as F, CellBorderBox as G, HeaderFooterStoryRecord as H, InlineDrawingRecord as I, TableBorderBox as J, TableCellStyleFormatting as K, LineRecord as L, ModelRange as M, NoteAreaRecord as N, TableFloatPosition as O, ParagraphFragmentRecord as P, StyleCascadeTable as Q, ResolvedRunStyle as R, SemanticLayout as S, TextMeasurer as T, FixedPoint as U, VersionedShapingLibrary as V, FontByteValidator as W, SourceRange as X, HyperlinkProjector as Y, FieldLinkProjector as Z, StoryPageFieldNeeds as _, PageRecord as a, SpanLinkRecord as a0, PageBorderFrameRecord as a1, ParagraphBorderStrokeRecord as a2, StrikeoutStrokePt as a3, AbstractNumDefinition as a5, AnchoredDrawingLayoutFallback as a6, BidiEmbeddingLevels as a7, BorderGridGeometry as a8, CascadedParagraphFormatting as a9, FontResourceInstrumentation as aA, FontResourceSnapshotOptions as aB, FontSlot as aC, FontValidationResult as aD, GlyphOutline as aE, GroupTextboxStoryRecord as aF, LevelOverride as aJ, LineSpacingRule as aK, ListMarkerAlign as aL, ListMarkerRecord as aM, ListSuffix as aN, NumDefinition as aY, NumberingLevelIndent as aZ, NumberingPictureBullet as a_, CjkTypographySettings as aa, ContentControlGeometryFragment as ab, ContentControlLevel as ac, ContentControlMappedType as ad, DeclaredFontSubstitution as ah, DrawingClipFallback as ai, DrawingGeometry as aj, DrawingGroupPictureRecord as ak, EquationFractionGeometry as an, EquationGeometry as ao, EquationNaryGeometry as ap, EquationRadicalGeometry as aq, EquationRowGeometry as ar, EquationScriptGeometry as as, EquationSpanRecord as at, EquationTextGeometry as au, FieldAtomMarker as av, FontFingerprintInputs as aw, FontResolutionErrorCode as ay, FontResourceDefinition as az, LayoutBox as b, PageBorderDisplay as b1, PageBorderOffsetFrom as b2, PageBorderSide as b3, PageBorderStrokeRecord as b4, PageBorderZOrder as b5, PageRefCalibrationCell as b6, PageRefFieldProjection as b7, ParagraphAutoSpacingContext as b8, ParagraphBorderEdge as b9, ShapedCluster as bA, ShapedFontSpan as bB, ShapedGlyph as bC, ShapedRunComparatorInputs as bD, ShapedVerticalMetrics as bE, ShapingContext as bF, ShapingEnvironment as bG, ShapingEnvironmentFingerprintInputs as bH, StyleDefinition as bI, TabAlignment as bK, TabDestination as bL, TabLeader as bM, TabStop as bN, TableBorderSideName as bO, TableBorderStrokeRecord as bP, TableFragmentRecord as bQ, TextDirection as bR, TextboxStoryFallbackReason as bS, TextboxStoryLayout as bT, VerticalAlign as bV, ParagraphBorderSide as ba, ParagraphBorders as bb, ParagraphBottomBorderRecord as bc, ParagraphIndent as bd, ParagraphLayoutInputs as be, ParagraphLineSpacing as bf, ParagraphSpacing as bg, RefFieldSpec as bh, RefNoteParts as bi, ResolvedCellBorders as bj, ResolvedPictureBullet as bk, ResolvedTabStops as bl, ResolvedTableBorderEdge as bm, ResolvedTableBorderEdgeSegment as bn, ResolvedUnderline as bo, ScriptItem as bq, SemanticArtifactRootStoryKind as br, SemanticArtifactStoryKind as bs, SemanticCommentArtifactRecord as bt, SemanticReviewArtifactOccurrence as bu, SemanticReviewArtifactOccurrenceGeometry as bv, SemanticReviewArtifactPosition as bw, SemanticReviewArtifactSource as bx, SemanticTrackedChangeArtifactRecord as by, ShapeInput as bz, NoteStoryRecord as c, ContentControlLock as d, StyleSpanRecord as e, SectionPageBorders as f, TableRowFragmentRecord as g, TableCellFragmentRecord as h, ShapingEnvironmentInput as i, TextShaper as j, ResolvedFont as k, NormalizationPolicy as l, FixedPointRoundingMode as m, FontRequest as n, SemanticReviewArtifactRecord as o, ListMarkerPictureRecord as p, FontSubstitution as q, ShapedRun as r, NumberingLevel as s, NumberingIndex as t, DrawingInsets as u, TableBorderSide as v, TableFloatXSpec as w, TableFloatYSpec as x, ResolvedListItem as y, RefFieldContext as z };