@docx-editor.dev/core 2.21.1 → 2.22.0

package/dist/{semantic-records-StH-AnHK.d.ts → semantic-records-C5OeXnaL.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-DDVBYTIG.js';
+import { a0 as OoxmlProperty, a1 as OoxmlElement, i as OoxmlNode, O as OoxmlPart, aG as TableBorderStyle, aH as DrawingAccessibility, aI as DrawingImageEffects, a8 as SourceCrop, aJ as DrawingTransform, aK as VectorShapeProjection, aj as DrawingHorizontalReferenceFrame, ak as DrawingVerticalReferenceFrame, aa as ImageWrapTarget, a4 as DrawingProjection, aL as OoxmlDrawingNode } from './types-barrel-ChGvWjkO.js';
+import { b as ImageResourceState } from './image-resources-B0v-XaTM.js';
+import { O as OmmlEquationProjection } from './omml-equation-CfTm3jOK.js';
+
+/** 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;
@@ -63,6 +141,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 +202,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,114 +238,257 @@ 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.
+ * 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 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;
+declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
 /**
- * How a tab stop positions the text that follows it.
+ * 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.
  *
- * 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.
+ * 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.
  */
-type TabAlignment = 'left' | 'center' | 'right' | 'decimal';
+interface ParagraphSpacing {
+    /** `w:spacing/@before`, in points. */
+    readonly before: number;
+    /** `w:spacing/@after`, in points. */
+    readonly after: number;
+}
 /**
- * `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.
+ * 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).
  *
- * 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.
+ * 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.
  */
-type TabLeader = 'dot' | 'hyphen' | 'underscore' | 'heavy' | 'middleDot';
+declare const AUTO_PARAGRAPH_SPACING_PT = 14;
 /**
- * The character each leader repeats (§17.3.1.38, ST_TabTlc).
+ * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
+ * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
  *
- * 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.
+ * 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/`.
  */
-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 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;
 }
 /**
- * A paragraph's tab stops after the style cascade, with the default interval that applies past
- * the last explicit one.
+ * 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.
  */
-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;
+type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
 /**
- * Resolve tab stops from cascaded `w:pPr` nodes (docDefaults → style chain → direct).
+ * Resolved line spacing: the rule, and the value it applies.
  *
- * 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.
+ * `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.
  */
-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;
+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;
+}
+/** Single spacing: what a paragraph that says nothing gets. */
+declare const SINGLE_LINE_SPACING: ParagraphLineSpacing;
 /**
- * Republish stops under a document-wide default-tab interval (`w:defaultTabStop`).
+ * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
  *
- * 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.
+ * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
+ * unbounded border width becomes a layout dimension.
  */
-declare function withDefaultTabInterval(tabs: ResolvedTabStops, defaultIntervalPt: number | undefined): ResolvedTabStops;
+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"];
 /**
- * Read `w:settings/w:defaultTabStop` (ECMA-376 §17.15.1.25), in points.
+ * Which of the six `CT_PBdr` edges.
  *
- * 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.
+ * 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).
  *
- * `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.
+ * `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.
  */
-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 ParagraphBorders {
+    readonly top?: ParagraphBorderEdge;
+    readonly left?: ParagraphBorderEdge;
+    readonly bottom?: ParagraphBorderEdge;
+    readonly right?: ParagraphBorderEdge;
+    readonly between?: ParagraphBorderEdge;
+    readonly bar?: ParagraphBorderEdge;
 }
 /**
- * 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.
+ * 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 nextTabDestination(tabs: ResolvedTabStops, currentX: number, rightEdge: number): TabDestination;
+declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
 /**
- * Width of a tab glyph so the following segment lands on the destination.
+ * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
  *
- * `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).
+ * 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 tabAdvanceWidth(alignment: TabAlignment, currentX: number, destinationX: number, segmentWidth: number, decimalOffset: number): number;
+declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
 /**
- * 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.
+ * 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.
  */
-declare function tabStopsFingerprint(tabs: ResolvedTabStops): string;
+declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
+    height: number;
+    baseline: number;
+};
+/**
+ * `w:contextualSpacing` (17.3.1.9): drop before/after between paragraphs of the SAME
+ * style. Word's built-in `ListParagraph` sets it, so every list authored in Word gets a
+ * paragraph gap between items without this.
+ */
+declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
+/**
+ * Resolve `w:pBdr` from the paragraph-properties node.
+ *
+ * Nested — every edge is a child of `pBdr`, not an attribute — so this reads the typed tree
+ * rather than the flattened `OoxmlProperty[]` bag `propertiesOf` builds for leaf props.
+ */
+declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+/**
+ * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
+ *
+ * Word does not merge edges across the cascade. A style that states only `w:bottom` discards
+ * the box its `basedOn` ancestor declared, so folding edge by edge would leave a lone
+ * underline surrounded by a box no one authored. Absence inherits; `nil`/`none` clear.
+ */
+declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
+/**
+ * Visual stroke thickness layout publishes for one edge (points).
+ *
+ * Compound `ST_Border` values (`double`, …) use the shared inflated band so a thin
+ * `w:sz="3"` double still occupies a visible double-line box — matching table borders.
+ */
+declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+/**
+ * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
+ *
+ * Vertically that is flow height — a top rule pushes the first line down, a bottom rule holds
+ * the page open below the last one — so pagination has to see it. Horizontally it is
+ * publish-only: Word draws left/right paragraph rules OUTSIDE the text column and never
+ * re-breaks the lines, which is why adding a box to a paragraph in Word does not reflow it.
+ */
+declare function paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+/** Vertical extent a bottom border adds below the last line (gap + rule). */
+declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+/**
+ * Identity of a paragraph's border set, for the `w:between` group rule.
+ *
+ * Word treats consecutive paragraphs whose border settings are IDENTICAL as ONE bordered
+ * block: the top rule draws above the first, the bottom rule below the last, and each
+ * interior boundary gets `w:between` or nothing (§17.3.1.24). That is why applying a box to
+ * three selected paragraphs in Word draws one box and not three.
+ *
+ * Empty string means "no borders", which never groups with anything.
+ */
+declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
+/**
+ * Gap to insert before a paragraph once the previous paragraph's `after` is already in the
+ * flow cursor — Word takes the larger of the two rather than summing them.
+ */
+declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+/**
+ * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ *
+ * Adjacent before/after still collapse to the larger gap, but before is dropped entirely when
+ * the paragraph 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';
@@ -304,6 +537,8 @@ interface ResolvedRunStyle {
         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;
@@ -326,8 +561,17 @@ interface ResolvedRunStyle {
     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. */
+    /** `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.
      *
@@ -391,6 +635,16 @@ declare function runStylesEqual(a: ResolvedRunStyle, b: ResolvedRunStyle): boole
  * painter, and the caret — has to apply this itself, and from one place, or the two drift.
  */
 declare function baselineShiftPtOf(style: ResolvedRunStyle): number;
+/**
+ * Shared glyph-size factor for baseline, superscript, and subscript text.
+ *
+ * The 65% script scale follows the common Word font metrics (Arial, Calibri, Times New
+ * Roman) and improves the saved Word reference at 10pt and 11pt. It is a uniform policy;
+ * per-face script metrics and Word's output-device rounding are not modeled here.
+ * Layout, surface paint, and exporters must apply the same factor to avoid caret drift.
+ * @public
+ */
+declare function glyphSizeFactorOf(style: ResolvedRunStyle): number;
 
 /**
  * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
@@ -677,6 +931,8 @@ interface ShapeInput {
  */
 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 +1005,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
@@ -1143,236 +1412,116 @@ 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}.
- */
-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.
+ * 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 paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
+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;
 /**
- * Apply resolved line spacing to a line's natural (glyph-derived) box.
+ * How a tab stop positions the text that follows it.
  *
- * 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.
+ * 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 applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
-    height: number;
-    baseline: number;
-};
+type TabAlignment = 'left' | 'center' | 'right' | 'decimal';
 /**
- * `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.
+ * `w:tab/@w:leader` (ECMA-376 §17.3.1.38, ST_TabTlc): the character repeated across the
+ * space a tab reserves. `none` is the default and is represented by an absent leader.
+ *
+ * This is the difference between a Word table of contents and a column of headings floating
+ * next to a column of page numbers, so it is carried through layout to paint rather than
+ * dropped as a geometry-irrelevant attribute.
  */
-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;
+    /** 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;
+}
+/** 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 +1539,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 +1562,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 +1659,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 +1686,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 +1702,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 +1723,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;
 
 /**
@@ -1672,6 +1825,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 +1850,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 +1889,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;
 }
@@ -1786,30 +1968,11 @@ 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;
@@ -1823,6 +1986,7 @@ 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;
@@ -1838,6 +2002,12 @@ declare const MAX_STYLE_DEFINITIONS = 4096;
  * styles part are never reused under another.
  */
 interface StyleCascadeTable {
+    /** Legacy or explicitly disabled optional OpenType substitutions. */
+    readonly disableOptionalLigatures?: true;
+    /** Legacy noExtraLineSpacing behavior, included in the producer fingerprint. */
+    readonly preserveExactLineBaseline?: 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
@@ -2025,253 +2195,6 @@ interface ParagraphLayoutInputs {
  */
 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.
- */
-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;
-
 interface EquationGeometryBase {
     readonly box: LayoutBox;
     /** Baseline measured from this node's top edge. */
@@ -2570,6 +2493,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 +2599,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;
     /**
@@ -2813,10 +2740,15 @@ 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}), or an empty section-mark
+     * paragraph before a continuous section, which paints 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;
@@ -2982,6 +2914,40 @@ interface ListMarkerRecord {
     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;
+}
+/**
+ * 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.
@@ -3187,6 +3153,8 @@ interface NoteAreaRecord {
         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;
     };
     readonly notes: readonly NoteStoryRecord[];
     readonly fallbackReason?: string;
@@ -3387,11 +3355,19 @@ 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 { type SpanLinkRecord as $, type AnchoredDrawingRecord as A, type BlockFragmentRecord as B, type ContentControlBoundaryRecord as C, type DrawingPoint as D, type NoteAreaRecord as E, type FontResourceSnapshot as F, type NoteStoryRecord as G, type HeaderFooterStoryRecord as H, type InlineDrawingRecord as I, type ContentControlLock as J, type FontByteValidator as K, type LineRecord as L, type ModelRange as M, type NormalizationPolicy as N, type FixedPoint as O, type PageGeometry as P, type SourceRange as Q, type ResolvedRunStyle as R, type SemanticLayout as S, type TextMeasurer as T, type HyperlinkProjector as U, type VersionedShapingLibrary as V, type InlineDrawingLayoutContext as W, type FieldLinkProjector as X, type StoryPageFieldNeeds as Y, type RefFieldContext as Z, type HyperlinkFieldSpec as _, type StyleSpanRecord as a, type PageBorderDisplay as a$, type PageBorderFrameRecord as a0, type ParagraphBorderStrokeRecord as a1, type StrikeoutStrokePt as a2, AUTO_PARAGRAPH_SPACING_PT as a3, type AbstractNumDefinition as a4, type AnchoredDrawingLayoutFallback as a5, type BidiEmbeddingLevels as a6, type BorderGridGeometry as a7, type CascadedParagraphFormatting as a8, type CjkTypographySettings as a9, type FontResourceSnapshotOptions as aA, type FontSlot as aB, type FontValidationResult as aC, type GlyphOutline as aD, HARD_MAX_AGGREGATE_FONT_BYTES as aE, HARD_MAX_FONT_BYTES as aF, HARD_MAX_FONT_SOURCES as aG, type LevelOverride as aH, type LineSpacingRule as aI, type ListMarkerAlign as aJ, type ListMarkerRecord as aK, type ListSuffix as aL, MAX_BORDER_SPACE_PT as aM, MAX_BORDER_WIDTH_PT as aN, MAX_LVL_OVERRIDES as aO, MAX_NUMBERING_DEFINITIONS as aP, MAX_PARAGRAPH_SPACING_PT as aQ, MAX_STYLE_BASED_ON_DEPTH as aR, MAX_STYLE_DEFINITIONS as aS, MAX_TABLE_BORDER_STROKES as aT, MAX_TAB_POSITION_TWIPS as aU, MAX_TAB_STOPS as aV, type NumDefinition as aW, type NumberingLevelIndent as aX, type NumberingPictureBullet as aY, PAGE_BORDER_SIDES as aZ, PARAGRAPH_BORDER_SIDES as a_, type ContentControlGeometryFragment as aa, type ContentControlLevel as ab, type ContentControlMappedType as ac, DEFAULT_PAGE_GEOMETRY as ad, DEFAULT_RUN_STYLE as ae, DEFAULT_TAB_INTERVAL_PT as af, DEFAULT_TAB_INTERVAL_TWIPS as ag, type DeclaredFontSubstitution as ah, type DrawingClipFallback as ai, type DrawingGeometry as aj, EMPTY_NUMBERING_INDEX as ak, EMPTY_TAB_STOPS as al, type EquationFractionGeometry as am, type EquationGeometry as an, type EquationNaryGeometry as ao, type EquationRadicalGeometry as ap, type EquationRowGeometry as aq, type EquationScriptGeometry as ar, type EquationSpanRecord as as, type EquationTextGeometry as at, type FieldAtomMarker as au, type FontFingerprintInputs as av, FontResolutionError as aw, type FontResolutionErrorCode as ax, type FontResourceDefinition as ay, type FontResourceInstrumentation as az, type SectionPageBorders as b, buildStyleCascadeTable as b$, type PageBorderOffsetFrom as b0, type PageBorderSide as b1, type PageBorderStrokeRecord as b2, type PageBorderZOrder as b3, type PageRefCalibrationCell as b4, type PageRefFieldProjection as b5, type ParagraphAutoSpacingContext as b6, type ParagraphBorderEdge as b7, type ParagraphBorderSide as b8, type ParagraphBorders as b9, type ShapedGlyph as bA, type ShapedRunComparatorInputs as bB, type ShapedVerticalMetrics as bC, type ShapingEnvironment as bD, type ShapingEnvironmentFingerprintInputs as bE, type StyleDefinition as bF, TAB_LEADER_GLYPH as bG, type TabAlignment as bH, type TabDestination as bI, type TabLeader as bJ, type TabStop as bK, type TableBorderSideName as bL, type TableBorderStrokeRecord as bM, type TableFragmentRecord as bN, type TextDirection as bO, type TextboxStoryFallbackReason as bP, type TextboxStoryLayout as bQ, UnsupportedScriptError as bR, type VerticalAlign as bS, appliedSpaceBefore as bT, applyLineSpacing as bU, baselineShiftPtOf as bV, borderExtentPt as bW, borderWeight as bX, bottomBorderExtentPt as bY, boundedStructuralFontValidator as bZ, buildNumberingIndex as b_, type ParagraphBottomBorderRecord as ba, type ParagraphIndent as bb, type ParagraphLayoutInputs as bc, type ParagraphLineSpacing as bd, type ParagraphSpacing as be, type RefFieldSpec as bf, type RefNoteParts as bg, type ResolvedCellBorders as bh, type ResolvedPictureBullet as bi, type ResolvedTabStops as bj, type ResolvedTableBorderEdge as bk, type ResolvedTableBorderEdgeSegment as bl, type ResolvedUnderline as bm, SINGLE_LINE_SPACING as bn, type ScriptItem as bo, type SemanticArtifactRootStoryKind as bp, type SemanticArtifactStoryKind as bq, type SemanticCommentArtifactRecord as br, type SemanticReviewArtifactOccurrence as bs, type SemanticReviewArtifactOccurrenceGeometry as bt, type SemanticReviewArtifactPosition as bu, type SemanticReviewArtifactSource as bv, type SemanticTrackedChangeArtifactRecord as bw, type ShapeInput as bx, type ShapedCluster as by, type ShapedFontSpan as bz, type TableRowFragmentRecord as c, cascadeParagraphFormatting as c0, cascadeRunProperties as c1, cascadedBottomBorder as c2, cascadedParagraphBorders as c3, cascadedTabStops as c4, collapsedSpaceBefore as c5, createFontResourceSnapshot as c6, createShapedRun as c7, createShapingEnvironment as c8, defaultTabIntervalFromSettings as c9, resolveBorderConflict as cA, resolveNumberingLevel as cB, resolveParagraphLayoutInputs as cC, resolveRunStyle as cD, resolveStoryListItems as cE, resolveStoryRefFields as cF, resolveTableCellBorderGrid as cG, runStylesEqual as cH, shapedRunComparatorInputs as cI, shapingEnvironmentFingerprint as cJ, shapingEnvironmentFingerprintInputs as cK, styleForFontSlot as cL, tabAdvanceWidth as cM, tabStopsFingerprint as cN, walkStoryParagraphs as cO, withDefaultTabInterval as cP, withNumberingStyleLinks as cQ, withResolvedListItems as cR, displayText as ca, fixedPoint as cb, fontRequestKey as cc, glyphSizeFactorOf as cd, isValidStyleId as ce, itemizeScriptFontSlots as cf, layoutEquation as cg, measureDisplayText as ch, mergeListIndent as ci, nextTabDestination as cj, pageBordersFingerprint as ck, paragraphBorderExtentPt as cl, paragraphBorderStrokeWidthPt as cm, paragraphBorders as cn, paragraphBordersFingerprint as co, paragraphBreaksBefore as cp, paragraphContextualSpacing as cq, paragraphLineSpacing as cr, paragraphSpacing as cs, paragraphTabStops as ct, parsePageBorders as cu, parseRefInstruction as cv, readBorderSide as cw, readCellBorders as cx, readNumPr as cy, readTableBorders as cz, type TableCellFragmentRecord as d, type ShapingEnvironmentInput as e, type TextShaper as f, type ResolvedFont as g, type FixedPointRoundingMode as h, type FontRequest as i, type SemanticReviewArtifactRecord as j, type ListMarkerPictureRecord as k, type FontSubstitution as l, type ShapedRun as m, type NumberingLevel as n, type NumberingIndex as o, type ParagraphFragmentRecord as p, type LayoutBox as q, type DrawingInsets as r, type TableBorderSide as s, type PageRecord as t, type ResolvedListItem as u, type CellBorderBox as v, type TableCellStyleFormatting as w, type TableFloatPosition as x, type TableBorderBox as y, type StyleCascadeTable as z };