@docx-editor.dev/core 2.22.0 → 2.23.0

package/dist/{semantic-records-C5OeXnaL.d.ts → semantic-records-DB0VgWsr.d.ts}

@@ -1,7 +1,7 @@
-import { c as RevisionAttribution, a as RevisionDisplayMode } from './revision-projection-DDVBYTIG.js';
-import { a0 as OoxmlProperty, a1 as OoxmlElement, i as OoxmlNode, O as OoxmlPart, aG as TableBorderStyle, aH as DrawingAccessibility, aI as DrawingImageEffects, a8 as SourceCrop, aJ as DrawingTransform, aK as VectorShapeProjection, aj as DrawingHorizontalReferenceFrame, ak as DrawingVerticalReferenceFrame, aa as ImageWrapTarget, a4 as DrawingProjection, aL as OoxmlDrawingNode } from './types-barrel-ChGvWjkO.js';
-import { b as ImageResourceState } from './image-resources-B0v-XaTM.js';
-import { O as OmmlEquationProjection } from './omml-equation-CfTm3jOK.js';
+import { c as RevisionAttribution, a as RevisionDisplayMode } from './revision-projection-CVJeA2jp.js';
+import { a0 as OoxmlProperty, a1 as OoxmlElement, N as OoxmlNode, O as OoxmlPart, aG as TableBorderStyle, aH as DrawingAccessibility, aI as DrawingImageEffects, a8 as SourceCrop, aJ as DrawingTransform, aK as VectorShapeProjection, aj as DrawingHorizontalReferenceFrame, ak as DrawingVerticalReferenceFrame, aa as ImageWrapTarget, a4 as DrawingProjection, aL as OoxmlDrawingNode } from './types-barrel-DN_-gaRX.js';
+import { b as ImageResourceState } from './image-resources-DkuzBnTM.js';
+import { O as OmmlEquationProjection } from './omml-equation-BY7OdfGY.js';
 
 /** A strikeout stroke at the drawn size, in points. `offsetPt` is the stroke TOP. @public */
 interface StrikeoutStrokePt {
@@ -96,7 +96,10 @@ type ListMarkerAlign = 'left' | 'center' | 'right';
  * must not overwrite an inherited `hanging` with a synthesized zero.
  */
 interface NumberingLevelIndent {
-    /** Authored physical/logical sides, in points, before paragraph direction resolves them. */
+    /**
+     * 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;
@@ -110,9 +113,9 @@ interface NumberingLevelIndent {
     /**
      * Which of these the LEVEL actually authored.
      *
-     * A level's `w:pPr/w:ind` sits between the paragraph style and direct formatting, so the
-     * merge has to tell "the level says left = 0" from "the level says nothing about left and
-     * the style's value stands". Absent (the default) reads as "says nothing", which is what a
+     * 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?: {
@@ -239,894 +242,947 @@ declare function resolveNumberingLevel(index: NumberingIndex, numId: string, ilv
 declare const EMPTY_NUMBERING_INDEX: NumberingIndex;
 
 /**
- * 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.
+ * A face, as something asks for it: family plus the two axes this engine admits.
  *
- * 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.
+ * 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.
  */
-declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
+interface FontRequest {
+    readonly family: string;
+    readonly weight: number;
+    readonly style: 'normal' | 'italic';
+}
 /**
- * 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.
+ * 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.
  */
-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;
+interface FontSubstitution {
+    readonly requested: FontRequest;
+    readonly resolved: FontRequest;
+    readonly lineMetrics?: {
+        readonly heightEm: number;
+        readonly baselineEm: number;
+    };
+}
+declare const RESOLVED_FONT_BRAND: unique symbol;
 /**
- * A paragraph's resolved space before and after, in points.
+ * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
+ * a font.
  *
- * 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.
+ * 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 ParagraphSpacing {
-    /** `w:spacing/@before`, in points. */
-    readonly before: number;
-    /** `w:spacing/@after`, in points. */
-    readonly after: number;
+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;
 }
 /**
- * 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).
+ * Largest single face this engine will ever admit, whatever a caller configures.
  *
- * 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.
+ * 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 AUTO_PARAGRAPH_SPACING_PT = 14;
+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;
 /**
- * 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.
+ * Why a face was not admitted.
  *
- * 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/`.
+ * `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.
  */
-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;
-}
+type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
 /**
- * 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.
+ * A face that could not be admitted, carrying whatever evidence the refusal produced.
  *
- * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
- * does. `atLeast` uses it as a floor.
+ * 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.
  */
-type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
+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;
+    });
+}
 /**
- * Resolved line spacing: the rule, and the value it applies.
+ * One face offered to a snapshot, before admission.
  *
- * `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.
+ * `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 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;
+interface FontResourceDefinition {
+    readonly request: FontRequest;
+    readonly id: string;
+    readonly bytes: Uint8Array;
+    readonly hash: string;
+    readonly faceIndex: number;
+    readonly availability?: 'available' | 'forbidden';
 }
-/** 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.
+ * A host-declared redirect: requests for `from` resolve to `to`.
  *
- * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
- * unbounded border width becomes a layout dimension.
+ * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
+ * without the document being rewritten.
  */
-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;
+interface DeclaredFontSubstitution {
+    readonly from: FontRequest;
+    readonly to: FontRequest;
+    readonly lineMetrics?: {
+        readonly heightEm: number;
+        readonly baselineEm: number;
+    };
 }
-/** 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"];
+/** 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;
+};
 /**
- * Which of the six `CT_PBdr` edges.
+ * The injected check that bytes really are a font.
  *
- * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
- * consecutive paragraphs share a border definition.
+ * 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 ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
+type FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;
 /**
- * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
+ * An immutable set of admitted faces, and the only way to reach one.
  *
- * `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.
+ * `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 ParagraphBorders {
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-    readonly between?: ParagraphBorderEdge;
-    readonly bar?: ParagraphBorderEdge;
+interface FontResourceSnapshot {
+    readonly epoch: number;
+    /** The admitted face, or a typed refusal. Never throws. */
+    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
 }
 /**
- * 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.
+ * How a snapshot is built: which faces, under what limits, validated how.
  *
- * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
- * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
+ * `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.
  */
-declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
+interface FontResourceSnapshotOptions {
+    readonly epoch: number;
+    readonly maxFontBytes: number;
+    readonly resources: readonly FontResourceDefinition[];
+    readonly substitutions?: readonly DeclaredFontSubstitution[];
+    readonly validateFont: FontByteValidator;
+    readonly instrumentation?: FontResourceInstrumentation;
+}
 /**
- * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
+ * Optional counters for the operations font admission is expected to do RARELY.
  *
- * 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.
+ * 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.
  */
-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/`.
+interface FontResourceInstrumentation {
+    readonly onOwnedByteCopy?: () => void;
+    readonly onHash?: () => void;
+    readonly onTableScan?: () => void;
+    readonly onAdmission?: () => void;
+}
+/**
+ * The canonical string identifying one face request.
  *
- * Exact-height boxes place their baseline at 80% of the height; the legacy
- * noExtraLineSpacing switch instead preserves the face baseline within the box.
+ * 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 function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
-    height: number;
-    baseline: number;
-};
+declare const fontRequestKey: (request: FontRequest) => string;
+/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
+declare const boundedStructuralFontValidator: FontByteValidator;
 /**
- * `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.
+ * 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 function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
+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;
+};
 /**
- * Resolve `w:pBdr` from the paragraph-properties node.
+ * Brand a safe integer as a {@link FixedPoint} coordinate.
  *
- * 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.
+ * 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 function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+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';
 /**
- * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
+ * The shaping library and its exact version.
  *
- * 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.
+ * 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.
  */
-declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
+interface VersionedShapingLibrary {
+    readonly name: string;
+    readonly version: string;
+}
 /**
- * Visual stroke thickness layout publishes for one edge (points).
+ * Everything that determines how text shapes — the complete input to a
+ * {@link ShapingEnvironment}.
  *
- * 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.
+ * 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.
  */
-declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+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;
+}
 /**
- * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
+ * A validated {@link ShapingEnvironmentInput} — build one with `createShapingEnvironment`.
  *
- * 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.
+ * 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.
  */
-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;
+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;
 /**
- * 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.
+ * One positioned glyph.
  *
- * Empty string means "no borders", which never groups with anything.
+ * `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.
  */
-declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
+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;
+}
 /**
- * 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.
+ * 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.
  */
-declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+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;
+}
 /**
- * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ * A stretch of glyphs that came from ONE face.
  *
- * 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.
+ * 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.
  */
-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;
+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;
 }
 /**
- * A run's character properties after the full cascade, in the units layout works in.
+ * One shaped run: text turned into positioned glyphs, with everything needed to measure it, paint
+ * it, and put a caret in it.
  *
- * Points rather than half-points, RRGGBB rather than theme references — everything already
- * resolved, so measurement and paint never re-run the cascade per glyph.
+ * The engine's measurement unit. Layout never measures characters — it measures these.
  */
-interface ResolvedRunStyle {
-    readonly fontFamily: string | null;
+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 `eastAsia` slot's typeface (`w:rFonts w:eastAsia`/`w:eastAsiaTheme`), or null when
-     * no level authors one.
+     * 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`.
      *
-     * 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`).
+     * 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 fontFamilyEastAsia: string | null;
-    /** 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;
-    };
-    /** 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;
+    readonly exactAdvancesX?: readonly number[];
 }
-/** 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.
+ * A {@link ShapedRun} reduced to the fields two shaping results must agree on to be considered
+ * identical.
  *
- * 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.
+ * 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 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>>;
+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;
 }
 /**
- * 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.
+ * The one thing layout needs from a shaping backend.
  *
- * `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.
+ * 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.
  */
-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;
+interface TextShaper {
+    shape(input: ShapeInput): ShapedRun;
+}
 /**
- * How far a run's glyphs are lifted off the line's baseline, in points. Positive is up.
+ * A font reduced to the values that identify it for fingerprinting.
  *
- * 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.
+ * 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.
  */
-declare function baselineShiftPtOf(style: ResolvedRunStyle): number;
+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;
+}
 /**
- * Shared glyph-size factor for baseline, superscript, and subscript text.
+ * A {@link ShapingEnvironment} reduced to comparable values.
  *
- * 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
+ * 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.
  */
-declare function glyphSizeFactorOf(style: ResolvedRunStyle): number;
-
+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;
+}
 /**
- * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
- * within.
+ * Validate and freeze a shaping environment.
  *
- * 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.
+ * 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.
  */
-interface BidiEmbeddingLevels {
-    readonly levels: Uint8Array;
-    readonly paragraphs: readonly {
-        readonly start: number;
-        readonly end: number;
-        readonly level: number;
-    }[];
-}
-
+declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
 /**
- * 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.
+ * Reduce an environment to its comparable form, with records sorted so key order cannot affect
+ * the result.
  */
-interface FontRequest {
-    readonly family: string;
-    readonly weight: number;
-    readonly style: 'normal' | 'italic';
-}
+declare const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
+/** Canonical serialization of every shaping variable, including byte hash and provenance. */
+declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
 /**
- * A request that was answered by a DIFFERENT face than the one asked for.
+ * Validate and freeze a shaped run against the environment that produced it.
  *
- * 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.
+ * 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.
  */
-interface FontSubstitution {
-    readonly requested: FontRequest;
-    readonly resolved: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
-}
-declare const RESOLVED_FONT_BRAND: unique symbol;
+declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
 /**
- * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
- * a font.
+ * Reduce a shaped run to its comparable form, validating it on the way through.
  *
- * 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.
+ * What the D9 determinism oracles compare: two shaping runs of the same text in the same
+ * environment must produce byte-identical structures here.
  */
-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;
-}
+declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
+
 /**
- * Largest single face this engine will ever admit, whatever a caller configures.
+ * Whether a paragraph must start a new page (`w:pageBreakBefore`).
  *
- * 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.
+ * 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 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;
+declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
 /**
- * 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.
+ * 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.
  */
-type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
+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 face that could not be admitted, carrying whatever evidence the refusal produced.
+ * A paragraph's resolved space before and after, in points.
  *
- * 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.
+ * 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.
  */
-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;
-    });
+interface ParagraphSpacing {
+    /** `w:spacing/@before`, in points. */
+    readonly before: number;
+    /** `w:spacing/@after`, in points. */
+    readonly after: number;
 }
 /**
- * One face offered to a snapshot, before admission.
+ * 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).
  *
- * `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".
+ * 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.
  */
-interface FontResourceDefinition {
-    readonly request: FontRequest;
-    readonly id: string;
-    readonly bytes: Uint8Array;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly availability?: 'available' | 'forbidden';
-}
+declare const AUTO_PARAGRAPH_SPACING_PT = 14;
 /**
- * A host-declared redirect: requests for `from` resolve to `to`.
+ * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
+ * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
  *
- * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
- * without the document being rewritten.
+ * 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 DeclaredFontSubstitution {
-    readonly from: FontRequest;
-    readonly to: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
+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;
 }
-/** 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.
+ * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
  *
- * 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.
+ * `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 FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;
+type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
 /**
- * An immutable set of admitted faces, and the only way to reach one.
+ * Resolved line spacing: the rule, and the value it applies.
  *
- * `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.
+ * `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 FontResourceSnapshot {
-    readonly epoch: number;
-    /** The admitted face, or a typed refusal. Never throws. */
-    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
+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;
 /**
- * How a snapshot is built: which faces, under what limits, validated how.
+ * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
  *
- * `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.
+ * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
+ * unbounded border width becomes a layout dimension.
  */
-interface FontResourceSnapshotOptions {
-    readonly epoch: number;
-    readonly maxFontBytes: number;
-    readonly resources: readonly FontResourceDefinition[];
-    readonly substitutions?: readonly DeclaredFontSubstitution[];
-    readonly validateFont: FontByteValidator;
-    readonly instrumentation?: FontResourceInstrumentation;
+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"];
 /**
- * Optional counters for the operations font admission is expected to do RARELY.
+ * Which of the six `CT_PBdr` edges.
  *
- * 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.
+ * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
+ * consecutive paragraphs share a border definition.
  */
-interface FontResourceInstrumentation {
-    readonly onOwnedByteCopy?: () => void;
-    readonly onHash?: () => void;
-    readonly onTableScan?: () => void;
-    readonly onAdmission?: () => void;
+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;
 }
 /**
- * The canonical string identifying one face request.
+ * 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.
  *
- * 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.
+ * 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 const fontRequestKey: (request: FontRequest) => string;
-/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
-declare const boundedStructuralFontValidator: FontByteValidator;
+declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
 /**
- * Admit a set of faces and return the immutable snapshot layout resolves against.
+ * Apply resolved line spacing to a line's natural (glyph-derived) box.
  *
- * 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".
+ * `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` line of a snapping paragraph under an active line grid takes whole pitches
+ * instead ({@link gridLineBox}); `trailing` then names the extra below the grid line.
  */
-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;
+declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
+    height: number;
+    baseline: number;
+    trailing?: number;
 };
 /**
- * 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.
+ * `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 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';
+declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
 /**
- * The shaping library and its exact version.
+ * Resolve `w:pBdr` from the paragraph-properties node.
  *
- * 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.
+ * 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.
  */
-interface VersionedShapingLibrary {
-    readonly name: string;
-    readonly version: string;
-}
+declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
 /**
- * Everything that determines how text shapes — the complete input to a
- * {@link ShapingEnvironment}.
+ * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
  *
- * 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.
+ * 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.
  */
-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;
-}
+declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
 /**
- * A validated {@link ShapingEnvironmentInput} — build one with `createShapingEnvironment`.
+ * Visual stroke thickness layout publishes for one edge (points).
  *
- * 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.
+ * 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.
  */
-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;
-}
+declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
 /**
- * One positioned glyph.
+ * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
  *
- * `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.
+ * 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.
  */
-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;
-}
+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;
 /**
- * One cluster: the smallest indivisible text-to-glyph correspondence.
+ * Identity of a paragraph's border set, for the `w:between` group rule.
  *
- * 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.
+ * 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.
  */
-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;
-}
+declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
 /**
- * A stretch of glyphs that came from ONE face.
+ * 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).
  *
- * 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.
+ * 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.
  */
-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;
+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;
 }
 /**
- * One shaped run: text turned into positioned glyphs, with everything needed to measure it, paint
- * it, and put a caret in it.
+ * A run's character properties after the full cascade, in the units layout works in.
  *
- * The engine's measurement unit. Layout never measures characters — it measures these.
+ * 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 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;
+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;
     /**
-     * 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`.
+     * Character shading fill (`w:rPr/w:shd`), validated RRGGBB, or null.
      *
-     * 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.
+     * 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.
      *
-     * Absent on runs an assembly path cannot state exactly; a reader falls back to `originX`.
+     * 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 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;
+    readonly hidden: boolean;
 }
+/** The style a run inherits when it authors nothing. */
+declare const DEFAULT_RUN_STYLE: ResolvedRunStyle;
 /**
- * The one thing layout needs from a shaping backend.
+ * The theme part's typefaces, for resolving `w:rFonts` theme attributes.
  *
- * 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.
+ * 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 TextShaper {
-    shape(input: ShapeInput): ShapedRun;
+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>>;
 }
 /**
- * A font reduced to the values that identify it for fingerprinting.
+ * Resolve one run's direct formatting.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * `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.
  */
-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;
-}
+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;
 /**
- * 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.
+ * How far a run's glyphs are lifted off the line's baseline, in points. Positive is up.
  *
- * @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.
+ * 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 const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
-/** Canonical serialization of every shaping variable, including byte hash and provenance. */
-declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
+declare function baselineShiftPtOf(style: ResolvedRunStyle): number;
 /**
- * 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.
+ * Shared glyph-size factor for baseline, superscript, and subscript text.
  *
- * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
+ * 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 const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
+declare function glyphSizeFactorOf(style: ResolvedRunStyle): number;
+
 /**
- * Reduce a shaped run to its comparable form, validating it on the way through.
+ * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
+ * within.
  *
- * What the D9 determinism oracles compare: two shaping runs of the same text in the same
- * environment must produce byte-identical structures here.
+ * 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.
  */
-declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
+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.
@@ -1180,6 +1236,27 @@ declare function itemizeScriptFontSlots(text: string, paragraphOffset: number, e
  */
 declare function styleForFontSlot(style: ResolvedRunStyle, slot: FontSlot | undefined): ResolvedRunStyle;
 
+type AllowlistedPageField = 'PAGE' | 'NUMPAGES' | 'SECTIONPAGES';
+/**
+ * Which allowlisted page fields a header/footer story actually contains.
+ *
+ * Drives layout reuse: no fields → one baseline; NUMPAGES only → one layout per page count;
+ * SECTIONPAGES only → one layout per section page count; PAGE (alone or combined) → per
+ * distinct evaluated values with a bounded cache. Counts both complex markers and
+ * `w:fldSimple` (including an allowlisted page field nested inside a non-page simple field).
+ */
+interface StoryPageFieldNeeds {
+    readonly hasPage: boolean;
+    readonly hasNumPages: boolean;
+    readonly hasSectionPages: boolean;
+    /**
+     * 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;
+}
+
 /**
  * One parsed `HYPERLINK` instruction: the raw, unsanitized pieces.
  *
@@ -1304,21 +1381,6 @@ interface RefNoteParts {
  */
 declare function resolveStoryRefFields(blocks: readonly OoxmlElement[], listItems: ReadonlyMap<string, ResolvedListItem> | undefined, notes?: RefNoteParts): RefFieldContext | null;
 
-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;
-}
-
 /**
  * What a piece says about the FIELD result it came from, for Word's shading.
  *
@@ -1454,6 +1516,11 @@ interface TabStop {
     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;
 }
@@ -1466,6 +1533,11 @@ interface ResolvedTabStops {
     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;
@@ -1778,6 +1850,15 @@ interface TextboxStoryLayout {
     readonly clippedResourceToken?: string;
 }
 
+/** 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;
@@ -1812,6 +1893,15 @@ interface InlineDrawingRecord {
     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.
@@ -1930,18 +2020,22 @@ declare function readNumPr(paragraphPropertyNodes: readonly OoxmlNode[]): {
  */
 declare function withNumberingStyleLinks(index: NumberingIndex, styleCascade: StyleCascadeTable | undefined): NumberingIndex;
 /**
- * The effective indent of a list paragraph: STYLE, then the numbering LEVEL, then DIRECT.
+ * The effective indent of a list paragraph: `inherited`, then the numbering LEVEL, then
+ * `direct`, per attribute.
  *
- * Word applies a level's `w:pPr/w:ind` between the paragraph style and the paragraph's own
- * formatting, per attribute — and the ordering matters on real documents. A converted
- * agreement numbers its `(a)` items with a level stating `left=1512 hanging=738` under a
- * `ListParagraph` style stating `left=775 hanging=624`, and states only `hanging="737"` on
- * the paragraph itself. Reading the flattened cascade as "the paragraph's indent" gave the
- * STYLE's 775 to a level that had overridden it, so every lettered sub-item hung a full
- * indent step to the left of where Word puts it.
+ * 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 the cascade WITHOUT the paragraph's own `w:pPr` (defaults, table cell style,
- * style chain); `direct` is that `w:pPr` alone.
+ * `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;
 /**
@@ -1976,6 +2070,7 @@ declare function withResolvedListItems<T extends {
 
 interface StyleDefinition {
     readonly styleId: string;
+    readonly name?: string;
     readonly type: string;
     readonly basedOn: string | null;
     /** `w:next` — the authoring style for a following paragraph. */
@@ -1991,8 +2086,6 @@ interface StyleDefinition {
 }
 declare function isValidStyleId(raw: string | undefined): raw is string;
 
-/** Soft ceiling on `basedOn` chain length — enough for real templates, refuses hostile graphs. */
-declare const MAX_STYLE_BASED_ON_DEPTH = 32;
 /** Soft ceiling on style definitions read from one styles part. */
 declare const MAX_STYLE_DEFINITIONS = 4096;
 /**
@@ -2002,10 +2095,21 @@ declare const MAX_STYLE_DEFINITIONS = 4096;
  * 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;
     /** Explicit compatibility opt-in to the unmodified ISO table style hierarchy. */
     readonly strictTableStyleHierarchy?: boolean;
     readonly typography?: CjkTypographySettings;
@@ -2048,12 +2152,7 @@ interface StyleCascadeTable {
 interface CascadedParagraphFormatting {
     /** Flat paragraph properties in cascade order (defaults → bases → style → direct). */
     readonly paragraphProperties: readonly OoxmlProperty[];
-    /**
-     * The same list WITHOUT the paragraph's own `w:pPr` — everything it inherits.
-     *
-     * Numbering needs the two tiers apart: a level's `w:pPr/w:ind` outranks the style's and is
-     * outranked by the paragraph's own, and a flattened list cannot say which is which.
-     */
+    /** 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[];
@@ -2066,7 +2165,9 @@ interface CascadedParagraphFormatting {
      */
     readonly runProperties: readonly OoxmlProperty[];
     /**
-     * Content cascade plus direct `w:pPr/w:rPr` — empty-line metrics and last-line mark height.
+     * 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[];
     /**
@@ -2165,8 +2266,8 @@ interface ParagraphLayoutInputs {
     readonly shading: string | undefined;
     readonly inheritedRunProperties: readonly OoxmlProperty[];
     /**
-     * Paragraph-mark cascade (`inheritedRunProperties` + direct `w:pPr/w:rPr`).
-     * Empty-line sizing and last-line mark height — never content-run face.
+     * 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. */
@@ -2192,6 +2293,9 @@ interface ParagraphLayoutInputs {
  *
  * `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;
 
@@ -2644,9 +2748,9 @@ interface LineRecord {
     /** Distance from the line box top to the text baseline. */
     readonly baseline: number;
     /**
-     * Space ABOVE the glyph band inside {@link box} (exact centering, not auto/atLeast).
+     * Space ABOVE the glyph band inside {@link box} (exact centering, atLeast growth).
      *
-     * `auto` / `atLeast` extras grow the box BELOW the glyphs — paint puts that depth in
+     * `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.
      *
@@ -2655,18 +2759,18 @@ interface LineRecord {
      */
     readonly leading: number;
     /**
-     * Auto/atLeast line-spacing depth BELOW the glyph band, inside {@link box}.
+     * Auto line-spacing depth BELOW the glyph band, inside {@link box}.
      *
-     * The complement of {@link leading}: exact spacing centres the glyphs and moves the
-     * baseline down, while auto/atLeast leave the band at the top and grow the box beneath it.
+     * 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 the exact rule.
+     * 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 the exact rule and on lines holding drawings, where the box is authored.
+     * Zero under exact and atLeast, and on lines holding drawings (the box is authored).
      * Absent on lines published before this was measured; treat as zero.
      */
     readonly trailingSpacing?: number;
@@ -2742,8 +2846,9 @@ interface ParagraphFragmentRecord {
     readonly clipToBox?: true;
     /**
      * The fragment retains its source identity without consuming body flow height: a positioned
-     * text frame (with {@link ParagraphFragmentRecord.positionedFrame}), or an empty section-mark
-     * paragraph before a continuous section, which paints nothing.
+     * 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. */
@@ -2903,11 +3008,8 @@ interface ListMarkerRecord {
      */
     readonly level: number;
     /**
-     * The `w:numId` this marker resolved through.
-     *
-     * Published with the level because the two together are what identifies a list: whether
-     * a demote is even possible depends on which levels THIS definition declares, and a
-     * document may hold several lists whose level 0 looks identical.
+     * 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. */
@@ -2924,6 +3026,11 @@ interface ListMarkerRecord {
      * 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.
@@ -3007,16 +3114,14 @@ interface TableRowFragmentRecord {
     readonly rowIndex: number;
     /** True when the authored row resolves `w:tblHeader`, including its first occurrence. */
     readonly isHeaderRow: boolean;
-    /**
-     * True for a `w:tblHeader` row RE-EMITTED at the top of a continuation page. Painted,
-     * but excluded from interaction walks so each caret stop exists exactly once.
-     */
+    /** 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 that already emitted content on a prior page
-     * (cell content fragmented at a paragraph/line boundary). Same `id` as the lead fragment.
-     */
+    /** 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;
 }
@@ -3147,7 +3252,7 @@ interface NoteAreaRecord {
     readonly box: LayoutBox;
     /** Separator rule / authored separator story; absent when no notes on this page. */
     readonly separator?: {
-        readonly kind: 'separator' | 'continuationSeparator';
+        readonly kind: 'separator' | 'continuationSeparator' | 'continuationNotice';
         readonly box: LayoutBox;
         readonly fragments: readonly BlockFragmentRecord[];
         readonly synthetic: boolean;
@@ -3156,6 +3261,8 @@ interface NoteAreaRecord {
         /** 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;
 }
@@ -3255,6 +3362,8 @@ interface PageRecord {
      * 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).
@@ -3370,4 +3479,5 @@ interface TextMeasurer {
     };
 }
 
-export { type SpanLinkRecord as $, type AnchoredDrawingRecord as A, type BlockFragmentRecord as B, type ContentControlBoundaryRecord as C, type DrawingPoint as D, type NoteAreaRecord as E, type FontResourceSnapshot as F, type NoteStoryRecord as G, type HeaderFooterStoryRecord as H, type InlineDrawingRecord as I, type ContentControlLock as J, type FontByteValidator as K, type LineRecord as L, type ModelRange as M, type NormalizationPolicy as N, type FixedPoint as O, type PageGeometry as P, type SourceRange as Q, type ResolvedRunStyle as R, type SemanticLayout as S, type TextMeasurer as T, type HyperlinkProjector as U, type VersionedShapingLibrary as V, type InlineDrawingLayoutContext as W, type FieldLinkProjector as X, type StoryPageFieldNeeds as Y, type RefFieldContext as Z, type HyperlinkFieldSpec as _, type StyleSpanRecord as a, type PageBorderDisplay as a$, type PageBorderFrameRecord as a0, type ParagraphBorderStrokeRecord as a1, type StrikeoutStrokePt as a2, AUTO_PARAGRAPH_SPACING_PT as a3, type AbstractNumDefinition as a4, type AnchoredDrawingLayoutFallback as a5, type BidiEmbeddingLevels as a6, type BorderGridGeometry as a7, type CascadedParagraphFormatting as a8, type CjkTypographySettings as a9, type FontResourceSnapshotOptions as aA, type FontSlot as aB, type FontValidationResult as aC, type GlyphOutline as aD, HARD_MAX_AGGREGATE_FONT_BYTES as aE, HARD_MAX_FONT_BYTES as aF, HARD_MAX_FONT_SOURCES as aG, type LevelOverride as aH, type LineSpacingRule as aI, type ListMarkerAlign as aJ, type ListMarkerRecord as aK, type ListSuffix as aL, MAX_BORDER_SPACE_PT as aM, MAX_BORDER_WIDTH_PT as aN, MAX_LVL_OVERRIDES as aO, MAX_NUMBERING_DEFINITIONS as aP, MAX_PARAGRAPH_SPACING_PT as aQ, MAX_STYLE_BASED_ON_DEPTH as aR, MAX_STYLE_DEFINITIONS as aS, MAX_TABLE_BORDER_STROKES as aT, MAX_TAB_POSITION_TWIPS as aU, MAX_TAB_STOPS as aV, type NumDefinition as aW, type NumberingLevelIndent as aX, type NumberingPictureBullet as aY, PAGE_BORDER_SIDES as aZ, PARAGRAPH_BORDER_SIDES as a_, type ContentControlGeometryFragment as aa, type ContentControlLevel as ab, type ContentControlMappedType as ac, DEFAULT_PAGE_GEOMETRY as ad, DEFAULT_RUN_STYLE as ae, DEFAULT_TAB_INTERVAL_PT as af, DEFAULT_TAB_INTERVAL_TWIPS as ag, type DeclaredFontSubstitution as ah, type DrawingClipFallback as ai, type DrawingGeometry as aj, EMPTY_NUMBERING_INDEX as ak, EMPTY_TAB_STOPS as al, type EquationFractionGeometry as am, type EquationGeometry as an, type EquationNaryGeometry as ao, type EquationRadicalGeometry as ap, type EquationRowGeometry as aq, type EquationScriptGeometry as ar, type EquationSpanRecord as as, type EquationTextGeometry as at, type FieldAtomMarker as au, type FontFingerprintInputs as av, FontResolutionError as aw, type FontResolutionErrorCode as ax, type FontResourceDefinition as ay, type FontResourceInstrumentation as az, type SectionPageBorders as b, buildStyleCascadeTable as b$, type PageBorderOffsetFrom as b0, type PageBorderSide as b1, type PageBorderStrokeRecord as b2, type PageBorderZOrder as b3, type PageRefCalibrationCell as b4, type PageRefFieldProjection as b5, type ParagraphAutoSpacingContext as b6, type ParagraphBorderEdge as b7, type ParagraphBorderSide as b8, type ParagraphBorders as b9, type ShapedGlyph as bA, type ShapedRunComparatorInputs as bB, type ShapedVerticalMetrics as bC, type ShapingEnvironment as bD, type ShapingEnvironmentFingerprintInputs as bE, type StyleDefinition as bF, TAB_LEADER_GLYPH as bG, type TabAlignment as bH, type TabDestination as bI, type TabLeader as bJ, type TabStop as bK, type TableBorderSideName as bL, type TableBorderStrokeRecord as bM, type TableFragmentRecord as bN, type TextDirection as bO, type TextboxStoryFallbackReason as bP, type TextboxStoryLayout as bQ, UnsupportedScriptError as bR, type VerticalAlign as bS, appliedSpaceBefore as bT, applyLineSpacing as bU, baselineShiftPtOf as bV, borderExtentPt as bW, borderWeight as bX, bottomBorderExtentPt as bY, boundedStructuralFontValidator as bZ, buildNumberingIndex as b_, type ParagraphBottomBorderRecord as ba, type ParagraphIndent as bb, type ParagraphLayoutInputs as bc, type ParagraphLineSpacing as bd, type ParagraphSpacing as be, type RefFieldSpec as bf, type RefNoteParts as bg, type ResolvedCellBorders as bh, type ResolvedPictureBullet as bi, type ResolvedTabStops as bj, type ResolvedTableBorderEdge as bk, type ResolvedTableBorderEdgeSegment as bl, type ResolvedUnderline as bm, SINGLE_LINE_SPACING as bn, type ScriptItem as bo, type SemanticArtifactRootStoryKind as bp, type SemanticArtifactStoryKind as bq, type SemanticCommentArtifactRecord as br, type SemanticReviewArtifactOccurrence as bs, type SemanticReviewArtifactOccurrenceGeometry as bt, type SemanticReviewArtifactPosition as bu, type SemanticReviewArtifactSource as bv, type SemanticTrackedChangeArtifactRecord as bw, type ShapeInput as bx, type ShapedCluster as by, type ShapedFontSpan as bz, type TableRowFragmentRecord as c, cascadeParagraphFormatting as c0, cascadeRunProperties as c1, cascadedBottomBorder as c2, cascadedParagraphBorders as c3, cascadedTabStops as c4, collapsedSpaceBefore as c5, createFontResourceSnapshot as c6, createShapedRun as c7, createShapingEnvironment as c8, defaultTabIntervalFromSettings as c9, resolveBorderConflict as cA, resolveNumberingLevel as cB, resolveParagraphLayoutInputs as cC, resolveRunStyle as cD, resolveStoryListItems as cE, resolveStoryRefFields as cF, resolveTableCellBorderGrid as cG, runStylesEqual as cH, shapedRunComparatorInputs as cI, shapingEnvironmentFingerprint as cJ, shapingEnvironmentFingerprintInputs as cK, styleForFontSlot as cL, tabAdvanceWidth as cM, tabStopsFingerprint as cN, walkStoryParagraphs as cO, withDefaultTabInterval as cP, withNumberingStyleLinks as cQ, withResolvedListItems as cR, displayText as ca, fixedPoint as cb, fontRequestKey as cc, glyphSizeFactorOf as cd, isValidStyleId as ce, itemizeScriptFontSlots as cf, layoutEquation as cg, measureDisplayText as ch, mergeListIndent as ci, nextTabDestination as cj, pageBordersFingerprint as ck, paragraphBorderExtentPt as cl, paragraphBorderStrokeWidthPt as cm, paragraphBorders as cn, paragraphBordersFingerprint as co, paragraphBreaksBefore as cp, paragraphContextualSpacing as cq, paragraphLineSpacing as cr, paragraphSpacing as cs, paragraphTabStops as ct, parsePageBorders as cu, parseRefInstruction as cv, readBorderSide as cw, readCellBorders as cx, readNumPr as cy, readTableBorders as cz, type TableCellFragmentRecord as d, type ShapingEnvironmentInput as e, type TextShaper as f, type ResolvedFont as g, type FixedPointRoundingMode as h, type FontRequest as i, type SemanticReviewArtifactRecord as j, type ListMarkerPictureRecord as k, type FontSubstitution as l, type ShapedRun as m, type NumberingLevel as n, type NumberingIndex as o, type ParagraphFragmentRecord as p, type LayoutBox as q, type DrawingInsets as r, type TableBorderSide as s, type PageRecord as t, type ResolvedListItem as u, type CellBorderBox as v, type TableCellStyleFormatting as w, type TableFloatPosition as x, type TableBorderBox as y, type StyleCascadeTable as z };
+export { PARAGRAPH_BORDER_SIDES as a$, AUTO_PARAGRAPH_SPACING_PT as a3, HARD_MAX_AGGREGATE_FONT_BYTES as aF, HARD_MAX_FONT_BYTES as aG, HARD_MAX_FONT_SOURCES as aH, MAX_BORDER_SPACE_PT as aN, MAX_BORDER_WIDTH_PT as aO, MAX_LVL_OVERRIDES as aP, MAX_NUMBERING_DEFINITIONS as aQ, MAX_PARAGRAPH_SPACING_PT as aR, MAX_SHAPING_CONTEXT as aS, MAX_STYLE_DEFINITIONS as aT, MAX_TABLE_BORDER_STROKES as aU, MAX_TAB_POSITION_TWIPS as aV, MAX_TAB_STOPS as aW, PAGE_BORDER_SIDES as a_, DEFAULT_PAGE_GEOMETRY as ad, 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, boundedStructuralFontValidator as b$, TAB_LEADER_GLYPH as bI, UnsupportedScriptError as bT, appliedSpaceBefore as bV, applyLineSpacing as bW, baselineShiftPtOf as bX, borderExtentPt as bY, borderWeight as bZ, bottomBorderExtentPt as b_, SINGLE_LINE_SPACING as bo, buildNumberingIndex as c0, buildStyleCascadeTable as c1, cascadeParagraphFormatting as c2, cascadeRunProperties as c3, cascadedBottomBorder as c4, cascadedParagraphBorders as c5, cascadedTabStops as c6, collapsedSpaceBefore as c7, createFontResourceSnapshot as c8, createShapedRun as c9, readNumPr as cA, readTableBorders as cB, resolveBorderConflict as cC, resolveNumberingLevel as cD, resolveParagraphLayoutInputs as cE, resolveRunStyle as cF, resolveStoryListItems as cG, resolveStoryRefFields as cH, resolveTableCellBorderGrid as cI, runStylesEqual as cJ, shapedRunComparatorInputs as cK, shapingEnvironmentFingerprint as cL, shapingEnvironmentFingerprintInputs as cM, styleForFontSlot as cN, tabAdvanceWidth as cO, tabStopsFingerprint as cP, walkStoryParagraphs as cQ, withDefaultTabInterval as cR, withNumberingStyleLinks as cS, withResolvedListItems as cT, createShapingEnvironment as ca, defaultTabIntervalFromSettings as cb, displayText as cc, fixedPoint as cd, fontRequestKey as ce, glyphSizeFactorOf as cf, isValidStyleId as cg, itemizeScriptFontSlots as ch, layoutEquation as ci, measureDisplayText as cj, mergeListIndent as ck, nextTabDestination as cl, pageBordersFingerprint as cm, paragraphBorderExtentPt as cn, paragraphBorderStrokeWidthPt as co, paragraphBorders as cp, paragraphBordersFingerprint as cq, paragraphBreaksBefore as cr, paragraphContextualSpacing as cs, paragraphLineSpacing as ct, paragraphSpacing as cu, paragraphTabStops as cv, parsePageBorders as cw, parseRefInstruction as cx, readBorderSide as cy, readCellBorders as cz };
+export type { SpanLinkRecord as $, AnchoredDrawingRecord as A, BlockFragmentRecord as B, ContentControlBoundaryRecord as C, DrawingPoint as D, NoteAreaRecord as E, FontResourceSnapshot as F, NoteStoryRecord as G, HeaderFooterStoryRecord as H, InlineDrawingRecord as I, ContentControlLock as J, FontByteValidator as K, LineRecord as L, ModelRange as M, NormalizationPolicy as N, FixedPoint as O, PageGeometry as P, SourceRange as Q, ResolvedRunStyle as R, SemanticLayout as S, TextMeasurer as T, HyperlinkProjector as U, VersionedShapingLibrary as V, InlineDrawingLayoutContext as W, FieldLinkProjector as X, StoryPageFieldNeeds as Y, RefFieldContext as Z, HyperlinkFieldSpec as _, StyleSpanRecord as a, PageBorderFrameRecord as a0, ParagraphBorderStrokeRecord as a1, StrikeoutStrokePt as a2, AbstractNumDefinition as a4, AnchoredDrawingLayoutFallback as a5, BidiEmbeddingLevels as a6, BorderGridGeometry as a7, CascadedParagraphFormatting as a8, CjkTypographySettings as a9, FontResourceInstrumentation as aA, FontResourceSnapshotOptions as aB, FontSlot as aC, FontValidationResult as aD, GlyphOutline as aE, LevelOverride as aI, LineSpacingRule as aJ, ListMarkerAlign as aK, ListMarkerRecord as aL, ListSuffix as aM, NumDefinition as aX, NumberingLevelIndent as aY, NumberingPictureBullet as aZ, ContentControlGeometryFragment as aa, ContentControlLevel as ab, ContentControlMappedType as ac, 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, SectionPageBorders as b, PageBorderDisplay as b0, PageBorderOffsetFrom as b1, PageBorderSide as b2, PageBorderStrokeRecord as b3, PageBorderZOrder as b4, PageRefCalibrationCell as b5, PageRefFieldProjection as b6, ParagraphAutoSpacingContext as b7, ParagraphBorderEdge as b8, ParagraphBorderSide as b9, ShapedFontSpan as bA, ShapedGlyph as bB, ShapedRunComparatorInputs as bC, ShapedVerticalMetrics as bD, ShapingContext as bE, ShapingEnvironment as bF, ShapingEnvironmentFingerprintInputs as bG, StyleDefinition as bH, TabAlignment as bJ, TabDestination as bK, TabLeader as bL, TabStop as bM, TableBorderSideName as bN, TableBorderStrokeRecord as bO, TableFragmentRecord as bP, TextDirection as bQ, TextboxStoryFallbackReason as bR, TextboxStoryLayout as bS, VerticalAlign as bU, ParagraphBorders as ba, ParagraphBottomBorderRecord as bb, ParagraphIndent as bc, ParagraphLayoutInputs as bd, ParagraphLineSpacing as be, ParagraphSpacing as bf, RefFieldSpec as bg, RefNoteParts as bh, ResolvedCellBorders as bi, ResolvedPictureBullet as bj, ResolvedTabStops as bk, ResolvedTableBorderEdge as bl, ResolvedTableBorderEdgeSegment as bm, ResolvedUnderline as bn, ScriptItem as bp, SemanticArtifactRootStoryKind as bq, SemanticArtifactStoryKind as br, SemanticCommentArtifactRecord as bs, SemanticReviewArtifactOccurrence as bt, SemanticReviewArtifactOccurrenceGeometry as bu, SemanticReviewArtifactPosition as bv, SemanticReviewArtifactSource as bw, SemanticTrackedChangeArtifactRecord as bx, ShapeInput as by, ShapedCluster as bz, TableRowFragmentRecord as c, TableCellFragmentRecord as d, ShapingEnvironmentInput as e, TextShaper as f, ResolvedFont as g, FixedPointRoundingMode as h, FontRequest as i, SemanticReviewArtifactRecord as j, ListMarkerPictureRecord as k, FontSubstitution as l, ShapedRun as m, NumberingLevel as n, NumberingIndex as o, ParagraphFragmentRecord as p, LayoutBox as q, DrawingInsets as r, TableBorderSide as s, PageRecord as t, ResolvedListItem as u, CellBorderBox as v, TableCellStyleFormatting as w, TableFloatPosition as x, TableBorderBox as y, StyleCascadeTable as z };