@arbidocs/blocks 0.4.101 → 0.4.102

package/node_modules/@docx-editor.dev/core/dist/index-Bsg7oIKP.d.ts

@@ -0,0 +1,3869 @@
+import { W as TreeDocOp, co as TextFormFieldRange, cn as TextFormFieldOptions, au as Unsubscribe, E as ExecResult, ao as DrawingPositionInput, aM as DrawingTransform, A as ParagraphTabStop, y as IndentFormatting, z as ParagraphFlags, aB as ParagraphDisagreements, aj as DrawingTreeDocOp, at as SelectionPin, Q as OoxmlPackage, g as ReviewRevisionKind, an as ImageWrapTarget } from './types-barrel-D3xCgQX6.js';
+import { k as FieldResultsMode, I as InsertImageInput, S as StoryScope, A as ApplyImagePropertiesInput, i as ImageIntentResult } from './tree-package-fragment-BeeKxDw8.js';
+import { a as ImageDecodePort, S as SupportedImageMime } from './image-resources-BN-hUgCn.js';
+import './document-protection-BAGVGqaP.js';
+import { EditorModule, ReviewModuleContribution } from './contracts/modules.js';
+import { D as DocumentSource, a as FontConfiguration, Z as ZoomMode, E as EditorFontError, i as Editor, e as EditorCommand, C as CanResult, p as SelectedImageState, z as FormatPainterSurfaceState, g as ScrollPlacement, r as TrackedChangePredicate, q as TrackedChangeFilterMode, F as FontFaceRequest, b as FontSource, I as ImageContext, B as TableBorderEdgeTarget, G as TableBorderSpec, J as TableBorderStyle, K as TableContext } from './editor-Ci7IZGmG.js';
+import { e as RevisionMarkupOptions, a as ReviewDisplayMode, i as RevisionMarkupChromeHandlers, d as ResolvedRevisionMarkup } from './revision-projection-DZ4kKVev.js';
+import { S as SemanticPosition, a as SemanticSelection, N as NavigationCommand } from './semantic-interaction-CIC-PooQ.js';
+import { e as FontConfigurationFragment, g as FontResolver, i as MarkedFontResolver, f as FontResolutionRequest } from './font-resolver-BVQB14qT.js';
+import { R as ReviewPaneOptions } from './review-pane-D9jm8DcY.js';
+import { EditorCollaborationSession, CollaborationRemoteSelection, CollaborationModuleContribution } from './collaboration.js';
+import { d as RevisionStyles, R as ReviewAuthorInfo, c as RevisionAuthorStyle, F as FieldShadingMode, f as DrawingPaintStrings } from './semantic-paint-BME37OMv.js';
+import { b as ResolvedFootnoteProperties, R as ResolvedEndnoteProperties, A as AuthoredNoteProperties } from './note-properties-4Y9o6Gyk.js';
+import { S as SemanticLayout, T as TextMeasurer, C as ContentControlBoundaryRecord } from './semantic-records-4B3WwFAi.js';
+import { B as BookmarkIndex } from './custom-node-writes-cvL5rhcD.js';
+import { C as CellSelection, S as SectionProperties } from './semantic-cell-selection-D9D1KSXq.js';
+import { T as TreeDocxSessionView, a as TreeApplyResult } from './tree-session-contract-CVbmlMlq.js';
+import { C as CollaborationStatus } from './failure-NS2lsya4.js';
+import { V as ViewScope, b as EditorExecOptions } from './editor-scope-OHPwVQ5l.js';
+import './contracts/document.js';
+import './contracts/interaction.js';
+
+/**
+ * A blank document, freshly zipped per call (the caller may hand the
+ * bytes to a loader that takes ownership). Calibri 11pt and Word's Normal paragraph
+ * spacing are authored in `w:docDefaults`, Word's built-in style gallery in `styles.xml`,
+ * and US Letter geometry in the section. Word opens the saved file.
+ *
+ * @public
+ */
+declare function blankDocumentBytes(): Uint8Array;
+
+type TableCommandSelectionPolicy = {
+    readonly kind: 'preserveSelection';
+} | {
+    readonly kind: 'adoptCommittedCaret';
+};
+type TableCommandPlan = {
+    readonly ok: true;
+    readonly ops: readonly TreeDocOp[];
+    readonly selection: TableCommandSelectionPolicy;
+} | {
+    readonly ok: false;
+    readonly code: 'unsupported' | 'invalidArgs' | 'locked';
+    readonly reason: string;
+};
+
+type NotePropertiesSlice = {
+    readonly resolved: ResolvedFootnoteProperties | ResolvedEndnoteProperties;
+    readonly documentAuthored?: AuthoredNoteProperties;
+    readonly sectionAuthored?: AuthoredNoteProperties;
+};
+type NotePropertiesStateSnapshot = {
+    readonly sectionIndex: number;
+    readonly footnote: NotePropertiesSlice;
+    readonly endnote: NotePropertiesSlice;
+};
+
+/** Priority of an editor-owned popup renderer. @public */
+interface PopupChromeRegistrationOptions {
+    /** Use only when no manually registered renderer exists. */
+    readonly fallback?: boolean;
+}
+/**
+ * A core-owned content-control value edit.
+ *
+ * `kind` names the widget that was pressed. A `checkbox` session carries the current state as
+ * `'true'` / `'false'` and expects the opposite (or the same) back through `apply`; the
+ * packaged pop-ups apply the toggle at once, so a host only sees it when it renders the
+ * widget itself. A `buildingBlockGallery` session is a list session: `items` are the
+ * glossary's blocks for the control's gallery, named by `w:docPartPr/w:name`, and `apply`
+ * takes a name. A `picture` session carries the control's drawing node id as `value` and
+ * takes new image bytes through `replaceImage`; `apply` refuses, since no text stands for an
+ * image.
+ * @public
+ */
+interface ContentControlWidgetSession {
+    readonly controlId: string;
+    readonly kind: 'dropdown' | 'comboBox' | 'date' | 'checkbox' | 'picture' | 'buildingBlockGallery';
+    readonly items: readonly {
+        readonly displayText: string;
+        readonly value: string;
+    }[];
+    readonly value: string;
+    /** The editor's regional locale, for a date picker's month, weekday and first-day rules. */
+    readonly locale: string;
+    readonly anchor: HTMLElement | null;
+    readonly signal: AbortSignal;
+    canApply(): boolean;
+    apply(value: string): boolean;
+    cancel(): void;
+    /**
+     * Picture sessions only: replace the control's image with these bytes. The engine sniffs
+     * the format (PNG, JPEG, GIF, BMP or WebP) and keeps the drawing's size. Resolves false
+     * when the bytes are not a supported image, the control no longer takes a write, or the
+     * document is open for viewing or suggesting. Cancellation during decoding prevents
+     * the commit; only one replacement may be pending for a session.
+     */
+    replaceImage?(bytes: Uint8Array): Promise<boolean>;
+}
+/** Framework rendering for content-control value widgets. @public */
+interface ContentControlWidgetChromeHandlers {
+    readonly onRequest?: (session: ContentControlWidgetSession) => void;
+    /**
+     * Session kinds this renderer takes. Defaults to `dropdown`, `comboBox`, `date` and
+     * `buildingBlockGallery` (the list-shaped sessions), so a renderer written for the pop-ups
+     * never receives a checkbox or picture press it does not expect. Include `'checkbox'` to
+     * take those presses too; the engine then leaves the toggle to `apply`, and a press nobody
+     * takes toggles the box as before. Include `'picture'` to own the image pick; a press nobody
+     * takes opens the engine's own file picker.
+     */
+    readonly kinds?: readonly ContentControlWidgetSession['kind'][];
+}
+/** An invalid protected-field acknowledgement. @public */
+interface InvalidTextFormFieldSession {
+    readonly type: 'number' | 'date';
+    readonly signal: AbortSignal;
+    /** Clear the unchanged invalid value, if the target still permits it. */
+    acknowledge(): void;
+    /** Dismiss without clearing the authored value. */
+    cancel(): void;
+}
+/** Framework rendering for invalid protected-field acknowledgements. @public */
+interface InvalidTextFormFieldChromeHandlers {
+    readonly onRequest?: (session: InvalidTextFormFieldSession) => void;
+}
+
+/** A core-owned options edit. Its signal aborts when the dialog must close. @public */
+interface TextFormFieldDialogSession {
+    readonly field: TextFormFieldRange;
+    readonly signal: AbortSignal;
+    /** Whether the current target exists and permits editing. Draft validation happens on apply. */
+    canApply(): boolean;
+    /** Save one undoable edit. A refused write leaves the session open. */
+    apply(text: string, options: TextFormFieldOptions): boolean;
+    /** Close without changing the document. Safe to call more than once. */
+    cancel(): void;
+}
+/** Framework-owned presentation for core-owned Field Options sessions. @public */
+interface TextFormFieldChromeHandlers {
+    readonly onRequest?: (session: TextFormFieldDialogSession) => void;
+}
+
+/**
+ * Receives the element that shows the loading indicator on the first page, while a large
+ * document lays out its remaining pages.
+ *
+ * @example
+ * ```ts
+ * editor.setOpeningIndicatorHost({
+ *   publish(element) {
+ *     // Render your indicator into `element`, or remove it when `element` is null.
+ *   },
+ * });
+ * ```
+ *
+ * @public
+ */
+interface OpeningIndicatorHost {
+    /**
+     * Called with the indicator element when the first pages show, and with `null` when the
+     * remaining pages are laid out or the open is abandoned. The element is empty while a host
+     * is set: render the host's content into it. It is centered on the first page, at most 30%
+     * of the window height below the page top, and scrolls with the document.
+     */
+    publish(element: HTMLElement | null): void;
+}
+
+/**
+ * A hyperlink as the surface reports it: its identity, where it sits, and the SANITIZED
+ * target. `href: null` is an inert link — a refused scheme or a dangling relationship — which
+ * a UI shows and offers to edit but must never offer to open.
+ */
+interface SurfaceHyperlink {
+    /** Canonical node id of the `w:hyperlink`. */
+    readonly id: string;
+    readonly paragraphId: string;
+    /** UTF-16 range of the link's display text within its paragraph. */
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+    readonly kind: 'external' | 'internal' | 'unresolved';
+    /** Sanitized projection: an absolute URL, `#anchor`, or null when inert. */
+    readonly href: string | null;
+    /** The authored target, for an editor to seed its input with. */
+    readonly authored: string;
+    readonly anchor?: string;
+    readonly tooltip?: string;
+}
+/**
+ * Reading and writing hyperlinks on the surface.
+ *
+ * Every href that leaves here has already been through `sanitizeHref` — targets come from files,
+ * so `javascript:`, `data:` and `vbscript:` are dropped at the parse boundary rather than trusted
+ * to be filtered by whoever renders them.
+ */
+interface HyperlinkOps {
+    /** Every link in the paragraph the caret is in. */
+    linksInCaretParagraph(): SurfaceHyperlink[];
+    /** The link the caret sits in, or null. */
+    linkAtCaret(): SurfaceHyperlink | null;
+    /**
+     * The FIELD link whose painted atom the caret sits on, or null.
+     *
+     * Separate from {@link linkAtCaret} on purpose: a `HYPERLINK` field is not a tree node, so
+     * the typed lane never returns one, and link-create must not mistake a field atom for an
+     * editable link. Resolved from the layout projection, boundary-inclusive.
+     */
+    fieldLinkAtCaret(): SurfaceHyperlink | null;
+    /** The link with this node id, or null. */
+    linkById(linkId: string): SurfaceHyperlink | null;
+    /**
+     * Apply a link to the selection, or retarget the one the caret is already in.
+     *
+     * `text` replaces the display text when supplied. Returns whether anything committed;
+     * a refusal leaves the document exactly as it was.
+     */
+    applyHyperlink(input: {
+        readonly url?: string;
+        readonly anchor?: string;
+        readonly text?: string;
+        readonly tooltip?: string;
+    }): boolean;
+    /** Take the link off the one at the caret (or a named one). Returns whether it committed. */
+    removeHyperlink(linkId?: string): boolean;
+}
+
+/** A click on a painted link, after native navigation was refused. */
+interface HyperlinkActivation {
+    readonly link: SurfaceHyperlink;
+    /** The clicked line fragment's viewport rect, so a popover can be placed under it. */
+    readonly rect: {
+        readonly left: number;
+        readonly top: number;
+        readonly bottom: number;
+        readonly right: number;
+    };
+}
+/**
+ * Moving the caret and the viewport: to a position, to a bookmark, or out to an external target.
+ *
+ * {@link SurfaceNavigation.openExternal} is THE external-activation call site, and it refuses
+ * anything but an already-sanitized href. Routing an authored target through some other path is
+ * how a document gets to choose where a click goes.
+ */
+interface SurfaceNavigation {
+    /** Snap to a semantic position using layout geometry, then place the caret there. */
+    goToPosition(position: {
+        paragraphId: string;
+        offset: number;
+    }): boolean;
+    /**
+     * Scroll a bookmark into view and place the caret at it. Answers false for a name no
+     * bookmark declares — an inert click, which is what Word does with a dangling anchor.
+     */
+    goToBookmark(name: string): boolean;
+    /**
+     * THE external-activation call site. Refuses anything but a sanitized projection, so a
+     * caller cannot route an authored target through it by mistake.
+     */
+    openExternal(href: string | null): boolean;
+    destroy(): void;
+}
+
+/** One addressable inline equation and its compact editable projection. */
+interface SurfaceEquation {
+    readonly id: string;
+    readonly paragraphId: string;
+    readonly start: number;
+    readonly end: number;
+    readonly linear: string;
+    readonly fallbackText: string;
+    /** True when every source construct belongs to the editable subset. */
+    readonly supported: boolean;
+}
+/** A user click on one painted equation. */
+interface EquationActivation {
+    readonly equation: SurfaceEquation;
+    readonly rect: {
+        readonly left: number;
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+    };
+}
+/** Boundary-inclusive lookup, matching the hyperlink and field atom popovers. */
+declare function equationAtPosition(equations: readonly SurfaceEquation[], position: SemanticPosition): SurfaceEquation | null;
+type EquationAction = 'replace' | 'remove';
+/** Engine-owned capability result for equation editing chrome. */
+type EquationCanResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: 'locked' | 'notFound' | 'unsupported';
+    readonly reason: string;
+};
+/** Surface equation reads and atomic replace/remove writes. */
+interface EquationOps {
+    equationsInCaretParagraph(): SurfaceEquation[];
+    equationAtCaret(): SurfaceEquation | null;
+    equationById(equationId: string): SurfaceEquation | null;
+    /** Whether equation chrome can run an action, with the engine-owned refusal reason. */
+    can(equationId: string, action: EquationAction): EquationCanResult;
+    applyEquation(equationId: string, linear: string): boolean;
+    removeEquation(equationId: string): boolean;
+}
+
+/**
+ * Everything {@link createDocxEditor} accepts. Every field is optional.
+ *
+ * `container` is the one that changes the shape of the whole lifecycle: omitting it produces an
+ * instance that does no DOM work until `attach(el)`, which is what lets a provider own the editor
+ * before any component has rendered a mount point.
+ *
+ * @public
+ */
+interface DocxEditorConfig {
+    /**
+     * The element the paginated surface mounts into. The surface owns this subtree.
+     *
+     * Optional: an instance created WITHOUT a container stashes its document bytes and does
+     * no DOM work until `attach(el)` — the provider-first shape, where the editor exists
+     * before any component has rendered a mount point. With a container, the document mounts
+     * immediately at construction, exactly as before.
+     */
+    container?: HTMLElement;
+    /**
+     * A document to load at construction: DOCX bytes, or `'blank'` for Word's blank
+     * template. A `DocumentHandle` cannot be re-opened (the handle is identity, not
+     * content), so passing one emits a typed `error` event rather than silently loading
+     * nothing. Omitting this mounts NO document, which is not the same as an empty one.
+     */
+    document?: DocumentSource;
+    /**
+     * Font bytes for Word-accurate (HarfBuzz-shaped) line wrap and pagination. Omitted,
+     * layout falls back to a fixed-width estimate; fonts embedded in the document are
+     * wired in automatically either way. For Word's default faces (Calibri, Times New
+     * Roman, …) pass `await loadDefaultFonts()` from `@docx-editor.dev/fonts` — a bare
+     * fragment (`{ sources, substitutions }`) is accepted and composed with defaults, or
+     * merge several origins yourself with `composeFontConfiguration`. Sampled per load;
+     * failures degrade to the fixed measurer and report through `onFontError`.
+     *
+     * Pass a {@link FontResolver} instead to resolve ON DEMAND: the function is called once
+     * per load, after the document is parsed, with the families it actually declares, and
+     * only what it returns is loaded. A document naming nothing the resolver covers costs
+     * nothing. Note that a fetching resolver makes opening a document perform network
+     * requests — the engine never supplies one, so that stays your call.
+     */
+    fonts?: FontConfiguration | FontConfigurationFragment | FontResolver;
+    author?: string;
+    /** BCP-47 locale for regional date input and generated labels; defaults to en-US. */
+    locale?: string;
+    /** Drawing and form-control UI labels; defaults to English when omitted. */
+    translate?: (key: string, params?: Record<string, string | number>) => string;
+    /**
+     * Capability modules to register — the seam `@docx-editor.dev/pro` plugs in
+     * through. Omitted, the editor runs the free tier: lossless round-trip,
+     * final-state revision rendering, review chrome disabled with the engine's
+     * reason. See {@link EditorModule}.
+     */
+    modules?: readonly EditorModule[];
+    /**
+     * The mode the editor opens in — one prop, matching the toolbar's three-state pill.
+     *
+     * - `'edit'` — opens in editing, even when the document's `w:trackRevisions` asks for
+     *   tracked changes; the reader still moves between modes from the toolbar.
+     * - `'suggesting'` — opens in suggesting. It needs what suggesting always needs — a
+     *   review module and an {@link DocxEditorConfig.author} — and falls back to editing
+     *   with the reason published when either is missing. A missing author is a host
+     *   configuration error and is also reported once on the console; the editor enters
+     *   suggesting as soon as {@link DocxEditorInstance.setAuthor} names one.
+     * - `'view'` — read-only: every mutating command through the facade is refused, and
+     *   the toolbar cannot leave viewing.
+     * - Omitted — the DOCUMENT decides: a package carrying `w:trackRevisions` opens in
+     *   suggesting, everything else in editing.
+     */
+    mode?: 'edit' | 'view' | 'suggesting';
+    /**
+     * How painted tracked changes are coloured. Presentation only — nothing is serialised.
+     *
+     * - `'author'` (the DEFAULT) — every change takes its author's colour from the
+     *   `--doc-review-author-N` ramp, by order of first appearance, as Word does. Restyle a
+     *   slot under `.docx-editor` to change the ramp.
+     * - `'kind'` — insertions green, deletions red, so "added" and "removed" are what a
+     *   glance tells apart, whoever proposed them.
+     * - {@link RevisionAuthorAssignments} — style the named authors; `others` decides
+     *   whether the rest take the ramp (the default) or the kind colours.
+     *
+     * The opening value. In React this is authored declaratively — `DocxEditor.ColorByChangeType`
+     * and `DocxEditor.AuthorStyle` compose and apply it, seeding this config for the first
+     * paint — so React hosts never pass it by hand; it is the entry for headless hosts. Read
+     * the document's resolved roster with `getReviewAuthors`. Applies wherever revision
+     * markup paints: the full all-markup view needs a review module registered; without one
+     * the proposed view still marks surviving insertions.
+     */
+    revisionStyles?: RevisionStyles;
+    /** Initial local revision presentation and tracking preferences. */
+    revisionMarkup?: RevisionMarkupOptions;
+    /** Initial review projection. Markup modes require a review module. */
+    reviewDisplayMode?: ReviewDisplayMode;
+    /**
+     * How the reader edits saved field results.
+     *
+     * - `'atomic'` (the DEFAULT) — every field is one unit: typing beside a field lands before
+     *   or after it, and Backspace removes it whole.
+     * - `'editable'` — fields that show their saved result (DATE, TIME, MERGEFIELD, HYPERLINK
+     *   display text, QUOTE, FILENAME, FILLIN, SEQ, and the save, print, and creation dates)
+     *   accept typing, deletion, and selection inside the result. Fields the engine computes
+     *   live (PAGE, NUMPAGES, REF, PAGEREF, DOCPROPERTY, and others) stay one unit.
+     *
+     * Editable results must be unnested. Simple fields inside complex field results are not
+     * supported in editable mode.
+     *
+     * Fixed for the instance. `'editable'` with a collaboration module throws a `TypeError`:
+     * shared paragraph text keeps every field one unit.
+     */
+    fieldResults?: FieldResultsMode;
+    /** Override raster decode for insert/replace image commands; defaults to browser/headless. */
+    imageDecodePort?: ImageDecodePort;
+    /**
+     * The scale to open at, as a fixed number.
+     *
+     * Supplying one also picks the mode: an editor given a `zoom` and no `zoomMode` opens
+     * FIXED at that value and stays there. An embedder that pinned 100% keeps 100%.
+     */
+    zoom?: number;
+    /**
+     * Where the scale comes from. Defaults to `'auto'` — fit the page width, between 50% and
+     * 100% — unless {@link DocxEditorConfig.zoom} is supplied, which means fixed.
+     *
+     * `'auto'` leaves a window wide enough for the sheet exactly where it is today and shrinks
+     * a narrower one instead of growing a horizontal scrollbar. Pass `{ type: 'fixed' }` for
+     * the old unconditional behaviour.
+     */
+    zoomMode?: ZoomMode | 'auto';
+    onFontError?: (error: EditorFontError) => void;
+    /** Localized labels for table insertion furniture on the painted surface. */
+    tableInteractionLabel?: (key: 'table.insertRowBelow' | 'table.insertColumnRight') => string;
+}
+/**
+ * Which measurer the current document's layout runs on, and whether shaped resolution is
+ * still in flight. Returned by {@link DocxEditorInstance.fontMeasurement}.
+ */
+interface FontMeasurementState {
+    /** `fixed` estimates advance widths; `shaped` measures real font bytes with HarfBuzz. */
+    readonly measurer: 'fixed' | 'shaped';
+    /** True while font resolution for the current document is still running. */
+    readonly resolving: boolean;
+    /** The shaped measurer's identity (admitted face hashes); absent while fixed. */
+    readonly producer?: string;
+}
+/**
+ * The host chrome that answers the engine's hyperlink gestures.
+ *
+ * A CLICK on an external link and Ctrl/Cmd+K both mean "the user wants the link UI", and the
+ * engine deliberately does not know what that looks like. Registered rather than passed at
+ * construction because the chrome mounts after the editor does, and it survives a document
+ * reload — the surface is rebuilt, the handlers are not.
+ */
+interface HyperlinkChromeHandlers {
+    /** A plain click on an external or inert link: show the popover at `activation.rect`. */
+    readonly onPopover?: (activation: HyperlinkActivation) => void;
+    /** Ctrl/Cmd+K: open insert-or-edit for the selection. */
+    readonly onRequest?: () => void;
+}
+/** Host chrome that edits a clicked Office Math equation. */
+interface EquationChromeHandlers {
+    readonly onPopover?: (activation: EquationActivation) => void;
+}
+/**
+ * The concrete facade type: the full `Editor` contract plus the instance-only surface.
+ *
+ * `surface`, `stateVersion`, `attach` and `detach` live HERE rather than on `Editor`:
+ * they are what a store binding and a mounting host need, not what document commands
+ * need. Production adapters program against `Editor` for everything else.
+ */
+interface DocxEditorInstance extends Editor {
+    /** Bumps on mount, detach, destroy, and document reload — guards async image intents. */
+    readonly mountGeneration: number;
+    /**
+     * The underlying paginated surface for harnesses and tests that need capabilities the
+     * contract does not carry yet (select-all, node-id addressed selection).
+     */
+    readonly surface: PaginatedSurface | null;
+    /**
+     * Wire the host's hyperlink chrome to the engine's gestures — a click on an external
+     * link, and Ctrl/Cmd+K. Returns an unsubscribe that restores whatever was registered
+     * before, so a popover component can register in an effect and clean up in its teardown.
+     *
+     * Instance-only, like `surface`: it is what a MOUNTING host needs, not what a document
+     * command needs.
+     */
+    setHyperlinkChrome(handlers: HyperlinkChromeHandlers): Unsubscribe;
+    /**
+     * Register local revision settings chrome. Disposal cancels its active sessions.
+     * Manual renderers take priority over fallback renderers. Pass null to use native chrome
+     * until disposal restores the previous registration.
+     */
+    setRevisionMarkupChrome(handlers: RevisionMarkupChromeHandlers | null, options?: PopupChromeRegistrationOptions): Unsubscribe;
+    /** Register Field Options chrome. Disposal closes sessions owned by this registration. */
+    setTextFormFieldChrome(handlers: TextFormFieldChromeHandlers, options?: PopupChromeRegistrationOptions): Unsubscribe;
+    /** Register typed content-control widget chrome. */
+    setContentControlWidgetChrome(handlers: ContentControlWidgetChromeHandlers, options?: PopupChromeRegistrationOptions): Unsubscribe;
+    /** Register invalid protected-field acknowledgement chrome. */
+    setInvalidTextFormFieldChrome(handlers: InvalidTextFormFieldChromeHandlers, options?: PopupChromeRegistrationOptions): Unsubscribe;
+    /** Wire the host equation popover to painted equation clicks. */
+    setEquationChrome(handlers: EquationChromeHandlers): Unsubscribe;
+    /**
+     * Render the host's own component as the remote-caret label, or restore the default
+     * collaborator-name label with `null`. The engine keeps owning label geometry, class,
+     * and presence colour; the host owns the content of each published element.
+     *
+     * Instance-only, like `setHyperlinkChrome`: it is what a MOUNTING host needs. Tolerated
+     * before `attach` and after `detach` — the registration waits and applies on the next
+     * mount, and it survives a document reload the way the hyperlink chrome does.
+     */
+    setRemoteCaretLabelHost(host: RemoteCaretLabelHost | null): void;
+    /**
+     * Render the host's own loading indicator on the first page while a large document lays out
+     * its remaining pages, or restore the packaged spinner with `null`. The engine keeps owning
+     * the element and its place on the page; the host owns its content.
+     *
+     * Instance-only, like `setRemoteCaretLabelHost`, and tolerated at any time: a host set
+     * before the open applies when the first pages show. `DocxEditor.Loading` with `overlay`
+     * registers one for you, so set this only when you build your own loading screen.
+     *
+     * @example
+     * ```ts
+     * editor.setOpeningIndicatorHost({
+     *   publish(element) {
+     *     element?.replaceChildren(document.createTextNode('Opening…'));
+     *   },
+     * });
+     * ```
+     */
+    setOpeningIndicatorHost(host: OpeningIndicatorHost | null): void;
+    /**
+     * Monotonic version of the observable editor state. Bumps whenever anything
+     * `snapshot()` reports could have moved — a committed change, a selection move, zoom,
+     * load success or failure, attach/detach, destroy. An external store (React's
+     * `useSyncExternalStore`) uses it as a cheap "did anything change" signal; `snapshot()`
+     * itself is cached per version and returns a stable reference between bumps.
+     */
+    stateVersion(): number;
+    /**
+     * Which measurer the current document's layout runs on, and whether shaped
+     * resolution is still in flight — the honest "are wrap points Word-accurate yet?"
+     * readout a host shows instead of guessing. `fixed` with `resolving: false` is the
+     * steady state for a document with no usable font source (the documented zero-config
+     * fallback); `shaped` means HarfBuzz measurement over real font bytes. Changes bump
+     * `stateVersion()`.
+     */
+    fontMeasurement(): FontMeasurementState;
+    /**
+     * Every author the review surface DRAWS, in Word's slot order, with the colour the review
+     * chrome draws them in. The discovery surface a legend or colour picker builds on —
+     * authors depend on the loaded file, so they cannot be known at configuration time.
+     *
+     * The colour is the author's, not the document's: under `'kind'` the painted text goes to
+     * the insertion/deletion colours while the cards keep these accents, so a legend built
+     * from this describes the rail rather than the page.
+     *
+     * BOTH HALVES OF REVIEW. Authors of tracked changes come first, numbered by where their
+     * first change appears; authors who only commented follow. One person therefore draws in
+     * one colour across their comments and their edits, which is what a reader assumes the
+     * moment they learn the pairing on either. The order puts commenters last so that adding
+     * a comment can never renumber a tracked change the painter has already drawn.
+     *
+     * The complete attached-document roster. A reviewer remains listed while this view hides
+     * their changes, so the reviewer menu can turn them on again. Empty while detached.
+     * Reference-stable between changes, so it is safe as a dependency; changes bump
+     * `stateVersion()`.
+     */
+    getReviewAuthors(): readonly ReviewAuthorInfo[];
+    /** Whether this author's revisions and comments are shown in the current review view. */
+    isReviewAuthorVisible(author: string): boolean;
+    /**
+     * Show one author's markup, or render their revisions as accepted and hide their comments.
+     * This changes view state only. It does not apply tree operations or change saved bytes.
+     */
+    setReviewAuthorVisible(author: string, visible: boolean): void;
+    /** Show or hide every reviewer in one layout pass. */
+    setAllReviewAuthorsVisible(visible: boolean): void;
+    /** Restore every reviewer to the shown state. */
+    showAllReviewAuthors(): void;
+    /**
+     * The presence colour the engine paints for one display name — the answer the remote
+     * caret label takes, so chrome built on this cannot disagree with the painted caret.
+     *
+     * A name the review roster draws takes its resolved colour, sanitized exactly as the
+     * paint sink sanitizes it: a declared colour the paint refuses falls to the author's
+     * ramp-slot token. Any other name takes the next slot from the engine's stable
+     * allocator, in first-resolution order, and keeps it for the session. While no document
+     * is attached this returns `'var(--doc-accent)'`, the same default the overlay CSS
+     * falls back to.
+     */
+    presenceColorFor(name: string): string;
+    /**
+     * The live collaboration replica, or null when this editor is not in a room.
+     *
+     * Presence chrome reads it from here rather than being handed it: the editor already holds
+     * the session a `collaborationModule` contributed, so a host that threads it down to every
+     * avatar and caret consumer is passing something the tree below it can already see.
+     */
+    collaborationSession(): EditorCollaborationSession | null;
+    /**
+     * The configured author used when a comment or reply omits an explicit author.
+     *
+     * @internal Review compose chrome uses this to draw an unfinished comment in the same
+     * author colour it will receive after commit.
+     */
+    getConfiguredAuthor(): string | null;
+    /**
+     * Set the author for runtime editor state.
+     *
+     * Unlike the construction-time {@link DocxEditorConfig.author}, this value applies to every
+     * later comment, reply, and tracked change. It does not rewrite existing revisions. The value
+     * survives document reloads and font remounts. An empty or whitespace value clears the author,
+     * after which suggesting refuses writes with its existing reason.
+     *
+     * Naming an author also completes a request for suggesting that was refused for want of
+     * one — a `mode: 'suggesting'` or a document's `w:trackRevisions` that opened in editing —
+     * unless the reader has chosen a mode since.
+     *
+     * @public
+     */
+    setAuthor(author: string | undefined): void;
+    /**
+     * Set the host editing mode without rebuilding the editor.
+     *
+     * This has the same meaning as {@link DocxEditorConfig.mode}. Passing `undefined` lets the
+     * document's tracking settings select the mode again. A host change clears the reader's
+     * toolbar choice, so a later document reload can adopt `w:trackRevisions` again.
+     *
+     * @public
+     */
+    setMode(mode: 'edit' | 'view' | 'suggesting' | undefined): void;
+    /**
+     * Set the drawing and form-control label resolver without rebuilding the editor.
+     * Open dialogs preserve their controls and input; later surface mounts use the same resolver.
+     *
+     * @public
+     */
+    setTranslate(translate: ((key: string, params?: Record<string, string | number>) => string) | undefined): void;
+    /**
+     * Set regional date input and generated labels without rebuilding the editor.
+     * Stored dates are preserved; an in-progress field edit retains its starting locale.
+     * Omitted, invalid, and unsupported locales use en-US. Translation catalogues fall back by language.
+     *
+     * @public
+     */
+    setLocale(locale: string | undefined): void;
+    /**
+     * The style declared for one author, whether or not the SURFACE has published them yet —
+     * so review chrome can draw a card the rail is holding before the roster catches up.
+     *
+     * {@link DocxEditorInstance.getReviewAuthors} answers for every author of a tracked
+     * change or a comment, so this is a narrow fallback rather than the way to reach a
+     * commenter.
+     *
+     * @internal The seam `@docx-editor.dev/pro`'s review rail resolves those authors
+     * through. A consumer reads `useReviewAuthor` (pro) or `useReviewAuthors` (react)
+     * instead; nothing here answers a question those two do not.
+     */
+    getReviewAuthorStyle(author: string): RevisionAuthorStyle | undefined;
+    /**
+     * Replace how tracked changes are coloured, live. Paint-level: pages repaint without a
+     * layout pass, and the caret, selection and undo history stay where they are. Pass
+     * `'author'` to restore the default, or `'kind'` to opt out to the green/red
+     * rendering. Survives a document reload.
+     *
+     * The imperative PRIMITIVE beneath React's declarative lane: `DocxEditor.ColorByChangeType`
+     * and `DocxEditor.AuthorStyle` drive this seam, and React hosts declare those instead
+     * of calling it. Call it directly from headless and non-React hosts.
+     */
+    setRevisionStyles(styles: RevisionStyles): void;
+    /** Merge local preferences and emit revisionMarkupChange after a change.
+     * Invalid settings throw TypeError without changing the previous settings.
+     */
+    setRevisionMarkup(options: RevisionMarkupOptions): void;
+    /**
+     * Change the review pane settings: every field of `ReviewPaneOptions`, such as when the
+     * pane opens by itself and what it does when its card column does not fit. An omitted
+     * field keeps its value. Read the settings in force
+     * from `snapshot().reviewPane`. They stay in force across `load()` and are never saved into
+     * the document. This sets how the pane behaves; to open or close the pane itself, use
+     * `useReview().setPaneOpen` or the `toggleReviewPane` command.
+     *
+     * Returns `changed: false` on success, like every view-only call, because `changed` answers
+     * for the document; to detect a settings change, compare the `snapshot().reviewPane`
+     * reference, which changes only when a setting changes. Refused with `unsupported` when no review module is registered, and
+     * with `invalidArgs` for an unknown field or value. A refusal changes nothing.
+     *
+     * @example
+     * ```ts
+     * const result = editor.setReviewPaneOptions({ opening: 'manual', overflow: 'shrinkPage' });
+     * if (!result.ok) console.warn(result.reason);
+     * ```
+     */
+    setReviewPaneOptions(options: ReviewPaneOptions): ExecResult;
+    /**
+     * Mount into `el`. If the instance holds pending document bytes (created without a
+     * container, or previously detached), they mount now — under the shaped measurer when
+     * fonts have resolved in the meantime. Attaching while already mounted elsewhere moves
+     * the live content via `session.save()`.
+     *
+     * HONEST COSTS: a mount from bytes is a fresh session — the undo stack and the caret do
+     * not survive re-attach (the same cost as the async font remount). After `destroy()`
+     * this is a no-op that emits a typed `error` event: a destroyed instance never remounts.
+     */
+    attach(el: HTMLElement): void;
+    /**
+     * Tear down the painted surface, stashing the CURRENT document bytes
+     * (`session.save()`) so a later `attach` restores the content — but not the undo stack
+     * or the caret. No-op when already detached or destroyed.
+     */
+    detach(): void;
+}
+
+/** Which of the eight resize handles a drag started from, by compass direction. */
+type ImageResizeHandle = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw';
+/** EMUs per point. DrawingML stores extents in EMU; layout works in points. */
+declare const EMU_PER_POINT = 12700;
+/** Points to EMU, rounded — EMUs are integral in the file. */
+declare function pointsToEmu(points: number): number;
+/** EMU to points. Unrounded, so overlay geometry keeps sub-point precision during a drag. */
+declare function emuToOverlayPoints(emu: number): number;
+/**
+ * The extent a resize drag produces, in EMU.
+ *
+ * Computed from the drag's START extent rather than the previous frame's, so a drag that reverses
+ * direction lands exactly where it began instead of accumulating rounding error.
+ *
+ * `preserveAspect` behaves the way Word's handles do: a corner handle scales by whichever axis
+ * moved further, while an edge handle drives the other axis from the original ratio. Both axes
+ * are floored at one point, so a drag past the opposite edge cannot invert the image.
+ */
+declare function computeResizedImageExtentEmu(startWidthEmu: number, startHeightEmu: number, handle: ImageResizeHandle, deltaWidthPt: number, deltaHeightPt: number, preserveAspect: boolean): {
+    readonly cx: number;
+    readonly cy: number;
+};
+/**
+ * The position a move drag produces, preserving the anchoring the file already used.
+ *
+ * A `frame`-mode position keeps its `relativeToH`/`relativeToV` bases and only shifts the offsets
+ * it actually had — writing an offset the file omitted would re-anchor the drawing to a different
+ * reference and move it somewhere the drag never pointed.
+ */
+declare function computeMovedImagePosition(start: DrawingPositionInput, deltaXPt: number, deltaYPt: number): DrawingPositionInput;
+
+type ImageMutationPreconditions = Readonly<{
+    mountGeneration: number;
+    packageRevision: number;
+    drawingNodeId: string | null;
+    selectionParagraphId: string;
+    selectionOffset: number;
+}>;
+/**
+ * The selected image and what may be done to it, or null when nothing image-like is selected.
+ *
+ * Unsupported placeholders, hidden drawings, and select-locked drawings cannot be selected.
+ */
+declare function selectedImageStateOf(surface: PaginatedSurface | null): SelectedImageState | null;
+/**
+ * Snapshot the state an image mutation was planned against: mount generation, package revision,
+ * and the selection anchor.
+ *
+ * Taken at the START of a drag so the commit can be checked against it with
+ * {@link isStaleImageInteractionCommit}. A pointer gesture spans many frames, and a document that
+ * moved underneath it must not have the gesture's final coordinates applied to it.
+ */
+declare function captureImageMutationPreconditions(editor: Pick<DocxEditorInstance, 'surface' | 'mountGeneration'>): ImageMutationPreconditions | null;
+/**
+ * Whether an insert or replace would be accepted — the `can` half of the can-before-exec pair.
+ *
+ * Refuses in suggesting mode, since an image property edit has no tracked-change representation.
+ */
+declare function canExecuteImageCommand(command: Extract<EditorCommand, {
+    type: 'insertImage' | 'replaceImage';
+}>, surface: PaginatedSurface | null): CanResult;
+/**
+ * Run an insert or replace, re-checking the same gates {@link canExecuteImageCommand} applies.
+ *
+ * Async because image bytes must be decoded to derive their natural extent before the drawing can
+ * be projected — the one editor command that cannot complete synchronously.
+ */
+declare function executeImageCommand(editor: DocxEditorInstance, command: Extract<EditorCommand, {
+    type: 'insertImage' | 'replaceImage';
+}>): Promise<ExecResult>;
+/** How far one arrow-key press nudges a selected image, in points. */
+declare const IMAGE_OVERLAY_NUDGE_PT = 1;
+/** How far Shift+arrow nudges a selected image, in points. */
+declare const IMAGE_OVERLAY_NUDGE_SHIFT_PT = 10;
+/**
+ * One in-flight image drag: where it started, and everything needed to decide at commit time
+ * whether the document still describes what the gesture was planned against.
+ *
+ * Both revisions are captured because they move independently — layout can re-flow without the
+ * package changing, and vice versa.
+ */
+interface ImageInteractionSession {
+    readonly drawingNodeId: string;
+    readonly startBounds: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly startWidthEmu: number;
+    readonly startHeightEmu: number;
+    readonly startPosition: DrawingPositionInput | null;
+    readonly anchorFrameOrigin: {
+        readonly x: number;
+        readonly y: number;
+    } | null;
+    readonly transform: DrawingTransform;
+    readonly mode: 'move' | 'resize';
+    readonly handle: ImageResizeHandle | null;
+    readonly preconditions: ImageMutationPreconditions;
+    readonly layoutRevision: number;
+    readonly packageRevision: number;
+    readonly kind: 'inline' | 'anchored';
+}
+/**
+ * How an image drag scrolls the page when it reaches the viewport edge.
+ *
+ * Returns the delta ACTUALLY applied rather than the one requested, because a drag at the end of
+ * the document cannot scroll further and the overlay must not move the image by a distance the
+ * page did not travel.
+ */
+interface ImageOverlayScrollPort {
+    /** Scroll by a preview delta and return the actual applied document-space delta in points. */
+    scrollBy(deltaY: number): number;
+}
+/**
+ * The painted geometry of the selected drawing, plus what the overlay is allowed to do to it.
+ *
+ * Carries BOTH the painted rect (points, for hit-testing and handle placement) and the stored
+ * extent (EMU, for writing back), so the overlay never has to convert between the two spaces to
+ * decide what it is looking at.
+ */
+interface SelectedDrawingOverlayTarget {
+    /** Keep the text area available for pointer editing through the frame. */
+    readonly textbox?: boolean;
+    readonly id: string;
+    readonly pageIndex: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly kind: 'inline' | 'anchored';
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly position: DrawingPositionInput | null;
+    readonly anchorFrameOrigin: {
+        readonly x: number;
+        readonly y: number;
+    } | null;
+    readonly transform: DrawingTransform;
+    readonly canResize: boolean;
+    readonly canMove: boolean;
+    /** Hard lock from `noChangeAspect` — never overridden by Shift. */
+    readonly aspectLocked: boolean;
+}
+/**
+ * The painted geometry of the selected drawing, for the resize/move overlay — or null.
+ *
+ * Stricter than {@link selectedImageStateOf}: it also requires a COLLAPSED selection, because a
+ * range that merely contains a drawing is a text selection, and drawing handles over it would
+ * claim an object the user did not single out.
+ */
+declare function selectedDrawingOverlayTargetOf(surface: PaginatedSurface | null): SelectedDrawingOverlayTarget | null;
+/**
+ * Whether a drag's commit should be refused because the document moved under it — the refusal to
+ * return, or null when the commit is still valid.
+ *
+ * Checks the mount generation and both revisions captured by
+ * {@link captureImageMutationPreconditions}. A gesture spans many frames, so this is the one
+ * place that decides its coordinates still describe the document they were measured against.
+ */
+declare function isStaleImageInteractionCommit(editor: Pick<DocxEditorInstance, 'surface' | 'mountGeneration'>, session: ImageInteractionSession): ExecResult | null;
+
+/** Points → CSS pixels at the given zoom (matches `mountPaginatedSurface` / semantic paint). */
+declare function surfacePaintScale(zoom: number): number;
+/** Layout points to CSS pixels. Pair with {@link surfacePaintScale} for the current zoom. */
+declare function layoutPointsToCssPixels(points: number, paintScale: number): number;
+/** CSS pixels back to layout points — what a pointer event's coordinates must go through. */
+declare function cssPixelsToLayoutPoints(pixels: number, paintScale: number): number;
+/**
+ * What an overlay needs to place itself over the painted pages: the zoom scale, and where each
+ * page sits horizontally.
+ *
+ * Per-page X offsets rather than one origin, because pages are centred independently and a
+ * narrower page in a mixed-size document does not start where its neighbours do.
+ */
+interface SurfaceOverlayCoordinates {
+    readonly paintScale: number;
+    readonly pageOffsetX: ReadonlyMap<number, number>;
+}
+/** A rectangle in one page's content frame, in layout points. */
+interface OverlayFrameRect {
+    readonly pageIndex: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Page-content frame → sheet-space CSS pixels (matches `paintSelectionOverlay`). */
+declare function overlayFrameToSheetCssPixels(layout: SemanticLayout, frame: OverlayFrameRect, coordinates: SurfaceOverlayCoordinates): {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+};
+/**
+ * Where the painted surface's box begins inside overlay chrome's containing block, in CSS pixels.
+ *
+ * {@link overlayFrameToSheetCssPixels} produces coordinates relative to the surface element —
+ * the box the pages paint into — but overlay chrome portals OUTSIDE that element, and its
+ * absolutely positioned pieces resolve against the nearest positioned ancestor. The surface
+ * centres itself inside that ancestor with a stylesheet margin, so a frame placed without this
+ * origin lands at the far left of the viewport, one full centring margin off the image it rings.
+ * `offsetLeft`/`offsetTop` measure against the same positioned ancestor the chrome resolves
+ * against — every element between the two is static — which is what makes the two spaces agree.
+ */
+declare function overlayHostOrigin(surfaceElement: HTMLElement | null): {
+    readonly left: number;
+    readonly top: number;
+};
+/** Whether this handle drag should preserve aspect ratio. */
+declare function resizePreservesAspect(handle: ImageResizeHandle, aspectLocked: boolean, shiftKey: boolean, textbox?: boolean): boolean;
+/**
+ * Where an anchored drawing's positioning frame begins, in layout points.
+ *
+ * An anchored drawing's offsets are relative to a base the file names (page, margin, column, …),
+ * so a move drag needs that base's origin to turn a pointer delta into a stored offset.
+ */
+interface AnchorFrameOrigin {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * One resize frame: the extent to store, and the box to draw while the pointer is still down.
+ *
+ * Both, because they are different spaces — the extent is EMU for the file, the preview is
+ * points for the overlay — and computing them separately would let the handle drift from the
+ * rectangle it is dragging.
+ */
+interface ImageResizeResult {
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly previewBounds: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly position: DrawingPositionInput | null;
+}
+/**
+ * Resolve one resize frame from the pointer's current position.
+ *
+ * Handles rotation and flips by mapping the SCREEN-space handle back to the drawing's local axes
+ * first: dragging the visually-right handle of a 90°-rotated image must change its stored height,
+ * and a flipped image's handles move in the opposite direction from where they appear.
+ */
+declare function computeImageResizeResult(options: {
+    readonly handle: ImageResizeHandle;
+    readonly startWidthEmu: number;
+    readonly startHeightEmu: number;
+    readonly startBounds: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly startPosition: DrawingPositionInput | null;
+    readonly anchorFrameOrigin?: AnchorFrameOrigin | null;
+    readonly deltaXPt: number;
+    readonly deltaYPt: number;
+    readonly transform: DrawingTransform;
+    readonly preserveAspect: boolean;
+    readonly kind: 'inline' | 'anchored';
+}): ImageResizeResult;
+/**
+ * An {@link ImageOverlayScrollPort} over a real scroll container.
+ *
+ * Reports the delta the element ACTUALLY scrolled, converted back to points — at the end of the
+ * document that is less than asked for, and the overlay must not move the image further than the
+ * page travelled.
+ */
+declare function createImageOverlayScrollPort(scroller: HTMLElement, paintScale: number): {
+    scrollBy(deltaYPoints: number): number;
+};
+/**
+ * The committed result of a whole drag, recomputed from the release coordinates.
+ *
+ * Recomputed rather than accumulated from the per-frame previews, so rounding applied once per
+ * frame cannot add up into a final extent that differs from where the pointer actually stopped.
+ */
+interface FinalizedImageOverlayInteraction extends ImageResizeResult {
+    readonly position: DrawingPositionInput | null;
+}
+/** Recompute the committed overlay result from release pointer coordinates. */
+declare function finalizeImageOverlayInteraction(options: {
+    readonly session: ImageInteractionSession;
+    readonly deltaXPt: number;
+    readonly deltaYPt: number;
+    readonly accumulatedScrollPt: number;
+    readonly aspectLocked: boolean;
+    readonly shiftKey: boolean;
+    readonly textbox?: boolean;
+    readonly anchorFrameOrigin: AnchorFrameOrigin | null;
+}): FinalizedImageOverlayInteraction;
+
+/**
+ * How a section-addressed op should name the section a caret is in.
+ *
+ * `w:sectPr` lives on the body story, so the op can only name BODY content — and a caret in a
+ * header or a note is not body content. The three answers are genuinely different, and
+ * collapsing them to "a paragraph or `null`" is what let an unaddressable section quietly
+ * become a document-wide write.
+ */
+type SectionAnchor = 
+/** Name this body paragraph. Its section is the one the caret is in. */
+{
+    readonly kind: 'anchor';
+    readonly paragraphId: string;
+}
+/** One section: an anchor names nothing extra, so the op may omit it. */
+ | {
+    readonly kind: 'whole-document';
+}
+/**
+ * Several sections, and the caret's holds no paragraph to name.
+ *
+ * An omitted anchor here would write EVERY section, which is what `scope: 'document'` is
+ * for — so answering it to a `scope: 'section'` request changes sections nobody asked
+ * about. There is no anchor that reaches an empty final section: one exists only when every
+ * paragraph already closes an earlier section, so nothing sits at or after it.
+ */
+ | {
+    readonly kind: 'unaddressable';
+};
+
+/**
+ * What a host may set on a surface image insert.
+ *
+ * The decode port and the collaboration actor are the SURFACE's to supply. An actor a host
+ * could pass would be a second identity for the same mint, which is the thing actor-scoped
+ * allocation exists to prevent.
+ */
+type SurfaceInsertImageInput = Omit<InsertImageInput, 'decodePort' | 'actorId'>;
+
+/**
+ * Every field of the Paragraph dialog, in the units the rest of this contract uses:
+ * points for spacing, TWIPS for indents.
+ *
+ * An omitted field is left as authored. Where `null` is allowed it REMOVES the setting,
+ * which is not the same as writing a zero — a zero blocks the cascade, a removal lets the
+ * style through again.
+ */
+interface SurfaceParagraphFormat {
+    readonly alignment?: 'left' | 'center' | 'right' | 'both';
+    /** Base direction; see `directionalParagraphEntry` for what each value writes. */
+    readonly direction?: 'ltr' | 'rtl';
+    readonly spaceBeforePt?: number | null;
+    readonly spaceAfterPt?: number | null;
+    readonly lineSpacing?: {
+        readonly rule: 'multiple' | 'exact' | 'atLeast';
+        readonly value: number;
+    } | null;
+    readonly indentLeftTwips?: number | null;
+    readonly indentRightTwips?: number | null;
+    /** ONE signed first-line offset: negative is a hanging indent (§17.3.1.12). */
+    readonly indentFirstLineTwips?: number | null;
+    readonly contextualSpacing?: boolean;
+    readonly keepNext?: boolean;
+    readonly keepLines?: boolean;
+    readonly widowControl?: boolean;
+    readonly pageBreakBefore?: boolean;
+    /**
+     * Replace the paragraph's custom tab stops. An empty list CLEARS them, which is what Word's
+     * "Clear All" does; omit the field to leave them as authored.
+     */
+    readonly tabStops?: readonly ParagraphTabStop[];
+}
+/** One property in a batched paragraph write. */
+interface ParagraphPropertyEdit {
+    readonly localName: string;
+    /** A null-valued attribute REMOVES that attribute; see `setParagraphProperty`. */
+    readonly attributes?: Record<string, string | null>;
+    /** Keep the attributes this entry does not name, for multi-setting elements. */
+    readonly mergeAttributes?: boolean;
+    /**
+     * For `w:jc` only: `attributes.val` names a PHYSICAL edge, as a toolbar button does. The
+     * writer converts it per paragraph, because a bidi paragraph reaches its right margin
+     * with `left` (see `jcValueForAlignment`).
+     */
+    readonly physicalAlignment?: boolean;
+    /**
+     * For `w:bidi` only: the base direction the paragraph must END in. The writer spells it per
+     * paragraph and skips one already in that direction (see `directionalParagraphEntry`).
+     */
+    readonly paragraphDirection?: 'ltr' | 'rtl';
+    /** Drop the paragraph's own element of this name instead of writing one. */
+    readonly remove?: boolean;
+}
+
+/**
+ * Which review write is being committed through `commitReviewOps`.
+ *
+ * The callback that performs the write is opaque, so a lane deciding whether to allow it cannot
+ * tell an Accept from a comment delete. That mattered once a replica was attached: these paths
+ * reach the store directly rather than through `applyTreeOps`, and the ones that graft a package
+ * and swap the shell record no primitive effects — they replicate as NOTHING, leaving the peer a
+ * `commentReference` naming a comment it never received. Naming the write lets each be admitted
+ * only once a two-replica test proves it arrives whole.
+ */
+type ReviewWriteIntent = 'revision-resolve' | 'revision-attribution' | 'comment-add' | 'comment-reply' | 'comment-resolve' | 'comment-delete' | 'package-scoped';
+
+/**
+ * Everything an overlay needs to paint over one rendered frame of the surface.
+ *
+ * `pages` is the materialized page set (absent when every page is built), and `scale` and
+ * `pageOffsetX` are the values the page painter used, so overlay geometry lands on the text.
+ */
+interface SurfaceOverlayFrame {
+    readonly layer: HTMLElement;
+    readonly layout: SemanticLayout;
+    readonly revision: number;
+    readonly scale: number;
+    readonly pages?: ReadonlySet<number>;
+    readonly pageOffsetX?: ReadonlyMap<number, number>;
+    readonly measurer?: TextMeasurer;
+}
+/** A painter the surface calls after every render, and on request. */
+type SurfaceOverlayPainter = (frame: SurfaceOverlayFrame) => void;
+
+/**
+ * Content-control interaction lane on the paginated surface.
+ *
+ * Chrome toggles are surface state; value / remove commit through tree ops.
+ */
+interface ContentControlOps {
+    /** Toggle show-all boundary chrome. No layout reflow. */
+    setShowAll(show: boolean): void;
+    /** Toggle form-fill Tab navigation mode. */
+    setFormFill(active: boolean): void;
+    /** Whether show-all chrome is on. */
+    showAll(): boolean;
+    /** Whether form-fill navigation is on. */
+    formFill(): boolean;
+    /** Innermost control at the caret from layout boundary records. */
+    atCaret(): ContentControlBoundaryRecord | null;
+    /**
+     * Move to the next or previous editable control (tabIndex, then document order).
+     *
+     * Skips content-locked and bound controls. Selects the control's content for replacement.
+     * Returns whether navigation landed somewhere.
+     */
+    navigate(direction: 'next' | 'previous'): boolean;
+    /**
+     * Set a control's value through `setContentControlValue`. Honours lock / bound refusals.
+     * Returns whether the op committed.
+     */
+    setValue(controlId: string, value: string): boolean;
+    /**
+     * Unwrap a control keeping its content (`removeContentControl`). Defaults to the control
+     * at the caret. Returns whether the op committed.
+     */
+    remove(controlId?: string): boolean;
+    /**
+     * Engine reason a widget or remove action is disabled, or null when allowed.
+     *
+     * `edit` covers content / value changes; `remove` covers unwrap.
+     */
+    disabledReason(controlId: string, action: 'edit' | 'remove'): string | null;
+}
+/**
+ * Content-control chrome the surface owns, not the document.
+ *
+ * Boundary furniture visibility and form-fill navigation are surface chrome, not model
+ * bytes — toggling them never reflows layout records.
+ */
+interface ContentControlSurfaceState {
+    /** Show boundary chrome for every control. */
+    readonly showAll: boolean;
+    /** Tab / Shift+Tab navigate between editable controls. */
+    readonly formFill: boolean;
+    /** Innermost control containing the caret, or null. */
+    readonly activeControlId: string | null;
+}
+
+/**
+ * What one paint did.
+ *
+ * Four answers rather than a boolean, because the two FAILURES are different problems with
+ * different words for the user: `'nothingToPaint'` says the selection holds nothing the
+ * capture can reach, and `'refused'` says the document would not take the write — a locked
+ * content control, a collaboration gate, a document open for viewing. Collapsed to false,
+ * a refused paint told the reader to select some text.
+ *
+ * `'armed'` is the collapsed-caret outcome: no text to paint, so the character half went to
+ * the stored-marks lane and the next characters typed will carry it.
+ */
+type FormatPainterPaintResult = 'painted' | 'armed' | 'nothingToPaint' | 'refused';
+/** Word's Format Painter over the surface. */
+interface FormatPainterOps {
+    state(): FormatPainterSurfaceState;
+    /**
+     * Capture the formatting at the selection. False when the selection resolves to no span
+     * the layout has published yet — there is nothing to read.
+     */
+    capture(): boolean;
+    /** Paint the captured formatting over the current selection. */
+    apply(): FormatPainterPaintResult;
+    /**
+     * One press of the painter control, with Word's meaning.
+     *
+     * A press while the painter is off captures and arms it for a single application. A press
+     * that lands within the double-press window locks it on. A press while it is armed and
+     * outside that window turns it off.
+     *
+     * The double-press window is the ENGINE's, deliberately: the alternative is each adapter
+     * binding its own `dblclick` beside its own `click`, which is two hosts deciding
+     * separately what a double-click means and drifting the moment one of them changes.
+     *
+     * False when there was nothing at the selection to capture, so a control can report a
+     * refusal rather than looking as though it armed.
+     */
+    press(): boolean;
+    /** Turn the painter off, keeping the capture. `Esc` and a finished single application. */
+    disarm(): void;
+}
+
+/**
+ * Where the last pass spent its time, and how much work it actually did.
+ *
+ * The durations are the surface's own three phases — layout, paint, selection sync — timed
+ * separately because they fail separately: a full relayout, a full repaint and a forced
+ * reflow each have a different fix. The counters come free from machinery that already
+ * exists: the layout session says how much was re-placed versus reused, and the scheduler
+ * says how often work was thrown away as stale. `placed` equal to `total` on every
+ * keystroke is the one-glance sign that incremental layout is not engaging.
+ */
+interface PaginatedSurfacePerf {
+    /** Time the last layout pass took, in milliseconds. */
+    readonly layoutMs: number;
+    /** Time the last paint took — building and swapping the page DOM. */
+    readonly paintMs: number;
+    /** Time the last selection sync took — writing the model selection into the browser. */
+    readonly selectionMs: number;
+    /** Paragraphs the last pass re-placed, against the number in the document. */
+    readonly placed: number;
+    readonly total: number;
+    /** Pages carried over from the previous layout without being rebuilt. */
+    readonly reusedPages: number;
+    /** Passes that could not resume and laid the document out from the top. */
+    readonly fullPasses: number;
+    /** Layouts discarded because the model had already moved on. */
+    readonly staleDiscards: number;
+    /** Cooperative runs abandoned mid-flight for a newer revision. */
+    readonly cancelledRuns: number;
+}
+
+/**
+ * One live remote-caret label the engine positioned. The host owns its content; the engine
+ * still owns the label's geometry, class, and presence colour, and rebuilds the labels
+ * wholesale on every repaint that moves them.
+ *
+ * @public
+ */
+interface RemoteCaretLabelAnchor {
+    readonly element: HTMLElement;
+    readonly selection: CollaborationRemoteSelection;
+}
+/**
+ * A host that renders its own content inside the engine's remote-caret labels.
+ *
+ * @public
+ */
+interface RemoteCaretLabelHost {
+    /**
+     * Called after every paint that rebuilt the labels, with the current anchors.
+     *
+     * A skipped paint (nothing moved) does not re-publish: the host keeps its last anchors
+     * until the next publish, and elements from a previous publish are dead after the next
+     * one. An empty array is a real publish — every remote caret left the screen.
+     *
+     * Never mutate editor state synchronously from `publish` — a mutation repaints, and the
+     * nested rebuild's publish would arrive before this one returned; only set host state.
+     */
+    publish(anchors: readonly RemoteCaretLabelAnchor[]): void;
+}
+
+/**
+ * How a paginated surface opens. Every field is optional.
+ *
+ * `measurer` is the injection seam that keeps layout DOM-free — supply one to lay a document out
+ * on a server, or leave it off in a browser to get the canvas measurer.
+ */
+interface PaginatedSurfaceOptions {
+    /** UI labels for shared form controls; omitted keys fall back to English. */
+    readonly translate?: (key: string, params?: Record<string, string | number>) => string;
+    /** Regional conventions for new date input; defaults to en-US. */
+    readonly locale?: string;
+    /**
+     * The collaboration module's replica for this surface's session. Absent,
+     * the surface does not attach, and local store history remains the undo
+     * authority.
+     */
+    readonly collaborationModel?: CollaborationModuleContribution;
+    /**
+     * How saved field results are edited. `atomic` (the default) keeps every field one unit.
+     * `editable` lets the reader type, delete, and select inside the saved result of a DATE,
+     * MERGEFIELD, HYPERLINK, or similar field. Results must be unnested; simple fields inside
+     * complex field results are not supported. Refused with a {@link collaborationModel}.
+     */
+    readonly fieldResults?: FieldResultsMode;
+    readonly measurer?: TextMeasurer;
+    /** Ambient author for tracked edits. Required before suggesting can write anything. */
+    readonly author?: string;
+    /** Opening mode; changeable at runtime with `setEditingMode`. */
+    readonly editingMode?: SurfaceEditingMode;
+    /**
+     * Identifies the measurer for cache invalidation.
+     *
+     * Fonts resolve asynchronously, so a host that swaps its measurer must change this or the
+     * cached pre-font layout is served for the rest of the session.
+     */
+    readonly producer?: string;
+    /**
+     * Maps a document-declared font family to the alias its registered bytes live under, so
+     * painted runs can use embedded glyphs without the file's family name entering the
+     * page-global CSS font namespace.
+     */
+    readonly fontAlias?: (family: string) => string | undefined;
+    /** Points to CSS pixels. */
+    readonly scale?: number;
+    /**
+     * How revisions project into layout and paint. Omitted keeps the layout default
+     * (`all-markup`). The editor facade passes `proposed` when no review module is
+     * registered — the free tier's final-state rendering; the machinery below this
+     * option is shared either way.
+     */
+    readonly revisionDisplayMode?: ReviewDisplayMode;
+    /** Authors whose changes open in their accepted view-time projection. */
+    readonly hiddenRevisionAuthors?: readonly string[];
+    /**
+     * When a field's result wears Word's grey shading. Omitted keeps Word's own default,
+     * `when-selected`.
+     *
+     * Applies to ORDINARY fields only. Legacy form fields follow the document's
+     * `w:doNotShadeFormData`, because a form's blanks are the document's own statement about
+     * itself rather than a reader's preference.
+     *
+     * A paint-level option, not a layout one: it changes no geometry, so switching it repaints
+     * without remeasuring a single line.
+     */
+    readonly fieldShading?: FieldShadingMode;
+    /** Show paragraph-end furniture without changing document content. */
+    readonly showParagraphMarks?: boolean;
+    readonly onToggleParagraphMarks?: () => void;
+    /**
+     * How tracked changes are coloured: by AUTHOR (the default), by kind, or by author with
+     * host-pinned colours. A paint-level option like {@link fieldShading}: it changes no
+     * geometry, so switching it repaints without remeasuring a line. Applies wherever
+     * revision markup paints, whatever the {@link revisionDisplayMode} leaves visible.
+     */
+    readonly revisionStyles?: RevisionStyles;
+    readonly revisionMarkup?: ResolvedRevisionMarkup;
+    /**
+     * The review module's derivation hooks for this surface's session. Absent,
+     * `session.reviewItems()` is the typed empty queue and every review affordance
+     * built on it stays inert.
+     */
+    readonly reviewModel?: ReviewModuleContribution;
+    /**
+     * The family a run with no authored font is reported as by `formatting()` AND painted
+     * in — the face the measurer falls back to. Absent, such a run reports
+     * `fontFamily: null` and paints in whatever font the page inherits, which the measurer
+     * did not measure: visible glyphs drift from wrap points and caret geometry.
+     */
+    readonly defaultFontFamily?: string;
+    /**
+     * Who resolves a pointer to a caret.
+     *
+     * `'engine'` (the default) answers from the layout records, which is what makes a click in
+     * a margin, an indent or a cell's padding land where it was aimed. `'native'` binds no
+     * pointer handlers and leaves the browser's own caret placement in charge.
+     */
+    readonly pointer?: 'engine' | 'native';
+    readonly onChange?: (state: PaginatedSurfaceState) => void;
+    /**
+     * A plain click on an external (or inert) hyperlink, for a host to open its popover with.
+     *
+     * Absent means such a click does nothing. That is deliberate: a host with no popover
+     * mounted must not have clicks silently opening tabs, and the popover is the only path to
+     * activation (see the navigation module's single `window.open` gate).
+     */
+    readonly onHyperlinkPopover?: (activation: HyperlinkActivation) => void;
+    readonly onEquationPopover?: (activation: EquationActivation) => void;
+    /**
+     * Ctrl/Cmd+K — Word's Insert Hyperlink. The engine reports the request; the host's chrome
+     * decides what a link dialog looks like. A host that passes nothing leaves the key alone
+     * rather than doing something surprising with it.
+     */
+    readonly onRequestHyperlink?: () => void;
+    /** Return true when host chrome handles this session. */
+    readonly onRequestTextFormField?: (session: TextFormFieldDialogSession) => boolean;
+    readonly onRequestContentControlWidget?: (session: ContentControlWidgetSession) => boolean;
+    readonly onRequestInvalidTextFormField?: (session: InvalidTextFormFieldSession) => boolean;
+    /**
+     * Localized accessible names for core-owned table insertion furniture.
+     * Defaults to English from `@docx-editor.dev/i18n` when omitted.
+     */
+    readonly tableInteractionLabel?: (key: 'table.insertRowBelow' | 'table.insertColumnRight') => string;
+    /** Localized drawing refusal labels; defaults to English when omitted. */
+    readonly drawingStrings?: DrawingPaintStrings;
+    /** Override raster decode for package image intents; defaults to browser/headless. */
+    readonly imageDecodePort?: ImageDecodePort;
+    /**
+     * Localized name for a generated TOC, written as the control's `w:alias` on insert.
+     *
+     * The update ACTIONS are not here: they are rows in the host's context menu, which owns
+     * its own labels. The engine paints no menu of its own.
+     */
+    readonly tocLabels?: {
+        readonly title: string;
+    };
+}
+
+/**
+ * What the selection is currently formatted as.
+ *
+ * A value is present only when EVERY span in the selection agrees on it: a selection running
+ * from 11pt into 14pt has no font size, and a toolbar should show a blank rather than pick
+ * one of the two and imply the whole selection is that.
+ */
+interface SurfaceFormatting {
+    readonly bold: boolean;
+    readonly italic: boolean;
+    readonly underline: boolean;
+    readonly strikethrough: boolean;
+    readonly superscript: boolean;
+    readonly subscript: boolean;
+    readonly fontFamily: string | null;
+    /** Half-points, the unit OOXML stores and the picker expects. */
+    readonly fontSizeHalfPoints: number | null;
+    readonly color: string | null;
+    readonly highlight: string | null;
+    readonly alignment: 'left' | 'center' | 'right' | 'both' | null;
+    /** Paragraph base direction through the cascade; null when the selection mixes them. */
+    readonly direction: 'ltr' | 'rtl' | null;
+    readonly styleId: string | null;
+    /**
+     * `w:spacing`'s line rule and its value: LINES for `multiple`, points for the other two
+     * (`w:line` is 240ths of a line under `auto` and twentieths of a point otherwise).
+     * Null when the selection's paragraphs disagree, or state no line spacing at all.
+     */
+    readonly lineSpacing: {
+        readonly rule: 'multiple' | 'exact' | 'atLeast';
+        readonly value: number;
+    } | null;
+    /** `w:spacing/@w:before` and `@w:after` in points, null when the selection disagrees. */
+    readonly spaceBeforePt: number | null;
+    readonly spaceAfterPt: number | null;
+    /**
+     * Effective indent at the selection, in twips, or null with no selection or inside a
+     * table.
+     *
+     * The one field here that does NOT go null on disagreement: the values are the FIRST
+     * touched paragraph's and `mixed` reports the disagreement per field, because a ruler
+     * must draw its handles somewhere and Word draws them at the first selected paragraph.
+     */
+    readonly indent: IndentFormatting | null;
+    /**
+     * The paragraph flags the Paragraph dialog shows as checkboxes, or null when the
+     * selection's paragraphs disagree about that one.
+     *
+     * `contextualSpacing` is "Don't add space between paragraphs of the same style"; the
+     * other four are its Pagination block. Each is read from the cascade, so a flag a STYLE
+     * sets reads as on — which is what a checkbox has to show.
+     */
+    readonly paragraphFlags: ParagraphFlags;
+    /**
+     * The paragraph's resolved custom tab stops, cascade included, or null when the selection
+     * disagrees or nothing is loaded. Positions in TWIPS, like every other measurement a
+     * control writes back.
+     */
+    readonly tabStops: readonly ParagraphTabStop[] | null;
+    /**
+     * Which of the paragraph-level reads above are `null` because the selection DISAGREES,
+     * as opposed to because nothing states them. See {@link ParagraphDisagreements}.
+     */
+    readonly disagrees: ParagraphDisagreements;
+}
+/** How a reveal places its target in the viewport. */
+interface RevealOptions {
+    /**
+     * `'start'` puts the target near the top (a heading the user jumped to), `'center'`
+     * centres it, `'nearest'` scrolls only when it is out of view — and only far enough to
+     * clear the edge, which parks the target flush against it. `'centerIfNeeded'` is the one
+     * a jump-to-next-thing control wants: silent while the target is already on screen, and
+     * centred when it has to move, so the reader lands looking AT the thing rather than at
+     * the bottom line of the window. Default `'start'`.
+     */
+    readonly block?: ScrollPlacement;
+    /** Padding above the target, in CSS pixels. Default 24. */
+    readonly offsetPx?: number;
+    readonly behavior?: ScrollBehavior;
+}
+/**
+ * How the current selection came to address a drawing — see
+ * {@link PaginatedSurface.drawingSelectionIntent}.
+ */
+type DrawingSelectionIntent = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'pointer';
+    readonly drawingNodeId: string;
+} | {
+    readonly kind: 'programmatic';
+};
+/**
+ * Everything observable about the surface right now, as one immutable value.
+ *
+ * `revision` is the change token: it moves whenever anything else here does, which is what lets
+ * `snapshot()` hand back the same reference until state actually changes.
+ */
+interface PaginatedSurfaceState {
+    readonly revision: number;
+    readonly pageCount: number;
+    readonly selection: SemanticSelection;
+    /**
+     * The rectangle of table cells a drag across cells selected, or null.
+     *
+     * `selection` always holds the equivalent TEXT range, so a reader that does not care about
+     * rectangles needs no branch. This is for the ones that do — the highlight, and table
+     * commands that act on cells rather than characters.
+     */
+    readonly cellSelection: CellSelection | null;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    /**
+     * Lifecycle of the attached replica, or `'inactive'` when no collaboration
+     * module is registered on this surface.
+     */
+    readonly collaborationStatus: CollaborationStatus | 'inactive';
+    readonly lastRejection: string | null;
+    /**
+     * The typing format armed at the caret (Word's stored marks), or null.
+     *
+     * NOT document state — nothing is written until the next characters are typed — but it
+     * IS observable state: `formatting()` reports it, so a host that reflects the toolbar
+     * has to learn when it moves. Reference-stable while unchanged, so a host can compare
+     * it to decide whether to re-derive. See `toggleRunProperty` for the lane itself.
+     */
+    readonly pendingFormat: readonly {
+        readonly localName: string;
+    }[] | null;
+    /**
+     * Content-control chrome and form-fill mode.
+     *
+     * Surface-owned (not document bytes). Updates report through the same `onChange` path as
+     * selection moves — hosts must not maintain a parallel channel.
+     */
+    readonly contentControls: ContentControlSurfaceState;
+    /**
+     * The TOC the last right-click landed on, or null.
+     *
+     * A right-click deliberately does not move the caret, and a TOC refuses the caret
+     * entirely, so `selection` can never say which table of contents the user is pointing at.
+     * This is how a host's context menu learns it. Surface chrome, not document state.
+     */
+    readonly contextTocId: string | null;
+    /**
+     * Format painter arming, and the level of what it holds.
+     *
+     * Surface chrome, not document bytes — the lane `contentControls` above sits in, reported
+     * through the same `onChange` so a toolbar's pressed state has exactly one source.
+     */
+    readonly formatPainter: FormatPainterSurfaceState;
+    /** Timing and reuse counters for the last pass. Diagnostics, not document state. */
+    readonly perf: PaginatedSurfacePerf;
+}
+
+/**
+ * How an edit is written.
+ *
+ * `'suggest'` is the one that changes what the ops MEAN: the same keystroke becomes a `w:ins`
+ * and the same Backspace becomes a `w:del` over the words it would have removed. `'view'`
+ * refuses edits outright.
+ */
+type SurfaceEditingMode = 'edit' | 'suggest' | 'view';
+
+/**
+ * Where the section after an inserted break begins — Word's Layout > Breaks menu.
+ *
+ * `evenPage` / `oddPage` sections from a file paginate with their blank parity sheet, but
+ * inserting one is not offered here.
+ *
+ * @public
+ */
+type SectionBreakInsertType = 'nextPage' | 'continuous';
+/**
+ * The mounted, painted, editable document — the layer `createDocxEditor` builds its contract on.
+ *
+ * The painted pages ARE the editable surface: they are `contenteditable`, but the DOM is a
+ * picture. Browser mutations are prevented and re-expressed as tree ops, and selection maps only
+ * through `data-paragraph-id`/`data-start`, never through DOM node identity.
+ *
+ * Every write goes through the guarded mutation path on this object. Reaching past it into
+ * `session` to apply ops directly bypasses the layout invalidation and the caret bookkeeping.
+ */
+interface PaginatedSurface {
+    readonly session: TreeDocxSessionView;
+    /** The collaboration replica a `collaborationModule` attached, or null. */
+    collaborationSession(): EditorCollaborationSession | null;
+    storyScope(): StoryScope;
+    imageDecodePort(): ImageDecodePort;
+    applyDrawingOps(ops: readonly DrawingTreeDocOp[]): TreeApplyResult;
+    applyImageProperties(input: ApplyImagePropertiesInput): ImageIntentResult;
+    deleteImage(drawingNodeId: string): ImageIntentResult;
+    insertImage(input: SurfaceInsertImageInput): Promise<ImageIntentResult>;
+    replaceImage(drawingNodeId: string, bytes: Uint8Array, mime: SupportedImageMime, options: {
+        readonly expectedPackageRevision: number;
+        readonly commitGuard?: () => boolean;
+    }): Promise<ImageIntentResult>;
+    layout(): SemanticLayout;
+    state(): PaginatedSurfaceState;
+    /** One-based page at the caret, or at the centre of the mounted viewport. */
+    currentPage(mode?: 'viewport' | 'caret'): number;
+    type(text: string): void;
+    /** Author one explicit tracked text change without changing the editing mode. */
+    proposeTextChange(kind: 'insertion' | 'deletion' | 'replacement', text: string, author?: string): boolean;
+    /**
+     * Queue plain typed text for a batched commit at the caret.
+     *
+     * The DOM input lane's entry: a burst of keystrokes appends here and lands through ONE
+     * `type()` call — one transaction, one undo step, one layout flush — when the queue drains.
+     * Every surface mutation, selection or scope move, geometry read, composition start and
+     * teardown flushes first. Code reading `session` directly sits BELOW the buffer and must
+     * call {@link flushPendingInput}, as save/detach do. `type()` stays synchronous.
+     */
+    enqueueType(text: string): void;
+    /**
+     * Land any queued typed text now, as its own transaction, AND publish any layout pass a
+     * commit deferred under input pressure — so the caller reads current text and current
+     * geometry at one seam. Both halves are no-ops when nothing is pending, which is the
+     * common case: an isolated commit lays out synchronously in its own tail, and deferral
+     * only happens when the browser reports queued input behind an expensive pass.
+     */
+    flushPendingInput(): void;
+    /**
+     * Insert text whose newlines are PARAGRAPH BOUNDARIES, in one commit.
+     *
+     * `type` writes its argument into run text verbatim, so a newline reaching it is a
+     * control character the store refuses — which vetoes the whole transaction and makes
+     * the insert do nothing at all. This is the lane for text that arrives from outside the
+     * editor (a paste, a drop), where line breaks are structure rather than characters.
+     *
+     * Plain text only, by construction: no markup is parsed and no DOM is built from the
+     * payload, whatever its origin.
+     */
+    insertPlainText(text: string): void;
+    deleteBackward(): void;
+    /** Delete forward — the Delete key, and `deleteContentForward` from an IME. */
+    deleteForward(): void;
+    /** Delete to the previous word boundary — Alt/Ctrl+Backspace. */
+    deleteWordBackward(): void;
+    /** Delete to the next word boundary — Alt/Ctrl+Delete. */
+    deleteWordForward(): void;
+    splitParagraph(): void;
+    /** A tab character as a `w:tab` element, not a literal tab in the run text. */
+    insertTab(): void;
+    /** A `w:br` — Shift+Enter, a line break inside the same paragraph. */
+    insertLineBreak(): void;
+    /** A `w:br w:type="page"` — Ctrl+Enter, a hard page break inside the paragraph. */
+    insertPageBreak(): void;
+    /**
+     * Word's Increase/Decrease Indent, over every paragraph the selection touches.
+     *
+     * A NUMBERED or BULLETED paragraph changes LEVEL: `w:numPr/w:ilvl` moves by one, which
+     * re-resolves its marker from `numbering.xml` — so a bullet becomes a hollow circle, a
+     * `1.` becomes an `a.`, exactly as Word demotes a list item. A level the definition
+     * does not declare is DECLARED on the way, with Word's default format for that depth
+     * (its stock bullets and number formats cycle every three levels) — a definition that
+     * stops at `ilvl 0` never blocks the press. Everything else moves its `w:ind/@left` by
+     * one default tab stop, never past the margin.
+     *
+     * Answers whether anything changed, so a caller can fall back (Tab inserting a tab
+     * where there is no list to demote).
+     */
+    adjustIndent(direction: 'increase' | 'decrease'): boolean;
+    /**
+     * Tab (`increase`) or Shift+Tab (`decrease`) over a selection outside a list: change the
+     * indent and keep the text.
+     *
+     * A selection over two or more paragraphs, or a cell rectangle, steps the left indent of
+     * each paragraph. A selection in one paragraph that starts at the paragraph start, whole or
+     * partial, works on the first line: Tab sets a first-line indent of one default tab stop
+     * (`w:defaultTabStop`), or steps the left indent when the first line already has that
+     * indent or more, or a hanging indent. Shift+Tab clears a first-line indent that the
+     * paragraph states itself, so a style value applies again, and otherwise steps the left
+     * indent back. A paragraph the selection reaches only at its start is not touched by this
+     * rule, unless it is the empty last paragraph of the story.
+     *
+     * Answers true when the selection takes this rule, also when the write is refused or
+     * changes nothing, so the text is never replaced. Answers false for a caret and for a
+     * selection in one paragraph that starts inside the text; there Tab types a tab character
+     * and Shift+Tab steps the left indent.
+     */
+    indentWithTab(direction: 'increase' | 'decrease'): boolean;
+    /**
+     * Set indent to exact values on every paragraph the selection touches — what a ruler
+     * drag and an indent spinner both need, where {@link adjustIndent} only steps.
+     *
+     * Twips. Omitting a field leaves it as authored; `null` CLEARS it, so the paragraph
+     * falls back to its style — distinct from zero, which blocks the cascade.
+     *
+     * `firstLine` is ONE SIGNED offset, negative for a hanging indent; the two OOXML
+     * spellings are written for it, the unused one as an explicit zero. Answers whether
+     * anything was committed.
+     */
+    setIndent(update: {
+        readonly left?: number | null;
+        readonly right?: number | null;
+        readonly firstLine?: number | null;
+    }): boolean;
+    /**
+     * Whether Increase/Decrease Indent would do anything right now.
+     *
+     * A list item at level 0 cannot outdent and one at level 8 cannot indent — `w:ilvl`
+     * has nine levels and Word greys the control out at the ends. A missing level
+     * DEFINITION never disables it: `adjustIndent` declares the level as it goes. The one
+     * residue: a `w:numStyleLink` definition missing the level refuses the declaration
+     * (its levels belong to the linked style), so there the press is a safe no-op rather
+     * than a greyed control.
+     */
+    canAdjustIndent(direction: 'increase' | 'decrease'): boolean;
+    /**
+     * Enter on an empty list item: outdent a level, or leave the list at level 0.
+     *
+     * Answers false when the caret is not on an empty list item, so the caller falls
+     * through to an ordinary paragraph split.
+     */
+    exitListOnEmptyItem(): boolean;
+    /** Whether the paragraph at the caret is a list item, for Tab's Word-like fallback. */
+    isListParagraph(): boolean;
+    /**
+     * Word's Bullets and Numbering buttons.
+     *
+     * Turns every paragraph the selection touches into a list of `kind`, or takes them all
+     * out when they are already one. The definition is created in `numbering.xml` on first
+     * use — a document that has never carried a list has no numbering part at all.
+     */
+    toggleList(kind: 'bullet' | 'ordered'): boolean;
+    /** Whether every paragraph the selection touches is already a list of `kind`. */
+    isListActive(kind: 'bullet' | 'ordered'): boolean;
+    /** Select the whole document. */
+    selectAll(): void;
+    /**
+     * Turn the browser's editing affordance on the pages layer on or off.
+     *
+     * The facade's `mode` gates COMMANDS, which stops `exec` but not the keyboard: the pages
+     * layer is `contentEditable` and binds `beforeinput` itself, so a document the facade
+     * called read-only still accepted typing straight into it. Read-only has to reach the
+     * surface to be true.
+     */
+    setEditable(editable: boolean): void;
+    /**
+     * Scroll a page, or the page a paragraph sits on, into view. Returns whether it
+     * scrolled — false when the target is not laid out, or the surface is not inside a
+     * scroll container, so a caller can tell "no such target" from "done".
+     *
+     * The geometry comes from the LAYOUT, never from the DOM: a page that has not been
+     * materialized yet has no element to measure, and that is exactly the page a reveal is
+     * usually asked for. `revealParagraph` scrolls to the paragraph's own line rather than
+     * the top of its page, so a heading deep in a page lands in view.
+     */
+    revealPage(pageIndex: number, options?: RevealOptions): boolean;
+    revealParagraph(paragraphId: string, options?: RevealOptions): boolean;
+    /**
+     * Scroll an exact position into view — `revealParagraph` for a caret that is not at
+     * offset 0. Focus-independent and virtualization-safe like every reveal: geometry
+     * comes from the layout and the target page is materialized on the way. Defaults to
+     * `block: 'nearest'`, so an already-visible target never yanks the viewport.
+     */
+    revealPosition(position: SemanticPosition, options?: RevealOptions): boolean;
+    /** Set the selection directly, for a host driving the surface programmatically. */
+    setSelection(next: SemanticSelection): void;
+    /**
+     * Select one painted drawing at its host paragraph, as a pointer press would.
+     *
+     * False when the layout paints no such drawing on that paragraph, in which case nothing
+     * moves: the caller decides what to do rather than being left mid-way.
+     */
+    selectDrawing(drawingNodeId: string, hostParagraphId: string): boolean;
+    /**
+     * Select a rectangle of table cells, or clear one with null.
+     *
+     * The equivalent text range is installed alongside it, so `state().selection` stays valid
+     * for every reader that does not know rectangles exist.
+     */
+    setCellSelection(next: CellSelection | null): void;
+    /**
+     * Toggle a run property over the selection, e.g. `b`, `i`, `u`.
+     *
+     * AT A COLLAPSED CARET this ARMS the property instead of writing it — Word's stored
+     * marks. Nothing reaches the document until the next characters are typed there, and
+     * those take the armed format; the armed state shows in `formatting()` and in
+     * `state().pendingFormat` immediately, so a toolbar reflects the press. It survives the
+     * caret-preserving edits (Backspace, Delete, Enter) and IME composition, and is
+     * discarded when the caret moves elsewhere or the document is undone. A property the
+     * store cannot author is refused at arm time rather than left to poison the keystroke.
+     */
+    toggleRunProperty(localName: string, attributes?: Record<string, string>): void;
+    /**
+     * SET a run property over the selection, rather than toggling it.
+     *
+     * Font family, size and colour are values, not switches: picking Arial twice must leave
+     * the text in Arial, which a toggle would not. Arms at a collapsed caret on the same
+     * terms as `toggleRunProperty`.
+     */
+    setRunProperty(localName: string, attributes?: Record<string, string>): void;
+    /**
+     * Set a property on every paragraph the selection touches — alignment, style, spacing.
+     *
+     * `mergeAttributes` keeps the attributes the call does not name, for the properties that
+     * carry several independent settings in one element: `w:spacing` holds the line rule and
+     * the space before and after, so a line-spacing pick must not delete the space-before. A
+     * null-valued attribute removes just that one.
+     */
+    setParagraphProperty(localName: string, attributes?: Record<string, string | null>, options?: Pick<ParagraphPropertyEdit, 'mergeAttributes' | 'physicalAlignment' | 'paragraphDirection'>): void;
+    /**
+     * Several paragraph properties in ONE transaction, so a dialog is one undo step.
+     *
+     * `setParagraphProperty` is this with a single entry. A dialog that fired one call per
+     * field would leave the user pressing Ctrl+Z five times to undo one OK, and would paint
+     * four intermediate layouts on the way.
+     */
+    setParagraphProperties(entries: readonly ParagraphPropertyEdit[]): void;
+    /**
+     * The Paragraph dialog as ONE write: alignment, indents, spacing, line spacing and the
+     * five paragraph flags, over every paragraph the selection touches.
+     *
+     * One transaction, so pressing OK is one undo step and the page repaints once. An omitted
+     * field is left as authored; `null` where the type allows it REMOVES the setting so the
+     * style supplies it again. Returns whether anything was written.
+     */
+    setParagraphFormat(update: SurfaceParagraphFormat): boolean;
+    /**
+     * Word's Clear All Formatting: direct run properties off the selected text, and every
+     * paragraph the selection touches back to the default style with its direct paragraph
+     * properties and mark dropped.
+     *
+     * Only what the document states DIRECTLY — formatting inherited from a style survives, so
+     * the text falls back to its style rather than to nothing. Properties an op cannot name
+     * (`w:rStyle`, `w:lang`, `w:sectPr`, `w:pBdr`) are preserved for the same reason every
+     * other write preserves them.
+     */
+    clearFormatting(): void;
+    /**
+     * Formatting as it stands at the selection, for a toolbar to reflect.
+     *
+     * With a typing format armed at the caret this reports what the NEXT characters typed
+     * will look like, not what the document holds — which is the answer a toolbar wants and
+     * the one Word gives.
+     */
+    formatting(): SurfaceFormatting;
+    /**
+     * The section the document declares: page size, margins, columns, orientation.
+     *
+     * What a ruler is made of, and what pagination is measured against.
+     */
+    sectionProperties(): SectionProperties;
+    /**
+     * The section GOVERNING one paragraph — what a ruler or dialog reflects when the caret sits
+     * in a multi-section document.
+     *
+     * Body content answers for itself, whatever story is open. A header or footer belongs to the
+     * section that names its relationship, and a note to the section holding its reference mark.
+     * An id nothing settles falls back to the FIRST section: the tail is the document-wide answer
+     * and is wrong for everything not on the last page.
+     */
+    sectionPropertiesAt(paragraphId: string): SectionProperties;
+    /**
+     * How a section-addressed op should name the section `paragraphId` is in.
+     *
+     * `w:sectPr` lives on the body story, so such an op can only name body content — and a caret
+     * in a header or a note is not body content. Passing that caret straight through made every
+     * section write from furniture fail `unknown-paragraph`.
+     */
+    sectionAnchorParagraphAt(paragraphId: string): SectionAnchor;
+    /**
+     * Write section page-setup fields — size, orientation, margins — as ONE undoable
+     * transaction. Twips throughout; omitted fields are left as authored. With
+     * `anchorParagraphId` only that paragraph's governing section is written (Word's
+     * "Apply to: This section"); without it, every section. Returns whether the write
+     * committed (a hostile value is refused by the op layer).
+     */
+    setSectionProperties(update: {
+        readonly pageWidthTwips?: number;
+        readonly pageHeightTwips?: number;
+        readonly orientation?: 'portrait' | 'landscape';
+        readonly marginTopTwips?: number;
+        readonly marginRightTwips?: number;
+        readonly marginBottomTwips?: number;
+        readonly marginLeftTwips?: number;
+        readonly anchorParagraphId?: string;
+    }): boolean;
+    /**
+     * Insert a section break at the caret: the paragraph splits, and the head ends a new
+     * section cloning the governing section's page setup — Word's Layout > Breaks. One
+     * undoable step. Returns whether the break committed.
+     *
+     * `breakType` says where the section AFTER the break begins: `'nextPage'` (the default,
+     * Word's Next Page) starts a new sheet, `'continuous'` keeps it on the sheet the
+     * previous section ended, which is how a mid-page column or margin change is authored.
+     */
+    insertSectionBreak(breakType?: SectionBreakInsertType): boolean;
+    /**
+     * Why {@link insertSectionBreak} would refuse this kind right now, or `null`.
+     *
+     * THE authority for the BREAK's own questions, so `Editor.can` and the write cannot answer
+     * those differently. Both halves are things only the surface knows: the LIVE editing mode
+     * (a document that declares `w:trackRevisions` opens suggesting without anyone passing a
+     * mode, and Review > Track Changes moves it again afterwards), and the paragraph the break
+     * would actually land in — which for a range in suggesting mode is past the struck words,
+     * not the selection's head.
+     *
+     * NOT the deletion's questions. A break replaces the selection first, and that deletion can
+     * cross content a control holds or a region protected some other way; only the store sees
+     * that, and it sees it at write time. So a range whose landing is fine while its deletion
+     * is not answers `null` here and refuses at the press — as every other replacing command in
+     * the engine does, less loudly. Story scope is gated separately again, because a caret in a
+     * header refuses every break kind for a different reason.
+     */
+    sectionBreakRefusal(breakType?: SectionBreakInsertType): string | null;
+    /** The layout session, so a host or a test can see how much work a pass actually did. */
+    layoutSession(): {
+        readonly stats: {
+            readonly placed: number;
+            readonly total: number;
+            readonly reusedPages: number;
+        };
+    };
+    /**
+     * The hyperlink lane: what link the caret is in, and the insert / retarget / unlink verbs.
+     *
+     * Every verb is one `transact`, so it is one undo step. Targets going IN are host-supplied
+     * and pass the package's own URL allowlist; targets coming OUT are the sanitized
+     * projection, so a caller cannot accidentally hand a refused scheme to a sink.
+     */
+    readonly hyperlinks: HyperlinkOps;
+    readonly equations: EquationOps;
+    /**
+     * Content-control chrome, form-fill navigation, and value / remove verbs.
+     *
+     * Value and remove commit through `session.applyTreeOps` — the same write path as typing.
+     * Show-all and form-fill are surface chrome and never reflow layout.
+     */
+    readonly contentControls: ContentControlOps;
+    /** Word's Format Painter: capture, apply, and the transient armed mode. */
+    readonly formatPainter: FormatPainterOps;
+    /** Whether a `rows`×`cols` table can be inserted at the caret. */
+    canInsertTable(rows: number, cols: number): boolean;
+    /**
+     * Insert an empty `rows`×`cols` table at the caret, columns evenly dividing the content
+     * width of the caret's section, and leave the caret in the first cell.
+     */
+    insertTable(rows: number, cols: number): boolean;
+    /** Whether the addressed (or caret-local) body TOC can be refreshed. */
+    canRefreshToc(tocId?: string): boolean;
+    /** Whether a generated body TOC can be inserted before the caret paragraph. */
+    canInsertToc(): boolean;
+    /** Insert and populate a generated body TOC before the caret paragraph. */
+    insertToc(): boolean;
+    /** Refresh cached TOC entries and/or page numbers through the two-pass layout pipeline. */
+    canEditTextFormField(): boolean;
+    editTextFormField(): boolean;
+    refreshToc(tocId?: string, mode?: 'entire' | 'pageNumbers'): boolean;
+    /**
+     * Rewrite stale REF field results in the body, footnote and endnote stories so a save
+     * exports what the pages paint. Fresh results commit nothing (no transaction, no revision
+     * bump, no undo entry); a rewrite is ONE transaction and ONE undo unit across every stale
+     * part. Viewing, a non-editable session, and a collaborative session write nothing — the
+     * collaboration gate cannot journal the rewrite, so those saves export cached results and
+     * the call returns false.
+     */
+    refreshRefFieldResults(): boolean;
+    /**
+     * Commit pending form input, refresh REF results, and serialize the document.
+     * Throws an error with code `invalidArgs` for invalid form values, or `invalidState`
+     * during an active edit. Retry after the edit finishes. A destroyed surface throws
+     * with code `destroyed`. Does not change focus.
+     */
+    save(): Uint8Array;
+    /** Whether a body paragraph belongs to a detected TOC boundary or cached result. */
+    isInsideToc(paragraphId: string): boolean;
+    /**
+     * Bookmark jumps and the ONE external-activation gate. A host's popover "open" action
+     * calls `openExternal`; nothing else in the engine may call `window.open`.
+     */
+    readonly navigation: SurfaceNavigation;
+    /**
+     * Pin the current selection so it stays VISIBLY selected while focus is elsewhere.
+     *
+     * A document has one selection: the moment a panel focuses an input of its own the browser
+     * takes the highlight off the text, which is when the user most needs to see what the panel
+     * is about to act on. This draws the range on the engine's own overlay instead, so it
+     * survives the focus move. The MODEL selection is untouched — the op the panel finally runs
+     * addresses the same characters it always would.
+     *
+     * The pin releases itself when the caret leaves the range (either edge counts as inside),
+     * which is what lets a host close its panel on "the user clicked somewhere else" without
+     * every adapter reimplementing that comparison.
+     */
+    retainSelection(): SelectionPin;
+    /** Drop one owned pin. Another owner's pin remains visible. */
+    releaseSelection(pin: SelectionPin): void;
+    /** The pinned range, or null once it was released or escaped. */
+    retainedSelection(): SemanticSelection | null;
+    /**
+     * How edits are written right now.
+     *
+     * Lives on the SURFACE, not on the store. The store's write vocabulary stays explicit —
+     * an op says whether it is tracked — and the surface is the one thing that knows a
+     * keystroke happened, so it is the right place to decide what that keystroke becomes.
+     */
+    editingMode(): SurfaceEditingMode;
+    setEditingMode(mode: SurfaceEditingMode): void;
+    /** Set the ambient author after buffered text commits under the previous author. */
+    setAuthor(author: string | undefined): void;
+    /** The ambient author tracked edits and review writes record, or undefined. */
+    author(): string | undefined;
+    /** Replace localized drawing labels and repaint materialized pages. */
+    setDrawingStrings(strings: DrawingPaintStrings): void;
+    /** Update shared form-control labels without replacing open dialogs. */
+    setTranslate(translate: PaginatedSurfaceOptions['translate']): void;
+    /** Set regional conventions for subsequent date input without reformatting stored values. */
+    setLocale(locale: string | undefined): void;
+    /** Replace the localized title used by later TOC insertions. */
+    setTocLabels(labels: NonNullable<PaginatedSurfaceOptions['tocLabels']>): void;
+    /**
+     * Every author with a revision in the CURRENT layout, mapped to Word's colour slot by
+     * order of first appearance. One map instance per layout, so a caller can key caches on
+     * its identity.
+     */
+    revisionAuthors(): ReadonlyMap<string, number>;
+    /** Reviewers currently projected as accepted, without changing the document. */
+    hiddenRevisionAuthors(): ReadonlySet<string>;
+    /** Show one reviewer's markup, or render that reviewer's changes as accepted. */
+    setRevisionAuthorVisible(author: string, visible: boolean): void;
+    /** Show or hide every reviewer in one layout pass. */
+    setAllRevisionAuthorsVisible(visible: boolean): void;
+    /** Clear the reviewer filter in one layout pass. */
+    showAllRevisionAuthors(): void;
+    /** Apply a view-time predicate over complete tracked-change items. */
+    setTrackedChangesFilter(predicate: TrackedChangePredicate | null, mode?: TrackedChangeFilterMode): void;
+    /** The presence colour the caret paints for `name`, sanitized as the paint sink is. */
+    remotePresenceColor(name: string): string | undefined;
+    /**
+     * Replace how tracked changes are coloured, live. Paint-level: the pages repaint without
+     * remeasuring a line, and the caret, selection and undo history stay where they are.
+     */
+    setRevisionMarkup(settings: ResolvedRevisionMarkup): void;
+    setRevisionStyles(colors: RevisionStyles | undefined): void;
+    /** Toggle paragraph-end furniture without layout or document changes. */
+    setShowParagraphMarks(show: boolean): void;
+    /**
+     * Hand remote-caret label content to the host, or take it back with `null`.
+     *
+     * With a host set, the engine still creates and positions each label (same class, same
+     * presence colour) but leaves it empty, marks it `data-docx-remote-actor`, and calls
+     * {@link RemoteCaretLabelHost.publish} after every paint that rebuilt the labels.
+     * Registration and unregistration repaint immediately, so the first publish fires
+     * without waiting for awareness to move and unregistering restores the default
+     * collaborator-name labels.
+     */
+    setRemoteCaretLabelHost(host: RemoteCaretLabelHost | null): void;
+    /**
+     * Install the painter for host text highlights, or remove it with `null`. The surface calls
+     * it after every render and once on installation, with the frame it just painted.
+     */
+    setHighlightPainter(painter: SurfaceOverlayPainter | null): void;
+    /** Call the installed highlight painter against the current frame. */
+    repaintHighlights(): void;
+    /**
+     * Commit ops that came from automation, through the gate a keystroke goes through.
+     *
+     * The narrow entry an automation host writes with, and the reason it needs one: reaching
+     * `session.applyTreeOps` past this skips the editing-mode gate entirely — a document open for
+     * viewing accepts a scripted edit, and a suggesting document records one as a permanent
+     * change with no proposal and no author. Here, viewing refuses, suggesting attributes, the
+     * refusal reason is reported like any other, and the pages repaint from the commit.
+     *
+     * The ops address the story the CALLER named, whatever story the reader is in: the caller
+     * identified its target before calling, so following the caret into a header would write
+     * somewhere else entirely. They default to the body rather than to the reader's story.
+     *
+     * They arrive as a BUILDER, given a way to mint the relationship an external hyperlink names.
+     * That mint changes the package outside the transaction and outside the undo stack, so it must not
+     * happen until the mode has allowed the write — a link minted while the batch was still being
+     * planned left its target in a read-only document's `.rels`. A builder answering null means the
+     * target is one this engine will not author, and the write is refused having changed nothing.
+     */
+    applyAutomationOps(staged: (relate: (url: string) => string | null) => readonly TreeDocOp[] | null, scope?: StoryScope, packageEdits?: readonly ((pkg: OoxmlPackage) => OoxmlPackage)[], requiresReview?: boolean): TreeApplyResult;
+    /**
+     * Which revision halves this surface is SHOWING.
+     *
+     * Read by the automation adapter so the object model's formatting reaches the same runs the
+     * toolbar does. A range's offsets cover every revision half whatever the view does with
+     * them, so with markup on, a selection over a struck word means one thing to a reader and
+     * would mean another to a script that assumed the resolved result.
+     */
+    revisionDisplayMode(): ReviewDisplayMode;
+    /** Change the review display without accepting, rejecting, or changing author filters. */
+    setRevisionDisplayMode(mode: ReviewDisplayMode): void;
+    /**
+     * Where a replacement for `[start, end)` of a paragraph lands, or null when the edit would
+     * not be tracked.
+     *
+     * Non-null exactly when suggesting: the struck words stay, so the replacement goes past
+     * them, minus whatever of the range was this author's own pending insertion, which leaves.
+     * The SAME rule every replacing lane of the keyboard reads, exposed so the automation object
+     * model aims a scripted `Replace` where typing does and can answer the span it wrote.
+     */
+    replacementLanding(paragraphId: string, start: number, end: number): number | null;
+    /**
+     * Commit review ops — accept, reject, a new comment — through the SAME path a keystroke
+     * takes: layout, paint, and a caret clamped to what the document now holds.
+     *
+     * `intent` names WHICH review write this is, so a lane that judges them can tell them apart.
+     * The callback is opaque, and a replica admits only the writes proven to replicate — see
+     * {@link ReviewWriteIntent}.
+     *
+     * Applying them straight to the session skipped all three. Rejecting an insertion left the
+     * pages painting text the tree no longer had, every card anchored where it used to be, and
+     * the caret past the end of the paragraph — after which every keystroke was refused with
+     * `offset-out-of-range` until the user happened to click somewhere else.
+     */
+    commitReviewOps(run: () => {
+        readonly committed: boolean;
+        readonly reason?: unknown;
+    }, intent?: ReviewWriteIntent): void;
+    /**
+     * The layout as last PUBLISHED, without forcing pending work.
+     *
+     * `layout()` flushes first, which is right for a caller that is about to act on geometry
+     * and wrong for one that merely decorates it. The review rail read through `layout()` and
+     * so forced a synchronous full pass on every keystroke — eleven seconds per read on a
+     * 2432-block document. A card whose anchor is one frame stale is invisible; the paint that
+     * follows the flush republishes it.
+     */
+    publishedLayout(): SemanticLayout;
+    /**
+     * How the current selection came to address a drawing, if it does at all.
+     *
+     * Word's rule: a caret NEXT TO a floating object is a text caret, never an object selection —
+     * only clicking the object (or a host selection write) selects it. The engine's selection is a
+     * caret at the anchor offset either way, so offsets cannot tell them apart; this is the
+     * discriminator. `none` for a fresh mount (the initial caret routinely coincides with a drawing
+     * anchored at offset zero) and after typing, caret keys, or a press on a non-drawing. `pointer`
+     * names the drawing the press landed on, so a stale press cannot claim a later one.
+     */
+    drawingSelectionIntent(): DrawingSelectionIntent;
+    /**
+     * Paint-scale coordinate context for overlay chrome.
+     *
+     * Internal seam — not part of the public editor contract. Image overlay uses the same
+     * `zoom * 96/72` scale and per-page horizontal offsets the painter applied.
+     */
+    overlayCoordinates(): SurfaceOverlayCoordinates;
+    /**
+     * The comment, tracked change or carded custom node the caret is in, as the painted bands
+     * report it. A custom node without `reviewCard` is never the answer: it has no card.
+     *
+     * ONE source for "which item is open". The band under the text and the card beside it are
+     * two views of the same answer, and deriving it twice let them disagree — the card closed
+     * while the text stayed highlighted.
+     */
+    activeReviewKey(): string | null;
+    /**
+     * Open THIS item, named by key, for as long as `selection` stays the live one.
+     *
+     * Without it the caret is the only evidence of which card is open, and a caret cannot name a
+     * card when two cards cover exactly the same characters: `w:ins` wrapping `w:del` — content
+     * one reviewer added and another struck — gives the insertion and the deletion one identical
+     * range, and every click on either card classified back to whichever the queue happened to
+     * list first. The reader clicked "Deleted" and watched "Added" light up.
+     *
+     * A key, not a position, because the position is precisely what is ambiguous. It holds only
+     * while the selection matches; a pointer or keyboard move hands the answer back to the caret,
+     * which is what lets the reader step out of a card by clicking away from it.
+     *
+     * `selection` is what activation wants installed, and it is installed HERE rather than by a
+     * `setSelection` of the caller's own so that the pin is up before anything is published. The
+     * other order repainted the bands and reported state while the caret was still the only
+     * evidence, so a host saw the wrong twin active for one frame and then a correction. Omit it
+     * to pin against the live selection, which is what a header or note scope has already set.
+     */
+    activateReview(key: string, selection?: SemanticSelection, options?: {
+        readonly allowExcluded?: boolean;
+    }): void;
+    /**
+     * The key {@link activateReview} pinned, or null once its selection is no longer live.
+     *
+     * Exists so nothing outside the surface keeps its own copy of "the selection came from
+     * opening a card". `selectionPlacement` needs that fact to stay quiet about offering a
+     * comment on text the reader only selected by opening a card over it, and the copy it used to
+     * keep was set on one of activation's three branches, so a header card offered to comment on
+     * itself.
+     */
+    activatedReviewKey(): string | null;
+    /**
+     * Close the open item until the caret next moves.
+     *
+     * What a click on the canvas means. The caret does not move when someone clicks the grey
+     * around the page, so nothing else would ever put the item away.
+     */
+    dismissActiveReview(): void;
+    /**
+     * Revision kinds the CARET must not activate, or null for none.
+     *
+     * The review rail filters what it renders (structural and format cards are hidden by
+     * default), but {@link activeReviewKey} used to compute over the unfiltered queue — a
+     * click on tracked text under a format change activated a card the rail does not draw,
+     * and nothing on screen lit up. A host that filters its list tells the surface, so the
+     * band and the visible cards stay one answer.
+     */
+    setReviewActivationExclusions(kinds: readonly ReviewRevisionKind[] | null, options?: {
+        readonly formattingKinds?: readonly string[];
+    }): void;
+    /**
+     * `bookmarkName -> position` over the current revision, for resolving an internal link.
+     * First in document order wins a duplicate name, matching Word.
+     */
+    bookmarks(): BookmarkIndex;
+    /** The selected text, for copy and cut. */
+    selectedText(): string;
+    /**
+     * Every clipboard flavour for the current selection: plain text, and the interop HTML
+     * carrying the embedded fragment when the selection is a body-story range. A cell
+     * rectangle answers grid text plus a flattened table; `html` is null where only plain
+     * text should be written. Unsupported object selections return a refusal reason.
+     */
+    copyFlavours(): {
+        readonly text: string;
+        readonly html: string | null;
+        readonly reason?: 'unsupported-content';
+    };
+    /**
+     * Route one paste payload by fidelity: embedded fragment, then external HTML, then
+     * plain text. Unsupported object fragments refuse without fallback. Other decode, read,
+     * or apply failures can degrade. Suggesting mode, non-body
+     * stories and an armed force-plain all land on the plain lane. False when the payload
+     * landed on no lane at all (nothing to insert).
+     */
+    pasteRich(text: string, html: string | null): boolean;
+    /** The next paste routes plain, whatever its payload carries (Cmd+Shift+V). */
+    armForcePlainPaste(): void;
+    /** Remove the selection, if any. Returns whether anything was deleted. */
+    deleteSelection(): boolean;
+    navigate(command: NavigationCommand, extend?: boolean): void;
+    /** Reverse the last history entry and put the caret back where it was made. */
+    undo(): void;
+    redo(): void;
+    /**
+     * Refresh table insertion furniture labels without remounting or relayout.
+     *
+     * @public
+     */
+    refreshTableInteractionLabels(): void;
+    focus(): void;
+    /**
+     * Refresh table insertion furniture labels without remounting the surface.
+     *
+     * @public
+     */
+    setTableInteractionLabel(resolver: (key: 'table.insertRowBelow' | 'table.insertColumnRight') => string): void;
+    destroy(): void;
+    /**
+     * The section a painted page belongs to, and the page that section starts on.
+     *
+     * Published because opening a furniture story without a page opens it without a section, and
+     * the section is what the ruler clamps to and what a new table's grid is divided from. One
+     * header part can serve several sections, so only the page settles which one the reader is
+     * looking at.
+     */
+    sectionAtPage(pageIndex: number): {
+        sectionIndex: number;
+        sectionStart: number;
+    };
+    /** Active editing view — body, or an open header/footer story by rId. */
+    activeScope(): ViewScope;
+    /** Activate a view scope. Returns false when a header/footer rId cannot be opened. */
+    setActiveScope(scope: ViewScope): boolean;
+    /**
+     * Open a header/footer story for editing on the painted surface.
+     * Refuses dangling / unknown relationship ids.
+     */
+    enterHeaderFooter(args: {
+        readonly rId: string;
+        readonly pageIndex?: number;
+        readonly sectionIndex?: number;
+        readonly kind?: 'header' | 'footer';
+        readonly variant?: 'default' | 'first' | 'even';
+        readonly position?: SemanticPosition;
+    }): boolean;
+    /** Leave furniture editing and restore the prior body selection. */
+    exitHeaderFooter(): void;
+    /** Chrome read-model for the open furniture scope, or null when editing the body. */
+    headerFooterState(): {
+        readonly editing: 'header' | 'footer' | null;
+        readonly sectionIndex: number;
+        readonly variant?: 'default' | 'first' | 'even';
+        readonly rId?: string;
+        readonly partName?: string;
+        readonly inherited?: boolean;
+        readonly titlePage?: boolean;
+        readonly evenAndOddHeaders?: boolean;
+        readonly headerDistanceTwips?: number;
+        readonly footerDistanceTwips?: number;
+    } | null;
+    /**
+     * Commit one package-level furniture lifecycle op (create/delete/link/unlink/options).
+     * Flushes layout so the next enter/rebind sees the new resolution.
+     */
+    applyHeaderFooterLifecycle(op: {
+        readonly op: 'createHeaderFooter' | 'deleteHeaderFooter' | 'linkToPrevious' | 'unlinkFromPrevious' | 'setSectionFurnitureOptions' | 'setDocumentProtection';
+        readonly sectionIndex?: number;
+        /** `setDocumentProtection` only: enforce filling-in-forms protection, or lift it. */
+        readonly enforce?: boolean;
+        readonly kind?: 'header' | 'footer';
+        readonly variant?: 'default' | 'first' | 'even';
+        readonly titlePage?: boolean;
+        readonly evenAndOddHeaders?: boolean;
+        readonly headerDistanceTwips?: number;
+        readonly footerDistanceTwips?: number;
+    }): {
+        readonly ok: true;
+    } | {
+        readonly ok: false;
+        readonly reason: string;
+    };
+    /** Insert an allowlisted page field at the caret in the open HF story. */
+    insertPageField(field: 'PAGE' | 'NUMPAGES' | 'SECTIONPAGES' | 'PAGE_X_OF_Y'): boolean;
+    /** Insert a footnote/endnote at the body caret. */
+    insertNote(noteKind: 'footnote' | 'endnote'): boolean;
+    deleteNote(noteKind: 'footnote' | 'endnote', noteId: number): boolean;
+    convertNote(fromKind: 'footnote' | 'endnote', noteId: number): boolean;
+    convertAllNotes(fromKind: 'footnote' | 'endnote'): boolean;
+    setNoteProperties(args: {
+        readonly scope: 'document' | 'section';
+        readonly sectionIndex?: number;
+        readonly footnote?: {
+            readonly numFmt?: string;
+            readonly numRestart?: string;
+            readonly position?: string;
+            readonly numStart?: number;
+        };
+        readonly endnote?: {
+            readonly numFmt?: string;
+            readonly numRestart?: string;
+            readonly position?: string;
+            readonly numStart?: number;
+        };
+    }): boolean;
+    enterNote(scopeId: string, position?: {
+        paragraphId: string;
+        offset: number;
+    }): boolean;
+    exitNote(): void;
+    /** Resolved/authored note properties for the caret section — chrome read-model. */
+    notePropertiesState(): NotePropertiesStateSnapshot | null;
+    /** Plain-text preview for hover chrome — never returns markup. */
+    notePreviewText(scopeId: string): string | null;
+    /** Commit one table-command plan as a single store transaction. */
+    applyTableCommandPlan(plan: TableCommandPlan): ExecResult;
+}
+/**
+ * What opening a document produced: a mounted surface, or a refusal.
+ *
+ * A result rather than a throw, because every refusal here comes from FILE input — a package the
+ * bounded reader rejected, a part that exceeded a limit — and a malformed upload should surface
+ * as a message the host can show rather than an exception it has to catch.
+ */
+type OpenPaginatedResult = {
+    readonly ok: true;
+    readonly surface: PaginatedSurface;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+    readonly detail?: string;
+};
+
+/** One URL to fetch and the face it claims to be. */
+interface FontUrlSource {
+    readonly url: string;
+    readonly family: string;
+    readonly weight: number;
+    readonly style: 'normal' | 'italic';
+    /**
+     * Expected `sha256:` content hash. When present, mismatching bytes are REFUSED —
+     * pin this for any URL not under the app's sole control.
+     */
+    readonly hash?: string;
+    readonly faceIndex?: number;
+}
+/**
+ * What to fetch, and under what limits.
+ *
+ * Only `sources` is required. Each carries its own expected hash, so bytes are trusted by
+ * CONTENT rather than by origin — a swapped asset fails admission even from a trusted host.
+ */
+interface LoadFontsRequest {
+    readonly sources: readonly FontUrlSource[];
+    /** Cache API bucket name; default `docx-editor-fonts`. */
+    readonly cacheName?: string;
+    /** Injectable for tests and CSP-constrained hosts; defaults to global `fetch`. */
+    readonly fetcher?: typeof fetch;
+    /** Per-font byte ceiling; defaults to the engine hard maximum. */
+    readonly maxFontBytes?: number;
+    /** Cancels loading with `signal.reason`, without returning per-source failures. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Why one font did not load.
+ *
+ * Distinguished rather than collapsed to "failed" because the responses differ: `networkError`
+ * and `httpError` are worth retrying, while `hashMismatch` and `malformed` mean the bytes were
+ * not what the source claimed and retrying will fetch the same wrong thing.
+ */
+type FontLoadFailureReason = 'networkError' | 'httpError' | 'hashMismatch' | 'overLimit' | 'emptyResponse'
+/** The declared face itself is unusable (empty family, out-of-range weight); nothing was fetched. */
+ | 'invalidRequest'
+/** The bytes are not a font at all — most often an HTML error page served with 200. */
+ | 'malformed';
+/**
+ * One face that did not load, with whatever evidence the failure produced.
+ *
+ * Non-fatal: {@link LoadFontsResult} still carries every source that succeeded, and the affected
+ * family falls back to the engine's fixed measurement.
+ */
+interface FontLoadFailure {
+    readonly url: string;
+    readonly request: FontFaceRequest;
+    readonly reason: FontLoadFailureReason;
+    /** HTTP status for `httpError`; hashes for `hashMismatch`. */
+    readonly status?: number;
+    readonly expectedHash?: string;
+    readonly actualHash?: string;
+    readonly diagnostic?: string;
+}
+/**
+ * What one `loadFonts` call produced: the faces that arrived, plus the ones that did not.
+ *
+ * A `FontConfigurationFragment`, so it composes straight into `composeFontConfiguration`
+ * alongside other font sources. Partial success is the normal case — compose it even with
+ * failures present.
+ */
+interface LoadFontsResult extends FontConfigurationFragment {
+    readonly sources: readonly FontSource[];
+    readonly failures: readonly FontLoadFailure[];
+}
+/**
+ * Fetch app-specified font URLs into verified, cache-backed `FontSource`s.
+ *
+ * Fetches ONLY the URLs listed — never a default host or engine-chosen CDN — and never
+ * rejects for a per-source failure: the result carries every admitted source and a
+ * typed entry for every drop. Cancellation instead rejects with `signal.reason`. Compose the result with `composeFontConfiguration`.
+ */
+declare function loadFonts(request: LoadFontsRequest): Promise<LoadFontsResult>;
+/**
+ * Turn font bytes you ALREADY hold into a `FontSource` — a file input, IndexedDB, a
+ * bundler import. `loadFonts` covers URLs; this covers everything else, so no caller has
+ * to hand-assemble the record or reach for a hashing helper.
+ *
+ * Returns a typed failure instead of throwing when the descriptor or the bytes are
+ * unusable, matching `loadFonts`: one bad face degrades itself, never its neighbours.
+ */
+declare function createFontSource(bytes: Uint8Array, request: FontFaceRequest & {
+    readonly faceIndex?: number;
+}, options?: {
+    readonly id?: string;
+    readonly maxFontBytes?: number;
+}): {
+    readonly source: FontSource;
+} | {
+    readonly failure: FontLoadFailure;
+};
+
+/** Options for loading application fonts when the editor resolves its font configuration. @public */
+interface CustomFontsOptions extends Omit<LoadFontsRequest, 'signal'> {
+    /** Reports each failed face. Defaults to a console warning. Cancellation does not call this handler. */
+    readonly onFailure?: (failure: FontLoadFailure) => void;
+}
+/** A font origin that supplies validated application font bytes on demand. @public */
+type CustomFontsResolver = MarkedFontResolver<(request: FontResolutionRequest) => Promise<LoadFontsResult>>;
+/**
+ * Supply application fonts without manual resolver wiring.
+ *
+ * Loads all listed faces when the editor resolves fonts, including families the document
+ * does not use yet. This makes company fonts available in the font picker for new documents.
+ * Faces supplied by earlier origins are skipped by family, weight, and style; family
+ * matching ignores case. URLs always come from `sources`, never from document text.
+ *
+ * Uses {@link loadFonts} for validation, optional hash checks, and browser caching.
+ * The editor registers the returned bytes under private aliases. This function does not
+ * change the document's selected fonts or register page-wide family names.
+ *
+ * Constructing the resolver does not fetch. Cancellation of the document load rejects
+ * with `signal.reason`, without warnings or `onFailure` calls. Other face failures are
+ * reported once per resolution, and successful faces remain available to the editor.
+ *
+ * ```ts
+ * const fonts = useFonts(
+ *   customFonts({ sources: companyFontFiles, onFailure: reportFontFailure }),
+ *   packagedFonts(),
+ *   googleFonts(),
+ * );
+ * ```
+ *
+ * Use {@link loadFonts} directly to load every listed face eagerly.
+ * @public
+ */
+declare function customFonts(options: CustomFontsOptions): CustomFontsResolver;
+
+/**
+ * A row that runs one chrome slot.
+ *
+ * @public
+ */
+interface ChromeMenuItemEntry {
+    readonly kind: 'item';
+    readonly slot: ChromeSlotId;
+    /**
+     * Plain-label override for this row.
+     *
+     * A slot's own `labelKey` is a TOOLTIP key, and several of them fold the shortcut into
+     * the text (`formattingBar.boldShortcut` is "Bold (Ctrl+B)"). A menu puts the shortcut
+     * in its own right-hand column, so the row needs the bare noun. Both keys already exist
+     * in the catalogue — this points at the plain one rather than minting a duplicate.
+     */
+    readonly labelKey?: string;
+    /** i18n key of the shortcut shown right-aligned on the row (`toolbar.saveShortcut`). */
+    readonly shortcutKey?: string;
+    /**
+     * The row opens a size PICKER instead of firing on click — Word's insert-table grid.
+     * The slot still owns the label, the icon and the enabled state; only the dispatch
+     * differs, and the picked size is what the host sends.
+     */
+    readonly picker?: 'tableGrid';
+}
+/**
+ * A row that opens a nested panel of rows (Insert › Break).
+ *
+ * It carries its own label and icon rather than a slot, because a submenu PARENT has no
+ * command: clicking it opens the panel. Giving it a slot would mint a public id for a
+ * control that can never be enabled, and `toolbarCommandState` would have to invent an
+ * answer about it.
+ *
+ * @public
+ */
+interface ChromeMenuSubmenuEntry {
+    readonly kind: 'submenu';
+    readonly labelKey: string;
+    readonly paths: readonly string[] | null;
+    readonly items: readonly ChromeMenuEntry[];
+}
+/** A horizontal rule between groups of rows. @public */
+interface ChromeMenuSeparatorEntry {
+    readonly kind: 'separator';
+}
+/** One row of a chrome menu. @public */
+type ChromeMenuEntry = ChromeMenuItemEntry | ChromeMenuSubmenuEntry | ChromeMenuSeparatorEntry;
+/**
+ * Every menu id, as a literal union. Stable public API; renaming one is a breaking change,
+ * exactly like a group or slot id.
+ *
+ * @public
+ */
+type ChromeMenuId = 'file' | 'format' | 'insert' | 'review' | 'help';
+/** One menu of the menu bar. @public */
+interface ChromeMenu {
+    readonly id: ChromeMenuId;
+    readonly labelKey: string;
+    readonly entries: readonly ChromeMenuEntry[];
+}
+
+/**
+ * HOW a control reaches the engine — never WHETHER it is enabled.
+ *
+ * Enabled state has exactly one source: `toolbarCommandState(editor, slot)`, which
+ * asks `Editor.can`. The registry is static data and cannot know what the engine
+ * will honour at this selection, in this document, at this moment.
+ *
+ * There used to be a fourth member, `parityOnly`, meaning "visible but permanently
+ * disabled". It was a second, static answer to the question `Editor.can` already
+ * answers, and it went stale the moment the engine wired underline, strike, the four
+ * alignments, the list commands and the four value slots: the registry still said
+ * parity-only, React ignored it and ran them, and Vue believed it and rendered twelve
+ * WORKING commands permanently disabled. A slot the engine has not wired needs no
+ * registry flag — `commandForSlot` answers null and `toolbarCommandState` disables the
+ * control with the engine's own words ("not wired to an editor command").
+ */
+type ChromeControlState = 
+/**
+ * Dispatched as one fixed engine command: enabled when
+ * `Editor.can(commandForSlot(slot))` succeeds, a click runs
+ * `runToolbarCommand(editor, slot)`. The command is resolved from the SLOT id
+ * through `commandForSlot` in toolbar-commands.ts — the one command table both
+ * adapters share. A slot with no row there is simply not wired YET, and says so
+ * through the engine rather than through this descriptor.
+ */
+{
+    readonly kind: 'command';
+}
+/**
+ * Dispatched with a PICKED value: `commandForSlotValue(slot, value)`. Enabled when
+ * the engine would honour a well-formed value right now (`toolbarCommandState`
+ * probes for exactly that), so the control needs chrome that produces a value — a
+ * font list, a size, a colour — before a click means anything.
+ *
+ * A distinct kind because 'command' cannot describe it: there is no fixed command
+ * to hand `Editor.can`, and a bare click has nothing to send.
+ */
+ | {
+    readonly kind: 'value';
+}
+/** `Editor.save()` — not a command (see `runSave`). */
+ | {
+    readonly kind: 'save';
+}
+/**
+ * `Editor.load()` — not a command either, and the exact twin of `save`: bytes cross the
+ * boundary between the host and the engine, and only the host can produce them. The
+ * control needs chrome that reads a file (a picker, a drop target) before a click means
+ * anything, so a bare click has nothing to send — the same reason `save` is not `command`.
+ *
+ * A fourth kind rather than reusing `save` because the two dispatch in opposite
+ * directions, and an adapter branching on `kind` must be able to tell them apart. Unlike
+ * the deleted `parityOnly`, this one IS named by a control (`file.open`).
+ */
+ | {
+    readonly kind: 'load';
+}
+/** Host conversion through `runChromeExport` or `runChromePrint`; not an editing command. */
+ | {
+    readonly kind: 'export';
+};
+/**
+ * The SHAPE a control renders as (task M6V.1).
+ *
+ * The legacy toolbar is not a row of uniform icon buttons: it mixes labelled dropdowns
+ * (`Normal`, `Arial`, alignment, line spacing), numeric steppers with visible values
+ * (zoom `- 100% +`, size `- 26 +`), split colour controls (a glyph over a colour swatch
+ * with its own caret), and a mode pill (`Editing`). Rendering all of them as icon
+ * buttons is the difference an owner review called out as "not visual parity" — the
+ * regions were all present and it still did not look like the product.
+ */
+/** `modePill` is deliberately absent. It was declared, never used by any control, and
+ *  rendered nothing — the editing-mode control below is a `dropdown`, which is what the
+ *  legacy product shows. A shape no descriptor names is a branch adapters must implement
+ *  and can never exercise. */
+type ChromeControlShape = 'icon' | 'stepper' | 'dropdown' | 'colorSplit';
+/**
+ * One toolbar control as the registry describes it — what it renders as, never whether it is
+ * enabled.
+ *
+ * Enabled state has exactly ONE source, `toolbarCommandState`, which asks the engine. A
+ * descriptor carrying its own disabled flag would be a second answer that goes stale the moment
+ * the engine wires the slot.
+ *
+ * @public
+ */
+interface ChromeControl<Id extends string = string> {
+    /** Stable control id, unique WITHIN its group. Public API; renames are breaking. */
+    readonly id: Id;
+    /** How it renders. Defaults to `icon`. */
+    readonly shape?: ChromeControlShape;
+    /** Displayed value for a stepper or dropdown (an i18n key, or a literal for numbers). */
+    readonly valueText?: string;
+    /** Swatch colour for a `colorSplit` control. */
+    readonly swatch?: string;
+    /** i18n key for the accessible name and tooltip. Never hardcoded English. */
+    readonly labelKey: string;
+    /** Material Symbols path data, or null for a non-icon control (a picker). */
+    readonly paths: readonly string[] | null;
+    /** For pickers: the i18n key of the placeholder value shown. */
+    readonly valueKey?: string;
+    /** `false` keeps this public slot composable but omits it from the default toolbar. */
+    readonly defaultToolbar?: false;
+    readonly state: ChromeControlState;
+}
+/**
+ * One toolbar group: the taxonomy both adapters derive their default arrangement FROM.
+ *
+ * Never hand-list controls in an adapter — a default toolbar is built by walking `CHROME_GROUPS`,
+ * so a slot added here appears in React and Vue without either being edited.
+ *
+ * @public
+ */
+interface ChromeGroup<Id extends string = string, ControlId extends string = string> {
+    /** Stable group id. Public API; renames are breaking. */
+    readonly id: Id;
+    readonly labelKey: string;
+    /**
+     * Not part of the DEFAULT toolbar arrangement. The chrome spec shows these
+     * controls only in a context the engine does not model yet (an image or table
+     * selection), or not at all (save belongs in the host's File menu, never in the
+     * bar). Their slots stay public for composition — a host can still place
+     * `image.insert` or `file.save` explicitly — but the default chrome is the
+     * registry's default bar, which ends at the editing-mode picker.
+     */
+    readonly contextual?: true;
+    readonly controls: readonly ChromeControl<ControlId>[];
+}
+/**
+ * The complete chrome, in bar order. Literal-typed (`as const`) so the slot-id
+ * vocabulary below is derived from the data and cannot drift from it.
+ *
+ * Taxonomy taste: ids are short, lowercaseCamel, and never repeat their group's name
+ * (`alignment.left`, not `alignment.alignLeft`; `font.family`, not `font.fontFamily`).
+ */
+declare const CHROME_GROUPS: readonly [{
+    readonly id: 'history';
+    readonly labelKey: 'formattingBar.groups.history';
+    readonly controls: readonly [{
+        readonly id: 'undo';
+        readonly labelKey: 'formattingBar.undoShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'redo';
+        readonly labelKey: 'formattingBar.redoShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'zoom';
+    readonly labelKey: 'formattingBar.groups.zoom';
+    readonly controls: readonly [{
+        readonly id: 'level';
+        readonly shape: 'stepper';
+        readonly valueText: '100%';
+        readonly labelKey: 'formattingBar.groups.zoom';
+        readonly paths: null;
+        readonly valueKey: 'zoom.zoomLevel';
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'styles';
+    readonly labelKey: 'formattingBar.groups.styles';
+    readonly controls: readonly [{
+        readonly id: 'style';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'styles.selectAriaLabel';
+        readonly paths: null;
+        readonly valueKey: 'styles.normalText';
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }];
+}, {
+    readonly id: 'font';
+    readonly labelKey: 'formattingBar.groups.font';
+    readonly controls: readonly [{
+        readonly id: 'family';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'font.selectAriaLabel';
+        readonly paths: null;
+        readonly valueKey: 'font.sansSerif';
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'size';
+        readonly shape: 'stepper';
+        readonly valueText: '11';
+        readonly labelKey: 'fontSize.listLabel';
+        readonly paths: null;
+        readonly valueKey: 'fontSize.label';
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }];
+}, {
+    readonly id: 'text';
+    readonly labelKey: 'formattingBar.groups.textFormatting';
+    readonly controls: readonly [{
+        readonly id: 'bold';
+        readonly labelKey: 'formattingBar.boldShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'italic';
+        readonly labelKey: 'formattingBar.italicShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'underline';
+        readonly labelKey: 'formattingBar.underlineShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'strike';
+        readonly labelKey: 'formattingBar.strikethrough';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'color';
+        readonly shape: 'colorSplit';
+        readonly swatch: '#ff0000';
+        readonly labelKey: 'formattingBar.fontColor';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'highlight';
+        readonly shape: 'colorSplit';
+        readonly swatch: '#ffff00';
+        readonly labelKey: 'formattingBar.highlightColor';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'link';
+        readonly labelKey: 'formattingBar.insertLinkShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'script';
+    readonly labelKey: 'formattingBar.groups.script';
+    readonly controls: readonly [{
+        readonly id: 'super';
+        readonly labelKey: 'formattingBar.superscript';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'sub';
+        readonly labelKey: 'formattingBar.subscript';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'alignment';
+    readonly labelKey: 'formattingBar.groups.alignment';
+    readonly controls: readonly [{
+        readonly id: 'left';
+        readonly labelKey: 'alignment.alignLeft';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'center';
+        readonly labelKey: 'alignment.center';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'right';
+        readonly labelKey: 'alignment.alignRight';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'justify';
+        readonly labelKey: 'alignment.justify';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'direction';
+    readonly labelKey: 'formattingBar.groups.direction';
+    readonly contextual: true;
+    readonly controls: readonly [{
+        readonly id: 'ltr';
+        readonly labelKey: 'toolbar.leftToRight';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'rtl';
+        readonly labelKey: 'toolbar.rightToLeft';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'list';
+    readonly labelKey: 'formattingBar.groups.listFormatting';
+    readonly controls: readonly [{
+        readonly id: 'bullet';
+        readonly labelKey: 'lists.bulletList';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'numbered';
+        readonly labelKey: 'lists.numberedList';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'outdent';
+        readonly labelKey: 'lists.decreaseIndent';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'indent';
+        readonly labelKey: 'lists.increaseIndent';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'lineSpacing';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'lineSpacing.label';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'format';
+    readonly labelKey: 'formattingBar.groups.format';
+    readonly controls: readonly [{
+        readonly id: 'painter';
+        readonly labelKey: 'formattingBar.formatPainterShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'clear';
+        readonly labelKey: 'formattingBar.clearFormatting';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'review';
+    readonly labelKey: 'formattingBar.commentsAndChanges';
+    readonly controls: readonly [{
+        readonly id: 'revisionMarkup';
+        readonly shape: 'icon';
+        readonly labelKey: 'revisionMarkup.title';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'simpleMarkup';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.simpleMarkup';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'allMarkup';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.allMarkup';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'noMarkup';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.noMarkup';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'original';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.original';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'previousChange';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.previousChange';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'nextChange';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.nextChange';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'acceptAllChanges';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.acceptAllChanges';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'rejectAllChanges';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.rejectAllChanges';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'paragraphMarks';
+        readonly shape: 'icon';
+        readonly labelKey: 'formattingBar.paragraphMarks';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'protectDocument';
+        readonly shape: 'icon';
+        readonly labelKey: 'review.protectDocument';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'comments';
+        readonly shape: 'icon';
+        readonly labelKey: 'formattingBar.commentsAndChanges';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'addComment';
+        readonly shape: 'icon';
+        readonly labelKey: 'formattingBar.addComment';
+        readonly defaultToolbar: false;
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'authors';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'reviewers.label';
+        readonly paths: readonly string[];
+        readonly defaultToolbar: false;
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'editingMode';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'editingMode.label';
+        readonly valueKey: 'editingMode.editing';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'contentControl';
+    readonly labelKey: 'contentControl.group';
+    readonly contextual: true;
+    readonly controls: readonly [{
+        readonly id: 'showAll';
+        readonly labelKey: 'contentControl.showAll';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'formFill';
+        readonly labelKey: 'contentControl.formFill';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'inspector';
+        readonly labelKey: 'contentControl.inspector';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'remove';
+        readonly labelKey: 'contentControl.remove';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'image';
+    readonly labelKey: 'formattingBar.groups.image';
+    readonly contextual: true;
+    readonly controls: readonly [{
+        readonly id: 'insert';
+        readonly labelKey: 'toolbar.image';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'properties';
+        readonly labelKey: 'formattingBar.imagePropertiesShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'wrap';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'formattingBar.imageWrap';
+        readonly paths: readonly string[];
+        readonly valueKey: 'imageWrap.inline';
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'altText';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'formattingBar.altText';
+        readonly paths: null;
+        readonly valueKey: 'imageProperties.altText';
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }];
+}, {
+    readonly id: 'table';
+    readonly labelKey: 'formattingBar.groups.table';
+    readonly contextual: true;
+    readonly controls: readonly [{
+        readonly id: 'insert';
+        readonly labelKey: 'toolbar.table';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'borderTarget';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'table.borders.tooltip';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'borderColor';
+        readonly shape: 'colorSplit';
+        readonly swatch: '#000000';
+        readonly labelKey: 'table.borderColor';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'borderStyle';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'table.borders.styleAriaLabel';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'borderWidth';
+        readonly shape: 'dropdown';
+        readonly labelKey: 'table.borderWidth';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }, {
+        readonly id: 'cellFill';
+        readonly shape: 'colorSplit';
+        readonly swatch: '#ffffff';
+        readonly labelKey: 'table.cellFillColor';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'value';
+        };
+    }];
+}, {
+    readonly id: 'paragraph';
+    readonly labelKey: 'dialogs.paragraph.title';
+    readonly contextual: true;
+    readonly controls: readonly [{
+        readonly id: 'dialog';
+        readonly labelKey: 'lineSpacing.options';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'file';
+    readonly labelKey: 'toolbar.file';
+    readonly contextual: true;
+    readonly controls: readonly [{
+        readonly id: 'open';
+        readonly labelKey: 'toolbar.open';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'load';
+        };
+    }, {
+        readonly id: 'save';
+        readonly labelKey: 'toolbar.saveShortcut';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'save';
+        };
+    }, {
+        readonly id: 'exportMarkdown';
+        readonly labelKey: 'toolbar.exportMarkdown';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'export';
+        };
+    }, {
+        readonly id: 'exportPdf';
+        readonly labelKey: 'toolbar.exportPdf';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'export';
+        };
+    }, {
+        readonly id: 'print';
+        readonly labelKey: 'toolbar.print';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'export';
+        };
+    }, {
+        readonly id: 'pageSetup';
+        readonly labelKey: 'toolbar.pageSetup';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}, {
+    readonly id: 'insert';
+    readonly labelKey: 'toolbar.insert';
+    readonly contextual: true;
+    readonly controls: readonly [{
+        readonly id: 'textBox';
+        readonly labelKey: 'toolbar.insertTextBox';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'footnote';
+        readonly labelKey: 'toolbar.insertFootnote';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'endnote';
+        readonly labelKey: 'toolbar.insertEndnote';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'pageNumber';
+        readonly labelKey: 'headerFooter.insertPageNumber';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'totalPages';
+        readonly labelKey: 'headerFooter.insertTotalPages';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'sectionPages';
+        readonly labelKey: 'headerFooter.insertSectionPages';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'pageXofY';
+        readonly labelKey: 'headerFooter.insertPageXofY';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'pageBreak';
+        readonly labelKey: 'toolbar.pageBreak';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'sectionBreakNextPage';
+        readonly labelKey: 'toolbar.sectionBreakNextPage';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'sectionBreakContinuous';
+        readonly labelKey: 'toolbar.sectionBreakContinuous';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }, {
+        readonly id: 'toc';
+        readonly labelKey: 'toolbar.tableOfContents';
+        readonly paths: readonly string[];
+        readonly state: {
+            readonly kind: 'command';
+        };
+    }];
+}];
+/**
+ * Every group id in the chrome, as a literal union. Stable public API; renaming a group
+ * id is a breaking change.
+ *
+ * @public
+ */
+type ChromeGroupId = 'history' | 'zoom' | 'styles' | 'font' | 'text' | 'script' | 'alignment' | 'direction' | 'list' | 'format' | 'review' | 'contentControl' | 'image' | 'table' | 'paragraph' | 'file' | 'insert';
+/**
+ * The public slot vocabulary: `${groupId}.${controlId}` for every control that actually
+ * exists — `text.bold`, `font.family`, `alignment.left`. THE stable contract a host
+ * composes against and `commandForSlot` resolves; renaming a slot is a breaking change.
+ *
+ * @public
+ */
+type ChromeSlotId = 'history.undo' | 'history.redo' | 'zoom.level' | 'styles.style' | 'font.family' | 'font.size' | 'text.bold' | 'text.italic' | 'text.underline' | 'text.strike' | 'text.color' | 'text.highlight' | 'text.link' | 'script.super' | 'script.sub' | 'alignment.left' | 'alignment.center' | 'alignment.right' | 'alignment.justify' | 'direction.ltr' | 'direction.rtl' | 'list.bullet' | 'list.numbered' | 'list.outdent' | 'list.indent' | 'list.lineSpacing' | 'format.painter' | 'format.clear' | 'review.revisionMarkup' | 'review.comments' | 'review.addComment' | 'review.paragraphMarks' | 'review.protectDocument' | 'review.simpleMarkup' | 'review.allMarkup' | 'review.noMarkup' | 'review.original' | 'review.previousChange' | 'review.nextChange' | 'review.acceptAllChanges' | 'review.rejectAllChanges' | 'review.authors' | 'review.editingMode' | 'contentControl.showAll' | 'contentControl.formFill' | 'contentControl.inspector' | 'contentControl.remove' | 'image.insert' | 'image.properties' | 'image.wrap' | 'image.altText' | 'table.insert' | 'table.borderTarget' | 'table.borderColor' | 'table.borderStyle' | 'table.borderWidth' | 'table.cellFill' | 'file.open' | 'file.save' | 'file.exportMarkdown' | 'file.exportPdf' | 'file.print' | 'paragraph.dialog' | 'file.pageSetup' | 'insert.textBox' | 'insert.footnote' | 'insert.endnote' | 'insert.pageNumber' | 'insert.totalPages' | 'insert.sectionPages' | 'insert.pageXofY' | 'insert.pageBreak' | 'insert.sectionBreakNextPage' | 'insert.sectionBreakContinuous' | 'insert.toc';
+/**
+ * Every control id in the chrome, as a literal union. Unique WITHIN a group, not
+ * globally (`image.insert` / `table.insert`) — key consumers on {@link ChromeSlotId}.
+ *
+ * @public
+ */
+type ChromeControlId = ChromeSlotId extends `${string}.${infer C}` ? C : never;
+/**
+ * The slot id of one control within its group. Only meaningful for entries of
+ * `CHROME_GROUPS` — the cast is sound because every group/control pair in the registry
+ * is, by construction, a member of the `ChromeSlotId` union.
+ *
+ * @public
+ */
+declare function chromeSlotId(group: {
+    readonly id: string;
+}, control: {
+    readonly id: string;
+}): ChromeSlotId;
+/**
+ * The groups of the DEFAULT toolbar arrangement, in bar order: every group that is
+ * not `contextual`. This is the registry's default bar — undo/redo through the
+ * editing-mode picker — and what both adapters render when the host composes
+ * nothing. Contextual slots (`image.*`, `table.insert`, `file.save`) remain
+ * available for explicit composition.
+ *
+ * @public
+ */
+declare function defaultChromeGroups(): readonly ChromeGroup[];
+/**
+ * The formatting-bar groups for one editor snapshot: the default bar, plus the
+ * contextual `image` group when a drawing is selected. Insertion without a selection
+ * lives in the packaged Insert menu (`CHROME_MENUS`), not in the bar — a host that wants
+ * a bar button places `DocxEditor.Toolbar.ImageInsert` itself.
+ *
+ * @public
+ */
+declare function formattingBarChromeGroups(image: ImageContext | null): readonly ChromeGroup[];
+
+/**
+ * The menu bar the chrome shows above the toolbar, in bar order: File, Format, Insert, Review,
+ * Help.
+ *
+ * @public
+ */
+declare const CHROME_MENUS: readonly ChromeMenu[];
+/**
+ * Every slot a menu places, in menu order, submenus flattened. What a parity test asserts
+ * against, and what a host enumerates to know which capabilities the menu bar reaches.
+ *
+ * @public
+ */
+declare function chromeMenuSlots(): readonly ChromeSlotId[];
+/** Total controls, so a parity test can assert none were dropped. */
+declare function chromeControlCount(): number;
+/** Tooltip for adapter controls without a picker; command refusals use engine reasons. */
+declare const CHROME_UNAVAILABLE_KEY = "formattingBar.unavailableInPreview";
+
+/** Material Symbol name → SVG path data (viewBox "0 -960 960 960"). */
+declare const GENERATED_ICON_PATHS: Readonly<Record<string, readonly string[]>>;
+
+/** Border target picker value — concrete scopes plus clear (`none`). */
+type TableBorderTargetValue = TableBorderEdgeTarget | 'none';
+/** UI draft: last active edge scope and the complete border spec to reapply. */
+interface TableChromeDraft {
+    readonly activeTarget: TableBorderEdgeTarget;
+    readonly spec: TableBorderSpec;
+}
+/** The draft a table's border chrome starts from: a 1pt black single border on every edge. */
+declare const DEFAULT_TABLE_CHROME_DRAFT: TableChromeDraft;
+/**
+ * The chrome slots that only exist while the caret is inside a table.
+ *
+ * A subset of `ChromeSlotId`, so these names are public API on the same terms — renaming one is
+ * a breaking change.
+ */
+type TableChromeSlotId = 'table.borderTarget' | 'table.borderColor' | 'table.borderStyle' | 'table.borderWidth' | 'table.cellFill';
+/** Every {@link TableChromeSlotId}, for iteration and for {@link isTableChromeSlot}. */
+declare const TABLE_CHROME_SLOT_IDS: readonly TableChromeSlotId[];
+/** Furniture insertion controls (Task 8) share this label seam. */
+type TableInteractionLabelKey = 'table.insertRowBelow' | 'table.insertColumnRight';
+/**
+ * The English label for a furniture-insertion control.
+ *
+ * The FALLBACK, for a host that has not wired its own translator — adapters pass their
+ * `useTranslation` result instead so the control follows the app's locale.
+ */
+declare function defaultTableLabel(key: TableInteractionLabelKey): string;
+/** Whether a chrome slot is one of the table-only ones. Narrows the type. */
+declare function isTableChromeSlot(slot: ChromeSlotId): slot is TableChromeSlotId;
+/** Contextual table chrome is visible when the engine reports table context. */
+declare function tableChromeVisible(table: TableContext | null | undefined): boolean;
+/** One entry in the border-target picker: which edges it addresses, its icon, and its label key. */
+interface TableBorderTargetOption {
+    readonly value: TableBorderTargetValue;
+    readonly icon: keyof typeof GENERATED_ICON_PATHS;
+    /** i18n key, never a literal string — both adapters translate it themselves. */
+    readonly labelKey: string;
+}
+/** The border-target picker's entries, in Word's own order, ending with clear. */
+declare const TABLE_BORDER_TARGET_OPTIONS: readonly TableBorderTargetOption[];
+/** One entry in the border-style picker, with the CSS class that draws its preview line. */
+interface TableBorderStyleOption {
+    readonly value: TableBorderStyle;
+    readonly labelKey: string;
+    /** Class on the preview swatch. Defined in the core stylesheet, which both adapters import. */
+    readonly previewClass: string;
+}
+/** The border-style picker's entries. */
+declare const TABLE_BORDER_STYLE_OPTIONS: readonly TableBorderStyleOption[];
+/** One entry in the border-width picker. */
+interface TableBorderWidthOption {
+    /** `w:sz` — eighths of a point, as OOXML stores border widths. */
+    readonly size: number;
+    readonly labelKey: string;
+    /** Points, for drawing the preview swatch. `size / 8`. */
+    readonly previewThickness: number;
+}
+/** Widths in eighths of a point — Word-like presets. */
+declare const TABLE_BORDER_WIDTH_OPTIONS: readonly TableBorderWidthOption[];
+/**
+ * What one table-chrome selection produced: the command to run, and the draft to remember.
+ *
+ * Both halves matter. A border picker is stateful — choosing "dashed" and then "outside" must
+ * apply a dashed outside border — so each pick returns the COMPLETE spec to execute alongside the
+ * draft the next pick builds on.
+ */
+interface TableChromePick {
+    readonly command: EditorCommand;
+    readonly nextDraft: TableChromeDraft;
+}
+/**
+ * Build the engine command for one table chrome pick and the draft state after it.
+ * Target picks apply the current complete spec; `none` clears the active target only.
+ */
+declare function applyTableChromePick(draft: TableChromeDraft, slot: TableChromeSlotId, value: unknown): TableChromePick | null;
+/** Probe command for `Editor.can` — uses the draft's active target and a well-formed value. */
+declare function probeTableChromeCommand(slot: TableChromeSlotId, draft?: TableChromeDraft): EditorCommand | null;
+/**
+ * The i18n key naming one border target, for a trigger that shows the active scope.
+ *
+ * Falls back to the "all" key rather than throwing: a label is chrome, and a missing one should
+ * not take the toolbar down.
+ */
+declare function tableChromeLabelKeyForTarget(target: TableBorderEdgeTarget): string;
+/** Material Symbol paths for one table chrome icon name. */
+declare function tableChromeIconPaths(name: keyof typeof GENERATED_ICON_PATHS): readonly string[];
+
+/** Value types accepted by toolbar controls. Font size uses half-points. @public */
+interface ToolbarValueMap {
+    'font.family': string;
+    'font.size': number;
+    'text.color': string;
+    'text.highlight': string;
+    'styles.style': string;
+    'list.lineSpacing': number;
+    'image.wrap': ImageWrapTarget;
+    'image.altText': string;
+    'review.editingMode': 'editing' | 'suggesting' | 'viewing';
+}
+/** @public */
+type ToolbarValueSlot = keyof ToolbarValueMap | TableChromeSlotId;
+/** @public */
+type ToolbarSlotValue<K extends ToolbarValueSlot> = K extends keyof ToolbarValueMap ? ToolbarValueMap[K] : unknown;
+/** A command hook keeps its nullary event-handler form and accepts explicit options. @public */
+interface EditorCommandExecute {
+    (): boolean;
+    (options: EditorExecOptions): boolean;
+}
+/** Ignore framework events passed to a command used directly as an event handler. */
+declare function commandExecOptions(value: unknown): EditorExecOptions | undefined;
+
+/**
+ * The probe a slot uses to ask "would the engine honour this right now?" when its real
+ * command needs an argument the slot itself cannot supply.
+ *
+ * `text.link` is the case: whether this selection could become a link is the engine's
+ * question, but WHICH link is a URL field's. Chrome that owns a link UI (React's
+ * `ToolbarLink`) asks with this and dispatches through that UI.
+ *
+ * DELIBERATELY NOT in `SLOT_COMMANDS`. Enabled state has one source, and putting the probe
+ * there would enable the control in EVERY adapter — including Vue, which has grown no link
+ * UI, where the result is an enabled button whose click can only be refused. A dead button
+ * is the worse lie: `file.save` was a disabled control for a capability that works, and this
+ * would be an enabled control for one that is not reachable. Vue's slot therefore keeps
+ * reporting the honest "not wired to an editor command" until its popover lands.
+ *
+ * @public
+ */
+declare function chromeProbeForSlot(slotId: ChromeSlotId): EditorCommand | null;
+/**
+ * The public editor command behind one chrome slot, or `null` when the slot is
+ * not wired to a command yet (parity-only chrome, or save — which is not a
+ * command). The single source of command truth for both adapters.
+ *
+ * @public
+ */
+declare function commandForSlot(slotId: ChromeSlotId): EditorCommand | null;
+
+/**
+ * Build an engine command for one table chrome slot using the caller's draft state.
+ *
+ * @public
+ */
+declare function commandForTableChromeSlotValue(slotId: TableChromeSlotId, value: unknown, draft: TableChromeDraft): EditorCommand | null;
+/**
+ * The engine command for a VALUE-TYPED slot carrying the picked value, or `null` for a
+ * slot that does not take a value.
+ *
+ * Two families: the run-property pickers (`font.family`, `font.size`, `text.color`,
+ * `text.highlight`) resolve to `setMarkAttr`, and `styles.style` resolves to
+ * `setParagraphStyle` — a paragraph styleId, not a mark. Either way the value is
+ * validated by the engine's own gate (`can` refuses a malformed one with `invalidArgs`;
+ * a styleId the document does not define is refused at `exec`), so a host can pass user
+ * input through unmodified.
+ *
+ * @public
+ */
+declare function commandForSlotValue(slotId: ChromeSlotId, value: unknown): EditorCommand | null;
+/**
+ * Whether one control is enabled, and the engine's reason when it is not.
+ *
+ * @public
+ */
+interface ToolbarCommandState {
+    readonly id: ChromeSlotId;
+    readonly enabled: boolean;
+    /** The engine's reason when disabled — surfaced as a tooltip, never invented. */
+    readonly disabledReason: string | null;
+    /**
+     * What the control currently SHOWS, for the slots whose answer is a value rather than a
+     * pressed state — the editing-mode pill, and image wrap when it lands.
+     *
+     * `active` cannot express this: "the mode is Suggesting" is not a boolean about one
+     * command, and a parallel channel for it would be a second place a control could read its
+     * own state from. Absent for every slot whose state really is just pressed-or-not.
+     */
+    readonly value?: string;
+    /** Whether the command is currently APPLIED at the selection, from `Editor.isActive` —
+     *  derived in the engine for marks and alignment, honest-false elsewhere. */
+    readonly active: boolean;
+}
+/**
+ * Enabled state for one table chrome slot using explicit draft state.
+ *
+ * @public
+ */
+declare function tableChromeToolbarState(editor: Editor | null, slot: TableChromeSlotId, draft?: TableChromeDraft): ToolbarCommandState;
+/**
+ * Ask the engine whether one control should be enabled.
+ *
+ * @public
+ */
+declare function toolbarCommandState(editor: Editor | null, id: ChromeSlotId): ToolbarCommandState;
+/**
+ * Whether a slot's control renders as a TOGGLE — pressed or not — so it carries
+ * `aria-pressed`.
+ *
+ * Shared rather than derived per adapter, because it is not derivable from the command table
+ * alone: the format painter has no fixed command (a press captures, arms, locks or stands
+ * down, which no single `EditorCommand` describes), so a rule that only read `commandForSlot`
+ * left it announcing nothing at all to a screen reader while it was armed.
+ *
+ * @public
+ */
+declare function chromeSlotIsToggle(slotId: ChromeSlotId): boolean;
+/**
+ * Enabled state for several controls in one pass.
+ *
+ * @public
+ */
+declare function toolbarCommandStates(editor: Editor | null, ids: readonly ChromeSlotId[]): readonly ToolbarCommandState[];
+/**
+ * Result of {@link runTableChromeCommand}: engine outcome plus post-pick draft on success.
+ *
+ * @public
+ */
+interface RunTableChromeCommandResult {
+    readonly result: ExecResult;
+    readonly nextDraft: TableChromeDraft | null;
+}
+/**
+ * Run one table chrome pick with explicit draft state; returns the post-pick draft on success.
+ *
+ * @public
+ */
+declare function runTableChromeCommand(editor: Editor | null, slot: TableChromeSlotId, value: unknown, draft: TableChromeDraft): RunTableChromeCommandResult;
+/**
+ * Run a toolbar control: `can` first, then `exec` only if it said yes. Returns
+ * the engine's refusal untouched when it said no, so a caller cannot mistake a
+ * declined command for a no-op.
+ *
+ * @public
+ */
+declare function runToolbarCommand(editor: Editor | null, id: ChromeSlotId): ExecResult;
+/** @public */
+declare function runToolbarCommand(editor: Editor | null, id: Exclude<ChromeSlotId, ToolbarValueSlot>, options: EditorExecOptions): ExecResult;
+/** @public */
+declare function runToolbarCommand<K extends keyof ToolbarValueMap>(editor: Editor | null, id: K, value: ToolbarValueMap[NoInfer<K>], options?: EditorExecOptions): ExecResult;
+/** @public */
+declare function runToolbarCommand(editor: Editor | null, id: TableChromeSlotId, value: unknown, options?: EditorExecOptions): ExecResult;
+/** @public */
+declare function runToolbarCommand(editor: Editor | null, id: ChromeSlotId, value: undefined, options: EditorExecOptions): ExecResult;
+/**
+ * Save goes straight to `Editor.save()` — it is not a command.
+ *
+ * @public
+ */
+declare function runSave(editor: Editor | null): Promise<ArrayBuffer>;
+/**
+ * Enabled state for a table command when the caller holds the paginated surface.
+ *
+ * Uses the same planner-backed `tableCommandState` as `Editor.can`/`gateTableCommand`.
+ * Chrome slot mapping for table controls is Task 9 — this helper is the shared
+ * can-before-exec seam for arbitrary table commands.
+ *
+ * @public
+ */
+declare function tableCommandToolbarState(surface: PaginatedSurface | null, command: EditorCommand): Pick<ToolbarCommandState, 'enabled' | 'disabledReason'>;
+/**
+ * Run a table command: planner-backed `can` first, then `exec` only when allowed.
+ *
+ * @public
+ */
+declare function runTableCommand(editor: Editor | null, command: EditorCommand, options?: EditorExecOptions): ExecResult;
+
+/**
+ * Build an editor: the full `Editor` contract over a paginated surface.
+ *
+ * Construction is separate from mounting. Pass a `container` and the document mounts
+ * immediately; omit it and nothing touches the DOM until `attach(el)` — the provider-first
+ * shape. `detach()` remounts from the saved bytes, which resets undo and the caret.
+ *
+ * `snapshot()` is version-cached: the same reference until state actually moves, with
+ * reference-stable sub-objects, so it is safe as a `useSyncExternalStore` source.
+ *
+ * @example
+ * ```ts
+ * const editor = createDocxEditor({ document: bytes, modules: [reviewModule()] });
+ * editor.attach(element);
+ * editor.on('change', () => setDirty(true));
+ * ```
+ *
+ * @public
+ */
+declare function createDocxEditor(config: DocxEditorConfig): DocxEditorInstance;
+
+/** Native event policy for one continuous control gesture. @public */
+interface HistoryGroupBindingOptions {
+    readonly kind: 'native-color' | 'range' | 'repeat' | 'keyboard';
+}
+/** Dispose when the element or editor changes. @public */
+interface HistoryGroupBinding {
+    /** Options for the next synchronous formatting command. */
+    options(): EditorExecOptions;
+    /** Close the gesture and remove every listener; does not revert edits. */
+    dispose(): void;
+}
+/**
+ * Bind native gesture events. Framework change handlers apply values; this binding ends groups.
+ * Native color `change` means value commitment, not portable popup closure. Controls without
+ * a terminal change event end on the next activation, Escape, blur, or disposal.
+ * Range/repeat controls end on pointer release/cancel or keyup, including outside releases.
+ * Terminal events close after propagation so the final value can use the same handle.
+ * @public
+ */
+declare function bindHistoryGroup(editor: Editor, element: HTMLElement, config: HistoryGroupBindingOptions): HistoryGroupBinding;
+
+/** File menu conversion formats. @public */
+type ChromeExportFormat = 'markdown' | 'pdf';
+/** Viewer settings captured before PDF conversion. @public */
+interface ChromeExportView {
+    readonly displayMode: ReviewDisplayMode;
+    readonly revisionMarkup: ResolvedRevisionMarkup;
+    /** Stable session slots, including gaps left by removed authors. */
+    readonly revisionAuthorSlots?: Readonly<Record<string, number>>;
+}
+/**
+ * Conversion handlers for File > Export. Install the corresponding converter package.
+ * Use `exportMarkdown` for Markdown. PDF requires `exportPdf` on a Node.js server.
+ * Browser hosts supply a PDF handler that calls that server after the user selects Export.
+ * @public
+ */
+interface ChromeExportHandlers {
+    /** Returns continuous document Markdown. Page output is not downloaded. */
+    readonly markdown?: (source: Uint8Array) => Promise<{
+        readonly markdown: string;
+    }>;
+    /** Returns PDF bytes from `@docx-editor.dev/docx-to-pdf` on Node.js. */
+    readonly pdf?: (source: Uint8Array, view?: ChromeExportView) => Promise<{
+        readonly bytes: Uint8Array;
+    }>;
+}
+/** Download data from a completed conversion. @public */
+interface ChromeExportResult {
+    readonly bytes: Uint8Array;
+    readonly extension: 'md' | 'pdf';
+    readonly mimeType: string;
+}
+/** An export has no configured converter. @public */
+declare class ChromeExportError extends Error {
+    readonly format: ChromeExportFormat;
+    readonly code = "missing-exporter";
+    constructor(format: ChromeExportFormat);
+}
+/**
+ * Saves the current document and converts those bytes through the configured handler.
+ * Missing handlers fail before saving. Conversion never changes the editor document.
+ * @public
+ */
+declare function runChromeExport(editor: Pick<Editor, 'save'> & Partial<Pick<DocxEditorInstance, 'snapshot' | 'getReviewAuthors'>>, format: ChromeExportFormat, handlers?: ChromeExportHandlers): Promise<ChromeExportResult>;
+
+/** Why the browser could not print the converted PDF. @public */
+type ChromePrintErrorCode = 'pdf-viewer-unavailable' | 'pdf-load-failed' | 'print-refused' | 'print-ended';
+/**
+ * The browser could not print the converted PDF. The PDF at `ChromePrintJob.url` is still
+ * available, so the user can open it and print from the PDF viewer.
+ * @public
+ */
+declare class ChromePrintError extends Error {
+    /** Why the browser could not print. */
+    readonly code: ChromePrintErrorCode;
+    constructor(code: ChromePrintErrorCode);
+}
+/**
+ * True for the print shortcut: Cmd+P on Apple platforms, Ctrl+P elsewhere. On macOS,
+ * Ctrl+P moves the caret to the previous line, so it is not a print shortcut there. The P
+ * key matches by `code` too when it types no Latin letter, as on Cyrillic or Hebrew layouts.
+ * @public
+ */
+declare function isChromePrintShortcut(event: KeyboardEvent): boolean;
+/** Options for `ChromePrintJob.print`. @public */
+interface ChromePrintOptions {
+    /**
+     * Runs after the PDF loads and before the print dialog opens. Close any modal dialog
+     * here: a modal dialog makes the rest of the page, including the print frame, inert.
+     */
+    readonly beforePrint?: () => void | Promise<void>;
+}
+/**
+ * A converted PDF, ready for the browser print dialog.
+ * Call `dispose()` when the job ends: it removes the print frame and revokes `url`.
+ * @public
+ */
+interface ChromePrintJob {
+    /** An object URL for the PDF. It stays valid until `dispose()`. */
+    readonly url: string;
+    /**
+     * Opens the browser print dialog for the PDF from a hidden frame.
+     * Rejects with `ChromePrintError` when the browser has no PDF viewer, the frame cannot
+     * load the PDF, or the job has ended. A browser without a PDF viewer would download the
+     * PDF instead of loading it, so the frame is not created in that case.
+     */
+    print(options?: ChromePrintOptions): Promise<void>;
+    /** Removes the print frame and revokes `url`. Later `print()` calls reject. */
+    dispose(): void;
+}
+/**
+ * Saves the current document, converts it with the configured PDF handler, and prepares
+ * the result for printing. Uses the same handler and checks as File > Export > PDF, so a
+ * missing handler rejects with `ChromeExportError` before the document is saved.
+ * Saving commits pending form input and can refresh field results with an undo step.
+ * `container` receives the hidden print frame. For an editor inside a modal dialog,
+ * pass an element inside that dialog.
+ * @public
+ */
+declare function runChromePrint(editor: Pick<Editor, 'save'> & Partial<Pick<Editor, 'snapshot'>>, handlers?: ChromeExportHandlers, container?: Document | Element): Promise<ChromePrintJob>;
+
+export { IMAGE_OVERLAY_NUDGE_SHIFT_PT as $, CHROME_GROUPS as C, DEFAULT_TABLE_CHROME_DRAFT as F, EMU_PER_POINT as I, IMAGE_OVERLAY_NUDGE_PT as _, createFontSource as a$, applyTableChromePick as aJ, bindHistoryGroup as aK, blankDocumentBytes as aL, canExecuteImageCommand as aM, captureImageMutationPreconditions as aN, chromeControlCount as aO, chromeMenuSlots as aP, chromeProbeForSlot as aQ, chromeSlotId as aR, chromeSlotIsToggle as aS, commandExecOptions as aT, commandForSlot as aU, commandForSlotValue as aV, commandForTableChromeSlotValue as aW, computeImageResizeResult as aX, computeMovedImagePosition as aY, computeResizedImageExtentEmu as aZ, createDocxEditor as a_, TABLE_BORDER_STYLE_OPTIONS as ar, TABLE_BORDER_TARGET_OPTIONS as as, TABLE_BORDER_WIDTH_OPTIONS as at, TABLE_CHROME_SLOT_IDS as au, CHROME_MENUS as b, createImageOverlayScrollPort as b0, cssPixelsToLayoutPoints as b1, customFonts as b2, defaultChromeGroups as b3, defaultTableLabel as b4, emuToOverlayPoints as b5, equationAtPosition as b6, executeImageCommand as b7, finalizeImageOverlayInteraction as b8, formattingBarChromeGroups as b9, isChromePrintShortcut as ba, isStaleImageInteractionCommit as bb, isTableChromeSlot as bc, layoutPointsToCssPixels as bd, loadFonts as be, overlayFrameToSheetCssPixels as bf, overlayHostOrigin as bg, pointsToEmu as bh, probeTableChromeCommand as bi, resizePreservesAspect as bj, runChromeExport as bk, runChromePrint as bl, runSave as bm, runTableChromeCommand as bn, runTableCommand as bo, runToolbarCommand as bp, selectedDrawingOverlayTargetOf as bq, selectedImageStateOf as br, surfacePaintScale as bs, tableChromeIconPaths as bt, tableChromeLabelKeyForTarget as bu, tableChromeToolbarState as bv, tableChromeVisible as bw, tableCommandToolbarState as bx, toolbarCommandState as by, toolbarCommandStates as bz, CHROME_UNAVAILABLE_KEY as c, ChromeExportError as g, ChromePrintError as t };
+export type { AnchorFrameOrigin as A, CustomFontsOptions as B, DocxEditorInstance as D, CustomFontsResolver as E, DocxEditorConfig as G, DrawingSelectionIntent as H, EditorCommandExecute as J, EquationActivation as K, EquationChromeHandlers as L, EquationOps as M, FinalizedImageOverlayInteraction as N, OpenPaginatedResult as O, PaginatedSurfaceOptions as P, FontLoadFailure as Q, FontLoadFailureReason as R, FontMeasurementState as S, TableCommandPlan as T, FontUrlSource as U, HistoryGroupBinding as V, HistoryGroupBindingOptions as W, HyperlinkActivation as X, HyperlinkChromeHandlers as Y, HyperlinkOps as Z, PaginatedSurface as a, ImageInteractionSession as a0, ImageOverlayScrollPort as a1, ImageResizeHandle as a2, ImageResizeResult as a3, InvalidTextFormFieldChromeHandlers as a4, InvalidTextFormFieldSession as a5, LoadFontsRequest as a6, LoadFontsResult as a7, OpeningIndicatorHost as a8, OverlayFrameRect as a9, TableChromePick as aA, TableChromeSlotId as aB, TableInteractionLabelKey as aC, TextFormFieldChromeHandlers as aD, TextFormFieldDialogSession as aE, ToolbarCommandState as aF, ToolbarSlotValue as aG, ToolbarValueMap as aH, ToolbarValueSlot as aI, PaginatedSurfaceState as aa, ParagraphPropertyEdit as ab, PopupChromeRegistrationOptions as ac, RemoteCaretLabelAnchor as ad, RemoteCaretLabelHost as ae, ReviewWriteIntent as af, RunTableChromeCommandResult as ag, SectionAnchor as ah, SectionBreakInsertType as ai, SelectedDrawingOverlayTarget as aj, SurfaceEquation as ak, SurfaceFormatting as al, SurfaceHyperlink as am, SurfaceInsertImageInput as an, SurfaceNavigation as ao, SurfaceOverlayCoordinates as ap, SurfaceParagraphFormat as aq, TableBorderStyleOption as av, TableBorderTargetOption as aw, TableBorderTargetValue as ax, TableBorderWidthOption as ay, TableChromeDraft as az, ChromeControl as d, ChromeControlId as e, ChromeControlState as f, ChromeExportFormat as h, ChromeExportHandlers as i, ChromeExportResult as j, ChromeExportView as k, ChromeGroup as l, ChromeGroupId as m, ChromeMenu as n, ChromeMenuEntry as o, ChromeMenuId as p, ChromeMenuItemEntry as q, ChromeMenuSeparatorEntry as r, ChromeMenuSubmenuEntry as s, ChromePrintErrorCode as u, ChromePrintJob as v, ChromePrintOptions as w, ChromeSlotId as x, ContentControlWidgetChromeHandlers as y, ContentControlWidgetSession as z };