@docx-editor.dev/core 2.28.0 → 2.30.0

package/dist/{semantic-records-4B3WwFAi.d.ts → semantic-records-CjcF26ZL.d.ts}

@@ -1,7 +1,244 @@
-import { o as RevisionAttribution, b as RevisionDisplayMode } from './revision-projection-DZ4kKVev.js';
-import { X as OoxmlProperty, Z as OoxmlElement, N as OoxmlNode, O as OoxmlPart, aJ as TableBorderStyle, aK as DrawingAccessibility, aL as DrawingImageEffects, al as SourceCrop, aM as DrawingTransform, aN as VectorShapeProjection, aw as DrawingHorizontalReferenceFrame, ax as DrawingVerticalReferenceFrame, an as ImageWrapTarget, a0 as DrawingProjection, aO as OoxmlDrawingNode } from './types-barrel-D3xCgQX6.js';
-import { b as ImageResourceState } from './image-resources-BN-hUgCn.js';
-import { O as OmmlEquationProjection } from './omml-equation-CuzBL5DD.js';
+import { N as OoxmlNode, am as OoxmlProperty, O as OoxmlPart, ah as OoxmlElement, aQ as TableBorderStyle, aR as DrawingAccessibility, aS as DrawingImageEffects, aJ as SourceCrop, aP as DrawingTransform, aT as VectorShapeProjection, X as DrawingHorizontalReferenceFrame, $ as DrawingVerticalReferenceFrame, a1 as ImageWrapTarget, al as DrawingProjection, aU as OoxmlDrawingNode } from './types-barrel-CA0xB8kH.js';
+import { I as ImageResourceState } from './image-resources-Bipz8toD.js';
+import { O as OmmlEquationProjection } from './omml-equation-DP2WpUbK.js';
+
+/** 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;
+}
+
+/**
+ * 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 RevisionKind = 'insert' | 'delete' | 'moveFrom' | 'moveTo' | 'format';
+/**
+ * One revision wrapper's provenance, as authored.
+ *
+ * `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 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;
+}
+/**
+ * Which revisions layout resolves before producing pages.
+ *
+ * - `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.
+ */
+type RevisionDisplayMode = 'all-markup' | 'proposed' | 'original';
+/**
+ * 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.
+ *
+ * `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.
+ */
+declare const DEFAULT_REVISION_DISPLAY_MODE: RevisionDisplayMode;
+/**
+ * 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.
+ *
+ * `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 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';
+    /**
+     * 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 resolvedMarkup?: 'plain';
+    readonly cacheKey: string;
+}
+/** @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;
+/**
+ * Whether content under this stack of revisions is laid out in the given mode.
+ *
+ * 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.
+ */
+declare function revisionsVisible(revisions: readonly RevisionAttribution[], mode: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): boolean;
+/**
+ * Every revision on a paragraph's own MARK, from `w:pPr/w:rPr/w:ins|w:del|w:moveFrom|w:moveTo`.
+ *
+ * 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.
+ */
+declare function paragraphMarkRevisionsOf(paragraph: OoxmlNode): readonly RevisionAttribution[];
+/**
+ * The tracked FORMAT change on a paragraph's own mark, from `w:pPr/w:rPr/w:rPrChange`.
+ *
+ * `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.
+ */
+declare function paragraphMarkFormatRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
+/**
+ * The single decision a one-field reader sees.
+ *
+ * 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.
+ */
+declare function shownMarkRevision(revisions: readonly RevisionAttribution[]): RevisionAttribution | undefined;
+/**
+ * Does this decision, taken, remove the paragraph mark?
+ *
+ * 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;
+/**
+ * The one decision on a paragraph's mark that a single-field reader sees.
+ *
+ * @deprecated Reads one of the revisions a mark can carry. Use {@link paragraphMarkRevisionsOf},
+ * which answers with all of them.
+ */
+declare function paragraphMarkRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
+/**
+ * The tracked FORMAT change on a property list, from `w:rPrChange` or `w:pPrChange`.
+ *
+ * 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 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 {
@@ -11,6 +248,518 @@ interface StrikeoutStrokePt {
     readonly thicknessPt: number;
 }
 
+/**
+ * Whether a paragraph must start a new page (`w:pageBreakBefore`).
+ *
+ * LAST WINS, like every other toggle read off the cascade (`paragraphKeeps` does the same
+ * for `w:keepNext`). An any-wins `.some()` cannot be switched off: a Chapter or Heading style
+ * carries `w:pageBreakBefore`, and Word writes `w:val="0"` on the one instance whose author
+ * unchecked the box — that paragraph still broke, so the document grew a blank page and every
+ * page number after it was wrong.
+ *
+ * An absent `w:val` is on (§17.17.4), and the off vocabulary is the whole of it — `off` is a
+ * spelling too, which {@link isOn} beside this already accepts.
+ */
+declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
+/**
+ * Soft ceiling matching the spike's resolved-style limit (31_680 twips ≈ 22"). Beyond
+ * that an attacker-authored spacing would push pagination into pathological page counts.
+ */
+declare const MAX_PARAGRAPH_SPACING_PT: number;
+/** Soft ceiling on border width (96 eighths = 12pt). Word's UI tops out well below this. */
+declare const MAX_BORDER_WIDTH_PT = 12;
+/** Soft ceiling on border-to-text gap (`w:space`, already in points). */
+declare const MAX_BORDER_SPACE_PT = 3168;
+/**
+ * A paragraph's resolved space before and after, in points.
+ *
+ * Already collapsed against `w:contextualSpacing`, so adjacent same-style paragraphs that suppress
+ * their gap arrive here with it removed rather than leaving that to whoever stacks them.
+ */
+interface ParagraphSpacing {
+    /** `w:spacing/@before`, in points. */
+    readonly before: number;
+    /** `w:spacing/@after`, in points. */
+    readonly after: number;
+}
+/**
+ * The gap Word substitutes when `w:beforeAutospacing` / `w:afterAutospacing` is on
+ * (ECMA-376 §17.3.1.33, the `w:spacing` clause both attributes belong to).
+ *
+ * The attribute means "the consumer decides", and the authored `@before` / `@after` beside it
+ * is IGNORED rather than used as the value. Word's answer is HTML's default `<p>` margin,
+ * 14pt, which is what a document round-tripped through Word's HTML filter carries — and this
+ * one is everywhere, because Word writes `w:before="100" w:beforeAutospacing="1"` for it. Reading
+ * only the literal 100 twips lays every such paragraph out 9pt tight, which moves page breaks.
+ */
+declare const AUTO_PARAGRAPH_SPACING_PT = 14;
+/**
+ * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
+ * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
+ *
+ * This resolves the interior list-item value. Body layout restores each outer list margin
+ * in `resolveListAutoSpacing`, where neighboring blocks are available. A caller that says
+ * nothing gets the body answer.
+ *
+ * A TABLE CELL is not such a context. Measured on a captured control at 10pt, where the
+ * line pitch is 11.52pt: the reference puts 26.16pt between two paragraphs in the body with
+ * auto spacing on, and the SAME 26.16pt between two paragraphs inside a cell. With an empty
+ * paragraph between them it is 52.32, exactly twice. Reading it as 0 in a cell lays every
+ * such paragraph 13.92pt tight, which is enough to pull a signature block back onto the
+ * previous page. See `.cache/pdf/claude-autospacing/`.
+ */
+interface ParagraphAutoSpacingContext {
+    /** The paragraph participates in numbering (`w:numPr`), i.e. it is a list item. */
+    readonly inList?: boolean;
+    /**
+     * The paragraph lives in a table cell. Kept because callers describe position with it and
+     * list resolution reads it; it does NOT zero auto spacing.
+     */
+    readonly inTableCell?: boolean;
+    /** Section grid pitch in points; no grid uses Word's fixed 12pt line unit. */
+    readonly lineUnitPt?: number;
+    /**
+     * `w:doNotUseHTMLParagraphAutoSpacing` is on: automatic spacing outside a list resolves to
+     * the fixed 5pt before and 10pt after instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
+     */
+    readonly fixedAutoSpacing?: boolean;
+}
+/**
+ * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
+ *
+ * `auto` is the interesting one: `@line` is 240ths of a line, so 240 is single, 360 is
+ * one-and-a-half, 480 is double — and Word's own Normal style since 2013 is 259, i.e.
+ * 1.08. A document laid out at a flat single spacing is ~8% tight on EVERY line, which
+ * moves every page break, so this is not a cosmetic detail.
+ *
+ * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
+ * does. `atLeast` uses it as a floor.
+ */
+type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
+/**
+ * Resolved line spacing: the rule, and the value it applies.
+ *
+ * `value` means different things per rule — 240ths of a line under `auto`, points under `exact`
+ * and `atLeast` — which is why the two travel together and neither is useful alone.
+ */
+interface ParagraphLineSpacing {
+    readonly rule: LineSpacingRule;
+    /** `auto`: the 240ths-of-a-line multiplier numerator. Otherwise points. */
+    readonly value: number;
+    /** Legacy noExtraLineSpacing: retain the natural baseline within an exact-height box. */
+    readonly preserveExactBaseline?: true;
+    /**
+     * Active section line-grid pitch in points (`w:docGrid/@w:linePitch`). Present only when
+     * the paragraph snaps to the grid; only with `auto`. See `line-grid.ts`.
+     */
+    readonly gridPitch?: number;
+}
+/** Single spacing: what a paragraph that says nothing gets. */
+declare const SINGLE_LINE_SPACING: ParagraphLineSpacing;
+/**
+ * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
+ *
+ * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
+ * unbounded border width becomes a layout dimension.
+ */
+interface ParagraphBorderEdge {
+    /** Authored `ST_Border` value (`single`, `dashed`, …). */
+    readonly val: string;
+    /** RRGGBB, or null when auto/missing (paint defaults to black). */
+    readonly color: string | null;
+    /** Border thickness in points (`w:sz` is eighths of a point). */
+    readonly widthPt: number;
+    /** Gap from text to the rule, in points (`w:space`). */
+    readonly spacePt: number;
+    /**
+     * `w:shadow` — Word offsets a drop shadow behind the rule.
+     *
+     * Present only when authored true, so an edge that says nothing keeps the shape earlier
+     * fixtures assert. Resolved and carried; drawing it is deferred.
+     */
+    readonly shadow?: true;
+}
+/** The six `CT_PBdr` children, in schema order (ECMA-376 §17.3.1.24). */
+declare const PARAGRAPH_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right', 'between', 'bar'];
+/**
+ * Which of the six `CT_PBdr` edges.
+ *
+ * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
+ * consecutive paragraphs share a border definition.
+ */
+type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
+/**
+ * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
+ *
+ * `top`/`left`/`bottom`/`right` are the four physical edges of the box. The other two are
+ * group-relative: `between` draws at a boundary INSIDE a run of consecutive paragraphs whose
+ * border settings are identical, and `bar` is the vertical change-bar rule beside the
+ * paragraph, drawn whether or not the paragraph groups with its neighbours.
+ */
+interface ParagraphBorders {
+    readonly top?: ParagraphBorderEdge;
+    readonly left?: ParagraphBorderEdge;
+    readonly bottom?: ParagraphBorderEdge;
+    readonly right?: ParagraphBorderEdge;
+    readonly between?: ParagraphBorderEdge;
+    readonly bar?: ParagraphBorderEdge;
+}
+/**
+ * Resolve `w:spacing` before/after from flat paragraph properties.
+ *
+ * Line spacing (`w:line` / `w:lineRule`) is a separate concern — it changes measured line
+ * height, not the gap between paragraphs — and is not resolved here.
+ *
+ * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
+ * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
+ */
+declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
+/**
+ * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
+ *
+ * Merged per attribute for the same reason as before/after: `w:spacing` is one element
+ * carrying independent attributes, and a style that states only `@line` must not reset the
+ * rule an earlier entry in the cascade set.
+ */
+declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
+/**
+ * Apply resolved line spacing to a line's natural (glyph-derived) box.
+ *
+ * `auto` places its extra BELOW the line — the last line's multiple spacing still separates
+ * it from the next paragraph. Putting that delta above inverted cover-page rhythm:
+ * `w:line="460"` on "between" opened a large gap above the word and almost none before
+ * "MERIDIAN".
+ *
+ * `atLeast` does the OPPOSITE: the box grows upward and the glyphs sit on its floor. A
+ * captured control settles it — Times New Roman 12 pt at `w:line="360" w:lineRule="atLeast"`
+ * puts the reference's baseline at 15.36 pt, which is `18 - descent` snapped to the device
+ * grid, where treating it like `auto` leaves the baseline at 11.28 and the text 4.08 pt too
+ * high. `w:line="240" atLeast` is below the natural line, falls through to the natural
+ * height, and is unaffected. See `.cache/pdf/claude-linerule/`.
+ *
+ * Exact-height boxes place their baseline at 80% of the height; the legacy
+ * noExtraLineSpacing switch instead preserves the face baseline within the box.
+ *
+ * An `auto` or `atLeast` line of a snapping paragraph under an active line grid takes whole
+ * pitches instead ({@link gridLineBox}); `trailing` then names the box below the glyphs.
+ */
+declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
+    height: number;
+    baseline: number;
+    trailing?: number;
+};
+/**
+ * `w:contextualSpacing` (17.3.1.9): drop before/after between paragraphs of the SAME
+ * style. Word's built-in `ListParagraph` sets it, so every list authored in Word gets a
+ * paragraph gap between items without this.
+ */
+declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
+/**
+ * Resolve `w:pBdr` from the paragraph-properties node.
+ *
+ * Nested — every edge is a child of `pBdr`, not an attribute — so this reads the typed tree
+ * rather than the flattened `OoxmlProperty[]` bag `propertiesOf` builds for leaf props.
+ */
+declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+/**
+ * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
+ *
+ * Word does not merge edges across the cascade. A style that states only `w:bottom` discards
+ * the box its `basedOn` ancestor declared, so folding edge by edge would leave a lone
+ * underline surrounded by a box no one authored. Absence inherits; `nil`/`none` clear.
+ */
+declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
+/**
+ * Visual stroke thickness layout publishes for one edge (points).
+ *
+ * Compound `ST_Border` values (`double`, …) use the shared inflated band so a thin
+ * `w:sz="3"` double still occupies a visible double-line box — matching table borders.
+ */
+declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+/**
+ * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
+ *
+ * Vertically that is flow height — a top rule pushes the first line down, a bottom rule holds
+ * the page open below the last one — so pagination has to see it. Horizontally it is
+ * publish-only: Word draws left/right paragraph rules OUTSIDE the text column and never
+ * re-breaks the lines, which is why adding a box to a paragraph in Word does not reflow it.
+ */
+declare function paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+/** Vertical extent a bottom border adds below the last line (gap + rule). */
+declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+/**
+ * Identity of a paragraph's border set, for the `w:between` group rule.
+ *
+ * Word treats consecutive paragraphs whose border settings are IDENTICAL as ONE bordered
+ * block: the top rule draws above the first, the bottom rule below the last, and each
+ * interior boundary gets `w:between` or nothing (§17.3.1.24). That is why applying a box to
+ * three selected paragraphs in Word draws one box and not three.
+ *
+ * Empty string means "no borders", which never groups with anything.
+ */
+declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
+/**
+ * Gap to insert before a paragraph once the previous paragraph's `after` is already in the
+ * flow cursor — Word takes the larger of the two rather than summing them.
+ */
+declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+/**
+ * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ *
+ * Adjacent before/after still collapse to the larger gap, but before is dropped entirely when
+ * the paragraph naturally moves to the top of a page mid-section. An explicit page-break-before
+ * paragraph, or the first paragraph of a document/section, retains before. Callers publish this
+ * applied value on the fragment so shading, borders,
+ * selection, and paint share one geometry.
+ */
+declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, preserveAtPageStart: boolean): number;
+
+/**
+ * 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;
+
+/**
+ * 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.
+ *
+ * `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.
+ *
+ * Returns `undefined` when the element is absent. An empty element yields `{}` so callers
+ * can tell "present but unauthored" from "missing" and serialization can re-emit empty.
+ * Hostile / out-of-range attribute values are dropped rather than clamped into meaning.
+ */
+declare function parsePageNumbering(sectPr: OoxmlNode): SectionPageNumbering | undefined;
+/** Parse one `w:sectPr` into geometry/break properties (null reads as Word's defaults). */
+declare function parseSectionProperties(sectPr: OoxmlNode | null | undefined): SectionProperties;
+/** `w:sectPr` nested under a paragraph's `w:pPr`, if present. */
+declare function paragraphSectionNode(paragraph: OoxmlElement): OoxmlElement | undefined;
+/**
+ * The section properties a part declares, or Word's defaults where it says nothing.
+ *
+ * Returns the FINAL section (body-level `w:sectPr`, else the last paragraph-level one).
+ * Multi-section geometry belongs to `enumerateDocumentSections`; chrome that needs "the
+ * document's page" still reads the last section, which is what Word's body-level sectPr is.
+ */
+declare function readSectionProperties(part: OoxmlPart): SectionProperties;
+/**
+ * Split the body story into sections.
+ *
+ * A paragraph carrying `w:pPr/w:sectPr` ends the current section (that paragraph is IN the
+ * section being ended). The body-level `w:sectPr` ends the final section. A document with
+ * neither yields one section of Word defaults covering every block.
+ *
+ * Enumeration is capped at {@link MAX_DOCUMENT_SECTIONS}. Further paragraph-level section
+ * breaks are ignored and remaining blocks fold into the last accepted section (fail closed).
+ *
+ * `displayMode` MUST match the one the caller passes to `storyBlocks`. `blockStart` /
+ * `blockEndExclusive` are indices into that list, and the list changes shape with the mode:
+ * the proposed view drops a paragraph whose mark and content a revision both removed. Slicing
+ * a filtered list with indices counted over an unfiltered one puts body text under another
+ * section's page geometry — the wrong paper size, the wrong margins, the wrong header.
+ */
+declare function enumerateDocumentSections(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): DocumentSection[];
+/**
+ * Canonical section index behind each section in a revision-projected body.
+ *
+ * A removed paragraph mark can collapse an entire section. The projected section keeps the
+ * surviving paragraph's geometry, while package APIs such as header/footer resolution remain
+ * indexed over the canonical tree. This bridge prevents those two index spaces from being
+ * paired positionally.
+ */
+declare function projectedSectionSourceIndexes(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): readonly number[];
+/**
+ * Every section in a document, with a flag saying whether the list was cut short.
+ *
+ * `truncated` is reported rather than silent: section count comes from a file, so a crafted
+ * document declaring thousands of paragraph-level `w:sectPr` marks is bounded, and a reader
+ * should be able to tell that happened.
+ */
+interface DocumentSectionsEnumeration {
+    readonly sections: DocumentSection[];
+    /** True when paragraph-level sectPr marks beyond {@link MAX_DOCUMENT_SECTIONS} were dropped. */
+    readonly truncated: boolean;
+}
+/**
+ * Like {@link enumerateDocumentSections}, but reports whether the section bound clipped
+ * hostile input. Prefer the plain enumerator for normal layout; use this when a caller
+ * needs a named fail-closed diagnostic.
+ */
+declare function enumerateDocumentSectionsBounded(part: OoxmlPart, displayMode?: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): DocumentSectionsEnumeration;
+/**
+ * Section properties as the geometry layout paginates against.
+ *
+ * The gutter is added to the LEFT margin: it is binding allowance, extra space on the inner
+ * edge, and folding it into the content width instead would silently narrow every line.
+ *
+ * Top and bottom keep the authored sign of `w:pgMar`: a negative value is an exact inset that
+ * header and footer height never moves. Read them through `page-body-margins.ts`.
+ */
+declare function geometryOfSection(section: SectionProperties): PageGeometry;
+
 /**
  * `w:tblpPr/@w:horzAnchor` (17.4.58) and `@w:vertAnchor` (17.4.66): the box a floated
  * table's offsets are measured from. Absent means `text` for both.
@@ -678,314 +1427,48 @@ interface ShapingEnvironmentFingerprintInputs {
     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;
-}
-/**
- * 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.
- *
- * @throws TypeError on a malformed tag, name, or axis value.
- */
-declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
-/**
- * Reduce an environment to its comparable form, with records sorted so key order cannot affect
- * the result.
- */
-declare const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
-/** Canonical serialization of every shaping variable, including byte hash and provenance. */
-declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
-/**
- * Validate and freeze a shaped run against the environment that produced it.
- *
- * Checks the internal consistency a shaper must satisfy: direction matches the environment,
- * cluster ranges tile the text without gaps or overlap, glyph ranges stay in bounds, font spans
- * cover every glyph, and caret edges are monotonic. A shaper that violates any of these produces
- * a caret that lands in the wrong place, which is far harder to diagnose downstream than here.
- *
- * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
- */
-declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
-/**
- * Reduce a shaped run to its comparable form, validating it on the way through.
- *
- * What the D9 determinism oracles compare: two shaping runs of the same text in the same
- * environment must produce byte-identical structures here.
- */
-declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
-
-/**
- * Whether a paragraph must start a new page (`w:pageBreakBefore`).
- *
- * LAST WINS, like every other toggle read off the cascade (`paragraphKeeps` does the same
- * for `w:keepNext`). An any-wins `.some()` cannot be switched off: a Chapter or Heading style
- * carries `w:pageBreakBefore`, and Word writes `w:val="0"` on the one instance whose author
- * unchecked the box — that paragraph still broke, so the document grew a blank page and every
- * page number after it was wrong.
- *
- * An absent `w:val` is on (§17.17.4), and the off vocabulary is the whole of it — `off` is a
- * spelling too, which {@link isOn} beside this already accepts.
- */
-declare function paragraphBreaksBefore(props: readonly OoxmlProperty[]): boolean;
-/**
- * Soft ceiling matching the spike's resolved-style limit (31_680 twips ≈ 22"). Beyond
- * that an attacker-authored spacing would push pagination into pathological page counts.
- */
-declare const MAX_PARAGRAPH_SPACING_PT: number;
-/** Soft ceiling on border width (96 eighths = 12pt). Word's UI tops out well below this. */
-declare const MAX_BORDER_WIDTH_PT = 12;
-/** Soft ceiling on border-to-text gap (`w:space`, already in points). */
-declare const MAX_BORDER_SPACE_PT = 3168;
-/**
- * A paragraph's resolved space before and after, in points.
- *
- * Already collapsed against `w:contextualSpacing`, so adjacent same-style paragraphs that suppress
- * their gap arrive here with it removed rather than leaving that to whoever stacks them.
- */
-interface ParagraphSpacing {
-    /** `w:spacing/@before`, in points. */
-    readonly before: number;
-    /** `w:spacing/@after`, in points. */
-    readonly after: number;
-}
-/**
- * The gap Word substitutes when `w:beforeAutospacing` / `w:afterAutospacing` is on
- * (ECMA-376 §17.3.1.33, the `w:spacing` clause both attributes belong to).
- *
- * The attribute means "the consumer decides", and the authored `@before` / `@after` beside it
- * is IGNORED rather than used as the value. Word's answer is HTML's default `<p>` margin,
- * 14pt, which is what a document round-tripped through Word's HTML filter carries — and this
- * one is everywhere, because Word writes `w:before="100" w:beforeAutospacing="1"` for it. Reading
- * only the literal 100 twips lays every such paragraph out 9pt tight, which moves page breaks.
- */
-declare const AUTO_PARAGRAPH_SPACING_PT = 14;
-/**
- * Where a paragraph sits, for the contexts in which Word's auto spacing resolves to 0
- * instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
- *
- * This resolves the interior list-item value. Body layout restores each outer list margin
- * in `resolveListAutoSpacing`, where neighboring blocks are available. A caller that says
- * nothing gets the body answer.
- *
- * A TABLE CELL is not such a context. Measured on a captured control at 10pt, where the
- * line pitch is 11.52pt: the reference puts 26.16pt between two paragraphs in the body with
- * auto spacing on, and the SAME 26.16pt between two paragraphs inside a cell. With an empty
- * paragraph between them it is 52.32, exactly twice. Reading it as 0 in a cell lays every
- * such paragraph 13.92pt tight, which is enough to pull a signature block back onto the
- * previous page. See `.cache/pdf/claude-autospacing/`.
- */
-interface ParagraphAutoSpacingContext {
-    /** The paragraph participates in numbering (`w:numPr`), i.e. it is a list item. */
-    readonly inList?: boolean;
-    /**
-     * The paragraph lives in a table cell. Kept because callers describe position with it and
-     * list resolution reads it; it does NOT zero auto spacing.
-     */
-    readonly inTableCell?: boolean;
-    /** Section grid pitch in points; no grid uses Word's fixed 12pt line unit. */
-    readonly lineUnitPt?: number;
-    /**
-     * `w:doNotUseHTMLParagraphAutoSpacing` is on: automatic spacing outside a list resolves to
-     * the fixed 5pt before and 10pt after instead of {@link AUTO_PARAGRAPH_SPACING_PT}.
-     */
-    readonly fixedAutoSpacing?: boolean;
-}
-/**
- * Resolved line spacing (`w:spacing/@line` + `@lineRule`, ECMA-376 17.3.1.33).
- *
- * `auto` is the interesting one: `@line` is 240ths of a line, so 240 is single, 360 is
- * one-and-a-half, 480 is double — and Word's own Normal style since 2013 is 259, i.e.
- * 1.08. A document laid out at a flat single spacing is ~8% tight on EVERY line, which
- * moves every page break, so this is not a cosmetic detail.
- *
- * `exact` fixes the line box at `@line` twips and lets tall glyphs clip, the way Word
- * does. `atLeast` uses it as a floor.
- */
-type LineSpacingRule = 'auto' | 'exact' | 'atLeast';
-/**
- * Resolved line spacing: the rule, and the value it applies.
- *
- * `value` means different things per rule — 240ths of a line under `auto`, points under `exact`
- * and `atLeast` — which is why the two travel together and neither is useful alone.
- */
-interface ParagraphLineSpacing {
-    readonly rule: LineSpacingRule;
-    /** `auto`: the 240ths-of-a-line multiplier numerator. Otherwise points. */
-    readonly value: number;
-    /** Legacy noExtraLineSpacing: retain the natural baseline within an exact-height box. */
-    readonly preserveExactBaseline?: true;
-    /**
-     * Active section line-grid pitch in points (`w:docGrid/@w:linePitch`). Present only when
-     * the paragraph snaps to the grid; only with `auto`. See `line-grid.ts`.
-     */
-    readonly gridPitch?: number;
-}
-/** Single spacing: what a paragraph that says nothing gets. */
-declare const SINGLE_LINE_SPACING: ParagraphLineSpacing;
-/**
- * One resolved `w:pBdr` edge: its style, colour, thickness and gap.
- *
- * `widthPt` and `spacePt` are already converted and CLAMPED — both come from a file, and an
- * unbounded border width becomes a layout dimension.
- */
-interface ParagraphBorderEdge {
-    /** Authored `ST_Border` value (`single`, `dashed`, …). */
-    readonly val: string;
-    /** RRGGBB, or null when auto/missing (paint defaults to black). */
-    readonly color: string | null;
-    /** Border thickness in points (`w:sz` is eighths of a point). */
-    readonly widthPt: number;
-    /** Gap from text to the rule, in points (`w:space`). */
-    readonly spacePt: number;
-    /**
-     * `w:shadow` — Word offsets a drop shadow behind the rule.
-     *
-     * Present only when authored true, so an edge that says nothing keeps the shape earlier
-     * fixtures assert. Resolved and carried; drawing it is deferred.
-     */
-    readonly shadow?: true;
-}
-/** The six `CT_PBdr` children, in schema order (ECMA-376 §17.3.1.24). */
-declare const PARAGRAPH_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right', 'between', 'bar'];
-/**
- * Which of the six `CT_PBdr` edges.
- *
- * Four are physical box edges; `between` and `bar` are group-relative, drawn only where
- * consecutive paragraphs share a border definition.
- */
-type ParagraphBorderSide = (typeof PARAGRAPH_BORDER_SIDES)[number];
-/**
- * A paragraph's resolved `w:pBdr` (ECMA-376 §17.3.1.24).
- *
- * `top`/`left`/`bottom`/`right` are the four physical edges of the box. The other two are
- * group-relative: `between` draws at a boundary INSIDE a run of consecutive paragraphs whose
- * border settings are identical, and `bar` is the vertical change-bar rule beside the
- * paragraph, drawn whether or not the paragraph groups with its neighbours.
- */
-interface ParagraphBorders {
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-    readonly between?: ParagraphBorderEdge;
-    readonly bar?: ParagraphBorderEdge;
-}
-/**
- * Resolve `w:spacing` before/after from flat paragraph properties.
- *
- * Line spacing (`w:line` / `w:lineRule`) is a separate concern — it changes measured line
- * height, not the gap between paragraphs — and is not resolved here.
- *
- * `w:beforeAutospacing` / `w:afterAutospacing` REPLACE the authored measurement on their own
- * side rather than adding to it; see {@link AUTO_PARAGRAPH_SPACING_PT}.
- */
-declare function paragraphSpacing(props: readonly OoxmlProperty[], context?: ParagraphAutoSpacingContext): ParagraphSpacing;
-/**
- * Resolve `w:line` / `w:lineRule` from flat paragraph properties.
- *
- * Merged per attribute for the same reason as before/after: `w:spacing` is one element
- * carrying independent attributes, and a style that states only `@line` must not reset the
- * rule an earlier entry in the cascade set.
- */
-declare function paragraphLineSpacing(props: readonly OoxmlProperty[]): ParagraphLineSpacing;
-/**
- * Apply resolved line spacing to a line's natural (glyph-derived) box.
- *
- * `auto` places its extra BELOW the line — the last line's multiple spacing still separates
- * it from the next paragraph. Putting that delta above inverted cover-page rhythm:
- * `w:line="460"` on "between" opened a large gap above the word and almost none before
- * "MERIDIAN".
- *
- * `atLeast` does the OPPOSITE: the box grows upward and the glyphs sit on its floor. A
- * captured control settles it — Times New Roman 12 pt at `w:line="360" w:lineRule="atLeast"`
- * puts the reference's baseline at 15.36 pt, which is `18 - descent` snapped to the device
- * grid, where treating it like `auto` leaves the baseline at 11.28 and the text 4.08 pt too
- * high. `w:line="240" atLeast` is below the natural line, falls through to the natural
- * height, and is unaffected. See `.cache/pdf/claude-linerule/`.
- *
- * Exact-height boxes place their baseline at 80% of the height; the legacy
- * noExtraLineSpacing switch instead preserves the face baseline within the box.
- *
- * An `auto` or `atLeast` line of a snapping paragraph under an active line grid takes whole
- * pitches instead ({@link gridLineBox}); `trailing` then names the box below the glyphs.
- */
-declare function applyLineSpacing(spacing: ParagraphLineSpacing, naturalHeight: number, naturalBaseline: number): {
-    height: number;
-    baseline: number;
-    trailing?: number;
-};
-/**
- * `w:contextualSpacing` (17.3.1.9): drop before/after between paragraphs of the SAME
- * style. Word's built-in `ListParagraph` sets it, so every list authored in Word gets a
- * paragraph gap between items without this.
- */
-declare function paragraphContextualSpacing(props: readonly OoxmlProperty[]): boolean;
-/**
- * Resolve `w:pBdr` from the paragraph-properties node.
- *
- * Nested — every edge is a child of `pBdr`, not an attribute — so this reads the typed tree
- * rather than the flattened `OoxmlProperty[]` bag `propertiesOf` builds for leaf props.
- */
-declare function paragraphBorders(pPr: OoxmlNode | undefined): ParagraphBorders;
+    readonly direction: TextDirection;
+    readonly features: readonly (readonly [string, number])[];
+    readonly fallbackOrder: readonly FontFingerprintInputs[];
+    readonly fixedPointScale: number;
+    readonly roundingMode: FixedPointRoundingMode;
+}
 /**
- * `w:pBdr` after the style cascade: a later `w:pBdr` replaces an earlier one WHOLESALE.
+ * Validate and freeze a shaping environment.
  *
- * Word does not merge edges across the cascade. A style that states only `w:bottom` discards
- * the box its `basedOn` ancestor declared, so folding edge by edge would leave a lone
- * underline surrounded by a box no one authored. Absence inherits; `nil`/`none` clear.
- */
-declare function cascadedParagraphBorders(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorders;
-/**
- * Visual stroke thickness layout publishes for one edge (points).
+ * 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.
  *
- * 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.
+ * @throws TypeError on a malformed tag, name, or axis value.
  */
-declare function paragraphBorderStrokeWidthPt(edge: ParagraphBorderEdge): number;
+declare const createShapingEnvironment: (input: ShapingEnvironmentInput) => ShapingEnvironment;
 /**
- * Extent one border edge occupies away from the text it decorates: gap plus rule, in points.
- *
- * Vertically that is flow height — a top rule pushes the first line down, a bottom rule holds
- * the page open below the last one — so pagination has to see it. Horizontally it is
- * publish-only: Word draws left/right paragraph rules OUTSIDE the text column and never
- * re-breaks the lines, which is why adding a box to a paragraph in Word does not reflow it.
+ * Reduce an environment to its comparable form, with records sorted so key order cannot affect
+ * the result.
  */
-declare function paragraphBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
-/** Vertical extent a bottom border adds below the last line (gap + rule). */
-declare function bottomBorderExtentPt(edge: ParagraphBorderEdge | undefined): number;
+declare const shapingEnvironmentFingerprintInputs: (input: ShapingEnvironmentInput) => ShapingEnvironmentFingerprintInputs;
+/** Canonical serialization of every shaping variable, including byte hash and provenance. */
+declare const shapingEnvironmentFingerprint: (environment: ShapingEnvironmentInput) => string;
 /**
- * Identity of a paragraph's border set, for the `w:between` group rule.
+ * Validate and freeze a shaped run against the environment that produced it.
  *
- * Word treats consecutive paragraphs whose border settings are IDENTICAL as ONE bordered
- * block: the top rule draws above the first, the bottom rule below the last, and each
- * interior boundary gets `w:between` or nothing (§17.3.1.24). That is why applying a box to
- * three selected paragraphs in Word draws one box and not three.
+ * Checks the internal consistency a shaper must satisfy: direction matches the environment,
+ * cluster ranges tile the text without gaps or overlap, glyph ranges stay in bounds, font spans
+ * cover every glyph, and caret edges are monotonic. A shaper that violates any of these produces
+ * a caret that lands in the wrong place, which is far harder to diagnose downstream than here.
  *
- * Empty string means "no borders", which never groups with anything.
- */
-declare function paragraphBordersFingerprint(borders: ParagraphBorders): string;
-/**
- * Gap to insert before a paragraph once the previous paragraph's `after` is already in the
- * flow cursor — Word takes the larger of the two rather than summing them.
+ * @throws TypeError when the run and environment disagree, or the run is internally inconsistent.
  */
-declare function collapsedSpaceBefore(before: number, previousAfter: number): number;
+declare const createShapedRun: (input: ShapedRun, environmentInput: ShapingEnvironmentInput) => ShapedRun;
 /**
- * Applied before-spacing for placement (Word 2013+ / compat mode 15).
+ * Reduce a shaped run to its comparable form, validating it on the way through.
  *
- * Adjacent before/after still collapse to the larger gap, but before is dropped entirely when
- * the paragraph naturally moves to the top of a page mid-section. An explicit page-break-before
- * paragraph, or the first paragraph of a document/section, retains before. Callers publish this
- * applied value on the fragment so shading, borders,
- * selection, and paint share one geometry.
+ * What the D9 determinism oracles compare: two shaping runs of the same text in the same
+ * environment must produce byte-identical structures here.
  */
-declare function appliedSpaceBefore(before: number, previousAfter: number, atTopOfPage: boolean, preserveAtPageStart: boolean): number;
+declare const shapedRunComparatorInputs: (input: ShapedRun, environment: ShapingEnvironmentInput) => ShapedRunComparatorInputs;
 
 /** `w:vertAlign` — script position, which also scales the run's effective size. */
 type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
@@ -1132,6 +1615,8 @@ interface ThemeFonts {
     readonly minorSupplemental?: Readonly<Record<string, string>>;
     /** Lower-cased font table names that declare a Chinese character set. */
     readonly chineseFontTableFaces?: readonly string[];
+    /** Lower-cased font table names that declare an East Asian character set. */
+    readonly eastAsianFontTableFaces?: readonly string[];
 }
 /**
  * Resolve one run's direct formatting.
@@ -1628,6 +2113,10 @@ declare function tabStopsFingerprint(tabs: ResolvedTabStops): string;
 interface CjkTypographySettings {
     /** Apply the strict Japanese small-kana and prolonged-sound-mark restrictions. */
     readonly strict: boolean;
+    /** Disable adjacent full-width punctuation compression when false. */
+    readonly punctuationKerning?: boolean;
+    /** The document defaults explicitly select an East Asian face as the East Asian font. */
+    readonly sourceEastAsianFont?: boolean;
     /** Whitespace compression selected by `w:characterSpacingControl`. */
     readonly compression: 'doNotCompress' | 'compressPunctuation' | 'compressPunctuationAndJapaneseKana';
     /** Custom no-line-start characters, keyed by normalized language tag. */
@@ -2362,6 +2851,8 @@ interface EquationTextGeometry extends EquationGeometryBase {
     readonly kind: 'text' | 'fallback';
     readonly text: string;
     readonly fontSizePt: number;
+    /** The same resolved face used by measurement and the trusted paint sink. */
+    readonly runStyle?: ResolvedRunStyle;
 }
 interface EquationRowGeometry extends EquationGeometryBase {
     readonly kind: 'row';
@@ -2380,6 +2871,11 @@ interface EquationRadicalGeometry extends EquationGeometryBase {
     readonly degree?: EquationGeometry;
     readonly bar: LayoutBox;
 }
+interface EquationBarGeometry extends EquationGeometryBase {
+    readonly kind: 'bar';
+    readonly body: EquationGeometry;
+    readonly bar: LayoutBox;
+}
 interface EquationScriptGeometry extends EquationGeometryBase {
     readonly kind: 'script';
     readonly base: EquationGeometry;
@@ -2393,7 +2889,7 @@ interface EquationNaryGeometry extends EquationGeometryBase {
     readonly lowerLimit?: EquationGeometry;
     readonly upperLimit?: EquationGeometry;
 }
-type EquationGeometry = EquationTextGeometry | EquationRowGeometry | EquationFractionGeometry | EquationRadicalGeometry | EquationScriptGeometry | EquationNaryGeometry;
+type EquationGeometry = EquationTextGeometry | EquationRowGeometry | EquationFractionGeometry | EquationRadicalGeometry | EquationBarGeometry | EquationScriptGeometry | EquationNaryGeometry;
 /** Equation metadata carried by one atomic semantic span. */
 interface EquationSpanRecord {
     readonly sourceNodeId: string;
@@ -2404,65 +2900,6 @@ interface EquationSpanRecord {
 /** Compose one bounded OMML projection into paint-ready point geometry. */
 declare function layoutEquation(projection: OmmlEquationProjection, measurer: TextMeasurer, style: ResolvedRunStyle): EquationSpanRecord;
 
-/**
- * The four physical sides of `CT_PageBorders`.
- *
- * Four, not the six of `w:pBdr`: `w:between` and `w:bar` are paragraph-group rules and the
- * page has no analogue for either.
- */
-declare const PAGE_BORDER_SIDES: readonly ['top', 'left', 'bottom', 'right'];
-/** Which of the four page-frame edges. */
-type PageBorderSide = (typeof PAGE_BORDER_SIDES)[number];
-/**
- * `w:offsetFrom` (`ST_PgBorderOffset`) — what `w:space` on each edge is measured from.
- *
- * The schema default is `text`, NOT `page`. Word's own UI opens on "Edge of page", which is
- * why the wrong default is easy to assume and expensive to hold: at `text` the rule sits
- * `w:space` points outside the TEXT, so its distance from the sheet edge is the margin minus
- * the space — a number that moves whenever the margins do.
- */
-type PageBorderOffsetFrom = 'page' | 'text';
-/** `w:display` (`ST_PgBorderDisplay`) — which pages of the section carry the frame. */
-type PageBorderDisplay = 'allPages' | 'firstPage' | 'notFirstPage';
-/** `w:zOrder` (`ST_PgBorderZOrder`) — whether the frame paints over the text or under it. */
-type PageBorderZOrder = 'front' | 'back';
-/**
- * One section's resolved `w:pgBorders`.
- *
- * Resolved, not raw: every attribute the file omitted is filled in with the SCHEMA default,
- * so a consumer never has to know which of the three were authored. An edge is present only
- * when it paints — `nil` / `none` and art borders are already gone (see {@link parsePageBorders}).
- */
-interface SectionPageBorders {
-    /** `w:offsetFrom`; absent attribute reads as `text` (§17.6.10). */
-    readonly offsetFrom: PageBorderOffsetFrom;
-    /** `w:display`; absent attribute reads as `allPages`. */
-    readonly display: PageBorderDisplay;
-    /** `w:zOrder`; absent attribute reads as `front`. */
-    readonly zOrder: PageBorderZOrder;
-    readonly top?: ParagraphBorderEdge;
-    readonly left?: ParagraphBorderEdge;
-    readonly bottom?: ParagraphBorderEdge;
-    readonly right?: ParagraphBorderEdge;
-}
-/**
- * Parse `w:pgBorders` off one `w:sectPr`.
- *
- * Undefined when the element is absent AND when it paints nothing — every edge off, or every
- * edge an art border. Unlike `w:pgNumType`, an empty-but-present element is not distinguished:
- * these properties are a LAYOUT input, serialization re-emits the canonical tree, and a frame
- * with no edges has exactly one meaning downstream.
- */
-declare function parsePageBorders(sectPr: OoxmlNode): SectionPageBorders | undefined;
-/**
- * Identity of one section's page frame, for incremental-layout context keys.
- *
- * A `w:pgBorders` edit changes nothing the flow measures — the frame is drawn beside the text,
- * never through it — so no per-paragraph key moves and every reuse path would hand back the
- * previous sheets with the previous frame. This token goes in the pass context so it does not.
- */
-declare function pageBordersFingerprint(borders: SectionPageBorders | undefined): string;
-
 /** Published root story containing an artifact occurrence. @public */
 type SemanticArtifactRootStoryKind = 'body' | 'header' | 'footer' | 'footnote' | 'endnote' | 'note-separator';
 /** Exact story in which a review artifact's source anchor was laid out. @public */
@@ -2550,6 +2987,91 @@ interface SemanticCommentArtifactRecord {
 /** Exporter-neutral review artifact normalized by core. @public */
 type SemanticReviewArtifactRecord = SemanticTrackedChangeArtifactRecord | SemanticCommentArtifactRecord;
 
+/**
+ * Raw `w:lock/@w:val` on one control, or `unlocked` when absent / unrecognised.
+ *
+ * Effective permissions across a nesting chain are the union of every ancestor's lock on two
+ * axes (content edit / removal); see {@link ContentControlBoundaryRecord.effectiveLock}.
+ */
+type ContentControlLock = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';
+/**
+ * Mapped control type for layout / chrome — same members as the shipped public
+ * `ContentControlType`. Untyped and preserved-only kinds report as `richText`.
+ */
+type ContentControlMappedType = 'richText' | 'plainText' | 'checkbox' | 'dropdown' | 'comboBox' | 'date' | 'picture' | 'buildingBlockGallery' | 'repeatingSection';
+/** Where the control sits in the tree relative to its content. */
+type ContentControlLevel = 'block' | 'inline' | 'row' | 'cell';
+/**
+ * One piece of a control's content geometry.
+ *
+ * A block control that crosses a page break publishes one fragment per page rather than a
+ * single rectangle covering the inter-page gap. An inline control publishes one fragment per
+ * LINE it touches, covering the text's vertical extent (line-spacing leading excluded), so a
+ * wrapped control never claims the words beside it. Coordinates match fragment boxes
+ * (page-content space).
+ */
+interface ContentControlGeometryFragment {
+    readonly pageIndex: number;
+    readonly box: LayoutBox;
+}
+/**
+ * Layout-published boundary for one content control (`w:sdt` / typed `contentControl`).
+ *
+ * Chrome, lock feedback, and hit resolution read this record — never painted DOM. The wrapper
+ * itself is not a layout box; `fragments` cover the content that already flowed in place.
+ */
+interface ContentControlBoundaryRecord {
+    /** Canonical node id of the control wrapper — not `w:id`. */
+    readonly id: string;
+    readonly alias?: string;
+    readonly tag?: string;
+    readonly controlType: ContentControlMappedType;
+    /** This control's own `w:lock`, before ancestor union. */
+    readonly lock: ContentControlLock;
+    /**
+     * Nested lock union with every ancestor control, collapsed back to a single `ST_Lock`
+     * vocabulary value (both axes locked → `sdtContentLocked`).
+     */
+    readonly effectiveLock: ContentControlLock;
+    /** `w:showingPlcHdr` is present on the control's properties. */
+    readonly placeholder: boolean;
+    /** `w:dataBinding` is present — content edits are refused as bound. */
+    readonly bound: boolean;
+    /** 0 for a top-level control; increments through nested wrappers under the shared nesting bound. */
+    readonly nestingDepth: number;
+    readonly level: ContentControlLevel;
+    readonly fragments: readonly ContentControlGeometryFragment[];
+    /** An inline control's model offsets in its paragraph; positions map through this, not geometry. */
+    readonly range?: ContentControlModelRange;
+}
+/** `[start, end)` UTF-16 offsets of an inline control's content in one paragraph. */
+interface ContentControlModelRange {
+    /** The paragraph that holds the control. */
+    readonly paragraphId: string;
+    /** Offset of the control's first character. */
+    readonly start: number;
+    /** Offset just past the control's last character. */
+    readonly end: number;
+}
+
+/** Page geometry, in points. */
+interface PageGeometry {
+    readonly width: number;
+    readonly height: number;
+    readonly margin: {
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    };
+    /** `w:pgMar/@header` — sheet edge to header top, in points. Defaults to 36 (720 twips). */
+    readonly headerDistance?: number;
+    /** `w:pgMar/@footer` — sheet edge to footer bottom, in points. Defaults to 36. */
+    readonly footerDistance?: number;
+}
+/** US Letter with one-inch margins, in points. */
+declare const DEFAULT_PAGE_GEOMETRY: PageGeometry;
+
 /** A half-open UTF-16 range inside one paragraph, addressed by its canonical node id. */
 interface SourceRange {
     readonly paragraphId: string;
@@ -2789,6 +3311,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[];
@@ -3339,61 +3863,6 @@ interface NoteAreaRecord {
  * - `endnote-overflow`: sheets inserted to finish sectEnd/docEnd collections.
  */
 type PageNoteStream = 'footnote-drain' | 'endnote-overflow';
-/**
- * Raw `w:lock/@w:val` on one control, or `unlocked` when absent / unrecognised.
- *
- * Effective permissions across a nesting chain are the union of every ancestor's lock on two
- * axes (content edit / removal); see {@link ContentControlBoundaryRecord.effectiveLock}.
- */
-type ContentControlLock = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';
-/**
- * Mapped control type for layout / chrome — same members as the shipped public
- * `ContentControlType`. Untyped and preserved-only kinds report as `richText`.
- */
-type ContentControlMappedType = 'richText' | 'plainText' | 'checkbox' | 'dropdown' | 'comboBox' | 'date' | 'picture' | 'buildingBlockGallery' | 'repeatingSection';
-/** Where the control sits in the tree relative to its content. */
-type ContentControlLevel = 'block' | 'inline' | 'row' | 'cell';
-/**
- * One piece of a control's content geometry.
- *
- * A block control that crosses a page break publishes one fragment per page rather than a
- * single rectangle covering the inter-page gap. An inline control publishes one fragment per
- * LINE it touches, covering the text's vertical extent (line-spacing leading excluded), so a
- * wrapped control never claims the words beside it. Coordinates match fragment boxes
- * (page-content space).
- */
-interface ContentControlGeometryFragment {
-    readonly pageIndex: number;
-    readonly box: LayoutBox;
-}
-/**
- * Layout-published boundary for one content control (`w:sdt` / typed `contentControl`).
- *
- * Chrome, lock feedback, and hit resolution read this record — never painted DOM. The wrapper
- * itself is not a layout box; `fragments` cover the content that already flowed in place.
- */
-interface ContentControlBoundaryRecord {
-    /** Canonical node id of the control wrapper — not `w:id`. */
-    readonly id: string;
-    readonly alias?: string;
-    readonly tag?: string;
-    readonly controlType: ContentControlMappedType;
-    /** This control's own `w:lock`, before ancestor union. */
-    readonly lock: ContentControlLock;
-    /**
-     * Nested lock union with every ancestor control, collapsed back to a single `ST_Lock`
-     * vocabulary value (both axes locked → `sdtContentLocked`).
-     */
-    readonly effectiveLock: ContentControlLock;
-    /** `w:showingPlcHdr` is present on the control's properties. */
-    readonly placeholder: boolean;
-    /** `w:dataBinding` is present — content edits are refused as bound. */
-    readonly bound: boolean;
-    /** 0 for a top-level control; increments through nested wrappers under the shared nesting bound. */
-    readonly nestingDepth: number;
-    readonly level: ContentControlLevel;
-    readonly fragments: readonly ContentControlGeometryFragment[];
-}
 /**
  * One laid-out page: the sheet, the content area, and everything that landed on it.
  *
@@ -3487,6 +3956,13 @@ interface SemanticLayout {
      * reuse paths that would otherwise return previous pages by identity with stale boundaries.
      */
     readonly controlContextToken?: string;
+    /** Body section breaks in document order, each named by the section that FOLLOWS it. */
+    readonly sectionBreaks?: readonly SectionBreakMarkRecord[];
+}
+/** The paragraph whose `w:sectPr` ends a section, and how the next section starts. */
+interface SectionBreakMarkRecord {
+    readonly paragraphId: string;
+    readonly kind: SectionBreakType;
 }
 
 /**
@@ -3528,5 +4004,5 @@ interface TextMeasurer {
     };
 }
 
-export { PAGE_BORDER_SIDES as a$, AUTO_PARAGRAPH_SPACING_PT as a4, HARD_MAX_AGGREGATE_FONT_BYTES as aG, HARD_MAX_FONT_BYTES as aH, HARD_MAX_FONT_SOURCES as aI, MAX_BORDER_SPACE_PT as aO, MAX_BORDER_WIDTH_PT as aP, MAX_LVL_OVERRIDES as aQ, MAX_NUMBERING_DEFINITIONS as aR, MAX_PARAGRAPH_SPACING_PT as aS, MAX_SHAPING_CONTEXT as aT, MAX_STYLE_DEFINITIONS as aU, MAX_TABLE_BORDER_STROKES as aV, MAX_TAB_POSITION_TWIPS as aW, MAX_TAB_STOPS as aX, DEFAULT_RUN_STYLE as ae, DEFAULT_TAB_INTERVAL_PT as af, DEFAULT_TAB_INTERVAL_TWIPS as ag, EMPTY_NUMBERING_INDEX as al, EMPTY_TAB_STOPS as am, FontResolutionError as ax, bottomBorderExtentPt as b$, PARAGRAPH_BORDER_SIDES as b0, TAB_LEADER_GLYPH as bJ, UnsupportedScriptError as bU, appliedSpaceBefore as bW, applyLineSpacing as bX, baselineShiftPtOf as bY, borderExtentPt as bZ, borderWeight as b_, SINGLE_LINE_SPACING as bp, boundedStructuralFontValidator as c0, buildNumberingIndex as c1, buildStyleCascadeTable as c2, cascadeParagraphFormatting as c3, cascadeRunProperties as c4, cascadedBottomBorder as c5, cascadedParagraphBorders as c6, cascadedTabStops as c7, collapsedSpaceBefore as c8, createFontResourceSnapshot as c9, readCellBorders as cA, readNumPr as cB, readTableBorders as cC, resolveBorderConflict as cD, resolveNumberingLevel as cE, resolveParagraphLayoutInputs as cF, resolveRunStyle as cG, resolveStoryListItems as cH, resolveStoryRefFields as cI, resolveTableCellBorderGrid as cJ, runStylesEqual as cK, shapedRunComparatorInputs as cL, shapingEnvironmentFingerprint as cM, shapingEnvironmentFingerprintInputs as cN, styleForFontSlot as cO, tabAdvanceWidth as cP, tabStopsFingerprint as cQ, withDefaultTabInterval as cR, withNumberingStyleLinks as cS, withResolvedListItems as cT, createShapedRun as ca, createShapingEnvironment as cb, defaultTabIntervalFromSettings as cc, displayText as cd, fixedPoint as ce, fontRequestKey as cf, glyphSizeFactorOf as cg, isValidStyleId as ch, itemizeScriptFontSlots as ci, layoutEquation as cj, measureDisplayText as ck, mergeListIndent as cl, nextTabDestination as cm, pageBordersFingerprint as cn, paragraphBorderExtentPt as co, paragraphBorderStrokeWidthPt as cp, paragraphBorders as cq, paragraphBordersFingerprint as cr, paragraphBreaksBefore as cs, paragraphContextualSpacing as ct, paragraphLineSpacing as cu, paragraphSpacing as cv, paragraphTabStops as cw, parsePageBorders as cx, parseRefInstruction as cy, readBorderSide as cz };
-export type { HyperlinkFieldSpec as $, AnchoredDrawingRecord as A, BlockFragmentRecord as B, ContentControlBoundaryRecord as C, DrawingPoint as D, InlineDrawingLayoutContext as E, FontResourceSnapshot as F, CellBorderBox as G, HeaderFooterStoryRecord as H, InlineDrawingRecord as I, TableBorderBox as J, TableCellStyleFormatting as K, LineRecord as L, ModelRange as M, NoteAreaRecord as N, TableFloatPosition as O, ParagraphFragmentRecord as P, StyleCascadeTable as Q, ResolvedRunStyle as R, SemanticLayout as S, TextMeasurer as T, FixedPoint as U, VersionedShapingLibrary as V, FontByteValidator as W, SourceRange as X, HyperlinkProjector as Y, FieldLinkProjector as Z, StoryPageFieldNeeds as _, PageRecord as a, SpanLinkRecord as a0, PageBorderFrameRecord as a1, ParagraphBorderStrokeRecord as a2, StrikeoutStrokePt as a3, AbstractNumDefinition as a5, AnchoredDrawingLayoutFallback as a6, BidiEmbeddingLevels as a7, BorderGridGeometry as a8, CascadedParagraphFormatting as a9, FontResourceInstrumentation as aA, FontResourceSnapshotOptions as aB, FontSlot as aC, FontValidationResult as aD, GlyphOutline as aE, GroupTextboxStoryRecord as aF, LevelOverride as aJ, LineSpacingRule as aK, ListMarkerAlign as aL, ListMarkerRecord as aM, ListSuffix as aN, NumDefinition as aY, NumberingLevelIndent as aZ, NumberingPictureBullet as a_, CjkTypographySettings as aa, ContentControlGeometryFragment as ab, ContentControlLevel as ac, ContentControlMappedType as ad, DeclaredFontSubstitution as ah, DrawingClipFallback as ai, DrawingGeometry as aj, DrawingGroupPictureRecord as ak, EquationFractionGeometry as an, EquationGeometry as ao, EquationNaryGeometry as ap, EquationRadicalGeometry as aq, EquationRowGeometry as ar, EquationScriptGeometry as as, EquationSpanRecord as at, EquationTextGeometry as au, FieldAtomMarker as av, FontFingerprintInputs as aw, FontResolutionErrorCode as ay, FontResourceDefinition as az, LayoutBox as b, PageBorderDisplay as b1, PageBorderOffsetFrom as b2, PageBorderSide as b3, PageBorderStrokeRecord as b4, PageBorderZOrder as b5, PageRefCalibrationCell as b6, PageRefFieldProjection as b7, ParagraphAutoSpacingContext as b8, ParagraphBorderEdge as b9, ShapedCluster as bA, ShapedFontSpan as bB, ShapedGlyph as bC, ShapedRunComparatorInputs as bD, ShapedVerticalMetrics as bE, ShapingContext as bF, ShapingEnvironment as bG, ShapingEnvironmentFingerprintInputs as bH, StyleDefinition as bI, TabAlignment as bK, TabDestination as bL, TabLeader as bM, TabStop as bN, TableBorderSideName as bO, TableBorderStrokeRecord as bP, TableFragmentRecord as bQ, TextDirection as bR, TextboxStoryFallbackReason as bS, TextboxStoryLayout as bT, VerticalAlign as bV, ParagraphBorderSide as ba, ParagraphBorders as bb, ParagraphBottomBorderRecord as bc, ParagraphIndent as bd, ParagraphLayoutInputs as be, ParagraphLineSpacing as bf, ParagraphSpacing as bg, RefFieldSpec as bh, RefNoteParts as bi, ResolvedCellBorders as bj, ResolvedPictureBullet as bk, ResolvedTabStops as bl, ResolvedTableBorderEdge as bm, ResolvedTableBorderEdgeSegment as bn, ResolvedUnderline as bo, ScriptItem as bq, SemanticArtifactRootStoryKind as br, SemanticArtifactStoryKind as bs, SemanticCommentArtifactRecord as bt, SemanticReviewArtifactOccurrence as bu, SemanticReviewArtifactOccurrenceGeometry as bv, SemanticReviewArtifactPosition as bw, SemanticReviewArtifactSource as bx, SemanticTrackedChangeArtifactRecord as by, ShapeInput as bz, NoteStoryRecord as c, ContentControlLock as d, StyleSpanRecord as e, SectionPageBorders as f, TableRowFragmentRecord as g, TableCellFragmentRecord as h, ShapingEnvironmentInput as i, TextShaper as j, ResolvedFont as k, NormalizationPolicy as l, FixedPointRoundingMode as m, FontRequest as n, SemanticReviewArtifactRecord as o, ListMarkerPictureRecord as p, FontSubstitution as q, ShapedRun as r, NumberingLevel as s, NumberingIndex as t, DrawingInsets as u, TableBorderSide as v, TableFloatXSpec as w, TableFloatYSpec as x, ResolvedListItem as y, RefFieldContext as z };
+export { DEFAULT_REVISION_MARKUP as D, resolveRevisionMarkup as Q, DEFAULT_PAGE_GEOMETRY as aA, DEFAULT_REVISION_DISPLAY_MODE as aB, DEFAULT_RUN_STYLE as aC, DEFAULT_SECTION_PROPERTIES as aD, DEFAULT_TAB_INTERVAL_PT as aE, DEFAULT_TAB_INTERVAL_TWIPS as aF, EMPTY_NUMBERING_INDEX as aM, EMPTY_TAB_STOPS as aN, FontResolutionError as aZ, AUTO_PARAGRAPH_SPACING_PT as ap, HARD_MAX_AGGREGATE_FONT_BYTES as b6, HARD_MAX_FONT_BYTES as b7, HARD_MAX_FONT_SOURCES as b8, SINGLE_LINE_SPACING as bU, MAX_BORDER_SPACE_PT as be, MAX_BORDER_WIDTH_PT as bf, MAX_DOCUMENT_SECTIONS as bg, MAX_LVL_OVERRIDES as bh, MAX_NUMBERING_DEFINITIONS as bi, MAX_PARAGRAPH_SPACING_PT as bj, MAX_SHAPING_CONTEXT as bk, MAX_STYLE_DEFINITIONS as bl, MAX_TABLE_BORDER_STROKES as bm, MAX_TAB_POSITION_TWIPS as bn, MAX_TAB_STOPS as bo, PAGE_BORDER_SIDES as bs, PARAGRAPH_BORDER_SIDES as bt, nextTabDestination as c$, boundedStructuralFontValidator as cA, buildNumberingIndex as cB, buildStyleCascadeTable as cC, cascadeParagraphFormatting as cD, cascadeRunProperties as cE, cascadedBottomBorder as cF, cascadedParagraphBorders as cG, cascadedTabStops as cH, collapsedSpaceBefore as cI, createFontResourceSnapshot as cJ, createShapedRun as cK, createShapingEnvironment as cL, defaultTabIntervalFromSettings as cM, displayText as cN, enumerateDocumentSections as cO, enumerateDocumentSectionsBounded as cP, fixedPoint as cQ, fontRequestKey as cR, formatRevisionOf as cS, geometryOfSection as cT, glyphSizeFactorOf as cU, isValidStyleId as cV, itemizeScriptFontSlots as cW, layoutEquation as cX, markRevisionRemovesMark as cY, measureDisplayText as cZ, mergeListIndent as c_, TAB_LEADER_GLYPH as ch, UnsupportedScriptError as cs, appliedSpaceBefore as cu, applyLineSpacing as cv, baselineShiftPtOf as cw, borderExtentPt as cx, borderWeight as cy, bottomBorderExtentPt as cz, pageBordersFingerprint as d0, paragraphBorderExtentPt as d1, paragraphBorderStrokeWidthPt as d2, paragraphBorders as d3, paragraphBordersFingerprint as d4, paragraphBreaksBefore as d5, paragraphContextualSpacing as d6, paragraphLineSpacing as d7, paragraphMarkFormatRevisionOf as d8, paragraphMarkRevisionOf as d9, shapedRunComparatorInputs as dA, shapingEnvironmentFingerprint as dB, shapingEnvironmentFingerprintInputs as dC, shownMarkRevision as dD, styleForFontSlot as dE, tabAdvanceWidth as dF, tabStopsFingerprint as dG, withDefaultTabInterval as dH, withNumberingStyleLinks as dI, withResolvedListItems as dJ, paragraphMarkRevisionsOf as da, paragraphSectionNode as db, paragraphSpacing as dc, paragraphTabStops as dd, parsePageBorders as de, parsePageNumbering as df, parseRefInstruction as dg, parseSectionProperties as dh, projectedSectionSourceIndexes as di, readBorderSide as dj, readCellBorders as dk, readNumPr as dl, readSectionProperties as dm, readTableBorders as dn, resolveBorderConflict as dp, resolveNumberingLevel as dq, resolveParagraphLayoutInputs as dr, resolveRunStyle as ds, resolveStoryListItems as dt, resolveStoryRefFields as du, resolveTableCellBorderGrid as dv, revisionAuthorFilter as dw, revisionsAreDeletion as dx, revisionsVisible as dy, runStylesEqual 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, FontResourceDefinition 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 aG, DocumentSection as aH, DocumentSectionsEnumeration as aI, DrawingClipFallback as aJ, DrawingGeometry as aK, DrawingGroupPictureRecord as aL, EquationBarGeometry as aO, EquationFractionGeometry as aP, EquationGeometry as aQ, EquationNaryGeometry as aR, EquationRadicalGeometry as aS, EquationRowGeometry as aT, EquationScriptGeometry as aU, EquationSpanRecord as aV, EquationTextGeometry as aW, FieldAtomMarker as aX, FontFingerprintInputs as aY, FontResolutionErrorCode 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, ContentControlModelRange as az, RevisionDisplayMode as b, SemanticArtifactRootStoryKind as b$, FontResourceInstrumentation as b0, FontResourceSnapshotOptions as b1, FontSlot as b2, FontValidationResult as b3, GlyphOutline as b4, GroupTextboxStoryRecord as b5, LevelOverride as b9, PageRefFieldProjection as bA, ParagraphAutoSpacingContext as bB, ParagraphBorderEdge as bC, ParagraphBorderSide as bD, ParagraphBorders as bE, ParagraphBottomBorderRecord as bF, ParagraphIndent as bG, ParagraphLayoutInputs as bH, ParagraphLineSpacing as bI, ParagraphSpacing as bJ, RefFieldSpec as bK, RefNoteParts as bL, ResolvedCellBorders as bM, ResolvedPictureBullet as bN, ResolvedTabStops as bO, ResolvedTableBorderEdge as bP, ResolvedTableBorderEdgeSegment as bQ, ResolvedUnderline as bR, RevisionFilter as bS, RevisionKind as bT, ScriptItem as bV, SectionBreakMarkRecord as bW, SectionBreakType as bX, SectionColumnDefinition as bY, SectionMargins as bZ, SectionPageNumbering as b_, LineSpacingRule as ba, ListMarkerAlign as bb, ListMarkerRecord as bc, ListSuffix as bd, NumDefinition as bp, NumberingLevelIndent as bq, NumberingPictureBullet as br, PageBorderDisplay as bu, PageBorderOffsetFrom as bv, PageBorderSide as bw, PageBorderStrokeRecord as bx, PageBorderZOrder as by, PageRefCalibrationCell as bz, PageRecord as c, SemanticArtifactStoryKind as c0, SemanticCommentArtifactRecord as c1, SemanticReviewArtifactOccurrence as c2, SemanticReviewArtifactOccurrenceGeometry as c3, SemanticReviewArtifactPosition as c4, SemanticReviewArtifactSource as c5, SemanticTrackedChangeArtifactRecord as c6, ShapeInput as c7, ShapedCluster as c8, ShapedFontSpan as c9, ShapedGlyph as ca, ShapedRunComparatorInputs as cb, ShapedVerticalMetrics as cc, ShapingContext as cd, ShapingEnvironment as ce, ShapingEnvironmentFingerprintInputs as cf, StyleDefinition as cg, TabAlignment as ci, TabDestination as cj, TabLeader as ck, TabStop as cl, TableBorderSideName as cm, TableBorderStrokeRecord as cn, TableFragmentRecord as co, TextDirection as cp, TextboxStoryFallbackReason as cq, TextboxStoryLayout as cr, VerticalAlign as ct, 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 };