@arbidocs/blocks 0.5.107 → 0.5.108

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

@@ -1,991 +1,1474 @@
-import { o as RevisionAttribution, b as RevisionDisplayMode } from './revision-projection-DZ4kKVev.js';
-import { X as OoxmlProperty, Z as OoxmlElement, N as OoxmlNode, O as OoxmlPart, aJ as TableBorderStyle, aK as DrawingAccessibility, aL as DrawingImageEffects, al as SourceCrop, aM as DrawingTransform, aN as VectorShapeProjection, aw as DrawingHorizontalReferenceFrame, ax as DrawingVerticalReferenceFrame, an as ImageWrapTarget, a0 as DrawingProjection, aO as OoxmlDrawingNode } from './types-barrel-D3xCgQX6.js';
-import { b as ImageResourceState } from './image-resources-BN-hUgCn.js';
-import { O as OmmlEquationProjection } from './omml-equation-CuzBL5DD.js';
+import { N as OoxmlNode, ah as OoxmlProperty, O as OoxmlPart, ak as OoxmlElement, aM as TableBorderStyle, aN as DrawingAccessibility, aO as DrawingImageEffects, aI as SourceCrop, aP as DrawingTransform, aQ as VectorShapeProjection, X as DrawingHorizontalReferenceFrame, $ as DrawingVerticalReferenceFrame, a1 as ImageWrapTarget, an as DrawingProjection, aR as OoxmlDrawingNode } from './types-barrel-DuC5QBNC.js';
+import { I as ImageResourceState } from './image-resources-tXLQShoC.js';
+import { O as OmmlEquationProjection } from './omml-equation-BUbU0utM.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;
+/** Named revision colors. Identifiers are stable and never contain CSS. @public */
+declare const REVISION_MARKUP_COLORS: readonly ['black', 'blue', 'turquoise', 'green', 'pink', 'red', 'yellow', 'white', 'darkBlue', 'teal', 'darkGreen', 'violet', 'darkRed', 'darkYellow', 'gray50', 'gray25', 'lightBlue', 'lightYellow', 'lightOrange', 'lightPurple', 'lightGreen', 'gray'];
+/** @public */
+type RevisionMarkupNamedColor = (typeof REVISION_MARKUP_COLORS)[number];
+/** @public */
+type RevisionMarkupColor = RevisionMarkupNamedColor | 'byAuthor' | 'auto';
+/** @public */
+type RevisionMarkupMark = 'none' | 'colorOnly' | 'bold' | 'italic' | 'underline' | 'doubleUnderline' | 'strikethrough' | 'doubleStrikethrough';
+/** @public */
+type RevisionDeletionMark = RevisionMarkupMark | 'hidden' | 'caret' | 'pound';
+/** @public */
+type RevisionChangedLinesMark = 'none' | 'leftBorder' | 'rightBorder' | 'outsideBorder';
+/** @public */
+interface RevisionMarkupStyle<Mark extends string = RevisionMarkupMark> {
+    readonly mark: Mark;
+    readonly color: RevisionMarkupColor;
+}
+/** Viewer-only text styling. Document highlighting remains unchanged. @public */
+interface RevisionMarkupTextStyle<Mark extends string = RevisionMarkupMark> extends RevisionMarkupStyle<Mark> {
+    /** Background color behind revision text. Defaults to `none`. */
+    readonly background: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+}
+/** Fully resolved, immutable viewer preferences. @public */
+interface ResolvedRevisionMarkup {
+    readonly insertions: RevisionMarkupTextStyle;
+    readonly deletions: RevisionMarkupTextStyle<RevisionDeletionMark>;
+    readonly movedFrom: RevisionMarkupTextStyle<RevisionDeletionMark>;
+    readonly movedTo: RevisionMarkupTextStyle;
+    readonly formatting: RevisionMarkupTextStyle;
+    readonly changedLines: RevisionMarkupStyle<RevisionChangedLinesMark>;
+    readonly cells: {
+        readonly inserted: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly deleted: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly merged: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly split: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+    };
+    readonly trackMoves: boolean;
+    readonly trackFormatting: boolean;
+}
+/** Partial viewer preferences. Omitted values keep the previous value. @public */
+type RevisionMarkupOptions = {
+    readonly [K in keyof ResolvedRevisionMarkup]?: ResolvedRevisionMarkup[K] extends boolean ? boolean : Partial<ResolvedRevisionMarkup[K]>;
+};
+/** Initial viewer preferences. @public */
+declare const DEFAULT_REVISION_MARKUP: ResolvedRevisionMarkup;
+/** Validate and merge preferences without modifying the input. @public */
+declare function resolveRevisionMarkup(input?: RevisionMarkupOptions, previous?: ResolvedRevisionMarkup): ResolvedRevisionMarkup;
+/** A local settings draft owned by the editor. @public */
+interface RevisionMarkupDialogSession {
+    /** Aborts on close, replacement, load, detach, destroy, or renderer disposal. */
+    readonly signal: AbortSignal;
+    /** Read the immutable draft. */
+    get(): ResolvedRevisionMarkup;
+    /** Merge validated options into the draft without committing preferences. */
+    set(options: RevisionMarkupOptions): void;
+    /** Restore default preferences in the draft only. */
+    reset(): void;
+    /** Observe draft changes, including effective external preference changes. */
+    subscribe(listener: () => void): () => void;
+    canApply(): boolean;
+    /** Commit the draft and close. Returns false after cancellation. */
+    apply(): boolean;
+    /** Close without committing the draft. */
+    cancel(): void;
+}
+/** Host rendering for the Track changes options dialog. @public */
+interface RevisionMarkupChromeHandlers {
+    readonly onRequest?: (session: RevisionMarkupDialogSession) => void;
 }
 
 /**
- * `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.
+ * What a revision wrapper asserts about the content inside it.
+ *
+ * `moveFrom` / `moveTo` are deliberately distinct from `delete` / `insert`: a move is one
+ * decision with two halves, and presenting it as an unrelated deletion and insertion invites
+ * resolving one without the other, which duplicates or loses the content.
  */
-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';
+type RevisionKind = 'insert' | 'delete' | 'moveFrom' | 'moveTo' | 'format';
 /**
- * `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.
+ * One revision wrapper's provenance, as 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.
+ * `id` is the verbatim `@w:id` string rather than a number: `ST_DecimalNumber` restricts
+ * `xsd:integer` with no bounds, so a file may carry a value outside the safe integer range, and
+ * parsing it to a number would silently merge two distinct revisions.
+ *
+ * `date` is absent when the file omits it. `@w:date` is optional on `CT_TrackChange`, and
+ * inventing one is a silent content change.
  */
-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;
-    };
+interface RevisionAttribution {
+    readonly kind: RevisionKind;
+    readonly id: string;
+    readonly author: string;
+    readonly date?: string;
+    /** The wrapper's node id, so a surface can address this exact site. */
+    readonly nodeId: string;
 }
-
 /**
- * One `w:numPicBullet`: the image a level draws instead of its `w:lvlText`.
+ * Which revisions layout resolves before producing pages.
  *
- * `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
+ * - `all-markup` shows both halves of every change.
+ * - `proposed` shows what the document becomes if every change is accepted.
+ * - `original` shows what it was before any of them.
+ *
+ * The last two are specified as equal to accept-all and reject-all OUTPUT, which is what makes
+ * them testable, without either applying an op.
  */
-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;
-}
+type RevisionDisplayMode = 'all-markup' | 'proposed' | 'original';
 /**
- * A level's picture bullet with the size it is actually DRAWN at.
+ * The views the review chrome offers, in Word's terms: the three layout projections plus
+ * Simple Markup, which reads as the proposed result with a red change bar beside every line
+ * a change touched — the document as accepting everything would leave it, and where.
+ */
+type ReviewDisplayMode = RevisionDisplayMode | 'simple-markup';
+/**
+ * How a document renders tracked changes when nothing says otherwise.
  *
- * 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
+ * `all-markup` matches Word's own default: a reader who opens a document with pending changes
+ * sees them, rather than a clean-looking document hiding edits nobody has accepted.
  */
-interface ResolvedPictureBullet {
-    /** `v:imagedata/@r:id`, relative to the NUMBERING part's relationships. */
-    readonly relationshipId: string;
-    /** Painted width in points, after the marker font scale. */
-    readonly width: number;
-    /** Painted height in points, after the marker font scale. */
-    readonly height: number;
-    /** The `v:shape` extent exactly as the file authored it. */
-    readonly authored: NumberingPictureBullet;
-}
-
-/** Soft ceiling on abstractNum / num entries read from one part. */
-declare const MAX_NUMBERING_DEFINITIONS = 512;
-/** Soft ceiling on override entries per `w:num`. */
-declare const MAX_LVL_OVERRIDES = 9;
-/** `w:suff` — what separates a list marker from the text after it. */
-type ListSuffix = 'tab' | 'space' | 'nothing';
-/** `w:lvlJc` — how a list marker aligns within its own indent. */
-type ListMarkerAlign = 'left' | 'center' | 'right';
+declare const DEFAULT_REVISION_DISPLAY_MODE: RevisionDisplayMode;
 /**
- * One level's indent, plus which parts the level actually AUTHORED.
+ * A view-time tracked-change filter. Revisions rejected by `includes` use the filter's accepted
+ * or rejected projection, while included revisions keep the display mode's normal projection.
  *
- * The provenance matters: `w:ind` cascades per-attribute, so a level that authored only `left`
- * must not overwrite an inherited `hanging` with a synthesized zero.
+ * `cacheKey` is a canonical, content-based identity for layout caches. The set itself is kept
+ * because author names are attacker-controlled strings and must never be parsed back from a
+ * delimiter-based key.
  */
-interface NumberingLevelIndent {
-    /**
-     * The sides as the level spells them, in points. `left` and `start` both name the leading
-     * indent, and `right` and `end` the trailing one; `left`/`right` below hold those two.
-     */
-    readonly authored?: {
-        readonly left?: number;
-        readonly right?: number;
-        readonly start?: number;
-        readonly end?: number;
-    };
-    readonly left: number;
-    readonly right: number;
-    readonly hanging: number;
-    readonly firstLine: number;
+interface RevisionFilter {
+    readonly revisionMarkup?: ResolvedRevisionMarkup;
+    readonly hiddenAuthors: ReadonlySet<string>;
+    readonly includes?: (revision: RevisionAttribution) => boolean;
+    readonly includesNode?: (nodeId: string, author: string) => boolean;
+    /** Accepted/original projection for a revision excluded by `includesNode`. */
+    readonly excludedNodeMode?: (nodeId: string, author: string) => 'proposed' | 'original';
     /**
-     * Which of these the LEVEL actually authored.
-     *
-     * A level's `w:pPr/w:ind` sits between the formatting it outranks and the formatting that
-     * outranks it (`mergeListIndent`), so the merge has to tell "the level says left = 0" from
-     * "the level says nothing about left and the style's value stands". Absent (the default) reads as "says nothing", which is what a
-     * hand-built level in a test means.
+     * In a resolved view, content the view keeps paints as ORDINARY text: no author ink, no
+     * decoration, no change bar of its own. This is Word's No Markup, Original and Simple
+     * Markup, which the review chrome asks for. Without it the accepted projection keeps the
+     * attribution on kept insertions, which is what the engine paints when no review module
+     * is registered — colour by author, deletions resolved — and what its roster reads.
      */
-    readonly stated?: {
-        readonly left: boolean;
-        readonly right: boolean;
-        /** `w:hanging`/`w:firstLine` are one mutually exclusive slot (§17.3.1.10, §17.3.1.12). */
-        readonly firstLineOffset: boolean;
-    };
+    readonly resolvedMarkup?: 'plain';
+    readonly cacheKey: string;
 }
-/** One `w:lvl`: how this depth numbers, what its marker looks like, and how it indents. */
-interface NumberingLevel {
-    readonly ilvl: number;
-    readonly start: number;
-    readonly numFmt: string;
-    readonly lvlText: string;
-    readonly lvlJc: ListMarkerAlign;
-    readonly suff: ListSuffix;
-    readonly indent: NumberingLevelIndent;
-    /**
-     * `w:lvlRestart` one-based trigger level, or `0` when the level never restarts.
-     * Omitted in XML → restart when the previous level (or any earlier level) is used.
-     */
-    readonly lvlRestart?: number;
-    /**
-     * `w:isLgl` (§17.9.9): render EVERY level referenced by this level's `w:lvlText` in
-     * decimal, whatever number format those levels declare for themselves.
-     */
-    readonly isLgl: boolean;
-    /**
-     * `w:lvlPicBulletId` (§17.9.12): this level's marker is the `w:numPicBullet` of that id,
-     * drawn INSTEAD of `w:lvlText`. Absent on every ordinary level.
-     */
-    readonly picBulletId?: string;
-    /** Level `w:rPr` as flat properties (for marker face / vanish). */
-    readonly runProperties: readonly OoxmlProperty[];
-    /** True when level run props request vanish — marker must not paint. */
-    readonly vanish: boolean;
+/** @deprecated Use {@link RevisionFilter}. */
+interface RevisionAuthorFilter extends RevisionFilter {
 }
+/** Build a canonical reviewer filter. An empty input returns `undefined` for the fast path. */
+declare function revisionAuthorFilter(hiddenAuthors: Iterable<string>): RevisionAuthorFilter | undefined;
 /**
- * One `w:lvlOverride` on a `w:num`: a restart value, a replacement level, or both.
+ * Whether content under this stack of revisions is laid out in the given mode.
  *
- * How two lists share an abstract definition while numbering independently.
+ * Containment governs, so a single enclosing wrapper the mode resolves away suppresses
+ * everything inside it regardless of what the inner wrappers say. An insertion inside a
+ * deletion does not survive the proposed result: the deletion it sits in was accepted.
  */
-interface LevelOverride {
-    readonly startOverride?: number;
-    /** Full level replacement when `w:lvl` is present under the override. */
-    readonly level?: NumberingLevel;
-}
+declare function revisionsVisible(revisions: readonly RevisionAttribution[], mode: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): boolean;
 /**
- * One `w:abstractNum` — the shape of a list, without being a list.
+ * Every revision on a paragraph's own MARK, from `w:pPr/w:rPr/w:ins|w:del|w:moveFrom|w:moveTo`.
  *
- * Never referenced by a paragraph directly. Paragraphs name a {@link NumDefinition}, which names
- * one of these, so several lists can share a definition and still count separately.
+ * All four members of `EG_ParaRPrTrackChanges`. A moved paragraph carries `w:moveFrom` on the
+ * mark of the copy it left and `w:moveTo` on the mark of the copy it arrived at, so a move
+ * that spans whole paragraphs is recorded here and nowhere else.
+ *
+ * `EG_ParaRPrTrackChanges` records that the pilcrow itself was inserted or deleted, which is how
+ * Word writes a paragraph split or merge. It is not content — there is no text to decorate — so
+ * a surface shows it as a mark of its own beside the paragraph, the way Word draws a struck-
+ * through ¶.
+ *
+ * A LIST, because the group is `ins? del? moveFrom? moveTo?` and the first two can both be
+ * there: that pair is what Word writes when a second author proposes removing a mark the first
+ * proposed adding, and it is what this engine's own writer emits (`tree-op-tracked.ts`).
+ * Answering with the first one hid the second author's decision from the PAGE. The review pane
+ * walks the tree itself and always listed both, which is the worse shape of the two: a card
+ * offering a decision the reader could see no sign of.
+ *
+ * Ordered as the file orders them, which is the order the group declares.
+ *
+ * Property-position `w:ins`/`w:del` stay `generic` in the tree deliberately, so this reads them
+ * by name rather than by kind.
  */
-interface AbstractNumDefinition {
-    readonly abstractNumId: string;
-    readonly levels: ReadonlyMap<number, NumberingLevel>;
-    /**
-     * `w:numStyleLink` (§17.9.21): this definition carries no levels of its own — the numbering
-     * lives on the named style. Word follows the link; resolve it with
-     * {@link resolveNumberingStyleLinks} before reading levels, or every paragraph on this
-     * abstract renders with NO marker at all.
-     */
-    readonly numStyleLink?: string;
-    /**
-     * `w:styleLink` (§17.9.23): the definition side of the same pair — this abstract IS the
-     * numbering of the named style. Kept so a link can be verified rather than assumed.
-     */
-    readonly styleLink?: string;
-}
+declare function paragraphMarkRevisionsOf(paragraph: OoxmlNode): readonly RevisionAttribution[];
 /**
- * One `w:num` — the thing a paragraph's `w:numId` actually names.
+ * The tracked FORMAT change on a paragraph's own mark, from `w:pPr/w:rPr/w:rPrChange`.
  *
- * Points at an {@link AbstractNumDefinition} and may override any of its levels.
+ * `CT_ParaRPr` ends with it (§17.13.5.32), and Word writes it when a user changes the mark's
+ * own run properties with tracking on. It reaches the fragment rather than a span because it
+ * decorates no characters, and it is not in `props`: a fragment's `props` carry the mark's
+ * `w:rPr` by NAME only, with none of its children.
+ *
+ * Note that `w:rPrChange/w:rPr` is `CT_ParaRPrOriginal`, which may carry its own revision
+ * marks. Those describe the mark as it WAS and must not be read as live ones, which is why
+ * this reads the change element's own attributes and never descends into it.
  */
-interface NumDefinition {
-    readonly numId: string;
-    readonly abstractNumId: string;
-    readonly overrides: ReadonlyMap<number, LevelOverride>;
-}
+declare function paragraphMarkFormatRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
 /**
- * The bounded projection of `numbering.xml` that list layout resolves against.
+ * The single decision a one-field reader sees.
  *
- * Projection ONLY — never a mutation or serialization authority. Hostile values are dropped or
- * clamped, and a missing definition resolves to "no list" rather than a guess.
+ * A DELETION wins when a mark carries both, for the reason paint draws it that way: a break
+ * proposed and then unproposed ends up removed, so that is the decision a reader who can only
+ * see one must see. One function decides it, so the deprecated field, the deprecated function
+ * and the painted glyph cannot answer differently.
  */
-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>;
-}
+declare function shownMarkRevision(revisions: readonly RevisionAttribution[]): RevisionAttribution | undefined;
 /**
- * Build a numbering index from the root of a numbering part (`w:numbering`).
+ * Does this decision, taken, remove the paragraph mark?
  *
- * Empty / missing roots yield an empty index. Duplicate ids keep the first definition.
+ * A deletion does, and so does a `moveFrom`: the copy the paragraph moved OUT of goes away
+ * when the move is accepted. `insert` and `moveTo` are the other half of each pair, and they
+ * keep the break. Paint, the change bar and the resolved views all ask this one question, so
+ * a `moveFrom` cannot end up struck through in the margin and blue on the glyph.
  */
+declare function markRevisionRemovesMark(revision: RevisionAttribution): boolean;
 /**
- * Project `numbering.xml` into the bounded index.
+ * The one decision on a paragraph's mark that a single-field reader sees.
  *
- * Every ceiling here exists because the input is file-derived: definition counts, override
- * counts, indent magnitudes and style-link hop depth are all capped, and nothing from the file
- * becomes a loop bound or an allocation size.
+ * @deprecated Reads one of the revisions a mark can carry. Use {@link paragraphMarkRevisionsOf},
+ * which answers with all of them.
  */
-declare function buildNumberingIndex(root: OoxmlElement | null | undefined): NumberingIndex;
-/** Resolve the effective level for a `numId` + `ilvl`, applying overrides. */
+declare function paragraphMarkRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
 /**
- * The effective level for one paragraph's numbering reference, after overrides and style links.
+ * The tracked FORMAT change on a property list, from `w:rPrChange` or `w:pPrChange`.
  *
- * Answers null for a reference the index cannot resolve — a paragraph naming a definition the
- * file never declared is an unnumbered paragraph, not an error.
+ * A property change alters no characters, so it has no span of its own to strike or underline.
+ * Word marks the affected text and says what changed; the minimum a reader needs is to see that
+ * this text's formatting is itself a pending decision.
+ *
+ * Read from the flattened property list because that is what layout already carries — the
+ * change wrapper is a `w:rPr`/`w:pPr` child like any other.
  */
-declare function resolveNumberingLevel(index: NumberingIndex, numId: string, ilvl: number): {
-    readonly abstractNumId: string;
-    readonly level: NumberingLevel;
-    readonly startOverride?: number;
-} | null;
-/** Empty index for tests / documents without numbering. */
-declare const EMPTY_NUMBERING_INDEX: NumberingIndex;
+declare function formatRevisionOf(properties: readonly {
+    readonly localName: string;
+    readonly attributes?: Readonly<Record<string, string>>;
+}[]): RevisionAttribution | null;
+/** True when this stack of revisions marks its content as deleted from the live document. */
+declare function revisionsAreDeletion(revisions: readonly RevisionAttribution[]): boolean;
+
+/** 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;
+}
 
 /**
- * A face, as something asks for it: family plus the two axes this engine admits.
+ * Whether a paragraph must start a new page (`w:pageBreakBefore`).
  *
- * 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.
+ * 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.
  */
-interface FontRequest {
-    readonly family: string;
-    readonly weight: number;
-    readonly style: 'normal' | 'italic';
-}
+declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
 /**
- * A request that was answered by a DIFFERENT face than the one asked for.
+ * 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.
  *
- * 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.
+ * 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 FontSubstitution {
-    readonly requested: FontRequest;
-    readonly resolved: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
+interface ParagraphSpacing {
+    /** `w:spacing/@before`, in points. */
+    readonly before: number;
+    /** `w:spacing/@after`, in points. */
+    readonly after: number;
 }
-declare const RESOLVED_FONT_BRAND: unique symbol;
 /**
- * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
- * a font.
+ * 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).
  *
- * 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.
+ * The attribute means "the consumer decides", and the authored `@before` / `@after` beside it
+ * is IGNORED rather than used as the value. Word's answer is HTML's default `<p>` margin,
+ * 14pt, which is what a document round-tripped through Word's HTML filter carries — and this
+ * one is everywhere, because Word writes `w:before="100" w:beforeAutospacing="1"` for it. Reading
+ * only the literal 100 twips lays every such paragraph out 9pt tight, which moves page breaks.
  */
-interface ResolvedFont {
-    readonly [RESOLVED_FONT_BRAND]: true;
-    readonly id: string;
-    readonly identity: string;
-    readonly request: FontRequest;
-    readonly family: string;
-    /** Owned byte length, available without creating a defensive byte copy. */
-    readonly byteLength: number;
-    readonly bytes: Uint8Array;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly substitution: FontSubstitution | null;
-}
+declare const AUTO_PARAGRAPH_SPACING_PT = 14;
 /**
- * Largest single face this engine will ever admit, whatever a caller configures.
+ * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
+ * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
  *
- * 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.
+ * 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.
  *
- * `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.
+ * 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/`.
  */
-type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
+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;
+}
 /**
- * A face that could not be admitted, carrying whatever evidence the refusal produced.
+ * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
  *
- * 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.
+ * `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.
  */
-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;
-    });
-}
+type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
 /**
- * One face offered to a snapshot, before admission.
+ * Resolved line spacing: the rule, and the value it applies.
  *
- * `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".
+ * `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 FontResourceDefinition {
-    readonly request: FontRequest;
-    readonly id: string;
-    readonly bytes: Uint8Array;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly availability?: 'available' | 'forbidden';
+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;
 /**
- * A host-declared redirect: requests for `from` resolve to `to`.
+ * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
  *
- * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
- * without the document being rewritten.
+ * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
+ * unbounded border width becomes a layout dimension.
  */
-interface DeclaredFontSubstitution {
-    readonly from: FontRequest;
-    readonly to: FontRequest;
-    readonly lineMetrics?: {
-        readonly heightEm: number;
-        readonly baselineEm: number;
-    };
+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;
 }
-/** 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 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'];
 /**
- * The injected check that bytes really are a font.
+ * Which of the six `CT_PBdr` edges.
  *
- * 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.
+ * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
+ * consecutive paragraphs share a border definition.
  */
-type FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;
+type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
 /**
- * An immutable set of admitted faces, and the only way to reach one.
+ * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
  *
- * `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.
+ * `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 FontResourceSnapshot {
-    readonly epoch: number;
-    /** The admitted face, or a typed refusal. Never throws. */
-    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
+interface ParagraphBorders {
+    readonly top?: ParagraphBorderEdge;
+    readonly left?: ParagraphBorderEdge;
+    readonly bottom?: ParagraphBorderEdge;
+    readonly right?: ParagraphBorderEdge;
+    readonly between?: ParagraphBorderEdge;
+    readonly bar?: ParagraphBorderEdge;
 }
 /**
- * How a snapshot is built: which faces, under what limits, validated how.
+ * Resolve `w:spacing` before/after from flat paragraph properties.
  *
- * `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.
+ * 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.
  *
- * 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.
+ * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
+ * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
  */
-interface FontResourceInstrumentation {
-    readonly onOwnedByteCopy?: () => void;
-    readonly onHash?: () => void;
-    readonly onTableScan?: () => void;
-    readonly onAdmission?: () => void;
-}
+declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
 /**
- * The canonical string identifying one face request.
+ * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
  *
- * Case- and whitespace-normalized, so `"Times New Roman"` and `"times new roman"` are one key —
- * a document may name a family either way and both must reach the same face.
+ * Merged per attribute for the same reason as before/after: `w:spacing` is one element
+ * carrying independent attributes, and a style that states only `@line` must not reset the
+ * rule an earlier entry in the cascade set.
  */
-declare const fontRequestKey: (request: FontRequest) => string;
-/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
-declare const boundedStructuralFontValidator: FontByteValidator;
+declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
 /**
- * Admit a set of faces and return the immutable snapshot layout resolves against.
+ * Apply resolved line spacing to a line's natural (glyph-derived) box.
  *
- * Admission is the trust boundary for font bytes: counts and sizes are checked against the hard
- * ceilings, each face's hash is re-derived and compared, and the bytes are handed to the injected
- * validator. A face failing any of these is recorded as a typed refusal rather than dropped, so
- * `resolve` can explain itself instead of answering "missing".
- */
-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;
-};
+ * `auto` places its extra BELOW the line — the last line's multiple spacing still separates
+ * it from the next paragraph. Putting that delta above inverted cover-page rhythm:
+ * `w:line="460"` on "between" opened a large gap above the word and almost none before
+ * "MERIDIAN".
+ *
+ * `atLeast` does the OPPOSITE: the box grows upward and the glyphs sit on its floor. A
+ * captured control settles it — Times New Roman 12 pt at `w:line="360" w:lineRule="atLeast"`
+ * puts the reference's baseline at 15.36 pt, which is `18 - descent` snapped to the device
+ * grid, where treating it like `auto` leaves the baseline at 11.28 and the text 4.08 pt too
+ * high. `w:line="240" atLeast` is below the natural line, falls through to the natural
+ * height, and is unaffected. See `.cache/pdf/claude-linerule/`.
+ *
+ * Exact-height boxes place their baseline at 80% of the height; the legacy
+ * noExtraLineSpacing switch instead preserves the face baseline within the box.
+ *
+ * An `auto` or `atLeast` line of a snapping paragraph under an active line grid takes whole
+ * pitches instead ({@link gridLineBox}); `trailing` then names the box below the glyphs.
+ */
+declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
+    height: number;
+    baseline: number;
+    trailing?: number;
+};
 /**
- * Brand a safe integer as a {@link FixedPoint} coordinate.
+ * `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.
  *
- * 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.
+ * 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.
  *
- * @throws RangeError when the value is not a safe integer.
+ * 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 const fixedPoint: (value: number) => FixedPoint;
-/** Which way a run reads. The parity projection of its bidi embedding level. */
-type TextDirection = 'ltr' | 'rtl';
-/** How fixed-point conversion breaks ties. Part of the shaping fingerprint. */
-type FixedPointRoundingMode = 'halfAwayFromZero' | 'halfToEven' | 'towardZero';
-/** Which Unicode normalization is applied before shaping, if any. */
-type NormalizationPolicy = 'none' | 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
+declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
 /**
- * The shaping library and its exact version.
+ * Visual stroke thickness layout publishes for one edge (points).
  *
- * 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.
+ * Compound `ST_Border` values (`double`, …) use the shared inflated band so a thin
+ * `w:sz="3"` double still occupies a visible double-line box — matching table borders.
  */
-interface VersionedShapingLibrary {
-    readonly name: string;
-    readonly version: string;
-}
+declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
 /**
- * Everything that determines how text shapes — the complete input to a
- * {@link ShapingEnvironment}.
+ * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
  *
- * 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.
+ * Vertically that is flow height — a top rule pushes the first line down, a bottom rule holds
+ * the page open below the last one — so pagination has to see it. Horizontally it is
+ * publish-only: Word draws left/right paragraph rules OUTSIDE the text column and never
+ * re-breaks the lines, which is why adding a box to a paragraph in Word does not reflow it.
  */
-interface ShapingEnvironmentInput {
-    readonly font: ResolvedFont;
-    readonly variationAxes: Readonly<Record<string, number>>;
-    readonly shapingLibrary: VersionedShapingLibrary;
-    readonly unicodeDataVersion: string;
-    readonly normalization: NormalizationPolicy;
-    readonly script: string;
-    readonly language: string;
-    readonly direction: TextDirection;
-    readonly features: Readonly<Record<string, number>>;
-    readonly fallbackOrder: readonly ResolvedFont[];
-    readonly fixedPointScale: number;
-    readonly roundingMode: FixedPointRoundingMode;
-}
+declare function paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+/** Vertical extent a bottom border adds below the last line (gap + rule). */
+declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
 /**
- * A validated {@link ShapingEnvironmentInput} — build one with `createShapingEnvironment`.
+ * Identity of a paragraph's border set, for the `w:between` group rule.
  *
- * 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.
+ * Word treats consecutive paragraphs whose border settings are IDENTICAL as ONE bordered
+ * block: the top rule draws above the first, the bottom rule below the last, and each
+ * interior boundary gets `w:between` or nothing (§17.3.1.24). That is why applying a box to
+ * three selected paragraphs in Word draws one box and not three.
+ *
+ * Empty string means "no borders", which never groups with anything.
  */
-interface ShapingEnvironment extends ShapingEnvironmentInput {
+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;
+
+/**
+ * The four physical sides of `CT_PageBorders`.
+ *
+ * Four, not the six of `w:pBdr`: `w:between` and `w:bar` are paragraph-group rules and the
+ * page has no analogue for either.
+ */
+declare const PAGE_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right'];
+/** Which of the four page-frame edges. */
+type PageBorderSide = (typeof PAGE_BORDER_SIDES)[number];
+/**
+ * `w:offsetFrom` (`ST_PgBorderOffset`) — what `w:space` on each edge is measured from.
+ *
+ * The schema default is `text`, NOT `page`. Word's own UI opens on "Edge of page", which is
+ * why the wrong default is easy to assume and expensive to hold: at `text` the rule sits
+ * `w:space` points outside the TEXT, so its distance from the sheet edge is the margin minus
+ * the space — a number that moves whenever the margins do.
+ */
+type PageBorderOffsetFrom = 'page' | 'text';
+/** `w:display` (`ST_PgBorderDisplay`) — which pages of the section carry the frame. */
+type PageBorderDisplay = 'allPages' | 'firstPage' | 'notFirstPage';
+/** `w:zOrder` (`ST_PgBorderZOrder`) — whether the frame paints over the text or under it. */
+type PageBorderZOrder = 'front' | 'back';
+/**
+ * One section's resolved `w:pgBorders`.
+ *
+ * Resolved, not raw: every attribute the file omitted is filled in with the SCHEMA default,
+ * so a consumer never has to know which of the three were authored. An edge is present only
+ * when it paints — `nil` / `none` and art borders are already gone (see {@link parsePageBorders}).
+ */
+interface SectionPageBorders {
+    /** `w:offsetFrom`; absent attribute reads as `text` (§17.6.10). */
+    readonly offsetFrom: PageBorderOffsetFrom;
+    /** `w:display`; absent attribute reads as `allPages`. */
+    readonly display: PageBorderDisplay;
+    /** `w:zOrder`; absent attribute reads as `front`. */
+    readonly zOrder: PageBorderZOrder;
+    readonly top?: ParagraphBorderEdge;
+    readonly left?: ParagraphBorderEdge;
+    readonly bottom?: ParagraphBorderEdge;
+    readonly right?: ParagraphBorderEdge;
 }
-/** 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;
+/**
+ * Parse `w:pgBorders` off one `w:sectPr`.
+ *
+ * Undefined when the element is absent AND when it paints nothing — every edge off, or every
+ * edge an art border. Unlike `w:pgNumType`, an empty-but-present element is not distinguished:
+ * these properties are a LAYOUT input, serialization re-emits the canonical tree, and a frame
+ * with no edges has exactly one meaning downstream.
+ */
+declare function parsePageBorders(sectPr: OoxmlNode): SectionPageBorders | undefined;
+/**
+ * Identity of one section's page frame, for incremental-layout context keys.
+ *
+ * A `w:pgBorders` edit changes nothing the flow measures — the frame is drawn beside the text,
+ * never through it — so no per-paragraph key moves and every reuse path would hand back the
+ * previous sheets with the previous frame. This token goes in the pass context so it does not.
+ */
+declare function pageBordersFingerprint(borders: SectionPageBorders | undefined): string;
+
+/**
+ * Hard ceiling on sections enumerated from a document (matches write-path
+ * `MAX_SECTIONS` in note/hf lifecycle). Hostile packages with unbounded `w:sectPr`
+ * marks fail closed here rather than amplifying layout props arrays.
+ */
+declare const MAX_DOCUMENT_SECTIONS = 4096;
+/** A section's margins in twips, including the header and footer reserve bands. */
+interface SectionMargins {
+    readonly topTwips: number;
+    readonly rightTwips: number;
+    readonly bottomTwips: number;
+    readonly leftTwips: number;
+    readonly headerTwips: number;
+    readonly footerTwips: number;
+    readonly gutterTwips: number;
+}
+/** One explicit `w:col`: its width and the gap after it. */
+interface SectionColumnDefinition {
+    readonly widthTwips: number;
+    /** Space after this column; zero on the final column. */
+    readonly gapTwips: number;
+}
+/**
+ * A section's column layout.
+ *
+ * Equal-width and explicit-width columns are one type because a file may declare `w:num` with no
+ * `w:col` children at all, and layout must handle both without branching at every use site.
+ */
+interface SectionColumns {
+    readonly count: number;
+    /** Shared gap for equal-width columns and fallback gap for incomplete explicit definitions. */
+    readonly gapTwips: number;
+    readonly equalWidth?: boolean;
+    readonly separator?: boolean;
+    /** Authored `w:col` geometry when `equalWidth` is false. */
+    readonly definitions?: readonly SectionColumnDefinition[];
+}
+/**
+ * How this section is placed relative to the previous one (ECMA-376 17.6.22,
+ * `ST_SectionMark`).
+ *
+ * All five schema values are read. `nextColumn` paginates like `nextPage` for now: in a
+ * single-column section that IS Word's behaviour, and multi-column flow is not modelled,
+ * so collapsing it at the parse boundary would only hide the authored value from a
+ * consumer that asks.
+ */
+type SectionBreakType = 'nextPage' | 'continuous' | 'evenPage' | 'oddPage' | 'nextColumn';
+/**
+ * Authored `w:pgNumType` (ECMA-376 CT_PageNumber).
+ *
+ * Distinguishes three states via {@link SectionProperties.pageNumbering}:
+ * - element absent → `undefined` (Word defaults; no empty element to re-emit)
+ * - empty `<w:pgNumType/>` → `{}` (present, no authored attrs; must round-trip empty)
+ * - attributes set → only those keys appear (never invent schema defaults like `fmt=decimal`)
+ *
+ * `chapStyle` / `chapSep` are preserved for consumers; PAGE projection does not yet compose
+ * chapter numbers (heading outline resolution is out of this slice).
+ */
+interface SectionPageNumbering {
+    /** Authored `@w:start` when present and in range; otherwise omitted. */
+    readonly start?: number;
+    /** Authored `@w:fmt` (ST_NumberFormat) when present; otherwise omitted. */
+    readonly fmt?: string;
+    /** Authored `@w:chapStyle` outline level when present and in range. */
+    readonly chapStyle?: number;
+    /** Authored `@w:chapSep` when present (hyphen / period / colon / emDash / enDash). */
+    readonly chapSep?: string;
+}
+/**
+ * One section's resolved `w:sectPr`, as layout needs it.
+ *
+ * Resolved, not raw: defaults the file omitted are filled in here (an absent `w:type` is
+ * `nextPage`), so layout never has to know which attributes were authored and which were
+ * inherited.
+ */
+interface SectionProperties {
+    /** Active document grid line pitch: line-unit paragraph margins and line snapping. */
+    readonly gridLinePitchTwips?: number;
+    readonly pageSize: {
+        readonly widthTwips: number;
+        readonly heightTwips: number;
+    };
+    readonly margins: SectionMargins;
+    readonly columns: SectionColumns;
+    readonly landscape: boolean;
+    readonly titlePage: boolean;
+    /** Absent `w:type` defaults to `nextPage`. */
+    readonly breakType: SectionBreakType;
     /**
-     * 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.
+     * Authored page-number type. Absent when `w:pgNumType` is missing; empty object when the
+     * element is present with no attributes (comprehensive-fixture shape).
      */
-    readonly context?: ShapingContext;
-}
-/** Pre- and post-context for one shaping call. See {@link ShapeInput.context}. @public */
-interface ShapingContext {
-    readonly before: string;
-    readonly after: string;
+    readonly pageNumbering?: SectionPageNumbering;
+    /**
+     * Resolved `w:pgBorders` (§17.6.10). Absent when the section declares none, or when every
+     * edge it declares is off or an art border — see {@link parsePageBorders}.
+     */
+    readonly pageBorders?: SectionPageBorders;
 }
-/** Longest context on either side, in UTF-16 units. Joining needs only the nearest letters. @public */
-declare const MAX_SHAPING_CONTEXT = 16;
 /**
- * One positioned glyph.
+ * One section of the body story: contiguous top-level blocks plus the properties that end it.
  *
- * `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.
+ * `blockStart` / `blockEndExclusive` index into `storyBlocks(part)`.
  */
-interface ShapedGlyph {
-    readonly id: number;
-    /** Optional synthetic glyph-size factor; positions and advances already include it. */
-    readonly drawScale?: number;
-    /** UTF-16 text offset identifying the cluster that produced this glyph. */
-    readonly cluster: number;
-    /** Pen origin before this glyph's shaping offsets, in fixed-point run coordinates. */
-    readonly originX: FixedPoint;
-    readonly originY: FixedPoint;
-    readonly advanceX: FixedPoint;
-    readonly advanceY: FixedPoint;
-    readonly offsetX: FixedPoint;
-    readonly offsetY: FixedPoint;
-    /** Exact monochrome outline returned by the admitted HarfBuzz face. */
-    readonly outline: GlyphOutline;
+interface DocumentSection {
+    readonly index: number;
+    readonly properties: SectionProperties;
+    readonly blockStart: number;
+    readonly blockEndExclusive: number;
 }
-/** A glyph's outline as SVG path data, in font design units. */
-interface GlyphOutline {
-    readonly path: string;
-    /** Design units per em — divide by this to scale the path to a point size. */
-    readonly unitsPerEm: number;
+/** US Letter, portrait, one-inch margins: Word's own default when a section says nothing. */
+declare const DEFAULT_SECTION_PROPERTIES: SectionProperties;
+/**
+ * Parse authored `w:pgNumType` without inventing schema defaults.
+ *
+ * Returns `undefined` when the element is absent. An empty element yields `{}` so callers
+ * can tell "present but unauthored" from "missing" and serialization can re-emit empty.
+ * Hostile / out-of-range attribute values are dropped rather than clamped into meaning.
+ */
+declare function parsePageNumbering(sectPr: OoxmlNode): SectionPageNumbering | undefined;
+/** Parse one `w:sectPr` into geometry/break properties (null reads as Word's defaults). */
+declare function parseSectionProperties(sectPr: OoxmlNode | null | undefined): SectionProperties;
+/** `w:sectPr` nested under a paragraph's `w:pPr`, if present. */
+declare function paragraphSectionNode(paragraph: OoxmlElement): OoxmlElement | undefined;
+/**
+ * The section properties a part declares, or Word's defaults where it says nothing.
+ *
+ * Returns the FINAL section (body-level `w:sectPr`, else the last paragraph-level one).
+ * Multi-section geometry belongs to `enumerateDocumentSections`; chrome that needs "the
+ * document's page" still reads the last section, which is what Word's body-level sectPr is.
+ */
+declare function readSectionProperties(part: OoxmlPart): SectionProperties;
+/**
+ * Split the body story into sections.
+ *
+ * A paragraph carrying `w:pPr/w:sectPr` ends the current section (that paragraph is IN the
+ * section being ended). The body-level `w:sectPr` ends the final section. A document with
+ * neither yields one section of Word defaults covering every block.
+ *
+ * Enumeration is capped at {@link MAX_DOCUMENT_SECTIONS}. Further paragraph-level section
+ * breaks are ignored and remaining blocks fold into the last accepted section (fail closed).
+ *
+ * `displayMode` MUST match the one the caller passes to `storyBlocks`. `blockStart` /
+ * `blockEndExclusive` are indices into that list, and the list changes shape with the mode:
+ * the proposed view drops a paragraph whose mark and content a revision both removed. Slicing
+ * a filtered list with indices counted over an unfiltered one puts body text under another
+ * section's page geometry — the wrong paper size, the wrong margins, the wrong header.
+ */
+declare function enumerateDocumentSections(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): DocumentSection[];
+/**
+ * Canonical section index behind each section in a revision-projected body.
+ *
+ * A removed paragraph mark can collapse an entire section. The projected section keeps the
+ * surviving paragraph's geometry, while package APIs such as header/footer resolution remain
+ * indexed over the canonical tree. This bridge prevents those two index spaces from being
+ * paired positionally.
+ */
+declare function projectedSectionSourceIndexes(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): readonly number[];
+/**
+ * Every section in a document, with a flag saying whether the list was cut short.
+ *
+ * `truncated` is reported rather than silent: section count comes from a file, so a crafted
+ * document declaring thousands of paragraph-level `w:sectPr` marks is bounded, and a reader
+ * should be able to tell that happened.
+ */
+interface DocumentSectionsEnumeration {
+    readonly sections: DocumentSection[];
+    /** True when paragraph-level sectPr marks beyond {@link MAX_DOCUMENT_SECTIONS} were dropped. */
+    readonly truncated: boolean;
 }
 /**
- * One cluster: the smallest indivisible text-to-glyph correspondence.
+ * Like {@link enumerateDocumentSections}, but reports whether the section bound clipped
+ * hostile input. Prefer the plain enumerator for normal layout; use this when a caller
+ * needs a named fail-closed diagnostic.
+ */
+declare function enumerateDocumentSectionsBounded(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): DocumentSectionsEnumeration;
+/**
+ * Section properties as the geometry layout paginates against.
  *
- * The unit the CARET moves by. A cluster may be several characters (a ligature) or several glyphs
- * (a decomposed mark), so neither a character index nor a glyph index is a valid caret position —
- * `caretEdges` is, and it includes both endpoints.
+ * The gutter is added to the LEFT margin: it is binding allowance, extra space on the inner
+ * edge, and folding it into the content width instead would silently narrow every line.
+ *
+ * Top and bottom keep the authored sign of `w:pgMar`: a negative value is an exact inset that
+ * header and footer height never moves. Read them through `page-body-margins.ts`.
  */
-interface ShapedCluster {
-    /** Half-open logical UTF-16 range in ShapedRun.text. */
-    readonly textStart: number;
-    readonly textEnd: number;
-    /** Half-open visual glyph range in ShapedRun.glyphs. */
-    readonly glyphStart: number;
-    readonly glyphEnd: number;
-    readonly advance: FixedPoint;
-    /** Fixed-point edges from this cluster's visual origin, including both endpoints. */
-    readonly caretEdges: readonly FixedPoint[];
-    /** Index into ShapedRun.fontSpans, preserving the exact fallback choice. */
-    readonly fontSpan: number;
+declare function geometryOfSection(section: SectionProperties): PageGeometry;
+
+/**
+ * `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;
+    };
 }
-/** A run's vertical metrics, from the face that shaped it. Drives line height and baseline. */
-interface ShapedVerticalMetrics {
-    readonly ascent: FixedPoint;
-    readonly descent: FixedPoint;
-    readonly lineGap: FixedPoint;
+
+/**
+ * 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 stretch of glyphs that came from ONE face.
+ * A level's picture bullet with the size it is actually DRAWN at.
  *
- * A run whose text needed fallback has several of these. Recording the exact face per span is
- * what lets a re-shape reproduce the same result rather than re-running fallback selection and
- * possibly choosing differently.
+ * 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 ShapedFontSpan {
-    readonly glyphStart: number;
-    readonly glyphEnd: number;
-    readonly font: ResolvedFont;
-    /** null denotes the primary font; otherwise this is the environment fallback-order index. */
-    readonly fallbackIndex: number | null;
+interface ResolvedPictureBullet {
+    /** `v:imagedata/@r:id`, relative to the NUMBERING part's relationships. */
+    readonly relationshipId: string;
+    /** Painted width in points, after the marker font scale. */
+    readonly width: number;
+    /** Painted height in points, after the marker font scale. */
+    readonly height: number;
+    /** The `v:shape` extent exactly as the file authored it. */
+    readonly authored: NumberingPictureBullet;
 }
+
+/** Soft ceiling on abstractNum / num entries read from one part. */
+declare const MAX_NUMBERING_DEFINITIONS = 512;
+/** Soft ceiling on override entries per `w:num`. */
+declare const MAX_LVL_OVERRIDES = 9;
+/** `w:suff` — what separates a list marker from the text after it. */
+type ListSuffix = 'tab' | 'space' | 'nothing';
+/** `w:lvlJc` — how a list marker aligns within its own indent. */
+type ListMarkerAlign = 'left' | 'center' | 'right';
 /**
- * One shaped run: text turned into positioned glyphs, with everything needed to measure it, paint
- * it, and put a caret in it.
+ * One level's indent, plus which parts the level actually AUTHORED.
  *
- * The engine's measurement unit. Layout never measures characters — it measures these.
+ * The provenance matters: `w:ind` cascades per-attribute, so a level that authored only `left`
+ * must not overwrite an inherited `hanging` with a synthesized zero.
  */
-interface ShapedRun {
-    readonly text: string;
-    readonly direction: TextDirection;
-    readonly bidiLevel: number;
-    readonly glyphs: readonly ShapedGlyph[];
-    readonly clusters: readonly ShapedCluster[];
-    readonly fontSpans: readonly ShapedFontSpan[];
-    readonly metrics: ShapedVerticalMetrics;
+interface NumberingLevelIndent {
     /**
-     * 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`.
+     * The sides as the level spells them, in points. `left` and `start` both name the leading
+     * indent, and `right` and `end` the trailing one; `left`/`right` below hold those two.
+     */
+    readonly authored?: {
+        readonly left?: number;
+        readonly right?: number;
+        readonly start?: number;
+        readonly end?: number;
+    };
+    readonly left: number;
+    readonly right: number;
+    readonly hanging: number;
+    readonly firstLine: number;
+    /**
+     * Which of these the LEVEL actually authored.
      *
-     * 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.
+     * A level's `w:pPr/w:ind` sits between the formatting it outranks and the formatting that
+     * outranks it (`mergeListIndent`), so the merge has to tell "the level says left = 0" from
+     * "the level says nothing about left and the style's value stands". Absent (the default) reads as "says nothing", which is what a
+     * hand-built level in a test means.
+     */
+    readonly stated?: {
+        readonly left: boolean;
+        readonly right: boolean;
+        /** `w:hanging`/`w:firstLine` are one mutually exclusive slot (§17.3.1.10, §17.3.1.12). */
+        readonly firstLineOffset: boolean;
+    };
+}
+/** One `w:lvl`: how this depth numbers, what its marker looks like, and how it indents. */
+interface NumberingLevel {
+    readonly ilvl: number;
+    readonly start: number;
+    readonly numFmt: string;
+    readonly lvlText: string;
+    readonly lvlJc: ListMarkerAlign;
+    readonly suff: ListSuffix;
+    readonly indent: NumberingLevelIndent;
+    /**
+     * `w:lvlRestart` one-based trigger level, or `0` when the level never restarts.
+     * Omitted in XML → restart when the previous level (or any earlier level) is used.
+     */
+    readonly lvlRestart?: number;
+    /**
+     * `w:isLgl` (§17.9.9): render EVERY level referenced by this level's `w:lvlText` in
+     * decimal, whatever number format those levels declare for themselves.
+     */
+    readonly isLgl: boolean;
+    /**
+     * `w:lvlPicBulletId` (§17.9.12): this level's marker is the `w:numPicBullet` of that id,
+     * drawn INSTEAD of `w:lvlText`. Absent on every ordinary level.
+     */
+    readonly picBulletId?: string;
+    /** Level `w:rPr` as flat properties (for marker face / vanish). */
+    readonly runProperties: readonly OoxmlProperty[];
+    /** True when level run props request vanish — marker must not paint. */
+    readonly vanish: boolean;
+}
+/**
+ * One `w:lvlOverride` on a `w:num`: a restart value, a replacement level, or both.
+ *
+ * How two lists share an abstract definition while numbering independently.
+ */
+interface LevelOverride {
+    readonly startOverride?: number;
+    /** Full level replacement when `w:lvl` is present under the override. */
+    readonly level?: NumberingLevel;
+}
+/**
+ * One `w:abstractNum` — the shape of a list, without being a list.
+ *
+ * Never referenced by a paragraph directly. Paragraphs name a {@link NumDefinition}, which names
+ * one of these, so several lists can share a definition and still count separately.
+ */
+interface AbstractNumDefinition {
+    readonly abstractNumId: string;
+    readonly levels: ReadonlyMap<number, NumberingLevel>;
+    /**
+     * `w:numStyleLink` (§17.9.21): this definition carries no levels of its own — the numbering
+     * lives on the named style. Word follows the link; resolve it with
+     * {@link resolveNumberingStyleLinks} before reading levels, or every paragraph on this
+     * abstract renders with NO marker at all.
+     */
+    readonly numStyleLink?: string;
+    /**
+     * `w:styleLink` (§17.9.23): the definition side of the same pair — this abstract IS the
+     * numbering of the named style. Kept so a link can be verified rather than assumed.
+     */
+    readonly styleLink?: string;
+}
+/**
+ * One `w:num` — the thing a paragraph's `w:numId` actually names.
+ *
+ * Points at an {@link AbstractNumDefinition} and may override any of its levels.
+ */
+interface NumDefinition {
+    readonly numId: string;
+    readonly abstractNumId: string;
+    readonly overrides: ReadonlyMap<number, LevelOverride>;
+}
+/**
+ * The bounded projection of `numbering.xml` that list layout resolves against.
+ *
+ * Projection ONLY — never a mutation or serialization authority. Hostile values are dropped or
+ * clamped, and a missing definition resolves to "no list" rather than a guess.
+ */
+interface NumberingIndex {
+    readonly abstractNums: ReadonlyMap<string, AbstractNumDefinition>;
+    readonly nums: ReadonlyMap<string, NumDefinition>;
+    /**
+     * `w:numPicBullet` declarations keyed by `w:numPicBulletId` (§17.9.20).
      *
-     * Absent on runs an assembly path cannot state exactly; a reader falls back to `originX`.
+     * 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 exactAdvancesX?: readonly number[];
+    readonly pictureBullets?: ReadonlyMap<string, NumberingPictureBullet>;
 }
 /**
- * A {@link ShapedRun} reduced to the fields two shaping results must agree on to be considered
- * identical.
+ * Build a numbering index from the root of a numbering part (`w:numbering`).
  *
- * Fonts appear as {@link FontFingerprintInputs} rather than whole `ResolvedFont` objects, so the
- * comparison is over VALUES and does not depend on object identity — which is what makes it work
- * across a reload or a worker boundary.
+ * Empty / missing roots yield an empty index. Duplicate ids keep the first definition.
  */
-interface ShapedRunComparatorInputs {
-    readonly text: string;
-    readonly direction: TextDirection;
-    readonly script: string;
-    readonly language: string;
-    readonly bidiLevel: number;
-    readonly glyphs: readonly ShapedGlyph[];
-    readonly clusters: readonly ShapedCluster[];
-    readonly fontSpans: readonly {
-        readonly glyphStart: number;
-        readonly glyphEnd: number;
-        readonly fallbackIndex: number | null;
-        readonly font: FontFingerprintInputs;
-    }[];
-    readonly metrics: ShapedVerticalMetrics;
+/**
+ * Project `numbering.xml` into the bounded index.
+ *
+ * Every ceiling here exists because the input is file-derived: definition counts, override
+ * counts, indent magnitudes and style-link hop depth are all capped, and nothing from the file
+ * becomes a loop bound or an allocation size.
+ */
+declare function buildNumberingIndex(root: OoxmlElement | null | undefined): NumberingIndex;
+/** Resolve the effective level for a `numId` + `ilvl`, applying overrides. */
+/**
+ * The effective level for one paragraph's numbering reference, after overrides and style links.
+ *
+ * Answers null for a reference the index cannot resolve — a paragraph naming a definition the
+ * file never declared is an unnumbered paragraph, not an error.
+ */
+declare function resolveNumberingLevel(index: NumberingIndex, numId: string, ilvl: number): {
+    readonly abstractNumId: string;
+    readonly level: NumberingLevel;
+    readonly startOverride?: number;
+} | null;
+/** Empty index for tests / documents without numbering. */
+declare const EMPTY_NUMBERING_INDEX: NumberingIndex;
+
+/**
+ * A face, as something asks for it: family plus the two axes this engine admits.
+ *
+ * Only static weights and slants. Variable-font axes are deliberately outside this vocabulary —
+ * the shaper refuses variation axes, and a variable file admitted here would render bold at
+ * regular weight.
+ */
+interface FontRequest {
+    readonly family: string;
+    readonly weight: number;
+    readonly style: 'normal' | 'italic';
 }
 /**
- * The one thing layout needs from a shaping backend.
+ * A request that was answered by a DIFFERENT face than the one asked for.
  *
- * Injected rather than imported, which is what keeps layout DOM-free and testable: a fixed-metric
- * shaper measures deterministically in a test, HarfBuzz measures for real in a browser, and
- * layout cannot tell the difference.
+ * Recorded rather than silently applied, because a substitution changes measurement: it is part
+ * of the shaping fingerprint, so a cached run shaped against a substitute is never reused for the
+ * real face.
  */
-interface TextShaper {
-    shape(input: ShapeInput): ShapedRun;
+interface FontSubstitution {
+    readonly requested: FontRequest;
+    readonly resolved: FontRequest;
+    readonly lineMetrics?: {
+        readonly heightEm: number;
+        readonly baselineEm: number;
+    };
 }
+declare const RESOLVED_FONT_BRAND: unique symbol;
 /**
- * A font reduced to the values that identify it for fingerprinting.
+ * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
+ * a font.
  *
- * Includes the content `hash` and `faceIndex`, so two faces with the same family name but
- * different bytes fingerprint differently — which is what stops a cached measurement being reused
- * against a substituted face.
+ * 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 FontFingerprintInputs {
-    readonly identity: string;
+interface ResolvedFont {
+    readonly [RESOLVED_FONT_BRAND]: true;
     readonly id: string;
-    readonly family: 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 byteLength: number;
     readonly substitution: FontSubstitution | null;
 }
 /**
- * A {@link ShapingEnvironment} reduced to comparable values.
+ * Largest single face this engine will ever admit, whatever a caller configures.
  *
- * Records and axis maps become SORTED entry arrays, because two environments differing only in
- * key insertion order must fingerprint the same — otherwise a cache would miss on a difference
- * that changes no glyph.
+ * 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 ShapingEnvironmentFingerprintInputs {
-    readonly font: FontFingerprintInputs;
-    readonly variationAxes: readonly (readonly [string, number])[];
-    readonly shapingLibrary: VersionedShapingLibrary;
-    readonly unicodeDataVersion: string;
-    readonly normalization: NormalizationPolicy;
-    readonly script: string;
-    readonly language: string;
-    readonly direction: TextDirection;
-    readonly features: readonly (readonly [string, number])[];
-    readonly fallbackOrder: readonly FontFingerprintInputs[];
-    readonly fixedPointScale: number;
-    readonly roundingMode: FixedPointRoundingMode;
-}
+declare 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;
 /**
- * Validate and freeze a shaping environment.
- *
- * Checks every field that could silently corrupt a measurement: OpenType tags must be four ASCII
- * bytes, script and language must be non-blank and control-character free, fonts must already be
- * validated. Throws rather than coercing — a bad tag that shapes anyway produces a document that
- * measures wrong everywhere and looks fine.
+ * Why a face was not admitted.
  *
- * @throws TypeError on a malformed tag, name, or axis value.
+ * `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 const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
+type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
 /**
- * Reduce an environment to its comparable form, with records sorted so key order cannot affect
- * the result.
+ * 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 const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
-/** Canonical serialization of every shaping variable, including byte hash and provenance. */
-declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
+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;
+    });
+}
 /**
- * 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.
+ * One face offered to a snapshot, before admission.
  *
- * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
+ * `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".
  */
-declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
+interface FontResourceDefinition {
+    readonly request: FontRequest;
+    readonly id: string;
+    readonly bytes: Uint8Array;
+    readonly hash: string;
+    readonly faceIndex: number;
+    readonly availability?: 'available' | 'forbidden';
+}
 /**
- * Reduce a shaped run to its comparable form, validating it on the way through.
+ * A host-declared redirect: requests for `from` resolve to `to`.
  *
- * What the D9 determinism oracles compare: two shaping runs of the same text in the same
- * environment must produce byte-identical structures here.
+ * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
+ * without the document being rewritten.
  */
-declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
-
+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;
+};
 /**
- * Whether a paragraph must start a new page (`w:pageBreakBefore`).
+ * The injected check that bytes really are a font.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * `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 paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
+interface FontResourceSnapshot {
+    readonly epoch: number;
+    /** The admitted face, or a typed refusal. Never throws. */
+    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
+}
 /**
- * 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.
+ * 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 const MAX_PARAGRAPH_SPACING_PT: number;
-/** Soft ceiling on border width (96 eighths = 12pt). Word's UI tops out well below this. */
-declare const MAX_BORDER_WIDTH_PT = 12;
-/** Soft ceiling on border-to-text gap (`w:space`, already in points). */
-declare const MAX_BORDER_SPACE_PT = 3168;
+interface FontResourceSnapshotOptions {
+    readonly epoch: number;
+    readonly maxFontBytes: number;
+    readonly resources: readonly FontResourceDefinition[];
+    readonly substitutions?: readonly DeclaredFontSubstitution[];
+    readonly validateFont: FontByteValidator;
+    readonly instrumentation?: FontResourceInstrumentation;
+}
 /**
- * A paragraph's resolved space before and after, in points.
+ * Optional counters for the operations font admission is expected to do RARELY.
  *
- * 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.
+ * 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 ParagraphSpacing {
-    /** `w:spacing/@before`, in points. */
-    readonly before: number;
-    /** `w:spacing/@after`, in points. */
-    readonly after: number;
+interface FontResourceInstrumentation {
+    readonly onOwnedByteCopy?: () => void;
+    readonly onHash?: () => void;
+    readonly onTableScan?: () => void;
+    readonly onAdmission?: () => void;
 }
 /**
- * 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 canonical string identifying one face request.
  *
- * 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.
+ * 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 AUTO_PARAGRAPH_SPACING_PT = 14;
+declare const fontRequestKey: (request: FontRequest) => string;
+/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
+declare const boundedStructuralFontValidator: FontByteValidator;
 /**
- * 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.
+ * Admit a set of faces and return the immutable snapshot layout resolves against.
  *
- * 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/`.
+ * 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".
  */
-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;
-}
+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;
+};
 /**
- * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
+ * Brand a safe integer as a {@link FixedPoint} coordinate.
  *
- * `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.
+ * 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.
  *
- * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
- * does. `atLeast` uses it as a floor.
+ * @throws RangeError when the value is not a safe integer.
  */
-type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
+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';
 /**
- * Resolved line spacing: the rule, and the value it applies.
+ * The shaping library and its exact version.
  *
- * `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.
+ * 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 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;
+interface VersionedShapingLibrary {
+    readonly name: string;
+    readonly version: string;
 }
-/** 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.
+ * Everything that determines how text shapes — the complete input to a
+ * {@link ShapingEnvironment}.
  *
- * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
- * unbounded border width becomes a layout dimension.
+ * 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 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;
+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;
     /**
-     * `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.
+     * 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 shadow?: true;
+    readonly context?: ShapingContext;
 }
-/** 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'];
+/** 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;
 /**
- * Which of the six `CT_PBdr` edges.
+ * One positioned glyph.
  *
- * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
- * consecutive paragraphs share a border definition.
+ * `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.
  */
-type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
+interface ShapedGlyph {
+    readonly id: number;
+    /** Optional synthetic glyph-size factor; positions and advances already include it. */
+    readonly drawScale?: number;
+    /** UTF-16 text offset identifying the cluster that produced this glyph. */
+    readonly cluster: number;
+    /** Pen origin before this glyph's shaping offsets, in fixed-point run coordinates. */
+    readonly originX: FixedPoint;
+    readonly originY: FixedPoint;
+    readonly advanceX: FixedPoint;
+    readonly advanceY: FixedPoint;
+    readonly offsetX: FixedPoint;
+    readonly offsetY: FixedPoint;
+    /** Exact monochrome outline returned by the admitted HarfBuzz face. */
+    readonly outline: GlyphOutline;
+}
+/** A glyph's outline as SVG path data, in font design units. */
+interface GlyphOutline {
+    readonly path: string;
+    /** Design units per em — divide by this to scale the path to a point size. */
+    readonly unitsPerEm: number;
+}
 /**
- * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
+ * One cluster: the smallest indivisible text-to-glyph correspondence.
  *
- * `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.
+ * The unit the CARET moves by. A cluster may be several characters (a ligature) or several glyphs
+ * (a decomposed mark), so neither a character index nor a glyph index is a valid caret position —
+ * `caretEdges` is, and it includes both endpoints.
  */
-interface ParagraphBorders {
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-    readonly between?: ParagraphBorderEdge;
-    readonly bar?: ParagraphBorderEdge;
+interface ShapedCluster {
+    /** Half-open logical UTF-16 range in ShapedRun.text. */
+    readonly textStart: number;
+    readonly textEnd: number;
+    /** Half-open visual glyph range in ShapedRun.glyphs. */
+    readonly glyphStart: number;
+    readonly glyphEnd: number;
+    readonly advance: FixedPoint;
+    /** Fixed-point edges from this cluster's visual origin, including both endpoints. */
+    readonly caretEdges: readonly FixedPoint[];
+    /** Index into ShapedRun.fontSpans, preserving the exact fallback choice. */
+    readonly fontSpan: number;
+}
+/** A run's vertical metrics, from the face that shaped it. Drives line height and baseline. */
+interface ShapedVerticalMetrics {
+    readonly ascent: FixedPoint;
+    readonly descent: FixedPoint;
+    readonly lineGap: FixedPoint;
 }
 /**
- * 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.
+ * A stretch of glyphs that came from ONE face.
  *
- * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
- * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
+ * A run whose text needed fallback has several of these. Recording the exact face per span is
+ * what lets a re-shape reproduce the same result rather than re-running fallback selection and
+ * possibly choosing differently.
  */
-declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
+interface ShapedFontSpan {
+    readonly glyphStart: number;
+    readonly glyphEnd: number;
+    readonly font: ResolvedFont;
+    /** null denotes the primary font; otherwise this is the environment fallback-order index. */
+    readonly fallbackIndex: number | null;
+}
 /**
- * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
+ * One shaped run: text turned into positioned glyphs, with everything needed to measure it, paint
+ * it, and put a caret in 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.
+ * The engine's measurement unit. Layout never measures characters — it measures these.
  */
-declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
+interface ShapedRun {
+    readonly text: string;
+    readonly direction: TextDirection;
+    readonly bidiLevel: number;
+    readonly glyphs: readonly ShapedGlyph[];
+    readonly clusters: readonly ShapedCluster[];
+    readonly fontSpans: readonly ShapedFontSpan[];
+    readonly metrics: ShapedVerticalMetrics;
+    /**
+     * The same horizontal advances as `glyphs[i].advanceX`, in the same fixed-point units, but
+     * BEFORE the per-glyph rounding to the fixed-point grid. Parallel to `glyphs`.
+     *
+     * Measurement and line breaking read `advanceX` and must keep doing so: pagination is decided
+     * on those numbers, and two runs shaped identically have to compare equal. A painter that
+     * gives every glyph its own absolute position sums the advances instead, and a sum of ROUNDED
+     * advances drifts by up to half a fixed-point unit per glyph — an error that only grows along
+     * a line. Summing these and rounding once, at the position actually written, does not.
+     *
+     * Absent on runs an assembly path cannot state exactly; a reader falls back to `originX`.
+     */
+    readonly exactAdvancesX?: readonly number[];
+}
 /**
- * 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.
+ * A {@link ShapedRun} reduced to the fields two shaping results must agree on to be considered
+ * identical.
  *
- * An `auto` or `atLeast` line of a snapping paragraph under an active line grid takes whole
- * pitches instead ({@link gridLineBox}); `trailing` then names the box below the glyphs.
+ * Fonts appear as {@link FontFingerprintInputs} rather than whole `ResolvedFont` objects, so the
+ * comparison is over VALUES and does not depend on object identity — which is what makes it work
+ * across a reload or a worker boundary.
  */
-declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
-    height: number;
-    baseline: number;
-    trailing?: number;
-};
+interface ShapedRunComparatorInputs {
+    readonly text: string;
+    readonly direction: TextDirection;
+    readonly script: string;
+    readonly language: string;
+    readonly bidiLevel: number;
+    readonly glyphs: readonly ShapedGlyph[];
+    readonly clusters: readonly ShapedCluster[];
+    readonly fontSpans: readonly {
+        readonly glyphStart: number;
+        readonly glyphEnd: number;
+        readonly fallbackIndex: number | null;
+        readonly font: FontFingerprintInputs;
+    }[];
+    readonly metrics: ShapedVerticalMetrics;
+}
 /**
- * `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.
+ * The one thing layout needs from a shaping backend.
+ *
+ * Injected rather than imported, which is what keeps layout DOM-free and testable: a fixed-metric
+ * shaper measures deterministically in a test, HarfBuzz measures for real in a browser, and
+ * layout cannot tell the difference.
  */
-declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
+interface TextShaper {
+    shape(input: ShapeInput): ShapedRun;
+}
 /**
- * Resolve `w:pBdr` from the paragraph-properties node.
+ * A font reduced to the values that identify it for fingerprinting.
  *
- * 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.
+ * Includes the content `hash` and `faceIndex`, so two faces with the same family name but
+ * different bytes fingerprint differently — which is what stops a cached measurement being reused
+ * against a substituted face.
  */
-declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+interface FontFingerprintInputs {
+    readonly identity: string;
+    readonly id: string;
+    readonly family: string;
+    readonly request: FontRequest;
+    readonly hash: string;
+    readonly faceIndex: number;
+    readonly byteLength: number;
+    readonly substitution: FontSubstitution | null;
+}
 /**
- * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
+ * A {@link ShapingEnvironment} reduced to comparable values.
  *
- * 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.
+ * Records and axis maps become SORTED entry arrays, because two environments differing only in
+ * key insertion order must fingerprint the same — otherwise a cache would miss on a difference
+ * that changes no glyph.
  */
-declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
+interface ShapingEnvironmentFingerprintInputs {
+    readonly font: FontFingerprintInputs;
+    readonly variationAxes: readonly (readonly [string, number])[];
+    readonly shapingLibrary: VersionedShapingLibrary;
+    readonly unicodeDataVersion: string;
+    readonly normalization: NormalizationPolicy;
+    readonly script: string;
+    readonly language: string;
+    readonly direction: TextDirection;
+    readonly features: readonly (readonly [string, number])[];
+    readonly fallbackOrder: readonly FontFingerprintInputs[];
+    readonly fixedPointScale: number;
+    readonly roundingMode: FixedPointRoundingMode;
+}
 /**
- * Visual stroke thickness layout publishes for one edge (points).
+ * Validate and freeze a shaping environment.
  *
- * 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.
+ * Checks every field that could silently corrupt a measurement: OpenType tags must be four ASCII
+ * bytes, script and language must be non-blank and control-character free, fonts must already be
+ * validated. Throws rather than coercing — a bad tag that shapes anyway produces a document that
+ * measures wrong everywhere and looks fine.
+ *
+ * @throws TypeError on a malformed tag, name, or axis value.
  */
-declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
 /**
- * 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.
+ * Reduce an environment to its comparable form, with records sorted so key order cannot affect
+ * the result.
  */
-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 const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
+/** Canonical serialization of every shaping variable, including byte hash and provenance. */
+declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
 /**
- * Identity of a paragraph's border set, for the `w:between` group rule.
+ * Validate and freeze a shaped run against the environment that produced it.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
  */
-declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
 /**
- * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ * Reduce a shaped run to its comparable form, validating it on the way through.
  *
- * 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.
+ * What the D9 determinism oracles compare: two shaping runs of the same text in the same
+ * environment must produce byte-identical structures here.
  */
-declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, preserveAtPageStart: boolean): number;
+declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
 
 /** `w:vertAlign` — script position, which also scales the run's effective size. */
 type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
@@ -2404,65 +2887,6 @@ interface EquationSpanRecord {
 /** Compose one bounded OMML projection into paint-ready point geometry. */
 declare function layoutEquation(projection: OmmlEquationProjection, measurer: TextMeasurer, style: ResolvedRunStyle): EquationSpanRecord;
 
-/**
- * The four physical sides of `CT_PageBorders`.
- *
- * Four, not the six of `w:pBdr`: `w:between` and `w:bar` are paragraph-group rules and the
- * page has no analogue for either.
- */
-declare const PAGE_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right'];
-/** Which of the four page-frame edges. */
-type PageBorderSide = (typeof PAGE_BORDER_SIDES)[number];
-/**
- * `w:offsetFrom` (`ST_PgBorderOffset`) — what `w:space` on each edge is measured from.
- *
- * The schema default is `text`, NOT `page`. Word's own UI opens on "Edge of page", which is
- * why the wrong default is easy to assume and expensive to hold: at `text` the rule sits
- * `w:space` points outside the TEXT, so its distance from the sheet edge is the margin minus
- * the space — a number that moves whenever the margins do.
- */
-type PageBorderOffsetFrom = 'page' | 'text';
-/** `w:display` (`ST_PgBorderDisplay`) — which pages of the section carry the frame. */
-type PageBorderDisplay = 'allPages' | 'firstPage' | 'notFirstPage';
-/** `w:zOrder` (`ST_PgBorderZOrder`) — whether the frame paints over the text or under it. */
-type PageBorderZOrder = 'front' | 'back';
-/**
- * One section's resolved `w:pgBorders`.
- *
- * Resolved, not raw: every attribute the file omitted is filled in with the SCHEMA default,
- * so a consumer never has to know which of the three were authored. An edge is present only
- * when it paints — `nil` / `none` and art borders are already gone (see {@link parsePageBorders}).
- */
-interface SectionPageBorders {
-    /** `w:offsetFrom`; absent attribute reads as `text` (§17.6.10). */
-    readonly offsetFrom: PageBorderOffsetFrom;
-    /** `w:display`; absent attribute reads as `allPages`. */
-    readonly display: PageBorderDisplay;
-    /** `w:zOrder`; absent attribute reads as `front`. */
-    readonly zOrder: PageBorderZOrder;
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-}
-/**
- * Parse `w:pgBorders` off one `w:sectPr`.
- *
- * Undefined when the element is absent AND when it paints nothing — every edge off, or every
- * edge an art border. Unlike `w:pgNumType`, an empty-but-present element is not distinguished:
- * these properties are a LAYOUT input, serialization re-emits the canonical tree, and a frame
- * with no edges has exactly one meaning downstream.
- */
-declare function parsePageBorders(sectPr: OoxmlNode): SectionPageBorders | undefined;
-/**
- * Identity of one section's page frame, for incremental-layout context keys.
- *
- * A `w:pgBorders` edit changes nothing the flow measures — the frame is drawn beside the text,
- * never through it — so no per-paragraph key moves and every reuse path would hand back the
- * previous sheets with the previous frame. This token goes in the pass context so it does not.
- */
-declare function pageBordersFingerprint(borders: SectionPageBorders | undefined): string;
-
 /** Published root story containing an artifact occurrence. @public */
 type SemanticArtifactRootStoryKind = 'body' | 'header' | 'footer' | 'footnote' | 'endnote' | 'note-separator';
 /** Exact story in which a review artifact's source anchor was laid out. @public */
@@ -2550,6 +2974,24 @@ interface SemanticCommentArtifactRecord {
 /** Exporter-neutral review artifact normalized by core. @public */
 type SemanticReviewArtifactRecord = SemanticTrackedChangeArtifactRecord | SemanticCommentArtifactRecord;
 
+/** Page geometry, in points. */
+interface PageGeometry {
+    readonly width: number;
+    readonly height: number;
+    readonly margin: {
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    };
+    /** `w:pgMar/@header` — sheet edge to header top, in points. Defaults to 36 (720 twips). */
+    readonly headerDistance?: number;
+    /** `w:pgMar/@footer` — sheet edge to footer bottom, in points. Defaults to 36. */
+    readonly footerDistance?: number;
+}
+/** US Letter with one-inch margins, in points. */
+declare const DEFAULT_PAGE_GEOMETRY: PageGeometry;
+
 /** A half-open UTF-16 range inside one paragraph, addressed by its canonical node id. */
 interface SourceRange {
     readonly paragraphId: string;
@@ -2789,6 +3231,8 @@ interface StyleSpanRecord {
 interface LineRecord {
     /** An authored manual line break ends this line; optional display furniture can show ↵. */
     readonly manualBreakAfter?: true;
+    /** An authored page or column break ends this line; optional furniture can label it. */
+    readonly breakAfter?: 'page' | 'column';
     readonly id: string;
     readonly range: SourceRange;
     readonly spans: readonly StyleSpanRecord[];
@@ -3487,6 +3931,13 @@ interface SemanticLayout {
      * reuse paths that would otherwise return previous pages by identity with stale boundaries.
      */
     readonly controlContextToken?: string;
+    /** Body section breaks in document order, each named by the section that FOLLOWS it. */
+    readonly sectionBreaks?: readonly SectionBreakMarkRecord[];
+}
+/** The paragraph whose `w:sectPr` ends a section, and how the next section starts. */
+interface SectionBreakMarkRecord {
+    readonly paragraphId: string;
+    readonly kind: SectionBreakType;
 }
 
 /**
@@ -3528,5 +3979,5 @@ interface TextMeasurer {
     };
 }
 
-export { PAGE_BORDER_SIDES as a$, AUTO_PARAGRAPH_SPACING_PT as a4, HARD_MAX_AGGREGATE_FONT_BYTES as aG, HARD_MAX_FONT_BYTES as aH, HARD_MAX_FONT_SOURCES as aI, MAX_BORDER_SPACE_PT as aO, MAX_BORDER_WIDTH_PT as aP, MAX_LVL_OVERRIDES as aQ, MAX_NUMBERING_DEFINITIONS as aR, MAX_PARAGRAPH_SPACING_PT as aS, MAX_SHAPING_CONTEXT as aT, MAX_STYLE_DEFINITIONS as aU, MAX_TABLE_BORDER_STROKES as aV, MAX_TAB_POSITION_TWIPS as aW, MAX_TAB_STOPS as aX, DEFAULT_RUN_STYLE as ae, DEFAULT_TAB_INTERVAL_PT as af, DEFAULT_TAB_INTERVAL_TWIPS as ag, EMPTY_NUMBERING_INDEX as al, EMPTY_TAB_STOPS as am, FontResolutionError as ax, bottomBorderExtentPt as b$, PARAGRAPH_BORDER_SIDES as b0, TAB_LEADER_GLYPH as bJ, UnsupportedScriptError as bU, appliedSpaceBefore as bW, applyLineSpacing as bX, baselineShiftPtOf as bY, borderExtentPt as bZ, borderWeight as b_, SINGLE_LINE_SPACING as bp, boundedStructuralFontValidator as c0, buildNumberingIndex as c1, buildStyleCascadeTable as c2, cascadeParagraphFormatting as c3, cascadeRunProperties as c4, cascadedBottomBorder as c5, cascadedParagraphBorders as c6, cascadedTabStops as c7, collapsedSpaceBefore as c8, createFontResourceSnapshot as c9, readCellBorders as cA, readNumPr as cB, readTableBorders as cC, resolveBorderConflict as cD, resolveNumberingLevel as cE, resolveParagraphLayoutInputs as cF, resolveRunStyle as cG, resolveStoryListItems as cH, resolveStoryRefFields as cI, resolveTableCellBorderGrid as cJ, runStylesEqual as cK, shapedRunComparatorInputs as cL, shapingEnvironmentFingerprint as cM, shapingEnvironmentFingerprintInputs as cN, styleForFontSlot as cO, tabAdvanceWidth as cP, tabStopsFingerprint as cQ, withDefaultTabInterval as cR, withNumberingStyleLinks as cS, withResolvedListItems as cT, createShapedRun as ca, createShapingEnvironment as cb, defaultTabIntervalFromSettings as cc, displayText as cd, fixedPoint as ce, fontRequestKey as cf, glyphSizeFactorOf as cg, isValidStyleId as ch, itemizeScriptFontSlots as ci, layoutEquation as cj, measureDisplayText as ck, mergeListIndent as cl, nextTabDestination as cm, pageBordersFingerprint as cn, paragraphBorderExtentPt as co, paragraphBorderStrokeWidthPt as cp, paragraphBorders as cq, paragraphBordersFingerprint as cr, paragraphBreaksBefore as cs, paragraphContextualSpacing as ct, paragraphLineSpacing as cu, paragraphSpacing as cv, paragraphTabStops as cw, parsePageBorders as cx, parseRefInstruction as cy, readBorderSide as cz };
-export type { HyperlinkFieldSpec as $, AnchoredDrawingRecord as A, BlockFragmentRecord as B, ContentControlBoundaryRecord as C, DrawingPoint as D, InlineDrawingLayoutContext as E, FontResourceSnapshot as F, CellBorderBox as G, HeaderFooterStoryRecord as H, InlineDrawingRecord as I, TableBorderBox as J, TableCellStyleFormatting as K, LineRecord as L, ModelRange as M, NoteAreaRecord as N, TableFloatPosition as O, ParagraphFragmentRecord as P, StyleCascadeTable as Q, ResolvedRunStyle as R, SemanticLayout as S, TextMeasurer as T, FixedPoint as U, VersionedShapingLibrary as V, FontByteValidator as W, SourceRange as X, HyperlinkProjector as Y, FieldLinkProjector as Z, StoryPageFieldNeeds as _, PageRecord as a, SpanLinkRecord as a0, PageBorderFrameRecord as a1, ParagraphBorderStrokeRecord as a2, StrikeoutStrokePt as a3, AbstractNumDefinition as a5, AnchoredDrawingLayoutFallback as a6, BidiEmbeddingLevels as a7, BorderGridGeometry as a8, CascadedParagraphFormatting as a9, FontResourceInstrumentation as aA, FontResourceSnapshotOptions as aB, FontSlot as aC, FontValidationResult as aD, GlyphOutline as aE, GroupTextboxStoryRecord as aF, LevelOverride as aJ, LineSpacingRule as aK, ListMarkerAlign as aL, ListMarkerRecord as aM, ListSuffix as aN, NumDefinition as aY, NumberingLevelIndent as aZ, NumberingPictureBullet as a_, CjkTypographySettings as aa, ContentControlGeometryFragment as ab, ContentControlLevel as ac, ContentControlMappedType as ad, DeclaredFontSubstitution as ah, DrawingClipFallback as ai, DrawingGeometry as aj, DrawingGroupPictureRecord as ak, EquationFractionGeometry as an, EquationGeometry as ao, EquationNaryGeometry as ap, EquationRadicalGeometry as aq, EquationRowGeometry as ar, EquationScriptGeometry as as, EquationSpanRecord as at, EquationTextGeometry as au, FieldAtomMarker as av, FontFingerprintInputs as aw, FontResolutionErrorCode as ay, FontResourceDefinition as az, LayoutBox as b, PageBorderDisplay as b1, PageBorderOffsetFrom as b2, PageBorderSide as b3, PageBorderStrokeRecord as b4, PageBorderZOrder as b5, PageRefCalibrationCell as b6, PageRefFieldProjection as b7, ParagraphAutoSpacingContext as b8, ParagraphBorderEdge as b9, ShapedCluster as bA, ShapedFontSpan as bB, ShapedGlyph as bC, ShapedRunComparatorInputs as bD, ShapedVerticalMetrics as bE, ShapingContext as bF, ShapingEnvironment as bG, ShapingEnvironmentFingerprintInputs as bH, StyleDefinition as bI, TabAlignment as bK, TabDestination as bL, TabLeader as bM, TabStop as bN, TableBorderSideName as bO, TableBorderStrokeRecord as bP, TableFragmentRecord as bQ, TextDirection as bR, TextboxStoryFallbackReason as bS, TextboxStoryLayout as bT, VerticalAlign as bV, ParagraphBorderSide as ba, ParagraphBorders as bb, ParagraphBottomBorderRecord as bc, ParagraphIndent as bd, ParagraphLayoutInputs as be, ParagraphLineSpacing as bf, ParagraphSpacing as bg, RefFieldSpec as bh, RefNoteParts as bi, ResolvedCellBorders as bj, ResolvedPictureBullet as bk, ResolvedTabStops as bl, ResolvedTableBorderEdge as bm, ResolvedTableBorderEdgeSegment as bn, ResolvedUnderline as bo, ScriptItem as bq, SemanticArtifactRootStoryKind as br, SemanticArtifactStoryKind as bs, SemanticCommentArtifactRecord as bt, SemanticReviewArtifactOccurrence as bu, SemanticReviewArtifactOccurrenceGeometry as bv, SemanticReviewArtifactPosition as bw, SemanticReviewArtifactSource as bx, SemanticTrackedChangeArtifactRecord as by, ShapeInput as bz, NoteStoryRecord as c, ContentControlLock as d, StyleSpanRecord as e, SectionPageBorders as f, TableRowFragmentRecord as g, TableCellFragmentRecord as h, ShapingEnvironmentInput as i, TextShaper as j, ResolvedFont as k, NormalizationPolicy as l, FixedPointRoundingMode as m, FontRequest as n, SemanticReviewArtifactRecord as o, ListMarkerPictureRecord as p, FontSubstitution as q, ShapedRun as r, NumberingLevel as s, NumberingIndex as t, DrawingInsets as u, TableBorderSide as v, TableFloatXSpec as w, TableFloatYSpec as x, ResolvedListItem as y, RefFieldContext as z };
+export { DEFAULT_REVISION_MARKUP as D, resolveRevisionMarkup as Q, DEFAULT_REVISION_DISPLAY_MODE as aA, DEFAULT_RUN_STYLE as aB, DEFAULT_SECTION_PROPERTIES as aC, DEFAULT_TAB_INTERVAL_PT as aD, DEFAULT_TAB_INTERVAL_TWIPS as aE, EMPTY_NUMBERING_INDEX as aL, EMPTY_TAB_STOPS as aM, FontResolutionError as aX, AUTO_PARAGRAPH_SPACING_PT as ap, DEFAULT_PAGE_GEOMETRY as az, HARD_MAX_AGGREGATE_FONT_BYTES as b4, HARD_MAX_FONT_BYTES as b5, HARD_MAX_FONT_SOURCES as b6, SINGLE_LINE_SPACING as bS, MAX_BORDER_SPACE_PT as bc, MAX_BORDER_WIDTH_PT as bd, MAX_DOCUMENT_SECTIONS as be, MAX_LVL_OVERRIDES as bf, MAX_NUMBERING_DEFINITIONS as bg, MAX_PARAGRAPH_SPACING_PT as bh, MAX_SHAPING_CONTEXT as bi, MAX_STYLE_DEFINITIONS as bj, MAX_TABLE_BORDER_STROKES as bk, MAX_TAB_POSITION_TWIPS as bl, MAX_TAB_STOPS as bm, PAGE_BORDER_SIDES as bq, PARAGRAPH_BORDER_SIDES as br, paragraphBorderExtentPt as c$, buildStyleCascadeTable as cA, cascadeParagraphFormatting as cB, cascadeRunProperties as cC, cascadedBottomBorder as cD, cascadedParagraphBorders as cE, cascadedTabStops as cF, collapsedSpaceBefore as cG, createFontResourceSnapshot as cH, createShapedRun as cI, createShapingEnvironment as cJ, defaultTabIntervalFromSettings as cK, displayText as cL, enumerateDocumentSections as cM, enumerateDocumentSectionsBounded as cN, fixedPoint as cO, fontRequestKey as cP, formatRevisionOf as cQ, geometryOfSection as cR, glyphSizeFactorOf as cS, isValidStyleId as cT, itemizeScriptFontSlots as cU, layoutEquation as cV, markRevisionRemovesMark as cW, measureDisplayText as cX, mergeListIndent as cY, nextTabDestination as cZ, pageBordersFingerprint as c_, TAB_LEADER_GLYPH as cf, UnsupportedScriptError as cq, appliedSpaceBefore as cs, applyLineSpacing as ct, baselineShiftPtOf as cu, borderExtentPt as cv, borderWeight as cw, bottomBorderExtentPt as cx, boundedStructuralFontValidator as cy, buildNumberingIndex as cz, paragraphBorderStrokeWidthPt as d0, paragraphBorders as d1, paragraphBordersFingerprint as d2, paragraphBreaksBefore as d3, paragraphContextualSpacing as d4, paragraphLineSpacing as d5, paragraphMarkFormatRevisionOf as d6, paragraphMarkRevisionOf as d7, paragraphMarkRevisionsOf as d8, paragraphSectionNode as d9, shapingEnvironmentFingerprintInputs as dA, shownMarkRevision as dB, styleForFontSlot as dC, tabAdvanceWidth as dD, tabStopsFingerprint as dE, withDefaultTabInterval as dF, withNumberingStyleLinks as dG, withResolvedListItems as dH, paragraphSpacing as da, paragraphTabStops as db, parsePageBorders as dc, parsePageNumbering as dd, parseRefInstruction as de, parseSectionProperties as df, projectedSectionSourceIndexes as dg, readBorderSide as dh, readCellBorders as di, readNumPr as dj, readSectionProperties as dk, readTableBorders as dl, resolveBorderConflict as dm, resolveNumberingLevel as dn, resolveParagraphLayoutInputs as dp, resolveRunStyle as dq, resolveStoryListItems as dr, resolveStoryRefFields as ds, resolveTableCellBorderGrid as dt, revisionAuthorFilter as du, revisionsAreDeletion as dv, revisionsVisible as dw, runStylesEqual as dx, shapedRunComparatorInputs as dy, shapingEnvironmentFingerprint as dz, REVISION_MARKUP_COLORS as w };
+export type { TableBorderSide as $, AnchoredDrawingRecord as A, BlockFragmentRecord as B, ContentControlBoundaryRecord as C, RevisionMarkupColor as E, FontResourceSnapshot as F, RevisionMarkupMark as G, HeaderFooterStoryRecord as H, InlineDrawingRecord as I, RevisionMarkupNamedColor as J, RevisionMarkupStyle as K, LineRecord as L, RevisionMarkupTextStyle as M, NoteAreaRecord as N, SectionProperties as O, ParagraphFragmentRecord as P, RevisionMarkupDialogSession as R, SemanticLayout as S, TextMeasurer as T, NumberingLevel as U, VersionedShapingLibrary as V, NumberingIndex as W, DrawingPoint as X, DrawingInsets as Y, ModelRange as Z, RevisionAttribution as _, ReviewDisplayMode as a, FontResourceSnapshotOptions as a$, TableFloatXSpec as a0, TableFloatYSpec as a1, ResolvedListItem as a2, RefFieldContext as a3, InlineDrawingLayoutContext as a4, CellBorderBox as a5, TableBorderBox as a6, TableCellStyleFormatting as a7, TableFloatPosition as a8, StyleCascadeTable as a9, DeclaredFontSubstitution as aF, DocumentSection as aG, DocumentSectionsEnumeration 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, FontResourceInstrumentation as a_, RevisionAuthorFilter as aa, FixedPoint as ab, FontByteValidator as ac, SourceRange as ad, HyperlinkProjector as ae, FieldLinkProjector as af, StoryPageFieldNeeds as ag, HyperlinkFieldSpec as ah, SpanLinkRecord as ai, PageGeometry as aj, SectionColumns as ak, SectionPageBorders as al, PageBorderFrameRecord as am, ParagraphBorderStrokeRecord as an, StrikeoutStrokePt as ao, AbstractNumDefinition as aq, AnchoredDrawingLayoutFallback as ar, BidiEmbeddingLevels as as, BorderGridGeometry as at, CascadedParagraphFormatting as au, CjkTypographySettings as av, ContentControlGeometryFragment as aw, ContentControlLevel as ax, ContentControlMappedType as ay, RevisionDisplayMode as b, SemanticCommentArtifactRecord as b$, FontSlot as b0, FontValidationResult as b1, GlyphOutline as b2, GroupTextboxStoryRecord as b3, LevelOverride as b7, LineSpacingRule as b8, ListMarkerAlign as b9, ParagraphBorderEdge as bA, ParagraphBorderSide as bB, ParagraphBorders as bC, ParagraphBottomBorderRecord as bD, ParagraphIndent as bE, ParagraphLayoutInputs as bF, ParagraphLineSpacing as bG, ParagraphSpacing as bH, RefFieldSpec as bI, RefNoteParts as bJ, ResolvedCellBorders as bK, ResolvedPictureBullet as bL, ResolvedTabStops as bM, ResolvedTableBorderEdge as bN, ResolvedTableBorderEdgeSegment as bO, ResolvedUnderline as bP, RevisionFilter as bQ, RevisionKind as bR, ScriptItem as bT, SectionBreakMarkRecord as bU, SectionBreakType as bV, SectionColumnDefinition as bW, SectionMargins as bX, SectionPageNumbering as bY, SemanticArtifactRootStoryKind as bZ, SemanticArtifactStoryKind as b_, ListMarkerRecord as ba, ListSuffix as bb, NumDefinition as bn, NumberingLevelIndent as bo, NumberingPictureBullet as bp, PageBorderDisplay as bs, PageBorderOffsetFrom as bt, PageBorderSide as bu, PageBorderStrokeRecord as bv, PageBorderZOrder as bw, PageRefCalibrationCell as bx, PageRefFieldProjection as by, ParagraphAutoSpacingContext as bz, PageRecord as c, SemanticReviewArtifactOccurrence as c0, SemanticReviewArtifactOccurrenceGeometry as c1, SemanticReviewArtifactPosition as c2, SemanticReviewArtifactSource as c3, SemanticTrackedChangeArtifactRecord as c4, ShapeInput as c5, ShapedCluster as c6, ShapedFontSpan as c7, ShapedGlyph as c8, ShapedRunComparatorInputs as c9, ShapedVerticalMetrics as ca, ShapingContext as cb, ShapingEnvironment as cc, ShapingEnvironmentFingerprintInputs as cd, StyleDefinition as ce, TabAlignment as cg, TabDestination as ch, TabLeader as ci, TabStop as cj, TableBorderSideName as ck, TableBorderStrokeRecord as cl, TableFragmentRecord as cm, TextDirection as cn, TextboxStoryFallbackReason as co, TextboxStoryLayout as cp, VerticalAlign as cr, LayoutBox as d, NoteStoryRecord as e, ContentControlLock as f, StyleSpanRecord as g, TableRowFragmentRecord as h, TableCellFragmentRecord as i, ShapingEnvironmentInput as j, TextShaper as k, ResolvedRunStyle as l, ResolvedFont as m, NormalizationPolicy as n, FixedPointRoundingMode as o, FontRequest as p, ResolvedRevisionMarkup as q, SemanticReviewArtifactRecord as r, ListMarkerPictureRecord as s, RevisionMarkupOptions as t, FontSubstitution as u, ShapedRun as v, RevisionChangedLinesMark as x, RevisionDeletionMark as y, RevisionMarkupChromeHandlers as z };