@sobree/core 0.1.0 → 0.1.2

package/dist/editor/index.d.ts

@@ -1,266 +1,20 @@
 import { BlobCache, BlobStore } from '../blob';
-import { BlockRef, EditError, EditResult, InlinePosition, Range as ApiRange, Selection } from '../doc/api';
-import { EmbedFontFaces, EmbedFontOptions } from '../fonts';
+import { Range as ApiRange, BlockRef, EditError, EditResult, InlinePosition, Selection } from '../doc/api';
 import { RunPropertiesPatch } from '../doc/runs';
-import { Block, InlineRun, ParagraphAlignment, ParagraphProperties, SobreeDocument } from '../doc/types';
+import { Block, InlineRun, SobreeDocument } from '../doc/types';
+import { EmbedFontFaces, EmbedFontOptions } from '../fonts';
+import { History } from '../history';
 import { BlockRegistry } from './internal/blockRegistry';
 import { countBlocks } from './internal/positionMap';
+import { EditorSelection } from './selection';
 import { EditorTable } from './table';
-import { History } from '../history';
+import { ApiRangeType, BlockInfo, ChangePayload, CommandBus, CommandDefinition, CommandSnapshot, EditorEvent, EditorEventPayload, EditorOptions, KeyDownPayload, OutlineItem, ParagraphPropertiesPatch, RevisionSpan, SelectionPayload, TrackChangesState, Unsubscribe, WrapTag } from './types';
 import * as Y from "yjs";
+export { EditorCommands } from './commands';
+export { EditorSelection } from './selection';
 export type { BlockRef, EditError, EditResult, InlinePosition, Selection };
-export type ApiRangeType = ApiRange;
-/**
- * One logical tracked change — a maximal run of consecutive inline
- * runs that all carry a `revision` marker by the same author.
- * `getRevisions()` returns these; pass `range` straight to
- * `acceptRevision` / `rejectRevision`.
- *
- * `kinds` is the set of revision types in the span: `["ins"]` or
- * `["del"]` for a plain change, both for a delete-then-insert
- * replacement (which accepts/rejects as a single unit).
- */
-export interface RevisionSpan {
-    range: ApiRange;
-    author?: string;
-    kinds: ("ins" | "del")[];
-    /** ISO date of the span's first revision run, if recorded. */
-    date?: string;
-    /**
-     * Discriminator between revision levels:
-     *   `"inline"` (default for backwards compat) — the span covers
-     *     `ins`/`del` text runs inside a block. Pass `range` to
-     *     `acceptRevision` / `rejectRevision`.
-     *   `"paragraph"` — the span flags the *paragraph mark* itself on
-     *     `range.from.block`. The range covers offset `[0, length]` of
-     *     the block so it still selects the right element for UIs, but
-     *     accept/reject must go through `acceptParagraphRevision` /
-     *     `rejectParagraphRevision`.
-     *   `"format"` — the span flags a tracked format change
-     *     (`<w:rPrChange>`) on contiguous runs by the same author.
-     *     `kinds` always reports `["ins"]` (the marker is binary: a
-     *     format change exists or not). Pass `range` to
-     *     `acceptFormatRevision` / `rejectFormatRevision`.
-     */
-    level?: "inline" | "paragraph" | "format";
-}
-/**
- * Track-changes mode. When `enabled` is true, the editor reinterprets
- * authoring mutations as tracked revisions rather than direct edits:
- *
- *   - `insertRun` stamps `revision: { type: "ins", author }` on the
- *     inserted run instead of merging it in plainly.
- *   - `deleteRange` stamps `revision: { type: "del", author }` on the
- *     plain text runs in range instead of dropping them. A run that's
- *     already an `ins` *by the same author* is dropped instead — the
- *     author cancelling their own pending insert — and runs already
- *     carrying a peer's revision are left untouched (the API user must
- *     resolve those via `acceptRevision` / `rejectRevision` first).
- *   - All other mutations (`applyRunProperties`, block-level ops, etc.)
- *     pass through unchanged in this first cut; format-change tracking
- *     (`<w:rPrChange>`) and paragraph-mark tracking will land later.
- *
- * `author` is the human-readable name written into the revision
- * marker. Optional — falls back to no `author` field, mirroring the
- * Word semantics for anonymous-author tracked changes.
- *
- * This is the *authoring* side of the review feature. `getRevisions`
- * / `acceptRevision` / `rejectRevision` are the *consumption* side
- * and work the same regardless of this flag.
- */
-export interface TrackChangesState {
-    enabled: boolean;
-    author?: string;
-}
-export type { CellRef, InsertAt, InsertColumnOpts, InsertRowOpts, MergeCellsOpts, } from './table';
-/**
- * Payload delivered to `change` subscribers. Plain data — safe to
- * JSON-stringify and ship over a wire. `rawParts` is stripped from
- * `document` so the payload never carries binary Uint8Arrays.
- */
-export interface ChangePayload {
-    doc: SobreeDocument;
-    /**
-     * @deprecated Use `doc` instead. This alias is kept for backwards
-     * compatibility within the pre-1.0 line and will be removed before
-     * v1. Same reference as `doc`.
-     */
-    document: SobreeDocument;
-    revision: number;
-    documentVersion: number;
-}
-/** Summary of a top-level block, for `getBlocks()` and list-style UIs. */
-export interface BlockInfo {
-    /** Current position in the body (unstable across edits). */
-    index: number;
-    /** Stable id — pair with `version` to form a `BlockRef`. */
-    id: string;
-    /** Bumps on every modification of this block. */
-    version: number;
-    kind: Block["kind"];
-    styleId?: string;
-    alignment?: ParagraphAlignment;
-    /** Plain-text preview. */
-    text: string;
-    /** Total character-length of the block's content (see `runsLength`). */
-    length: number;
-}
-/** Outline entry — one per heading in document order. */
-export interface OutlineItem {
-    level: number;
-    text: string;
-    blockIndex: number;
-    block: BlockRef;
-}
-export type ParagraphPropertiesPatch = {
-    [K in keyof ParagraphProperties]?: ParagraphProperties[K] | undefined;
-};
-export type WrapTag = "sup" | "sub" | "strong" | "em" | "u" | "s" | "mark";
-export type EditorEvent = "change" | "selection" | "keydown" | "track-changes-change";
-export type EditorEventPayload = {
-    change: ChangePayload;
-    selection: SelectionPayload;
-    keydown: KeyDownPayload;
-    "track-changes-change": TrackChangesState;
-};
-export type Unsubscribe = () => void;
-/**
- * Payload delivered to `selection` subscribers. Fires whenever the live
- * DOM selection changes — typing, clicking, arrow-key navigation, focus
- * loss, programmatic restore. Subscribers should subscribe through the
- * editor rather than `document.addEventListener("selectionchange")`
- * directly so cleanup is centralised and the editor can later add
- * dedup / throttling.
- *
- * `selection` is the model shape (`null` when focus is outside the
- * editor). The convenience fields below mirror what `EditorSelection`
- * exposes for ergonomics — read whichever one you need.
- */
-export interface SelectionPayload {
-    selection: Selection;
-    range: ApiRange | null;
-    caret: InlinePosition | null;
-    block: BlockRef | null;
-}
-/**
- * Payload delivered to `keydown` subscribers. Fires for every key press
- * inside the editor host. The editor binds NO shortcuts itself —
- * plugins map keys to API calls via `preventDefault()` (stops the
- * browser's default action) and `stopPropagation()` (stops the chain
- * of remaining subscribers). Subscribers fire in registration order.
- */
-export interface KeyDownPayload {
-    /** `KeyboardEvent.key` — `"b"`, `"Enter"`, `"ArrowLeft"`, … (lowercased for letters). */
-    key: string;
-    /** `KeyboardEvent.code` — `"KeyB"`, `"Enter"`, `"ArrowLeft"`, … (layout-independent). */
-    code: string;
-    ctrl: boolean;
-    shift: boolean;
-    alt: boolean;
-    meta: boolean;
-    /** Stop the browser's default for this key (insertion, navigation, …). */
-    preventDefault(): void;
-    /** Stop further subscribers from receiving this key. */
-    stopPropagation(): void;
-    /** Underlying DOM event — for advanced needs (`isComposing`, repeat, …). */
-    originalEvent: KeyboardEvent;
-}
-/**
- * A registered command — a named, callable unit of editor work that
- * plugins coordinate around. Same definition gets reached by a
- * keyboard shortcut, a toolbar click, a programmatic call from an
- * agent, or an MCP request.
- *
- * The `run` function is the one place the work happens. `isActive` and
- * `isAvailable` let UI plugins paint toggle / disabled state without
- * understanding what the command actually does.
- */
-export interface CommandDefinition<Args = void> {
-    /** Dotted, namespaced — `"mark.toggle.bold"`, `"section.insertBreak"`, … */
-    name: string;
-    /** Short human label for tooltips / command palettes. */
-    title?: string;
-    /** Perform the work. Should be idempotent w.r.t. selection (a second
-     *  invocation on an already-bold selection clears bold, etc.). */
-    run: (args: Args) => void;
-    /** True when the command represents an active state (mark already on,
-     *  block is already a heading, …). Drives toolbar `is-active`. */
-    isActive?: () => boolean;
-    /** False when the command can't run (e.g. selection is wrong shape).
-     *  Defaults to true. Drives toolbar `disabled`. */
-    isAvailable?: () => boolean;
-}
-/** Snapshot of one registered command — what `commands.list()` returns. */
-export interface CommandSnapshot {
-    name: string;
-    title: string;
-    isActive: boolean;
-    isAvailable: boolean;
-}
-/**
- * Registry every plugin uses to talk to every other plugin. The
- * editor owns it; plugins register commands on attach and unregister
- * on detach. Keyboard plugins, toolbar plugins, and a future MCP
- * adapter all share the same dispatch path: `editor.commands.execute(name)`.
- */
-export interface CommandBus {
-    /** Register a command. Returns an unsubscribe that removes it. */
-    register<Args = void>(def: CommandDefinition<Args>): () => void;
-    /** Run a registered command. No-op (with a warning) if unknown. */
-    execute<Args = void>(name: string, args?: Args): void;
-    /** Snapshot every registered command — for command palettes,
-     *  toolbars rendering toggle states, accessibility audits. */
-    list(): CommandSnapshot[];
-    /** Whether the named command is currently registered. */
-    has(name: string): boolean;
-}
-export interface EditorOptions {
-    initialDocument?: SobreeDocument;
-    changeDebounceMs?: number;
-    /**
-     * Elements whose children are editable blocks, in document order. Called
-     * fresh each time — the list can grow/shrink (e.g. during pagination).
-     */
-    contentHosts?: () => HTMLElement[];
-    /**
-     * Y.Doc backing the document. Optional — if absent, the editor creates
-     * one internally. Embedders pass their own when they need to attach
-     * a provider (`y-websocket`, `y-indexeddb`, `y-webrtc`, …) for
-     * persistence or collaboration.
-     *
-     * When supplied, the editor checks whether the Y.Doc already has body
-     * content. If empty, it seeds from `initialDocument`. If non-empty
-     * (Phase 2+: a peer joined an active room), the existing Y.Doc state
-     * wins and `initialDocument` is ignored. See `editor.ydoc` for the
-     * public escape hatch.
-     */
-    ydoc?: Y.Doc;
-    /**
-     * Optional content-hashed `BlobStore` for binary parts (images, fonts).
-     *
-     * Without one (default): bytes live inline in the Y.Doc's `parts`
-     * Y.Map and replicate to every peer through Y updates. Fine for
-     * small docs.
-     *
-     * With one (Phase 3.2+): the editor hashes binary parts, uploads
-     * the bytes to the store, and writes only the hash into the Y.Doc's
-     * `partRefs` Y.Map. Y updates stay small regardless of image size.
-     * The editor maintains a local `BlobCache` that synchronously serves
-     * already-fetched bytes to the renderer; `editor.ensurePartsLoaded()`
-     * is the async hook for explicit pre-fetching (e.g. before
-     * `toDocx()`).
-     *
-     * See `@sobree/core/blob` for the interface + reference impls
-     * (`inMemoryBlobStore`, `fetchBlobStore`).
-     */
-    blobStore?: BlobStore;
-    /**
-     * Initial track-changes mode. When omitted, the editor starts in
-     * direct-edit mode (`{ enabled: false }`) and embedders can flip it
-     * later via `editor.setTrackChanges`. See `TrackChangesState`.
-     */
-    trackChanges?: TrackChangesState;
-}
+export type { ApiRangeType, BlockInfo, ChangePayload, CommandBus, CommandDefinition, CommandSnapshot, EditorEvent, EditorEventPayload, EditorOptions, KeyDownPayload, OutlineItem, ParagraphPropertiesPatch, RevisionSpan, SelectionPayload, TrackChangesState, Unsubscribe, WrapTag, };
+export type { CellRef, InsertAt, InsertColumnOpts, InsertRowOpts, MergeCellsOpts, } from './types';
 export { runsLength } from '../doc/runs';
 export type { RunPropertiesPatch };
 /**
@@ -349,7 +103,9 @@ export declare class Editor {
     private dragOverListener;
     private dropListener;
     private revision;
-    private readonly listeners;
+    /** The editor's observable event surface (change / selection / keydown
+     *  / track-changes-change). See `./events.ts`. */
+    private readonly events;
     /**
      * Authoring mode for revisions. Off by default — mutations apply
      * plainly. On, `insertRun` / `deleteRange` route through
@@ -358,26 +114,13 @@ export declare class Editor {
      */
     private trackChanges;
     /**
-     * One-shot warning set for tracked-mode beforeinput types we don't
-     * (yet) route through the API — paragraph splits, paste, IME, etc.
-     * We let the browser handle them untracked rather than swallowing
-     * the keystroke, but log the inputType the first time we see it so
-     * the gap is visible during development.
+     * Track-changes authoring input handler — routes tracked-mode
+     * `beforeinput` / IME composition / paste through the typed API so
+     * resulting runs carry revision markers. Holds the IME composition
+     * snapshot + warn-once state. Built in the constructor. See
+     * `ops/trackedInput`.
      */
-    private trackedInputWarned;
-    /**
-     * Active IME composition state (`compositionstart` → `compositionend`).
-     * `null` outside composition or in non-tracked mode.
-     *
-     * Snapshot-then-restore is the only practical way to track IME-typed
-     * text: we can't intercept `beforeinput` during composition without
-     * breaking input methods on most platforms, so we let the browser
-     * mutate the DOM natively during composition, then on `compositionend`
-     * we roll back to the pre-composition AST and re-insert the final
-     * composed string (`event.data`) through `insertRun` — which stamps
-     * the `revision: ins` marker per `TrackChangesState`.
-     */
-    private composition;
+    private trackedInput;
     private compositionStartListener;
     private compositionEndListener;
     /** Document-level `selectionchange` listener. Funnels every cursor
@@ -408,7 +151,20 @@ export declare class Editor {
      * and `emitChangeNow` sync only when this flag is set.
      */
     private domDirty;
+    /**
+     * Kernel seam handed to the behaviour modules (`ops/*`, `query`). Built
+     * once in the constructor; closes over this instance's privates so the
+     * `commit` pipeline / lock checks stay private to the class. See
+     * `./context.ts`.
+     */
+    private readonly ctx;
     constructor(host: HTMLElement, options?: EditorOptions);
+    /**
+     * Assemble the {@link EditorContext} the behaviour modules operate on.
+     * Closes over `this` so the kernel methods (`commit`, `checkRefs`, …)
+     * stay private to the class while modules get a curated surface.
+     */
+    private buildContext;
     /**
      * Re-project the Y.Doc into `this.doc`, sync the BlockRegistry to
      * the projected ids, re-render the DOM, and fire `change`. Called
@@ -421,21 +177,11 @@ export declare class Editor {
      * is owned by the caller. Missing hashes stay out of `rawParts`;
      * the renderer handles missing parts gracefully (placeholder).
      */
-    private resolveCachedPartRefsInto;
     /**
-     * Callback fired by the BlobCache when a background fetch lands.
-     * Walks `lastPartRefs` to find which paths reference this hash,
-     * patches `this.doc.rawParts`, and re-renders so the user sees
-     * the part appear.
-     */
-    private onBlobResolved;
-    /**
-     * Wait for every currently-referenced binary part to be available
-     * in the local cache. Useful before `toDocx()` so the exported
-     * file contains all images / fonts.
-     *
-     * Returns a resolved Promise immediately when no `blobStore` is
-     * configured (today's default — bytes are always inline).
+     * Wait for every currently-referenced binary part to be available in
+     * the local cache. Useful before `toDocx()` so the exported file
+     * contains all images / fonts. Resolves immediately when no
+     * `blobStore` is configured (bytes are always inline).
      */
     ensurePartsLoaded(): Promise<void>;
     /**
@@ -455,6 +201,20 @@ export declare class Editor {
      * operations that Y.UndoManager turns into a single stack item.
      */
     private applyDocument;
+    /**
+     * Re-render the current `doc` into the content hosts. Syncs
+     * `@font-face` registrations BEFORE rendering so newly-embedded fonts
+     * are available to the render pass. No selection restore, no change
+     * emit — callers sequence those.
+     */
+    private renderCurrent;
+    /**
+     * Soft-revert to a doc `snapshot` and re-render. Resets the
+     * serialised-block cache + dom-dirty flag; no registry reset, mirror, or
+     * change emit. Used to undo native IME mutations before a tracked
+     * re-insert (see `ops/trackedInput`).
+     */
+    private restoreSnapshot;
     /**
      * Drop entries from `rawParts` that nothing in the AST references.
      * Useful after deleting images (or font embeds — Phase 3) to keep the
@@ -469,15 +229,10 @@ export declare class Editor {
         pruned: string[];
     };
     /**
-     * Embed a TTF/OTF font into the document. Thin wrapper around
-     * `embedFontIntoDoc()` from the fonts module — handles the
-     * setDocument round so the renderer + `@font-face` registry pick
-     * up the new face automatically.
-     *
-     * Refuses (with a warning) when the font's OS/2 `fsType` field
-     * marks it as restricted, unless `opts.allowRestricted` is true.
-     * Pass any subset of {regular, bold, italic, boldItalic}; missing
-     * faces are simply not embedded.
+     * Embed a TTF/OTF font into the document. Refuses (with a warning)
+     * restricted fonts unless `opts.allowRestricted` is true. Pass any
+     * subset of {regular, bold, italic, boldItalic}; missing faces are
+     * simply not embedded.
      */
     embedFont(name: string, faces: EmbedFontFaces, opts?: EmbedFontOptions): {
         warnings: string[];
@@ -502,40 +257,19 @@ export declare class Editor {
     /** Replace the block at `target`'s index with `block`. */
     replaceBlock(target: BlockRef, block: Block): EditResult<BlockRef>;
     /**
-     * Insert `block` before the target block. Returns the new ref.
-     *
-     * In track-changes mode (see `setTrackChanges`), if `block` is a
-     * paragraph it gets stamped with `revision: { type: "ins", author }`
-     * on its properties — the same paragraph-mark semantics as
-     * `splitBlock`. Non-paragraph blocks (table, section_break) don't
-     * carry the marker in v1 and insert plain.
+     * Insert `block` before the target block. Returns the new ref. In
+     * track-changes mode a paragraph block is stamped `revision: ins`;
+     * non-paragraph blocks insert plain.
      */
     insertBlockBefore(target: BlockRef, block: Block): EditResult<BlockRef>;
-    /**
-     * Insert `block` after the target block. Returns the new ref.
-     * Tracked-mode behaviour matches `insertBlockBefore`.
-     */
+    /** Insert `block` after the target block. Returns the new ref. */
     insertBlockAfter(target: BlockRef, block: Block): EditResult<BlockRef>;
     /**
-     * Delete the target block.
-     *
-     * In track-changes mode, paragraph blocks aren't removed — their
-     * `properties.revision` is stamped `del` (the renderer shows the
-     * paragraph mark with a strikethrough ¶ glyph; the body text stays
-     * visible). If the paragraph carries the *current author's* pending
-     * `ins` marker (a paragraph the user themselves just created), the
-     * block is removed outright — cancelling an un-committed insert,
-     * matching the inline `deleteRange` semantics. Non-paragraph blocks
-     * (tables, section breaks) bypass tracking in v1 — they remove plainly.
+     * Delete the target block. In track-changes mode paragraph blocks are
+     * stamped `del` (kept visible) rather than removed; tables / section
+     * breaks remove plainly.
      */
     deleteBlock(target: BlockRef): EditResult<void>;
-    /**
-     * Stamp `revision: ins` on a paragraph block if tracked mode is on
-     * and the block doesn't already carry one. Helper for
-     * `insertBlockBefore` / `insertBlockAfter`. Non-paragraph blocks
-     * pass through unchanged.
-     */
-    private stampInsertedBlockIfTracked;
     /** Merge a patch into each target paragraph's properties. */
     applyBlockProperties(targets: BlockRef[], patch: ParagraphPropertiesPatch): EditResult<void>;
     /**
@@ -557,48 +291,21 @@ export declare class Editor {
         expect?: Record<string, number>;
     }): EditResult<void>;
     /**
-     * Insert a run at `at`. Splits the run list at the offset.
-     *
-     * In track-changes mode (see `setTrackChanges`), the run is stamped
-     * with `revision: { type: "ins", author }` before insertion (unless
-     * it already carries a `revision` — caller-provided revisions are
-     * never overwritten).
+     * Insert a run at `at`. In track-changes mode the run is stamped
+     * `revision: ins` unless it already carries one.
      */
     insertRun(at: InlinePosition, run: InlineRun): EditResult<BlockRef>;
     /**
-     * Split a paragraph at `at`. The runs before the offset stay on the
-     * original block; the runs after move into a fresh paragraph that's
-     * inserted immediately after. The new block inherits the original
-     * paragraph's properties (alignment, style, indent, …) so the visual
-     * shape of the split is what the user expects from pressing Enter.
-     *
-     * In track-changes mode (see `setTrackChanges`), the new paragraph's
-     * `properties.revision` is stamped `{ type: "ins", author }` — the
-     * "this paragraph break is a tracked insert" marker. The original
-     * paragraph is left clean; only the *new* paragraph carries the mark,
-     * mirroring how Word stores `<w:rPr><w:ins/></w:rPr>` inside `<w:pPr>`.
-     *
-     * `at.offset` is clamped to `[0, block-length]`. A split at offset 0
-     * inserts an empty paragraph *before* the cursor; a split at the
-     * block's full length inserts an empty paragraph *after*.
-     *
-     * Returns the ref of the *new* (second) block — callers typically
-     * place the caret at its offset 0.
+     * Split a paragraph at `at`; runs after the offset move into a new
+     * paragraph inserted after, inheriting the original's properties.
+     * Returns the new (second) block's ref. In track-changes mode the new
+     * paragraph is stamped `revision: ins`.
      */
     splitBlock(at: InlinePosition): EditResult<BlockRef>;
     /**
-     * Insert an image at `at`. The bytes are stored in `doc.rawParts` under
-     * a fresh `word/media/imageN.{ext}` path; a `DrawingRun` referencing
-     * that path is inserted at the position.
-     *
-     * When a `blobStore` is configured (Phase 3.2+), the bytes also
-     * migrate in the background: hashed, uploaded to the store, and a
-     * `partRefs[partPath] = hash` entry written to the Y.Doc. Once the
-     * migration lands, the Y.Doc's inline `parts[partPath]` is cleared —
-     * so the bytes ride the side-channel, not the Y update stream.
-     * The local renderer keeps reading `doc.rawParts[partPath]`
-     * throughout (the value is stable from the moment `insertImage`
-     * returns).
+     * Insert an image at `at`. Bytes are stored in `doc.rawParts` and a
+     * `DrawingRun` is inserted; with a `blobStore` configured the bytes
+     * migrate to the store in the background.
      */
     insertImage(at: InlinePosition, bytes: Uint8Array, opts: {
         mime: string;
@@ -630,20 +337,6 @@ export declare class Editor {
     deleteRange(range: ApiRange, opts?: {
         expect?: Record<string, number>;
     }): EditResult<void>;
-    /**
-     * Tracked cross-paragraph delete. Walks each paragraph in the range:
-     * stamps `del` on the affected runs (first-block tail / intermediate
-     * full / last-block head), and on every paragraph *after the first*
-     * stamps the paragraph-mark `del` so `acceptAllRevisions` later
-     * merges them all into the first block. Single commit.
-     */
-    private deleteRangeAcrossBlocksTracked;
-    /**
-     * Non-tracked cross-paragraph delete. Keeps the head of the first
-     * block + the tail of the last block, splices them into the first
-     * block as one paragraph, and removes everything in between.
-     */
-    private deleteRangeAcrossBlocksPlain;
     /**
      * Read the current track-changes mode. Defaults to `{ enabled: false }`
      * — the editor mutates the document plainly. See `setTrackChanges`.
@@ -663,110 +356,6 @@ export declare class Editor {
      * to a toolbar pill / mode badge.
      */
     setTrackChanges(state: TrackChangesState): void;
-    /**
-     * Route a tracked-mode `beforeinput` event through the typed API so
-     * the resulting runs carry revision markers. Returns `true` if the
-     * event was consumed (caller should `preventDefault`), `false` to
-     * let the browser handle it natively (untracked).
-     *
-     * **Handled inputTypes** (the 95% case — typing and deleting text):
-     *
-     *   - `insertText`, `insertReplacementText` — typed characters,
-     *     dictation / autocomplete replacements.
-     *   - `deleteContentBackward`, `deleteContentForward` — Backspace
-     *     and Delete keys, including over a selection.
-     *   - `deleteWordBackward`, `deleteWordForward` — Option-Backspace
-     *     style word deletions; the browser collapses to the right
-     *     selection range before firing, we just delete it.
-     *   - `deleteByCut` — Cmd-X. The clipboard side has already been
-     *     populated by the browser; we mark the source range deleted.
-     *
-     * **Unhandled** (return `false`, fall through, warn-once):
-     *
-     *   - `insertParagraph` / `insertLineBreak` — block split / soft
-     *     break. Word tracks these as `<w:ins>` on the paragraph mark;
-     *     the corresponding AST mutation (split-block as a tracked op)
-     *     hasn't landed yet.
-     *   - `insertFromPaste` — paste is handled at the `paste` event level
-     *     in `onPaste` (not here), where tracked-mode plain-text paste is
-     *     already routed through `insertRun` / `splitBlock`. Rich-paste
-     *     (HTML) in tracked mode falls back to plain text by design.
-     *   - `insertCompositionText` — handled separately via
-     *     `compositionstart` / `compositionend` listeners
-     *     (`handleCompositionStart` / `handleCompositionEnd`). We let the
-     *     IME render natively during composition, then on end we restore
-     *     the pre-composition AST and re-insert the final composed string
-     *     through this `insertRun` path.
-     *
-     * Falling through means the keystroke still works (no broken UX in
-     * tracked mode), it just doesn't get a revision marker. The console
-     * warning makes the gap visible.
-     *
-     * Caret restoration: after every routed mutation we set the model
-     * selection to where the caret would have ended up on the equivalent
-     * direct-edit operation. Because tracked-mode `deleteRange` leaves
-     * the runs in place (marked `del`), offsets don't shift — caret math
-     * is straightforward.
-     */
-    private handleTrackedInput;
-    /**
-     * Snapshot the pre-composition AST + caret so `handleCompositionEnd`
-     * can roll back the browser's native IME mutations and re-insert the
-     * final composed string through the tracked-mode `insertRun`. No-op
-     * when tracked mode is off — IME falls through to the browser as
-     * always (untracked, but functional).
-     */
-    private handleCompositionStart;
-    /**
-     * Commit a tracked IME composition. Restores the AST to its
-     * pre-composition snapshot, re-renders, then inserts `event.data`
-     * through `insertRun` at the captured caret — so the final composed
-     * string lands as a tracked `ins` instead of as plain text from the
-     * browser's native IME commit.
-     *
-     * Bails out (and clears state) if tracked mode was toggled off
-     * mid-composition or the snapshot is missing; the browser's native
-     * commit then stands as-is (untracked, but functional).
-     */
-    private handleCompositionEnd;
-    /**
-     * Resolve the position to insert at when the user types over the
-     * current selection. For a caret, that's the caret itself; for a
-     * range, we delete the range first (which in tracked mode marks the
-     * runs `del` but keeps them in place — so the `from` offset is still
-     * the right insertion point afterwards). Returns `null` if the
-     * selection spans blocks or the delete failed.
-     */
-    private markedRangeForReplace;
-    /**
-     * Range a Backspace-style key should delete. Range-selection wins
-     * if there is one (just delete the selection). Otherwise step one
-     * character left of the caret — at offset 0 we have nothing to do
-     * (and Word does nothing in that position too, in v1; cross-block
-     * backspace is a follow-up).
-     */
-    private rangeForBackwardDelete;
-    /** Forward-delete equivalent of `rangeForBackwardDelete`. */
-    private rangeForForwardDelete;
-    /** Re-lookup the block by id to get a fresh `BlockRef` (current version). */
-    private refreshedPosition;
-    /** Place the caret at `(blockId, offset)` using a fresh block ref. */
-    private placeCaret;
-    /**
-     * True when the current DOM selection's caret sits inside an `<ins>`,
-     * `<del>`, or `<span.sobree-revision-format>` wrapper — the markup
-     * the renderer emits for tracked revisions. Used by `beforeinput` in
-     * mode-off to detect when we have to take over the insert path: if
-     * we don't, the browser's contenteditable inserts the new character
-     * INSIDE the wrapper and the post-input DOM-sync stamps it with the
-     * wrapper's revision marker (an edit the user explicitly opted out
-     * of tracking).
-     *
-     * Returns `false` for a normal caret in plain text, in a `<strong>`
-     * / `<em>` / etc. — those wrappers *should* inherit (formatting),
-     * unlike revision wrappers which encode "edit history."
-     */
-    private caretInsideRevisionWrapper;
     /**
      * Accept the tracked changes inside `range`: insertions become
      * permanent (the revision marker is stripped, text kept), deletions
@@ -777,112 +366,38 @@ export declare class Editor {
     acceptRevision(range: ApiRange, opts?: {
         expect?: Record<string, number>;
     }): EditResult<void>;
-    /**
-     * Reject the tracked changes inside `range`: insertions are removed
-     * (the inserted text is dropped), deletions are restored (the
-     * revision marker is stripped, deleted text kept). The inverse of
-     * `acceptRevision`.
-     */
+    /** Reject the tracked changes inside `range`. Inverse of `acceptRevision`. */
     rejectRevision(range: ApiRange, opts?: {
         expect?: Record<string, number>;
     }): EditResult<void>;
-    /**
-     * Accept tracked format changes inside `range`: each text run with a
-     * `revisionFormat` snapshot drops the snapshot; the current
-     * `properties` stay. Runs without one pass through.
-     */
+    /** Accept tracked format changes inside `range` (drop the snapshot). */
     acceptFormatRevision(range: ApiRange, opts?: {
         expect?: Record<string, number>;
     }): EditResult<void>;
-    /**
-     * Reject tracked format changes inside `range`: each run reverts its
-     * `properties` to `revisionFormat.before`. Inverse of
-     * `acceptFormatRevision`.
-     */
+    /** Reject tracked format changes inside `range` (revert to `before`). */
     rejectFormatRevision(range: ApiRange, opts?: {
         expect?: Record<string, number>;
     }): EditResult<void>;
     /**
-     * Accept the paragraph-mark revision on `target`.
-     *
-     * Per the semantics in `ParagraphProperties.revision`'s docblock:
-     *   - `ins` → strip the marker; the paragraph break stays permanent.
-     *   - `del` → merge this paragraph's content into the *previous*
-     *     paragraph; the paragraph break is consumed.
-     *
-     * Returns `range-empty`-coded failure if the block has no paragraph
-     * revision, and `invalid-state` if a `del` accept would require
-     * merging with a non-paragraph (table, section break) — those merges
-     * aren't well-defined yet.
+     * Accept the paragraph-mark revision on `target`. `ins` strips the
+     * marker (the break stays); `del` merges this paragraph into the
+     * previous one.
      */
     acceptParagraphRevision(target: BlockRef): EditResult<void>;
     /**
-     * Reject the paragraph-mark revision on `target`.
-     *   - `ins` → merge this paragraph into the *previous* one (the split
-     *     introduced by the tracked Enter is undone).
-     *   - `del` → strip the marker; the paragraph break stays.
+     * Reject the paragraph-mark revision on `target`. `ins` undoes the
+     * split (merge into previous); `del` strips the marker.
      */
     rejectParagraphRevision(target: BlockRef): EditResult<void>;
     /**
-     * Concatenate `body[index]`'s runs onto the end of `body[index-1]`
-     * and remove `body[index]`. The previous block must be a paragraph;
-     * otherwise we bail with `invalid-state`. Used by accept/reject of
-     * paragraph-mark revisions where the decision means "this paragraph
-     * break should not exist".
-     */
-    private mergeWithPrevious;
-    /**
-     * Strip the `revision` marker from `body[index]`'s paragraph
-     * properties, leaving the block (and its content) in place.
-     * Fallback for merge-impossible cases — see `mergeWithPrevious`'s
-     * `index <= 0` branch and `applyAllRevisions`' second pass.
-     */
-    private stripParagraphMarker;
-    /**
-     * Flag `body[index]`'s paragraph break as a tracked deletion —
-     * stamp `properties.revision = { type: "del", author }`. Used by
-     * `handleTrackedInput` for the Backspace-at-start-of-paragraph
-     * keystroke.
-     *
-     * Two short-circuits:
-     *   - If the paragraph already carries the *same author's* pending
-     *     `ins` (the user is backspacing into a split they themselves
-     *     just made), drop the marker and merge into the previous
-     *     paragraph — cancelling an un-committed insert rather than
-     *     layering del on top of ins.
-     *   - If the paragraph carries some OTHER revision (peer's ins, an
-     *     existing del), leave it alone with a no-op success. The
-     *     reviewer should resolve those via accept/reject first.
-     */
-    private markParagraphBreakForDelete;
-    /**
-     * Enumerate every logical tracked change in the document.
-     *
-     * Consecutive revision-bearing runs by the same author coalesce into
-     * one `RevisionSpan` — so a delete-then-insert replacement is one
-     * span, and two unrelated insertions in a paragraph (separated by
-     * plain text) are two. Each span's `range` carries fresh, versioned
-     * `BlockRef`s, ready to hand to `acceptRevision` / `rejectRevision`.
-     *
-     * Call after each `change` — the ranges are positional, so re-query
-     * rather than caching across edits.
+     * Enumerate every logical tracked change. Consecutive same-author
+     * revision runs coalesce into one `RevisionSpan` with fresh versioned
+     * refs. Re-query after each `change`.
      */
     getRevisions(): RevisionSpan[];
     /**
-     * Walk one paragraph and append its revision spans to `out`. Used by
-     * `getRevisions` for both top-level paragraphs (where `ref` is the
-     * paragraph's own BlockRef) and for paragraphs inside table cells
-     * (where `ref` is the *containing table's* BlockRef as a sentinel —
-     * cell paragraphs don't have their own registry entry yet).
-     *
-     * Emits the same three-level span shape as the inline walker:
-     * paragraph-mark first, then coalesced inline ins/del spans, then
-     * coalesced format-change spans.
-     */
-    private collectParagraphRevisions;
-    /**
-     * Accept every tracked change in the document. With `opts.author`,
-     * accept only that author's changes. One commit for the whole sweep.
+     * Accept every tracked change in the document (optionally filtered by
+     * `opts.author`). One commit for the whole sweep.
      */
     acceptAllRevisions(opts?: {
         author?: string;
@@ -891,21 +406,10 @@ export declare class Editor {
     rejectAllRevisions(opts?: {
         author?: string;
     }): EditResult<void>;
-    private applyAllRevisions;
-    /**
-     * Walk a table's cell paragraphs and apply the accept/reject
-     * decision to inline + format + paragraph-mark revisions inside.
-     * Returns `{ next, changed }` so the caller knows whether to bump
-     * the table block. Paragraph-mark del within a cell falls back to
-     * strip-the-marker rather than attempting a cross-cell-paragraph
-     * merge — that structural edit is out of v1 scope for tables.
-     */
-    private sweepTableCellRevisions;
     /** Mark comment `id` resolved (`Comment.done = true`). */
     resolveComment(id: number): EditResult<void>;
     /** Re-open a resolved comment `id` (`Comment.done = false`). */
     reopenComment(id: number): EditResult<void>;
-    private setCommentDone;
     setBlockPropertiesAtSelection(patch: ParagraphPropertiesPatch): EditResult<void>;
     setRunPropertiesAtSelection(patch: RunPropertiesPatch): EditResult<void>;
     wrapSelection(tag: WrapTag): EditResult<void>;
@@ -917,8 +421,8 @@ export declare class Editor {
     }): EditResult<BlockRef>;
     /**
      * Unwrap span ancestors intersecting the selection, up to the block.
-     * Best-effort DOM-level cleanup — preserves the current in-place UX
-     * without re-rendering.
+     * Best-effort DOM-level cleanup — preserves the in-place UX without a
+     * re-render.
      */
     clearInlineFormattingAtSelection(): void;
     on<E extends EditorEvent>(event: E, cb: (p: EditorEventPayload[E]) => void): Unsubscribe;
@@ -938,12 +442,6 @@ export declare class Editor {
     private blockIdsArray;
     private checkRefs;
     private checkRange;
-    /**
-     * Apply a runs transform to the runs covered by `range`. Returns
-     * `EditResult<void>`. Handles both single- and multi-block ranges.
-     * Assumes locks have already been checked.
-     */
-    private mutateRunsInRange;
     /**
      * Apply a mutation to `this.doc`, update the registry, re-render, fire
      * change. Returns the affected refs (post-bump).
@@ -990,27 +488,6 @@ export declare class Editor {
      * driven mutations (already rendered) from remote ones (need re-render).
      */
     private mirrorToYDoc;
-    /**
-     * Returns the set of part paths that mirror should NOT write
-     * inline — they're (or will soon be) tracked via the partRefs
-     * Y.Map instead. Returns `undefined` when there's nothing to skip
-     * (the common no-BlobStore case) so the mirror takes its
-     * fastest path.
-     */
-    private computePartPathSkipSet;
-    /**
-     * Background migrate inline part bytes into the BlobStore. Called
-     * by mutators (`insertImage`, `embedFont`) when a `BlobStore` is
-     * configured. The local `doc.rawParts` keeps its inline copy so
-     * the renderer stays synchronous; the Y.Doc gets a `partRefs`
-     * entry referencing the BlobStore content hash, and any stale
-     * `parts` entry is deleted.
-     *
-     * Robust against errors: an upload failure logs and leaves the
-     * path in the pending set so a future call can retry. The local
-     * renderer is unaffected (bytes are still in `doc.rawParts`).
-     */
-    private migratePartToBlobStore;
     /**
      * Compose the current selection into a {@link SelectionPayload} and
      * dispatch to subscribers. Called from the document-level
@@ -1018,61 +495,6 @@ export declare class Editor {
      * even when no subscribers exist (the early-return keeps it cheap).
      */
     private fireSelection;
-    /**
-     * Normalise a DOM `KeyboardEvent` into a {@link KeyDownPayload} and
-     * dispatch to subscribers in registration order. Subscribers can
-     * `preventDefault()` (browser default) and / or `stopPropagation()`
-     * (further subscribers). The editor itself binds no shortcuts —
-     * everything goes through plugins.
-     */
     private fireKeyDown;
-    private summariseBlock;
-    private onPaste;
-    /**
-     * Insert `text` at the current selection in track-changes mode, with
-     * each `\n` becoming a `splitBlock`. Used by `onPaste` for plain-text
-     * paste; could be reused for tracked drop (a follow-up). Splits the
-     * line list once up-front and walks it so each insertRun lands at the
-     * caret of the *current* paragraph (which may be a fresh one from a
-     * preceding splitBlock).
-     */
-    private pasteTrackedText;
-    private onDragOver;
-    private onDrop;
-    private insertImageFromFile;
-}
-/**
- * Read and write the caret / selection in model terms. Lives on
- * `editor.selection`. Wraps `window.getSelection()` so callers never
- * touch the DOM directly.
- */
-export declare class EditorSelection {
-    private readonly editor;
-    constructor(editor: Editor);
-    /** Current selection as a model `Selection`. Returns `null` when focus is outside. */
-    get(): Selection;
-    /** Apply a model selection to the DOM. */
-    set(sel: Selection): boolean;
-    /** Shortcut: current selection as a `Range`, or `null` when collapsed/absent. */
-    currentRange(): ApiRange | null;
-    /** Shortcut: the caret position (collapses a range to its `from`). */
-    currentCaret(): InlinePosition | null;
-    /** Shortcut: ref of the block containing the caret. */
-    currentBlock(): BlockRef | null;
-    /** Legacy: current block index (for code still using indices). */
-    currentBlockIndex(): number | null;
-}
-/**
- * Default {@link CommandBus} implementation. Plain in-memory map; no
- * editor coupling beyond the closure plugins use when registering.
- * Replacing it would mean swapping a field on Editor — the rest of
- * the surface stays the same.
- */
-export declare class EditorCommands implements CommandBus {
-    private readonly commands;
-    register<Args = void>(def: CommandDefinition<Args>): () => void;
-    execute<Args = void>(name: string, args?: Args): void;
-    list(): CommandSnapshot[];
-    has(name: string): boolean;
 }
 export { countBlocks };