edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/doc/history.js

@@ -1,24 +1,320 @@
+/**
+ * The document's history: the one undo manager (fork patch YP18 removed the
+ * engine's). It captures the tracked local transactions that write in its
+ * scope (the block registry, the text delete marks, the document's data)
+ * into steps, and an undo or a redo replays a step in one transaction over
+ * the engine's struct primitives (`redoItem`, `keepItem`). Its rules: text
+ * comes back as the delete marks allow (`hist.undo.restore`), an undone
+ * creation is withdrawn (`hist.undo.withdraw`), an overwritten attr is
+ * repaired, the stack keeps `limit` steps, and the purge horizon drops the
+ * steps below it (`hist.purge.horizon`).
+ */
+import { getUnixTime } from 'lib0-v14/time';
 import { ownTextIds } from '../text/model.js';
 import { readHorizon } from '../purge.js';
-import { BLOCK_NODE, DATA, DATA_LEAF_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, ID, INLINE_NODE, isNodeLike, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
-import { asYNode, collectable, collectNow, collects, engineOps, onTransaction, stepsOf, walkIdSetStructs } from '../structs.js';
+import { BLOCK_NODE, DATA_LEAF_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
+import { changedUnder, collectable, collectNow, collects, dropSearchMarkers, engineOps, walkIdSet } from '../structs.js';
 import { isInitialized } from './gate.js';
 import { EdytorDocDisposedError } from './funnel.js';
+import { registryOf, withdrawOnUndo } from '../placement/model.js';
 /** The undo steps a document's history keeps by default: older ones are released. */
 export const DEFAULT_HISTORY_LIMIT = 200;
 /** The origin of the transaction that releases a dropped history step's content. */
 const HISTORY_TRIM = Symbol('edytor.history.trim');
+/** One undo or redo step: what its transactions inserted and deleted, and what the views keep on it. */
+export class StackItem {
+    inserts;
+    deletes;
+    /** Per-view metadata (`session/history.ts`: the selections around the step). */
+    meta = new Map();
+    constructor(inserts, deletes) {
+        this.inserts = inserts;
+        this.deletes = deletes;
+    }
+}
+/** The single-value attrs a history step must never leave undefined. */
+const REPAIRED = {
+    [BLOCK_NODE]: [TYPE, LAST_CHANGED_ATTR],
+    [INLINE_NODE]: [TYPE]
+};
+/**
+ * A document's undo manager: the undo and redo stacks of the tracked local
+ * transactions in its scope. `undo()`/`redo()` replay the top step and
+ * return it (`null`: nothing changed); `stopCapturing()` closes the open
+ * step; `clear()` drops every step and releases what they kept.
+ */
+export class UndoManager {
+    undoStack = [];
+    redoStack = [];
+    /** Whether an `undo()` is replaying (its transaction is captured into the redo stack). */
+    undoing = false;
+    redoing = false;
+    /** The step a replay applies, while its transaction runs. */
+    currStackItem = null;
+    /** When the open step last took a transaction (ms since the epoch; 0: no open step). */
+    lastChange = 0;
+    captureTimeout;
+    trackedOrigins;
+    captureTransaction;
+    limit;
+    doc;
+    #rules;
+    #ops;
+    #observers = new Set();
+    /** What dropped steps released (an item is released once every step that deleted it is gone). */
+    #released;
+    #horizon;
+    constructor(rules, options = {}) {
+        this.#rules = rules;
+        this.#ops = engineOps(rules.Y);
+        this.#released = this.#ops.idSet();
+        this.doc = rules.doc;
+        this.#horizon = rules.doc.get(HORIZON_ROOT);
+        this.captureTimeout = options.captureTimeout ?? 500;
+        this.limit = options.limit ?? DEFAULT_HISTORY_LIMIT;
+        this.captureTransaction = options.captureTransaction ?? (() => true);
+        this.trackedOrigins = options.trackedOrigins ?? new Set([null]);
+        // Its own replays are tracked: an undo's transaction becomes a redo step.
+        this.trackedOrigins.add(this);
+        this.#ops.on(rules.doc, 'afterTransaction', this.#afterTransaction);
+        this.#ops.on(rules.doc, 'destroy', this.destroy);
+    }
+    /** Be told of every step taken into a stack (added, or the open one updated). Returns the unsubscribe. */
+    observe(f) {
+        this.#observers.add(f);
+        return () => this.#observers.delete(f);
+    }
+    /** The next transaction starts a step of its own. */
+    stopCapturing() {
+        this.lastChange = 0;
+    }
+    canUndo() {
+        return this.undoStack.length > 0;
+    }
+    canRedo() {
+        return this.redoStack.length > 0;
+    }
+    /** Replay the top undo step; the step, or `null` when nothing changed. */
+    undo() {
+        this.undoing = true;
+        try {
+            return this.#pop(this.undoStack);
+        }
+        finally {
+            this.undoing = false;
+        }
+    }
+    /** Replay the top redo step; the step, or `null` when nothing changed. */
+    redo() {
+        this.redoing = true;
+        try {
+            return this.#pop(this.redoStack);
+        }
+        finally {
+            this.redoing = false;
+        }
+    }
+    /** Drop every step (undo and redo) and release what they kept for their replay. */
+    clear() {
+        this.#release([...this.undoStack.splice(0), ...this.redoStack.splice(0)]);
+    }
+    destroy = () => {
+        this.trackedOrigins.delete(this);
+        this.#ops.off(this.doc, 'afterTransaction', this.#afterTransaction);
+        this.#ops.off(this.doc, 'destroy', this.destroy);
+        this.#observers.clear();
+    };
+    #inScope(item) {
+        return this.#rules.scope.some((node) => this.#ops.inside(node, item));
+    }
+    #afterTransaction = (transaction) => {
+        const tr = transaction;
+        this.#capture(tr);
+        // The purge horizon arrived: the steps below it go (`hist.purge.horizon`).
+        if (tr.changed.has(this.#horizon))
+            this.#prune();
+    };
+    #capture(tr) {
+        const ops = this.#ops;
+        const origin = tr.origin;
+        if (!this.captureTransaction(tr) ||
+            !changedUnder(tr, this.#rules.scope) ||
+            (!this.trackedOrigins.has(origin) &&
+                (!origin || !this.trackedOrigins.has(origin.constructor))))
+            return;
+        const { undoing, redoing } = this;
+        const stack = undoing ? this.redoStack : this.undoStack;
+        // A replay's step is its own; a new edit ends what could be redone.
+        if (undoing)
+            this.lastChange = 0;
+        else if (!redoing)
+            this.#release(this.redoStack.splice(0));
+        const now = getUnixTime();
+        const open = stack.at(-1);
+        const merge = open !== undefined &&
+            !undoing &&
+            !redoing &&
+            this.lastChange > 0 &&
+            now - this.lastChange < this.captureTimeout;
+        if (merge) {
+            open.deletes = ops.merge([open.deletes, tr.deleteSet]);
+            open.inserts = ops.merge([open.inserts, tr.insertSet]);
+        }
+        else
+            stack.push(new StackItem(tr.insertSet, tr.deleteSet));
+        if (!undoing && !redoing)
+            this.lastChange = now;
+        // What the step deleted is kept from collection while a step may bring it back.
+        ops.iterate(tr, tr.deleteSet, (item) => {
+            if (ops.isItem(item) && this.#inScope(item))
+                ops.keep(item);
+        });
+        const step = stack.at(-1);
+        // A streamless block's own text is shared by every replica that
+        // typed into it first: no step captures it, so undoing the first
+        // typing removes the typing and keeps the text (and nonce).
+        const own = ownTextIds.get(this.doc);
+        if (own !== undefined)
+            step.inserts = ops.diff(step.inserts, own);
+        // The undo stack keeps its newest `limit` steps.
+        const over = this.undoStack.length - this.limit;
+        if (!merge && !undoing && over > 0)
+            this.#release(this.undoStack.splice(0, over));
+        const event = {
+            stackItem: step,
+            origin: tr.origin,
+            type: undoing ? 'redo' : 'undo'
+        };
+        for (const f of this.#observers)
+            f(event, !merge);
+    }
+    /**
+     * Replay the top step of `stack` in one transaction (origin: this
+     * manager): what it inserted is deleted (or withdrawn), what it deleted
+     * comes back (text as its delete marks allow), the overwritten attrs are
+     * repaired. A step that changes nothing is skipped for the one below.
+     */
+    #pop(stack) {
+        const ops = this.#ops;
+        const { marks, withdraw, repair } = this.#rules;
+        const deletedByHistory = (id) => [this.undoStack, this.redoStack].some((s) => s.some((step) => step.deletes.has(id.client, id.clock)));
+        this.doc.transact((transaction) => {
+            const tr = transaction;
+            while (stack.length > 0 && this.currStackItem === null) {
+                const step = stack.pop();
+                const restore = new Set();
+                const remove = [];
+                let changed = false;
+                ops.iterate(tr, step.inserts, (struct) => {
+                    if (!ops.isItem(struct))
+                        return;
+                    const item = ops.latest(tr, struct);
+                    if (!item.deleted && this.#inScope(item))
+                        remove.push(item);
+                });
+                ops.iterate(tr, step.deletes, (struct) => {
+                    if (!ops.isItem(struct) || !this.#inScope(struct))
+                        return;
+                    // Created and deleted within the step: nothing to bring back.
+                    if (step.inserts.has(struct.id.client, struct.id.clock))
+                        return;
+                    // Text comes back through the delete marks (`onApply`): withheld here.
+                    if (!marks.restoreFilter(struct))
+                        changed = true;
+                    else
+                        restore.add(struct);
+                });
+                for (const item of restore)
+                    changed = ops.redo(tr, item, restore, step.inserts, deletedByHistory) !== null || changed;
+                // Children before parents: more is known when an item is judged.
+                for (let i = remove.length - 1; i >= 0; i--) {
+                    if (!withdraw(remove[i], step))
+                        ops.remove(tr, remove[i]);
+                    changed = true;
+                }
+                this.currStackItem = changed ? step : null;
+                if (changed) {
+                    marks.onApply(tr, step);
+                    repair(step);
+                }
+            }
+            tr.changed.forEach((keys, node) => {
+                if (keys.has(null))
+                    dropSearchMarkers(node);
+            });
+        }, this);
+        const step = this.currStackItem;
+        this.currStackItem = null;
+        return step;
+    }
+    /**
+     * Release what dropped steps kept for their replay: the engine collects
+     * that content now, as it would have at the delete without a history
+     * (the doc's `gcFilter` still decides: a text copy another replica may
+     * have to copy again stays, `text/deletes.ts`). An item is released only
+     * once every step that deleted part of it was dropped (the engine merges
+     * deleted items across steps): never split, so the store keeps its
+     * merged items. Only the items themselves are released: a kept
+     * container's flag may guard a newer step's items inside it.
+     */
+    #release(dropped) {
+        if (dropped.length === 0)
+            return;
+        const { Y, doc } = this.#rules;
+        const released = this.#released;
+        for (const step of dropped)
+            this.#ops.insertInto(released, step.deletes);
+        const covered = (st) => {
+            const end = st.id.clock + st.length;
+            return (released.clients.get(st.id.client)?.getIds() ?? []).some((r) => r.clock <= st.id.clock && end <= r.clock + r.len);
+        };
+        const gc = collects(doc);
+        doc.transact((tr) => {
+            for (const step of dropped)
+                walkIdSet(Y, doc, step.deletes, (st) => {
+                    const it = st;
+                    if (it.content === undefined || it.keep !== true || !covered(it))
+                        return;
+                    it.keep = false;
+                    if (gc && it.deleted && collectable(doc, it))
+                        collectNow(it, tr);
+                });
+        }, HISTORY_TRIM);
+    }
+    /**
+     * The purge horizon (`hist.purge.horizon`): every step all of whose
+     * inserts the room stored before it is dropped and released — a replay
+     * of it would bring back content the purge removed. A step that inserted
+     * nothing is kept.
+     */
+    #prune() {
+        const horizon = readHorizon(this.doc);
+        if (horizon === null)
+            return;
+        const sv = this.#rules.Y.decodeStateVector(horizon.sv);
+        const past = (step) => {
+            let any = false;
+            for (const [client, ranges] of step.inserts.clients)
+                for (const r of ranges.getIds()) {
+                    any = true;
+                    if (r.clock + r.len > (sv.get(client) ?? 0))
+                        return false;
+                }
+            return any;
+        };
+        const dropped = [];
+        for (const stack of [this.undoStack, this.redoStack]) {
+            const kept = stack.filter((step) => !past(step) || !dropped.push(step));
+            stack.splice(0, stack.length, ...kept);
+        }
+        this.#release(dropped);
+    }
+}
 /** The history factory of one facade. */
 export const docHistory = (c) => {
-    const { Y, doc, M, D, BA, releasers, init, write, disposed, actorOf, lineageDepth, lineagePending } = c;
-    const ops = engineOps(Y);
-    /** The single-value attrs a history step must never leave undefined. */
-    const REPAIRED = {
-        [BLOCK_NODE]: [TYPE, DATA, LAST_CHANGED_ATTR],
-        [INLINE_NODE]: [TYPE, DATA]
-    };
+    const { Y, doc, D, init, write, disposed } = c;
     /**
-     * Undo repair, inside the history transaction. A popped step
+     * Undo repair, inside the replay's transaction. A replayed step
      * deletes its own attr write and re-creates the value that write
      * overwrote — unless a concurrent write sits between them, where the
      * engine refuses the restore (the peer's value was deleted at
@@ -30,7 +326,7 @@ export const docHistory = (c) => {
      */
     const repairAttrs = (step) => {
         const lost = new Map();
-        walkIdSetStructs(Y, doc, step.deletes, (s) => {
+        walkIdSet(Y, doc, step.deletes, (s) => {
             const node = s.parent;
             const key = s.parentSub;
             // A collected struct (a node the room's purge removed) has no key.
@@ -54,153 +350,42 @@ export const docHistory = (c) => {
                     node.setAttr(key, value);
         }
     };
+    /**
+     * The document's undo manager, SCOPED TO THE BLOCK REGISTRY (with the
+     * text delete marks and the document's data), attached only after the
+     * doc carries the schema version record:
+     *
+     * - the `meta` root (version stamp, schema name) is outside the scope,
+     *   so `init`'s version write is undo-inert: undo can never strip
+     *   `meta.v` or resurrect a stale schema version;
+     * - attach-after-init: the deterministic bootstrap insert IS inside the
+     *   registry; this factory runs `init` first (a no-op on initialized
+     *   docs), so the bootstrap always predates capture;
+     * - remote/provider writes never enter the stack: applied updates carry
+     *   a foreign origin (and are non-local), which the tracked origins
+     *   (and the document's `captureTransaction`) leave out.
+     */
     const createUndoManager = (options = {}) => {
         if (disposed()) {
             throw new EdytorDocDisposedError('createUndoManager');
         }
-        const { limit = DEFAULT_HISTORY_LIMIT, ...opts } = options;
         write(() => {
             if (!isInitialized(doc))
                 init(doc);
         });
-        // Text delete marks (fork patch YP11): the marks are in scope (an undo removes the
-        // undoer's own), and the history restores text only as the marks allow.
-        // An undone creation withdraws the block instead of deleting it (fork patch YP12, `hist.undo.withdraw`).
+        // Text delete marks (`text/deletes.ts`): the marks are in scope (an undo
+        // removes the undoer's own), and the history restores text only as the
+        // marks allow. An undone creation withdraws the block instead of
+        // deleting it (`hist.undo.withdraw`).
         const marks = D.history(doc, () => um);
-        const um = new Y.UndoManager([M.registryOf(doc), D.scope(doc), doc.get(DOC_DATA_ROOT)].map(asYNode), {
-            ...opts,
-            ...marks,
-            onApply: (tr, step) => {
-                marks.onApply(tr, step);
-                repairAttrs(step);
-            },
-            withdraw: M.withdrawOnUndo(doc)
-        });
-        // A streamless block's own text is shared by every replica that
-        // typed into it first: no history step captures it, so undoing the
-        // first typing removes the typing and keeps the text (and nonce).
-        const skipOwnText = ({ stackItem }) => {
-            const ids = ownTextIds.get(doc);
-            if (ids !== undefined)
-                stackItem.inserts = ops.diff(stackItem.inserts, ids);
-        };
-        um.on('stack-item-added', skipOwnText);
-        um.on('stack-item-updated', skipOwnText);
-        // The undo stack keeps its newest `limit` steps. A step that
-        // falls off releases what it kept for its undo (its deleted items),
-        // and the engine collects their content now, as it would have at
-        // the delete without a history (the doc's `gcFilter` still decides:
-        // a text copy another replica may have to copy again stays, fork patch YP11).
-        // An item is released only once every step that deleted part of it
-        // fell off (the engine merges deleted items across steps): never
-        // split, so the store keeps its merged items. Only the items
-        // themselves are released: a kept container's flag may guard a
-        // newer step's items inside it.
-        const released = ops.idSet();
-        const covered = (st) => {
-            const end = st.id.clock + st.length;
-            return (released.clients.get(st.id.client)?.getIds() ?? []).some((r) => r.clock <= st.id.clock && end <= r.clock + r.len);
-        };
-        const release = (dropped) => {
-            if (dropped.length === 0)
-                return;
-            for (const step of dropped)
-                ops.insertInto(released, step.deletes);
-            const gc = collects(doc);
-            doc.transact((tr) => {
-                for (const step of dropped)
-                    walkIdSetStructs(Y, doc, step.deletes, (st) => {
-                        const it = st;
-                        if (it.content === undefined || it.keep !== true || !covered(it))
-                            return;
-                        it.keep = false;
-                        if (gc && it.deleted && collectable(doc, it))
-                            collectNow(it, tr);
-                    });
-            }, HISTORY_TRIM);
-        };
-        const trim = ({ type }) => {
-            const over = um.undoStack.length - limit;
-            if (type !== 'undo' || !(over > 0))
-                return;
-            release(stepsOf(um.undoStack.splice(0, over)));
-        };
-        um.on('stack-item-added', trim);
-        // `releaseHistory(um)`: every step dropped and released by the same rule.
-        releasers.set(um, () => release(stepsOf([...um.undoStack.splice(0), ...um.redoStack.splice(0)])));
-        // The purge horizon (`hist.purge.horizon`): when the room's purge horizon arrives,
-        // every step all of whose inserts the room stored before it is
-        // dropped and released — an undo of it would bring back content
-        // the purge removed. A step that inserted nothing is kept.
-        const horizonRoot = doc.get(HORIZON_ROOT);
-        const pastHorizon = (step, sv) => {
-            let any = false;
-            for (const [client, ranges] of step.inserts.clients)
-                for (const r of ranges.getIds()) {
-                    any = true;
-                    if (r.clock + r.len > (sv.get(client) ?? 0))
-                        return false;
-                }
-            return any;
-        };
-        const prune = () => {
-            const horizon = readHorizon(doc);
-            if (horizon === null)
-                return;
-            const sv = Y.decodeStateVector(horizon.sv);
-            const dropped = [];
-            for (const stack of [um.undoStack, um.redoStack].map((stepsOf))) {
-                const kept = stack.filter((step) => !pastHorizon(step, sv) || !dropped.push(step));
-                stack.splice(0, stack.length, ...kept);
-            }
-            release(dropped);
-        };
-        onTransaction(doc, 'afterTransaction', (tr) => {
-            if (tr.changed.has(horizonRoot))
-                prune();
-        });
-        // Lineage for undo/redo: the replay displaces the state
-        // every block the popped stack item touches, so each one's subtree
-        // is captured (`force`: lost whoever owns `l`) from the history
-        // transaction's own `beforeTransaction`, before the replay writes.
-        // The ring writes join that transaction — one update per undo —
-        // and sit outside the manager's scope, so the replay never undoes
-        // or re-captures them. Nothing else is stamped for undo/redo: the
-        // engine's replay restores `l`, and `contributors` are add-only.
-        // An undo run inside an enclosing transaction gets no lineage (it
-        // is a defect of its own: it empties the redo stack).
-        if (lineageDepth > 0) {
-            const onBefore = (tr) => {
-                const stack = um.undoing ? um.undoStack : um.redoing ? um.redoStack : [];
-                const item = stack[stack.length - 1];
-                if (tr.origin !== um || item === undefined || actorOf() === undefined)
-                    return;
-                try {
-                    const touched = new Set();
-                    for (const idSet of [item.inserts, item.deletes]) {
-                        walkIdSetStructs(Y, doc, idSet, (s) => {
-                            let n = s.parent;
-                            while (isNodeLike(n)) {
-                                const bid = n.name === BLOCK_NODE ? n.getAttr(ID) : undefined;
-                                if (typeof bid === 'string')
-                                    return void touched.add(bid);
-                                n = n._item?.parent;
-                            }
-                        });
-                    }
-                    for (const bid of touched) {
-                        const pending = lineagePending(bid, true);
-                        if (pending !== undefined)
-                            BA.appendLineage(doc, bid, pending, lineageDepth);
-                    }
-                }
-                catch (err) {
-                    // Throwing here would leave the engine's transaction open.
-                    console.error('[edytor-doc] undo lineage capture failed', err);
-                }
-            };
-            onTransaction(doc, 'beforeTransaction', onBefore);
-        }
+        const um = new UndoManager({
+            Y,
+            doc,
+            scope: [registryOf(doc), D.scope(doc), doc.get(DOC_DATA_ROOT)],
+            marks,
+            withdraw: withdrawOnUndo(doc),
+            repair: repairAttrs
+        }, options);
         return um;
     };
     return { createUndoManager };

package/dist/crdt/doc/layout.d.ts

@@ -3,7 +3,6 @@ import type { Prepared } from './types.js';
 import type { OpsContext } from './steps.js';
 /** The layout ops of one facade, prepared. */
 export declare const layoutOps: (c: OpsContext) => {
-    layoutKind: (kind?: string) => string | undefined;
     besideAt: (target: BlockId, kind?: string) => BlockId;
     placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
     wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;

package/dist/crdt/doc/layout.js

@@ -16,6 +16,8 @@ export const layoutOps = (c) => {
         const kinds = [...roles.layoutKinds()];
         return kinds.length === 1 ? kinds[0] : undefined;
     };
+    /** A fresh empty block of `type`. */
+    const spec = (type) => sanitizeSpec({ id: newId('b'), type, data: {} });
     /**
      * The block a beside placement at `target` stands beside
      * (`layout.place-beside`): a layout or an item for itself; a block whose
@@ -95,7 +97,6 @@ export const layoutOps = (c) => {
             return REFUSED;
         if (layout !== null && (isIsland(layout) || insideIsland(layout, v)))
             return REFUSED;
-        const spec = (type) => sanitizeSpec({ id: newId('b'), type, data: {} });
         const fresh = spec(item);
         const into = (parent) => moveTo(moved, parent, 0, ranksFor(parent, 0, moved.length));
         let writes;
@@ -160,7 +161,6 @@ export const layoutOps = (c) => {
         if (columns > blocks.length && !fitsIn(item, fill))
             return REFUSED;
         const ordered = blocks.toSorted((a, b) => positionOf(a).index - positionOf(b).index);
-        const spec = (type) => sanitizeSpec({ id: newId('b'), type, data: {} });
         const items = Array.from({ length: columns }, (_, i) => i < ordered.length ? spec(item) : { ...spec(item), children: [spec(fill)] });
         const wrapper = { ...spec(wrap), children: items };
         const at = positionOf(ordered[0]).index;
@@ -182,7 +182,6 @@ export const layoutOps = (c) => {
         return plan([wrapper.id], emptied(ordered, writes, kept));
     };
     return {
-        layoutKind,
         besideAt,
         placeBeside,
         wrapInLayout

package/dist/crdt/doc/meta.d.ts

@@ -1,3 +1,4 @@
+import { type JSONBlock, type JSONInlineBlock, type JSONText } from '../../utils/json.js';
 import { type DataPatch } from '../data.js';
 import { type BlockId, type BlockSpec, type ContentItem } from '../placement/model.js';
 import type { Prepared, PlanStep, DataTarget } from './types.js';
@@ -6,14 +7,13 @@ import type { OpsContext } from './steps.js';
 export declare const metaOps: (c: OpsContext) => {
     dataSteps: (target: DataTarget, patches: DataPatch[]) => PlanStep[] | null;
     replaceData: (data: unknown) => DataPatch[];
-    leafSets: (data: unknown, current: unknown) => DataPatch[];
-    retypeSteps: (id: BlockId, type: string) => PlanStep[];
     setBlockType: (id: BlockId, type: string) => Prepared;
     patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
     setBlock: (id: BlockId, value: {
         type?: string;
         data?: Record<string, unknown>;
-        content?: ContentItem[];
-        children?: BlockSpec[];
+        content?: (ContentItem | JSONText | JSONInlineBlock)[];
+        children?: (BlockSpec | JSONBlock)[];
     }) => Prepared;
 };
+export type MetaOps = ReturnType<typeof metaOps>;

package/dist/crdt/doc/meta.js

@@ -5,13 +5,13 @@
  */
 import { randOf } from '../rand.js';
 import { TYPE } from '../schema.js';
-import { sanitizeSpec, sanitizeWireJson } from '../../utils/json.js';
+import { asBlockSpec, asContentItem, sanitizeSpec, sanitizeWireJson } from '../../utils/json.js';
 import { patchWrites, leafKey, isObject } from '../data.js';
-import { promotedRank } from '../placement/model.js';
+import { collides, promotedRank, ranksAt } from '../placement/model.js';
 import { ref, refused, sanitizeItem } from './plan.js';
 /** The meta ops of one facade, prepared. */
 export const metaOps = (c) => {
-    const { doc, M, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, is, isVoid, displayLength, live, contentTarget, REFUSED, plan, moveTo, attr, leavingIsland, settle, remove, atomOf } = c;
+    const { doc, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, is, isVoid, displayLength, live, contentTarget, REFUSED, plan, moveTo, attr, leavingIsland, settle, remove, atomOf, writeContent } = c;
     /**
      * The data step of `patches` (sanitized) on a block, one of its atoms or
      * the document (`crdt/data.ts`): none when it changes nothing, `null`
@@ -52,11 +52,10 @@ export const metaOps = (c) => {
      */
     const leafSets = (data, current) => {
         const out = [];
-        const plainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
         const walk = (v, at, path) => {
-            if (plainObject(v) && Object.keys(v).length > 0 && (path.length === 0 || plainObject(at)))
+            if (isObject(v) && Object.keys(v).length > 0 && (path.length === 0 || isObject(at)))
                 for (const [k, x] of Object.entries(v))
-                    walk(x, plainObject(at) ? at[k] : undefined, [...path, k]);
+                    walk(x, isObject(at) ? at[k] : undefined, [...path, k]);
             else if (path.length > 0)
                 out.push({ path, value: v });
         };
@@ -158,15 +157,15 @@ export const metaOps = (c) => {
      */
     const setBlock = (id, value) => {
         id = ref(id);
-        const content = value.content?.map(sanitizeItem);
-        const children = value.children?.map(sanitizeSpec);
+        const content = value.content?.map((item) => sanitizeItem(asContentItem(item)));
+        const children = value.children?.map((child) => sanitizeSpec(asBlockSpec(child)));
         if (!live(id) || (content !== undefined && !contentTarget(id)))
             return REFUSED;
         const type = value.type === undefined ? undefined : ref(value.type);
         const toVoid = type === undefined ? isVoid(id) : roles.childless(type);
         if (children?.length && toVoid)
             return REFUSED;
-        if (children !== undefined && M.collides(doc, children))
+        if (children !== undefined && collides(doc, children))
             return refused('id-collision');
         const data = value.data === undefined ? [] : dataSteps(id, leafSets(value.data, blockDataOf(id)));
         if (data === null)
@@ -183,21 +182,13 @@ export const metaOps = (c) => {
             const length = displayLength(id);
             if (length > 0)
                 writes.push({ op: 'deleteText', id, offset: 0, length });
-            let at = 0;
-            for (const item of content) {
-                if (item.kind === 'inline')
-                    writes.push({ op: 'insertInline', id, offset: at++, atom: item });
-                else if (item.text !== '') {
-                    writes.push({ op: 'insertText', id, offset: at, text: item.text, marks: item.marks });
-                    at += item.text.length;
-                }
-            }
+            writeContent(writes, id, 0, content);
         }
         if (children !== undefined) {
             for (const kid of childrenIds(id))
                 writes.push(remove(kid));
             // Every current child is deleted, so the new ones rank from an empty list.
-            const ranks = M.ranksAt([], 0, children.length, doc.clientID, randOf(doc));
+            const ranks = ranksAt([], 0, children.length, doc.clientID, randOf(doc));
             if (children.length > 0)
                 writes.push({ op: 'insertBlocks', parent: id, index: 0, specs: children, ranks });
         }
@@ -206,8 +197,6 @@ export const metaOps = (c) => {
     return {
         dataSteps,
         replaceData,
-        leafSets,
-        retypeSteps,
         setBlockType,
         patchData,
         setBlock