edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/edytor-doc.js

@@ -4,27 +4,30 @@
  * This module binds the three proven engine layers over ONE Y.Doc into the
  * single public surface the command layer and providers consume:
  *
- * - `placement/model.ts` (`bindModel`) — stable block registry + placement
+ * - `placement/model.ts` — stable block registry + placement
  *   candidates; identity-preserving move/nest/split/merge.
- * - `text/model.ts` (`bindText`) — stable backing texts delimited by stream
+ * - `text/model.ts` — stable backing texts delimited by stream
  *   boundaries + merge claims; split/merge never copy text.
- * - `text/runs.ts` (`bindRuns`) — the maintained run view: immutable run
+ * - `text/runs.ts` (`indexOf`) — the maintained run view: immutable run
  *   snapshots, structural sharing, the change report.
  *
- * This module is the wiring: `create` builds a facade's parts, each a
+ * This module is the wiring: `docFacade` builds a facade's parts, each a
  * module under `doc/` taking an explicit context — the parts before it —
- * and assembles the facade object.
+ * and assembles the facade object. An editor's documents use it directly;
+ * the public binding (`bindDocModel`, `bindEdytorDoc`) adds the engine
+ * layers as objects (`model`, `text`, `runs`) and the room's tasks, so an
+ * editor's graph holds none of what only they reach.
  *
  * - `doc/gate.ts` — the schema manifest and gate (module-level);
  *   `doc/seed.ts` — the version record and the deterministic seed;
  *   `doc/types.ts` — the public types; `doc/plan.ts` — op results, a plan's
  *   effect, ingress normalization.
- * - `doc/reads.ts` (`DocBase`: the doc, its engine layers, its index and
+ * - `doc/reads.ts` (`DocBase`: the doc, its engine, its index and
  *   roles) — the reads, roles and document order; `doc/capability.ts` —
  *   structural capability (`canPlace`, `fits`, `canMerge`, the island and
  *   void rules).
- * - `doc/funnel.ts` — the write funnel (`write`, `apply`, attribution and
- *   lineage); `doc/events.ts` — `onChange`; `doc/history.ts` —
+ * - `doc/funnel.ts` — the write funnel (`write`, `apply`, attribution);
+ *   `doc/events.ts` — `onChange`; `doc/history.ts` —
  *   `createUndoManager`; `doc/anchors.ts` — caret anchors.
  * - `doc/steps.ts` — the step writers every op composes (ranks, settle,
  *   emptying, dissolving); the prepared op families over them
@@ -45,20 +48,18 @@
  */
 import { setMarkEdges } from './text/marks.js';
 import { keepingReplaced } from './incarnations.js';
-import { TYPE, SCHEMA } from './schema.js';
-import { bindModel } from './placement/model.js';
+import { SCHEMA } from './schema.js';
+import { bindModel, blockText, crdtId, listBlockIds, project, resolveBlock } from './placement/model.js';
 import { bindText } from './text/model.js';
 import { bindDeletes } from './text/deletes.js';
 import { bindPurge, readHorizon } from './purge.js';
 import { restoreDocument } from './restore.js';
-import { bindRuns } from './text/runs.js';
-import { bindNodes } from './nodes.js';
+import { bindRuns, indexOf } from './text/runs.js';
 import { bindBlockAttribution, blockAttributionOf } from './attribution/block.js';
 import { rangeDeleteOps } from './rangeDelete.js';
 import { flowOps } from './flow.js';
-import { sanitizeSpec } from '../utils/json.js';
 import { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
-import { bindSeed } from './doc/seed.js';
+import { bindSeed, restore } from './doc/seed.js';
 import { applied, ref } from './doc/plan.js';
 import { docReads } from './doc/reads.js';
 import { docCapability } from './doc/capability.js';
@@ -73,40 +74,25 @@ import { splitMergeOps } from './doc/split-merge.js';
 import { deleteOps } from './doc/delete.js';
 import { metaOps } from './doc/meta.js';
 import { contentOps } from './doc/content.js';
-import { tableOps } from './doc/table.js';
 // ── schema manifest and gate (`doc/gate.ts`) ────────────────────────────
 export { SCHEMA };
 export { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
 export { UnsupportedDocError } 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';
 /**
- * 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`).
+ * 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 const bindEdytorDoc = (Y) => {
-    // The doc's index (`text/runs.ts`) is the one owner of derived state:
-    // commands, runs, anchors, the change report and rendering read it.
-    const R = bindRuns(Y);
-    const M = bindModel(Y);
-    const T = bindText(Y);
+export const docFacade = (Y, layers) => {
     const D = bindDeletes(Y);
-    const P = bindPurge(Y);
-    /** Each history's release of all its steps (`releaseHistory`). */
-    const releasers = new WeakMap();
     // Compact per-block attribution writes (`attribution/block.ts`).
     // One bound instance per engine binding; its suppression memory is
     // per-doc (WeakMap-keyed), so facades on the same doc share it.
     const BA = bindBlockAttribution(Y);
-    // ── version record / bootstrap (doc-level, facade-free) ────────────
-    // `schemaVersion`, `registryEmpty`, `isInitialized`, `checkSchema` and
-    // `assertSchema` are module-level (see above) — pure doc reads shared by
-    // providers and migration without re-binding.
-    const { restore, init, seed } = bindSeed(Y, M, BA);
-    // ── per-doc facade ──────────────────────────────────────────────────
-    const create = (doc, config = {}) => {
+    const { init, seed } = bindSeed(Y, BA);
+    return (doc, config = {}) => {
         keepingReplaced(doc);
         // Document-boundary check — foreign (v13-engine) and legacy-schema docs
         // fail fast here rather than inside the runs view (see assertUsableDoc).
@@ -116,7 +102,7 @@ export const bindEdytorDoc = (Y) => {
         const defaultType = config.defaultType ?? 'paragraph';
         const defaultChildOf = config.defaultChildOf ?? (() => undefined);
         const rendersContentOf = config.rendersContent ?? (() => true);
-        const runsView = R.attach(doc);
+        const runsView = indexOf(doc);
         // The role table — the display and every guard below ask it.
         // a void kind displays no children — the index sheds them into its
         // slot at read time, so a child a peer nests or splits under a block
@@ -146,16 +132,11 @@ export const bindEdytorDoc = (Y) => {
         if (config.roleOf)
             runsView.roles(roles);
         // The facade's parts, each over the ones before it (`doc/*`).
-        const base = { Y, doc, M, T, runsView, roles, roleOf, rendersContentOf };
+        const base = { Y, doc, runsView, roles, roleOf, rendersContentOf };
         const reads = { ...base, ...docReads(base) };
         const shape = { ...reads, ...docCapability(reads) };
-        const { blockJSON, view, blockTypeOf, blockDataOf, docData, dataItemIds, childrenIds, positionOf, pathOf, ancestorsOf, slotOf, isVoid, isIsland, isLines, islandOf, insideIsland, isLayout, isLayoutItem, insideItem, order, compare, next, previous, displayLength, contentItems, hasBlock, live, contentTarget } = reads;
-        const { canPlace, isContainer, fits, fitted, emptiable, nestParent, canMerge, rendersContent, defaultChild, kindToCopy } = shape;
-        // Lineage ring watermark repair — concurrent partition appends can
-        // merge a ring past every writer's `depth`; this converges the
-        // stored ring back to the entries' own watermark after remote
-        // applies. Once per doc, doc-lifetime, no-op when nothing is over.
-        BA.attachRingTrim(doc);
+        const { blockJSON, view, blockTypeOf, blockDataOf, docData, dataItemIds, dataPreview, childrenIds, positionOf, pathOf, ancestorsOf, slotOf, isVoid, isIsland, isLines, islandOf, insideIsland, isLayout, isLayoutItem, order, compare, next, previous, displayLength, contentItems, hasBlock, live } = reads;
+        const { canPlace, fits, nestParent, canMerge, defaultChild } = shape;
         const funnel = writeFunnel({ ...reads, BA, config });
         const { write, apply } = funnel;
         const events = docEvents({ runsView });
@@ -164,10 +145,10 @@ export const bindEdytorDoc = (Y) => {
             funnel.dispose();
             events.close();
         };
-        const { createUndoManager } = docHistory({ ...base, ...funnel, D, BA, releasers, init });
+        const { createUndoManager } = docHistory({ ...base, ...funnel, D, init });
         const { anchorAt, followUndo, resolveAnchor } = docAnchors(reads);
         const steps = { ...shape, ...planSteps(shape) };
-        const { REFUSED, plan, ranksFor, move, pieceRanks, attr, settle, dissolving, remove } = steps;
+        const { plan } = steps;
         // The prepared op families (`OpsContext`: the reads, capability and step writers).
         const { insertBlocks, moveBlocks, unNestBlocks, unNestBlock, landingOf, liftOut, duplicateBlock } = moveOps(steps);
         const { besideAt, placeBeside, wrapInLayout } = layoutOps(steps);
@@ -175,65 +156,12 @@ export const bindEdytorDoc = (Y) => {
         const { deleteBlocks, deleteBlock } = deleteOps(steps);
         const { dataSteps, replaceData, setBlockType, patchData, setBlock } = metaOps(steps);
         const { insertText, deleteText, formatRange, clearMarks, insertInline, removeInline } = contentOps(steps);
-        const tables = tableOps({ ...steps, dataSteps });
-        /** What range deletion and flow placement read, and the step writers they compose. */
-        const context = {
-            ref,
-            refused: REFUSED,
-            plan,
-            order: () => view().order,
-            positionOf,
-            ancestorsOf: (id) => ancestorsOf(id),
-            childrenIds,
-            displayLength,
-            contentTarget,
-            rendersContent,
-            canMerge,
-            isIsland,
-            isLines,
-            defaultChild,
-            fitted,
-            move,
-            retype: (id, type) => attr(id, TYPE, type),
-            isContainer,
-            emptiable,
-            settle,
-            remove,
-            insertBlocks,
-            sanitize: sanitizeSpec,
-            collides: (specs) => M.collides(doc, specs),
-            isVoid,
-            roleOf: (kind) => ({
-                void: roles.childless(kind),
-                island: roles.island(kind),
-                rendersContent: roles.rendersContent(kind),
-                layout: roles.layout(kind)
-            }),
-            insideItem: (id) => insideItem(id),
-            tailOf: (id) => ({ type: kindToCopy(id), data: blockDataOf(id) }),
-            ranksFor,
-            insertRanks: (parent, index, count) => ranksFor(parent, index, count, [], true),
-            pieceRanks,
-            redata: (id, data) => dataSteps(id, replaceData(data)) ?? [],
-            deleteBlocks: (ids, filled) => deleteBlocks(ids, false, filled),
-            dissolving: (gone, leaving, writes) => dissolving(new Set(gone), leaving, writes),
-            tableOf: (id) => reads.tableOf(id),
-            isTableCell: (id) => reads.isTableCell(id),
-            tableKind: (kind) => roles.table(kind) !== undefined
-                ? 'table'
-                : reads.isRowKind(kind)
-                    ? 'row'
-                    : reads.isCellKind(kind)
-                        ? 'cell'
-                        : undefined
-        };
+        /** What range deletion and flow placement compose: the step writers and the ops. */
+        const ops = { ...steps, insertBlocks, deleteBlocks, dataSteps, replaceData };
         /** Every document op, prepared — `apply(prepare.op(…))` is the op. */
         const prepare = {
             insertBlocks,
-            insertBlock: (dest, spec) => insertBlocks(dest, [spec]),
             moveBlocks,
-            /** Relocate `id` — identity preserved. */
-            moveBlock: (id, dest) => moveBlocks([id], dest),
             /**
              * 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).
@@ -255,25 +183,17 @@ export const bindEdytorDoc = (Y) => {
             setBlock,
             setBlockType,
             patchData,
-            /** Replace a block's `data`: a patch of its root. */
-            setBlockData: (id, data) => patchData(id, [{ path: [], value: data }]),
             duplicateBlock,
             insertText,
             deleteText,
             formatRange,
-            setMark: (id, offset, length, name, value) => formatRange(id, offset, length, { [name]: value }),
-            unsetMark: (id, offset, length, name) => formatRange(id, offset, length, { [name]: null }),
             clearMarks,
             insertInline,
             removeInline,
-            /** Replace an inline atom's `data`: a patch of its root. */
-            setInlineData: (id, inlineId, data) => patchData({ block: id, atom: inlineId }, [{ path: [], value: data }]),
             /** Delete a block selection — one plan; only the members leave (`deleteBlocks` above). */
             deleteBlocks: (ids) => deleteBlocks(ids),
-            // Tables (`table.*`): rows are blocks, columns the table's `data.columns`.
-            ...tables,
-            ...rangeDeleteOps(context),
-            ...flowOps(context)
+            ...rangeDeleteOps(ops),
+            ...flowOps(ops)
         };
         /**
          * Plans prepared at one version, as one plan (refused if any part is;
@@ -306,14 +226,6 @@ export const bindEdytorDoc = (Y) => {
         // ── facade object ─────────────────────────────────────────────────
         /** A read taking an id first: the id normalizes at ingress. */
         const byRef = (f) => (id, ...rest) => f(ref(id), ...rest);
-        /**
-         * The typed-node surface (`document.block(id)` handles — see
-         * `nodes.ts`). Created lazily on first use; `bindNodes` caches one
-         * handle per block id, so repeated `facade.block(id)` calls return
-         * the same instance.
-         */
-        let nodeApi;
-        const nodes = () => (nodeApi ??= bindNodes(facade));
         const facade = {
             // lifecycle
             init: (opts) => write(() => init(doc, opts)),
@@ -332,16 +244,8 @@ export const bindEdytorDoc = (Y) => {
             assertSchema: () => assertSchema(doc),
             dispose,
             createUndoManager,
-            /**
-             * 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.
-             */
-            releaseHistory: (um) => releasers.get(um)?.(),
             // reads — every id argument normalizes at ingress
-            project: () => M.project(doc),
+            project: () => project(doc),
             toJSON,
             blockJSON: byRef(blockJSON),
             childrenIds: byRef(childrenIds),
@@ -352,20 +256,21 @@ export const bindEdytorDoc = (Y) => {
             pathOf: byRef(pathOf),
             parentOf: byRef((id) => positionOf(id)?.parent ?? null),
             ancestorsOf: byRef((id) => ancestorsOf(id)),
-            listBlockIds: () => M.listBlockIds(doc),
-            blockText: byRef((id) => M.blockText(doc, id)),
+            listBlockIds: () => listBlockIds(doc),
+            blockText: byRef((id) => blockText(doc, id)),
             blockTypeOf: byRef(blockTypeOf),
             blockDataOf: byRef(blockDataOf),
             docData,
             dataItemIds,
+            dataPreview,
             /**
              * 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: byRef((id) => blockAttributionOf(doc, id)),
-            crdtId: byRef((id) => M.crdtId(doc, id)),
-            resolveBlock: byRef((id) => M.resolveBlock(doc, id)),
+            crdtId: byRef((id) => crdtId(doc, id)),
+            resolveBlock: byRef((id) => resolveBlock(doc, id)),
             displayLength: byRef(displayLength),
             contentItems: byRef(contentItems),
             hasBlock: byRef(hasBlock),
@@ -433,10 +338,10 @@ export const bindEdytorDoc = (Y) => {
             // that batch several ops into one undo step / one event)
             transact: (fn, origin) => write(() => doc.transact(fn, origin)),
             // escape hatch for the history and debugging — the bound engine layers.
-            model: M,
-            text: T,
+            model: layers.model,
+            text: layers.text,
             runsView,
-            // ── model-state version + typed node surface ──────────
+            // ── model-state version ─────────────────────────────
             /**
              * The index version — bumps on every fold that changed derived
              * state, mid-transaction writes included. Read surfaces that
@@ -445,18 +350,24 @@ export const bindEdytorDoc = (Y) => {
              */
             get version() {
                 return runsView.version();
-            },
-            /**
-             * 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) => nodes().block(ref(id))
+            }
         };
         return facade;
     };
+};
+/**
+ * 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`). A document composes
+ * this binding; {@link bindEdytorDoc} adds the room's purge and restore.
+ */
+export const bindDocModel = (Y) => {
+    const M = bindModel(Y);
+    const T = bindText(Y);
+    const R = bindRuns(Y);
+    const D = bindDeletes(Y);
+    const { init, seed } = bindSeed(Y, bindBlockAttribution(Y));
+    const create = docFacade(Y, { model: M, text: T });
     return {
         /** The schema manifest constants table. */
         SCHEMA,
@@ -491,12 +402,26 @@ export const bindEdytorDoc = (Y) => {
          * what an editing replica keeps.
          */
         keepCopies: (doc) => void D.scope(doc),
+        /** The bound engine layers (same instances the facades use). */
+        model: M,
+        text: T,
+        runs: R
+    };
+};
+/**
+ * {@link bindDocModel} with the room's tasks: only the public binding
+ * (`bindCrdt(Y).doc`) reaches them, so an editor's graph holds neither.
+ */
+export const bindEdytorDoc = (Y) => {
+    const { model, text, runs, ...binding } = bindDocModel(Y);
+    // The spread last: the declared type lists the binding first, as before.
+    return {
         /**
          * Purge from `doc` what was deleted before `horizon` (`room.purge.what`): real deletes, inside the caller's transaction,
          * and the horizon record every history reads (`hist.purge.horizon`).
          * The room's purge task runs it; `facade` is a facade over `doc`.
          */
-        purge: P.purge,
+        purge: bindPurge(Y).purge,
         /** The purge horizon `doc` holds, or `null`. */
         horizonOf: (doc) => readHorizon(doc),
         /**
@@ -504,9 +429,9 @@ export const bindEdytorDoc = (Y) => {
          * registry holds and writing only what differs (`room.history.restore`), inside the caller's transaction.
          */
         restoreTo: restoreDocument,
-        /** The bound engine layers (same instances the facades use). */
-        model: M,
-        text: T,
-        runs: R
+        model,
+        text,
+        runs,
+        ...binding
     };
 };

package/dist/crdt/engine-api.d.ts

@@ -2,15 +2,11 @@
  * Engine-facing types for the placement model.
  *
  * The vendored v14 engine is plain JSDoc-typed JS that is deliberately
- * excluded from `tsconfig.json` type-checking. Its emitted declarations
- * (`vendor/yjs/dts`) parameterize `YNode` on a delta-config generic that
- * collapses to `never` when instantiated with `any` — unusable as an
- * ergonomic call surface.
- *
- * So the model works against the STRUCTURAL interfaces below — the exact
- * subset of the v14 Node/Doc surface it uses — and receives the engine
- * module by injection (`bindModel(Y)`). Only `engine.js` (declared by
- * `engine.d.ts`) imports vendor `.js`, so `pnpm check` never traverses
+ * excluded from `tsconfig.json` type-checking. The model works against the
+ * STRUCTURAL interfaces below — the exact
+ * subset of the v14 Node/Doc surface it uses — and reads the engine
+ * through `engine.js` (its `Y`, declared by `engine.d.ts`), the only
+ * module that imports vendor `.js`, so `pnpm check` never traverses
  * vendored sources.
  */
 import type * as Y from './vendor/yjs/dts/index.js';
@@ -24,7 +20,8 @@ import type { Y as Engine } from './engine.js';
 export type EngineApi = typeof Engine;
 export type YDoc = InstanceType<typeof Y.Doc>;
 export type YNode = InstanceType<typeof Y.Node>;
-export type YUndoManager = InstanceType<typeof Y.UndoManager>;
+/** The document's undo manager (`doc/history.ts`). */
+export type YUndoManager = import('./doc/history.js').UndoManager;
 export type YTransaction = Y.Transaction;
 export type YItem = Y.Item;
 /** Engine item identity — used by `crdtId` (`client:clock`). */
@@ -53,23 +50,6 @@ export type EngineItemRef = {
 export interface EngineTransaction {
     changed?: Map<unknown, Set<string | null>>;
 }
-/**
- * The deep-observer event surface (v14 `YEvent`, observed through
- * `observeDeep` on an ancestor — in our schema, the registry root). The
- * document index folds the event's `transaction.changed` at commit.
- */
-export interface EngineDeepEvent {
-    readonly target: unknown;
-    readonly currentTarget: unknown;
-    readonly keysChanged?: ReadonlySet<string>;
-    readonly delta?: {
-        toJSON(): unknown;
-    };
-    readonly deltaDeep?: {
-        toJSON(): unknown;
-    };
-    readonly transaction?: unknown;
-}
 /**
  * Structural minimum of the vendored `Y.Node` (v14) used by the placement
  * model. A real `YNode` satisfies this at runtime; typed consumers cast once
@@ -89,27 +69,8 @@ export interface EngineNode {
     deleteAttr(key: string): void;
     forEachAttr(f: (value: unknown, key: string, node: EngineNode) => void): void;
     attrKeys(): IterableIterator<string>;
-    insert(index: number, content: unknown, format?: Record<string, unknown>): void;
+    insert(index: number, content: unknown): void;
     delete(index: number, length?: number): void;
-    format(index: number, length: number, formats: Record<string, unknown>): void;
-    get(index: number): unknown;
-    slice(start?: number, end?: number): unknown[];
-    toArray(): unknown[];
-    /** Maintained delta cache — `toJSON()` yields the serialized op list. */
-    readonly delta: {
-        toJSON(): {
-            children?: unknown[];
-        };
-    };
-    toDelta(opts?: {
-        deep?: boolean;
-    }): {
-        toJSON(): unknown;
-    };
-    /** Deep event channel — anchors/observers follow the node across moves. */
-    observeDeep(f: (event: EngineDeepEvent, transaction: unknown) => void): unknown;
-    unobserveDeep(f: (event: EngineDeepEvent, transaction: unknown) => void): void;
-    on(name: 'delta', f: (delta: unknown, origin: unknown) => void): void;
 }
 /** Structural minimum of the vendored `Y.Doc`. */
 export interface EngineDoc {
@@ -130,6 +91,13 @@ export interface EngineDoc {
      */
     on(name: 'update', f: (update: Uint8Array, origin: unknown, doc: EngineDoc, transaction: unknown) => void): void;
     off(name: 'update', f: (update: Uint8Array, origin: unknown, doc: EngineDoc, transaction: unknown) => void): void;
+    /**
+     * Doc-level `commit` channel — fires once per
+     * transaction, before `afterTransaction`, with the transaction: the
+     * index folds it there.
+     */
+    on(name: 'commit', f: (transaction: never) => void): void;
+    off(name: 'commit', f: (transaction: never) => void): void;
     /** Doc destruction event — doc-scoped state must release on destroy. */
     on(name: 'destroy', f: () => void): void;
     off(name: 'destroy', f: () => void): void;

package/dist/crdt/engine.d.ts

@@ -4,7 +4,6 @@ import type * as V from './vendor/yjs/dts/index.js';
 export type EngineSymbol =
 	| 'Doc'
 	| 'Node'
-	| 'UndoManager'
 	| 'Item'
 	| 'RangeCursor'
 	| 'transact'
@@ -13,33 +12,24 @@ export type EngineSymbol =
 	| 'encodeStateVector'
 	| 'decodeStateVector'
 	| 'decodeUpdate'
-	| 'decodeUpdateV2'
-	| 'UpdateEncoderV1'
+	| 'UpdateEncoder'
 	| 'writeIdSet'
 	| 'mergeUpdates'
-	| 'applyUpdateV2'
-	| 'encodeStateAsUpdateV2'
-	| 'mergeUpdatesV2'
-	| 'convertUpdateFormatV2ToV1'
-	| 'UpdateDecoderV1'
-	| 'UpdateEncoderV2'
 	| 'Skip'
 	| 'findIndexSS'
 	| 'isKeptReplaced'
-	| 'createRelativePositionFromTypeIndex'
-	| 'createRelativePositionFromJSON'
-	| 'createAbsolutePositionFromRelativePosition'
-	| 'relativePositionToJSON'
+	| 'idAtIndex'
+	| 'indexOfId'
 	| 'createIdSet'
 	| 'diffIdSet'
 	| 'insertIntoIdSet'
-	| 'createIdMap'
-	| 'insertIntoIdMap'
-	| 'createContentMap'
-	| 'decodeContentMap'
 	| 'iterateStructsByIdSet'
 	| 'getItemCleanStart'
 	| 'redoItem'
+	| 'keepItem'
+	| 'followRedone'
+	| 'isParentOf'
+	| 'mergeIdSets'
 	| 'ContentAny'
 	| 'createID';
 

package/dist/crdt/engine.js

@@ -15,7 +15,6 @@ import * as V from './vendor/yjs/src/index.js';
 export const Y = {
 	Doc: V.Doc,
 	Node: V.Node,
-	UndoManager: V.UndoManager,
 	Item: V.Item,
 	RangeCursor: V.RangeCursor,
 	transact: V.transact,
@@ -24,38 +23,29 @@ export const Y = {
 	encodeStateVector: V.encodeStateVector,
 	decodeStateVector: V.decodeStateVector,
 	decodeUpdate: V.decodeUpdate,
-	// the engine's pending store is V2-encoded (admission of pending structs)
-	decodeUpdateV2: V.decodeUpdateV2,
 	// the store-before-ack body carries the acknowledged deletes (`sync.writeSaved`)
-	UpdateEncoderV1: V.UpdateEncoderV1,
+	UpdateEncoder: V.UpdateEncoder,
 	writeIdSet: V.writeIdSet,
 	mergeUpdates: V.mergeUpdates,
-	// storage in the v2 (columnar) encoding: room rows and the IndexedDB store
-	applyUpdateV2: V.applyUpdateV2,
-	encodeStateAsUpdateV2: V.encodeStateAsUpdateV2,
-	mergeUpdatesV2: V.mergeUpdatesV2,
-	convertUpdateFormatV2ToV1: V.convertUpdateFormatV2ToV1,
-	UpdateDecoderV1: V.UpdateDecoderV1,
-	UpdateEncoderV2: V.UpdateEncoderV2,
 	Skip: V.Skip,
 	findIndexSS: V.findIndexSS,
 	// a concurrent creation of one block id keeps the losing node (fork patch YP14)
 	isKeptReplaced: V.isKeptReplaced,
-	createRelativePositionFromTypeIndex: V.createRelativePositionFromTypeIndex,
-	createRelativePositionFromJSON: V.createRelativePositionFromJSON,
-	createAbsolutePositionFromRelativePosition: V.createAbsolutePositionFromRelativePosition,
-	relativePositionToJSON: V.relativePositionToJSON,
+	// a position as an item id and back (fork patch YP19)
+	idAtIndex: V.idAtIndex,
+	indexOfId: V.indexOfId,
 	createIdSet: V.createIdSet,
 	diffIdSet: V.diffIdSet,
 	insertIntoIdSet: V.insertIntoIdSet,
-	createIdMap: V.createIdMap,
-	insertIntoIdMap: V.insertIntoIdMap,
-	createContentMap: V.createContentMap,
-	decodeContentMap: V.decodeContentMap,
 	// text delete marks (`text/deletes.ts`, fork patch YP11)
 	iterateStructsByIdSet: V.iterateStructsByIdSet,
 	getItemCleanStart: V.getItemCleanStart,
 	redoItem: V.redoItem,
+	// the document's undo manager (`doc/history.ts`, fork patch YP18)
+	keepItem: V.keepItem,
+	followRedone: V.followRedone,
+	isParentOf: V.isParentOf,
+	mergeIdSets: V.mergeIdSets,
 	// a folded delete record appended after the one it replaces
 	ContentAny: V.ContentAny,
 	createID: V.createID

package/dist/crdt/flow.d.ts

@@ -35,9 +35,13 @@
  *   other kind keeps its kind and data (a pasted image stays an image, a
  *   bulleted item in an `ordered-list` a bulleted item).
  */
-import type { BlockId, BlockSpec, Destination, SplitTail } from './placement/model.js';
-import type { PlanStep, Prepared } from './edytor-doc.js';
-import type { DocPosition, RangeDeleteContext, RangeView } from './rangeDelete.js';
+import type { BlockId, BlockSpec, Destination } from './placement/model.js';
+import type { Prepared } from './edytor-doc.js';
+import type { DocPosition, RangeView } from './rangeDelete.js';
+import type { OpsContext } from './doc/steps.js';
+import type { MoveOps } from './doc/moves.js';
+import type { DeleteOps } from './doc/delete.js';
+import type { MetaOps } from './doc/meta.js';
 /** One line of a flow: a kinded block, or an inline run when it has no `type`. */
 export type FlowLine = Omit<BlockSpec, 'type'> & {
     type?: string;
@@ -68,40 +72,8 @@ export type FlowTarget = DocPosition | {
 } | {
     slot: Destination;
 };
-/** What flow placement reads beyond range deletion's context. */
-export type FlowContext = RangeDeleteContext & {
-    defaultChild: (parent: BlockId | null) => string;
-    /** `kind`, or `parent`'s item where it does not fit there (the container rule). */
-    fitted: (parent: BlockId | null, kind: string | undefined) => string | undefined;
-    retype: (id: BlockId, type: string) => PlanStep[];
-    sanitize: (spec: BlockSpec) => BlockSpec;
-    collides: (specs: readonly BlockSpec[]) => boolean;
-    isVoid: (id: BlockId) => boolean;
-    /**
-     * A kind's display role: void, an island, whether it renders its own
-     * content, and a layout's item kind (`layout.*`).
-     */
-    roleOf: (kind: string) => {
-        void: boolean;
-        island: boolean;
-        rendersContent: boolean;
-        layout?: string;
-    };
-    /** `id` is a layout item or sits inside one (no layout lands there). */
-    insideItem: (id: BlockId) => boolean;
-    /** What a kind is to the table rules: a table, a row or a cell kind (`table.*`). */
-    tableKind: (kind: string) => 'table' | 'row' | 'cell' | undefined;
-    tailOf: (id: BlockId) => SplitTail;
-    ranksFor: (parent: BlockId | null, index: number, count: number) => string[];
-    /** `ranksFor` for new blocks: after a block this client ranked, in its run there. */
-    insertRanks: (parent: BlockId | null, index: number, count: number) => string[];
-    /** Ranks for the `count` blocks a split of `id` at `at` puts after it, by that offset. */
-    pieceRanks: (id: BlockId, at: number, count: number) => string[];
-    redata: (id: BlockId, data: Record<string, unknown>) => PlanStep[];
-    /** `deleteBlocks`; `filled`: a parent the plan fills again, never emptied (`flow.slot`). */
-    deleteBlocks: (ids: readonly BlockId[], filled?: BlockId | null) => Prepared;
-    insertBlocks: (dest: Destination, specs: readonly BlockSpec[]) => Prepared;
-};
+/** What flow placement composes: the step writers and the ops it places and deletes with. */
+export type FlowContext = OpsContext & Pick<MoveOps, 'insertBlocks'> & Pick<DeleteOps, 'deleteBlocks'> & Pick<MetaOps, 'dataSteps' | 'replaceData'>;
 /**
  * Where the caret ends a placed block: its own content's end when it shows a
  * line (renders its content, no void; a toggle's header, never its body),