edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/edytor-doc.d.ts

@@ -1,10 +1,10 @@
-import type { EngineApi, EngineDoc, YDoc, YUndoManager } from './engine-api.js';
+import type { EngineApi, EngineDoc, YDoc } from './engine-api.js';
 import { SCHEMA } from './schema.js';
-import { type BlockId, type BlockSpec, type Destination } from './placement/model.js';
+import { bindModel, type BlockId } from './placement/model.js';
+import { bindText } from './text/model.js';
 import { type RunView } from './text/runs.js';
-import { type DocBlock } from './nodes.js';
 import { type BlockAttribution } from './attribution/block.js';
-import { type JSONBlock, type JSONDoc } from '../utils/json.js';
+import type { JSONBlock, JSONDoc } from '../utils/json.js';
 import { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
 import type { EngineNode } from './engine-api.js';
 import type { ContentItem, InlineSpec, ModelView, SplitTail } from './placement/model.js';
@@ -17,20 +17,255 @@ export { SCHEMA };
 export { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
 export { UnsupportedDocError, type SchemaProblem } from './doc/gate.js';
 export { SEED_ORIGIN } from './doc/seed.js';
-export { EdytorDocDisposedError, lineageDepthOf } from './doc/funnel.js';
+export { EdytorDocDisposedError } from './doc/funnel.js';
 export { DEFAULT_HISTORY_LIMIT } from './doc/history.js';
 export type { AnchorAffinity, BlockRole, DataTarget, DocAnchor, DocChange, EdytorDocConfig, OpResult, OrderPolicy, Plan, PlanEffect, PlanStep, Prepared, TextRange };
 export type EdytorDoc = ReturnType<EdytorDocBinding['create']>;
+/** A facade as the editor reads it: every member but the public binding's engine layers. */
+export type DocFacade = Omit<EdytorDoc, 'model' | 'text'>;
 export type EdytorDocBinding = ReturnType<typeof bindEdytorDoc>;
+export type DocModelBinding = ReturnType<typeof bindDocModel>;
+/**
+ * The engine layers a facade lists as `model` and `text`: the public
+ * binding's ({@link bindDocModel}); an editor's facade lists none, so its
+ * graph holds neither object.
+ */
+type Layers = {
+    model: ReturnType<typeof bindModel> | undefined;
+    text: ReturnType<typeof bindText> | undefined;
+};
+/**
+ * The per-doc facade factory over the engine `Y` (the editor's documents
+ * use it directly; {@link bindDocModel} is the public binding around it).
+ */
+export declare const docFacade: <L extends Layers>(Y: EngineApi, layers: L) => (doc: EngineDoc, config?: EdytorDocConfig) => {
+    /** Every op prepared: pure, a plan of named steps + its effect, or `refused`. */
+    prepare: {
+        insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView) => Prepared;
+        deleteRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView) => Prepared;
+        replaceRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView) => Prepared;
+        insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | JSONBlock)[]) => Prepared;
+        moveBlocks: (ids: readonly BlockId[], dest: import("./index.js").Destination) => Prepared;
+        /**
+         * Move `id` to the last position under `parent` — under a container
+         * it is no item of, under its last item (`nestParent`: Tab after a list).
+         */
+        nestBlock: (id: BlockId, parent: BlockId) => Prepared;
+        unNestBlock: (id: BlockId) => Prepared;
+        unNestBlocks: (ids: readonly BlockId[]) => Prepared;
+        liftOut: (id: BlockId, kind: string, { keep, after }?: {
+            keep?: boolean;
+            after?: readonly import("./index.js").BlockSpec[];
+        }) => Prepared;
+        placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
+        wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
+        splitBlock: (id: BlockId, offset: number, newId: BlockId, tail?: SplitTail) => Prepared;
+        mergeBlocks: (fromId: BlockId, intoId: BlockId) => Prepared;
+        mergeBackward: (id: BlockId) => Prepared;
+        mergeForward: (id: BlockId) => Prepared;
+        deleteBlock: (id: BlockId, opts?: {
+            keepChildren?: boolean;
+        }) => Prepared;
+        setBlock: (id: BlockId, value: {
+            type?: string;
+            data?: Record<string, unknown>;
+            content?: (ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
+            children?: (import("./index.js").BlockSpec | JSONBlock)[];
+        }) => Prepared;
+        setBlockType: (id: BlockId, type: string) => Prepared;
+        patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
+        duplicateBlock: (id: BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => Prepared;
+        insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
+        deleteText: (id: BlockId, offset: number, length: number) => Prepared;
+        formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
+        clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
+        insertInline: (id: BlockId, offset: number, atom: import("./doc/content.js").NewInline) => Prepared;
+        removeInline: (id: BlockId, inlineId: string) => Prepared;
+        /** Delete a block selection — one plan; only the members leave (`deleteBlocks` above). */
+        deleteBlocks: (ids: readonly BlockId[]) => Prepared;
+    };
+    /** Write a prepared plan exactly (refusals pass through). */
+    apply: (p: Prepared) => OpResult;
+    compose: (...parts: Prepared[]) => Prepared;
+    transact: <R>(fn: () => R, origin?: unknown) => R;
+    model: L["model"];
+    text: L["text"];
+    runsView: RunView;
+    version: number;
+    insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView | undefined) => OpResult;
+    deleteRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => OpResult;
+    replaceRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => OpResult;
+    insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | JSONBlock)[]) => OpResult;
+    moveBlocks: (ids: readonly string[], dest: import("./index.js").Destination) => OpResult;
+    nestBlock: (id: string, parent: string) => OpResult;
+    unNestBlock: (id: string) => OpResult;
+    unNestBlocks: (ids: readonly string[]) => OpResult;
+    liftOut: (id: string, kind: string, args_2?: {
+        keep?: boolean;
+        after?: readonly import("./index.js").BlockSpec[];
+    } | undefined) => OpResult;
+    placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => OpResult;
+    wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => OpResult;
+    splitBlock: (id: string, offset: number, newId: string, tail?: SplitTail | undefined) => OpResult;
+    mergeBlocks: (fromId: string, intoId: string) => OpResult;
+    mergeBackward: (id: string) => OpResult;
+    mergeForward: (id: string) => OpResult;
+    deleteBlock: (id: string, opts?: {
+        keepChildren?: boolean;
+    } | undefined) => OpResult;
+    setBlock: (id: string, value: {
+        type?: string;
+        data?: Record<string, unknown>;
+        content?: (ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
+        children?: (import("./index.js").BlockSpec | JSONBlock)[];
+    }) => OpResult;
+    setBlockType: (id: string, type: string) => OpResult;
+    patchData: (target: DataTarget, patches: readonly DataPatch[]) => OpResult;
+    duplicateBlock: (id: string, freshId?: ((oldId: string, kind: "block" | "inline") => string) | undefined) => OpResult;
+    insertText: (id: string, offset: number, text: string, marks?: Record<string, unknown> | undefined) => OpResult;
+    deleteText: (id: string, offset: number, length: number) => OpResult;
+    formatRange: (id: string, offset: number, length: number, marks: Record<string, unknown>) => OpResult;
+    clearMarks: (id: string, offset: number, length: number) => OpResult;
+    insertInline: (id: string, offset: number, atom: import("./doc/content.js").NewInline) => OpResult;
+    removeInline: (id: string, inlineId: string) => OpResult;
+    deleteBlocks: (ids: readonly string[]) => OpResult;
+    init: (opts?: Parameters<(doc: EngineDoc, opts?: {
+        content?: import("./index.js").BlockSpec[];
+        defaultType?: string;
+    }) => void>[1]) => void;
+    /** Apply the deterministic seed of `value` and the document's `data` — the document's seed decision. */
+    seed: (value: JSONBlock[], data?: JsonObj) => void;
+    isInitialized: () => boolean;
+    /** Replicated `meta.v` schema version (the module-level read, bound). */
+    schemaVersion: () => number | undefined;
+    /**
+     * The schema gate for this doc — throws {@link SchemaMismatchError}
+     * on unversioned-content or unsupported-version state. Consumers
+     * (`Edytor.sync()`, packed consumers) call it before trusting
+     * a synced doc.
+     */
+    checkSchema: () => import("./edytor-doc.js").SchemaProblem | null;
+    assertSchema: () => void;
+    dispose: () => void;
+    createUndoManager: (options?: import("./doc/history.js").HistoryOptions) => import("./doc/history.js").UndoManager;
+    project: () => import("./index.js").ProjectedDoc;
+    toJSON: () => JSONDoc;
+    blockJSON: (id: string) => JSONBlock;
+    childrenIds: (id: string | null) => string[];
+    /** Visible children of `parent` with their ranks, in `(rank, id)` order. */
+    childSlots: (parent: BlockId | null) => import("./placement/model.js").ChildSlot[];
+    slotOf: (id: string) => {
+        parent: BlockId | null;
+        rank: string;
+    } | null;
+    positionOf: (id: string) => import("./index.js").Destination | null;
+    pathOf: (id: string) => number[] | null;
+    parentOf: (id: string) => string | null;
+    ancestorsOf: (id: string) => string[];
+    listBlockIds: () => string[];
+    blockText: (id: string) => string | null;
+    blockTypeOf: (id: string) => string | undefined;
+    blockDataOf: (id: string) => Record<string, unknown> | undefined;
+    docData: () => JsonObj;
+    dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+    dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+        data: {
+            [x: string]: unknown;
+        };
+        ids: (path: readonly string[]) => string[];
+    } | null;
+    /**
+     * Compact per-block attribution (`{createdBy, contributors,
+     * lastChangedBy}`), or `undefined` for unauthored/system blocks.
+     * O(1) per call; live-replicated (remote values read the same).
+     */
+    blockAttribution: (id: string) => BlockAttribution | undefined;
+    crdtId: (id: string) => string | null;
+    resolveBlock: (id: string) => EngineNode | null;
+    displayLength: (id: string) => number;
+    contentItems: (id: string) => ContentItem[];
+    hasBlock: (id: string) => boolean;
+    isVisibleBlock: (id: string) => boolean;
+    order: () => readonly BlockId[];
+    compare: (a: BlockId, b: BlockId) => number;
+    next: (id: string, policy?: OrderPolicy | undefined) => string | null;
+    previous: (id: string, policy?: OrderPolicy | undefined) => string | null;
+    anchorAt: (id: string, offset: number, affinity?: AnchorAffinity | undefined) => DocAnchor | null;
+    resolveAnchor: (anchor: DocAnchor) => {
+        blockId: BlockId;
+        offset: number;
+    } | null;
+    followUndo: (anchor: DocAnchor) => DocAnchor;
+    /** Re-read the roles after `roleOf` answers differently (roles adopted later). */
+    rolesChanged: () => void;
+    isVoid: (id: string) => boolean;
+    isIsland: (id: string) => boolean;
+    isLines: (id: string) => boolean;
+    /** `id` is a layout: its kind's role says `layout` (`layout.*`). */
+    isLayout: (id: string) => boolean;
+    /** `id` is a layout item: of its layout's item kind, directly in it (a column). */
+    isLayoutItem: (id: string) => boolean;
+    /** The block a beside placement at `id` stands beside (`placeBeside`'s resolution). */
+    besideAt: (id: BlockId, kind?: string) => string;
+    islandOf: (id: string) => string | null;
+    /** `id` is a table: its kind's role says `table` (`table.*`). */
+    isTable: (id: string) => boolean;
+    /** `id` is a table's row: of its table's row kind, directly in it. */
+    isTableRow: (id: string) => boolean;
+    /** `id` is a table's cell: of its row's cell kind, directly in a row of a table. */
+    isTableCell: (id: string) => boolean;
+    /** The table `id` is, or whose row or cell it is; `null` for any other block. */
+    tableOf: (id: string) => string | null;
+    /** The columns a table lists (`data.columns`), or `null` when it lists none. */
+    tableColumns: (id: string) => {
+        id: string;
+        width?: number;
+    }[] | null;
+    /**
+     * A table as a grid: its column ids and each shown row's cells by
+     * column, `null` where the row shows none (a padded cell, `table.pad`).
+     */
+    tableGrid: (id: string) => {
+        columns: string[];
+        rows: {
+            id: BlockId;
+            cells: (BlockId | null)[];
+        }[];
+    } | null;
+    insideIsland: (id: string) => boolean;
+    canPlace: (ids: readonly BlockId[], parent?: BlockId | null) => boolean;
+    canMerge: (from: BlockId, into: BlockId) => boolean;
+    /** May a block of `kind` sit directly under `parent`? The container rule (`fits`). */
+    fits: (parent: BlockId | null, kind: string) => boolean;
+    /** Where `ids` nest when nested into `parent` (Tab, a drop inside it): `nestParent`. */
+    nestParent: (ids: readonly BlockId[], parent: BlockId) => string;
+    /** Where a block of `kind` at `id`'s place lands, and the containers it leaves (`liftOut`). */
+    landingOf: (id: BlockId, kind: string, after?: boolean) => {
+        parent: string | null;
+        levels: string[];
+    };
+    defaultChild: (id: string | null) => string;
+    runs: (id: string) => readonly ContentRun[];
+    contentJSON: (id: string) => ({
+        text: string;
+        marks?: Record<string, unknown>;
+    } | {
+        id?: string;
+        type: string;
+        data?: unknown;
+    })[];
+    onChange: (cb: (change: DocChange) => void) => (() => void);
+};
 /**
  * Bind the assembled model to a concrete engine surface. `Y` must be the
  * vendored v14 module — injected so this file type-checks structurally and
- * never imports vendor `.js` (see `engine-api.ts`).
+ * never imports vendor `.js` (see `engine-api.ts`). A document composes
+ * this binding; {@link bindEdytorDoc} adds the room's purge and restore.
  */
-export declare const bindEdytorDoc: (Y: EngineApi) => {
+export declare const bindDocModel: (Y: EngineApi) => {
     /** The schema manifest constants table. */
     SCHEMA: {
-        readonly version: 5;
+        readonly version: 6;
         readonly name: "edytor-doc";
         readonly roots: {
             readonly registry: "blocks";
@@ -41,15 +276,15 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             readonly schema: "schema";
         };
     };
-    SCHEMA_VERSION: 5;
+    SCHEMA_VERSION: 6;
     SCHEMA_NAME: "edytor-doc";
     META_KEY: "meta";
     /** Doc-level API (no facade needed). */
     init: (doc: EngineDoc, opts?: {
-        content?: BlockSpec[];
+        content?: import("./index.js").BlockSpec[];
         defaultType?: string;
     }) => void;
-    restore: (doc: EngineDoc, content: BlockSpec[]) => void;
+    restore: (doc: EngineDoc, content: import("./index.js").BlockSpec[]) => void;
     seed: (doc: EngineDoc, value?: JSONBlock[], defaultType?: string, data?: JsonObj) => void;
     isInitialized: (doc: EngineDoc) => boolean;
     schemaVersion: (doc: EngineDoc) => number | undefined;
@@ -64,18 +299,8 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView) => Prepared;
             deleteRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView) => Prepared;
             replaceRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView) => Prepared;
-            insertTableRow: (table: BlockId, index: number) => Prepared;
-            deleteTableRows: (rows: readonly BlockId[]) => Prepared;
-            insertTableColumn: (table: BlockId, index: number, width?: number) => Prepared;
-            deleteTableColumn: (table: BlockId, column: string | number) => Prepared;
-            moveTableColumn: (table: BlockId, column: string | number, to: number) => Prepared;
-            moveTableRows: (rows: readonly BlockId[], to: number) => Prepared;
-            fillTableCell: (row: BlockId, column: string | number) => Prepared;
-            insertBlocks: (dest: Destination, specs: readonly (BlockSpec | JSONBlock)[]) => Prepared;
-            insertBlock: (dest: Destination, spec: BlockSpec | JSONBlock) => Prepared;
-            moveBlocks: (ids: readonly BlockId[], dest: Destination) => Prepared;
-            /** Relocate `id` — identity preserved. */
-            moveBlock: (id: BlockId, dest: Destination) => Prepared;
+            insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | JSONBlock)[]) => Prepared;
+            moveBlocks: (ids: readonly BlockId[], dest: import("./index.js").Destination) => Prepared;
             /**
              * Move `id` to the last position under `parent` — under a container
              * it is no item of, under its last item (`nestParent`: Tab after a list).
@@ -85,7 +310,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             unNestBlocks: (ids: readonly BlockId[]) => Prepared;
             liftOut: (id: BlockId, kind: string, { keep, after }?: {
                 keep?: boolean;
-                after?: readonly BlockSpec[];
+                after?: readonly import("./index.js").BlockSpec[];
             }) => Prepared;
             placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
             wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
@@ -99,24 +324,18 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             setBlock: (id: BlockId, value: {
                 type?: string;
                 data?: Record<string, unknown>;
-                content?: ContentItem[];
-                children?: BlockSpec[];
+                content?: (ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
+                children?: (import("./index.js").BlockSpec | JSONBlock)[];
             }) => Prepared;
             setBlockType: (id: BlockId, type: string) => Prepared;
             patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
-            /** Replace a block's `data`: a patch of its root. */
-            setBlockData: (id: BlockId, data: Record<string, unknown>) => Prepared;
-            duplicateBlock: (id: BlockId, freshId: (oldId: string, kind: "block" | "inline") => string) => Prepared;
+            duplicateBlock: (id: BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => Prepared;
             insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
             deleteText: (id: BlockId, offset: number, length: number) => Prepared;
             formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
-            setMark: (id: BlockId, offset: number, length: number, name: string, value: unknown) => Prepared;
-            unsetMark: (id: BlockId, offset: number, length: number, name: string) => Prepared;
             clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
-            insertInline: (id: BlockId, offset: number, atom: InlineSpec) => Prepared;
+            insertInline: (id: BlockId, offset: number, atom: import("./doc/content.js").NewInline) => Prepared;
             removeInline: (id: BlockId, inlineId: string) => Prepared;
-            /** Replace an inline atom's `data`: a patch of its root. */
-            setInlineData: (id: BlockId, inlineId: string, data: Record<string, unknown>) => Prepared;
             /** Delete a block selection — one plan; only the members leave (`deleteBlocks` above). */
             deleteBlocks: (ids: readonly BlockId[]) => Prepared;
         };
@@ -134,7 +353,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             view: (doc: EngineDoc) => ModelView;
             resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
             childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
-            positionInView: (v: ModelView, id: BlockId) => Destination | null;
+            positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
             buildInline: (atom: InlineSpec) => EngineNode;
             isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
             ranksAt: (siblings: readonly {
@@ -143,21 +362,21 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
             withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                 inserts: {
-                    hasId(id: unknown): boolean;
+                    has(client: number, clock: number): boolean;
                 };
             }) => boolean;
-            materializeSpec: (doc: EngineDoc, sp: BlockSpec, parent: BlockId | null, rank: string) => void;
-            collides: (doc: EngineDoc, specs: readonly BlockSpec[]) => boolean;
+            materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
+            collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
             writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
             ownText: (doc: EngineDoc, id: BlockId) => {
                 from: unknown;
                 to: number;
             };
-            insertBlocks: (doc: EngineDoc, dest: Destination, specs: BlockSpec[]) => boolean;
-            insertBlock: (doc: EngineDoc, dest: Destination, spec: BlockSpec) => boolean;
-            restoreBlocks: (doc: EngineDoc, specs: BlockSpec[]) => void;
+            insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
+            insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
+            restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
             project: (doc: EngineDoc) => import("./index.js").ProjectedDoc;
-            positionOf: (doc: EngineDoc, id: BlockId) => Destination | null;
+            positionOf: (doc: EngineDoc, id: BlockId) => import("./index.js").Destination | null;
             listBlockIds: (doc: EngineDoc) => BlockId[];
             blockText: (doc: EngineDoc, id: BlockId) => string | null;
             crdtId: (doc: EngineDoc, id: BlockId) => string | null;
@@ -193,34 +412,17 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         };
         runsView: RunView;
         version: number;
-        /**
-         * The typed handle over one document block — the domain command
-         * surface (see `nodes.ts` for the contract: display offsets,
-         * transaction-aware reads, dead-safe). Handles are cached per
-         * id; a handle for an absent id reports `exists`/`live`/`visible`
-         * false and refuses ops.
-         */
-        block: (id: BlockId) => DocBlock;
         insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView | undefined) => OpResult;
         deleteRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => OpResult;
         replaceRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => OpResult;
-        insertTableRow: (table: string, index: number) => OpResult;
-        deleteTableRows: (rows: readonly string[]) => OpResult;
-        insertTableColumn: (table: string, index: number, width?: number | undefined) => OpResult;
-        deleteTableColumn: (table: string, column: string | number) => OpResult;
-        moveTableColumn: (table: string, column: string | number, to: number) => OpResult;
-        moveTableRows: (rows: readonly string[], to: number) => OpResult;
-        fillTableCell: (row: string, column: string | number) => OpResult;
-        insertBlocks: (dest: Destination, specs: readonly (JSONBlock | BlockSpec)[]) => OpResult;
-        insertBlock: (dest: Destination, spec: JSONBlock | BlockSpec) => OpResult;
-        moveBlocks: (ids: readonly string[], dest: Destination) => OpResult;
-        moveBlock: (id: string, dest: Destination) => OpResult;
+        insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | JSONBlock)[]) => OpResult;
+        moveBlocks: (ids: readonly string[], dest: import("./index.js").Destination) => OpResult;
         nestBlock: (id: string, parent: string) => OpResult;
         unNestBlock: (id: string) => OpResult;
         unNestBlocks: (ids: readonly string[]) => OpResult;
         liftOut: (id: string, kind: string, args_2?: {
             keep?: boolean;
-            after?: readonly BlockSpec[];
+            after?: readonly import("./index.js").BlockSpec[];
         } | undefined) => OpResult;
         placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => OpResult;
         wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => OpResult;
@@ -234,25 +436,21 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         setBlock: (id: string, value: {
             type?: string;
             data?: Record<string, unknown>;
-            content?: ContentItem[];
-            children?: BlockSpec[];
+            content?: (ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
+            children?: (import("./index.js").BlockSpec | JSONBlock)[];
         }) => OpResult;
         setBlockType: (id: string, type: string) => OpResult;
         patchData: (target: DataTarget, patches: readonly DataPatch[]) => OpResult;
-        setBlockData: (id: string, data: Record<string, unknown>) => OpResult;
-        duplicateBlock: (id: string, freshId: (oldId: string, kind: "block" | "inline") => string) => OpResult;
+        duplicateBlock: (id: string, freshId?: ((oldId: string, kind: "block" | "inline") => string) | undefined) => OpResult;
         insertText: (id: string, offset: number, text: string, marks?: Record<string, unknown> | undefined) => OpResult;
         deleteText: (id: string, offset: number, length: number) => OpResult;
         formatRange: (id: string, offset: number, length: number, marks: Record<string, unknown>) => OpResult;
-        setMark: (id: string, offset: number, length: number, name: string, value: unknown) => OpResult;
-        unsetMark: (id: string, offset: number, length: number, name: string) => OpResult;
         clearMarks: (id: string, offset: number, length: number) => OpResult;
-        insertInline: (id: string, offset: number, atom: InlineSpec) => OpResult;
+        insertInline: (id: string, offset: number, atom: import("./doc/content.js").NewInline) => OpResult;
         removeInline: (id: string, inlineId: string) => OpResult;
-        setInlineData: (id: string, inlineId: string, data: Record<string, unknown>) => OpResult;
         deleteBlocks: (ids: readonly string[]) => OpResult;
         init: (opts?: Parameters<(doc: EngineDoc, opts?: {
-            content?: BlockSpec[];
+            content?: import("./index.js").BlockSpec[];
             defaultType?: string;
         }) => void>[1]) => void;
         /** Apply the deterministic seed of `value` and the document's `data` — the document's seed decision. */
@@ -269,17 +467,413 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         checkSchema: () => import("./edytor-doc.js").SchemaProblem | null;
         assertSchema: () => void;
         dispose: () => void;
-        createUndoManager: (options?: ConstructorParameters<EngineApi["UndoManager"]>[1] & {
-            limit?: number;
-        }) => YUndoManager;
+        createUndoManager: (options?: import("./doc/history.js").HistoryOptions) => import("./doc/history.js").UndoManager;
+        project: () => import("./index.js").ProjectedDoc;
+        toJSON: () => JSONDoc;
+        blockJSON: (id: string) => JSONBlock;
+        childrenIds: (id: string | null) => string[];
+        /** Visible children of `parent` with their ranks, in `(rank, id)` order. */
+        childSlots: (parent: BlockId | null) => import("./placement/model.js").ChildSlot[];
+        slotOf: (id: string) => {
+            parent: BlockId | null;
+            rank: string;
+        } | null;
+        positionOf: (id: string) => import("./index.js").Destination | null;
+        pathOf: (id: string) => number[] | null;
+        parentOf: (id: string) => string | null;
+        ancestorsOf: (id: string) => string[];
+        listBlockIds: () => string[];
+        blockText: (id: string) => string | null;
+        blockTypeOf: (id: string) => string | undefined;
+        blockDataOf: (id: string) => Record<string, unknown> | undefined;
+        docData: () => JsonObj;
+        dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+        dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+            data: {
+                [x: string]: unknown;
+            };
+            ids: (path: readonly string[]) => string[];
+        } | null;
+        /**
+         * Compact per-block attribution (`{createdBy, contributors,
+         * lastChangedBy}`), or `undefined` for unauthored/system blocks.
+         * O(1) per call; live-replicated (remote values read the same).
+         */
+        blockAttribution: (id: string) => BlockAttribution | undefined;
+        crdtId: (id: string) => string | null;
+        resolveBlock: (id: string) => EngineNode | null;
+        displayLength: (id: string) => number;
+        contentItems: (id: string) => ContentItem[];
+        hasBlock: (id: string) => boolean;
+        isVisibleBlock: (id: string) => boolean;
+        order: () => readonly BlockId[];
+        compare: (a: BlockId, b: BlockId) => number;
+        next: (id: string, policy?: OrderPolicy | undefined) => string | null;
+        previous: (id: string, policy?: OrderPolicy | undefined) => string | null;
+        anchorAt: (id: string, offset: number, affinity?: AnchorAffinity | undefined) => DocAnchor | null;
+        resolveAnchor: (anchor: DocAnchor) => {
+            blockId: BlockId;
+            offset: number;
+        } | null;
+        followUndo: (anchor: DocAnchor) => DocAnchor;
+        /** Re-read the roles after `roleOf` answers differently (roles adopted later). */
+        rolesChanged: () => void;
+        isVoid: (id: string) => boolean;
+        isIsland: (id: string) => boolean;
+        isLines: (id: string) => boolean;
+        /** `id` is a layout: its kind's role says `layout` (`layout.*`). */
+        isLayout: (id: string) => boolean;
+        /** `id` is a layout item: of its layout's item kind, directly in it (a column). */
+        isLayoutItem: (id: string) => boolean;
+        /** The block a beside placement at `id` stands beside (`placeBeside`'s resolution). */
+        besideAt: (id: BlockId, kind?: string) => string;
+        islandOf: (id: string) => string | null;
+        /** `id` is a table: its kind's role says `table` (`table.*`). */
+        isTable: (id: string) => boolean;
+        /** `id` is a table's row: of its table's row kind, directly in it. */
+        isTableRow: (id: string) => boolean;
+        /** `id` is a table's cell: of its row's cell kind, directly in a row of a table. */
+        isTableCell: (id: string) => boolean;
+        /** The table `id` is, or whose row or cell it is; `null` for any other block. */
+        tableOf: (id: string) => string | null;
+        /** The columns a table lists (`data.columns`), or `null` when it lists none. */
+        tableColumns: (id: string) => {
+            id: string;
+            width?: number;
+        }[] | null;
         /**
-         * Drop every step of a history `createUndoManager` made (undo and
-         * redo) and release what they kept for their undo, as the history
-         * limit does: the engine collects that content now, the doc's
-         * `gcFilter` still deciding. The room's validation history runs
-         * it after each frame.
+         * A table as a grid: its column ids and each shown row's cells by
+         * column, `null` where the row shows none (a padded cell, `table.pad`).
          */
-        releaseHistory: (um: YUndoManager) => void;
+        tableGrid: (id: string) => {
+            columns: string[];
+            rows: {
+                id: BlockId;
+                cells: (BlockId | null)[];
+            }[];
+        } | null;
+        insideIsland: (id: string) => boolean;
+        canPlace: (ids: readonly BlockId[], parent?: BlockId | null) => boolean;
+        canMerge: (from: BlockId, into: BlockId) => boolean;
+        /** May a block of `kind` sit directly under `parent`? The container rule (`fits`). */
+        fits: (parent: BlockId | null, kind: string) => boolean;
+        /** Where `ids` nest when nested into `parent` (Tab, a drop inside it): `nestParent`. */
+        nestParent: (ids: readonly BlockId[], parent: BlockId) => string;
+        /** Where a block of `kind` at `id`'s place lands, and the containers it leaves (`liftOut`). */
+        landingOf: (id: BlockId, kind: string, after?: boolean) => {
+            parent: string | null;
+            levels: string[];
+        };
+        defaultChild: (id: string | null) => string;
+        runs: (id: string) => readonly ContentRun[];
+        contentJSON: (id: string) => ({
+            text: string;
+            marks?: Record<string, unknown>;
+        } | {
+            id?: string;
+            type: string;
+            data?: unknown;
+        })[];
+        onChange: (cb: (change: DocChange) => void) => (() => void);
+    };
+    /**
+     * A new engine document that is an edytor document from the start:
+     * a registry value a concurrent creation replaced keeps its subtree
+     * (each edytor document carries the rule; the engine's default stays
+     * upstream's). `create` gives it to a document it adopts, which must
+     * not have integrated anything yet.
+     */
+    newDoc: (opts?: ConstructorParameters<EngineApi["Doc"]>[0]) => YDoc;
+    /**
+     * Keep, on `doc`, the text a replica may have to copy again: its
+     * `gcFilter` then spares a deleted copy's content, as every facade's
+     * history does. A doc that only relays updates (the room) calls it
+     * before applying anything, so what it collects and encodes matches
+     * what an editing replica keeps.
+     */
+    keepCopies: (doc: EngineDoc) => void;
+    /** The bound engine layers (same instances the facades use). */
+    model: {
+        REGISTRY_KEY: string;
+        registryOf: (doc: EngineDoc) => EngineNode;
+        blockNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
+        liveNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
+        isLive: (doc: EngineDoc, id: BlockId) => boolean;
+        candidatesOf: (node: EngineNode) => import("./placement/model.js").PlacementCand[];
+        view: (doc: EngineDoc) => ModelView;
+        resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
+        childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
+        positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
+        buildInline: (atom: InlineSpec) => EngineNode;
+        isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
+        ranksAt: (siblings: readonly {
+            rank: string;
+        }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
+        writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
+        withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
+            inserts: {
+                has(client: number, clock: number): boolean;
+            };
+        }) => boolean;
+        materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
+        collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
+        writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+        ownText: (doc: EngineDoc, id: BlockId) => {
+            from: unknown;
+            to: number;
+        };
+        insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
+        insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
+        restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
+        project: (doc: EngineDoc) => import("./index.js").ProjectedDoc;
+        positionOf: (doc: EngineDoc, id: BlockId) => import("./index.js").Destination | null;
+        listBlockIds: (doc: EngineDoc) => BlockId[];
+        blockText: (doc: EngineDoc, id: BlockId) => string | null;
+        crdtId: (doc: EngineDoc, id: BlockId) => string | null;
+        resolveBlock: (doc: EngineDoc, id: BlockId) => EngineNode | null;
+    };
+    text: {
+        newNode: (name: string) => EngineNode;
+        resolveAnchor: (doc: EngineDoc, text: EngineNode, anchor: Anchor) => number | null;
+        anchorAt: (text: EngineNode, index: number, assoc: number) => Anchor;
+        openRangeCursor: (text: EngineNode) => import("./text/model.js").RangeCursor;
+        itemsOfRange: (text: EngineNode, i0: number, i1: number) => import("./text/model.js").RangeItem[];
+        readSegs: (segs: readonly import("./text/model.js").Seg[], stats?: import("./text/model.js").RangeReadStats) => import("./text/model.js").RangeItem[];
+        computeOwnership: (doc: EngineDoc, given: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>) => import("./text/model.js").Ownership;
+        flatten: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").Seg[];
+        ownedLength: (segs: readonly import("./text/model.js").Seg[]) => number;
+        contentItemsOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").RangeItem[];
+        blockTextOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => string;
+        insertIntoText: (doc: EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, payload: string | EngineNode, marks?: Record<string, unknown>) => void;
+        deleteRange: (doc: EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number) => void;
+        formatRangeIn: (doc: EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
+        purgeStreams: (streams: readonly import("./text/model.js").Stream[]) => void;
+        findAtom: (own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, inlineId: string) => {
+            text: EngineNode;
+            at: number;
+            node: EngineNode;
+        } | null;
+        splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
+        claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+        ownText: (doc: EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
+            from: unknown;
+            to: number;
+        };
+    };
+    runs: {
+        attach: (doc: EngineDoc) => RunView;
+    };
+};
+/**
+ * {@link bindDocModel} with the room's tasks: only the public binding
+ * (`bindCrdt(Y).doc`) reaches them, so an editor's graph holds neither.
+ */
+export declare const bindEdytorDoc: (Y: EngineApi) => {
+    /** The schema manifest constants table. */
+    SCHEMA: {
+        readonly version: 6;
+        readonly name: "edytor-doc";
+        readonly roots: {
+            readonly registry: "blocks";
+            readonly meta: "meta";
+        };
+        readonly metaAttrs: {
+            readonly version: "v";
+            readonly schema: "schema";
+        };
+    };
+    SCHEMA_VERSION: 6;
+    SCHEMA_NAME: "edytor-doc";
+    META_KEY: "meta";
+    /** Doc-level API (no facade needed). */
+    init: (doc: EngineDoc, opts?: {
+        content?: import("./index.js").BlockSpec[];
+        defaultType?: string;
+    }) => void;
+    restore: (doc: EngineDoc, content: import("./index.js").BlockSpec[]) => void;
+    seed: (doc: EngineDoc, value?: JSONBlock[], defaultType?: string, data?: JsonObj) => void;
+    isInitialized: (doc: EngineDoc) => boolean;
+    schemaVersion: (doc: EngineDoc) => number | undefined;
+    registryEmpty: (doc: EngineDoc) => boolean;
+    checkSchema: (doc: EngineDoc) => import("./edytor-doc.js").SchemaProblem | null;
+    assertSchema: (doc: EngineDoc, docName?: string) => void;
+    SchemaMismatchError: typeof SchemaMismatchError;
+    /** Attach the per-doc facade. */
+    create: (doc: EngineDoc, config?: EdytorDocConfig) => {
+        /** Every op prepared: pure, a plan of named steps + its effect, or `refused`. */
+        prepare: {
+            insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView) => Prepared;
+            deleteRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView) => Prepared;
+            replaceRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView) => Prepared;
+            insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | JSONBlock)[]) => Prepared;
+            moveBlocks: (ids: readonly BlockId[], dest: import("./index.js").Destination) => Prepared;
+            /**
+             * Move `id` to the last position under `parent` — under a container
+             * it is no item of, under its last item (`nestParent`: Tab after a list).
+             */
+            nestBlock: (id: BlockId, parent: BlockId) => Prepared;
+            unNestBlock: (id: BlockId) => Prepared;
+            unNestBlocks: (ids: readonly BlockId[]) => Prepared;
+            liftOut: (id: BlockId, kind: string, { keep, after }?: {
+                keep?: boolean;
+                after?: readonly import("./index.js").BlockSpec[];
+            }) => Prepared;
+            placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
+            wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
+            splitBlock: (id: BlockId, offset: number, newId: BlockId, tail?: SplitTail) => Prepared;
+            mergeBlocks: (fromId: BlockId, intoId: BlockId) => Prepared;
+            mergeBackward: (id: BlockId) => Prepared;
+            mergeForward: (id: BlockId) => Prepared;
+            deleteBlock: (id: BlockId, opts?: {
+                keepChildren?: boolean;
+            }) => Prepared;
+            setBlock: (id: BlockId, value: {
+                type?: string;
+                data?: Record<string, unknown>;
+                content?: (ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
+                children?: (import("./index.js").BlockSpec | JSONBlock)[];
+            }) => Prepared;
+            setBlockType: (id: BlockId, type: string) => Prepared;
+            patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
+            duplicateBlock: (id: BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => Prepared;
+            insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
+            deleteText: (id: BlockId, offset: number, length: number) => Prepared;
+            formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
+            clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
+            insertInline: (id: BlockId, offset: number, atom: import("./doc/content.js").NewInline) => Prepared;
+            removeInline: (id: BlockId, inlineId: string) => Prepared;
+            /** Delete a block selection — one plan; only the members leave (`deleteBlocks` above). */
+            deleteBlocks: (ids: readonly BlockId[]) => Prepared;
+        };
+        /** Write a prepared plan exactly (refusals pass through). */
+        apply: (p: Prepared) => OpResult;
+        compose: (...parts: Prepared[]) => Prepared;
+        transact: <R>(fn: () => R, origin?: unknown) => R;
+        model: {
+            REGISTRY_KEY: string;
+            registryOf: (doc: EngineDoc) => EngineNode;
+            blockNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
+            liveNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
+            isLive: (doc: EngineDoc, id: BlockId) => boolean;
+            candidatesOf: (node: EngineNode) => import("./placement/model.js").PlacementCand[];
+            view: (doc: EngineDoc) => ModelView;
+            resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
+            childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
+            positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
+            buildInline: (atom: InlineSpec) => EngineNode;
+            isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
+            ranksAt: (siblings: readonly {
+                rank: string;
+            }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
+            writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
+            withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
+                inserts: {
+                    has(client: number, clock: number): boolean;
+                };
+            }) => boolean;
+            materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
+            collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
+            writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+            ownText: (doc: EngineDoc, id: BlockId) => {
+                from: unknown;
+                to: number;
+            };
+            insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
+            insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
+            restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
+            project: (doc: EngineDoc) => import("./index.js").ProjectedDoc;
+            positionOf: (doc: EngineDoc, id: BlockId) => import("./index.js").Destination | null;
+            listBlockIds: (doc: EngineDoc) => BlockId[];
+            blockText: (doc: EngineDoc, id: BlockId) => string | null;
+            crdtId: (doc: EngineDoc, id: BlockId) => string | null;
+            resolveBlock: (doc: EngineDoc, id: BlockId) => EngineNode | null;
+        };
+        text: {
+            newNode: (name: string) => EngineNode;
+            resolveAnchor: (doc: EngineDoc, text: EngineNode, anchor: Anchor) => number | null;
+            anchorAt: (text: EngineNode, index: number, assoc: number) => Anchor;
+            openRangeCursor: (text: EngineNode) => import("./text/model.js").RangeCursor;
+            itemsOfRange: (text: EngineNode, i0: number, i1: number) => import("./text/model.js").RangeItem[];
+            readSegs: (segs: readonly import("./text/model.js").Seg[], stats?: import("./text/model.js").RangeReadStats) => import("./text/model.js").RangeItem[];
+            computeOwnership: (doc: EngineDoc, given: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>) => import("./text/model.js").Ownership;
+            flatten: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").Seg[];
+            ownedLength: (segs: readonly import("./text/model.js").Seg[]) => number;
+            contentItemsOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").RangeItem[];
+            blockTextOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => string;
+            insertIntoText: (doc: EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, payload: string | EngineNode, marks?: Record<string, unknown>) => void;
+            deleteRange: (doc: EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number) => void;
+            formatRangeIn: (doc: EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
+            purgeStreams: (streams: readonly import("./text/model.js").Stream[]) => void;
+            findAtom: (own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, inlineId: string) => {
+                text: EngineNode;
+                at: number;
+                node: EngineNode;
+            } | null;
+            splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
+            claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+            ownText: (doc: EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
+                from: unknown;
+                to: number;
+            };
+        };
+        runsView: RunView;
+        version: number;
+        insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView | undefined) => OpResult;
+        deleteRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => OpResult;
+        replaceRange: (from: DocPosition, to: DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => OpResult;
+        insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | JSONBlock)[]) => OpResult;
+        moveBlocks: (ids: readonly string[], dest: import("./index.js").Destination) => OpResult;
+        nestBlock: (id: string, parent: string) => OpResult;
+        unNestBlock: (id: string) => OpResult;
+        unNestBlocks: (ids: readonly string[]) => OpResult;
+        liftOut: (id: string, kind: string, args_2?: {
+            keep?: boolean;
+            after?: readonly import("./index.js").BlockSpec[];
+        } | undefined) => OpResult;
+        placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => OpResult;
+        wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => OpResult;
+        splitBlock: (id: string, offset: number, newId: string, tail?: SplitTail | undefined) => OpResult;
+        mergeBlocks: (fromId: string, intoId: string) => OpResult;
+        mergeBackward: (id: string) => OpResult;
+        mergeForward: (id: string) => OpResult;
+        deleteBlock: (id: string, opts?: {
+            keepChildren?: boolean;
+        } | undefined) => OpResult;
+        setBlock: (id: string, value: {
+            type?: string;
+            data?: Record<string, unknown>;
+            content?: (ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
+            children?: (import("./index.js").BlockSpec | JSONBlock)[];
+        }) => OpResult;
+        setBlockType: (id: string, type: string) => OpResult;
+        patchData: (target: DataTarget, patches: readonly DataPatch[]) => OpResult;
+        duplicateBlock: (id: string, freshId?: ((oldId: string, kind: "block" | "inline") => string) | undefined) => OpResult;
+        insertText: (id: string, offset: number, text: string, marks?: Record<string, unknown> | undefined) => OpResult;
+        deleteText: (id: string, offset: number, length: number) => OpResult;
+        formatRange: (id: string, offset: number, length: number, marks: Record<string, unknown>) => OpResult;
+        clearMarks: (id: string, offset: number, length: number) => OpResult;
+        insertInline: (id: string, offset: number, atom: import("./doc/content.js").NewInline) => OpResult;
+        removeInline: (id: string, inlineId: string) => OpResult;
+        deleteBlocks: (ids: readonly string[]) => OpResult;
+        init: (opts?: Parameters<(doc: EngineDoc, opts?: {
+            content?: import("./index.js").BlockSpec[];
+            defaultType?: string;
+        }) => void>[1]) => void;
+        /** Apply the deterministic seed of `value` and the document's `data` — the document's seed decision. */
+        seed: (value: JSONBlock[], data?: JsonObj) => void;
+        isInitialized: () => boolean;
+        /** Replicated `meta.v` schema version (the module-level read, bound). */
+        schemaVersion: () => number | undefined;
+        /**
+         * The schema gate for this doc — throws {@link SchemaMismatchError}
+         * on unversioned-content or unsupported-version state. Consumers
+         * (`Edytor.sync()`, packed consumers) call it before trusting
+         * a synced doc.
+         */
+        checkSchema: () => import("./edytor-doc.js").SchemaProblem | null;
+        assertSchema: () => void;
+        dispose: () => void;
+        createUndoManager: (options?: import("./doc/history.js").HistoryOptions) => import("./doc/history.js").UndoManager;
         project: () => import("./index.js").ProjectedDoc;
         toJSON: () => JSONDoc;
         blockJSON: (id: string) => JSONBlock;
@@ -290,7 +884,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             parent: BlockId | null;
             rank: string;
         } | null;
-        positionOf: (id: string) => Destination | null;
+        positionOf: (id: string) => import("./index.js").Destination | null;
         pathOf: (id: string) => number[] | null;
         parentOf: (id: string) => string | null;
         ancestorsOf: (id: string) => string[];
@@ -300,6 +894,12 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         blockDataOf: (id: string) => Record<string, unknown> | undefined;
         docData: () => JsonObj;
         dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+        dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+            data: {
+                [x: string]: unknown;
+            };
+            ids: (path: readonly string[]) => string[];
+        } | null;
         /**
          * Compact per-block attribution (`{createdBy, contributors,
          * lastChangedBy}`), or `undefined` for unauthored/system blocks.
@@ -414,7 +1014,6 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
      * registry holds and writing only what differs (`room.history.restore`), inside the caller's transaction.
      */
     restoreTo: <Plan>(doc: EngineDoc, facade: import("./restore.js").RestoreFacade<Plan>, json: JSONDoc) => import("./restore.js").RestoreReport;
-    /** The bound engine layers (same instances the facades use). */
     model: {
         REGISTRY_KEY: string;
         registryOf: (doc: EngineDoc) => EngineNode;
@@ -425,7 +1024,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         view: (doc: EngineDoc) => ModelView;
         resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
         childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
-        positionInView: (v: ModelView, id: BlockId) => Destination | null;
+        positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
         buildInline: (atom: InlineSpec) => EngineNode;
         isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
         ranksAt: (siblings: readonly {
@@ -434,21 +1033,21 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
         withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
             inserts: {
-                hasId(id: unknown): boolean;
+                has(client: number, clock: number): boolean;
             };
         }) => boolean;
-        materializeSpec: (doc: EngineDoc, sp: BlockSpec, parent: BlockId | null, rank: string) => void;
-        collides: (doc: EngineDoc, specs: readonly BlockSpec[]) => boolean;
+        materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
+        collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
         writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
         ownText: (doc: EngineDoc, id: BlockId) => {
             from: unknown;
             to: number;
         };
-        insertBlocks: (doc: EngineDoc, dest: Destination, specs: BlockSpec[]) => boolean;
-        insertBlock: (doc: EngineDoc, dest: Destination, spec: BlockSpec) => boolean;
-        restoreBlocks: (doc: EngineDoc, specs: BlockSpec[]) => void;
+        insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
+        insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
+        restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
         project: (doc: EngineDoc) => import("./index.js").ProjectedDoc;
-        positionOf: (doc: EngineDoc, id: BlockId) => Destination | null;
+        positionOf: (doc: EngineDoc, id: BlockId) => import("./index.js").Destination | null;
         listBlockIds: (doc: EngineDoc) => BlockId[];
         blockText: (doc: EngineDoc, id: BlockId) => string | null;
         crdtId: (doc: EngineDoc, id: BlockId) => string | null;