@docx-editor.dev/core 2.0.1 → 2.1.1

package/dist/layout.d.ts

@@ -1,21 +1,22 @@
-import { V as VersionedShapingLibrary, T as TextShaper, F as FontByteValidator, a as FixedPointRoundingMode, b as FixedPoint, c as TextDirection, S as ShapedRun } from './shaped-measurer-B-TAtcQU.js';
-export { C as CacheLookup, d as CacheMiss, e as CacheProvenance, D as DeclaredFontSubstitution, f as FontFingerprintInputs, g as FontRequest, h as FontResolutionError, i as FontResolutionErrorCode, j as FontResourceDefinition, k as FontResourceInstrumentation, l as FontResourceSnapshot, m as FontResourceSnapshotOptions, n as FontSubstitution, o as FontValidationResult, G as GlyphOutline, H as HARD_MAX_AGGREGATE_FONT_BYTES, p as HARD_MAX_FONT_BYTES, q as HARD_MAX_FONT_SOURCES, L as LayoutShapingOptions, N as NormalizationPolicy, O as OperationSnapshot, r as OperationSnapshotField, s as OperationSnapshotGuard, R as ResolvedCache, t as ResolvedFont, u as ResourceDependencyProvenance, v as ShapeInput, w as ShapedCluster, x as ShapedFontSpan, y as ShapedGlyph, z as ShapedMeasurerOptions, A as ShapedRunComparatorInputs, B as ShapedVerticalMetrics, E as ShapingEnvironment, I as ShapingEnvironmentFingerprintInputs, J as ShapingEnvironmentInput, K as boundedStructuralFontValidator, M as captureOperationSnapshot, P as createFontResourceSnapshot, Q as createShapedMeasurer, U as createShapedRun, W as createShapingEnvironment, X as fixedPoint, Y as fontRequestKey, Z as guardOperationSnapshot, _ as sha256FontBytes, $ as shapedRunComparatorInputs, a0 as shapingEnvironmentFingerprint, a1 as shapingEnvironmentFingerprintInputs } from './shaped-measurer-B-TAtcQU.js';
-import { d as LayoutBox, D as DrawingPoint, e as DrawingInsets, f as TableBorderSide, a as StyleSpanRecord, I as InlineDrawingRecord, M as ModelRange, R as ResolvedRunStyle, g as ThemeFonts, h as ParagraphSpacing, i as ParagraphLineSpacing, j as ParagraphBorderEdge, k as ParagraphBorders, l as ResolvedTabStops, B as BlockFragmentRecord, T as TextMeasurer, S as SemanticLayout, m as PageRecord, n as ParagraphFragmentRecord, A as AnchoredDrawingRecord, F as FieldPageContext, o as InlineDrawingLayoutContext, P as PageGeometry, H as HyperlinkProjector, p as CellBorderBox, q as TableBorderBox } from './semantic-records-CWodBJsz.js';
-export { r as BorderGridGeometry, C as ContentControlBoundaryRecord, s as ContentControlGeometryFragment, t as ContentControlLevel, u as ContentControlLock, v as ContentControlMappedType, w as DEFAULT_PAGE_GEOMETRY, x as DEFAULT_RUN_STYLE, y as DEFAULT_TAB_INTERVAL_PT, z as DEFAULT_TAB_INTERVAL_TWIPS, E as EMPTY_TAB_STOPS, G as HeaderFooterStoryRecord, L as LineRecord, J as LineSpacingRule, K as ListMarkerRecord, N as MAX_BORDER_SPACE_PT, O as MAX_BORDER_WIDTH_PT, Q as MAX_PARAGRAPH_SPACING_PT, U as MAX_TABLE_BORDER_STROKES, V as MAX_TAB_POSITION_TWIPS, W as MAX_TAB_STOPS, X as PARAGRAPH_BORDER_SIDES, Y as ParagraphBorderSide, Z as ParagraphBorderStrokeRecord, _ as ParagraphBottomBorderRecord, $ as ParagraphIndent, a0 as ResolvedCellBorders, a1 as ResolvedTableBorderEdge, a2 as ResolvedTableBorderEdgeSegment, a3 as ResolvedUnderline, a4 as SINGLE_LINE_SPACING, a5 as SourceRange, a6 as SpanLinkRecord, a7 as TAB_LEADER_GLYPH, a8 as TabAlignment, a9 as TabDestination, aa as TabLeader, ab as TabStop, ac as TableBorderSideName, ad as TableBorderStrokeRecord, c as TableCellFragmentRecord, ae as TableFragmentRecord, b as TableRowFragmentRecord, af as VerticalAlign, ag as appliedSpaceBefore, ah as applyLineSpacing, ai as baselineShiftPtOf, aj as borderExtentPt, ak as borderWeight, al as bottomBorderExtentPt, am as cascadedParagraphBorders, an as cascadedTabStops, ao as collapsedSpaceBefore, ap as contentControlsOfLayout, aq as defaultTabIntervalFromSettings, ar as displayText, as as effectiveContentControlLock, at as formatPageNumber, au as fragmentsOfParagraph, av as lineAtPosition, aw as linesOf, ax as measureDisplayText, ay as nextTabDestination, az as paragraphBorderExtentPt, aA as paragraphBorderStrokeWidthPt, aB as paragraphBorders, aC as paragraphBordersFingerprint, aD as paragraphBreaksBefore, aE as paragraphContextualSpacing, aF as paragraphFragmentsOf, aG as paragraphFragmentsOfBlocks, aH as paragraphLineSpacing, aI as paragraphSpacing, aJ as paragraphTabStops, aK as readBorderSide, aL as readCellBorders, aM as readTableBorders, aN as resolveBorderConflict, aO as resolveRunStyle, aP as resolveTableCellBorderGrid, aQ as runStylesEqual, aR as tabAdvanceWidth, aS as tabStopsFingerprint, aT as unionLayoutBoxes, aU as withDefaultTabInterval } from './semantic-records-CWodBJsz.js';
+import { V as VersionedShapingLibrary, T as TextShaper, F as FontByteValidator, a as FixedPointRoundingMode, b as FixedPoint, c as TextDirection, S as ShapedRun } from './shaped-measurer-CZXL-a6v.js';
+export { C as CacheLookup, d as CacheMiss, e as CacheProvenance, D as DeclaredFontSubstitution, f as FontFingerprintInputs, g as FontRequest, h as FontResolutionError, i as FontResolutionErrorCode, j as FontResourceDefinition, k as FontResourceInstrumentation, l as FontResourceSnapshot, m as FontResourceSnapshotOptions, n as FontSubstitution, o as FontValidationResult, G as GlyphOutline, H as HARD_MAX_AGGREGATE_FONT_BYTES, p as HARD_MAX_FONT_BYTES, q as HARD_MAX_FONT_SOURCES, L as LayoutShapingOptions, N as NormalizationPolicy, O as OperationSnapshot, r as OperationSnapshotField, s as OperationSnapshotGuard, R as ResolvedCache, t as ResolvedFont, u as ResourceDependencyProvenance, v as ShapeInput, w as ShapedCluster, x as ShapedFontSpan, y as ShapedGlyph, z as ShapedMeasurerOptions, A as ShapedRunComparatorInputs, B as ShapedVerticalMetrics, E as ShapingEnvironment, I as ShapingEnvironmentFingerprintInputs, J as ShapingEnvironmentInput, K as boundedStructuralFontValidator, M as captureOperationSnapshot, P as createFontResourceSnapshot, Q as createShapedMeasurer, U as createShapedRun, W as createShapingEnvironment, X as fixedPoint, Y as fontRequestKey, Z as guardOperationSnapshot, _ as sha256FontBytes, $ as shapedRunComparatorInputs, a0 as shapingEnvironmentFingerprint, a1 as shapingEnvironmentFingerprintInputs } from './shaped-measurer-CZXL-a6v.js';
+import { d as LayoutBox, D as DrawingPoint, e as DrawingInsets, a as StyleSpanRecord, I as InlineDrawingRecord, M as ModelRange, R as ResolvedRunStyle, f as ThemeFonts, g as ParagraphSpacing, h as ParagraphLineSpacing, i as ParagraphBorderEdge, j as ParagraphBorders, k as ResolvedTabStops, l as TableBorderSide, B as BlockFragmentRecord, m as InlineDrawingLayoutContext, T as TextMeasurer, S as SemanticLayout, n as PageRecord, o as ParagraphFragmentRecord, A as AnchoredDrawingRecord, F as FieldPageContext, P as PageGeometry, H as HyperlinkProjector, p as CellBorderBox, q as TableBorderBox } from './semantic-records-zTC0_1zi.js';
+export { r as AUTO_PARAGRAPH_SPACING_PT, s as BorderGridGeometry, C as ContentControlBoundaryRecord, t as ContentControlGeometryFragment, u as ContentControlLevel, v as ContentControlLock, w as ContentControlMappedType, x as DEFAULT_PAGE_GEOMETRY, y as DEFAULT_RUN_STYLE, z as DEFAULT_TAB_INTERVAL_PT, E as DEFAULT_TAB_INTERVAL_TWIPS, G as EMPTY_TAB_STOPS, J as HeaderFooterStoryRecord, L as LineRecord, K as LineSpacingRule, N as ListMarkerRecord, O as MAX_BORDER_SPACE_PT, Q as MAX_BORDER_WIDTH_PT, U as MAX_PARAGRAPH_SPACING_PT, V as MAX_TABLE_BORDER_STROKES, W as MAX_TAB_POSITION_TWIPS, X as MAX_TAB_STOPS, Y as PARAGRAPH_BORDER_SIDES, Z as ParagraphAutoSpacingContext, _ as ParagraphBorderSide, $ as ParagraphBorderStrokeRecord, a0 as ParagraphBottomBorderRecord, a1 as ParagraphIndent, a2 as ResolvedCellBorders, a3 as ResolvedTableBorderEdge, a4 as ResolvedTableBorderEdgeSegment, a5 as ResolvedUnderline, a6 as SINGLE_LINE_SPACING, a7 as SourceRange, a8 as SpanLinkRecord, a9 as TAB_LEADER_GLYPH, aa as TabAlignment, ab as TabDestination, ac as TabLeader, ad as TabStop, ae as TableBorderSideName, af as TableBorderStrokeRecord, c as TableCellFragmentRecord, ag as TableFragmentRecord, b as TableRowFragmentRecord, ah as VerticalAlign, ai as appliedSpaceBefore, aj as applyLineSpacing, ak as baselineShiftPtOf, al as borderExtentPt, am as borderWeight, an as bottomBorderExtentPt, ao as cascadedParagraphBorders, ap as cascadedTabStops, aq as collapsedSpaceBefore, ar as contentControlsOfLayout, as as defaultTabIntervalFromSettings, at as displayText, au as effectiveContentControlLock, av as formatPageNumber, aw as fragmentsOfParagraph, ax as lineAtPosition, ay as linesOf, az as measureDisplayText, aA as nextTabDestination, aB as paragraphBorderExtentPt, aC as paragraphBorderStrokeWidthPt, aD as paragraphBorders, aE as paragraphBordersFingerprint, aF as paragraphBreaksBefore, aG as paragraphContextualSpacing, aH as paragraphFragmentsOf, aI as paragraphFragmentsOfBlocks, aJ as paragraphLineSpacing, aK as paragraphSpacing, aL as paragraphTabStops, aM as readBorderSide, aN as readCellBorders, aO as readTableBorders, aP as resolveBorderConflict, aQ as resolveRunStyle, aR as resolveTableCellBorderGrid, aS as runStylesEqual, aT as tabAdvanceWidth, aU as tabStopsFingerprint, aV as unionLayoutBoxes, aW as withDefaultTabInterval } from './semantic-records-zTC0_1zi.js';
 import { O as OoxmlNode, a as OoxmlElement, e as OoxmlPart } from './ooxml-tree-BU0e3DVi.js';
-import { O as OoxmlProperty, C as ContentControlKind, n as ContentControlLevel, o as ContentControlLock, p as ContentControlDataBinding, I as ImpactClass } from './tree-op-types-CwOeiaQ8.js';
-export { l as TableBorderStyle } from './tree-op-types-CwOeiaQ8.js';
+import { O as OoxmlProperty, C as ContentControlKind, n as ContentControlLevel, o as ContentControlLock, p as ContentControlDataBinding, I as ImpactClass } from './tree-op-types-DWLCllG7.js';
+export { l as TableBorderStyle } from './tree-op-types-DWLCllG7.js';
 import { N as NoteKind, n as noteTypeOf } from './note-nodes-BPSTVDMr.js';
-import { R as ResolvedFootnoteProperties, a as ResolvedEndnoteProperties } from './note-properties-m75hmP70.js';
+import { R as ResolvedFootnoteProperties, a as ResolvedEndnoteProperties } from './review-reads-CsoXSvUg.js';
+export { p as paragraphOrderOfPart } from './review-reads-CsoXSvUg.js';
 import { R as RevisionDisplayMode } from './revision-projection-DHAkcD_L.js';
 export { D as DEFAULT_REVISION_DISPLAY_MODE, a as RevisionAttribution, b as RevisionKind, f as formatRevisionOf, p as paragraphMarkRevisionOf, r as revisionsAreDeletion, c as revisionsVisible } from './revision-projection-DHAkcD_L.js';
-import { a as SectionColumns } from './semantic-cell-selection-DsmHmLJ5.js';
-export { C as CellSelection, D as DEFAULT_SECTION_PROPERTIES, b as DEFAULT_VERTICAL_WEIGHT, c as DocumentSection, d as DocumentSectionsEnumeration, e as DrawingOverlayFrame, H as HitPoint, f as HitTestOptions, M as MAX_DOCUMENT_SECTIONS, P as PlacedCell, g as SectionBreakType, h as SectionColumnDefinition, i as SectionMargins, j as SectionPageNumbering, S as SectionProperties, k as SemanticHit, l as SemanticHitDrawing, T as TableCellAddress, m as TableCellContext, n as caretBoxOnLine, o as cellSelectionBetween, p as cellSelectionRects, q as cellSelectionText, r as contentControlAtPoint, s as enumerateDocumentSections, t as enumerateDocumentSectionsBounded, u as findDrawingOverlayFrameInLayout, v as geometryOfSection, w as hitTestPage, x as hitTestSheet, y as isFurniturePoint, z as lineEndOffset, A as pageAtY, B as paragraphSectionNode, E as paragraphsInCells, F as parsePageNumbering, G as parseSectionProperties, I as readSectionProperties, J as spanOffsetX, K as spansInCells, L as tableContextAt } from './semantic-cell-selection-DsmHmLJ5.js';
+import { a as SectionColumns } from './semantic-cell-selection-D_8RbPII.js';
+export { C as CellSelection, D as DEFAULT_SECTION_PROPERTIES, b as DEFAULT_VERTICAL_WEIGHT, c as DocumentSection, d as DocumentSectionsEnumeration, e as DrawingOverlayFrame, H as HitPoint, f as HitTestOptions, M as MAX_DOCUMENT_SECTIONS, P as PlacedCell, g as SectionBreakType, h as SectionColumnDefinition, i as SectionMargins, j as SectionPageNumbering, S as SectionProperties, k as SemanticHit, l as SemanticHitDrawing, T as TableCellAddress, m as TableCellContext, n as caretBoxOnLine, o as cellSelectionBetween, p as cellSelectionRects, q as cellSelectionText, r as contentControlAtPoint, s as enumerateDocumentSections, t as enumerateDocumentSectionsBounded, u as findDrawingOverlayFrameInLayout, v as geometryOfSection, w as hitTestPage, x as hitTestSheet, y as isFurniturePoint, z as lineEndOffset, A as pageAtY, B as paragraphSectionNode, E as paragraphsInCells, F as parsePageNumbering, G as parseSectionProperties, I as readSectionProperties, J as spanOffsetX, K as spansInCells, L as tableContextAt } from './semantic-cell-selection-D_8RbPII.js';
 export { M as MAX_SDT_NESTING, c as collectFlowBlocks, a as contentControlContentChildren, i as isContentControl, b as isContentControlContent } from './content-control-walk-D06GijR0.js';
-export { h as CommentAnchor, i as CommentPosition, C as CommentRecord, j as CommentThreadState, c as ReviewCommentItem, d as ReviewCustomItem, a as ReviewItem, R as ReviewModelInput, k as ReviewParagraphAnchor, e as ReviewPosition, f as ReviewRange, b as ReviewRevisionItem, g as ReviewRevisionKind, W as W15_NAMESPACE_URI, l as activeReviewItem, m as commentBodyText, n as commentInitials, o as firstReviewRange, p as paragraphOrderOfPart, r as reviewAnchorIndex, q as reviewItemGeometry, s as reviewItemKey, t as reviewItemPositionRank, u as reviewItemRanges, v as reviewItemsAt, w as reviewThreadRootOf } from './review-support-Fy3vdIea.js';
-import { T as TreeModelChange } from './tree-store-hLtjeyWE.js';
-export { b as CaretAtOptions, C as CaretGeometry, K as KeyedRange, M as MoveCaretOptions, N as NavigationCommand, c as SelectionRect, S as SemanticPosition, a as SemanticSelection, d as caretAt, e as caretStops, f as caretStopsForBlocks, g as compositionAnchor, h as contentControlAtSemantic, i as contentControlsInLayout, j as documentOrder, k as hitTestSemantic, l as keyedRangeRects, m as moveCaret, p as paragraphTextFromLayout, s as selectionRects, n as spansInSelection, w as wordBoundary } from './semantic-interaction-Dy-dCUFF.js';
-import './image-resources-BJnTpG66.js';
+export { h as CommentAnchor, i as CommentPosition, C as CommentRecord, j as CommentThreadState, c as ReviewCommentItem, d as ReviewCustomItem, a as ReviewItem, R as ReviewModelInput, k as ReviewParagraphAnchor, e as ReviewPosition, f as ReviewRange, b as ReviewRevisionItem, g as ReviewRevisionKind, W as W15_NAMESPACE_URI, l as activeReviewItem, m as commentBodyText, n as commentInitials, o as firstReviewRange, r as reviewAnchorIndex, p as reviewItemGeometry, q as reviewItemKey, s as reviewItemPositionRank, t as reviewItemRanges, u as reviewItemsAt, v as reviewThreadRootOf } from './review-support-nsLXC9jf.js';
+import { T as TreeModelChange } from './tree-store-BscFPB7x.js';
+export { b as CaretAtOptions, C as CaretGeometry, K as KeyedRange, M as MoveCaretOptions, N as NavigationCommand, c as SelectionRect, S as SemanticPosition, a as SemanticSelection, d as caretAt, e as caretStops, f as caretStopsForBlocks, g as compositionAnchor, h as contentControlAtSemantic, i as contentControlsInLayout, j as documentOrder, k as hitTestSemantic, l as keyedRangeRects, m as moveCaret, p as paragraphTextFromLayout, s as selectionRects, n as spansInSelection, w as wordBoundary } from './semantic-interaction-CXH2wFqi.js';
+import './image-resources-C_YnqPhn.js';
 import './ooxml-package-D_CtywTW.js';
 
 /**
@@ -32,18 +33,84 @@ interface StoryPageFieldNeeds {
     readonly hasSectionPages: boolean;
 }
 
-type WrapTextSide = 'bothSides' | 'left' | 'right' | 'largest';
-interface WrapExclusionInput {
-    readonly mode: 'square' | 'tight' | 'through' | 'topAndBottom';
-    readonly contentBounds: LayoutBox;
-    readonly polygon: readonly DrawingPoint[] | null;
-    readonly clipPolygon: readonly DrawingPoint[] | null;
-    readonly wrapDistances: DrawingInsets;
-    readonly effectInsets: DrawingInsets;
-    readonly textSide: WrapTextSide;
-    readonly contentLeft: number;
-    readonly contentRight: number;
+/** A fingerprint over one paragraph's layout inputs. */
+type ParagraphLayoutKey = string;
+/** Cache counters, for asserting that incremental layout is actually reusing work. */
+interface LayoutCacheStats {
+    readonly hits: number;
+    readonly misses: number;
+    readonly evictions: number;
+    readonly size: number;
+}
+/**
+ * The per-paragraph measurement cache.
+ *
+ * Caches the BREAK only — where a paragraph's lines fall at a given width — never its placement.
+ * An edit high in a document still repaginates everything below it, while paragraphs nobody
+ * touched are never measured again.
+ */
+interface ParagraphLayoutCache<T> {
+    get(key: ParagraphLayoutKey): T | undefined;
+    set(key: ParagraphLayoutKey, value: T): void;
+    /** Drop entries for paragraphs a commit removed, so the cache cannot grow without bound. */
+    retain(keys: ReadonlySet<ParagraphLayoutKey>): void;
+    clear(): void;
+    readonly stats: LayoutCacheStats;
+}
+/**
+ * Everything that decides whether a cached paragraph break is still valid.
+ *
+ * `producer` is in the key because a font arriving after first paint changes every advance in the
+ * document while no content changes — without it the cache would serve the pre-font layout
+ * forever.
+ */
+interface ParagraphKeyInputs {
+    readonly paragraph: OoxmlNode;
+    readonly properties: readonly OoxmlProperty[];
+    /** Available width, which decides where the lines break. */
+    readonly width: number;
+    /**
+     * Who produced the measurements.
+     *
+     * Fonts loading after first paint change every advance while no content changes, so a
+     * cache keyed on content alone would serve the pre-font layout forever.
+     */
+    readonly producer: string;
+    /**
+     * Inline drawing projection/resource epoch for this paragraph.
+     *
+     * Pending→ready/refused transitions and extent/hidden changes must invalidate breaks even
+     * when paragraph text is unchanged.
+     */
+    readonly drawingToken?: string;
+    /** Active page exclusion zones affecting this paragraph's break. */
+    readonly exclusionToken?: string;
+}
+/**
+ * The cache key for one paragraph's measured break.
+ *
+ * Folds in the content, the available width, and the measurement producer. Anything that changes
+ * where lines fall must be in here, or the cache serves a break taken under different conditions.
+ */
+declare function paragraphLayoutKey(inputs: ParagraphKeyInputs): ParagraphLayoutKey;
+/** How large the paragraph cache grows before least-recently-used eviction. */
+interface ParagraphLayoutCacheOptions {
+    /**
+     * Entries retained before the least recently used are dropped.
+     *
+     * The default has to exceed a realistic document, or a full pass evicts exactly what the
+     * next one needs and the cache costs more than it saves.
+     */
+    readonly maxEntries?: number;
 }
+/**
+ * A bounded least-recently-used cache.
+ *
+ * Bounded because a long editing session touches far more paragraph states than a document
+ * contains — every keystroke mints a new key for the paragraph being typed in — and an
+ * unbounded cache would hold every intermediate state of the session.
+ */
+declare function createParagraphLayoutCache<T>(options?: ParagraphLayoutCacheOptions): ParagraphLayoutCache<T>;
 
 /**
  * Lookup of derived display marks keyed by {@link formatNoteScopeId}.
@@ -95,988 +162,940 @@ interface ProjectedNoteMark {
 /** Resolve display text for a noteReference / noteRef node under a mark context. */
 declare function projectedNoteMarkText(node: OoxmlNode, context: NoteMarkContext | undefined): ProjectedNoteMark | null;
 
-/**
- * What one cell side is before any ADJACENT cell has its say.
- *
- * - omitted → the table's own rule for that position (`tblBorders`, `insideH`/`insideV`)
- * - edge → the cell wins outright; no weight fight with the table
- * - none → an explicit `w:val="nil"`. Suppresses a matching table border on interior
- *   and perimeter sides alike, so a table whose cells all declare none paints borderless
- *   like Word even when `tblBorders` still carry `single` rules.
- */
-declare function effectiveBorderSide(authored: TableBorderSide, tableSide: TableBorderSide, _options?: {
-    readonly interior?: boolean;
-}): TableBorderSide;
+type WrapTextSide = 'bothSides' | 'left' | 'right' | 'largest';
+interface WrapExclusionInput {
+    readonly mode: 'square' | 'tight' | 'through' | 'topAndBottom';
+    readonly contentBounds: LayoutBox;
+    readonly polygon: readonly DrawingPoint[] | null;
+    readonly clipPolygon: readonly DrawingPoint[] | null;
+    readonly wrapDistances: DrawingInsets;
+    readonly effectInsets: DrawingInsets;
+    readonly textSide: WrapTextSide;
+    readonly contentLeft: number;
+    readonly contentRight: number;
+}
 
-/** Minimum stroke width for a compound (double/triple) band, in points. */
-declare const COMPOUND_BORDER_MIN_STROKE_PT = 1;
-/** Minimum gap between compound strokes, in points. */
-declare const COMPOUND_BORDER_MIN_GAP_PT = 1;
+/** Paint layer relative to body text — not the OOXML wrap element. */
+type DrawingPaintLayer = 'behind' | 'inFront';
+interface ExclusionZone {
+    readonly drawingNodeId: string;
+    readonly anchorParagraphId: string;
+    /** UTF-16 model offset of the anchor atom — exclusions apply at/after this point in the paragraph. */
+    readonly anchorModelStart: number;
+    readonly sourceOrder: number;
+    readonly paintLayer: DrawingPaintLayer;
+    readonly relativeHeight: number;
+    readonly allowOverlap: boolean;
+    /** Owning column index in a multi-column section — 0 for single-column and HF stories. */
+    readonly columnIndex: number;
+    /** Resolved top edge in page-content coordinates after overlap displacement. */
+    readonly y: number;
+    readonly verticalBand: LayoutBox;
+    readonly input: WrapExclusionInput;
+}
+
+interface PendingLine {
+    readonly spans: StyleSpanRecord[];
+    readonly drawings: InlineDrawingRecord[];
+    readonly start: number;
+    end: number;
+    width: number;
+    height: number;
+    baseline: number;
+    /**
+     * Space ABOVE the glyph band inside {@link height}.
+     *
+     * Exact spacing can center the glyphs and move the baseline. Auto/atLeast spacing leaves
+     * this at zero and puts its extra depth below instead.
+     */
+    leading: number;
+    /**
+     * Auto/atLeast line-spacing depth below the painted glyph band.
+     *
+     * Word lets this external depth cross the bottom text margin when the glyphs themselves
+     * still fit. Pagination therefore budgets {@link height} minus this amount at a page
+     * bottom, while paint keeps the full box and padding.
+     */
+    trailingSpacing: number;
+    /** When true, layout must start a new page after this line is placed. */
+    pageBreakAfter?: boolean;
+    /** When true, layout must advance to the next authored section column. */
+    columnBreakAfter?: boolean;
+    /** Model ranges on this line covering deleted content; see {@link LineRecord.deletedRanges}. */
+    deletedRanges?: readonly ModelRange[];
+    /** Vertical gap inserted before this line to clear a topAndBottom exclusion band. */
+    exclusionSkipBefore?: number;
+}
+/** Horizontal alignment of a paragraph (`w:jc`, ECMA-376 §17.3.1.13). */
+type Alignment = 'left' | 'center' | 'right' | 'both';
+
+/** 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';
 /**
- * How a multi-line border style (double, triple) is drawn: stroke width, gap, and total extent.
+ * One level's indent, plus which parts the level actually AUTHORED.
  *
- * The band is CENTRED on the authored width, so a double border occupies the space Word gives it
- * rather than growing the cell it surrounds.
+ * 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 CompoundBorderMetrics {
-    readonly strokePt: number;
-    readonly gapPt: number;
-    readonly extentPt: number;
-    /** Centers the compound band on the authored width; negative extends outward. */
-    readonly insetPt: number;
+interface NumberingLevelIndent {
+    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 paragraph style and direct formatting, so the
+     * merge has to tell "the level says left = 0" from "the level says nothing about left and
+     * the style's value stands". Absent (the default) reads as "says nothing", which is what a
+     * 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;
+    /** 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;
 }
 /**
- * Deterministic double stroke / gap / extent in layout points (scale-independent).
+ * One `w:lvlOverride` on a `w:num`: a restart value, a replacement level, or both.
  *
- * Thin authored widths inflate to a 1+1+1 point compound so a `w:sz="3"` double remains
- * visible at paint scale 1 — matching Word's hairline-double floor.
+ * How two lists share an abstract definition while numbering independently.
  */
-declare function computeDoubleBorderMetricsPt(widthPt: number): CompoundBorderMetrics;
-
+interface LevelOverride {
+    readonly startOverride?: number;
+    /** Full level replacement when `w:lvl` is present under the override. */
+    readonly level?: NumberingLevel;
+}
 /**
- * The exact HarfBuzz build this engine shapes against.
+ * One `w:abstractNum` — the shape of a list, without being a list.
  *
- * Pinned and verified at load: a runtime reporting a different version is REFUSED rather than
- * used, because glyph positioning can change between releases and a cached measurement taken
- * under one build must not be trusted under another.
+ * 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.
  */
-declare const HARFBUZZ_SHAPING_LIBRARY: VersionedShapingLibrary;
-/** Load and verify the HarfBuzz WASM runtime without adding top-level await to import graphs. */
-declare function initializeHarfBuzz(): Promise<void>;
-/** Whether the WASM runtime is loaded and shaping can proceed synchronously. */
-declare function isHarfBuzzInitialized(): boolean;
-/**
- * Why shaping refused.
- *
- * Mostly RESOURCE limits, because every input here derives from a file: text length, codepoint
- * count, glyph count and outline size are all attacker-influenced, and an unbounded shape call is
- * a denial-of-service vector rather than a rendering bug.
- */
-type HarfBuzzShapingErrorCode = 'notInitialized' | 'fontOverLimit' | 'malformedFont' | 'textOverLimit' | 'codepointsOverLimit' | 'glyphOverLimit' | 'outlineOverLimit' | 'shapedRunOverLimit' | 'unsupportedVariationAxes' | 'unsupportedFallback' | 'unsupportedColorFont' | 'unsupportedNormalization' | 'invalidBidiLevel' | 'shapingLibraryMismatch' | 'disposed';
+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;
+}
 /**
- * A shaping call that was refused, carrying the limit it exceeded where there was one.
+ * One `w:num` — the thing a paragraph's `w:numId` actually names.
  *
- * Thrown rather than returned: unlike a missing font, a run that cannot be shaped has no sensible
- * fallback measurement, and continuing would lay text out at made-up widths.
+ * Points at an {@link AbstractNumDefinition} and may override any of its levels.
  */
-declare class HarfBuzzShapingError extends Error {
-    readonly name = "HarfBuzzShapingError";
-    readonly code: HarfBuzzShapingErrorCode;
-    readonly limit?: number;
-    readonly actual?: number;
-    readonly diagnostic?: string;
-    constructor(code: HarfBuzzShapingErrorCode, details?: {
-        readonly limit?: number;
-        readonly actual?: number;
-        readonly diagnostic?: string;
-    });
+interface NumDefinition {
+    readonly numId: string;
+    readonly abstractNumId: string;
+    readonly overrides: ReadonlyMap<number, LevelOverride>;
 }
 /**
- * Resource budgets and cache sizes for one shaper. Every field optional.
+ * The bounded projection of `numbering.xml` that list layout resolves against.
  *
- * The caches exist because shaping is the expensive step: a face is opened once and reused, and
- * identical runs return their previous result. The caps exist because file-derived input decides
- * how much work is asked for.
+ * 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 HarfBuzzTextShaperOptions {
-    readonly maxFontBytes?: number;
-    readonly maxInputUtf16?: number;
-    readonly maxCodepoints?: number;
-    readonly maxGlyphs?: number;
-    readonly maxCachedFaces?: number;
-    readonly maxCachedShapes?: number;
-    readonly maxOutlineBytes?: number;
-    readonly maxCachedOutlineBytes?: number;
-    readonly maxShapedRunBytes?: number;
-    readonly maxCachedShapeBytes?: number;
-    readonly instrumentation?: HarfBuzzTextShaperInstrumentation;
-}
-/** One face-cache transition, for instrumentation. */
-interface HarfBuzzFaceCacheEvent {
-    readonly kind: 'created' | 'hit' | 'evicted';
-    readonly identity: string;
+interface NumberingIndex {
+    readonly abstractNums: ReadonlyMap<string, AbstractNumDefinition>;
+    readonly nums: ReadonlyMap<string, NumDefinition>;
 }
 /**
- * Optional counters for the work a shaper is expected to do rarely.
+ * Build a numbering index from the root of a numbering part (`w:numbering`).
  *
- * Exists so tests can assert the ABSENCE of work — re-opening a face or re-copying its bytes per
- * shape call would not change any output, only make typing slow, which no rendering assertion
- * would catch.
+ * Empty / missing roots yield an empty index. Duplicate ids keep the first definition.
  */
-interface HarfBuzzTextShaperInstrumentation {
-    readonly onFaceCacheEvent?: (event: HarfBuzzFaceCacheEvent) => void;
-    readonly onShapeCacheEvent?: (event: HarfBuzzShapeCacheEvent) => void;
-    readonly onByteCopy?: () => void;
-    readonly onTableScan?: () => void;
-    readonly onShapeCall?: () => void;
-    readonly onOutlinePathCall?: () => void;
-    readonly onOutlineCacheEvent?: (event: HarfBuzzOutlineCacheEvent) => void;
-}
-/** One shape-cache transition, for instrumentation. */
-interface HarfBuzzShapeCacheEvent {
-    readonly kind: 'hit' | 'miss' | 'stored' | 'evicted' | 'skipped' | 'cleared';
-    readonly retainedBytes: number;
-}
-/** One outline-cache transition, for instrumentation. */
-interface HarfBuzzOutlineCacheEvent {
-    readonly kind: 'created' | 'hit' | 'evicted' | 'skipped' | 'cleared';
-    readonly retainedBytes: number;
-}
 /**
- * A {@link TextShaper} backed by HarfBuzz, holding WASM resources.
+ * Project `numbering.xml` into the bounded index.
  *
- * {@link HarfBuzzTextShaper.dispose} is not optional housekeeping: the cached faces are WASM
- * allocations that garbage collection cannot reclaim, so a shaper outliving its editor leaks
- * until the page goes away.
+ * 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.
  */
-interface HarfBuzzTextShaper extends TextShaper {
-    dispose(): void;
-}
-/** Structural sfnt validation that does not construct native HarfBuzz objects. */
-declare const harfBuzzFontValidator: FontByteValidator;
-/** Convert signed font units by an exact rational multiplier using the declared tie rule. */
-declare const roundFontUnitToFixedPoint: (fontUnits: number, denominator: number, numerator: number, mode: FixedPointRoundingMode) => FixedPoint;
+declare function buildNumberingIndex(root: OoxmlElement | null | undefined): NumberingIndex;
+/** Resolve the effective level for a `numId` + `ilvl`, applying overrides. */
 /**
- * Build a HarfBuzz-backed shaper.
+ * The effective level for one paragraph's numbering reference, after overrides and style links.
  *
- * Requires `initializeHarfBuzz()` to have resolved — shaping is synchronous, so the WASM runtime
- * must already be loaded. Dispose the result when the editor goes away, or its cached faces leak.
+ * 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 const createHarfBuzzTextShaper: (options?: HarfBuzzTextShaperOptions) => HarfBuzzTextShaper;
+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;
 
 /**
- * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
- * within.
+ * A paragraph's list membership fully resolved: definition, level, marker text and geometry.
  *
- * The level is EXACT, not a direction: its parity gives direction, but the numeric value is what
- * reordering needs, and collapsing it early loses nested isolates.
+ * `markerText` is already expanded through the counter state, so it is the string a reader sees
+ * rather than the `w:lvlText` template.
  */
-interface BidiEmbeddingLevels {
-    readonly levels: Uint8Array;
-    readonly paragraphs: readonly {
-        readonly start: number;
-        readonly end: number;
-        readonly level: number;
-    }[];
+interface ResolvedListItem {
+    readonly numId: string;
+    readonly ilvl: number;
+    readonly abstractNumId: string;
+    /** `w:numFmt` of the resolved level — `bullet` or a numbering format. */
+    readonly numFmt: string;
+    readonly markerText: string;
+    readonly markerAlign: ListMarkerAlign;
+    readonly suffix: ListSuffix;
+    /** Effective indent after merging level + paragraph indents, in points. */
+    readonly indent: NumberingLevelIndent;
+    readonly markerStyle: ResolvedRunStyle;
+    /** Fingerprint for layout cache keys (indent + level identity, not ordinal). */
+    readonly cacheToken: string;
 }
-
 /**
- * Which `w:rFonts` slot a character resolves its face through.
+ * Read `w:numPr` from cascaded paragraph-property nodes (last wins).
  *
- * OOXML gives a run up to four faces and picks between them by SCRIPT, so one run of mixed Latin
- * and CJK text uses two different fonts without saying so anywhere in its properties.
+ * Flat `OoxmlProperty[]` bags drop nested `ilvl`/`numId`, so this walks the tree nodes
+ * the same way borders and tabs do.
  */
-type FontSlot = 'ascii' | 'hAnsi' | 'eastAsia' | 'cs';
+declare function readNumPr(paragraphPropertyNodes: readonly OoxmlNode[]): {
+    numId: string;
+    ilvl: number;
+} | null;
 /**
- * A run of text sharing one script, direction and font slot — the unit handed to the shaper.
+ * Resolve `w:numStyleLink` delegation using the document's styles (§17.9.21).
  *
- * Shaping cannot span a script change: Arabic and Latin in one call would produce wrong joining
- * behaviour, so a run is itemized into these first.
+ * Without a style table there is nothing to follow, so the index is returned unchanged —
+ * and so it is when nothing delegates, which keeps layout cache identity.
  */
-interface ScriptItem {
-    readonly from: number;
-    readonly to: number;
-    readonly direction: TextDirection;
-    readonly bidiLevel: number;
-    readonly script: 'Zyyy' | 'Latn' | 'Grek' | 'Cyrl' | 'Hani' | 'Hebr' | 'Arab' | 'Deva' | 'Beng' | 'Thai' | 'Khmr';
-    readonly slot: FontSlot;
-}
+declare function withNumberingStyleLinks(index: NumberingIndex, styleCascade: StyleCascadeTable | undefined): NumberingIndex;
 /**
- * A code point whose script this engine does not itemize.
+ * The effective indent of a list paragraph: STYLE, then the numbering LEVEL, then DIRECT.
  *
- * Carries the offending `codePoint` so the caller can report which character stopped it, rather
- * than failing anonymously somewhere in the middle of a paragraph.
+ * Word applies a level's `w:pPr/w:ind` between the paragraph style and the paragraph's own
+ * formatting, per attribute — and the ordering matters on real documents. A converted
+ * agreement numbers its `(a)` items with a level stating `left=1512 hanging=738` under a
+ * `ListParagraph` style stating `left=775 hanging=624`, and states only `hanging="737"` on
+ * the paragraph itself. Reading the flattened cascade as "the paragraph's indent" gave the
+ * STYLE's 775 to a level that had overridden it, so every lettered sub-item hung a full
+ * indent step to the left of where Word puts it.
+ *
+ * `inherited` is the cascade WITHOUT the paragraph's own `w:pPr` (defaults, table cell style,
+ * style chain); `direct` is that `w:pPr` alone.
  */
-declare class UnsupportedScriptError extends Error {
-    readonly name = "UnsupportedScriptError";
-    readonly code = "unsupportedScript";
-    readonly codePoint: number;
-    constructor(codePoint: number);
-}
+declare function mergeListIndent(levelIndent: NumberingLevelIndent, inherited: readonly OoxmlProperty[], direct?: readonly OoxmlProperty[]): NumberingLevelIndent;
 /**
- * Split text into shapeable runs by script, bidi level and font slot.
+ * Collect paragraphs of a block list in document order, descending into tables.
  *
- * Consumes the bidi levels rather than re-deriving direction, so itemization and reordering agree
- * by construction instead of by two implementations happening to match.
+ * Caps nesting so a hostile nested-table document cannot recurse without bound.
  */
-declare function itemizeScriptFontSlots(text: string, paragraphOffset: number, embedding: BidiEmbeddingLevels): readonly ScriptItem[];
-
-/** UTF-16 boundaries that are both whole-grapheme and HarfBuzz cluster edges. */
-declare function shapedHorizontalBoundaries(run: ShapedRun): readonly number[];
+declare function walkStoryParagraphs(blocks: readonly OoxmlElement[], maxTableDepth?: number): OoxmlElement[];
 /**
- * Whether an offset is a real caret position: both a grapheme boundary and a shaped cluster edge.
+ * Resolve every list paragraph in a story to a {@link ResolvedListItem}, keyed by node id.
  *
- * Both conditions, because they disagree. A ligature is one cluster spanning two graphemes, and
- * an offset inside it has no geometry the shaper can answer for — placing a caret there would
- * mean inventing an x coordinate.
+ * Non-list paragraphs are absent from the map. Hostile / missing numbering resolves inertly
+ * (paragraph omitted — laid out as ordinary text).
  */
-declare function isWholeGraphemeHorizontalBoundary(run: ShapedRun, utf16Offset: number): boolean;
-/** Every published shaped boundary has exact geometry from the shaping result. */
-declare function isGeometryTrustedCaretOffset(run: ShapedRun, utf16Offset: number): boolean;
+declare function resolveStoryListItems(blocks: readonly OoxmlElement[], index: NumberingIndex, styleCascade: StyleCascadeTable | undefined, isFontAvailable?: (family: string) => boolean): ReadonlyMap<string, ResolvedListItem>;
 /**
- * Whether the distance from a line's start to an offset can be trusted as exact.
+ * Attach a full-story list-item map to layout options.
  *
- * Requires BOTH ends to be shaped boundaries: accumulating advances across an offset the shaper
- * cannot place would produce a caret x that drifts further along the line.
+ * Resolves once over `blocks` (body story including table cells) so counters continue across
+ * section boundaries. No-ops when numbering is absent.
  */
-declare function isCumulativeGeometryTrustedFromLineOrigin(run: ShapedRun, lineStartUtf16Offset: number, utf16Offset: number): boolean;
-/** Grapheme offsets corresponding to exact shaped boundaries. */
-declare function semanticHorizontalBoundaries(run: ShapedRun): readonly number[];
-
+declare function withResolvedListItems<T extends {
+    readonly numberingIndex?: NumberingIndex;
+    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
+    readonly styleCascade?: StyleCascadeTable;
+    /**
+     * Host oracle for "is this font family really loaded". Supplied, a Symbol/Wingdings
+     * bullet keeps the file's own private-use codepoint so the authored typeface draws it;
+     * absent, it falls back to the Unicode equivalent rather than a tofu box.
+     */
+    readonly isFontAvailable?: (family: string) => boolean;
+}>(options: T, blocks: readonly OoxmlElement[]): T & {
+    readonly numberingIndex: NumberingIndex;
+    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
+};
 /**
- * One user-perceived character, and the UTF-16 range that encodes it.
+ * Horizontal marker box inside the hanging indent slot.
  *
- * The unit a caret moves by. An emoji with a skin-tone modifier is ONE segment spanning several
- * UTF-16 code units, so stepping by code unit would put the caret inside it.
+ * Coordinates are relative to the same origin as paragraph content (`indent.left` is the
+ * text start). Returns null when there is nothing to paint.
  */
-interface GraphemeSegment {
-    readonly index: number;
-    readonly text: string;
-    readonly utf16From: number;
-    readonly utf16To: number;
+declare function listMarkerBox(item: ResolvedListItem, markerWidth: number, lineY: number, lineHeight: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+
+/** Soft ceiling on `basedOn` chain length — enough for real templates, refuses hostile graphs. */
+declare const MAX_STYLE_BASED_ON_DEPTH = 32;
+/** Soft ceiling on style definitions read from one styles part. */
+declare const MAX_STYLE_DEFINITIONS = 4096;
+/** One `w:style` as the cascade reads it: its properties, and the style it is based on. */
+interface StyleDefinition {
+    readonly styleId: string;
+    readonly type: string;
+    readonly basedOn: string | null;
+    readonly paragraphProperties: readonly OoxmlProperty[];
+    readonly runProperties: readonly OoxmlProperty[];
+    /** The style's `w:pPr` node, when present — needed for nested `w:pBdr`. */
+    readonly paragraphPropertiesNode: OoxmlElement | undefined;
+    /** The style's `w:tblPr`, for a `w:type="table"` style. */
+    readonly tablePropertiesNode: OoxmlElement | undefined;
+    /**
+     * `w:tblStylePr` conditional formats by `w:type` (`firstRow`, `band1Horz`, …).
+     *
+     * Word puts a table's real appearance here: `Table Grid` carries its grid in the style's
+     * `w:tblBorders`, and the banded/​header looks live in these. A document states only
+     * `<w:tblStyle w:val="TableGrid"/>`.
+     */
+    readonly conditionalTableFormats: ReadonlyMap<string, OoxmlElement>;
 }
 /**
- * The replaceable segmentation strategy.
+ * The whole styles part, indexed and ready to resolve against.
  *
- * An explicit seam rather than a direct `Intl.Segmenter` call, so tests can install a
- * deterministic boundary and a runtime without `Intl.Segmenter` can be given one.
+ * `cacheToken` is load-bearing: it folds into layout cache producers so breaks measured under one
+ * styles part are never reused under another.
  */
-interface GraphemeBoundary {
-    segment(text: string): readonly GraphemeSegment[];
+interface StyleCascadeTable {
+    /**
+     * Bounded fingerprint folded into layout cache producers so a different styles part cannot
+     * reuse breaks measured under another cascade. Computed once per table (FNV-1a hex).
+     */
+    readonly cacheToken: string;
+    readonly docDefaultsRun: readonly OoxmlProperty[];
+    readonly docDefaultsParagraph: readonly OoxmlProperty[];
+    readonly docDefaultsParagraphNode: OoxmlElement | undefined;
+    /** `w:style[@w:default='1'][@w:type='paragraph']` — last wins among defaults of that type. */
+    readonly defaultParagraphStyleId: string | null;
+    /** `w:style[@w:default='1'][@w:type='character']` — last wins among defaults of that type. */
+    readonly defaultCharacterStyleId: string | null;
+    /**
+     * The theme part's Latin typefaces, for `w:rFonts` theme references.
+     *
+     * Lives on the cascade because it is document-level style material with the same
+     * lifetime, and because every site that resolves run properties already holds this table.
+     */
+    readonly themeFonts: ThemeFonts;
+    readonly styles: ReadonlyMap<string, StyleDefinition>;
 }
-/** Invariant locale for deterministic cross-runtime grapheme boundaries. */
-declare const GRAPHEME_SEGMENTER_LOCALE: "und";
-/** Whether this runtime provides `Intl.Segmenter`, which the default boundary requires. */
-declare function isIntlSegmenterAvailable(): boolean;
 /**
- * The default boundary, over `Intl.Segmenter` at the invariant `und` locale.
+ * A paragraph's properties after the cascade, plus the same list WITHOUT its own `w:pPr`.
  *
- * Locale-invariant on purpose: grapheme boundaries must not vary with the user's locale, or the
- * same document would paginate differently for different readers.
+ * Both, because a writer needs to know what a paragraph INHERITS to decide whether setting a
+ * value is a change or a no-op — and writing back an inherited value freezes it into the
+ * paragraph as though the author had chosen it.
  */
-declare const intlGraphemeBoundary: GraphemeBoundary;
-/** Current boundary generation, for callers that cache segmentation-derived answers. */
-declare function graphemeBoundaryEpoch(): number;
+interface CascadedParagraphFormatting {
+    /** Flat paragraph properties in cascade order (defaults → bases → style → direct). */
+    readonly paragraphProperties: readonly OoxmlProperty[];
+    /**
+     * The same list WITHOUT the paragraph's own `w:pPr` — everything it inherits.
+     *
+     * Numbering needs the two tiers apart: a level's `w:pPr/w:ind` outranks the style's and is
+     * outranked by the paragraph's own, and a flattened list cannot say which is which.
+     */
+    readonly inheritedParagraphProperties: readonly OoxmlProperty[];
+    /** Matching `w:pPr` nodes for nested border resolution. */
+    readonly paragraphPropertyNodes: readonly OoxmlNode[];
+    /**
+     * Inherited run properties for CONTENT runs (before direct run `rPr`).
+     *
+     * Does NOT include direct `w:pPr/w:rPr` — that formats the paragraph MARK only
+     * (ECMA-376 §17.3.1.36). Folding mark `w:sz` into content made BodyText runs with no
+     * direct size paint at the mark's size (Selection Notice "or" alternative → 6.5pt).
+     */
+    readonly runProperties: readonly OoxmlProperty[];
+    /**
+     * Content cascade plus direct `w:pPr/w:rPr` — empty-line metrics and last-line mark height.
+     */
+    readonly markRunProperties: readonly OoxmlProperty[];
+    /**
+     * The style this paragraph resolved to, or null when it names none and there is no
+     * document default. `w:contextualSpacing` compares neighbours by exactly this.
+     */
+    readonly styleId: string | null;
+}
+/** Accepted style ids only — over-long, control-bearing, or dangerous keys are dropped. */
+declare function isValidStyleId(raw: string | undefined): raw is string;
 /**
- * Split text into graphemes through the active boundary.
+ * What a table style contributes to the paragraphs of ONE cell: the style's whole-table
+ * `w:pPr`/`w:rPr` followed by every `w:tblStylePr` the cell is under (17.7.6.6), weakest
+ * first in the caller's condition order (banding, column, row, corner).
  *
- * Memoized on the last texts seen, because paragraph layout asks about the same string
- * repeatedly and a full segmentation pass per call made layout quadratic in paragraph length.
+ * This is how Word makes a header row bold and centred while the document states nothing
+ * but `<w:tblStyle w:val="…"/>` on the table and plain runs in the cells.
  */
-declare function segmentGraphemes(text: string): readonly GraphemeSegment[];
+interface TableCellStyleFormatting {
+    readonly paragraphProperties: readonly OoxmlProperty[];
+    /** Matching `w:pPr` nodes, for nested `w:pBdr` / `w:tabs` resolution. */
+    readonly paragraphPropertyNodes: readonly OoxmlElement[];
+    /** Inherited run properties for every run in the cell, before the paragraph style. */
+    readonly runProperties: readonly OoxmlProperty[];
+}
 /**
- * Install a different segmentation strategy, invalidating the memo.
+ * Build a cascade table from a styles part root.
  *
- * For tests and for runtimes lacking `Intl.Segmenter`. Call {@link resetGraphemeBoundary} to
- * restore the default.
+ * Only direct `w:style` children of the root participate (bounded count). Duplicate
+ * `styleId` values keep the last definition, matching Word's reader for this fixture class.
+ * Default paragraph/character style ids track `w:default="1"` with the same last-wins rule.
  */
-declare function setGraphemeBoundary(boundary: GraphemeBoundary): void;
-/** Restore the default `Intl.Segmenter` boundary and clear the memo. */
-declare function resetGraphemeBoundary(): void;
-/** How many user-perceived characters the text holds. */
-declare function graphemeCount(text: string): number;
+declare function buildStyleCascadeTable(stylesRoot: OoxmlElement | null, themeFonts?: ThemeFonts): StyleCascadeTable;
 /**
- * The grapheme index containing a UTF-16 offset. Clamps rather than throwing.
+ * Cascade paragraph + inherited run properties for one paragraph's direct `w:pPr`.
  *
- * Backed by a single-entry index cache: this runs once per character during paragraph layout, and
- * re-segmenting per call is what made a 20,000-character paragraph take minutes to open. One
- * entry rather than a map, because the keys are file-derived strings of unbounded size.
+ * Order: `docDefaults` → table style → `basedOn` ancestors → paragraph style → direct
+ * formatting, which is the style hierarchy of 17.7.2: a table style sits above the document
+ * defaults and below the paragraph style a cell paragraph names for itself.
+ * When `w:pStyle` is absent, the document's default paragraph style (`w:default="1"`) is used.
+ * Direct formatting is last so it overrides inherited values inside the existing resolvers.
  */
-declare function utf16OffsetToGrapheme(text: string, utf16Offset: number): number;
-/** The UTF-16 offset a grapheme index starts at. Clamps rather than throwing. */
-declare function graphemeOffsetToUtf16(text: string, graphemeOffset: number): number;
-
+declare function cascadeParagraphFormatting(table: StyleCascadeTable, directPPr: OoxmlNode | undefined, tableCellStyle?: TableCellStyleFormatting): CascadedParagraphFormatting;
 /**
- * One word-segmentation span. `wordLike` separates words from the whitespace and punctuation
- * between them, which is what double-click selection needs to skip.
+ * Bottom border after cascade: a later `w:pBdr` replaces an earlier one; absence inherits.
+ * `nil`/`none` clear the edge via `paragraphBorders`.
  */
-interface WordSegment {
-    readonly utf16From: number;
-    readonly utf16To: number;
-    readonly wordLike: boolean;
-}
+declare function cascadedBottomBorder(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorderEdge | undefined;
 /**
- * The replaceable word-segmentation strategy.
+ * Merge inherited paragraph-style run props with a run's direct `rPr` (direct last).
  *
- * Falls back to a BOUNDED grapheme-safe splitter where `Intl.Segmenter` is absent — bounded
- * because the input is file-derived, and grapheme-safe so a fallback never splits inside an
- * emoji.
+ * When a cascade table is supplied, also resolves `w:rStyle` character styles (basedOn chain,
+ * cycle/depth capped). Runs without an explicit `rStyle` pick up the default character style
+ * (`w:default="1"`). Precedence: inherited → character style chain → direct formatting.
  */
-interface WordBoundary {
-    segment(text: string): readonly WordSegment[];
-}
-/** Invariant locale for deterministic cross-runtime word boundaries. */
-declare const WORD_SEGMENTER_LOCALE: "und";
-/** Whether this runtime provides word-granularity `Intl.Segmenter`. */
-declare function isIntlWordSegmenterAvailable(): boolean;
-/** Intl.Segmenter word boundary for the invariant locale. */
-declare function createIntlWordBoundary(): WordBoundary;
-/** Bounded deterministic fallback — not full UAX #29 word conformance. */
-declare function boundedFallbackWordSegments(text: string): readonly WordSegment[];
-/** Explicit bounded fallback boundary (grapheme-safe, narrower than Intl). */
-declare function createBoundedFallbackWordBoundary(): WordBoundary;
-/** Injection points for {@link createDefaultWordBoundary}, so tests can force either path. */
-interface WordBoundaryResolverDeps {
-    readonly isIntlAvailable?: () => boolean;
-    readonly createIntlBoundary?: () => WordBoundary;
-    readonly createFallbackBoundary?: () => WordBoundary;
+declare function cascadeRunProperties(inheritedRunProperties: readonly OoxmlProperty[], directRunProperties: readonly OoxmlProperty[], table?: StyleCascadeTable): readonly OoxmlProperty[];
+/** Everything the line breaker needs about one paragraph, already cascaded and converted. */
+interface ParagraphLayoutInputs {
+    readonly props: OoxmlProperty[];
+    readonly indent: {
+        left: number;
+        right: number;
+        hanging: number;
+        firstLine: number;
+    };
+    readonly available: number;
+    readonly alignment: Alignment;
+    readonly spacing: ParagraphSpacing;
+    /** Resolved `w:line` / `w:lineRule`; single spacing where the cascade says nothing. */
+    readonly lineSpacing: ParagraphLineSpacing;
+    /** `w:contextualSpacing`: drop before/after between same-style neighbours. */
+    readonly contextualSpacing: boolean;
+    /** Resolved paragraph style id, for the `w:contextualSpacing` neighbour comparison. */
+    readonly styleId: string | null;
+    readonly bottomBorder: ParagraphBorderEdge | undefined;
+    /**
+     * Every `CT_PBdr` edge after cascade, not just the bottom one.
+     *
+     * `bottomBorder` stays alongside it because the fragment signature and the table flow
+     * read that field by name; this is the whole box, so a cell paragraph gets the same
+     * frame a body paragraph does.
+     */
+    readonly borders: ParagraphBorders;
+    /** Validated 6-hex paragraph shading fill from cascaded `w:pPr/w:shd`, absent for none. */
+    readonly shading: string | undefined;
+    readonly inheritedRunProperties: readonly OoxmlProperty[];
+    /**
+     * Paragraph-mark cascade (`inheritedRunProperties` + direct `w:pPr/w:rPr`).
+     * Empty-line sizing and last-line mark height — never content-run face.
+     */
+    readonly markRunProperties: readonly OoxmlProperty[];
+    /** Cascaded custom tab stops + default interval for paragraph-flow breaking. */
+    readonly tabStops: ResolvedTabStops;
+    /**
+     * Fingerprint folded into the paragraph layout cache key — nested `w:tabs` are absent
+     * from flat property bags, so style-inherited stops must be named explicitly.
+     */
+    readonly tabStopsCacheToken: string;
+    /** Resolved list marker inputs when the paragraph participates in numbering. */
+    readonly listItem?: ResolvedListItem;
 }
-/** Resolve production word boundary: Intl when available/construction succeeds, else bounded fallback. */
-declare function createDefaultWordBoundary(deps?: WordBoundaryResolverDeps): WordBoundary;
-/** Cached immutable production boundary (first resolved instance only). */
-declare function resolveDefaultWordBoundary(): WordBoundary;
-/** Split text into word segments through the given boundary, or the resolved default. */
-declare function segmentWords(text: string, boundary?: WordBoundary): readonly WordSegment[];
 /**
- * A word span expressed in GRAPHEME offsets rather than UTF-16 ones.
+ * Resolve every paragraph input semantic layout / table cells share: cascaded props when a
+ * style table is present, otherwise direct formatting only.
  *
- * What selection actually uses: a range whose ends are UTF-16 offsets could land inside a
- * grapheme, and selecting half an emoji is not a word.
+ * When `listItem` is provided, its merged level indent becomes the paragraph indent (list
+ * hanging / left from `numbering.xml`), which is what Word uses for fixture list paragraphs
+ * that author no direct `w:ind`.
+ *
+ * `tableCellStyle` carries what the enclosing table's style says about this cell's
+ * paragraphs; body paragraphs pass nothing.
+ *
+ * `inTableCell` is asked for separately because a cell paragraph may have no table style to
+ * inherit at all, and `w:beforeAutospacing` still needs to know it is in a cell.
  */
-interface GraphemeWordSegmentRecord {
-    readonly graphemeFrom: number;
-    readonly graphemeTo: number;
-    readonly wordLike: boolean;
-}
-/** Map UTF-16 word segments to grapheme-safe half-open ranges within one paragraph. */
-declare function wordSegmentsToGraphemeRecords(text: string, segments: readonly WordSegment[]): readonly GraphemeWordSegmentRecord[];
+declare function resolveParagraphLayoutInputs(paragraph: OoxmlElement, contentWidth: number, styleCascade: StyleCascadeTable | undefined, listItem?: ResolvedListItem, tableCellStyle?: TableCellStyleFormatting, inTableCell?: boolean): ParagraphLayoutInputs;
 
 /**
- * Strict hex fill: exactly six hex digits. Rejects `auto`, `nil`, and any non-hex payload
- * (CSS functions, URLs, short hex, theme tokens).
- */
-declare function resolveStrictHexFill(raw: string | undefined): string | undefined;
-/**
- * Resolve a `w:shd` attribute bag to a validated RRGGBB fill, or undefined.
- *
- * `w:themeFill` is a REFERENCE, and Word always writes the value it resolved to alongside
- * it: `<w:shd w:val="clear" w:fill="D9E2F3" w:themeFill="accent1" w:themeFillTint="33"/>`.
- * Reading `w:fill` in that case is not inventing a colour from the theme — it is reading
- * the colour the producer computed. Dropping the fill because a theme reference sat next
- * to it left every accent-shaded cell and paragraph unpainted.
- *
- * `val="nil"` clears shading. Pattern vals are not rendered; a valid solid `fill` still
- * paints as a clear fill until pattern support lands. A theme reference with no usable
- * `w:fill` still resolves to nothing rather than a guess.
- */
-declare function resolveOoxmlShadingFill(attributes: Readonly<Record<string, string>> | undefined): string | undefined;
-/** Read `w:shd` from a typed/generic element (table `tcPr`, nested `pPr`, …). */
-declare function shadingFillFromElement(shd: OoxmlElement | undefined): string | undefined;
-/**
- * Resolve paragraph shading from cascaded flat `w:pPr` properties.
- *
- * Later `w:shd` entries win (defaults → style → direct), matching spacing/border cascade.
- */
-declare function paragraphShading(props: readonly OoxmlProperty[]): string | undefined;
-/**
- * Page-content box for paragraph shading: union of this fragment's line boxes.
+ * What one cell side is before any ADJACENT cell has its say.
  *
- * Excludes collapsed before/after spacing and bottom-border extent so the painted band
- * matches Word's content-area fill (character shading height on a single line).
+ * - omitted → the table's own rule for that position (`tblBorders`, `insideH`/`insideV`)
+ * - edge → the cell wins outright; no weight fight with the table
+ * - none → an explicit `w:val="nil"`. Suppresses a matching table border on interior
+ *   and perimeter sides alike, so a table whose cells all declare none paints borderless
+ *   like Word even when `tblBorders` still carry `single` rules.
  */
-declare function paragraphShadingBox(lines: readonly {
-    readonly box: LayoutBox;
-}[], x: number, width: number): LayoutBox | undefined;
+declare function effectiveBorderSide(authored: TableBorderSide, tableSide: TableBorderSide, _options?: {
+    readonly interior?: boolean;
+}): TableBorderSide;
 
+/** Minimum stroke width for a compound (double/triple) band, in points. */
+declare const COMPOUND_BORDER_MIN_STROKE_PT = 1;
+/** Minimum gap between compound strokes, in points. */
+declare const COMPOUND_BORDER_MIN_GAP_PT = 1;
 /**
- * Where one note is referenced from — what per-page and per-section restart rules are computed
- * against.
- */
-interface NoteReferenceSite {
-    /** Stable note id (`w:id`). */
-    readonly noteId: number;
-    /** Section index of the reference (0-based). */
-    readonly sectionIndex: number;
-    /**
-     * Page index of the reference when known (0-based). Required for `eachPage` restart;
-     * when omitted, `eachPage` behaves like `continuous` for that site.
-     */
-    readonly pageIndex?: number;
-    /** When true, consumes no automatic number (`customMarkFollows`). */
-    readonly customMarkFollows?: boolean;
-}
-/**
- * The mark a note reference paints.
+ * How a multi-line border style (double, triple) is drawn: stroke width, gap, and total extent.
  *
- * `null` where `w:customMarkFollows` suppresses it: the document supplies its own glyph, and
- * painting an automatic number too would show the note twice.
+ * The band is CENTRED on the authored width, so a double border occupies the space Word gives it
+ * rather than growing the cell it surrounds.
  */
-interface NoteDisplayMark {
-    readonly noteId: number;
-    /** Formatted mark, or `null` when suppressed by customMarkFollows. */
-    readonly mark: string | null;
-    /** 1-based automatic sequence number when assigned; absent when suppressed. */
-    readonly displayNumber?: number;
+interface CompoundBorderMetrics {
+    readonly strokePt: number;
+    readonly gapPt: number;
+    readonly extentPt: number;
+    /** Centers the compound band on the authored width; negative extends outward. */
+    readonly insetPt: number;
 }
-type ResolvedNoteProperties = ResolvedFootnoteProperties | ResolvedEndnoteProperties;
 /**
- * Derive display marks for references of one note kind in document order.
- *
- * Restart rules:
- * - `continuous` — single sequence across the document from `numStart`
- * - `eachSect` — restart at `numStart` when `sectionIndex` changes
- * - `eachPage` — restart when `pageIndex` changes (falls back to continuous if unknown)
+ * Deterministic double stroke / gap / extent in layout points (scale-independent).
  *
- * IDs are stable; only display numbers change. Non-mutating.
- */
-declare function deriveNoteDisplayMarks(noteKind: NoteKind, references: readonly NoteReferenceSite[], properties: ResolvedNoteProperties): readonly NoteDisplayMark[];
-/**
- * Derive marks using per-reference-section resolved properties (`numFmt` / `numStart` /
- * `numRestart`). Restart rules consult each site's own section props.
+ * Thin authored widths inflate to a 1+1+1 point compound so a `w:sz="3"` double remains
+ * visible at paint scale 1 — matching Word's hairline-double floor.
  */
-declare function deriveNoteDisplayMarksResolved(_noteKind: NoteKind, references: readonly NoteReferenceSite[], resolveProps: (sectionIndex: number) => ResolvedNoteProperties): readonly NoteDisplayMark[];
-/** Map noteId → formatted mark for quick lookup (last site wins if duplicated). */
-declare function noteDisplayMarkMap(marks: readonly NoteDisplayMark[]): ReadonlyMap<number, string | null>;
+declare function computeDoubleBorderMetricsPt(widthPt: number): CompoundBorderMetrics;
 
-/** A fingerprint over one paragraph's layout inputs. */
-type ParagraphLayoutKey = string;
-/** Cache counters, for asserting that incremental layout is actually reusing work. */
-interface LayoutCacheStats {
-    readonly hits: number;
-    readonly misses: number;
-    readonly evictions: number;
-    readonly size: number;
-}
 /**
- * The per-paragraph measurement cache.
+ * The exact HarfBuzz build this engine shapes against.
  *
- * Caches the BREAK only — where a paragraph's lines fall at a given width — never its placement.
- * An edit high in a document still repaginates everything below it, while paragraphs nobody
- * touched are never measured again.
+ * Pinned and verified at load: a runtime reporting a different version is REFUSED rather than
+ * used, because glyph positioning can change between releases and a cached measurement taken
+ * under one build must not be trusted under another.
  */
-interface ParagraphLayoutCache<T> {
-    get(key: ParagraphLayoutKey): T | undefined;
-    set(key: ParagraphLayoutKey, value: T): void;
-    /** Drop entries for paragraphs a commit removed, so the cache cannot grow without bound. */
-    retain(keys: ReadonlySet<ParagraphLayoutKey>): void;
-    clear(): void;
-    readonly stats: LayoutCacheStats;
-}
+declare const HARFBUZZ_SHAPING_LIBRARY: VersionedShapingLibrary;
+/** Load and verify the HarfBuzz WASM runtime without adding top-level await to import graphs. */
+declare function initializeHarfBuzz(): Promise<void>;
+/** Whether the WASM runtime is loaded and shaping can proceed synchronously. */
+declare function isHarfBuzzInitialized(): boolean;
 /**
- * Everything that decides whether a cached paragraph break is still valid.
+ * Why shaping refused.
  *
- * `producer` is in the key because a font arriving after first paint changes every advance in the
- * document while no content changes — without it the cache would serve the pre-font layout
- * forever.
+ * Mostly RESOURCE limits, because every input here derives from a file: text length, codepoint
+ * count, glyph count and outline size are all attacker-influenced, and an unbounded shape call is
+ * a denial-of-service vector rather than a rendering bug.
  */
-interface ParagraphKeyInputs {
-    readonly paragraph: OoxmlNode;
-    readonly properties: readonly OoxmlProperty[];
-    /** Available width, which decides where the lines break. */
-    readonly width: number;
-    /**
-     * Who produced the measurements.
-     *
-     * Fonts loading after first paint change every advance while no content changes, so a
-     * cache keyed on content alone would serve the pre-font layout forever.
-     */
-    readonly producer: string;
-    /**
-     * Inline drawing projection/resource epoch for this paragraph.
-     *
-     * Pending→ready/refused transitions and extent/hidden changes must invalidate breaks even
-     * when paragraph text is unchanged.
-     */
-    readonly drawingToken?: string;
-    /** Active page exclusion zones affecting this paragraph's break. */
-    readonly exclusionToken?: string;
-}
+type HarfBuzzShapingErrorCode = 'notInitialized' | 'fontOverLimit' | 'malformedFont' | 'textOverLimit' | 'codepointsOverLimit' | 'glyphOverLimit' | 'outlineOverLimit' | 'shapedRunOverLimit' | 'unsupportedVariationAxes' | 'unsupportedFallback' | 'unsupportedColorFont' | 'unsupportedNormalization' | 'invalidBidiLevel' | 'shapingLibraryMismatch' | 'disposed';
 /**
- * The cache key for one paragraph's measured break.
+ * A shaping call that was refused, carrying the limit it exceeded where there was one.
  *
- * Folds in the content, the available width, and the measurement producer. Anything that changes
- * where lines fall must be in here, or the cache serves a break taken under different conditions.
+ * Thrown rather than returned: unlike a missing font, a run that cannot be shaped has no sensible
+ * fallback measurement, and continuing would lay text out at made-up widths.
  */
-declare function paragraphLayoutKey(inputs: ParagraphKeyInputs): ParagraphLayoutKey;
-/** How large the paragraph cache grows before least-recently-used eviction. */
-interface ParagraphLayoutCacheOptions {
-    /**
-     * Entries retained before the least recently used are dropped.
-     *
-     * The default has to exceed a realistic document, or a full pass evicts exactly what the
-     * next one needs and the cache costs more than it saves.
-     */
-    readonly maxEntries?: number;
+declare class HarfBuzzShapingError extends Error {
+    readonly name = "HarfBuzzShapingError";
+    readonly code: HarfBuzzShapingErrorCode;
+    readonly limit?: number;
+    readonly actual?: number;
+    readonly diagnostic?: string;
+    constructor(code: HarfBuzzShapingErrorCode, details?: {
+        readonly limit?: number;
+        readonly actual?: number;
+        readonly diagnostic?: string;
+    });
 }
 /**
- * A bounded least-recently-used cache.
+ * Resource budgets and cache sizes for one shaper. Every field optional.
  *
- * Bounded because a long editing session touches far more paragraph states than a document
- * contains — every keystroke mints a new key for the paragraph being typed in — and an
- * unbounded cache would hold every intermediate state of the session.
+ * The caches exist because shaping is the expensive step: a face is opened once and reused, and
+ * identical runs return their previous result. The caps exist because file-derived input decides
+ * how much work is asked for.
  */
-declare function createParagraphLayoutCache<T>(options?: ParagraphLayoutCacheOptions): ParagraphLayoutCache<T>;
-
-/** Paint layer relative to body text — not the OOXML wrap element. */
-type DrawingPaintLayer = 'behind' | 'inFront';
-interface ExclusionZone {
-    readonly drawingNodeId: string;
-    readonly anchorParagraphId: string;
-    /** UTF-16 model offset of the anchor atom — exclusions apply at/after this point in the paragraph. */
-    readonly anchorModelStart: number;
-    readonly sourceOrder: number;
-    readonly paintLayer: DrawingPaintLayer;
-    readonly relativeHeight: number;
-    readonly allowOverlap: boolean;
-    /** Owning column index in a multi-column section — 0 for single-column and HF stories. */
-    readonly columnIndex: number;
-    /** Resolved top edge in page-content coordinates after overlap displacement. */
-    readonly y: number;
-    readonly verticalBand: LayoutBox;
-    readonly input: WrapExclusionInput;
+interface HarfBuzzTextShaperOptions {
+    readonly maxFontBytes?: number;
+    readonly maxInputUtf16?: number;
+    readonly maxCodepoints?: number;
+    readonly maxGlyphs?: number;
+    readonly maxCachedFaces?: number;
+    readonly maxCachedShapes?: number;
+    readonly maxOutlineBytes?: number;
+    readonly maxCachedOutlineBytes?: number;
+    readonly maxShapedRunBytes?: number;
+    readonly maxCachedShapeBytes?: number;
+    readonly instrumentation?: HarfBuzzTextShaperInstrumentation;
 }
-
-interface PendingLine {
-    readonly spans: StyleSpanRecord[];
-    readonly drawings: InlineDrawingRecord[];
-    readonly start: number;
-    end: number;
-    width: number;
-    height: number;
-    baseline: number;
-    /**
-     * Space ABOVE the glyph band inside {@link height}.
-     *
-     * Exact spacing can center the glyphs and move the baseline. Auto/atLeast spacing leaves
-     * this at zero and puts its extra depth below instead.
-     */
-    leading: number;
-    /**
-     * Auto/atLeast line-spacing depth below the painted glyph band.
-     *
-     * Word lets this external depth cross the bottom text margin when the glyphs themselves
-     * still fit. Pagination therefore budgets {@link height} minus this amount at a page
-     * bottom, while paint keeps the full box and padding.
-     */
-    trailingSpacing: number;
-    /** When true, layout must start a new page after this line is placed. */
-    pageBreakAfter?: boolean;
-    /** When true, layout must advance to the next authored section column. */
-    columnBreakAfter?: boolean;
-    /** Model ranges on this line covering deleted content; see {@link LineRecord.deletedRanges}. */
-    deletedRanges?: readonly ModelRange[];
-    /** Vertical gap inserted before this line to clear a topAndBottom exclusion band. */
-    exclusionSkipBefore?: number;
+/** One face-cache transition, for instrumentation. */
+interface HarfBuzzFaceCacheEvent {
+    readonly kind: 'created' | 'hit' | 'evicted';
+    readonly identity: string;
 }
-/** Horizontal alignment of a paragraph (`w:jc`, ECMA-376 §17.3.1.13). */
-type Alignment = 'left' | 'center' | 'right' | 'both';
-
-/** 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.
+ * Optional counters for the work a shaper is expected to do rarely.
  *
- * 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.
+ * Exists so tests can assert the ABSENCE of work — re-opening a face or re-copying its bytes per
+ * shape call would not change any output, only make typing slow, which no rendering assertion
+ * would catch.
  */
-interface NumberingLevelIndent {
-    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 paragraph style and direct formatting, so the
-     * merge has to tell "the level says left = 0" from "the level says nothing about left and
-     * the style's value stands". Absent (the default) reads as "says nothing", which is what a
-     * 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;
-    };
+interface HarfBuzzTextShaperInstrumentation {
+    readonly onFaceCacheEvent?: (event: HarfBuzzFaceCacheEvent) => void;
+    readonly onShapeCacheEvent?: (event: HarfBuzzShapeCacheEvent) => void;
+    readonly onByteCopy?: () => void;
+    readonly onTableScan?: () => void;
+    readonly onShapeCall?: () => void;
+    readonly onOutlinePathCall?: () => void;
+    readonly onOutlineCacheEvent?: (event: HarfBuzzOutlineCacheEvent) => void;
 }
-/** 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;
-    /** 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 shape-cache transition, for instrumentation. */
+interface HarfBuzzShapeCacheEvent {
+    readonly kind: 'hit' | 'miss' | 'stored' | 'evicted' | 'skipped' | 'cleared';
+    readonly retainedBytes: number;
+}
+/** One outline-cache transition, for instrumentation. */
+interface HarfBuzzOutlineCacheEvent {
+    readonly kind: 'created' | 'hit' | 'evicted' | 'skipped' | 'cleared';
+    readonly retainedBytes: number;
 }
 /**
- * One `w:lvlOverride` on a `w:num`: a restart value, a replacement level, or both.
+ * A {@link TextShaper} backed by HarfBuzz, holding WASM resources.
  *
- * How two lists share an abstract definition while numbering independently.
+ * {@link HarfBuzzTextShaper.dispose} is not optional housekeeping: the cached faces are WASM
+ * allocations that garbage collection cannot reclaim, so a shaper outliving its editor leaks
+ * until the page goes away.
  */
-interface LevelOverride {
-    readonly startOverride?: number;
-    /** Full level replacement when `w:lvl` is present under the override. */
-    readonly level?: NumberingLevel;
+interface HarfBuzzTextShaper extends TextShaper {
+    dispose(): void;
 }
+/** Structural sfnt validation that does not construct native HarfBuzz objects. */
+declare const harfBuzzFontValidator: FontByteValidator;
+/** Convert signed font units by an exact rational multiplier using the declared tie rule. */
+declare const roundFontUnitToFixedPoint: (fontUnits: number, denominator: number, numerator: number, mode: FixedPointRoundingMode) => FixedPoint;
 /**
- * One `w:abstractNum` — the shape of a list, without being a list.
+ * Build a HarfBuzz-backed shaper.
  *
- * 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.
+ * Requires `initializeHarfBuzz()` to have resolved — shaping is synchronous, so the WASM runtime
+ * must already be loaded. Dispose the result when the editor goes away, or its cached faces leak.
  */
-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 const createHarfBuzzTextShaper: (options?: HarfBuzzTextShaperOptions) => HarfBuzzTextShaper;
+
 /**
- * One `w:num` — the thing a paragraph's `w:numId` actually names.
+ * UAX #9 embedding levels, one per UTF-16 code unit, plus the paragraph ranges they were resolved
+ * within.
  *
- * Points at an {@link AbstractNumDefinition} and may override any of its levels.
+ * The level is EXACT, not a direction: its parity gives direction, but the numeric value is what
+ * reordering needs, and collapsing it early loses nested isolates.
  */
-interface NumDefinition {
-    readonly numId: string;
-    readonly abstractNumId: string;
-    readonly overrides: ReadonlyMap<number, LevelOverride>;
+interface BidiEmbeddingLevels {
+    readonly levels: Uint8Array;
+    readonly paragraphs: readonly {
+        readonly start: number;
+        readonly end: number;
+        readonly level: number;
+    }[];
 }
+
 /**
- * The bounded projection of `numbering.xml` that list layout resolves against.
+ * Which `w:rFonts` slot a character resolves its face through.
  *
- * 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.
+ * OOXML gives a run up to four faces and picks between them by SCRIPT, so one run of mixed Latin
+ * and CJK text uses two different fonts without saying so anywhere in its properties.
  */
-interface NumberingIndex {
-    readonly abstractNums: ReadonlyMap<string, AbstractNumDefinition>;
-    readonly nums: ReadonlyMap<string, NumDefinition>;
-}
+type FontSlot = 'ascii' | 'hAnsi' | 'eastAsia' | 'cs';
 /**
- * Build a numbering index from the root of a numbering part (`w:numbering`).
+ * A run of text sharing one script, direction and font slot — the unit handed to the shaper.
  *
- * Empty / missing roots yield an empty index. Duplicate ids keep the first definition.
+ * Shaping cannot span a script change: Arabic and Latin in one call would produce wrong joining
+ * behaviour, so a run is itemized into these first.
  */
+interface ScriptItem {
+    readonly from: number;
+    readonly to: number;
+    readonly direction: TextDirection;
+    readonly bidiLevel: number;
+    readonly script: 'Zyyy' | 'Latn' | 'Grek' | 'Cyrl' | 'Hani' | 'Hebr' | 'Arab' | 'Deva' | 'Beng' | 'Thai' | 'Khmr';
+    readonly slot: FontSlot;
+}
 /**
- * Project `numbering.xml` into the bounded index.
+ * A code point whose script this engine does not itemize.
  *
- * 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.
+ * Carries the offending `codePoint` so the caller can report which character stopped it, rather
+ * than failing anonymously somewhere in the middle of a paragraph.
  */
-declare function buildNumberingIndex(root: OoxmlElement | null | undefined): NumberingIndex;
-/** Resolve the effective level for a `numId` + `ilvl`, applying overrides. */
+declare class UnsupportedScriptError extends Error {
+    readonly name = "UnsupportedScriptError";
+    readonly code = "unsupportedScript";
+    readonly codePoint: number;
+    constructor(codePoint: number);
+}
 /**
- * The effective level for one paragraph's numbering reference, after overrides and style links.
+ * Split text into shapeable runs by script, bidi level and font slot.
  *
- * 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.
+ * Consumes the bidi levels rather than re-deriving direction, so itemization and reordering agree
+ * by construction instead of by two implementations happening to match.
  */
-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 itemizeScriptFontSlots(text: string, paragraphOffset: number, embedding: BidiEmbeddingLevels): readonly ScriptItem[];
 
+/** UTF-16 boundaries that are both whole-grapheme and HarfBuzz cluster edges. */
+declare function shapedHorizontalBoundaries(run: ShapedRun): readonly number[];
 /**
- * A paragraph's list membership fully resolved: definition, level, marker text and geometry.
+ * Whether an offset is a real caret position: both a grapheme boundary and a shaped cluster edge.
  *
- * `markerText` is already expanded through the counter state, so it is the string a reader sees
- * rather than the `w:lvlText` template.
+ * Both conditions, because they disagree. A ligature is one cluster spanning two graphemes, and
+ * an offset inside it has no geometry the shaper can answer for — placing a caret there would
+ * mean inventing an x coordinate.
  */
-interface ResolvedListItem {
-    readonly numId: string;
-    readonly ilvl: number;
-    readonly abstractNumId: string;
-    /** `w:numFmt` of the resolved level — `bullet` or a numbering format. */
-    readonly numFmt: string;
-    readonly markerText: string;
-    readonly markerAlign: ListMarkerAlign;
-    readonly suffix: ListSuffix;
-    /** Effective indent after merging level + paragraph indents, in points. */
-    readonly indent: NumberingLevelIndent;
-    readonly markerStyle: ResolvedRunStyle;
-    /** Fingerprint for layout cache keys (indent + level identity, not ordinal). */
-    readonly cacheToken: string;
-}
+declare function isWholeGraphemeHorizontalBoundary(run: ShapedRun, utf16Offset: number): boolean;
+/** Every published shaped boundary has exact geometry from the shaping result. */
+declare function isGeometryTrustedCaretOffset(run: ShapedRun, utf16Offset: number): boolean;
 /**
- * Read `w:numPr` from cascaded paragraph-property nodes (last wins).
+ * Whether the distance from a line's start to an offset can be trusted as exact.
  *
- * Flat `OoxmlProperty[]` bags drop nested `ilvl`/`numId`, so this walks the tree nodes
- * the same way borders and tabs do.
+ * Requires BOTH ends to be shaped boundaries: accumulating advances across an offset the shaper
+ * cannot place would produce a caret x that drifts further along the line.
  */
-declare function readNumPr(paragraphPropertyNodes: readonly OoxmlNode[]): {
-    numId: string;
-    ilvl: number;
-} | null;
+declare function isCumulativeGeometryTrustedFromLineOrigin(run: ShapedRun, lineStartUtf16Offset: number, utf16Offset: number): boolean;
+/** Grapheme offsets corresponding to exact shaped boundaries. */
+declare function semanticHorizontalBoundaries(run: ShapedRun): readonly number[];
+
 /**
- * Resolve `w:numStyleLink` delegation using the document's styles (§17.9.21).
+ * One user-perceived character, and the UTF-16 range that encodes it.
  *
- * Without a style table there is nothing to follow, so the index is returned unchanged —
- * and so it is when nothing delegates, which keeps layout cache identity.
+ * The unit a caret moves by. An emoji with a skin-tone modifier is ONE segment spanning several
+ * UTF-16 code units, so stepping by code unit would put the caret inside it.
  */
-declare function withNumberingStyleLinks(index: NumberingIndex, styleCascade: StyleCascadeTable | undefined): NumberingIndex;
+interface GraphemeSegment {
+    readonly index: number;
+    readonly text: string;
+    readonly utf16From: number;
+    readonly utf16To: number;
+}
 /**
- * The effective indent of a list paragraph: STYLE, then the numbering LEVEL, then DIRECT.
- *
- * Word applies a level's `w:pPr/w:ind` between the paragraph style and the paragraph's own
- * formatting, per attribute — and the ordering matters on real documents. A converted
- * agreement numbers its `(a)` items with a level stating `left=1512 hanging=738` under a
- * `ListParagraph` style stating `left=775 hanging=624`, and states only `hanging="737"` on
- * the paragraph itself. Reading the flattened cascade as "the paragraph's indent" gave the
- * STYLE's 775 to a level that had overridden it, so every lettered sub-item hung a full
- * indent step to the left of where Word puts it.
+ * The replaceable segmentation strategy.
  *
- * `inherited` is the cascade WITHOUT the paragraph's own `w:pPr` (defaults, table cell style,
- * style chain); `direct` is that `w:pPr` alone.
+ * An explicit seam rather than a direct `Intl.Segmenter` call, so tests can install a
+ * deterministic boundary and a runtime without `Intl.Segmenter` can be given one.
  */
-declare function mergeListIndent(levelIndent: NumberingLevelIndent, inherited: readonly OoxmlProperty[], direct?: readonly OoxmlProperty[]): NumberingLevelIndent;
+interface GraphemeBoundary {
+    segment(text: string): readonly GraphemeSegment[];
+}
+/** Invariant locale for deterministic cross-runtime grapheme boundaries. */
+declare const GRAPHEME_SEGMENTER_LOCALE: "und";
+/** Whether this runtime provides `Intl.Segmenter`, which the default boundary requires. */
+declare function isIntlSegmenterAvailable(): boolean;
 /**
- * Collect paragraphs of a block list in document order, descending into tables.
+ * The default boundary, over `Intl.Segmenter` at the invariant `und` locale.
  *
- * Caps nesting so a hostile nested-table document cannot recurse without bound.
+ * Locale-invariant on purpose: grapheme boundaries must not vary with the user's locale, or the
+ * same document would paginate differently for different readers.
  */
-declare function walkStoryParagraphs(blocks: readonly OoxmlElement[], maxTableDepth?: number): OoxmlElement[];
+declare const intlGraphemeBoundary: GraphemeBoundary;
+/** Current boundary generation, for callers that cache segmentation-derived answers. */
+declare function graphemeBoundaryEpoch(): number;
 /**
- * Resolve every list paragraph in a story to a {@link ResolvedListItem}, keyed by node id.
+ * Split text into graphemes through the active boundary.
  *
- * Non-list paragraphs are absent from the map. Hostile / missing numbering resolves inertly
- * (paragraph omitted — laid out as ordinary text).
+ * Memoized on the last texts seen, because paragraph layout asks about the same string
+ * repeatedly and a full segmentation pass per call made layout quadratic in paragraph length.
  */
-declare function resolveStoryListItems(blocks: readonly OoxmlElement[], index: NumberingIndex, styleCascade: StyleCascadeTable | undefined, isFontAvailable?: (family: string) => boolean): ReadonlyMap<string, ResolvedListItem>;
+declare function segmentGraphemes(text: string): readonly GraphemeSegment[];
 /**
- * Attach a full-story list-item map to layout options.
+ * Install a different segmentation strategy, invalidating the memo.
  *
- * Resolves once over `blocks` (body story including table cells) so counters continue across
- * section boundaries. No-ops when numbering is absent.
+ * For tests and for runtimes lacking `Intl.Segmenter`. Call {@link resetGraphemeBoundary} to
+ * restore the default.
  */
-declare function withResolvedListItems<T extends {
-    readonly numberingIndex?: NumberingIndex;
-    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
-    readonly styleCascade?: StyleCascadeTable;
-    /**
-     * Host oracle for "is this font family really loaded". Supplied, a Symbol/Wingdings
-     * bullet keeps the file's own private-use codepoint so the authored typeface draws it;
-     * absent, it falls back to the Unicode equivalent rather than a tofu box.
-     */
-    readonly isFontAvailable?: (family: string) => boolean;
-}>(options: T, blocks: readonly OoxmlElement[]): T & {
-    readonly numberingIndex: NumberingIndex;
-    readonly listItems?: ReadonlyMap<string, ResolvedListItem>;
-};
+declare function setGraphemeBoundary(boundary: GraphemeBoundary): void;
+/** Restore the default `Intl.Segmenter` boundary and clear the memo. */
+declare function resetGraphemeBoundary(): void;
+/** How many user-perceived characters the text holds. */
+declare function graphemeCount(text: string): number;
 /**
- * Horizontal marker box inside the hanging indent slot.
+ * The grapheme index containing a UTF-16 offset. Clamps rather than throwing.
  *
- * Coordinates are relative to the same origin as paragraph content (`indent.left` is the
- * text start). Returns null when there is nothing to paint.
- */
-declare function listMarkerBox(item: ResolvedListItem, markerWidth: number, lineY: number, lineHeight: number): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-} | null;
-
-/** Soft ceiling on `basedOn` chain length — enough for real templates, refuses hostile graphs. */
-declare const MAX_STYLE_BASED_ON_DEPTH = 32;
-/** Soft ceiling on style definitions read from one styles part. */
-declare const MAX_STYLE_DEFINITIONS = 4096;
-/** One `w:style` as the cascade reads it: its properties, and the style it is based on. */
-interface StyleDefinition {
-    readonly styleId: string;
-    readonly type: string;
-    readonly basedOn: string | null;
-    readonly paragraphProperties: readonly OoxmlProperty[];
-    readonly runProperties: readonly OoxmlProperty[];
-    /** The style's `w:pPr` node, when present — needed for nested `w:pBdr`. */
-    readonly paragraphPropertiesNode: OoxmlElement | undefined;
-    /** The style's `w:tblPr`, for a `w:type="table"` style. */
-    readonly tablePropertiesNode: OoxmlElement | undefined;
-    /**
-     * `w:tblStylePr` conditional formats by `w:type` (`firstRow`, `band1Horz`, …).
-     *
-     * Word puts a table's real appearance here: `Table Grid` carries its grid in the style's
-     * `w:tblBorders`, and the banded/​header looks live in these. A document states only
-     * `<w:tblStyle w:val="TableGrid"/>`.
-     */
-    readonly conditionalTableFormats: ReadonlyMap<string, OoxmlElement>;
-}
+ * Backed by a single-entry index cache: this runs once per character during paragraph layout, and
+ * re-segmenting per call is what made a 20,000-character paragraph take minutes to open. One
+ * entry rather than a map, because the keys are file-derived strings of unbounded size.
+ */
+declare function utf16OffsetToGrapheme(text: string, utf16Offset: number): number;
+/** The UTF-16 offset a grapheme index starts at. Clamps rather than throwing. */
+declare function graphemeOffsetToUtf16(text: string, graphemeOffset: number): number;
+
 /**
- * The whole styles part, indexed and ready to resolve against.
- *
- * `cacheToken` is load-bearing: it folds into layout cache producers so breaks measured under one
- * styles part are never reused under another.
+ * One word-segmentation span. `wordLike` separates words from the whitespace and punctuation
+ * between them, which is what double-click selection needs to skip.
  */
-interface StyleCascadeTable {
-    /**
-     * Bounded fingerprint folded into layout cache producers so a different styles part cannot
-     * reuse breaks measured under another cascade. Computed once per table (FNV-1a hex).
-     */
-    readonly cacheToken: string;
-    readonly docDefaultsRun: readonly OoxmlProperty[];
-    readonly docDefaultsParagraph: readonly OoxmlProperty[];
-    readonly docDefaultsParagraphNode: OoxmlElement | undefined;
-    /** `w:style[@w:default='1'][@w:type='paragraph']` — last wins among defaults of that type. */
-    readonly defaultParagraphStyleId: string | null;
-    /** `w:style[@w:default='1'][@w:type='character']` — last wins among defaults of that type. */
-    readonly defaultCharacterStyleId: string | null;
-    /**
-     * The theme part's Latin typefaces, for `w:rFonts` theme references.
-     *
-     * Lives on the cascade because it is document-level style material with the same
-     * lifetime, and because every site that resolves run properties already holds this table.
-     */
-    readonly themeFonts: ThemeFonts;
-    readonly styles: ReadonlyMap<string, StyleDefinition>;
+interface WordSegment {
+    readonly utf16From: number;
+    readonly utf16To: number;
+    readonly wordLike: boolean;
 }
 /**
- * A paragraph's properties after the cascade, plus the same list WITHOUT its own `w:pPr`.
+ * The replaceable word-segmentation strategy.
  *
- * Both, because a writer needs to know what a paragraph INHERITS to decide whether setting a
- * value is a change or a no-op — and writing back an inherited value freezes it into the
- * paragraph as though the author had chosen it.
+ * Falls back to a BOUNDED grapheme-safe splitter where `Intl.Segmenter` is absent — bounded
+ * because the input is file-derived, and grapheme-safe so a fallback never splits inside an
+ * emoji.
  */
-interface CascadedParagraphFormatting {
-    /** Flat paragraph properties in cascade order (defaults → bases → style → direct). */
-    readonly paragraphProperties: readonly OoxmlProperty[];
-    /**
-     * The same list WITHOUT the paragraph's own `w:pPr` — everything it inherits.
-     *
-     * Numbering needs the two tiers apart: a level's `w:pPr/w:ind` outranks the style's and is
-     * outranked by the paragraph's own, and a flattened list cannot say which is which.
-     */
-    readonly inheritedParagraphProperties: readonly OoxmlProperty[];
-    /** Matching `w:pPr` nodes for nested border resolution. */
-    readonly paragraphPropertyNodes: readonly OoxmlNode[];
-    /** Inherited run properties for every run in the paragraph (before direct run `rPr`). */
-    readonly runProperties: readonly OoxmlProperty[];
-    /**
-     * The style this paragraph resolved to, or null when it names none and there is no
-     * document default. `w:contextualSpacing` compares neighbours by exactly this.
-     */
-    readonly styleId: string | null;
+interface WordBoundary {
+    segment(text: string): readonly WordSegment[];
 }
-/** Accepted style ids only — over-long, control-bearing, or dangerous keys are dropped. */
-declare function isValidStyleId(raw: string | undefined): raw is string;
+/** Invariant locale for deterministic cross-runtime word boundaries. */
+declare const WORD_SEGMENTER_LOCALE: "und";
+/** Whether this runtime provides word-granularity `Intl.Segmenter`. */
+declare function isIntlWordSegmenterAvailable(): boolean;
+/** Intl.Segmenter word boundary for the invariant locale. */
+declare function createIntlWordBoundary(): WordBoundary;
+/** Bounded deterministic fallback — not full UAX #29 word conformance. */
+declare function boundedFallbackWordSegments(text: string): readonly WordSegment[];
+/** Explicit bounded fallback boundary (grapheme-safe, narrower than Intl). */
+declare function createBoundedFallbackWordBoundary(): WordBoundary;
+/** Injection points for {@link createDefaultWordBoundary}, so tests can force either path. */
+interface WordBoundaryResolverDeps {
+    readonly isIntlAvailable?: () => boolean;
+    readonly createIntlBoundary?: () => WordBoundary;
+    readonly createFallbackBoundary?: () => WordBoundary;
+}
+/** Resolve production word boundary: Intl when available/construction succeeds, else bounded fallback. */
+declare function createDefaultWordBoundary(deps?: WordBoundaryResolverDeps): WordBoundary;
+/** Cached immutable production boundary (first resolved instance only). */
+declare function resolveDefaultWordBoundary(): WordBoundary;
+/** Split text into word segments through the given boundary, or the resolved default. */
+declare function segmentWords(text: string, boundary?: WordBoundary): readonly WordSegment[];
 /**
- * What a table style contributes to the paragraphs of ONE cell: the style's whole-table
- * `w:pPr`/`w:rPr` followed by every `w:tblStylePr` the cell is under (17.7.6.6), weakest
- * first in the caller's condition order (banding, column, row, corner).
+ * A word span expressed in GRAPHEME offsets rather than UTF-16 ones.
  *
- * This is how Word makes a header row bold and centred while the document states nothing
- * but `<w:tblStyle w:val="…"/>` on the table and plain runs in the cells.
+ * What selection actually uses: a range whose ends are UTF-16 offsets could land inside a
+ * grapheme, and selecting half an emoji is not a word.
  */
-interface TableCellStyleFormatting {
-    readonly paragraphProperties: readonly OoxmlProperty[];
-    /** Matching `w:pPr` nodes, for nested `w:pBdr` / `w:tabs` resolution. */
-    readonly paragraphPropertyNodes: readonly OoxmlElement[];
-    /** Inherited run properties for every run in the cell, before the paragraph style. */
-    readonly runProperties: readonly OoxmlProperty[];
+interface GraphemeWordSegmentRecord {
+    readonly graphemeFrom: number;
+    readonly graphemeTo: number;
+    readonly wordLike: boolean;
 }
+/** Map UTF-16 word segments to grapheme-safe half-open ranges within one paragraph. */
+declare function wordSegmentsToGraphemeRecords(text: string, segments: readonly WordSegment[]): readonly GraphemeWordSegmentRecord[];
+
 /**
- * Build a cascade table from a styles part root.
- *
- * Only direct `w:style` children of the root participate (bounded count). Duplicate
- * `styleId` values keep the last definition, matching Word's reader for this fixture class.
- * Default paragraph/character style ids track `w:default="1"` with the same last-wins rule.
+ * Strict hex fill: exactly six hex digits. Rejects `auto`, `nil`, and any non-hex payload
+ * (CSS functions, URLs, short hex, theme tokens).
  */
-declare function buildStyleCascadeTable(stylesRoot: OoxmlElement | null, themeFonts?: ThemeFonts): StyleCascadeTable;
+declare function resolveStrictHexFill(raw: string | undefined): string | undefined;
 /**
- * Cascade paragraph + inherited run properties for one paragraph's direct `w:pPr`.
+ * Resolve a `w:shd` attribute bag to a validated RRGGBB fill, or undefined.
  *
- * Order: `docDefaults` → table style → `basedOn` ancestors → paragraph style → direct
- * formatting, which is the style hierarchy of 17.7.2: a table style sits above the document
- * defaults and below the paragraph style a cell paragraph names for itself.
- * When `w:pStyle` is absent, the document's default paragraph style (`w:default="1"`) is used.
- * Direct formatting is last so it overrides inherited values inside the existing resolvers.
+ * `w:themeFill` is a REFERENCE, and Word always writes the value it resolved to alongside
+ * it: `<w:shd w:val="clear" w:fill="D9E2F3" w:themeFill="accent1" w:themeFillTint="33"/>`.
+ * Reading `w:fill` in that case is not inventing a colour from the theme — it is reading
+ * the colour the producer computed. Dropping the fill because a theme reference sat next
+ * to it left every accent-shaded cell and paragraph unpainted.
+ *
+ * `val="nil"` clears shading. Pattern vals are not rendered; a valid solid `fill` still
+ * paints as a clear fill until pattern support lands. A theme reference with no usable
+ * `w:fill` still resolves to nothing rather than a guess.
  */
-declare function cascadeParagraphFormatting(table: StyleCascadeTable, directPPr: OoxmlNode | undefined, tableCellStyle?: TableCellStyleFormatting): CascadedParagraphFormatting;
+declare function resolveOoxmlShadingFill(attributes: Readonly<Record<string, string>> | undefined): string | undefined;
+/** Read `w:shd` from a typed/generic element (table `tcPr`, nested `pPr`, …). */
+declare function shadingFillFromElement(shd: OoxmlElement | undefined): string | undefined;
 /**
- * Bottom border after cascade: a later `w:pBdr` replaces an earlier one; absence inherits.
- * `nil`/`none` clear the edge via `paragraphBorders`.
+ * Resolve paragraph shading from cascaded flat `w:pPr` properties.
+ *
+ * Later `w:shd` entries win (defaults → style → direct), matching spacing/border cascade.
  */
-declare function cascadedBottomBorder(paragraphPropertyNodes: readonly OoxmlNode[]): ParagraphBorderEdge | undefined;
+declare function paragraphShading(props: readonly OoxmlProperty[]): string | undefined;
 /**
- * Merge inherited paragraph-style run props with a run's direct `rPr` (direct last).
+ * Page-content box for paragraph shading: union of this fragment's line boxes.
  *
- * When a cascade table is supplied, also resolves `w:rStyle` character styles (basedOn chain,
- * cycle/depth capped). Runs without an explicit `rStyle` pick up the default character style
- * (`w:default="1"`). Precedence: inherited → character style chain → direct formatting.
+ * Excludes collapsed before/after spacing and bottom-border extent so the painted band
+ * matches Word's content-area fill (character shading height on a single line).
  */
-declare function cascadeRunProperties(inheritedRunProperties: readonly OoxmlProperty[], directRunProperties: readonly OoxmlProperty[], table?: StyleCascadeTable): readonly OoxmlProperty[];
-/** Everything the line breaker needs about one paragraph, already cascaded and converted. */
-interface ParagraphLayoutInputs {
-    readonly props: OoxmlProperty[];
-    readonly indent: {
-        left: number;
-        right: number;
-        hanging: number;
-        firstLine: number;
-    };
-    readonly available: number;
-    readonly alignment: Alignment;
-    readonly spacing: ParagraphSpacing;
-    /** Resolved `w:line` / `w:lineRule`; single spacing where the cascade says nothing. */
-    readonly lineSpacing: ParagraphLineSpacing;
-    /** `w:contextualSpacing`: drop before/after between same-style neighbours. */
-    readonly contextualSpacing: boolean;
-    /** Resolved paragraph style id, for the `w:contextualSpacing` neighbour comparison. */
-    readonly styleId: string | null;
-    readonly bottomBorder: ParagraphBorderEdge | undefined;
-    /**
-     * Every `CT_PBdr` edge after cascade, not just the bottom one.
-     *
-     * `bottomBorder` stays alongside it because the fragment signature and the table flow
-     * read that field by name; this is the whole box, so a cell paragraph gets the same
-     * frame a body paragraph does.
-     */
-    readonly borders: ParagraphBorders;
-    /** Validated 6-hex paragraph shading fill from cascaded `w:pPr/w:shd`, absent for none. */
-    readonly shading: string | undefined;
-    readonly inheritedRunProperties: readonly OoxmlProperty[];
-    /** Cascaded custom tab stops + default interval for paragraph-flow breaking. */
-    readonly tabStops: ResolvedTabStops;
+declare function paragraphShadingBox(lines: readonly {
+    readonly box: LayoutBox;
+}[], x: number, width: number): LayoutBox | undefined;
+
+/**
+ * Where one note is referenced from — what per-page and per-section restart rules are computed
+ * against.
+ */
+interface NoteReferenceSite {
+    /** Stable note id (`w:id`). */
+    readonly noteId: number;
+    /** Section index of the reference (0-based). */
+    readonly sectionIndex: number;
     /**
-     * Fingerprint folded into the paragraph layout cache key — nested `w:tabs` are absent
-     * from flat property bags, so style-inherited stops must be named explicitly.
+     * Page index of the reference when known (0-based). Required for `eachPage` restart;
+     * when omitted, `eachPage` behaves like `continuous` for that site.
      */
-    readonly tabStopsCacheToken: string;
-    /** Resolved list marker inputs when the paragraph participates in numbering. */
-    readonly listItem?: ResolvedListItem;
+    readonly pageIndex?: number;
+    /** When true, consumes no automatic number (`customMarkFollows`). */
+    readonly customMarkFollows?: boolean;
 }
 /**
- * Resolve every paragraph input semantic layout / table cells share: cascaded props when a
- * style table is present, otherwise direct formatting only.
+ * The mark a note reference paints.
  *
- * When `listItem` is provided, its merged level indent becomes the paragraph indent (list
- * hanging / left from `numbering.xml`), which is what Word uses for fixture list paragraphs
- * that author no direct `w:ind`.
+ * `null` where `w:customMarkFollows` suppresses it: the document supplies its own glyph, and
+ * painting an automatic number too would show the note twice.
+ */
+interface NoteDisplayMark {
+    readonly noteId: number;
+    /** Formatted mark, or `null` when suppressed by customMarkFollows. */
+    readonly mark: string | null;
+    /** 1-based automatic sequence number when assigned; absent when suppressed. */
+    readonly displayNumber?: number;
+}
+type ResolvedNoteProperties = ResolvedFootnoteProperties | ResolvedEndnoteProperties;
+/**
+ * Derive display marks for references of one note kind in document order.
  *
- * `tableCellStyle` carries what the enclosing table's style says about this cell's
- * paragraphs; body paragraphs pass nothing.
+ * Restart rules:
+ * - `continuous` — single sequence across the document from `numStart`
+ * - `eachSect` — restart at `numStart` when `sectionIndex` changes
+ * - `eachPage` — restart when `pageIndex` changes (falls back to continuous if unknown)
+ *
+ * IDs are stable; only display numbers change. Non-mutating.
+ */
+declare function deriveNoteDisplayMarks(noteKind: NoteKind, references: readonly NoteReferenceSite[], properties: ResolvedNoteProperties): readonly NoteDisplayMark[];
+/**
+ * Derive marks using per-reference-section resolved properties (`numFmt` / `numStart` /
+ * `numRestart`). Restart rules consult each site's own section props.
  */
-declare function resolveParagraphLayoutInputs(paragraph: OoxmlElement, contentWidth: number, styleCascade: StyleCascadeTable | undefined, listItem?: ResolvedListItem, tableCellStyle?: TableCellStyleFormatting): ParagraphLayoutInputs;
+declare function deriveNoteDisplayMarksResolved(_noteKind: NoteKind, references: readonly NoteReferenceSite[], resolveProps: (sectionIndex: number) => ResolvedNoteProperties): readonly NoteDisplayMark[];
+/** Map noteId → formatted mark for quick lookup (last site wins if duplicated). */
+declare function noteDisplayMarkMap(marks: readonly NoteDisplayMark[]): ReadonlyMap<number, string | null>;
 
 /** Hard ceiling on notes laid out in one pass (fail closed beyond). */
 declare const MAX_NOTES_LAID_OUT = 10000;
@@ -1134,6 +1153,25 @@ interface NoteSeparatorLayout {
     /** Set when an oversize authored separator was replaced with a synthetic rule. */
     readonly fallbackReason?: NoteLayoutFallbackReason;
 }
+/**
+ * Inline drawing support for ONE notes part.
+ *
+ * A note lives in `/word/footnotes.xml` or `/word/endnotes.xml`, not in the body part, so its
+ * pictures resolve against that part's relationships — the same per-part shape header/footer
+ * furniture uses. Without it a note paragraph flows with no drawing context at all and a
+ * picture inside it contributes no record: no image, and no placeholder either.
+ */
+interface NoteStoryDrawings {
+    readonly inlineDrawingLayout: InlineDrawingLayoutContext;
+    /**
+     * Per-paragraph projection + RESOURCE token for the break cache key.
+     *
+     * Image resources settle asynchronously, and the authored extent does not move when one
+     * does — so without the resource in the key the cached `pending` lines are served forever
+     * and a decoded picture never reaches the page.
+     */
+    readonly drawingTokenForParagraph?: (paragraph: OoxmlNode) => string;
+}
 interface LayoutNoteStoryOptions {
     readonly measurer: TextMeasurer;
     readonly producer: string;
@@ -1147,6 +1185,13 @@ interface LayoutNoteStoryOptions {
      * unbounded page fragments; overflow is split by the pagination layer, not here.
      */
     readonly maxFlowHeightPt?: number;
+    /** Resolves inline drawing support for the notes part a story lives in. */
+    readonly drawingsForPart?: (ownerPartName: string) => NoteStoryDrawings | undefined;
+    /**
+     * Notes part the story being laid out came from. Set by {@link layoutNoteById} /
+     * {@link layoutNoteSeparator}, which are the callers that hold the part.
+     */
+    readonly ownerPartName?: string;
 }
 /**
  * Stable line-id namespace for one note. Body line counters compare these as opaque strings
@@ -1246,6 +1291,11 @@ interface NotesLayoutInput {
     readonly cache?: ParagraphLayoutCache<readonly PendingLine[]>;
     readonly styleCascade?: StyleCascadeTable;
     readonly defaultTabStopPt?: number;
+    /**
+     * Inline drawing support per notes part. Absent means note paragraphs flow without
+     * drawing records, which is what a headless caller with no image port wants.
+     */
+    readonly drawingsForPart?: (ownerPartName: string) => NoteStoryDrawings | undefined;
 }
 /**
  * The layout with notes attached, plus any fallbacks taken and the mark context used.
@@ -2313,4 +2363,4 @@ declare class TablePaginationError extends Error {
     constructor(code: TablePaginationErrorCode, message: string);
 }
 
-export { AUTO_PREFERRED_WIDTH, type AbstractNumDefinition, type BidiEmbeddingLevels, BlockFragmentRecord, CELL_PAD, COMPOUND_BORDER_MIN_GAP_PT, COMPOUND_BORDER_MIN_STROKE_PT, type CanvasMeasurerOptions, type CanvasTextContext, type CanvasTextMetrics, type CascadedParagraphFormatting, CellBorderBox, type CellMarginsPt, type CellVerticalAlign, type CompoundBorderMetrics, type ContentControlFragmentRecord, DEFAULT_CANVAS_FONT_STACK, DEFAULT_CELL_MARGINS, EMPTY_NUMBERING_INDEX, FixedPoint, FixedPointRoundingMode, FontByteValidator, type FontSlot, GRAPHEME_SEGMENTER_LOCALE, type GraphemeBoundary, type GraphemeSegment, type GraphemeWordSegmentRecord, HARFBUZZ_SHAPING_LIBRARY, type HarfBuzzFaceCacheEvent, type HarfBuzzOutlineCacheEvent, type HarfBuzzShapeCacheEvent, HarfBuzzShapingError, type HarfBuzzShapingErrorCode, type HarfBuzzTextShaper, type HarfBuzzTextShaperInstrumentation, type HarfBuzzTextShaperOptions, type HeaderFooterVariantName, HyperlinkProjector, LayoutBox, type LayoutCacheStats, type LayoutScheduler, type LayoutSchedulerOptions, type LayoutScope, type LayoutSession, type LayoutSessionStats, type LevelOverride, type ListCounterAdvance, type ListCounterState, type ListMarkerAlign, type ListSuffix, MAX_EACH_PAGE_MARK_CANDIDATES, MAX_LVL_OVERRIDES, MAX_LVL_TEXT_LENGTH, MAX_MARKER_TEXT_LENGTH, MAX_NOTES_LAID_OUT, MAX_NOTE_FRAGMENTS, MAX_NOTE_OVERFLOW_PAGES, MAX_NOTE_REFLOW_ATTEMPTS, MAX_NUMBERING_DEFINITIONS, MAX_STYLE_BASED_ON_DEPTH, MAX_STYLE_DEFINITIONS, MAX_TABLE_COLUMNS, MAX_TABLE_NESTING, MAX_TABLE_ROW_FRAGMENTS, MAX_TABLE_ROW_HEIGHT_PT, type MaterializationInput, type NoteDisplayMark, type NoteLayoutFallbackReason, type NoteMarkContext, type NotePaginationFallbackReason, type NoteReferenceSite, type NoteSeparatorLayout, type NoteSeparatorRuleStyle, type NoteStoryLayout, type NotesAttachResult, type NotesLayoutInput, type NumDefinition, type NumberingIndex, type NumberingLevel, type NumberingLevelIndent, type PageFurniture, PageGeometry, PageRecord, type PageRefIndex, ParagraphBorderEdge, ParagraphBorders, ParagraphFragmentRecord, type ParagraphKeyInputs, type ParagraphLayoutCache, type ParagraphLayoutCacheOptions, type ParagraphLayoutInputs, ParagraphLineSpacing, ParagraphSpacing, type PreferredWidth, type PreferredWidthType, type ResolvedListItem, ResolvedRunStyle, type ResolvedSurfaceMeasurer, ResolvedTabStops, RevisionDisplayMode, type ScriptItem, SectionColumns, SemanticLayout, type SemanticLayoutOptions, type SemanticTableCell, type SemanticTableRow, type SemanticTableStructure, ShapedRun, type StyleCascadeTable, type StyleDefinition, StyleSpanRecord, type TableAlignment, TableBorderBox, TableBorderSide, type TableCellStyleFormatting, TablePaginationError, type TablePaginationErrorCode, type TableRowHeight, type TableRowHeightRule, TextDirection, TextMeasurer, TextShaper, UnsupportedScriptError, VersionedShapingLibrary, type ViewportWindow, WORD_SEGMENTER_LOCALE, type WordBoundary, type WordBoundaryResolverDeps, type WordSegment, attachNotesToLayout, boundedFallbackWordSegments, buildNumberingIndex, buildPageRefIndex, buildStyleCascadeTable, cascadeParagraphFormatting, cascadeRunProperties, cascadedBottomBorder, clampListValue, computeDoubleBorderMetricsPt, computeFootnoteReserves, contentControlBoundaries, createBoundedFallbackWordBoundary, createDefaultWordBoundary, createFixedMeasurer, createHarfBuzzTextShaper, createIntlWordBoundary, createLayoutScheduler, createLayoutSession, createListCounterState, createParagraphLayoutCache, defaultNoteSeparatorRuleStyle, deriveNoteDisplayMarks, deriveNoteDisplayMarksResolved, effectiveBorderSide, emptyTocPlaceholderParagraphIds, emptyTocSuppressedResultParagraphIds, expandLvlText, filterRefsOnPage, findSeparatorNote, formatDecimal, formatDecimalZero, formatLowerLetter, formatLowerRoman, formatNumFmt, formatUpperLetter, formatUpperRoman, fragmentOwnsAtomOffset, graphemeBoundaryEpoch, graphemeCount, graphemeOffsetToUtf16, harfBuzzFontValidator, initializeHarfBuzz, intlGraphemeBoundary, isCanvasMeasurementAvailable, isCumulativeGeometryTrustedFromLineOrigin, isGeometryTrustedCaretOffset, isHarfBuzzInitialized, isIntlSegmenterAvailable, isIntlWordSegmenterAvailable, isMarkerOnlySeparatorNote, isValidStyleId, isWholeGraphemeHorizontalBoundary, itemizeScriptFontSlots, layoutHeaderFooterStory, layoutNoteById, layoutNoteSeparator, layoutNoteStory, layoutSemanticDocument, listMarkerBox, mergeListIndent, normalNotesOf, noteDisplayMarkMap, noteLineIdPrefix, noteMarkKey, noteSeparatorAreaBox, noteStoryBlocks, pagesToMaterialize, paragraphLayoutKey, paragraphMarkDeleted, paragraphShading, paragraphShadingBox, projectedNoteMarkText, provisionalNoteMarks, readNumPr, readTableStructure, resetGraphemeBoundary, resolveDefaultSurfaceMeasurer, resolveDefaultWordBoundary, resolveNumberingLevel, resolveOoxmlShadingFill, resolveParagraphLayoutInputs, resolveStoryListItems, resolveStrictHexFill, revisionRemovesParagraph, roundFontUnitToFixedPoint, segmentGraphemes, segmentWords, semanticHorizontalBoundaries, setGraphemeBoundary, shadingFillFromElement, shapedHorizontalBoundaries, storyBlocks, syntheticSeparatorBox, tableOriginX, tocFieldChromeParagraphIds, tryCreateCanvasMeasurer, utf16OffsetToGrapheme, walkStoryParagraphs, withNumberingStyleLinks, withResolvedListItems, wordSegmentsToGraphemeRecords };
+export { AUTO_PREFERRED_WIDTH, type AbstractNumDefinition, type BidiEmbeddingLevels, BlockFragmentRecord, CELL_PAD, COMPOUND_BORDER_MIN_GAP_PT, COMPOUND_BORDER_MIN_STROKE_PT, type CanvasMeasurerOptions, type CanvasTextContext, type CanvasTextMetrics, type CascadedParagraphFormatting, CellBorderBox, type CellMarginsPt, type CellVerticalAlign, type CompoundBorderMetrics, type ContentControlFragmentRecord, DEFAULT_CANVAS_FONT_STACK, DEFAULT_CELL_MARGINS, EMPTY_NUMBERING_INDEX, FixedPoint, FixedPointRoundingMode, FontByteValidator, type FontSlot, GRAPHEME_SEGMENTER_LOCALE, type GraphemeBoundary, type GraphemeSegment, type GraphemeWordSegmentRecord, HARFBUZZ_SHAPING_LIBRARY, type HarfBuzzFaceCacheEvent, type HarfBuzzOutlineCacheEvent, type HarfBuzzShapeCacheEvent, HarfBuzzShapingError, type HarfBuzzShapingErrorCode, type HarfBuzzTextShaper, type HarfBuzzTextShaperInstrumentation, type HarfBuzzTextShaperOptions, type HeaderFooterVariantName, HyperlinkProjector, LayoutBox, type LayoutCacheStats, type LayoutScheduler, type LayoutSchedulerOptions, type LayoutScope, type LayoutSession, type LayoutSessionStats, type LevelOverride, type ListCounterAdvance, type ListCounterState, type ListMarkerAlign, type ListSuffix, MAX_EACH_PAGE_MARK_CANDIDATES, MAX_LVL_OVERRIDES, MAX_LVL_TEXT_LENGTH, MAX_MARKER_TEXT_LENGTH, MAX_NOTES_LAID_OUT, MAX_NOTE_FRAGMENTS, MAX_NOTE_OVERFLOW_PAGES, MAX_NOTE_REFLOW_ATTEMPTS, MAX_NUMBERING_DEFINITIONS, MAX_STYLE_BASED_ON_DEPTH, MAX_STYLE_DEFINITIONS, MAX_TABLE_COLUMNS, MAX_TABLE_NESTING, MAX_TABLE_ROW_FRAGMENTS, MAX_TABLE_ROW_HEIGHT_PT, type MaterializationInput, type NoteDisplayMark, type NoteLayoutFallbackReason, type NoteMarkContext, type NotePaginationFallbackReason, type NoteReferenceSite, type NoteSeparatorLayout, type NoteSeparatorRuleStyle, type NoteStoryDrawings, type NoteStoryLayout, type NotesAttachResult, type NotesLayoutInput, type NumDefinition, type NumberingIndex, type NumberingLevel, type NumberingLevelIndent, type PageFurniture, PageGeometry, PageRecord, type PageRefIndex, ParagraphBorderEdge, ParagraphBorders, ParagraphFragmentRecord, type ParagraphKeyInputs, type ParagraphLayoutCache, type ParagraphLayoutCacheOptions, type ParagraphLayoutInputs, ParagraphLineSpacing, ParagraphSpacing, type PreferredWidth, type PreferredWidthType, type ResolvedListItem, ResolvedRunStyle, type ResolvedSurfaceMeasurer, ResolvedTabStops, RevisionDisplayMode, type ScriptItem, SectionColumns, SemanticLayout, type SemanticLayoutOptions, type SemanticTableCell, type SemanticTableRow, type SemanticTableStructure, ShapedRun, type StyleCascadeTable, type StyleDefinition, StyleSpanRecord, type TableAlignment, TableBorderBox, TableBorderSide, type TableCellStyleFormatting, TablePaginationError, type TablePaginationErrorCode, type TableRowHeight, type TableRowHeightRule, TextDirection, TextMeasurer, TextShaper, UnsupportedScriptError, VersionedShapingLibrary, type ViewportWindow, WORD_SEGMENTER_LOCALE, type WordBoundary, type WordBoundaryResolverDeps, type WordSegment, attachNotesToLayout, boundedFallbackWordSegments, buildNumberingIndex, buildPageRefIndex, buildStyleCascadeTable, cascadeParagraphFormatting, cascadeRunProperties, cascadedBottomBorder, clampListValue, computeDoubleBorderMetricsPt, computeFootnoteReserves, contentControlBoundaries, createBoundedFallbackWordBoundary, createDefaultWordBoundary, createFixedMeasurer, createHarfBuzzTextShaper, createIntlWordBoundary, createLayoutScheduler, createLayoutSession, createListCounterState, createParagraphLayoutCache, defaultNoteSeparatorRuleStyle, deriveNoteDisplayMarks, deriveNoteDisplayMarksResolved, effectiveBorderSide, emptyTocPlaceholderParagraphIds, emptyTocSuppressedResultParagraphIds, expandLvlText, filterRefsOnPage, findSeparatorNote, formatDecimal, formatDecimalZero, formatLowerLetter, formatLowerRoman, formatNumFmt, formatUpperLetter, formatUpperRoman, fragmentOwnsAtomOffset, graphemeBoundaryEpoch, graphemeCount, graphemeOffsetToUtf16, harfBuzzFontValidator, initializeHarfBuzz, intlGraphemeBoundary, isCanvasMeasurementAvailable, isCumulativeGeometryTrustedFromLineOrigin, isGeometryTrustedCaretOffset, isHarfBuzzInitialized, isIntlSegmenterAvailable, isIntlWordSegmenterAvailable, isMarkerOnlySeparatorNote, isValidStyleId, isWholeGraphemeHorizontalBoundary, itemizeScriptFontSlots, layoutHeaderFooterStory, layoutNoteById, layoutNoteSeparator, layoutNoteStory, layoutSemanticDocument, listMarkerBox, mergeListIndent, normalNotesOf, noteDisplayMarkMap, noteLineIdPrefix, noteMarkKey, noteSeparatorAreaBox, noteStoryBlocks, pagesToMaterialize, paragraphLayoutKey, paragraphMarkDeleted, paragraphShading, paragraphShadingBox, projectedNoteMarkText, provisionalNoteMarks, readNumPr, readTableStructure, resetGraphemeBoundary, resolveDefaultSurfaceMeasurer, resolveDefaultWordBoundary, resolveNumberingLevel, resolveOoxmlShadingFill, resolveParagraphLayoutInputs, resolveStoryListItems, resolveStrictHexFill, revisionRemovesParagraph, roundFontUnitToFixedPoint, segmentGraphemes, segmentWords, semanticHorizontalBoundaries, setGraphemeBoundary, shadingFillFromElement, shapedHorizontalBoundaries, storyBlocks, syntheticSeparatorBox, tableOriginX, tocFieldChromeParagraphIds, tryCreateCanvasMeasurer, utf16OffsetToGrapheme, walkStoryParagraphs, withNumberingStyleLinks, withResolvedListItems, wordSegmentsToGraphemeRecords };