@docx-editor.dev/core 2.27.0 → 2.29.0

package/dist/{semantic-records-B9OolWGN.d.ts → semantic-records-DQmumPgL.d.ts}

@@ -1,991 +1,1474 @@
-import { o as RevisionAttribution, b as RevisionDisplayMode } from './revision-projection-CSNFudZY.js';
-import { X as OoxmlProperty, Z as OoxmlElement, N as OoxmlNode, O as OoxmlPart, aG as TableBorderStyle, aH as DrawingAccessibility, aI as DrawingImageEffects, a8 as SourceCrop, aJ as DrawingTransform, aK as VectorShapeProjection, aj as DrawingHorizontalReferenceFrame, ak as DrawingVerticalReferenceFrame, aa as ImageWrapTarget, a0 as DrawingProjection, aL as OoxmlDrawingNode } from './types-barrel-BFKR8Pzp.js';
-import { b as ImageResourceState } from './image-resources-BDFxcu7W.js';
-import { O as OmmlEquationProjection } from './omml-equation-DuczgG5o.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;
-};
-/**
- * Brand a safe integer as a {@link FixedPoint} coordinate.
+ * `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".
  *
- * 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.
+ * `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/`.
  *
- * @throws RangeError when the value is not a safe integer.
+ * 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 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 applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
+    height: number;
+    baseline: number;
+    trailing?: number;
+};
 /**
- * The shaping library and its exact version.
- *
- * Versioned because a library upgrade can change glyph positioning, and a cached measurement
- * taken under the old one must not be reused under the new one.
+ * `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.
  */
-interface VersionedShapingLibrary {
-    readonly name: string;
-    readonly version: string;
-}
+declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
 /**
- * Everything that determines how text shapes — the complete input to a
- * {@link ShapingEnvironment}.
+ * Resolve `w:pBdr` from the paragraph-properties node.
  *
- * 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.
+ * Nested — every edge is a child of `pBdr`, not an attribute — so this reads the typed tree
+ * rather than the flattened `OoxmlProperty[]` bag `propertiesOf` builds for leaf props.
  */
-interface 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 paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
 /**
- * A validated {@link ShapingEnvironmentInput} — build one with `createShapingEnvironment`.
+ * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
  *
- * 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 does not merge edges across the cascade. A style that states only `w:bottom` discards
+ * the box its `basedOn` ancestor declared, so folding edge by edge would leave a lone
+ * underline surrounded by a box no one authored. Absence inherits; `nil`/`none` clear.
  */
-interface ShapingEnvironment extends ShapingEnvironmentInput {
-}
-/** One shaping call: the text, its size, its bidi level, and the environment to shape it in. */
-interface ShapeInput {
-    readonly text: string;
-    readonly fontSizeHalfPoints: number;
-    /** Exact UAX #9 embedding/isolate level; direction is its parity projection. */
-    readonly bidiLevel: number;
-    readonly environment: ShapingEnvironment;
-    /**
-     * Logical text around `text` that the shaper reads for contextual forms but never
-     * shapes: HarfBuzz pre- and post-context. A word split across two formatting runs joins
-     * across the split only when each half sees the other's letters. At most
-     * {@link MAX_SHAPING_CONTEXT} UTF-16 units each; glyphs and clusters cover `text` alone.
-     */
-    readonly context?: ShapingContext;
-}
-/** Pre- and post-context for one shaping call. See {@link ShapeInput.context}. @public */
-interface ShapingContext {
-    readonly before: string;
-    readonly after: string;
-}
-/** Longest context on either side, in UTF-16 units. Joining needs only the nearest letters. @public */
-declare const MAX_SHAPING_CONTEXT = 16;
+declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
 /**
- * One positioned glyph.
+ * Visual stroke thickness layout publishes for one edge (points).
  *
- * `id` is a glyph index in its FACE, not a character — a ligature is one glyph spanning several
- * characters, and a single character may produce several glyphs. Use `cluster` to get back to
- * text.
+ * 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 ShapedGlyph {
-    readonly id: number;
-    /** Optional synthetic glyph-size factor; positions and advances already include it. */
-    readonly drawScale?: number;
-    /** UTF-16 text offset identifying the cluster that produced this glyph. */
-    readonly cluster: number;
-    /** Pen origin before this glyph's shaping offsets, in fixed-point run coordinates. */
-    readonly originX: FixedPoint;
-    readonly originY: FixedPoint;
-    readonly advanceX: FixedPoint;
-    readonly advanceY: FixedPoint;
-    readonly offsetX: FixedPoint;
-    readonly offsetY: FixedPoint;
-    /** Exact monochrome outline returned by the admitted HarfBuzz face. */
-    readonly outline: GlyphOutline;
-}
-/** A glyph's outline as SVG path data, in font design units. */
-interface GlyphOutline {
-    readonly path: string;
-    /** Design units per em — divide by this to scale the path to a point size. */
-    readonly unitsPerEm: number;
-}
+declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
 /**
- * One cluster: the smallest indivisible text-to-glyph correspondence.
+ * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
  *
- * 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.
+ * 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 ShapedCluster {
-    /** Half-open logical UTF-16 range in ShapedRun.text. */
-    readonly textStart: number;
-    readonly textEnd: number;
-    /** Half-open visual glyph range in ShapedRun.glyphs. */
-    readonly glyphStart: number;
-    readonly glyphEnd: number;
-    readonly advance: FixedPoint;
-    /** Fixed-point edges from this cluster's visual origin, including both endpoints. */
-    readonly caretEdges: readonly FixedPoint[];
-    /** Index into ShapedRun.fontSpans, preserving the exact fallback choice. */
-    readonly fontSpan: number;
-}
-/** A run's vertical metrics, from the face that shaped it. Drives line height and baseline. */
-interface ShapedVerticalMetrics {
-    readonly ascent: FixedPoint;
-    readonly descent: FixedPoint;
-    readonly lineGap: FixedPoint;
-}
+declare function 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 stretch of glyphs that came from ONE face.
+ * Identity of a paragraph's border set, for the `w:between` group rule.
  *
- * 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.
+ * 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 ShapedFontSpan {
-    readonly glyphStart: number;
-    readonly glyphEnd: number;
-    readonly font: ResolvedFont;
-    /** null denotes the primary font; otherwise this is the environment fallback-order index. */
-    readonly fallbackIndex: number | null;
-}
+declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
 /**
- * One shaped run: text turned into positioned glyphs, with everything needed to measure it, paint
- * it, and put a caret in it.
- *
- * The engine's measurement unit. Layout never measures characters — it measures these.
+ * 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.
  */
-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[];
-}
+declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
 /**
- * A {@link ShapedRun} reduced to the fields two shaping results must agree on to be considered
- * identical.
+ * Applied before-spacing for placement (Word 2013+ / compat mode 15).
  *
- * 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.
+ * Adjacent before/after still collapse to the larger gap, but before is dropped entirely when
+ * the paragraph naturally moves to the top of a page mid-section. An explicit page-break-before
+ * paragraph, or the first paragraph of a document/section, retains before. Callers publish this
+ * applied value on the fragment so shading, borders,
+ * selection, and paint share one geometry.
  */
-interface 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;
-}
+declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, preserveAtPageStart: boolean): number;
+
 /**
- * The one thing layout needs from a shaping backend.
+ * The four physical sides of `CT_PageBorders`.
  *
- * 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.
+ * Four, not the six of `w:pBdr`: `w:between` and `w:bar` are paragraph-group rules and the
+ * page has no analogue for either.
  */
-interface TextShaper {
-    shape(input: ShapeInput): ShapedRun;
-}
+declare const PAGE_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right'];
+/** Which of the four page-frame edges. */
+type PageBorderSide = (typeof PAGE_BORDER_SIDES)[number];
 /**
- * A font reduced to the values that identify it for fingerprinting.
+ * `w:offsetFrom` (`ST_PgBorderOffset`) — what `w:space` on each edge is measured from.
  *
- * Includes the content `hash` and `faceIndex`, so two faces with the same family name but
- * different bytes fingerprint differently — which is what stops a cached measurement being reused
- * against a substituted face.
- */
-interface FontFingerprintInputs {
-    readonly identity: string;
-    readonly id: string;
-    readonly family: string;
-    readonly request: FontRequest;
-    readonly hash: string;
-    readonly faceIndex: number;
-    readonly byteLength: number;
-    readonly substitution: FontSubstitution | null;
-}
+ * 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';
 /**
- * A {@link ShapingEnvironment} reduced to comparable values.
+ * One section's resolved `w:pgBorders`.
  *
- * 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.
+ * 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 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;
+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;
 }
 /**
- * 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.
+ * Parse `w:pgBorders` off one `w:sectPr`.
  *
- * @throws TypeError on a malformed tag, name, or axis value.
+ * 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 const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
+declare function parsePageBorders(sectPr: OoxmlNode): SectionPageBorders | undefined;
 /**
- * Reduce an environment to its comparable form, with records sorted so key order cannot affect
- * the result.
+ * 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 const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
-/** Canonical serialization of every shaping variable, including byte hash and provenance. */
-declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
+declare function pageBordersFingerprint(borders: SectionPageBorders | undefined): string;
+
 /**
- * Validate and freeze a shaped run against the environment that produced it.
+ * 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;
+    /**
+     * Authored page-number type. Absent when `w:pgNumType` is missing; empty object when the
+     * element is present with no attributes (comprehensive-fixture shape).
+     */
+    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;
+}
+/**
+ * One section of the body story: contiguous top-level blocks plus the properties that end 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.
+ * `blockStart` / `blockEndExclusive` index into `storyBlocks(part)`.
+ */
+interface DocumentSection {
+    readonly index: number;
+    readonly properties: SectionProperties;
+    readonly blockStart: number;
+    readonly blockEndExclusive: 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.
  *
- * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
+ * 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 const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
+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;
 /**
- * Reduce a shaped run to its comparable form, validating it on the way through.
+ * The section properties a part declares, or Word's defaults where it says nothing.
  *
- * What the D9 determinism oracles compare: two shaping runs of the same text in the same
- * environment must produce byte-identical structures here.
+ * 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 const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
-
+declare function readSectionProperties(part: OoxmlPart): SectionProperties;
 /**
- * Whether a paragraph must start a new page (`w:pageBreakBefore`).
+ * Split the body story into sections.
  *
- * LAST WINS, like every other toggle read off the cascade (`paragraphKeeps` does the same
- * for `w:keepNext`). An any-wins `.some()` cannot be switched off: a Chapter or Heading style
- * carries `w:pageBreakBefore`, and Word writes `w:val="0"` on the one instance whose author
- * unchecked the box — that paragraph still broke, so the document grew a blank page and every
- * page number after it was wrong.
+ * A 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.
  *
- * 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.
+ * 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 paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
+declare function enumerateDocumentSections(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): DocumentSection[];
 /**
- * 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.
+ * 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 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;
+declare function projectedSectionSourceIndexes(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): readonly number[];
 /**
- * A paragraph's resolved space before and after, in points.
+ * Every section in a document, with a flag saying whether the list was cut short.
  *
- * 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.
+ * `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 ParagraphSpacing {
-    /** `w:spacing/@before`, in points. */
-    readonly before: number;
-    /** `w:spacing/@after`, in points. */
-    readonly after: number;
+interface DocumentSectionsEnumeration {
+    readonly sections: DocumentSection[];
+    /** True when paragraph-level sectPr marks beyond {@link MAX_DOCUMENT_SECTIONS} were dropped. */
+    readonly truncated: boolean;
 }
 /**
- * The gap Word substitutes when `w:beforeAutospacing` / `w:afterAutospacing` is on
- * (ECMA-376 §17.3.1.33, the `w:spacing` clause both attributes belong to).
- *
- * The attribute means "the consumer decides", and the authored `@before` / `@after` beside it
- * is IGNORED rather than used as the value. Word's answer is HTML's default `<p>` margin,
- * 14pt, which is what a document round-tripped through Word's HTML filter carries — and this
- * one is everywhere, because Word writes `w:before="100" w:beforeAutospacing="1"` for it. Reading
- * only the literal 100 twips lays every such paragraph out 9pt tight, which moves page breaks.
+ * 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 const AUTO_PARAGRAPH_SPACING_PT = 14;
+declare function enumerateDocumentSectionsBounded(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): DocumentSectionsEnumeration;
 /**
- * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
- * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
+ * Section properties as the geometry layout paginates against.
  *
- * 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.
+ * 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.
  *
- * 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/`.
+ * 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 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 function geometryOfSection(section: SectionProperties): PageGeometry;
+
 /**
- * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
- *
- * `auto` is the interesting one: `@line` is 240ths of a line, so 240 is single, 360 is
- * one-and-a-half, 480 is double — and Word's own Normal style since 2013 is 259, i.e.
- * 1.08. A document laid out at a flat single spacing is ~8% tight on EVERY line, which
- * moves every page break, so this is not a cosmetic detail.
- *
- * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
- * does. `atLeast` uses it as a floor.
+ * `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 LineSpacingRule = 'auto' | 'exact' | 'atLeast';
+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';
 /**
- * Resolved line spacing: the rule, and the value it applies.
+ * `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.
  *
- * `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.
+ * 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 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 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;
+    };
 }
-/** 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.
+ * One `w:numPicBullet`: the image a level draws instead of its `w:lvlText`.
  *
- * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
- * unbounded border width becomes a layout dimension.
+ * `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 ParagraphBorderEdge {
-    /** Authored `ST_Border` value (`single`, `dashed`, …). */
-    readonly val: string;
-    /** RRGGBB, or null when auto/missing (paint defaults to black). */
-    readonly color: string | null;
-    /** Border thickness in points (`w:sz` is eighths of a point). */
-    readonly widthPt: number;
-    /** Gap from text to the rule, in points (`w:space`). */
-    readonly spacePt: number;
-    /**
-     * `w:shadow` — Word offsets a drop shadow behind the rule.
-     *
-     * Present only when authored true, so an edge that says nothing keeps the shape earlier
-     * fixtures assert. Resolved and carried; drawing it is deferred.
-     */
-    readonly shadow?: true;
+interface 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;
 }
-/** The six `CT_PBdr` children, in schema order (ECMA-376 §17.3.1.24). */
-declare const PARAGRAPH_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right', 'between', 'bar'];
 /**
- * Which of the six `CT_PBdr` edges.
+ * A level's picture bullet with the size it is actually DRAWN at.
  *
- * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
- * consecutive paragraphs share a border definition.
- */
-type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
+ * Separate from {@link NumberingPictureBullet} because the authored `v:shape` extent is not
+ * the painted extent: Word scales it by the marker run's font size. Layout, hit testing and
+ * both paint sinks read `width` / `height`; `authored` is kept so the scale stays inspectable.
+ * @public
+ */
+interface ResolvedPictureBullet {
+    /** `v:imagedata/@r:id`, relative to the NUMBERING part's relationships. */
+    readonly relationshipId: string;
+    /** Painted width in points, after the marker font scale. */
+    readonly width: number;
+    /** Painted height in points, after the marker font scale. */
+    readonly height: number;
+    /** The `v:shape` extent exactly as the file authored it. */
+    readonly authored: NumberingPictureBullet;
+}
+
+/** Soft ceiling on abstractNum / num entries read from one part. */
+declare const MAX_NUMBERING_DEFINITIONS = 512;
+/** Soft ceiling on override entries per `w:num`. */
+declare const MAX_LVL_OVERRIDES = 9;
+/** `w:suff` — what separates a list marker from the text after it. */
+type ListSuffix = 'tab' | 'space' | 'nothing';
+/** `w:lvlJc` — how a list marker aligns within its own indent. */
+type ListMarkerAlign = 'left' | 'center' | 'right';
+/**
+ * One level's indent, plus which parts the level actually AUTHORED.
+ *
+ * The provenance matters: `w:ind` cascades per-attribute, so a level that authored only `left`
+ * must not overwrite an inherited `hanging` with a synthesized zero.
+ */
+interface NumberingLevelIndent {
+    /**
+     * The sides as the level spells them, in points. `left` and `start` both name the leading
+     * indent, and `right` and `end` the trailing one; `left`/`right` below hold those two.
+     */
+    readonly authored?: {
+        readonly left?: number;
+        readonly right?: number;
+        readonly start?: number;
+        readonly end?: number;
+    };
+    readonly left: number;
+    readonly right: number;
+    readonly hanging: number;
+    readonly firstLine: number;
+    /**
+     * Which of these the LEVEL actually authored.
+     *
+     * A level's `w:pPr/w:ind` sits between the formatting it outranks and the formatting that
+     * outranks it (`mergeListIndent`), so the merge has to tell "the level says left = 0" from
+     * "the level says nothing about left and the style's value stands". Absent (the default) reads as "says nothing", which is what a
+     * hand-built level in a test means.
+     */
+    readonly stated?: {
+        readonly left: boolean;
+        readonly right: boolean;
+        /** `w:hanging`/`w:firstLine` are one mutually exclusive slot (§17.3.1.10, §17.3.1.12). */
+        readonly firstLineOffset: boolean;
+    };
+}
+/** One `w:lvl`: how this depth numbers, what its marker looks like, and how it indents. */
+interface NumberingLevel {
+    readonly ilvl: number;
+    readonly start: number;
+    readonly numFmt: string;
+    readonly lvlText: string;
+    readonly lvlJc: ListMarkerAlign;
+    readonly suff: ListSuffix;
+    readonly indent: NumberingLevelIndent;
+    /**
+     * `w:lvlRestart` one-based trigger level, or `0` when the level never restarts.
+     * Omitted in XML → restart when the previous level (or any earlier level) is used.
+     */
+    readonly lvlRestart?: number;
+    /**
+     * `w:isLgl` (§17.9.9): render EVERY level referenced by this level's `w:lvlText` in
+     * decimal, whatever number format those levels declare for themselves.
+     */
+    readonly isLgl: boolean;
+    /**
+     * `w:lvlPicBulletId` (§17.9.12): this level's marker is the `w:numPicBullet` of that id,
+     * drawn INSTEAD of `w:lvlText`. Absent on every ordinary level.
+     */
+    readonly picBulletId?: string;
+    /** Level `w:rPr` as flat properties (for marker face / vanish). */
+    readonly runProperties: readonly OoxmlProperty[];
+    /** True when level run props request vanish — marker must not paint. */
+    readonly vanish: boolean;
+}
+/**
+ * One `w:lvlOverride` on a `w:num`: a restart value, a replacement level, or both.
+ *
+ * How two lists share an abstract definition while numbering independently.
+ */
+interface LevelOverride {
+    readonly startOverride?: number;
+    /** Full level replacement when `w:lvl` is present under the override. */
+    readonly level?: NumberingLevel;
+}
+/**
+ * One `w:abstractNum` — the shape of a list, without being a list.
+ *
+ * Never referenced by a paragraph directly. Paragraphs name a {@link NumDefinition}, which names
+ * one of these, so several lists can share a definition and still count separately.
+ */
+interface AbstractNumDefinition {
+    readonly abstractNumId: string;
+    readonly levels: ReadonlyMap<number, NumberingLevel>;
+    /**
+     * `w:numStyleLink` (§17.9.21): this definition carries no levels of its own — the numbering
+     * lives on the named style. Word follows the link; resolve it with
+     * {@link resolveNumberingStyleLinks} before reading levels, or every paragraph on this
+     * abstract renders with NO marker at all.
+     */
+    readonly numStyleLink?: string;
+    /**
+     * `w:styleLink` (§17.9.23): the definition side of the same pair — this abstract IS the
+     * numbering of the named style. Kept so a link can be verified rather than assumed.
+     */
+    readonly styleLink?: string;
+}
+/**
+ * One `w:num` — the thing a paragraph's `w:numId` actually names.
+ *
+ * Points at an {@link AbstractNumDefinition} and may override any of its levels.
+ */
+interface NumDefinition {
+    readonly numId: string;
+    readonly abstractNumId: string;
+    readonly overrides: ReadonlyMap<number, LevelOverride>;
+}
+/**
+ * The bounded projection of `numbering.xml` that list layout resolves against.
+ *
+ * Projection ONLY — never a mutation or serialization authority. Hostile values are dropped or
+ * clamped, and a missing definition resolves to "no list" rather than a guess.
+ */
+interface NumberingIndex {
+    readonly abstractNums: ReadonlyMap<string, AbstractNumDefinition>;
+    readonly nums: ReadonlyMap<string, NumDefinition>;
+    /**
+     * `w:numPicBullet` declarations keyed by `w:numPicBulletId` (§17.9.20).
+     *
+     * Optional so a hand-built index stays valid; absent reads as "this part declares none",
+     * which is what a level's `w:lvlPicBulletId` then falls back from.
+     */
+    readonly pictureBullets?: ReadonlyMap<string, NumberingPictureBullet>;
+}
+/**
+ * Build a numbering index from the root of a numbering part (`w:numbering`).
+ *
+ * Empty / missing roots yield an empty index. Duplicate ids keep the first definition.
+ */
+/**
+ * Project `numbering.xml` into the bounded index.
+ *
+ * Every ceiling here exists because the input is file-derived: definition counts, override
+ * counts, indent magnitudes and style-link hop depth are all capped, and nothing from the file
+ * becomes a loop bound or an allocation size.
+ */
+declare function buildNumberingIndex(root: OoxmlElement | null | undefined): NumberingIndex;
+/** Resolve the effective level for a `numId` + `ilvl`, applying overrides. */
+/**
+ * The effective level for one paragraph's numbering reference, after overrides and style links.
+ *
+ * Answers null for a reference the index cannot resolve — a paragraph naming a definition the
+ * file never declared is an unnumbered paragraph, not an error.
+ */
+declare function resolveNumberingLevel(index: NumberingIndex, numId: string, ilvl: number): {
+    readonly abstractNumId: string;
+    readonly level: NumberingLevel;
+    readonly startOverride?: number;
+} | null;
+/** Empty index for tests / documents without numbering. */
+declare const EMPTY_NUMBERING_INDEX: NumberingIndex;
+
+/**
+ * A face, as something asks for it: family plus the two axes this engine admits.
+ *
+ * Only static weights and slants. Variable-font axes are deliberately outside this vocabulary —
+ * the shaper refuses variation axes, and a variable file admitted here would render bold at
+ * regular weight.
+ */
+interface FontRequest {
+    readonly family: string;
+    readonly weight: number;
+    readonly style: 'normal' | 'italic';
+}
+/**
+ * A request that was answered by a DIFFERENT face than the one asked for.
+ *
+ * Recorded rather than silently applied, because a substitution changes measurement: it is part
+ * of the shaping fingerprint, so a cached run shaped against a substitute is never reused for the
+ * real face.
+ */
+interface FontSubstitution {
+    readonly requested: FontRequest;
+    readonly resolved: FontRequest;
+    readonly lineMetrics?: {
+        readonly heightEm: number;
+        readonly baselineEm: number;
+    };
+}
+declare const RESOLVED_FONT_BRAND: unique symbol;
+/**
+ * A face that passed admission: the bytes are present, within limits, hash-verified, and parse as
+ * a font.
+ *
+ * Branded, so a `ResolvedFont` cannot be constructed by an object literal. Holding one is proof
+ * the checks ran — which is what lets shaping skip re-validating on every call.
+ */
+interface ResolvedFont {
+    readonly [RESOLVED_FONT_BRAND]: true;
+    readonly id: string;
+    readonly identity: string;
+    readonly request: FontRequest;
+    readonly family: string;
+    /** Owned byte length, available without creating a defensive byte copy. */
+    readonly byteLength: number;
+    readonly bytes: Uint8Array;
+    readonly hash: string;
+    readonly faceIndex: number;
+    readonly substitution: FontSubstitution | null;
+}
+/**
+ * Largest single face this engine will ever admit, whatever a caller configures.
+ *
+ * A CEILING, not a default: a host may set a smaller `maxFontBytes`, but nothing can raise it
+ * past this. Font bytes come from files, and an unbounded face is a memory-exhaustion vector.
+ */
+declare const HARD_MAX_FONT_BYTES: number;
+/** Most faces one snapshot may hold, whatever a caller configures. */
+declare const HARD_MAX_FONT_SOURCES = 256;
+/** Most bytes all admitted faces may total, whatever a caller configures. */
+declare const HARD_MAX_AGGREGATE_FONT_BYTES: number;
+/**
+ * Why a face was not admitted.
+ *
+ * `forbidden` and `hashMismatch` are adversarial signals rather than ordinary failures: the first
+ * is a face the host declared off-limits, the second is bytes that are not what their source
+ * claimed.
+ */
+type FontResolutionErrorCode = 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch';
+/**
+ * A face that could not be admitted, carrying whatever evidence the refusal produced.
+ *
+ * RETURNED rather than thrown by `FontResourceSnapshot.resolve`, because a missing face is an
+ * ordinary condition — layout falls back and carries on. It extends `Error` so a caller that
+ * would rather throw can.
+ */
+declare class FontResolutionError extends Error {
+    readonly name = "FontResolutionError";
+    readonly request: FontRequest;
+    readonly code: FontResolutionErrorCode;
+    readonly limit?: number;
+    readonly actual?: number;
+    readonly diagnostic?: string;
+    readonly expectedHash?: string;
+    readonly actualHash?: string;
+    constructor(code: FontResolutionErrorCode, request: FontRequest, details?: {
+        readonly limit?: number;
+        readonly actual?: number;
+        readonly diagnostic?: string;
+        readonly expectedHash?: string;
+        readonly actualHash?: string;
+    });
+}
+/**
+ * One face offered to a snapshot, before admission.
+ *
+ * `hash` is checked against the bytes, so a source cannot claim a face it did not supply. Setting
+ * `availability` to `forbidden` declares a face that exists but must not be used, which resolves
+ * as a typed refusal rather than as "missing".
+ */
+interface FontResourceDefinition {
+    readonly request: FontRequest;
+    readonly id: string;
+    readonly bytes: Uint8Array;
+    readonly hash: string;
+    readonly faceIndex: number;
+    readonly availability?: 'available' | 'forbidden';
+}
+/**
+ * A host-declared redirect: requests for `from` resolve to `to`.
+ *
+ * How a metric-compatible substitute is wired in — a document naming Calibri resolves to Carlito
+ * without the document being rewritten.
+ */
+interface DeclaredFontSubstitution {
+    readonly from: FontRequest;
+    readonly to: FontRequest;
+    readonly lineMetrics?: {
+        readonly heightEm: number;
+        readonly baselineEm: number;
+    };
+}
+/** Whether bytes parse as a usable font, with a diagnostic when they do not. */
+type FontValidationResult = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+    readonly diagnostic: string;
+};
+/**
+ * The injected check that bytes really are a font.
+ *
+ * Injected because it is the shaper that knows — HarfBuzz can open a face and read its tables,
+ * and this layer must not duplicate that judgement. Every byte reaching it is file input.
+ */
+type FontByteValidator = (bytes: Uint8Array, faceIndex: number) => FontValidationResult;
+/**
+ * An immutable set of admitted faces, and the only way to reach one.
+ *
+ * `epoch` identifies the snapshot: fonts change by REPLACING it, never by mutation, so a layout
+ * pass holds one snapshot for its whole run and cannot observe a face appearing or vanishing
+ * midway.
+ */
+interface FontResourceSnapshot {
+    readonly epoch: number;
+    /** The admitted face, or a typed refusal. Never throws. */
+    resolve(request: FontRequest): ResolvedFont | FontResolutionError;
+}
 /**
- * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
+ * How a snapshot is built: which faces, under what limits, validated how.
  *
- * `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.
+ * `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 ParagraphBorders {
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-    readonly between?: ParagraphBorderEdge;
-    readonly bar?: ParagraphBorderEdge;
+interface FontResourceSnapshotOptions {
+    readonly epoch: number;
+    readonly maxFontBytes: number;
+    readonly resources: readonly FontResourceDefinition[];
+    readonly substitutions?: readonly DeclaredFontSubstitution[];
+    readonly validateFont: FontByteValidator;
+    readonly instrumentation?: FontResourceInstrumentation;
 }
 /**
- * Resolve `w:spacing` before/after from flat paragraph properties.
+ * 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.
+ */
+interface FontResourceInstrumentation {
+    readonly onOwnedByteCopy?: () => void;
+    readonly onHash?: () => void;
+    readonly onTableScan?: () => void;
+    readonly onAdmission?: () => void;
+}
+/**
+ * The canonical string identifying one face request.
  *
- * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
- * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
+ * Case- and whitespace-normalized, so `"Times New Roman"` and `"times new roman"` are one key —
+ * a document may name a family either way and both must reach the same face.
  */
-declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
+declare const fontRequestKey: (request: FontRequest) => string;
+/** Bounded minimum sfnt/TTC check; Task 4 supplies full parser-backed validation. */
+declare const boundedStructuralFontValidator: FontByteValidator;
 /**
- * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
+ * Admit a set of faces and return the immutable snapshot layout resolves against.
  *
- * 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.
+ * Admission is the trust boundary for font bytes: counts and sizes are checked against the hard
+ * ceilings, each face's hash is re-derived and compared, and the bytes are handed to the injected
+ * validator. A face failing any of these is recorded as a typed refusal rather than dropped, so
+ * `resolve` can explain itself instead of answering "missing".
  */
-declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
+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;
+};
 /**
- * Apply resolved line spacing to a line's natural (glyph-derived) box.
+ * Brand a safe integer as a {@link FixedPoint} coordinate.
  *
- * `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".
+ * 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.
  *
- * `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/`.
+ * @throws RangeError when the value is not a safe integer.
+ */
+declare const fixedPoint: (value: number) => FixedPoint;
+/** Which way a run reads. The parity projection of its bidi embedding level. */
+type TextDirection = 'ltr' | 'rtl';
+/** How fixed-point conversion breaks ties. Part of the shaping fingerprint. */
+type FixedPointRoundingMode = 'halfAwayFromZero' | 'halfToEven' | 'towardZero';
+/** Which Unicode normalization is applied before shaping, if any. */
+type NormalizationPolicy = 'none' | 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
+/**
+ * The shaping library and its exact version.
  *
- * Exact-height boxes place their baseline at 80% of the height; the legacy
- * noExtraLineSpacing switch instead preserves the face baseline within the box.
+ * Versioned because a library upgrade can change glyph positioning, and a cached measurement
+ * taken under the old one must not be reused under the new one.
+ */
+interface VersionedShapingLibrary {
+    readonly name: string;
+    readonly version: string;
+}
+/**
+ * Everything that determines how text shapes — the complete input to a
+ * {@link ShapingEnvironment}.
  *
- * An `auto` line of a snapping paragraph under an active line grid takes whole pitches
- * instead ({@link gridLineBox}); `trailing` then names the extra below the grid line.
+ * Exhaustive on purpose. Any field that could change a glyph's position belongs here, because the
+ * environment's fingerprint is what decides whether a cached shaped run may be reused.
  */
-declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
-    height: number;
-    baseline: number;
-    trailing?: 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;
+}
 /**
- * `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.
+ * 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.
  */
-declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
+interface ShapingEnvironment extends ShapingEnvironmentInput {
+}
+/** One shaping call: the text, its size, its bidi level, and the environment to shape it in. */
+interface ShapeInput {
+    readonly text: string;
+    readonly fontSizeHalfPoints: number;
+    /** Exact UAX #9 embedding/isolate level; direction is its parity projection. */
+    readonly bidiLevel: number;
+    readonly environment: ShapingEnvironment;
+    /**
+     * Logical text around `text` that the shaper reads for contextual forms but never
+     * shapes: HarfBuzz pre- and post-context. A word split across two formatting runs joins
+     * across the split only when each half sees the other's letters. At most
+     * {@link MAX_SHAPING_CONTEXT} UTF-16 units each; glyphs and clusters cover `text` alone.
+     */
+    readonly context?: ShapingContext;
+}
+/** Pre- and post-context for one shaping call. See {@link ShapeInput.context}. @public */
+interface ShapingContext {
+    readonly before: string;
+    readonly after: string;
+}
+/** Longest context on either side, in UTF-16 units. Joining needs only the nearest letters. @public */
+declare const MAX_SHAPING_CONTEXT = 16;
+/**
+ * One positioned glyph.
+ *
+ * `id` is a glyph index in its FACE, not a character — a ligature is one glyph spanning several
+ * characters, and a single character may produce several glyphs. Use `cluster` to get back to
+ * text.
+ */
+interface ShapedGlyph {
+    readonly id: number;
+    /** Optional synthetic glyph-size factor; positions and advances already include it. */
+    readonly drawScale?: number;
+    /** UTF-16 text offset identifying the cluster that produced this glyph. */
+    readonly cluster: number;
+    /** Pen origin before this glyph's shaping offsets, in fixed-point run coordinates. */
+    readonly originX: FixedPoint;
+    readonly originY: FixedPoint;
+    readonly advanceX: FixedPoint;
+    readonly advanceY: FixedPoint;
+    readonly offsetX: FixedPoint;
+    readonly offsetY: FixedPoint;
+    /** Exact monochrome outline returned by the admitted HarfBuzz face. */
+    readonly outline: GlyphOutline;
+}
+/** A glyph's outline as SVG path data, in font design units. */
+interface GlyphOutline {
+    readonly path: string;
+    /** Design units per em — divide by this to scale the path to a point size. */
+    readonly unitsPerEm: number;
+}
+/**
+ * One cluster: the smallest indivisible text-to-glyph correspondence.
+ *
+ * The unit the CARET moves by. A cluster may be several characters (a ligature) or several glyphs
+ * (a decomposed mark), so neither a character index nor a glyph index is a valid caret position —
+ * `caretEdges` is, and it includes both endpoints.
+ */
+interface ShapedCluster {
+    /** Half-open logical UTF-16 range in ShapedRun.text. */
+    readonly textStart: number;
+    readonly textEnd: number;
+    /** Half-open visual glyph range in ShapedRun.glyphs. */
+    readonly glyphStart: number;
+    readonly glyphEnd: number;
+    readonly advance: FixedPoint;
+    /** Fixed-point edges from this cluster's visual origin, including both endpoints. */
+    readonly caretEdges: readonly FixedPoint[];
+    /** Index into ShapedRun.fontSpans, preserving the exact fallback choice. */
+    readonly fontSpan: number;
+}
+/** A run's vertical metrics, from the face that shaped it. Drives line height and baseline. */
+interface ShapedVerticalMetrics {
+    readonly ascent: FixedPoint;
+    readonly descent: FixedPoint;
+    readonly lineGap: FixedPoint;
+}
+/**
+ * A stretch of glyphs that came from ONE face.
+ *
+ * A run whose text needed fallback has several of these. Recording the exact face per span is
+ * what lets a re-shape reproduce the same result rather than re-running fallback selection and
+ * possibly choosing differently.
+ */
+interface ShapedFontSpan {
+    readonly glyphStart: number;
+    readonly glyphEnd: number;
+    readonly font: ResolvedFont;
+    /** null denotes the primary font; otherwise this is the environment fallback-order index. */
+    readonly fallbackIndex: number | null;
+}
+/**
+ * One shaped run: text turned into positioned glyphs, with everything needed to measure it, paint
+ * it, and put a caret in it.
+ *
+ * The engine's measurement unit. Layout never measures characters — it measures these.
+ */
+interface ShapedRun {
+    readonly text: string;
+    readonly direction: TextDirection;
+    readonly bidiLevel: number;
+    readonly glyphs: readonly ShapedGlyph[];
+    readonly clusters: readonly ShapedCluster[];
+    readonly fontSpans: readonly ShapedFontSpan[];
+    readonly metrics: ShapedVerticalMetrics;
+    /**
+     * The same horizontal advances as `glyphs[i].advanceX`, in the same fixed-point units, but
+     * BEFORE the per-glyph rounding to the fixed-point grid. Parallel to `glyphs`.
+     *
+     * Measurement and line breaking read `advanceX` and must keep doing so: pagination is decided
+     * on those numbers, and two runs shaped identically have to compare equal. A painter that
+     * gives every glyph its own absolute position sums the advances instead, and a sum of ROUNDED
+     * advances drifts by up to half a fixed-point unit per glyph — an error that only grows along
+     * a line. Summing these and rounding once, at the position actually written, does not.
+     *
+     * Absent on runs an assembly path cannot state exactly; a reader falls back to `originX`.
+     */
+    readonly exactAdvancesX?: readonly number[];
+}
 /**
- * Resolve `w:pBdr` from the paragraph-properties node.
+ * A {@link ShapedRun} reduced to the fields two shaping results must agree on to be considered
+ * identical.
  *
- * 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.
+ * 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 paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+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:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
+ * The one thing layout needs from a shaping backend.
  *
- * 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.
+ * 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 cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
+interface TextShaper {
+    shape(input: ShapeInput): ShapedRun;
+}
 /**
- * Visual stroke thickness layout publishes for one edge (points).
+ * A font reduced to the values that identify it for fingerprinting.
  *
- * 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.
+ * 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 paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+interface FontFingerprintInputs {
+    readonly identity: string;
+    readonly id: string;
+    readonly family: string;
+    readonly request: FontRequest;
+    readonly hash: string;
+    readonly faceIndex: number;
+    readonly byteLength: number;
+    readonly substitution: FontSubstitution | null;
+}
 /**
- * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
+ * A {@link ShapingEnvironment} reduced to comparable values.
  *
- * 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.
+ * 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 paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
-/** Vertical extent a bottom border adds below the last line (gap + rule). */
-declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+interface 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;
+}
 /**
- * Identity of a paragraph's border set, for the `w:between` group rule.
+ * Validate and freeze a shaping environment.
  *
- * 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 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.
  *
- * Empty string means "no borders", which never groups with anything.
+ * @throws TypeError on a malformed tag, name, or axis value.
  */
-declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
+declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
 /**
- * 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.
+ * Reduce an environment to its comparable form, with records sorted so key order cannot affect
+ * the result.
  */
-declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+declare const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
+/** Canonical serialization of every shaping variable, including byte hash and provenance. */
+declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
 /**
- * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ * Validate and freeze a shaped run against the environment that produced it.
  *
- * 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.
+ * Checks the internal consistency a shaper must satisfy: direction matches the environment,
+ * cluster ranges tile the text without gaps or overlap, glyph ranges stay in bounds, font spans
+ * cover every glyph, and caret edges are monotonic. A shaper that violates any of these produces
+ * a caret that lands in the wrong place, which is far harder to diagnose downstream than here.
+ *
+ * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
  */
-declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, preserveAtPageStart: boolean): number;
+declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
+/**
+ * Reduce a shaped run to its comparable form, validating it on the way through.
+ *
+ * What the D9 determinism oracles compare: two shaping runs of the same text in the same
+ * environment must produce byte-identical structures here.
+ */
+declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
 
 /** `w:vertAlign` — script position, which also scales the run's effective size. */
 type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
@@ -1130,6 +1613,8 @@ interface ThemeFonts {
     /** Language-specific theme faces, keyed by ISO 15924 script. */
     readonly majorSupplemental?: Readonly<Record<string, string>>;
     readonly minorSupplemental?: Readonly<Record<string, string>>;
+    /** Lower-cased font table names that declare a Chinese character set. */
+    readonly chineseFontTableFaces?: readonly string[];
 }
 /**
  * Resolve one run's direct formatting.
@@ -1195,6 +1680,29 @@ interface StoryPageFieldNeeds {
     readonly hasPageParity?: boolean;
 }
 
+interface DrawingPoint {
+    readonly x: number;
+    readonly y: number;
+}
+interface DrawingInsets {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+type DrawingClipFallback = 'none' | 'unsupported-preset';
+interface DrawingGeometry {
+    readonly contentBounds: LayoutBox;
+    readonly paintBounds: LayoutBox;
+    readonly hitBounds: LayoutBox;
+    readonly transformedCorners: readonly DrawingPoint[];
+    /** Unclipped image corners for affine encoding; clipping must not stretch the image. */
+    readonly imageTransformCorners?: readonly DrawingPoint[];
+    readonly clipPolygon: readonly DrawingPoint[] | null;
+    readonly clipFallback: DrawingClipFallback;
+    readonly effectInsets: DrawingInsets;
+}
+
 /**
  * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
  * within.
@@ -1443,6 +1951,17 @@ interface FieldAtomMarker {
      * first fragment, gated per field on the calibration verdict.
      */
     readonly pageRef?: PageRefFieldProjection;
+    /**
+     * The first model offset of the editable saved result this piece belongs to.
+     *
+     * Present only when saved results are laid out as text (`fieldResults: 'editable'`). The
+     * result is ordinary text then, so its pieces have their own offsets; every piece of one
+     * result shares this value, which keeps a multi-run link result one anchor and lets the
+     * caret find the whole result it is in.
+     */
+    readonly resultStart?: number;
+    /** The model offset just past the same result, beside {@link resultStart}. */
+    readonly resultEnd?: number;
 }
 /** A half-open model-offset range, in the paragraph's own UTF-16 offset space. */
 interface ModelRange {
@@ -1600,29 +2119,6 @@ interface CjkTypographySettings {
     readonly after: Readonly<Record<string, string>>;
 }
 
-interface DrawingPoint {
-    readonly x: number;
-    readonly y: number;
-}
-interface DrawingInsets {
-    readonly top: number;
-    readonly right: number;
-    readonly bottom: number;
-    readonly left: number;
-}
-type DrawingClipFallback = 'none' | 'unsupported-preset';
-interface DrawingGeometry {
-    readonly contentBounds: LayoutBox;
-    readonly paintBounds: LayoutBox;
-    readonly hitBounds: LayoutBox;
-    readonly transformedCorners: readonly DrawingPoint[];
-    /** Unclipped image corners for affine encoding; clipping must not stretch the image. */
-    readonly imageTransformCorners?: readonly DrawingPoint[];
-    readonly clipPolygon: readonly DrawingPoint[] | null;
-    readonly clipFallback: DrawingClipFallback;
-    readonly effectInsets: DrawingInsets;
-}
-
 /** Test-only mutable counters; omitted by production call sites. Not package-public. */
 interface TableBorderGridResolveWork {
     /** Sparse intervals emitted (not dense column slots). */
@@ -1639,9 +2135,8 @@ type TableBorderSideName = 'top' | 'right' | 'bottom' | 'left';
 /**
  * One border edge in one of three states.
  *
- * Omitted edges inherit. Explicit no-border edges suppress inherited rules; a directly
- * authored opposing edge can still win. This matches the saved Word sample's mixed and
- * borderless tables, including cells authored with `w:val="none"`.
+ * Omitted edges inherit. Explicit no-border edges suppress their own inherited rule.
+ * An opposing edge can still win, including a rule inherited by the neighboring cell.
  */
 type TableBorderSide = {
     readonly state: 'omitted';
@@ -1755,6 +2250,8 @@ interface BorderGridCell {
     readonly borders: CellBorderBox;
     /** Set on restart cells that visually span into later rows. */
     readonly mergeRowSpan?: number;
+    /** The row's `w:tblPrEx` table borders, which replace the table's own for this cell. */
+    readonly rowTableBorders?: TableBorderBox;
 }
 /**
  * The absolute grid a table's borders are drawn on: column widths, and per-row tops and heights.
@@ -1829,8 +2326,13 @@ interface TextboxStoryLayout {
         x: number;
         y: number;
     }>;
-    /** Content box width (extent minus horizontal insets). */
+    /** Content box width (extent minus horizontal insets; the widest line when unwrapped). */
     readonly contentWidth: number;
+    /**
+     * Box width (points) that unwrapped text sizes its shape to: the widest line plus the
+     * insets. Placement resolves the shape at this width. Absent when the extent width holds.
+     */
+    readonly extentWidth?: number;
     /** Content box height (extent minus vertical insets). */
     readonly contentHeight: number;
     /** Solid fill of the hosting shape, painted behind the story; null for no fill. */
@@ -1855,6 +2357,21 @@ interface TextboxStoryLayout {
     readonly clippedResourceToken?: string;
 }
 
+/** One laid-out group member story. */
+interface GroupTextboxStoryRecord {
+    /** Canonical node id of the member `wps:wsp`. */
+    readonly memberNodeId: string;
+    /** The member box in points, relative to the drawing extent's top-left corner. */
+    readonly box: LayoutBox;
+    /** The member's story, in content-box coordinates inside {@link box}. */
+    readonly story: TextboxStoryLayout;
+    /**
+     * Clockwise turn of the painted member about the center of {@link box}, in degrees. The
+     * story lays out upright; paint and export turn it. Hit testing never maps into it.
+     */
+    readonly rotationDegrees: number;
+}
+
 /** Clip `box` to a horizontal content band; preserves authored size, zeroes clipped axes. */
 /** How a drawing record holds the picture member of a shape group. */
 interface DrawingGroupPictureRecord {
@@ -1927,6 +2444,8 @@ interface InlineDrawingRecord {
      * inline text box carries one too: its story sits inside the extent the line reserves.
      */
     readonly textboxStory?: TextboxStoryLayout;
+    /** Read-only stories of a group's text box members, each placed in its member box. */
+    readonly groupTextboxStories?: readonly GroupTextboxStoryRecord[];
 }
 interface InlineDrawingLayoutContext {
     readonly ownerPartName: string;
@@ -2051,12 +2570,7 @@ declare function withNumberingStyleLinks(index: NumberingIndex, styleCascade: St
  * in `direct`, and the defaults and that style's bases go in `inherited`.
  */
 declare function mergeListIndent(levelIndent: NumberingLevelIndent, inherited: readonly OoxmlProperty[], direct?: readonly OoxmlProperty[]): NumberingLevelIndent;
-/**
- * Collect paragraphs of a block list in document order, descending into tables.
- *
- * Caps nesting so a hostile nested-table document cannot recurse without bound.
- */
-declare function walkStoryParagraphs(blocks: readonly OoxmlElement[], maxTableDepth?: number): OoxmlElement[];
+
 /**
  * Resolve every list paragraph in a story to a {@link ResolvedListItem}, keyed by node id.
  *
@@ -2373,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 */
@@ -2519,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;
@@ -2758,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[];
@@ -2798,7 +3273,8 @@ interface LineRecord {
      * nothing, which is why the caret, paint's `padding-bottom` and the content-control
      * boundary all need this published rather than recovered from the box.
      *
-     * Zero under exact and atLeast, and on lines holding drawings (the box is authored).
+     * Zero under exact and atLeast. On a line holding drawings, only an auto multiple above
+     * single spacing sets it: the multiple's extra text band below the drawings.
      * Absent on lines published before this was measured; treat as zero.
      */
     readonly trailingSpacing?: number;
@@ -3455,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;
 }
 
 /**
@@ -3496,5 +3979,5 @@ interface TextMeasurer {
     };
 }
 
-export { PARAGRAPH_BORDER_SIDES as a$, AUTO_PARAGRAPH_SPACING_PT as a4, HARD_MAX_AGGREGATE_FONT_BYTES as aF, HARD_MAX_FONT_BYTES as aG, HARD_MAX_FONT_SOURCES as aH, MAX_BORDER_SPACE_PT as aN, MAX_BORDER_WIDTH_PT as aO, MAX_LVL_OVERRIDES as aP, MAX_NUMBERING_DEFINITIONS as aQ, MAX_PARAGRAPH_SPACING_PT as aR, MAX_SHAPING_CONTEXT as aS, MAX_STYLE_DEFINITIONS as aT, MAX_TABLE_BORDER_STROKES as aU, MAX_TAB_POSITION_TWIPS as aV, MAX_TAB_STOPS as aW, PAGE_BORDER_SIDES as a_, DEFAULT_RUN_STYLE as ae, DEFAULT_TAB_INTERVAL_PT as af, DEFAULT_TAB_INTERVAL_TWIPS as ag, EMPTY_NUMBERING_INDEX as al, EMPTY_TAB_STOPS as am, FontResolutionError as ax, boundedStructuralFontValidator as b$, TAB_LEADER_GLYPH as bI, UnsupportedScriptError as bT, appliedSpaceBefore as bV, applyLineSpacing as bW, baselineShiftPtOf as bX, borderExtentPt as bY, borderWeight as bZ, bottomBorderExtentPt as b_, SINGLE_LINE_SPACING as bo, buildNumberingIndex as c0, buildStyleCascadeTable as c1, cascadeParagraphFormatting as c2, cascadeRunProperties as c3, cascadedBottomBorder as c4, cascadedParagraphBorders as c5, cascadedTabStops as c6, collapsedSpaceBefore as c7, createFontResourceSnapshot as c8, createShapedRun as c9, readNumPr as cA, readTableBorders as cB, resolveBorderConflict as cC, resolveNumberingLevel as cD, resolveParagraphLayoutInputs as cE, resolveRunStyle as cF, resolveStoryListItems as cG, resolveStoryRefFields as cH, resolveTableCellBorderGrid as cI, runStylesEqual as cJ, shapedRunComparatorInputs as cK, shapingEnvironmentFingerprint as cL, shapingEnvironmentFingerprintInputs as cM, styleForFontSlot as cN, tabAdvanceWidth as cO, tabStopsFingerprint as cP, walkStoryParagraphs as cQ, withDefaultTabInterval as cR, withNumberingStyleLinks as cS, withResolvedListItems as cT, createShapingEnvironment as ca, defaultTabIntervalFromSettings as cb, displayText as cc, fixedPoint as cd, fontRequestKey as ce, glyphSizeFactorOf as cf, isValidStyleId as cg, itemizeScriptFontSlots as ch, layoutEquation as ci, measureDisplayText as cj, mergeListIndent as ck, nextTabDestination as cl, pageBordersFingerprint as cm, paragraphBorderExtentPt as cn, paragraphBorderStrokeWidthPt as co, paragraphBorders as cp, paragraphBordersFingerprint as cq, paragraphBreaksBefore as cr, paragraphContextualSpacing as cs, paragraphLineSpacing as ct, paragraphSpacing as cu, paragraphTabStops as cv, parsePageBorders as cw, parseRefInstruction as cx, readBorderSide as cy, readCellBorders as cz };
-export type { 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, TableCellStyleFormatting as J, TableFloatPosition as K, LineRecord as L, ModelRange as M, NoteAreaRecord as N, TableBorderBox 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, LevelOverride as aI, LineSpacingRule as aJ, ListMarkerAlign as aK, ListMarkerRecord as aL, ListSuffix as aM, NumDefinition as aX, NumberingLevelIndent as aY, NumberingPictureBullet as aZ, 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 b0, PageBorderOffsetFrom as b1, PageBorderSide as b2, PageBorderStrokeRecord as b3, PageBorderZOrder as b4, PageRefCalibrationCell as b5, PageRefFieldProjection as b6, ParagraphAutoSpacingContext as b7, ParagraphBorderEdge as b8, ParagraphBorderSide as b9, ShapedFontSpan as bA, ShapedGlyph as bB, ShapedRunComparatorInputs as bC, ShapedVerticalMetrics as bD, ShapingContext as bE, ShapingEnvironment as bF, ShapingEnvironmentFingerprintInputs as bG, StyleDefinition as bH, TabAlignment as bJ, TabDestination as bK, TabLeader as bL, TabStop as bM, TableBorderSideName as bN, TableBorderStrokeRecord as bO, TableFragmentRecord as bP, TextDirection as bQ, TextboxStoryFallbackReason as bR, TextboxStoryLayout as bS, VerticalAlign as bU, ParagraphBorders as ba, ParagraphBottomBorderRecord as bb, ParagraphIndent as bc, ParagraphLayoutInputs as bd, ParagraphLineSpacing as be, ParagraphSpacing as bf, RefFieldSpec as bg, RefNoteParts as bh, ResolvedCellBorders as bi, ResolvedPictureBullet as bj, ResolvedTabStops as bk, ResolvedTableBorderEdge as bl, ResolvedTableBorderEdgeSegment as bm, ResolvedUnderline as bn, ScriptItem as bp, SemanticArtifactRootStoryKind as bq, SemanticArtifactStoryKind as br, SemanticCommentArtifactRecord as bs, SemanticReviewArtifactOccurrence as bt, SemanticReviewArtifactOccurrenceGeometry as bu, SemanticReviewArtifactPosition as bv, SemanticReviewArtifactSource as bw, SemanticTrackedChangeArtifactRecord as bx, ShapeInput as by, ShapedCluster as bz, 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 };