@docx-editor.dev/core 2.21.1 → 2.23.0

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

@@ -1,7 +1,85 @@
-import { c as RevisionAttribution, a as RevisionDisplayMode, b as RevisionAuthorFilter } from './revision-projection-kVd7p6Wd.js';
-import { a0 as OoxmlProperty, a1 as OoxmlElement, i as OoxmlNode, O as OoxmlPart, aG as TableBorderStyle, aH as DrawingAccessibility, aI as DrawingImageEffects, a7 as SourceCrop, aJ as DrawingTransform, aK as VectorShapeProjection, ai as DrawingHorizontalReferenceFrame, aj as DrawingVerticalReferenceFrame, a9 as ImageWrapTarget, a4 as DrawingProjection, aL as OoxmlDrawingNode } from './types-barrel-PwcfEkaX.js';
-import { I as ImageResourceState } from './image-resources-DxF-SN_8.js';
-import { O as OmmlEquationProjection } from './omml-equation-Bk3OP1fv.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 {
+    /** Distance from the baseline UP to the top of the stroke. */
+    readonly offsetPt: number;
+    /** Stroke height. Always positive. */
+    readonly thicknessPt: number;
+}
+
+/**
+ * `w:tblpPr/@w:horzAnchor` (17.4.58) and `@w:vertAnchor` (17.4.66): the box a floated
+ * table's offsets are measured from. Absent means `text` for both.
+ */
+type TableFloatAnchor = 'text' | 'margin' | 'page';
+/** `w:tblpPr/@w:tblpXSpec` (17.4.63, ST_XAlign). */
+type TableFloatXSpec = 'left' | 'center' | 'right' | 'inside' | 'outside';
+/** `w:tblpPr/@w:tblpYSpec` (17.4.65, ST_YAlign). */
+type TableFloatYSpec = 'inline' | 'top' | 'center' | 'bottom' | 'inside' | 'outside';
+/**
+ * `w:tblPr/w:tblpPr` (17.4.57) — a table positioned against an anchor box rather than at
+ * the point in the text where it was authored.
+ *
+ * A spec (`tblpXSpec`/`tblpYSpec`) supersedes the matching offset when both are present:
+ * 17.4.57 states the alignment outright, and the offset only answers "how far from the
+ * anchor" for the case where no alignment was stated.
+ */
+interface TableFloatPosition {
+    readonly horzAnchor: TableFloatAnchor;
+    readonly vertAnchor: TableFloatAnchor;
+    readonly xSpec?: TableFloatXSpec;
+    /** `w:tblpX` in points; signed, so a table can be pulled into the margin. */
+    readonly xPt: number;
+    readonly ySpec?: TableFloatYSpec;
+    /** `w:tblpY` in points; signed. */
+    readonly yPt: number;
+    readonly distances?: {
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    };
+}
+
+/**
+ * One `w:numPicBullet`: the image a level draws instead of its `w:lvlText`.
+ *
+ * `relationshipId` is unresolved on purpose — it names a relationship of the numbering part,
+ * and resolving it is the image-resource lookup's job, under its own validation and caps.
+ * @public
+ */
+interface NumberingPictureBullet {
+    /** `w:numPicBulletId` — what a level's `w:lvlPicBulletId` names. */
+    readonly picBulletId: string;
+    /** `v:imagedata/@r:id`, relative to the NUMBERING part's relationships. */
+    readonly relationshipId: string;
+    /** Authored `v:shape` width in points. */
+    readonly width: number;
+    /** Authored `v:shape` height in points. */
+    readonly height: number;
+}
+/**
+ * A level's picture bullet with the size it is actually DRAWN at.
+ *
+ * Separate from {@link NumberingPictureBullet} because the authored `v:shape` extent is not
+ * the painted extent: Word scales it by the marker run's font size. Layout, hit testing and
+ * both paint sinks read `width` / `height`; `authored` is kept so the scale stays inspectable.
+ * @public
+ */
+interface ResolvedPictureBullet {
+    /** `v:imagedata/@r:id`, relative to the NUMBERING part's relationships. */
+    readonly relationshipId: string;
+    /** Painted width in points, after the marker font scale. */
+    readonly width: number;
+    /** Painted height in points, after the marker font scale. */
+    readonly height: number;
+    /** The `v:shape` extent exactly as the file authored it. */
+    readonly authored: NumberingPictureBullet;
+}
 
 /** Soft ceiling on abstractNum / num entries read from one part. */
 declare const MAX_NUMBERING_DEFINITIONS = 512;
@@ -18,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;
@@ -32,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?: {
@@ -63,6 +144,11 @@ interface NumberingLevel {
      * decimal, whatever number format those levels declare for themselves.
      */
     readonly isLgl: boolean;
+    /**
+     * `w:lvlPicBulletId` (§17.9.12): this level's marker is the `w:numPicBullet` of that id,
+     * drawn INSTEAD of `w:lvlText`. Absent on every ordinary level.
+     */
+    readonly picBulletId?: string;
     /** Level `w:rPr` as flat properties (for marker face / vanish). */
     readonly runProperties: readonly OoxmlProperty[];
     /** True when level run props request vanish — marker must not paint. */
@@ -119,6 +205,13 @@ interface NumDefinition {
 interface NumberingIndex {
     readonly abstractNums: ReadonlyMap<string, AbstractNumDefinition>;
     readonly nums: ReadonlyMap<string, NumDefinition>;
+    /**
+     * `w:numPicBullet` declarations keyed by `w:numPicBulletId` (§17.9.20).
+     *
+     * Optional so a hand-built index stays valid; absent reads as "this part declares none",
+     * which is what a level's `w:lvlPicBulletId` then falls back from.
+     */
+    readonly pictureBullets?: ReadonlyMap<string, NumberingPictureBullet>;
 }
 /**
  * Build a numbering index from the root of a numbering part (`w:numbering`).
@@ -148,535 +241,291 @@ declare function resolveNumberingLevel(index: NumberingIndex, numId: string, ilv
 /** Empty index for tests / documents without numbering. */
 declare const EMPTY_NUMBERING_INDEX: NumberingIndex;
 
-/** Soft ceiling matching Word's practical custom-tab UI limit. */
-declare const MAX_TAB_STOPS = 64;
-/**
- * Soft ceiling on a tab position (31_680 twips ≈ 22"), matching paragraph-spacing bounds so
- * a hostile stop cannot shove layout into pathological widths.
- */
-declare const MAX_TAB_POSITION_TWIPS = 31680;
-/** OOXML / Word default when `w:settings/w:defaultTabStop` is absent: 720 twips = 0.5". */
-declare const DEFAULT_TAB_INTERVAL_TWIPS = 720;
-/** The default tab interval in points — {@link DEFAULT_TAB_INTERVAL_TWIPS} converted. */
-declare const DEFAULT_TAB_INTERVAL_PT: number;
 /**
- * How a tab stop positions the text that follows it.
+ * A face, as something asks for it: family plus the two axes this engine admits.
  *
- * Only `left` is a plain cursor jump. The other three size the tab glyph from the MEASURED
- * following segment, so its end, centre or decimal point lands on the stop.
+ * 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.
  */
-type TabAlignment = 'left' | 'center' | 'right' | 'decimal';
+interface FontRequest {
+    readonly family: string;
+    readonly weight: number;
+    readonly style: 'normal' | 'italic';
+}
 /**
- * `w:tab/@w:leader` (ECMA-376 §17.3.1.38, ST_TabTlc): the character repeated across the
- * space a tab reserves. `none` is the default and is represented by an absent leader.
+ * A request that was answered by a DIFFERENT face than the one asked for.
  *
- * This is the difference between a Word table of contents and a column of headings floating
- * next to a column of page numbers, so it is carried through layout to paint rather than
- * dropped as a geometry-irrelevant attribute.
+ * 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.
  */
-type TabLeader = 'dot' | 'hyphen' | 'underscore' | 'heavy' | 'middleDot';
+interface FontSubstitution {
+    readonly requested: FontRequest;
+    readonly resolved: FontRequest;
+    readonly lineMetrics?: {
+        readonly heightEm: number;
+        readonly baselineEm: number;
+    };
+}
+declare const RESOLVED_FONT_BRAND: unique symbol;
 /**
- * The character each leader repeats (§17.3.1.38, ST_TabTlc).
+ * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
+ * a font.
  *
- * Lives with the type rather than with the painter because LAYOUT has to measure it: a
- * leader is the same character typed over and over, and the only way to space it the way
- * typing it would is to ask the measurer how wide it actually is.
+ * 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.
  */
-declare const TAB_LEADER_GLYPH: ReadonlyMap<TabLeader, string>;
-/** One authored `w:tab`: where it sits, how it aligns, and what fills the gap. */
-interface TabStop {
-    /** Position from the paragraph content origin, in points. */
-    readonly positionPt: number;
-    readonly alignment: TabAlignment;
-    /** Absent for `none` — the schema default and the overwhelming majority of stops. */
-    readonly leader?: TabLeader;
+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;
 }
 /**
- * A paragraph's tab stops after the style cascade, with the default interval that applies past
- * the last explicit one.
+ * Largest single face this engine will ever admit, whatever a caller configures.
+ *
+ * A CEILING, not a default: a host may set a smaller `maxFontBytes`, but nothing can raise it
+ * past this. Font bytes come from files, and an unbounded face is a memory-exhaustion vector.
  */
-interface ResolvedTabStops {
-    /** Custom stops sorted by ascending position. */
-    readonly stops: readonly TabStop[];
-    /** Default-tab interval in points (always positive and bounded). */
-    readonly defaultIntervalPt: number;
-}
-/** The frozen "no custom stops" value, so a paragraph without tabs mints no object. */
-declare const EMPTY_TAB_STOPS: ResolvedTabStops;
+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;
 /**
- * Resolve tab stops from cascaded `w:pPr` nodes (docDefaults → style chain → direct).
+ * Why a face was not admitted.
  *
- * Each `w:tabs` merges with `clear` support; absence inherits. The leader travels with the
- * stop that declared it — a `clear` at the same position discards both together.
+ * `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.
  */
-declare function cascadedTabStops(paragraphPropertyNodes: readonly OoxmlNode[]): ResolvedTabStops;
-/** Direct `w:pPr` only — used when no style cascade table is present. */
-declare function paragraphTabStops(pPr: OoxmlNode | undefined): ResolvedTabStops;
+type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
 /**
- * Republish stops under a document-wide default-tab interval (`w:defaultTabStop`).
+ * A face that could not be admitted, carrying whatever evidence the refusal produced.
  *
- * The cascade resolves stops from the paragraph's own property chain, which cannot see
- * `settings.xml`; the interval is a document constant that arrives from the session. Returns
- * the input unchanged when nothing moves, so a cache-key fingerprint stays stable.
+ * RETURNED rather than thrown by `FontResourceSnapshot.resolve`, because a missing face is an
+ * ordinary condition — layout falls back and carries on. It extends `Error` so a caller that
+ * would rather throw can.
  */
-declare function withDefaultTabInterval(tabs: ResolvedTabStops, defaultIntervalPt: number | undefined): ResolvedTabStops;
+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;
+    });
+}
 /**
- * Read `w:settings/w:defaultTabStop` (ECMA-376 §17.15.1.25), in points.
+ * One face offered to a snapshot, before admission.
  *
- * Word's own interval, not a constant: a metric-locale template writes `w:val="1134"` (2cm)
- * and every default-interval tab in the document lands on that grid instead of the 0.5"
- * one. The value is FILE-DERIVED, so a non-integer, non-positive or out-of-range `val` falls
- * back to the schema default rather than being trusted into layout arithmetic.
+ * `hash` is checked against the bytes, so a source cannot claim a face it did not supply. Setting
+ * `availability` to `forbidden` declares a face that exists but must not be used, which resolves
+ * as a typed refusal rather than as "missing".
+ */
+interface FontResourceDefinition {
+    readonly request: FontRequest;
+    readonly id: string;
+    readonly bytes: Uint8Array;
+    readonly hash: string;
+    readonly faceIndex: number;
+    readonly availability?: 'available' | 'forbidden';
+}
+/**
+ * A host-declared redirect: requests for `from` resolve to `to`.
  *
- * `ST_TwipsMeasure` also admits a universal measure (`"2cm"`); Word writes plain twips, and
- * the spelled form falls back to the default rather than being parsed here.
+ * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
+ * without the document being rewritten.
  */
-declare function defaultTabIntervalFromSettings(settings: OoxmlNode | null | undefined): number;
-/** Where one tab character lands: the resolved x, and the stop that decided it. */
-interface TabDestination {
-    readonly positionPt: number;
-    readonly alignment: TabAlignment;
-    /** Leader of the stop that was reached; absent for `none` and for default-interval tabs. */
-    readonly leader?: TabLeader;
+interface DeclaredFontSubstitution {
+    readonly from: FontRequest;
+    readonly to: FontRequest;
+    readonly lineMetrics?: {
+        readonly heightEm: number;
+        readonly baselineEm: number;
+    };
 }
+/** Whether bytes parse as a usable font, with a diagnostic when they do not. */
+type FontValidationResult = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+    readonly diagnostic: string;
+};
 /**
- * Next tab destination strictly past `currentX`, preferring custom stops then the default
- * interval. Destination is clamped to `rightEdge` so stops cannot escape the content box.
+ * The injected check that bytes really are a font.
+ *
+ * Injected because it is the shaper that knows — HarfBuzz can open a face and read its tables,
+ * and this layer must not duplicate that judgement. Every byte reaching it is file input.
  */
-declare function nextTabDestination(tabs: ResolvedTabStops, currentX: number, rightEdge: number): TabDestination;
+type FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;
 /**
- * Width of a tab glyph so the following segment lands on the destination.
+ * An immutable set of admitted faces, and the only way to reach one.
  *
- * `segmentWidth` / `decimalOffset` are already measured in points. Decimal offset is the
- * advance from the segment start to the decimal point (0 when none — treated like right).
+ * `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.
  */
-declare function tabAdvanceWidth(alignment: TabAlignment, currentX: number, destinationX: number, segmentWidth: number, decimalOffset: number): number;
+interface FontResourceSnapshot {
+    readonly epoch: number;
+    /** The admitted face, or a typed refusal. Never throws. */
+    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
+}
 /**
- * Stable fingerprint for layout cache keys — nested `w:tabs` are not in flat `OoxmlProperty`
- * bags, so style-inherited stops must be named explicitly or breaks would collide.
+ * How a snapshot is built: which faces, under what limits, validated how.
+ *
+ * `maxFontBytes` is clamped to {@link HARD_MAX_FONT_BYTES} — a caller may tighten the budget but
+ * never widen it past the engine's own ceiling.
  */
-declare function tabStopsFingerprint(tabs: ResolvedTabStops): string;
-
-/** `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 FontResourceSnapshotOptions {
+    readonly epoch: number;
+    readonly maxFontBytes: number;
+    readonly resources: readonly FontResourceDefinition[];
+    readonly substitutions?: readonly DeclaredFontSubstitution[];
+    readonly validateFont: FontByteValidator;
+    readonly instrumentation?: FontResourceInstrumentation;
 }
 /**
- * A run's character properties after the full cascade, in the units layout works in.
+ * Optional counters for the operations font admission is expected to do RARELY.
  *
- * Points rather than half-points, RRGGBB rather than theme references — everything already
- * resolved, so measurement and paint never re-run the cascade per glyph.
+ * Exists so tests can assert the absence of work: hashing and byte-copying a 64 MB face on every
+ * resolve would not be visible in output, only in a stalled document, so the checks assert these
+ * fire once rather than per call.
  */
-interface 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;
-    /** 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;
-    };
-    readonly italic: boolean;
-    readonly underline: ResolvedUnderline | null;
-    readonly strike: boolean;
-    readonly doubleStrike: boolean;
-    /** An `ST_HighlightColor` name, or null. */
-    readonly highlight: string | null;
-    /**
-     * Character shading fill (`w:rPr/w:shd`), validated RRGGBB, or null.
-     *
-     * Paint applies this as the glyph-box background; a recognised highlight overrides it.
-     * Measurement ignores shading.
-     */
-    readonly shading: string | null;
-    readonly verticalAlign: VerticalAlign;
-    /** `w:position`, in points. Positive raises the baseline. */
-    readonly baselineShiftPt: number;
-    readonly caps: boolean;
-    readonly smallCaps: boolean;
-    /** `w:spacing`, in points. Added to every advance. */
-    readonly characterSpacingPt: number;
-    /** `w:w`, as a percentage. 100 is unscaled. */
-    readonly horizontalScalePercent: number;
-    /** `w:kern`, in points: the size at or above which kerning applies. 0 disables it. */
-    readonly kerningMinPt: number;
-    /**
-     * `w:vanish` (ECMA-376 §17.3.2.45): the run is hidden text.
-     *
-     * Word does not draw it AND does not paginate it — hidden index or comment text takes no
-     * space at all. So this cannot be a paint-time opacity: a hidden run that is still measured
-     * pushes every following line, and every following page break, to the wrong place. Layout
-     * drops the content instead (see `piecesOfParagraph`).
-     *
-     * `w:specVanish` (§17.3.2.36) is a different property — an always-hidden paragraph mark on
-     * a heading — and never sets this.
-     */
-    readonly hidden: boolean;
+interface FontResourceInstrumentation {
+    readonly onOwnedByteCopy?: () => void;
+    readonly onHash?: () => void;
+    readonly onTableScan?: () => void;
+    readonly onAdmission?: () => void;
 }
-/** 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.
+ * The canonical string identifying one face request.
  *
- * 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.
+ * 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.
  */
-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>>;
-}
+declare const fontRequestKey: (request: FontRequest) => string;
+/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
+declare const boundedStructuralFontValidator: FontByteValidator;
 /**
- * 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.
+ * Admit a set of faces and return the immutable snapshot layout resolves against.
  *
- * `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.
+ * 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 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;
+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;
+};
 /**
- * How far a run's glyphs are lifted off the line's baseline, in points. Positive is up.
+ * Brand a safe integer as a {@link FixedPoint} coordinate.
  *
- * 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.
+ * 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 baselineShiftPtOf(style: ResolvedRunStyle): number;
-
+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';
 /**
- * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
- * within.
+ * The shaping library and its exact version.
  *
- * 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.
+ * Versioned because a library upgrade can change glyph positioning, and a cached measurement
+ * taken under the old one must not be reused under the new one.
  */
-interface BidiEmbeddingLevels {
-    readonly levels: Uint8Array;
-    readonly paragraphs: readonly {
-        readonly start: number;
-        readonly end: number;
-        readonly level: number;
-    }[];
+interface VersionedShapingLibrary {
+    readonly name: string;
+    readonly version: string;
 }
-
 /**
- * A face, as something asks for it: family plus the two axes this engine admits.
+ * Everything that determines how text shapes — the complete input to a
+ * {@link ShapingEnvironment}.
  *
- * 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.
+ * Exhaustive on purpose. Any field that could change a glyph's position belongs here, because the
+ * environment's fingerprint is what decides whether a cached shaped run may be reused.
  */
-interface FontRequest {
-    readonly family: string;
-    readonly weight: number;
-    readonly style: 'normal' | 'italic';
+interface ShapingEnvironmentInput {
+    readonly font: ResolvedFont;
+    readonly variationAxes: Readonly<Record<string, number>>;
+    readonly shapingLibrary: VersionedShapingLibrary;
+    readonly unicodeDataVersion: string;
+    readonly normalization: NormalizationPolicy;
+    readonly script: string;
+    readonly language: string;
+    readonly direction: TextDirection;
+    readonly features: Readonly<Record<string, number>>;
+    readonly fallbackOrder: readonly ResolvedFont[];
+    readonly fixedPointScale: number;
+    readonly roundingMode: FixedPointRoundingMode;
 }
 /**
- * A request that was answered by a DIFFERENT face than the one asked for.
+ * A validated {@link ShapingEnvironmentInput} — build one with `createShapingEnvironment`.
  *
- * 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.
+ * Structurally identical to its input, but the nominal distinction is the point: holding one
+ * means the tags, axes and fonts inside it have already been checked.
  */
-interface FontSubstitution {
-    readonly requested: FontRequest;
-    readonly resolved: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
+interface ShapingEnvironment extends ShapingEnvironmentInput {
 }
-declare const RESOLVED_FONT_BRAND: unique symbol;
+/** 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;
 /**
- * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
- * a font.
+ * One positioned glyph.
  *
- * Branded, so a `ResolvedFont` cannot be constructed by an object literal. Holding one is proof
- * the checks ran — which is what lets shaping skip re-validating on every call.
- */
-interface ResolvedFont {
-    readonly [RESOLVED_FONT_BRAND]: true;
-    readonly id: string;
-    readonly identity: string;
-    readonly request: FontRequest;
-    readonly family: string;
-    /** Owned byte length, available without creating a defensive byte copy. */
-    readonly byteLength: number;
-    readonly bytes: Uint8Array;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly substitution: FontSubstitution | null;
-}
-/**
- * Largest single face this engine will ever admit, whatever a caller configures.
- *
- * A CEILING, not a default: a host may set a smaller `maxFontBytes`, but nothing can raise it
- * past this. Font bytes come from files, and an unbounded face is a memory-exhaustion vector.
- */
-declare const HARD_MAX_FONT_BYTES: number;
-/** Most faces one snapshot may hold, whatever a caller configures. */
-declare const HARD_MAX_FONT_SOURCES = 256;
-/** Most bytes all admitted faces may total, whatever a caller configures. */
-declare const HARD_MAX_AGGREGATE_FONT_BYTES: number;
-/**
- * Why a face was not admitted.
- *
- * `forbidden` and `hashMismatch` are adversarial signals rather than ordinary failures: the first
- * is a face the host declared off-limits, the second is bytes that are not what their source
- * claimed.
- */
-type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
-/**
- * A face that could not be admitted, carrying whatever evidence the refusal produced.
- *
- * RETURNED rather than thrown by `FontResourceSnapshot.resolve`, because a missing face is an
- * ordinary condition — layout falls back and carries on. It extends `Error` so a caller that
- * would rather throw can.
- */
-declare class FontResolutionError extends Error {
-    readonly name = "FontResolutionError";
-    readonly request: FontRequest;
-    readonly code: FontResolutionErrorCode;
-    readonly limit?: number;
-    readonly actual?: number;
-    readonly diagnostic?: string;
-    readonly expectedHash?: string;
-    readonly actualHash?: string;
-    constructor(code: FontResolutionErrorCode, request: FontRequest, details?: {
-        readonly limit?: number;
-        readonly actual?: number;
-        readonly diagnostic?: string;
-        readonly expectedHash?: string;
-        readonly actualHash?: string;
-    });
-}
-/**
- * One face offered to a snapshot, before admission.
- *
- * `hash` is checked against the bytes, so a source cannot claim a face it did not supply. Setting
- * `availability` to `forbidden` declares a face that exists but must not be used, which resolves
- * as a typed refusal rather than as "missing".
- */
-interface FontResourceDefinition {
-    readonly request: FontRequest;
-    readonly id: string;
-    readonly bytes: Uint8Array;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly availability?: 'available' | 'forbidden';
-}
-/**
- * A host-declared redirect: requests for `from` resolve to `to`.
- *
- * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
- * without the document being rewritten.
- */
-interface DeclaredFontSubstitution {
-    readonly from: FontRequest;
-    readonly to: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
-}
-/** Whether bytes parse as a usable font, with a diagnostic when they do not. */
-type FontValidationResult = {
-    readonly valid: true;
-} | {
-    readonly valid: false;
-    readonly diagnostic: string;
-};
-/**
- * The injected check that bytes really are a font.
- *
- * Injected because it is the shaper that knows — HarfBuzz can open a face and read its tables,
- * and this layer must not duplicate that judgement. Every byte reaching it is file input.
- */
-type FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;
-/**
- * An immutable set of admitted faces, and the only way to reach one.
- *
- * `epoch` identifies the snapshot: fonts change by REPLACING it, never by mutation, so a layout
- * pass holds one snapshot for its whole run and cannot observe a face appearing or vanishing
- * midway.
- */
-interface FontResourceSnapshot {
-    readonly epoch: number;
-    /** The admitted face, or a typed refusal. Never throws. */
-    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
-}
-/**
- * How a snapshot is built: which faces, under what limits, validated how.
- *
- * `maxFontBytes` is clamped to {@link HARD_MAX_FONT_BYTES} — a caller may tighten the budget but
- * never widen it past the engine's own ceiling.
- */
-interface FontResourceSnapshotOptions {
-    readonly epoch: number;
-    readonly maxFontBytes: number;
-    readonly resources: readonly FontResourceDefinition[];
-    readonly substitutions?: readonly DeclaredFontSubstitution[];
-    readonly validateFont: FontByteValidator;
-    readonly instrumentation?: FontResourceInstrumentation;
-}
-/**
- * Optional counters for the operations font admission is expected to do RARELY.
- *
- * Exists so tests can assert the absence of work: hashing and byte-copying a 64 MB face on every
- * resolve would not be visible in output, only in a stalled document, so the checks assert these
- * fire once rather than per call.
- */
-interface FontResourceInstrumentation {
-    readonly onOwnedByteCopy?: () => void;
-    readonly onHash?: () => void;
-    readonly onTableScan?: () => void;
-    readonly onAdmission?: () => void;
-}
-/**
- * The canonical string identifying one face request.
- *
- * Case- and whitespace-normalized, so `"Times New Roman"` and `"times new roman"` are one key —
- * a document may name a family either way and both must reach the same face.
- */
-declare const fontRequestKey: (request: FontRequest) => string;
-/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
-declare const boundedStructuralFontValidator: FontByteValidator;
-/**
- * Admit a set of faces and return the immutable snapshot layout resolves against.
- *
- * Admission is the trust boundary for font bytes: counts and sizes are checked against the hard
- * ceilings, each face's hash is re-derived and compared, and the bytes are handed to the injected
- * validator. A face failing any of these is recorded as a typed refusal rather than dropped, so
- * `resolve` can explain itself instead of answering "missing".
- */
-declare const createFontResourceSnapshot: (options: FontResourceSnapshotOptions) => FontResourceSnapshot;
-
-declare const FIXED_POINT: unique symbol;
-/** Fixed-point coordinates are safe integers in units declared by ShapingEnvironment.fixedPointScale. */
-type FixedPoint = number & {
-    readonly [FIXED_POINT]: true;
-};
-/**
- * Brand a safe integer as a {@link FixedPoint} coordinate.
- *
- * Fixed point rather than float throughout shaping so that two runs shaped identically compare
- * EQUAL — float accumulation would make the same text measure differently depending on how it was
- * split, and pagination is decided on those measurements.
- *
- * @throws RangeError when the value is not a safe integer.
- */
-declare const fixedPoint: (value: number) => FixedPoint;
-/** Which way a run reads. The parity projection of its bidi embedding level. */
-type TextDirection = 'ltr' | 'rtl';
-/** How fixed-point conversion breaks ties. Part of the shaping fingerprint. */
-type FixedPointRoundingMode = 'halfAwayFromZero' | 'halfToEven' | 'towardZero';
-/** Which Unicode normalization is applied before shaping, if any. */
-type NormalizationPolicy = 'none' | 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
-/**
- * The shaping library and its exact version.
- *
- * Versioned because a library upgrade can change glyph positioning, and a cached measurement
- * taken under the old one must not be reused under the new one.
- */
-interface VersionedShapingLibrary {
-    readonly name: string;
-    readonly version: string;
-}
-/**
- * Everything that determines how text shapes — the complete input to a
- * {@link ShapingEnvironment}.
- *
- * Exhaustive on purpose. Any field that could change a glyph's position belongs here, because the
- * environment's fingerprint is what decides whether a cached shaped run may be reused.
- */
-interface ShapingEnvironmentInput {
-    readonly font: ResolvedFont;
-    readonly variationAxes: Readonly<Record<string, number>>;
-    readonly shapingLibrary: VersionedShapingLibrary;
-    readonly unicodeDataVersion: string;
-    readonly normalization: NormalizationPolicy;
-    readonly script: string;
-    readonly language: string;
-    readonly direction: TextDirection;
-    readonly features: Readonly<Record<string, number>>;
-    readonly fallbackOrder: readonly ResolvedFont[];
-    readonly fixedPointScale: number;
-    readonly roundingMode: FixedPointRoundingMode;
-}
-/**
- * A validated {@link ShapingEnvironmentInput} — build one with `createShapingEnvironment`.
- *
- * Structurally identical to its input, but the nominal distinction is the point: holding one
- * means the tags, axes and fonts inside it have already been checked.
- */
-interface ShapingEnvironment extends ShapingEnvironmentInput {
-}
-/** One shaping call: the text, its size, its bidi level, and the environment to shape it in. */
-interface ShapeInput {
-    readonly text: string;
-    readonly fontSizeHalfPoints: number;
-    /** Exact UAX #9 embedding/isolate level; direction is its parity projection. */
-    readonly bidiLevel: number;
-    readonly environment: ShapingEnvironment;
-}
-/**
- * One positioned glyph.
- *
- * `id` is a glyph index in its FACE, not a character — a ligature is one glyph spanning several
- * characters, and a single character may produce several glyphs. Use `cluster` to get back to
- * text.
+ * `id` is a glyph index in its FACE, not a character — a ligature is one glyph spanning several
+ * characters, and a single character may produce several glyphs. Use `cluster` to get back to
+ * text.
  */
 interface ShapedGlyph {
     readonly id: number;
+    /** Optional synthetic glyph-size factor; positions and advances already include it. */
+    readonly drawScale?: number;
     /** UTF-16 text offset identifying the cluster that produced this glyph. */
     readonly cluster: number;
     /** Pen origin before this glyph's shaping offsets, in fixed-point run coordinates. */
@@ -749,6 +598,19 @@ interface ShapedRun {
     readonly clusters: readonly ShapedCluster[];
     readonly fontSpans: readonly ShapedFontSpan[];
     readonly metrics: ShapedVerticalMetrics;
+    /**
+     * The same horizontal advances as `glyphs[i].advanceX`, in the same fixed-point units, but
+     * BEFORE the per-glyph rounding to the fixed-point grid. Parallel to `glyphs`.
+     *
+     * Measurement and line breaking read `advanceX` and must keep doing so: pagination is decided
+     * on those numbers, and two runs shaped identically have to compare equal. A painter that
+     * gives every glyph its own absolute position sums the advances instead, and a sum of ROUNDED
+     * advances drifts by up to half a fixed-point unit per glyph — an error that only grows along
+     * a line. Summing these and rounding once, at the position actually written, does not.
+     *
+     * Absent on runs an assembly path cannot state exactly; a reader falls back to `originX`.
+     */
+    readonly exactAdvancesX?: readonly number[];
 }
 /**
  * A {@link ShapedRun} reduced to the fields two shaping results must agree on to be considered
@@ -830,34 +692,497 @@ interface ShapingEnvironmentFingerprintInputs {
  * 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.
+ * @throws TypeError on a malformed tag, name, or axis value.
+ */
+declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
+/**
+ * Reduce an environment to its comparable form, with records sorted so key order cannot affect
+ * the result.
+ */
+declare const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
+/** Canonical serialization of every shaping variable, including byte hash and provenance. */
+declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
+/**
+ * Validate and freeze a shaped run against the environment that produced it.
+ *
+ * Checks the internal consistency a shaper must satisfy: direction matches the environment,
+ * cluster ranges tile the text without gaps or overlap, glyph ranges stay in bounds, font spans
+ * cover every glyph, and caret edges are monotonic. A shaper that violates any of these produces
+ * a caret that lands in the wrong place, which is far harder to diagnose downstream than here.
+ *
+ * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
+ */
+declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
+/**
+ * Reduce a shaped run to its comparable form, validating it on the way through.
+ *
+ * What the D9 determinism oracles compare: two shaping runs of the same text in the same
+ * environment must produce byte-identical structures here.
+ */
+declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
+
+/**
+ * Whether a paragraph must start a new page (`w:pageBreakBefore`).
+ *
+ * LAST WINS, like every other toggle read off the cascade (`paragraphKeeps` does the same
+ * for `w:keepNext`). An any-wins `.some()` cannot be switched off: a Chapter or Heading style
+ * carries `w:pageBreakBefore`, and Word writes `w:val="0"` on the one instance whose author
+ * unchecked the box — that paragraph still broke, so the document grew a blank page and every
+ * page number after it was wrong.
+ *
+ * An absent `w:val` is on (§17.17.4), and the off vocabulary is the whole of it — `off` is a
+ * spelling too, which {@link isOn} beside this already accepts.
+ */
+declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
+/**
+ * Soft ceiling matching the spike's resolved-style limit (31_680 twips ≈ 22"). Beyond
+ * that an attacker-authored spacing would push pagination into pathological page counts.
+ */
+declare const MAX_PARAGRAPH_SPACING_PT: number;
+/** Soft ceiling on border width (96 eighths = 12pt). Word's UI tops out well below this. */
+declare const MAX_BORDER_WIDTH_PT = 12;
+/** Soft ceiling on border-to-text gap (`w:space`, already in points). */
+declare const MAX_BORDER_SPACE_PT = 3168;
+/**
+ * A paragraph's resolved space before and after, in points.
+ *
+ * Already collapsed against `w:contextualSpacing`, so adjacent same-style paragraphs that suppress
+ * their gap arrive here with it removed rather than leaving that to whoever stacks them.
+ */
+interface ParagraphSpacing {
+    /** `w:spacing/@before`, in points. */
+    readonly before: number;
+    /** `w:spacing/@after`, in points. */
+    readonly after: number;
+}
+/**
+ * The gap Word substitutes when `w:beforeAutospacing` / `w:afterAutospacing` is on
+ * (ECMA-376 §17.3.1.33, the `w:spacing` clause both attributes belong to).
+ *
+ * The attribute means "the consumer decides", and the authored `@before` / `@after` beside it
+ * is IGNORED rather than used as the value. Word's answer is HTML's default `<p>` margin,
+ * 14pt, which is what a document round-tripped through Word's HTML filter carries — and this
+ * one is everywhere, because Word writes `w:before="100" w:beforeAutospacing="1"` for it. Reading
+ * only the literal 100 twips lays every such paragraph out 9pt tight, which moves page breaks.
+ */
+declare const AUTO_PARAGRAPH_SPACING_PT = 14;
+/**
+ * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
+ * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
+ *
+ * This resolves the interior list-item value. Body layout restores each outer list margin
+ * in `resolveListAutoSpacing`, where neighboring blocks are available. A caller that says
+ * nothing gets the body answer.
+ *
+ * A TABLE CELL is not such a context. Measured on a captured control at 10pt, where the
+ * line pitch is 11.52pt: the reference puts 26.16pt between two paragraphs in the body with
+ * auto spacing on, and the SAME 26.16pt between two paragraphs inside a cell. With an empty
+ * paragraph between them it is 52.32, exactly twice. Reading it as 0 in a cell lays every
+ * such paragraph 13.92pt tight, which is enough to pull a signature block back onto the
+ * previous page. See `.cache/pdf/claude-autospacing/`.
+ */
+interface ParagraphAutoSpacingContext {
+    /** The paragraph participates in numbering (`w:numPr`), i.e. it is a list item. */
+    readonly inList?: boolean;
+    /**
+     * The paragraph lives in a table cell. Kept because callers describe position with it and
+     * list resolution reads it; it does NOT zero auto spacing.
+     */
+    readonly inTableCell?: boolean;
+    /** Section grid pitch in points; no grid uses Word's fixed 12pt line unit. */
+    readonly lineUnitPt?: number;
+    /**
+     * `w:doNotUseHTMLParagraphAutoSpacing` is on: automatic spacing outside a list resolves to
+     * the fixed 5pt before and 10pt after instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
+     */
+    readonly fixedAutoSpacing?: boolean;
+}
+/**
+ * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
+ *
+ * `auto` is the interesting one: `@line` is 240ths of a line, so 240 is single, 360 is
+ * one-and-a-half, 480 is double — and Word's own Normal style since 2013 is 259, i.e.
+ * 1.08. A document laid out at a flat single spacing is ~8% tight on EVERY line, which
+ * moves every page break, so this is not a cosmetic detail.
+ *
+ * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
+ * does. `atLeast` uses it as a floor.
+ */
+type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
+/**
+ * Resolved line spacing: the rule, and the value it applies.
+ *
+ * `value` means different things per rule — 240ths of a line under `auto`, points under `exact`
+ * and `atLeast` — which is why the two travel together and neither is useful alone.
+ */
+interface ParagraphLineSpacing {
+    readonly rule: LineSpacingRule;
+    /** `auto`: the 240ths-of-a-line multiplier numerator. Otherwise points. */
+    readonly value: number;
+    /** Legacy noExtraLineSpacing: retain the natural baseline within an exact-height box. */
+    readonly preserveExactBaseline?: true;
+    /**
+     * Active section line-grid pitch in points (`w:docGrid/@w:linePitch`). Present only when
+     * the paragraph snaps to the grid; only with `auto`. See `line-grid.ts`.
+     */
+    readonly gridPitch?: number;
+}
+/** Single spacing: what a paragraph that says nothing gets. */
+declare const SINGLE_LINE_SPACING: ParagraphLineSpacing;
+/**
+ * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
+ *
+ * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
+ * unbounded border width becomes a layout dimension.
+ */
+interface ParagraphBorderEdge {
+    /** Authored `ST_Border` value (`single`, `dashed`, …). */
+    readonly val: string;
+    /** RRGGBB, or null when auto/missing (paint defaults to black). */
+    readonly color: string | null;
+    /** Border thickness in points (`w:sz` is eighths of a point). */
+    readonly widthPt: number;
+    /** Gap from text to the rule, in points (`w:space`). */
+    readonly spacePt: number;
+    /**
+     * `w:shadow` — Word offsets a drop shadow behind the rule.
+     *
+     * Present only when authored true, so an edge that says nothing keeps the shape earlier
+     * fixtures assert. Resolved and carried; drawing it is deferred.
+     */
+    readonly shadow?: true;
+}
+/** The six `CT_PBdr` children, in schema order (ECMA-376 §17.3.1.24). */
+declare const PARAGRAPH_BORDER_SIDES: readonly ["top", "left", "bottom", "right", "between", "bar"];
+/**
+ * Which of the six `CT_PBdr` edges.
+ *
+ * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
+ * consecutive paragraphs share a border definition.
+ */
+type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
+/**
+ * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
+ *
+ * `top`/`left`/`bottom`/`right` are the four physical edges of the box. The other two are
+ * group-relative: `between` draws at a boundary INSIDE a run of consecutive paragraphs whose
+ * border settings are identical, and `bar` is the vertical change-bar rule beside the
+ * paragraph, drawn whether or not the paragraph groups with its neighbours.
+ */
+interface ParagraphBorders {
+    readonly top?: ParagraphBorderEdge;
+    readonly left?: ParagraphBorderEdge;
+    readonly bottom?: ParagraphBorderEdge;
+    readonly right?: ParagraphBorderEdge;
+    readonly between?: ParagraphBorderEdge;
+    readonly bar?: ParagraphBorderEdge;
+}
+/**
+ * Resolve `w:spacing` before/after from flat paragraph properties.
+ *
+ * Line spacing (`w:line` / `w:lineRule`) is a separate concern — it changes measured line
+ * height, not the gap between paragraphs — and is not resolved here.
+ *
+ * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
+ * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
+ */
+declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
+/**
+ * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
+ *
+ * Merged per attribute for the same reason as before/after: `w:spacing` is one element
+ * carrying independent attributes, and a style that states only `@line` must not reset the
+ * rule an earlier entry in the cascade set.
+ */
+declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
+/**
+ * Apply resolved line spacing to a line's natural (glyph-derived) box.
+ *
+ * `auto` places its extra BELOW the line — the last line's multiple spacing still separates
+ * it from the next paragraph. Putting that delta above inverted cover-page rhythm:
+ * `w:line="460"` on "between" opened a large gap above the word and almost none before
+ * "MERIDIAN".
+ *
+ * `atLeast` does the OPPOSITE: the box grows upward and the glyphs sit on its floor. A
+ * captured control settles it — Times New Roman 12 pt at `w:line="360" w:lineRule="atLeast"`
+ * puts the reference's baseline at 15.36 pt, which is `18 - descent` snapped to the device
+ * grid, where treating it like `auto` leaves the baseline at 11.28 and the text 4.08 pt too
+ * high. `w:line="240" atLeast` is below the natural line, falls through to the natural
+ * height, and is unaffected. See `.cache/pdf/claude-linerule/`.
+ *
+ * Exact-height boxes place their baseline at 80% of the height; the legacy
+ * noExtraLineSpacing switch instead preserves the face baseline within the box.
+ *
+ * An `auto` 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 function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
+    height: number;
+    baseline: number;
+    trailing?: number;
+};
+/**
+ * `w:contextualSpacing` (17.3.1.9): drop before/after between paragraphs of the SAME
+ * style. Word's built-in `ListParagraph` sets it, so every list authored in Word gets a
+ * paragraph gap between items without this.
+ */
+declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
+/**
+ * Resolve `w:pBdr` from the paragraph-properties node.
+ *
+ * Nested — every edge is a child of `pBdr`, not an attribute — so this reads the typed tree
+ * rather than the flattened `OoxmlProperty[]` bag `propertiesOf` builds for leaf props.
+ */
+declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+/**
+ * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
+ *
+ * Word does not merge edges across the cascade. A style that states only `w:bottom` discards
+ * the box its `basedOn` ancestor declared, so folding edge by edge would leave a lone
+ * underline surrounded by a box no one authored. Absence inherits; `nil`/`none` clear.
+ */
+declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
+/**
+ * Visual stroke thickness layout publishes for one edge (points).
+ *
+ * Compound `ST_Border` values (`double`, …) use the shared inflated band so a thin
+ * `w:sz="3"` double still occupies a visible double-line box — matching table borders.
+ */
+declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+/**
+ * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
+ *
+ * Vertically that is flow height — a top rule pushes the first line down, a bottom rule holds
+ * the page open below the last one — so pagination has to see it. Horizontally it is
+ * publish-only: Word draws left/right paragraph rules OUTSIDE the text column and never
+ * re-breaks the lines, which is why adding a box to a paragraph in Word does not reflow it.
+ */
+declare function paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+/** Vertical extent a bottom border adds below the last line (gap + rule). */
+declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+/**
+ * Identity of a paragraph's border set, for the `w:between` group rule.
+ *
+ * Word treats consecutive paragraphs whose border settings are IDENTICAL as ONE bordered
+ * block: the top rule draws above the first, the bottom rule below the last, and each
+ * interior boundary gets `w:between` or nothing (§17.3.1.24). That is why applying a box to
+ * three selected paragraphs in Word draws one box and not three.
+ *
+ * Empty string means "no borders", which never groups with anything.
+ */
+declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
+/**
+ * Gap to insert before a paragraph once the previous paragraph's `after` is already in the
+ * flow cursor — Word takes the larger of the two rather than summing them.
+ */
+declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+/**
+ * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ *
+ * Adjacent before/after still collapse to the larger gap, but before is dropped entirely when
+ * the paragraph naturally moves to the top of a page mid-section. An explicit page-break-before
+ * paragraph, or the first paragraph of a document/section, retains before. Callers publish this
+ * applied value on the fragment so shading, borders,
+ * selection, and paint share one geometry.
+ */
+declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, preserveAtPageStart: boolean): number;
+
+/** `w:vertAlign` — script position, which also scales the run's effective size. */
+type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
+/** A resolved underline: its variant, and its colour when it does not follow the text. */
+interface ResolvedUnderline {
+    /** The authored `ST_Underline` variant. */
+    readonly variant: string;
+    /** RRGGBB, or null when the underline follows the text colour. */
+    readonly color: string | null;
+}
+/**
+ * A run's character properties after the full cascade, in the units layout works in.
+ *
+ * Points rather than half-points, RRGGBB rather than theme references — everything already
+ * resolved, so measurement and paint never re-run the cascade per glyph.
+ */
+interface ResolvedRunStyle {
+    readonly fontFamily: string | null;
+    /**
+     * The `eastAsia` slot's typeface (`w:rFonts w:eastAsia`/`w:eastAsiaTheme`), or null when
+     * no level authors one.
+     *
+     * OOXML picks a run's face per SCRIPT: `fontFamily` covers the ascii/hAnsi slots, and
+     * ideographic/kana/hangul text resolves through this one instead. Kept beside — not
+     * folded into — `fontFamily`, because a mixed run needs both at once and the split into
+     * slot-homogeneous pieces happens downstream (`piecesOfParagraph`).
+     */
+    readonly fontFamilyEastAsia: string | null;
+    /**
+     * Present only on a `w:rtl` or `w:cs` run: the LATIN lane that the complex-script values
+     * replaced in `fontFamily`, `fontSizePt`, `bold` and `italic`. Nothing draws with it; it
+     * lets a copy of the formatting (the format painter) write each lane back separately.
+     */
+    readonly latinLane?: {
+        readonly fontFamily: string | null;
+        readonly fontFamilyEastAsia: string | null;
+        readonly fontSizePt: number;
+        readonly bold: boolean;
+        readonly italic: boolean;
+    };
+    /**
+     * The complex-script lane as the cascade states it, on every resolved run: the values a
+     * `w:rtl` or `w:cs` run draws with, and what a copy of the formatting writes to `w:bCs`,
+     * `w:iCs`, `w:szCs` and `w:rFonts/@w:cs`. `fontFamily` is null when no level names a face.
+     */
+    readonly complexLane?: {
+        readonly fontFamily: string | null;
+        readonly fontSizePt: number;
+        readonly bold: boolean;
+        readonly italic: boolean;
+    };
+    /** Script and paragraph-resolved direction for shaping and visual placement. */
+    readonly shaping?: {
+        readonly script: string;
+        readonly direction: 'ltr' | 'rtl';
+        readonly level: number;
+        readonly baseLevel: number;
+        /** Resolved w:rtl context; absent when authored Unicode controls govern the paragraph. */
+        readonly runDirection?: 'ltr' | 'rtl';
+        readonly wordSpacingPt?: number;
+        /** Neighbouring text a joining script reads across a formatting-run boundary. */
+        readonly context?: ShapingContext;
+    };
+    /** Points. `w:sz` is half-points, so 22 becomes 11. */
+    readonly fontSizePt: number;
+    /** RRGGBB, or null for the inherited/automatic colour. */
+    readonly color: string | null;
+    readonly bold: boolean;
+    /** Opaque solid `w14:textOutline`, in points; paint only, never a font-weight change. */
+    readonly textOutline?: {
+        readonly widthPt: number;
+        readonly color: string;
+    };
+    /** Character border; adjacent runs with matching edges share one outline. */
+    readonly border?: ParagraphBorderEdge;
+    readonly italic: boolean;
+    readonly underline: ResolvedUnderline | null;
+    readonly strike: boolean;
+    readonly doubleStrike: boolean;
+    /** An `ST_HighlightColor` name, or null. */
+    readonly highlight: string | null;
+    /**
+     * Character shading fill (`w:rPr/w:shd`), validated RRGGBB, or null.
+     *
+     * Paint applies this as the glyph-box background; a recognised highlight overrides it.
+     * Measurement ignores shading.
+     */
+    readonly shading: string | null;
+    readonly verticalAlign: VerticalAlign;
+    /** `w:position`, in points. Positive raises the baseline. */
+    readonly baselineShiftPt: number;
+    readonly caps: boolean;
+    readonly smallCaps: boolean;
+    /** `w:spacing`, in points. Added to every advance. */
+    readonly characterSpacingPt: number;
+    /** `w:w`, as a percentage. 100 is unscaled. */
+    readonly horizontalScalePercent: number;
+    /** `w:kern`, in points: the size at or above which kerning applies. */
+    readonly kerningMinPt: number;
+    /** Explicit kerning selection; a zero threshold disables it. Absent uses a positive threshold. */
+    readonly kerningEnabled?: boolean;
+    /** Resolved optional OpenType substitutions; required script ligatures are independent. */
+    readonly ligatures?: {
+        readonly standard: boolean;
+        readonly contextual: boolean;
+        readonly historical: boolean;
+        readonly discretionary: boolean;
+    };
+    /**
+     * `w:vanish` (ECMA-376 §17.3.2.45): the run is hidden text.
+     *
+     * Word does not draw it AND does not paginate it — hidden index or comment text takes no
+     * space at all. So this cannot be a paint-time opacity: a hidden run that is still measured
+     * pushes every following line, and every following page break, to the wrong place. Layout
+     * drops the content instead (see `piecesOfParagraph`).
+     *
+     * `w:specVanish` (§17.3.2.36) is a different property — an always-hidden paragraph mark on
+     * a heading — and never sets this.
+     */
+    readonly hidden: boolean;
+}
+/** The style a run inherits when it authors nothing. */
+declare const DEFAULT_RUN_STYLE: ResolvedRunStyle;
+/**
+ * The theme part's typefaces, for resolving `w:rFonts` theme attributes.
+ *
+ * Structurally identical to the binding lane's `DocumentThemeFonts` and assignable from it.
+ * Declared here so this lane reads validated strings rather than the theme tree.
+ */
+interface ThemeFonts {
+    /** `a:majorFont` latin typeface — headings. */
+    readonly major: string | null;
+    /** `a:minorFont` latin typeface — body text. */
+    readonly minor: string | null;
+    /** `a:majorFont` east asian typeface (`a:ea`) — headings. Optional for back-compat. */
+    readonly majorEastAsia?: string | null;
+    /** `a:minorFont` east asian typeface (`a:ea`) — body text. Optional for back-compat. */
+    readonly minorEastAsia?: string | null;
+    /** Complex-script heading and body theme faces. */
+    readonly majorBidi?: string | null;
+    readonly minorBidi?: string | null;
+    /** Language-specific theme faces, keyed by ISO 15924 script. */
+    readonly majorSupplemental?: Readonly<Record<string, string>>;
+    readonly minorSupplemental?: Readonly<Record<string, string>>;
+}
+/**
+ * Resolve one run's direct formatting.
+ *
+ * Unrecognised values are DROPPED rather than guessed: a `w:sz` of `"large"` leaves the
+ * default size rather than inventing one, because a wrong measurement moves every glyph
+ * after it and a missing one is visible immediately.
+ *
+ * `themeFonts` resolves `w:rFonts` theme references. Absent, a theme-only `rFonts` leaves
+ * the family inherited — which is what every run of a theme-fonted document does, so the
+ * whole document falls back to the surface default face.
  */
-declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
+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;
 /**
- * Reduce an environment to its comparable form, with records sorted so key order cannot affect
- * the result.
+ * How far a run's glyphs are lifted off the line's baseline, in points. Positive is up.
+ *
+ * Super and subscript move the GLYPHS without moving the run's box, so the box keeps tiling
+ * the line and the selection band stays continuous. Anything drawing at the glyphs — the
+ * painter, and the caret — has to apply this itself, and from one place, or the two drift.
  */
-declare 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.
+ * Shared glyph-size factor for baseline, superscript, and subscript text.
  *
- * 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.
+ * 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.
@@ -911,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.
  *
@@ -1035,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.
  *
@@ -1143,236 +1474,126 @@ interface CjkTypographySettings {
     readonly after: Readonly<Record<string, string>>;
 }
 
+/** Soft ceiling matching Word's practical custom-tab UI limit. */
+declare const MAX_TAB_STOPS = 64;
 /**
- * Whether a paragraph must start a new page (`w:pageBreakBefore`).
- *
- * LAST WINS, like every other toggle read off the cascade (`paragraphKeeps` does the same
- * for `w:keepNext`). An any-wins `.some()` cannot be switched off: a Chapter or Heading style
- * carries `w:pageBreakBefore`, and Word writes `w:val="0"` on the one instance whose author
- * unchecked the box — that paragraph still broke, so the document grew a blank page and every
- * page number after it was wrong.
- *
- * An absent `w:val` is on (§17.17.4), and the off vocabulary is the whole of it — `off` is a
- * spelling too, which {@link isOn} beside this already accepts.
- */
-declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
-/**
- * Soft ceiling matching the spike's resolved-style limit (31_680 twips ≈ 22"). Beyond
- * that an attacker-authored spacing would push pagination into pathological page counts.
- */
-declare const MAX_PARAGRAPH_SPACING_PT: number;
-/** Soft ceiling on border width (96 eighths = 12pt). Word's UI tops out well below this. */
-declare const MAX_BORDER_WIDTH_PT = 12;
-/** Soft ceiling on border-to-text gap (`w:space`, already in points). */
-declare const MAX_BORDER_SPACE_PT = 3168;
-/**
- * A paragraph's resolved space before and after, in points.
- *
- * Already collapsed against `w:contextualSpacing`, so adjacent same-style paragraphs that suppress
- * their gap arrive here with it removed rather than leaving that to whoever stacks them.
- */
-interface ParagraphSpacing {
-    /** `w:spacing/@before`, in points. */
-    readonly before: number;
-    /** `w:spacing/@after`, in points. */
-    readonly after: number;
-}
-/**
- * The gap Word substitutes when `w:beforeAutospacing` / `w:afterAutospacing` is on
- * (ECMA-376 §17.3.1.33, the `w:spacing` clause both attributes belong to).
- *
- * The attribute means "the consumer decides", and the authored `@before` / `@after` beside it
- * is IGNORED rather than used as the value. Word's answer is HTML's default `<p>` margin,
- * 14pt, which is what a document round-tripped through Word's HTML filter carries — and this
- * one is everywhere, because Word writes `w:before="100" w:beforeAutospacing="1"` for it. Reading
- * only the literal 100 twips lays every such paragraph out 9pt tight, which moves page breaks.
- */
-declare const AUTO_PARAGRAPH_SPACING_PT = 14;
-/**
- * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
- * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
- *
- * This resolves the interior list-item or table-cell value. Body layout restores each
- * outer list margin in `resolveListAutoSpacing`, where neighboring blocks are available.
- * A caller that says nothing gets the body answer.
- */
-interface ParagraphAutoSpacingContext {
-    /** The paragraph participates in numbering (`w:numPr`), i.e. it is a list item. */
-    readonly inList?: boolean;
-    /** The paragraph lives in a table cell. */
-    readonly inTableCell?: boolean;
-    /** Section grid pitch in points; no grid uses Word's fixed 12pt line unit. */
-    readonly lineUnitPt?: number;
-}
-/**
- * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
- *
- * `auto` is the interesting one: `@line` is 240ths of a line, so 240 is single, 360 is
- * one-and-a-half, 480 is double — and Word's own Normal style since 2013 is 259, i.e.
- * 1.08. A document laid out at a flat single spacing is ~8% tight on EVERY line, which
- * moves every page break, so this is not a cosmetic detail.
- *
- * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
- * does. `atLeast` uses it as a floor.
- */
-type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
-/**
- * Resolved line spacing: the rule, and the value it applies.
- *
- * `value` means different things per rule — 240ths of a line under `auto`, points under `exact`
- * and `atLeast` — which is why the two travel together and neither is useful alone.
- */
-interface ParagraphLineSpacing {
-    readonly rule: LineSpacingRule;
-    /** `auto`: the 240ths-of-a-line multiplier numerator. Otherwise points. */
-    readonly value: number;
-}
-/** Single spacing: what a paragraph that says nothing gets. */
-declare const SINGLE_LINE_SPACING: ParagraphLineSpacing;
-/**
- * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
- *
- * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
- * unbounded border width becomes a layout dimension.
- */
-interface ParagraphBorderEdge {
-    /** Authored `ST_Border` value (`single`, `dashed`, …). */
-    readonly val: string;
-    /** RRGGBB, or null when auto/missing (paint defaults to black). */
-    readonly color: string | null;
-    /** Border thickness in points (`w:sz` is eighths of a point). */
-    readonly widthPt: number;
-    /** Gap from text to the rule, in points (`w:space`). */
-    readonly spacePt: number;
-    /**
-     * `w:shadow` — Word offsets a drop shadow behind the rule.
-     *
-     * Present only when authored true, so an edge that says nothing keeps the shape earlier
-     * fixtures assert. Resolved and carried; drawing it is deferred.
-     */
-    readonly shadow?: true;
-}
-/** The six `CT_PBdr` children, in schema order (ECMA-376 §17.3.1.24). */
-declare const PARAGRAPH_BORDER_SIDES: readonly ["top", "left", "bottom", "right", "between", "bar"];
-/**
- * Which of the six `CT_PBdr` edges.
- *
- * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
- * consecutive paragraphs share a border definition.
- */
-type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
-/**
- * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
- *
- * `top`/`left`/`bottom`/`right` are the four physical edges of the box. The other two are
- * group-relative: `between` draws at a boundary INSIDE a run of consecutive paragraphs whose
- * border settings are identical, and `bar` is the vertical change-bar rule beside the
- * paragraph, drawn whether or not the paragraph groups with its neighbours.
- */
-interface ParagraphBorders {
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-    readonly between?: ParagraphBorderEdge;
-    readonly bar?: ParagraphBorderEdge;
-}
-/**
- * Resolve `w:spacing` before/after from flat paragraph properties.
- *
- * Line spacing (`w:line` / `w:lineRule`) is a separate concern — it changes measured line
- * height, not the gap between paragraphs — and is not resolved here.
- *
- * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
- * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
+ * Soft ceiling on a tab position (31_680 twips ≈ 22"), matching paragraph-spacing bounds so
+ * a hostile stop cannot shove layout into pathological widths.
  */
-declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
+declare const MAX_TAB_POSITION_TWIPS = 31680;
+/** OOXML / Word default when `w:settings/w:defaultTabStop` is absent: 720 twips = 0.5". */
+declare const DEFAULT_TAB_INTERVAL_TWIPS = 720;
+/** The default tab interval in points — {@link DEFAULT_TAB_INTERVAL_TWIPS} converted. */
+declare const DEFAULT_TAB_INTERVAL_PT: number;
 /**
- * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
+ * How a tab stop positions the text that follows it.
  *
- * 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.
+ * Only `left` is a plain cursor jump. The other three size the tab glyph from the MEASURED
+ * following segment, so its end, centre or decimal point lands on the stop.
  */
-declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
+type TabAlignment = 'left' | 'center' | 'right' | 'decimal';
 /**
- * Apply resolved line spacing to a line's natural (glyph-derived) box.
+ * `w:tab/@w:leader` (ECMA-376 §17.3.1.38, ST_TabTlc): the character repeated across the
+ * space a tab reserves. `none` is the default and is represented by an absent leader.
  *
- * Word places `auto` / `atLeast` extras BELOW the line (the last line's multiple spacing
- * still separates it from the next paragraph). Putting that delta above inverted cover-page
- * rhythm: `w:line="460"` on "between" opened a large gap above the word and almost none
- * before "MERIDIAN". `exact` taller than the glyphs centers the text (ECMA-376 17.3.1.33).
- * An `exact` box smaller than the glyphs keeps the baseline inside so clipped text still
- * sits on it.
- */
-declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
-    height: number;
-    baseline: number;
-};
-/**
- * `w:contextualSpacing` (17.3.1.9): drop before/after between paragraphs of the SAME
- * style. Word's built-in `ListParagraph` sets it, so every list authored in Word gets a
- * paragraph gap between items without this.
+ * This is the difference between a Word table of contents and a column of headings floating
+ * next to a column of page numbers, so it is carried through layout to paint rather than
+ * dropped as a geometry-irrelevant attribute.
  */
-declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
+type TabLeader = 'dot' | 'hyphen' | 'underscore' | 'heavy' | 'middleDot';
 /**
- * Resolve `w:pBdr` from the paragraph-properties node.
+ * The character each leader repeats (§17.3.1.38, ST_TabTlc).
  *
- * 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.
+ * Lives with the type rather than with the painter because LAYOUT has to measure it: a
+ * leader is the same character typed over and over, and the only way to space it the way
+ * typing it would is to ask the measurer how wide it actually is.
  */
-declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+declare const TAB_LEADER_GLYPH: ReadonlyMap<TabLeader, string>;
+/** One authored `w:tab`: where it sits, how it aligns, and what fills the gap. */
+interface TabStop {
+    /** Position from the paragraph content origin, in points. */
+    readonly positionPt: number;
+    readonly alignment: TabAlignment;
+    /** Legacy `num` stop: positions a numbering suffix, not a tab in ordinary text. */
+    readonly numberingOnly?: true;
+    /**
+     * Supplied at a hanging paragraph's text indent, not authored. It positions ordinary text
+     * tabs only: the numbering suffix treats the indent by its own rule.
+     */
+    readonly implied?: true;
+    /** Absent for `none` — the schema default and the overwhelming majority of stops. */
+    readonly leader?: TabLeader;
+}
 /**
- * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
- *
- * Word does not merge edges across the cascade. A style that states only `w:bottom` discards
- * the box its `basedOn` ancestor declared, so folding edge by edge would leave a lone
- * underline surrounded by a box no one authored. Absence inherits; `nil`/`none` clear.
+ * A paragraph's tab stops after the style cascade, with the default interval that applies past
+ * the last explicit one.
  */
-declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
+interface ResolvedTabStops {
+    /** Custom stops sorted by ascending position. */
+    readonly stops: readonly TabStop[];
+    /** Default-tab interval in points (always positive and bounded). */
+    readonly defaultIntervalPt: number;
+    /**
+     * `w:doNotUseIndentAsNumberingTabStop` (§17.15.3): a numbering suffix tab goes to the
+     * first authored stop past the marker, wherever it is, before it falls back to the indent.
+     */
+    readonly ignoreIndentAsNumberingTabStop?: true;
+}
+/** The frozen "no custom stops" value, so a paragraph without tabs mints no object. */
+declare const EMPTY_TAB_STOPS: ResolvedTabStops;
 /**
- * Visual stroke thickness layout publishes for one edge (points).
+ * Resolve tab stops from cascaded `w:pPr` nodes (docDefaults → style chain → direct).
  *
- * 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.
+ * Each `w:tabs` merges with `clear` support; absence inherits. The leader travels with the
+ * stop that declared it — a `clear` at the same position discards both together.
  */
-declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+declare function cascadedTabStops(paragraphPropertyNodes: readonly OoxmlNode[]): ResolvedTabStops;
+/** Direct `w:pPr` only — used when no style cascade table is present. */
+declare function paragraphTabStops(pPr: OoxmlNode | undefined): ResolvedTabStops;
 /**
- * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
+ * Republish stops under a document-wide default-tab interval (`w:defaultTabStop`).
  *
- * 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.
+ * The cascade resolves stops from the paragraph's own property chain, which cannot see
+ * `settings.xml`; the interval is a document constant that arrives from the session. Returns
+ * the input unchanged when nothing moves, so a cache-key fingerprint stays stable.
  */
-declare function paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
-/** Vertical extent a bottom border adds below the last line (gap + rule). */
-declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+declare function withDefaultTabInterval(tabs: ResolvedTabStops, defaultIntervalPt: number | undefined): ResolvedTabStops;
 /**
- * Identity of a paragraph's border set, for the `w:between` group rule.
+ * Read `w:settings/w:defaultTabStop` (ECMA-376 §17.15.1.25), in points.
  *
- * 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.
+ * Word's own interval, not a constant: a metric-locale template writes `w:val="1134"` (2cm)
+ * and every default-interval tab in the document lands on that grid instead of the 0.5"
+ * one. The value is FILE-DERIVED, so a non-integer, non-positive or out-of-range `val` falls
+ * back to the schema default rather than being trusted into layout arithmetic.
  *
- * Empty string means "no borders", which never groups with anything.
+ * `ST_TwipsMeasure` also admits a universal measure (`"2cm"`); Word writes plain twips, and
+ * the spelled form falls back to the default rather than being parsed here.
  */
-declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
+declare function defaultTabIntervalFromSettings(settings: OoxmlNode | null | undefined): number;
+/** Where one tab character lands: the resolved x, and the stop that decided it. */
+interface TabDestination {
+    readonly positionPt: number;
+    readonly alignment: TabAlignment;
+    /** Leader of the stop that was reached; absent for `none` and for default-interval tabs. */
+    readonly leader?: TabLeader;
+}
 /**
- * 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.
+ * Next tab destination strictly past `currentX`, preferring custom stops then the default
+ * interval. Destination is clamped to `rightEdge` so stops cannot escape the content box.
  */
-declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+declare function nextTabDestination(tabs: ResolvedTabStops, currentX: number, rightEdge: number, forNumbering?: boolean): TabDestination;
 /**
- * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ * Width of a tab glyph so the following segment lands on the destination.
  *
- * Adjacent before/after still collapse to the larger gap, but before is dropped entirely when
- * the paragraph begins at the top of a page mid-section. The first paragraph of a document or
- * section retains before. Callers publish this applied value on the fragment so shading, borders,
- * selection, and paint share one geometry.
+ * `segmentWidth` / `decimalOffset` are already measured in points. Decimal offset is the
+ * advance from the segment start to the decimal point (0 when none — treated like right).
+ */
+declare function tabAdvanceWidth(alignment: TabAlignment, currentX: number, destinationX: number, segmentWidth: number, decimalOffset: number): number;
+/**
+ * Stable fingerprint for layout cache keys — nested `w:tabs` are not in flat `OoxmlProperty`
+ * bags, so style-inherited stops must be named explicitly or breaks would collide.
  */
-declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, firstParagraphOfSection: boolean): number;
+declare function tabStopsFingerprint(tabs: ResolvedTabStops): string;
 
 interface DrawingPoint {
     readonly x: number;
@@ -1390,6 +1611,8 @@ interface DrawingGeometry {
     readonly paintBounds: LayoutBox;
     readonly hitBounds: LayoutBox;
     readonly transformedCorners: readonly DrawingPoint[];
+    /** Unclipped image corners for affine encoding; clipping must not stretch the image. */
+    readonly imageTransformCorners?: readonly DrawingPoint[];
     readonly clipPolygon: readonly DrawingPoint[] | null;
     readonly clipFallback: DrawingClipFallback;
     readonly effectInsets: DrawingInsets;
@@ -1411,9 +1634,9 @@ type TableBorderSideName = 'top' | 'right' | 'bottom' | 'left';
 /**
  * One border edge in one of three states.
  *
- * `omitted` and `none` are NOT the same: an omitted edge inherits from the table style or the
- * neighbouring cell, while an explicit `none` wins the conflict and draws nothing. Collapsing
- * them would let a style's border reappear where the author removed it.
+ * Omitted edges inherit. Explicit no-border edges suppress inherited rules; a directly
+ * authored opposing edge can still win. This matches the saved Word sample's mixed and
+ * borderless tables, including cells authored with `w:val="none"`.
  */
 type TableBorderSide = {
     readonly state: 'omitted';
@@ -1508,21 +1731,15 @@ declare function readBorderSide(node: OoxmlElement | undefined): TableBorderSide
 declare function readTableBorders(tblPr: OoxmlElement | undefined): TableBorderBox;
 /** Read one cell's `w:tcBorders`, under the same bounds {@link readTableBorders} applies. */
 declare function readCellBorders(tcPr: OoxmlElement | undefined): CellBorderBox;
-/**
- * Conflict weight: the authored width in eighths of a point, and nothing else.
- *
- * Word-matching, not conformance — §17.4.39 (`w:tblBorders`) and §17.4.66 (`w:tcBorders`)
- * describe the elements and specify no conflict algorithm. Word picks the heavier RULE, so
- * a 6pt dashed rule beats a hairline single. Folding the style rank into the weight (an
- * `sz × border-number` product) made a 0.5pt double outrank a 1pt single and made every
- * dashed or dotted rule weigh 1 regardless of `w:sz`, which erased its width entirely.
+/** Word's weighted border selection (MS-OI29500 §2.1.169, tcBorders).
+ * https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/7c791c5d-44c3-4fe8-abdd-8f136761bb93
  */
 declare function borderWeight(side: TableBorderSide): number;
 /**
  * Pick the winner between two candidates on a shared grid line (zero cell spacing).
  *
- * `none` loses to any edge; two `none`/omitted yield omitted (no paint). Width decides;
- * equal widths rank by style, then prefer the darker color, then `preferFirst`
+ * `none` loses to any edge; two `none`/omitted do not paint. Weighted widths decide;
+ * equal weights rank by style, then prefer the darker color, then `preferFirst`
  * (reading-order / first candidate).
  */
 declare function resolveBorderConflict(first: TableBorderSide, second: TableBorderSide, preferFirst?: boolean): TableBorderSide;
@@ -1541,6 +1758,8 @@ interface BorderGridCell {
  * own and leaving a hairline gap between them.
  */
 interface BorderGridGeometry {
+    /** Center simple horizontal strokes on collapsed row boundaries. */
+    readonly collapsedHorizontal?: boolean;
     /** Absolute column widths for the whole table (points). */
     readonly columnWidthsPt: readonly number[];
     /**
@@ -1555,6 +1774,12 @@ interface BorderGridGeometry {
     readonly cellBoxes: readonly (readonly {
         readonly width: number;
         readonly height: number;
+        /** False when a split occurrence still reserves a shared bottom stroke. */
+        readonly outerBottomInsetReserved?: boolean;
+        /** Simple vertical strokes share the cell grid line with legacy padding. */
+        readonly centeredSideRules?: boolean;
+        /** Simple vertical strokes paint centered on the grid line. */
+        readonly centeredSidePaint?: boolean;
     }[])[];
 }
 /**
@@ -1570,7 +1795,7 @@ interface BorderGridGeometry {
  * corner-adjusted endpoints in cell-local points.
  */
 declare function resolveTableCellBorderGrid(rows: readonly (readonly BorderGridCell[])[], table: TableBorderBox, columnCount: number, geometry?: BorderGridGeometry, work?: TableBorderGridResolveWork, ownershipBudget?: TableBorderOwnershipBudget): ResolvedCellBorders[][];
-/** Width contribution of a resolved edge for content inset / row sizing. */
+/** Painted extent inward from the cell edge; existing padding may already clear it. */
 declare function borderExtentPt(edge: ResolvedTableBorderEdge | TableBorderSide | undefined): number;
 
 /**
@@ -1625,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;
@@ -1659,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.
@@ -1672,6 +1915,19 @@ interface InlineDrawingLayoutContext {
     readonly projectionForAtom?: (atomNodeId: string) => DrawingProjection | null;
     readonly project: (drawing: OoxmlDrawingNode) => DrawingProjection | null;
     readonly resourceOf: (projection: DrawingProjection) => ImageResourceState;
+    /**
+     * Resolve a numbering picture bullet's image by relationship id.
+     *
+     * The owner is the NUMBERING part, not this context's story part: `w:numPicBullet` lives in
+     * `numbering.xml` and its `r:id` names a relationship of that part. The resolver answers the
+     * owner it used so a sink can key the resource without assuming the part name. Absent on a
+     * context whose host resolves no image resources, which degrades a picture bullet to its
+     * level's `w:lvlText`.
+     */
+    readonly pictureBulletResource?: (relationshipId: string) => {
+        readonly ownerPartName: string;
+        readonly resource: ImageResourceState;
+    } | null;
 }
 /** Named fallback when a positioning frame cannot be resolved (OpenSpec 4.6). */
 type AnchoredDrawingLayoutFallback = 'unresolvable-frame' | 'page-defer-exhausted';
@@ -1684,6 +1940,11 @@ interface AnchoredDrawingRecord extends Omit<InlineDrawingRecord, 'kind' | 'base
     readonly verticalFrameOrigin: number;
     readonly behindDocument: boolean;
     readonly allowOverlap: boolean;
+    /**
+     * Whether the object is laid out in the box it flows in. For an anchor in a table cell this
+     * is the layout's reading: `true` from compatibility mode 15, which ignores
+     * `layoutInCell="0"`. Everywhere else it is the authored `wp:anchor/@layoutInCell`.
+     */
     readonly layoutInCell: boolean;
     readonly relativeHeight: number;
     readonly wrap: Exclude<ImageWrapTarget, 'inline'>;
@@ -1718,6 +1979,17 @@ interface ResolvedListItem {
     /** Effective indent after merging level + paragraph indents, in points. */
     readonly indent: NumberingLevelIndent;
     readonly markerStyle: ResolvedRunStyle;
+    /**
+     * The image marker a `w:lvlPicBulletId` level resolved to, absent on every other item.
+     *
+     * Present means the marker is an IMAGE: it occupies `width` x `height` points in the
+     * hanging slot and `markerText` is only what a sink that cannot draw the image falls back
+     * to. The extent is the AUTHORED `v:shape` size scaled by the marker font size — see
+     * {@link resolvePictureBullet}, which also decides when the answer is no picture at all.
+     * Absent means the level declared none, named one the part does not declare, declared one
+     * this projection could not read, or resolved to a size nothing can paint.
+     */
+    readonly picBullet?: ResolvedPictureBullet;
     /** Fingerprint for layout cache keys (indent, marker text, marker face). */
     readonly cacheToken: string;
 }
@@ -1748,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;
 /**
@@ -1786,33 +2062,15 @@ declare function withResolvedListItems<T extends {
     readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
     readonly styleCascade?: StyleCascadeTable;
     readonly isFontAvailable?: (family: string) => boolean;
+    readonly measurer?: TextMeasurer;
 }>(options: T, blocks: readonly OoxmlElement[]): T & {
     readonly numberingIndex: NumberingIndex;
     readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
 };
-/**
- * Horizontal marker box inside the first-line indent slot.
- *
- * Coordinates are relative to the same origin as paragraph content (`indent.left` is the
- * text start). Returns null when there is nothing to paint.
- *
- * `w:hanging` and a positive `w:firstLine` are one mutually exclusive slot
- * (§17.3.1.10, §17.3.1.12), so the marker has two placements, not an interaction:
- * a hanging level puts the marker BEFORE the text start (`left - hanging`); a
- * positive-firstLine level puts it AFTER (`left + firstLine`) — the standard legal
- * shape `w:ind w:left="0" w:firstLine="720"` numbers at 0.5" while continuation
- * lines return to the margin. Reading only the hanging model painted every such
- * marker at the left margin.
- */
-declare function listMarkerBox(item: ResolvedListItem, markerWidth: number, lineY: number, lineHeight: number): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-} | null;
 
 interface StyleDefinition {
     readonly styleId: string;
+    readonly name?: string;
     readonly type: string;
     readonly basedOn: string | null;
     /** `w:next` — the authoring style for a following paragraph. */
@@ -1823,12 +2081,11 @@ interface StyleDefinition {
     readonly paragraphPropertiesNode: OoxmlElement | undefined;
     readonly tablePropertiesNode: OoxmlElement | undefined;
     readonly tableRowPropertiesNode: OoxmlElement | undefined;
+    readonly tableCellPropertiesNode?: OoxmlElement;
     readonly conditionalTableFormats: ReadonlyMap<string, OoxmlElement>;
 }
 declare function isValidStyleId(raw: string | undefined): raw is string;
 
-/** Soft ceiling on `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;
 /**
@@ -1838,6 +2095,23 @@ 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;
     /**
      * Bounded fingerprint folded into layout cache producers so a different styles part cannot
@@ -1878,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[];
@@ -1896,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[];
     /**
@@ -1995,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. */
@@ -2022,255 +2293,11 @@ 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.
- */
-declare function resolveParagraphLayoutInputs(paragraph: OoxmlElement, contentWidth: number, styleCascade: StyleCascadeTable | undefined, listItem?: ResolvedListItem, tableCellStyle?: TableCellStyleFormatting, inTableCell?: boolean, lineUnitPt?: number): ParagraphLayoutInputs;
-
-/**
- * `w:tblW` / `w:tcW` / `w:wBefore` (CT_TblWidth, 17.4.63 / 17.4.71 / 17.4.86): a PREFERRED
- * width plus the unit it is stated in. Preferred is the operative word — it is what the
- * producer asked for, not what the table resolved to.
- *
- * `pct` is stated in fiftieths of a percent (5000 = 100%) by Word, and in the `"50%"`
- * string form of `ST_Percentage` by others; both are read. `auto` and `nil` carry no width.
- */
-type PreferredWidthType = 'dxa' | 'pct' | 'auto' | 'nil';
-/**
- * `w:tblW` / `w:tcW` — a requested width, whose UNIT depends on its type.
  *
- * Points for `dxa`, percent for `pct`, and zero for `auto`/`nil`. Reading `value` without `type`
- * is always wrong.
+ * `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.
  */
-interface PreferredWidth {
-    readonly type: PreferredWidthType;
-    /** POINTS for `dxa`, PERCENT (0–100) for `pct`, 0 for `auto`/`nil`. */
-    readonly value: number;
-}
-/** The frozen "no preferred width" value — what a table or cell that declares none resolves to. */
-declare const AUTO_PREFERRED_WIDTH: PreferredWidth;
-
-/**
- * The uniform 3 pt (60 twip) inset this lane used to apply on every side.
- *
- * Word's defaults are not uniform — see {@link DEFAULT_CELL_MARGINS} — so nothing resolves
- * against this any more. Kept because it is published.
- */
-declare const CELL_PAD = 3;
-/** Resolved cell padding in points, after the table default and any per-cell override. */
-interface CellMarginsPt {
-    readonly top: number;
-    readonly right: number;
-    readonly bottom: number;
-    readonly left: number;
-}
-/**
- * Word's own default cell padding, for a document whose styles part states none.
- *
- * 0 top, 0 bottom, 108 twips left and right — the values `TableNormal` carries. A uniform
- * 3 pt on all four sides made every row of every table that authored no `w:tblCellMar` 6 pt
- * taller than Word's, and that error compounds down a table until it paginates a page early.
- * A document that DOES ship a default table style resolves against that instead; this is the
- * floor beneath it.
- */
-declare const DEFAULT_CELL_MARGINS: CellMarginsPt;
-
-/** `w:vAlign` — where a cell's content sits when the row is taller than the content. */
-type CellVerticalAlign = 'top' | 'center' | 'bottom';
-
-/**
- * Layout-time nesting ceiling. Parse-time depth (MAX_DEPTH = 256 XML levels) alone still
- * admits ~80 levels of `w:tbl` recursion into the layout walk; deeper tables render as an
- * empty cell box rather than recursing.
- */
-declare const MAX_TABLE_NESTING = 16;
-/**
- * Soft ceiling on an authored `w:trHeight` (~22"). Hostile `w:val` otherwise becomes a
- * multi-page row that every pagination preflight and cell box inherits.
- */
-declare const MAX_TABLE_ROW_HEIGHT_PT: number;
-/**
- * `w:trPr/w:trHeight` (17.4.81) resolved for layout. Points leave the reader already —
- * twips convert once here, matching every other table geometry boundary.
- *
- * Word quirk (matches Form025U and Word's UI export): a present `@w:val` with an omitted
- * `@w:hRule` is treated as `atLeast`, not ECMA's `auto`. Explicit `auto` still ignores val.
- */
-type TableRowHeightRule = 'auto' | 'atLeast' | 'exact';
-/**
- * `w:trHeight` — a row's height rule and its value.
- *
- * `auto` carries no value at all, which is why this is a union rather than a rule plus an
- * optional number.
- */
-type TableRowHeight = {
-    readonly rule: 'auto';
-} | {
-    readonly rule: 'atLeast' | 'exact';
-    readonly valuePt: number;
-};
-/** `w:tblPr/w:jc` (17.4.29, ST_JcTable): where the table sits within the text column. */
-type TableAlignment = 'left' | 'center' | 'right';
-/**
- * `w:tblpPr/@w:horzAnchor` (17.4.58) and `@w:vertAnchor` (17.4.66): the box a floated
- * table's offsets are measured from. Absent means `text` for both.
- */
-type TableFloatAnchor = 'text' | 'margin' | 'page';
-/** `w:tblpPr/@w:tblpXSpec` (17.4.63, ST_XAlign). */
-type TableFloatXSpec = 'left' | 'center' | 'right' | 'inside' | 'outside';
-/** `w:tblpPr/@w:tblpYSpec` (17.4.65, ST_YAlign). */
-type TableFloatYSpec = 'inline' | 'top' | 'center' | 'bottom' | 'inside' | 'outside';
-/**
- * `w:tblPr/w:tblpPr` (17.4.57) — a table positioned against an anchor box rather than at
- * the point in the text where it was authored.
- *
- * A spec (`tblpXSpec`/`tblpYSpec`) supersedes the matching offset when both are present:
- * 17.4.57 states the alignment outright, and the offset only answers "how far from the
- * anchor" for the case where no alignment was stated.
- */
-interface TableFloatPosition {
-    readonly horzAnchor: TableFloatAnchor;
-    readonly vertAnchor: TableFloatAnchor;
-    readonly xSpec?: TableFloatXSpec;
-    /** `w:tblpX` in points; signed, so a table can be pulled into the margin. */
-    readonly xPt: number;
-    readonly ySpec?: TableFloatYSpec;
-    /** `w:tblpY` in points; signed. */
-    readonly yPt: number;
-    readonly distances?: {
-        readonly top: number;
-        readonly right: number;
-        readonly bottom: number;
-        readonly left: number;
-    };
-}
-/**
- * One cell in the resolved table structure.
- *
- * `gridSpan` is clamped at READ time and layout never re-derives it — the value comes from a file
- * and would otherwise be a loop bound an attacker controls.
- */
-interface SemanticTableCell {
-    readonly id: string;
-    /** Derived content-edge geometry for a verified legacy full-width parent table. */
-    readonly legacyContentAlignment?: true;
-    /** Clamped to [1, MAX_TABLE_COLUMNS] at read time; layout never re-derives it. */
-    readonly gridSpan: number;
-    /** Physical grid column after width/style resolution and the bidiVisual projection. */
-    readonly gridColumn: number;
-    /** Stored grid index when bidiVisual maps this cell into a physical RTL grid. */
-    readonly logicalGridColumn?: number;
-    /** Canonical `w:gridCol` node id for this cell's start column, when the grid is authored. */
-    readonly gridColumnId?: string;
-    /** A vMerge cell that is not the restart continues the cell above: box, no content. */
-    readonly vMergeContinue: boolean;
-    /** `w:vAlign` — defaults to top when omitted/unrecognised. */
-    readonly vAlign: CellVerticalAlign;
-    /** `w:textDirection`; unsupported values keep horizontal layout. */
-    readonly textDirection: 'horizontal' | 'btLr';
-    /** Resolved per-side margins (tcMar over tblCellMar over the table style over Word's default). */
-    readonly margins: CellMarginsPt;
-    /** Three-state authored `tcBorders` (omitted / none / edge). */
-    readonly borders: CellBorderBox;
-    /** Validated 6-hex shading fill, absent for none/auto. */
-    readonly shading?: string;
-    /**
-     * `w:tcW` — the width this cell asked for, as authored.
-     *
-     * Published for consumers that need the cell's own statement (a column-resize handle has
-     * to write back to it). Column geometry is NOT derived from this field: the resolver works
-     * from a flat claim list built in the same pass, because resolving a column means looking
-     * at every cell that covers it across every row, not at one cell at a time. Read
-     * `columnWidthsPt` for what the table actually laid out.
-     */
-    readonly preferredWidth: PreferredWidth;
-    /**
-     * What the table style says about this cell's paragraphs and runs (17.7.6.6) — a header
-     * row's bold and centring live here, not in the cell's own properties.
-     */
-    readonly styleFormatting: TableCellStyleFormatting;
-    /** Block children in reading order, with content-control wrappers flattened. */
-    readonly blocks: readonly OoxmlElement[];
-}
-/** One row in the resolved structure: its cells, its height rule, and any row-level revision. */
-interface SemanticTableRow {
-    readonly id: string;
-    /** Pending Word row insertion/deletion authored in `w:trPr`. */
-    readonly revisionKind?: 'insert' | 'delete';
-    /**
-     * The `w:trPr/w:ins|w:del` attribution, carried with the kind so a painted row can say
-     * WHOSE pending decision it is — the review model addresses the decision by exactly this
-     * `(id, author, date)` triple, and a surface with only the kind could highlight the row
-     * but never open its card.
-     */
-    readonly revisionId?: string;
-    readonly revisionAuthor?: string;
-    readonly revisionDate?: string;
-    /** The row insertion a resolved view kept the row through; see the fragment record. */
-    readonly changeSites?: readonly RevisionAttribution[];
-    /** `w:trPr/w:tblHeader` — the row repeats atop each page the table continues onto. */
-    readonly isHeader: boolean;
-    /**
-     * `w:trPr/w:cantSplit` — the row must stay on one page. When it cannot fit a fresh page,
-     * layout fails closed rather than fragmenting or overflowing the content box.
-     */
-    readonly cantSplit: boolean;
-    /** `w:trPr/w:trHeight` — auto / atLeast floor / exact (clipped) row height. */
-    readonly height: TableRowHeight;
-    readonly cells: readonly SemanticTableCell[];
-}
-/**
- * A table resolved into a rectangular grid: column widths, rows, and the widths it asked for.
- *
- * The grid is normalized here so layout never has to reconcile `w:gridCol` against actual cell
- * spans — vertical merges and column spans are already accounted for.
- */
-interface SemanticTableStructure {
-    /** Whether stored columns and horizontal table properties display right to left. */
-    readonly bidiVisual?: true;
-    readonly columnWidthsPt: readonly number[];
-    readonly rows: readonly SemanticTableRow[];
-    /** Verified pre-2013 content-aligned full-width inline table; derived, never serialized. */
-    readonly legacyContentAlignment?: true;
-    /** `w:tblPr/w:tblW` — the width the table asked for. */
-    readonly tableWidth: PreferredWidth;
-    /**
-     * `w:tblInd` (17.4.50) in points — "this indentation should shift the table into the text
-     * margin by the specified amount". Applies to a left-aligned table; `w:jc` decides the
-     * placement outright for the other two.
-     */
-    readonly indentPt: number;
-    /** `w:tblPr/w:jc` (17.4.29) — where the table sits in the text column. */
-    readonly alignment: TableAlignment;
-    /**
-     * `w:tblPr/w:tblpPr` (17.4.57) — present when the table is positioned against an anchor
-     * box. Placement then comes from {@link tableFloatOriginX} rather than `w:jc`/`w:tblInd`.
-     */
-    readonly float?: TableFloatPosition;
-    /**
-     * `w:tblCellSpacing` (17.4.45) in points: the gap between adjacent cell edges. Applied as
-     * a half-gap inset on each side of every cell, so cells separate visually without the grid
-     * itself moving. Word ALSO grows the table's overall width by the spacing it adds around
-     * the outside; that part is not modelled, so a spaced table is laid out on the same grid
-     * its file states rather than a wider one.
-     */
-    readonly cellSpacingPt: number;
-    /**
-     * `w:tblPr/w:tblLayout/@w:type="fixed"` (17.4.52 — 17.4.53 is the `w:tblPrEx` exception
-     * variant, not this element). Fixed layout takes the grid as final;
-     * anything else is autofit, which in Word never renders wider than the text column.
-     */
-    readonly layoutFixed: boolean;
-    /** Table-level `tblBorders` (three-state, including insideH/insideV). */
-    readonly tableBorders: TableBorderBox;
-    /** Table-level `tblCellMar` defaults (per-side, Word's own default when a side is omitted). */
-    readonly defaultMargins: CellMarginsPt;
-}
-/**
- * Read one typed table node into a bounded structure, or null when the node is not a
- * typed table or sits beyond the nesting ceiling.
- */
-declare function readTableStructure(table: OoxmlNode, contentWidthPt: number, depth: number, styleCascade?: StyleCascadeTable, 
-/** Which revisions the view resolves away; only the proposed result performs the join. */
-displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter, compatibilityMode?: number): SemanticTableStructure | null;
+declare function resolveParagraphLayoutInputs(paragraph: OoxmlElement, contentWidth: number, styleCascade: StyleCascadeTable | undefined, listItem?: ResolvedListItem, tableCellStyle?: TableCellStyleFormatting, inTableCell?: boolean, lineUnitPt?: number): ParagraphLayoutInputs;
 
 interface EquationGeometryBase {
     readonly box: LayoutBox;
@@ -2570,6 +2597,8 @@ interface StyleSpanRecord {
      * ink displacement. Exporters must apply this offset to the ink origin.
      */
     readonly glyphOffsetPt?: number;
+    /** Measured face baseline for character-border geometry; span boxes remain selection bands. */
+    readonly borderBaselinePt?: number;
     readonly range: SourceRange;
     readonly text: string;
     /** The run's authored properties, retained as evidence. */
@@ -2674,6 +2703,8 @@ interface StyleSpanRecord {
      * and selection mapping refuses them the way it refuses markers.
      */
     readonly projected?: boolean;
+    /** Authored inline separator rule; its advance belongs to one note atom. */
+    readonly noteSeparator?: 'separator' | 'continuationSeparator';
     /** Paint-ready geometry for one atomic Office Math equation. */
     readonly equation?: EquationSpanRecord;
     /**
@@ -2717,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.
      *
@@ -2728,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;
@@ -2813,10 +2844,16 @@ interface ParagraphFragmentRecord {
     readonly emptyParagraphStyle?: ResolvedRunStyle;
     /** A fixed text frame clips its painted ink to this fragment's box; source ranges remain intact. */
     readonly clipToBox?: true;
-    /** A positioned text frame retains its source identity without consuming body flow height. */
+    /**
+     * The fragment retains its source identity without consuming body flow height: a positioned
+     * text frame (with {@link ParagraphFragmentRecord.positionedFrame}), an empty section-mark
+     * paragraph before a continuous section, or the empty line in front of a paragraph's leading
+     * page break at the bottom of a full page. The last two paint nothing.
+     */
     readonly outOfFlow?: true;
     /** Placement and wrapping of one authored text-frame group, in page-content coordinates. */
     readonly positionedFrame?: {
+        readonly dropCapLines?: number;
         readonly anchorId: string;
         readonly columnIndex: number;
         readonly groupId: string;
@@ -2971,17 +3008,53 @@ 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. */
     readonly numFmt: string;
     /** Resolved counter at this marker's own level; absent for bullets. */
     readonly ordinal?: number;
+    /**
+     * The IMAGE this marker draws instead of {@link ListMarkerRecord.text}, when the resolved
+     * level carries `w:lvlPicBulletId` (§17.9.12) and the referenced `w:numPicBullet` resolved.
+     *
+     * Absent on every ordinary marker, and absent when the picture bullet is missing, external,
+     * malformed or oversized — in which case `text` stands and the marker paints as the level's
+     * `w:lvlText` did before. A sink that cannot draw the resource paints `text` too, which is
+     * why both are published rather than one replacing the other.
+     */
+    readonly picture?: ListMarkerPictureRecord;
+    /**
+     * In a right-to-left paragraph: `text` in VISUAL order, one piece per direction run, each
+     * styled at its bidi level. Paint draws these instead of `text`, which stays logical.
+     */
+    readonly pieces?: readonly Pick<ListMarkerRecord, 'text' | 'style' | 'box'>[];
+}
+/**
+ * The picture a `w:lvlPicBulletId` marker paints, with its geometry already decided.
+ *
+ * Geometry is in the same coordinate space as {@link ListMarkerRecord.box}: paint positions
+ * from `box` and MUST NOT rescale it, neither from the resource's intrinsic pixels nor from
+ * the authored `v:shape` extent, which the marker font size has already scaled. The image
+ * sits with its BOTTOM on the first line's baseline, which is what makes the line tall
+ * enough for it.
+ *
+ * `resource` is the same validated-image projection an inline drawing carries, resolved
+ * through the numbering part's OWN relationships. A `ready` resource is the only one that
+ * can be drawn; every other state is a clean fall back to the marker text.
+ * @public
+ */
+interface ListMarkerPictureRecord {
+    /** The part whose relationships `relationshipId` belongs to — the numbering part. */
+    readonly ownerPartName: string;
+    /** `v:imagedata/@r:id` of the `w:numPicBullet` shape. */
+    readonly relationshipId: string;
+    /** Where the image paints, authored extent, in the marker's coordinate space. */
+    readonly box: LayoutBox;
+    /** Validated image state, or why there is none. */
+    readonly resource: ImageResourceState;
 }
 /**
  * The part of one table that sits on one page.
@@ -3041,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;
 }
@@ -3181,13 +3252,17 @@ 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;
         /** Layout-owned single/double rule when marker-only or synthetic; absent for authored stories. */
         readonly ruleStyle?: 'single' | 'double';
+        /** Resolved marker-run color; null/absent uses automatic black. */
+        readonly ruleColor?: string | null;
     };
+    /** Authored furniture below a note that continues on the next page. */
+    readonly continuationNotice?: NonNullable<NoteAreaRecord['separator']>;
     readonly notes: readonly NoteStoryRecord[];
     readonly fallbackReason?: string;
 }
@@ -3287,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).
@@ -3387,11 +3464,20 @@ interface TextMeasurer {
         left: number;
         right: number;
     } | undefined;
-    /** Line height and baseline for the resolved style. */
-    lineMetrics(style: ResolvedRunStyle): {
+    /** Whether line metrics use an admitted face instead of approximate fallback metrics. */
+    hasResolvedFont?(style: ResolvedRunStyle): boolean;
+    /**
+     * Optional `OS/2` strikeout stroke for the resolved face, at the drawn size. Word paints
+     * `w:separator` as a strikeout, so the note rule reads its thickness and offset here rather
+     * than assuming one face's numbers. Undefined keeps the caller's own default.
+     */
+    strikeoutMetrics?(style: ResolvedRunStyle): StrikeoutStrokePt | undefined;
+    /** Line metrics for the actual text faces; omitted text measures the primary face. */
+    lineMetrics(style: ResolvedRunStyle, text?: string): {
         height: number;
         baseline: number;
     };
 }
 
-export { type AbstractNumDefinition as $, type AnchoredDrawingRecord as A, type BlockFragmentRecord as B, type ContentControlBoundaryRecord as C, type DrawingPoint as D, type StyleCascadeTable as E, type FontResourceSnapshot as F, type HyperlinkProjector as G, type HeaderFooterStoryRecord as H, type InlineDrawingRecord as I, type InlineDrawingLayoutContext as J, type FieldLinkProjector as K, type LineRecord as L, type ModelRange as M, type NormalizationPolicy as N, type StoryPageFieldNeeds as O, type PageGeometry as P, type RefFieldContext as Q, type ResolvedRunStyle as R, type SemanticLayout as S, type TextMeasurer as T, type HyperlinkFieldSpec as U, type VersionedShapingLibrary as V, type SpanLinkRecord as W, type ResolvedListItem as X, type PageBorderFrameRecord as Y, AUTO_PARAGRAPH_SPACING_PT as Z, AUTO_PREFERRED_WIDTH as _, type StyleSpanRecord as a, PARAGRAPH_BORDER_SIDES as a$, type AnchoredDrawingLayoutFallback as a0, type BidiEmbeddingLevels as a1, type BorderGridGeometry as a2, CELL_PAD as a3, type CascadedParagraphFormatting as a4, type CellBorderBox as a5, type CellMarginsPt as a6, type CellVerticalAlign as a7, type CjkTypographySettings as a8, type ContentControlGeometryFragment 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_TABLE_NESTING as aU, MAX_TABLE_ROW_HEIGHT_PT as aV, MAX_TAB_POSITION_TWIPS as aW, MAX_TAB_STOPS as aX, type NumDefinition as aY, type NumberingLevelIndent as aZ, PAGE_BORDER_SIDES as a_, type ContentControlLevel as aa, type ContentControlMappedType as ab, DEFAULT_CELL_MARGINS 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, UnsupportedScriptError as b$, type PageBorderDisplay as b0, type PageBorderOffsetFrom as b1, type PageBorderSide as b2, type PageBorderStrokeRecord as b3, type PageBorderZOrder as b4, type PageRefCalibrationCell as b5, type PageRefFieldProjection as b6, type ParagraphAutoSpacingContext as b7, type ParagraphBorderEdge as b8, type ParagraphBorderSide as b9, type SemanticTableRow as bA, type SemanticTrackedChangeArtifactRecord as bB, type ShapeInput as bC, type ShapedCluster as bD, type ShapedFontSpan as bE, type ShapedGlyph as bF, type ShapedRunComparatorInputs as bG, type ShapedVerticalMetrics as bH, type ShapingEnvironment as bI, type ShapingEnvironmentFingerprintInputs as bJ, type StyleDefinition as bK, TAB_LEADER_GLYPH as bL, type TabAlignment as bM, type TabDestination as bN, type TabLeader as bO, type TabStop as bP, type TableAlignment as bQ, type TableBorderBox as bR, type TableBorderSideName as bS, type TableBorderStrokeRecord as bT, type TableCellStyleFormatting as bU, type TableFragmentRecord as bV, type TableRowHeight as bW, type TableRowHeightRule as bX, type TextDirection as bY, type TextboxStoryFallbackReason as bZ, type TextboxStoryLayout as b_, type ParagraphBorderStrokeRecord as ba, type ParagraphBorders as bb, type ParagraphBottomBorderRecord as bc, type ParagraphIndent as bd, type ParagraphLayoutInputs as be, type ParagraphLineSpacing as bf, type ParagraphSpacing as bg, type PreferredWidth as bh, type PreferredWidthType as bi, type RefFieldSpec as bj, type RefNoteParts as bk, type ResolvedCellBorders as bl, type ResolvedTabStops as bm, type ResolvedTableBorderEdge as bn, type ResolvedTableBorderEdgeSegment as bo, type ResolvedUnderline as bp, SINGLE_LINE_SPACING as bq, type ScriptItem as br, type SemanticArtifactRootStoryKind as bs, type SemanticArtifactStoryKind as bt, type SemanticCommentArtifactRecord as bu, type SemanticReviewArtifactOccurrence as bv, type SemanticReviewArtifactOccurrenceGeometry as bw, type SemanticReviewArtifactPosition as bx, type SemanticReviewArtifactSource as by, type SemanticTableCell as bz, type TableRowFragmentRecord as c, withNumberingStyleLinks as c$, type VerticalAlign as c0, appliedSpaceBefore as c1, applyLineSpacing as c2, baselineShiftPtOf as c3, borderExtentPt as c4, borderWeight as c5, bottomBorderExtentPt as c6, boundedStructuralFontValidator as c7, buildNumberingIndex as c8, buildStyleCascadeTable as c9, paragraphContextualSpacing as cA, paragraphLineSpacing as cB, paragraphSpacing as cC, paragraphTabStops as cD, parsePageBorders as cE, parseRefInstruction as cF, readBorderSide as cG, readCellBorders as cH, readNumPr as cI, readTableBorders as cJ, readTableStructure as cK, resolveBorderConflict as cL, resolveNumberingLevel as cM, resolveParagraphLayoutInputs as cN, resolveRunStyle as cO, resolveStoryListItems as cP, resolveStoryRefFields as cQ, resolveTableCellBorderGrid as cR, runStylesEqual as cS, shapedRunComparatorInputs as cT, shapingEnvironmentFingerprint as cU, shapingEnvironmentFingerprintInputs as cV, styleForFontSlot as cW, tabAdvanceWidth as cX, tabStopsFingerprint as cY, walkStoryParagraphs as cZ, withDefaultTabInterval as c_, cascadeParagraphFormatting as ca, cascadeRunProperties as cb, cascadedBottomBorder as cc, cascadedParagraphBorders as cd, cascadedTabStops as ce, collapsedSpaceBefore as cf, createFontResourceSnapshot as cg, createShapedRun as ch, createShapingEnvironment as ci, defaultTabIntervalFromSettings as cj, displayText as ck, fixedPoint as cl, fontRequestKey as cm, isValidStyleId as cn, itemizeScriptFontSlots as co, layoutEquation as cp, listMarkerBox as cq, measureDisplayText as cr, mergeListIndent as cs, nextTabDestination as ct, pageBordersFingerprint as cu, paragraphBorderExtentPt as cv, paragraphBorderStrokeWidthPt as cw, paragraphBorders as cx, paragraphBordersFingerprint as cy, paragraphBreaksBefore as cz, type TableCellFragmentRecord as d, withResolvedListItems as d0, 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 FontSubstitution as k, type ShapedRun as l, type NumberingLevel as m, type NumberingIndex as n, type ParagraphFragmentRecord as o, type LayoutBox as p, type DrawingInsets as q, type TableBorderSide as r, type PageRecord as s, type SemanticTableStructure as t, type NoteAreaRecord as u, type NoteStoryRecord as v, type ContentControlLock as w, type FontByteValidator as x, type FixedPoint as y, type SourceRange 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 };