edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/placement/model.js

@@ -1,17 +1,18 @@
 import { rankAfter, rankBetween } from './rank.js';
 import { AT, AT_NODE, BLOCK_NODE, CONTENT, CONTENT_NODE, DEL_PREFIX, hasDeleteMark, ID, CLAIMS, CLAIMS_NODE, INLINE_NODE, isNodeLike, NONCE, REGISTRY_KEY, TYPE, WITHDRAW_PREFIX } from '../schema.js';
 import { nonceOf, randOf } from '../rand.js';
-import { bindRuns } from '../text/runs.js';
+import { indexOf } from '../text/runs.js';
+import { Y } from '../engine.js';
 import { writeRunMarks } from '../text/marks.js';
-import { bindText, DEAD } from '../text/model.js';
+import { blockTextOf, DEAD, newNode, ownText as ownTextOf, splitAt } from '../text/model.js';
 import { cloneJson } from '../../utils/json.js';
 import { dataLeaves, patchWrites, writeLeaves } from '../data.js';
 import { incarnationNode, isIncarnationId } from '../incarnations.js';
-import { engineOps, newNode as makeNode } from '../structs.js';
+import { engineOps } from '../structs.js';
 export { REGISTRY_KEY };
 export { candidatesOf, resolvePlacements } from './resolve.js';
 export { promotedRank, sourceRank, SOURCE_SIDE } from './source.js';
-export { bySlot, childrenIndex, displayIndex, displayParentOf, displaySlotOf, documentOrder, isLiveIn, textRanker } from './display.js';
+export { bySlot, childrenIndex, displayParentOf, displaySlotOf, documentOrder, isLiveIn, textRanker } from './display.js';
 import { candidatesOf, resolvePlacements } from './resolve.js';
 import { bySlot, childrenIndex, displayParentOf, displaySlotOf, isLiveIn } from './display.js';
 /**
@@ -21,425 +22,423 @@ import { bySlot, childrenIndex, displayParentOf, displaySlotOf, isLiveIn } from
  * 'lib/crdt/vendor/yjs'`). Consumers inject it so this file stays free of
  * runtime vendor imports (see `engine-api.ts`).
  */
-export const bindModel = (Y) => {
-    /** Construct a detached v14 node, viewed through the structural interface. */
-    const newNode = (name) => makeNode(Y, name);
-    const { isKeptReplaced } = engineOps(Y);
-    /** The text-ownership engine (streams, claims, anchors). */
-    const T = bindText(Y);
-    /** The doc's index — every read of derived state goes through it. */
-    const R = bindRuns(Y);
-    // ── registry / record access ────────────────────────────────────────
-    const registryOf = (doc) => doc.get(REGISTRY_KEY);
-    const blockNodeOf = (doc, id) => {
-        const registry = registryOf(doc);
-        const v = registry.getAttr(id);
-        if (isNodeLike(v))
-            return v;
-        // A losing incarnation under its derived id.
-        return isIncarnationId(id) ? incarnationNode(registry, id, isKeptReplaced) : null;
-    };
-    /**
-     * The registry node when it carries no delete mark — the DELETED half of
-     * deleted-vs-hidden (a block under a deleted parent is hidden, not
-     * deleted). Not a targetability answer: ops ask {@link isLive}.
-     */
-    const liveNodeOf = (doc, id) => {
-        const n = blockNodeOf(doc, id);
-        return n !== null && !hasDeleteMark(n) ? n : null;
-    };
-    /** {@link isLiveIn} over the doc's current view. */
-    const isLive = (doc, id) => isLiveIn(view(doc), id);
-    /**
-     * The history's creation rule (fork patch YP12 `withdraw`, `hist.undo.withdraw`): an
-     * undo never deletes a block the undone step created. Its node and
-     * structure (attrs, placement candidates, the content and claims nodes)
-     * stay and the undoer's withdraw mark is written on it; what the step wrote
-     * inside the content and claims nodes (the undoer's own text, atoms,
-     * boundaries, claims) is deleted as usual. The index shows a withdrawn
-     * block while it holds another writer's content.
-     */
-    const withdrawOnUndo = (doc) => (item, stackItem) => {
-        const registry = registryOf(doc);
-        let below = null;
-        let cur = item;
-        while (cur?.parent !== registry) {
-            below = cur;
-            cur = cur?.parent?._item ?? null;
-            if (cur === null)
-                return false;
-        }
-        if (!stackItem.inserts.hasId(cur.id))
+const { isKeptReplaced } = engineOps(Y);
+// ── registry / record access ────────────────────────────────────────
+export const registryOf = (doc) => doc.get(REGISTRY_KEY);
+export const blockNodeOf = (doc, id) => {
+    const registry = registryOf(doc);
+    const v = registry.getAttr(id);
+    if (isNodeLike(v))
+        return v;
+    // A losing incarnation under its derived id.
+    return isIncarnationId(id) ? incarnationNode(registry, id, isKeptReplaced) : null;
+};
+/**
+ * The registry node when it carries no delete mark — the DELETED half of
+ * deleted-vs-hidden (a block under a deleted parent is hidden, not
+ * deleted). Not a targetability answer: ops ask {@link isLive}.
+ */
+export const liveNodeOf = (doc, id) => {
+    const n = blockNodeOf(doc, id);
+    return n !== null && !hasDeleteMark(n) ? n : null;
+};
+/** {@link isLiveIn} over the doc's current view. */
+export const isLive = (doc, id) => isLiveIn(view(doc), id);
+/**
+ * The history's creation rule (`doc/history.ts`, `hist.undo.withdraw`): an
+ * undo never deletes a block the undone step created. Its node and
+ * structure (attrs, placement candidates, the content and claims nodes)
+ * stay and the undoer's withdraw mark is written on it; what the step wrote
+ * inside the content and claims nodes (the undoer's own text, atoms,
+ * boundaries, claims) is deleted as usual. The index shows a withdrawn
+ * block while it holds another writer's content.
+ */
+export const withdrawOnUndo = (doc) => (item, stackItem) => {
+    const registry = registryOf(doc);
+    let below = null;
+    let cur = item;
+    while (cur?.parent !== registry) {
+        below = cur;
+        cur = cur?.parent?._item ?? null;
+        if (cur === null)
             return false;
-        if (below === null) {
-            const node = cur.content.type;
-            node.setAttr(WITHDRAW_PREFIX + doc.clientID, true);
-            return true;
-        }
-        return below === item || (below.parentSub !== CONTENT && below.parentSub !== CLAIMS);
-    };
-    // ── placement write ──────────────────────────────────────────────────
-    /**
-     * Atomically append one placement candidate `{p, r}` to a block's `at`
-     * map, stamped `seq = localMax+1, client = doc.clientID`, then compact:
-     * candidates below the top-2 are tombstoned (the runner-up survives as
-     * the acyclic fallback; deeper history is re-created by undo anyway).
-     * Must run inside a transaction.
-     */
-    const writePlacement = (doc, node, p, r) => {
-        const at = node.getAttr(AT);
-        if (!isNodeLike(at))
-            throw new Error(`writePlacement: block missing at-map`);
-        const cands = candidatesOf(node);
-        const seq = (cands[0]?.seq ?? 0) + 1;
-        // Tombstone everything below the runner-up (top-2 kept).
-        for (const c of cands.slice(2))
-            at.deleteAttr(c.key);
-        at.setAttr(`${seq}.${doc.clientID}`, { p, r });
-    };
-    // ── derived state ───────────────────────────────────────────────────
-    /** The doc's index as a `ModelView` — folded up to the open transaction's last write. */
-    const view = (doc) => R.attach(doc).view();
-    // ── content (rich-text sequence) helpers ────────────────────────────
-    /** A detached inline-atom node (inputs arrive normalized by the facade's ingress). */
-    const buildInline = (atom) => {
-        const node = newNode(INLINE_NODE);
-        node.setAttr(ID, atom.id);
-        node.setAttr(TYPE, atom.type);
-        writeLeaves(node, dataLeaves(atom.data));
-        return node;
-    };
-    // ── structural predicates ───────────────────────────────────────────
-    /**
-     * True iff `maybeAncestor` is `id` itself or lies on `id`'s
-     * DISPLAY-ancestor chain — the composed relation `owner(parent)`
-     * (`displayParentOf`), not the raw placement chain. A merge claim can
-     * place a block inside another's display subtree without appearing in
-     * its raw ancestry, so the merge refusal must see through the claim
-     * redirect — this is exactly the relation `resolvePlacements` keeps
-     * acyclic: a merge that would close a cycle is refused without mutation.
-     */
-    const isSelfOrDescendant = (placements, own, id, maybeAncestor) => {
-        let cur = id;
-        const seen = new Set();
-        while (cur !== null && !seen.has(cur)) {
-            if (cur === maybeAncestor)
-                return true;
-            seen.add(cur);
-            const pl = placements.get(cur);
-            if (pl === undefined)
-                break;
-            const dp = displayParentOf(own, pl, placements, cur);
-            if (dp === DEAD)
-                break; // unknown ancestor — hidden, not cyclic
-            cur = dp;
-        }
+    }
+    if (!cur.id || !stackItem.inserts.has(cur.id.client, cur.id.clock))
         return false;
-    };
-    // ── write primitives ────────────────────────────────────────────────
-    // The document's prepared plans decide every write; these only
-    // perform one planned step and never refuse. Must run inside a transaction.
-    /**
-     * `count` consecutive insertion ranks at `index` into the sibling list
-     * `siblings`.
-     *
-     * Degenerate seams (`left >= right`) are legal replicated states, not
-     * caller errors: equal-rank neighbours occur after cycle-fallback
-     * rehoming (two blocks may carry the same rank string minted in
-     * different sibling lists), and `rankBetween` THROWS on them — so
-     * callers must guard. No string sorts strictly between equal strings,
-     * so each new member takes `left` verbatim: it JOINS the tie and the
-     * `(rank, id)` display sort orders the whole group deterministically.
-     * On a valid seam the emitted chain is `rankBetween(left, right)` then
-     * `rankBetween(prev, right)` — with `run`, `rankAfter` (an insert: after a
-     * block this client ranked, in its run there).
-     */
-    const ranksAt = (siblings, index, count, clientId, rand, run = false) => {
-        let left = siblings[index - 1]?.rank;
-        const right = siblings[index]?.rank;
-        if (left !== undefined && right !== undefined && left >= right) {
-            return new Array(count).fill(left);
+    if (below === null) {
+        const node = cur.content.type;
+        node.setAttr(WITHDRAW_PREFIX + doc.clientID, true);
+        return true;
+    }
+    return below === item || (below.parentSub !== CONTENT && below.parentSub !== CLAIMS);
+};
+// ── placement write ──────────────────────────────────────────────────
+/**
+ * Atomically append one placement candidate `{p, r}` to a block's `at`
+ * map, stamped `seq = localMax+1, client = doc.clientID`, then compact:
+ * candidates below the top-2 are tombstoned (the runner-up survives as
+ * the acyclic fallback; deeper history is re-created by undo anyway).
+ * Must run inside a transaction.
+ */
+export const writePlacement = (doc, node, p, r) => {
+    const at = node.getAttr(AT);
+    if (!isNodeLike(at))
+        throw new Error(`writePlacement: block missing at-map`);
+    const cands = candidatesOf(node);
+    const seq = (cands[0]?.seq ?? 0) + 1;
+    // Tombstone everything below the runner-up (top-2 kept).
+    for (const c of cands.slice(2))
+        at.deleteAttr(c.key);
+    at.setAttr(`${seq}.${doc.clientID}`, { p, r });
+};
+// ── derived state ───────────────────────────────────────────────────
+/** The doc's index as a `ModelView` — folded up to the open transaction's last write. */
+export const view = (doc) => indexOf(doc).view();
+// ── content (rich-text sequence) helpers ────────────────────────────
+/** A detached inline-atom node (inputs arrive normalized by the facade's ingress). */
+export const buildInline = (atom) => {
+    const node = newNode(INLINE_NODE);
+    node.setAttr(ID, atom.id);
+    node.setAttr(TYPE, atom.type);
+    writeLeaves(node, dataLeaves(atom.data));
+    return node;
+};
+// ── structural predicates ───────────────────────────────────────────
+/**
+ * True iff `maybeAncestor` is `id` itself or lies on `id`'s
+ * DISPLAY-ancestor chain — the composed relation `owner(parent)`
+ * (`displayParentOf`), not the raw placement chain. A merge claim can
+ * place a block inside another's display subtree without appearing in
+ * its raw ancestry, so the merge refusal must see through the claim
+ * redirect — this is exactly the relation `resolvePlacements` keeps
+ * acyclic: a merge that would close a cycle is refused without mutation.
+ */
+export const isSelfOrDescendant = (placements, own, id, maybeAncestor) => {
+    let cur = id;
+    const seen = new Set();
+    while (cur !== null && !seen.has(cur)) {
+        if (cur === maybeAncestor)
+            return true;
+        seen.add(cur);
+        const pl = placements.get(cur);
+        if (pl === undefined)
+            break;
+        const dp = displayParentOf(own, pl, placements, cur);
+        if (dp === DEAD)
+            break; // unknown ancestor — hidden, not cyclic
+        cur = dp;
+    }
+    return false;
+};
+// ── write primitives ────────────────────────────────────────────────
+// The document's prepared plans decide every write; these only
+// perform one planned step and never refuse. Must run inside a transaction.
+/**
+ * `count` consecutive insertion ranks at `index` into the sibling list
+ * `siblings`.
+ *
+ * Degenerate seams (`left >= right`) are legal replicated states, not
+ * caller errors: equal-rank neighbours occur after cycle-fallback
+ * rehoming (two blocks may carry the same rank string minted in
+ * different sibling lists), and `rankBetween` THROWS on them — so
+ * callers must guard. No string sorts strictly between equal strings,
+ * so each new member takes `left` verbatim: it JOINS the tie and the
+ * `(rank, id)` display sort orders the whole group deterministically.
+ * On a valid seam the emitted chain is `rankBetween(left, right)` then
+ * `rankBetween(prev, right)` — with `run`, `rankAfter` (an insert: after a
+ * block this client ranked, in its run there).
+ */
+export const ranksAt = (siblings, index, count, clientId, rand, run = false) => {
+    let left = siblings[index - 1]?.rank;
+    const right = siblings[index]?.rank;
+    if (left !== undefined && right !== undefined && left >= right) {
+        return new Array(count).fill(left);
+    }
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        // An insert extends this client's run after a block it ranked.
+        const r = run
+            ? rankAfter(left, right, clientId, rand)
+            : rankBetween(left, right, clientId, rand);
+        out.push(r);
+        left = r;
+    }
+    return out;
+};
+/**
+ * One registry entry: the block node with its `claims` list (holding
+ * `claims`), its own backing text holding `items` (none for a split-born
+ * block: its stream lives in the text it was split from), and the atomic
+ * first placement candidate `{p, r}` stamped `1.clientID`. Pre-integration
+ * writes materialize when the node integrates (the registry write comes last).
+ */
+const createBlock = (doc, id, type, data, place, claims, items, n = nonceOf(doc)) => {
+    const node = newNode(BLOCK_NODE);
+    node.setAttr(ID, id);
+    node.setAttr(NONCE, n);
+    node.setAttr(TYPE, type);
+    writeLeaves(node, dataLeaves(data));
+    const content = items === null ? null : textOf(items);
+    if (content !== null)
+        node.setAttr(CONTENT, content);
+    const list = newNode(CLAIMS_NODE);
+    node.setAttr(CLAIMS, list);
+    if (claims.length > 0)
+        list.insert(0, claims);
+    const at = newNode(AT_NODE);
+    node.setAttr(AT, at);
+    at.setAttr(`1.${doc.clientID}`, place);
+    registryOf(doc).setAttr(id, node);
+    if (content !== null)
+        markText(doc, content, items);
+};
+/** A detached backing text holding `items`, unmarked ({@link markText} marks it once integrated). */
+const textOf = (items) => {
+    const content = newNode(CONTENT_NODE);
+    let clen = 0;
+    for (const item of items) {
+        if (item.kind === 'text') {
+            content.insert(clen, item.text);
+            clen += item.text.length;
         }
-        const out = [];
-        for (let i = 0; i < count; i++) {
-            // An insert extends this client's run after a block it ranked.
-            const r = run
-                ? rankAfter(left, right, clientId, rand)
-                : rankBetween(left, right, clientId, rand);
-            out.push(r);
-            left = r;
+        else {
+            content.insert(clen++, [buildInline(item)]);
         }
-        return out;
-    };
-    /**
-     * One registry entry: the block node with its `claims` list (holding
-     * `claims`), its own backing text holding `items` (none for a split-born
-     * block: its stream lives in the text it was split from), and the atomic
-     * first placement candidate `{p, r}` stamped `1.clientID`. Pre-integration
-     * writes materialize when the node integrates (the registry write comes last).
-     */
-    const createBlock = (doc, id, type, data, place, claims, items, n = nonceOf(doc)) => {
-        const node = newNode(BLOCK_NODE);
-        node.setAttr(ID, id);
-        node.setAttr(NONCE, n);
-        node.setAttr(TYPE, type);
-        writeLeaves(node, dataLeaves(data));
-        const content = items === null ? null : textOf(items);
-        if (content !== null)
-            node.setAttr(CONTENT, content);
-        const list = newNode(CLAIMS_NODE);
-        node.setAttr(CLAIMS, list);
-        if (claims.length > 0)
-            list.insert(0, claims);
-        const at = newNode(AT_NODE);
-        node.setAttr(AT, at);
-        at.setAttr(`1.${doc.clientID}`, place);
-        registryOf(doc).setAttr(id, node);
-        if (content !== null)
-            markText(doc, content, items);
-    };
-    /** A detached backing text holding `items`, unmarked ({@link markText} marks it once integrated). */
-    const textOf = (items) => {
-        const content = newNode(CONTENT_NODE);
-        let clen = 0;
-        for (const item of items) {
-            if (item.kind === 'text') {
-                content.insert(clen, item.text);
-                clen += item.text.length;
-            }
-            else {
-                content.insert(clen++, [buildInline(item)]);
+    }
+    return content;
+};
+/** The marks of `items`, written as paired operations on their integrated text. */
+const markText = (doc, content, items) => writeRunMarks(doc, content, 0, items.map((item) => item.kind === 'text'
+    ? { length: item.text.length, marks: item.marks }
+    : { length: 1 }));
+/**
+ * Restore definition (migration only; a first import
+ * restores into an empty doc): make `specs` the whole visible document
+ * under their own ids, in ONE transaction. An existing id keeps its
+ * registry entry: every delete mark is cleared and its type, data,
+ * placement and content are rewritten in place — a fresh own text holding
+ * the spec's content and an empty claims list; a block whose stream still
+ * starts at a live boundary gets a new nonce, so that boundary goes inert
+ * and the own text is its stream. An absent id is created. Every other
+ * block gets this writer's delete mark. Ranks are derived from the tree
+ * alone and the rewrites are last-writer-wins attrs, so two replicas
+ * restoring the same specs converge on one copy.
+ */
+export const restoreBlocks = (doc, specs) => doc.transact(() => {
+    const { own } = view(doc);
+    const keep = new Set();
+    const restore = (list, parent) => {
+        let rank;
+        for (const sp of list) {
+            keep.add(sp.id);
+            let node = blockNodeOf(doc, sp.id);
+            if (node === null) {
+                node = newNode(BLOCK_NODE);
+                node.setAttr(ID, sp.id);
+                node.setAttr(NONCE, nonceOf(doc));
+                node.setAttr(AT, newNode(AT_NODE));
+                registryOf(doc).setAttr(sp.id, node);
             }
-        }
-        return content;
-    };
-    /** The marks of `items`, written as paired operations on their integrated text. */
-    const markText = (doc, content, items) => writeRunMarks(doc, content, 0, items.map((item) => item.kind === 'text'
-        ? { length: item.text.length, marks: item.marks }
-        : { length: 1 }));
-    /**
-     * Restore definition (migration only; a first import
-     * restores into an empty doc): make `specs` the whole visible document
-     * under their own ids, in ONE transaction. An existing id keeps its
-     * registry entry: every delete mark is cleared and its type, data,
-     * placement and content are rewritten in place — a fresh own text holding
-     * the spec's content and an empty claims list; a block whose stream still
-     * starts at a live boundary gets a new nonce, so that boundary goes inert
-     * and the own text is its stream. An absent id is created. Every other
-     * block gets this writer's delete mark. Ranks are derived from the tree
-     * alone and the rewrites are last-writer-wins attrs, so two replicas
-     * restoring the same specs converge on one copy.
-     */
-    const restoreBlocks = (doc, specs) => doc.transact(() => {
-        const { own } = view(doc);
-        const keep = new Set();
-        const restore = (list, parent) => {
-            let rank;
-            for (const sp of list) {
-                keep.add(sp.id);
-                let node = blockNodeOf(doc, sp.id);
-                if (node === null) {
-                    node = newNode(BLOCK_NODE);
-                    node.setAttr(ID, sp.id);
-                    node.setAttr(NONCE, nonceOf(doc));
-                    node.setAttr(AT, newNode(AT_NODE));
-                    registryOf(doc).setAttr(sp.id, node);
-                }
-                else if (own.streamOf(sp.id)?.home !== sp.id && own.streamOf(sp.id) !== undefined) {
-                    node.setAttr(NONCE, nonceOf(doc));
-                }
-                for (const key of [...node.attrKeys()]) {
-                    if (key.startsWith(DEL_PREFIX) || key.startsWith(WITHDRAW_PREFIX))
-                        node.deleteAttr(key);
-                }
-                if (node.getAttr(TYPE) !== sp.type)
-                    node.setAttr(TYPE, sp.type);
-                writeLeaves(node, patchWrites(node, [{ path: [], value: sp.data ?? {} }]) ?? []);
-                const text = textOf(sp.content ?? []);
-                node.setAttr(CONTENT, text);
-                markText(doc, text, sp.content ?? []);
-                node.setAttr(CLAIMS, newNode(CLAIMS_NODE));
-                rank = rankBetween(rank, undefined, 0, () => 0);
-                writePlacement(doc, node, parent, rank);
-                restore(sp.children ?? [], sp.id);
+            else if (own.streamOf(sp.id)?.home !== sp.id && own.streamOf(sp.id) !== undefined) {
+                node.setAttr(NONCE, nonceOf(doc));
             }
-        };
-        restore(specs, null);
-        registryOf(doc).forEachAttr((node, id) => {
-            if (!keep.has(id) && isNodeLike(node) && !hasDeleteMark(node)) {
-                node.setAttr(DEL_PREFIX + doc.clientID, true);
+            for (const key of [...node.attrKeys()]) {
+                if (key.startsWith(DEL_PREFIX) || key.startsWith(WITHDRAW_PREFIX))
+                    node.deleteAttr(key);
             }
-        });
-    });
-    /**
-     * Materialize one spec subtree: the block owns its backing text (its
-     * stream from index 0); children recurse under a fresh sequential rank
-     * chain (a new block has no siblings to interleave with).
-     */
-    const materializeSpec = (doc, sp, parent, rank) => {
-        createBlock(doc, sp.id, sp.type, sp.data, { p: parent, r: rank }, [], sp.content ?? []);
-        let left;
-        for (const child of sp.children ?? []) {
-            const r = rankBetween(left, undefined, doc.clientID, randOf(doc));
-            materializeSpec(doc, child, sp.id, r);
-            left = r;
+            if (node.getAttr(TYPE) !== sp.type)
+                node.setAttr(TYPE, sp.type);
+            writeLeaves(node, patchWrites(node, [{ path: [], value: sp.data ?? {} }]) ?? []);
+            const text = textOf(sp.content ?? []);
+            node.setAttr(CONTENT, text);
+            markText(doc, text, sp.content ?? []);
+            node.setAttr(CLAIMS, newNode(CLAIMS_NODE));
+            rank = rankBetween(rank, undefined, 0, () => 0);
+            writePlacement(doc, node, parent, rank);
+            restore(sp.children ?? [], sp.id);
         }
     };
-    /**
-     * Does any id of `specs` (whole subtrees) collide — with another spec id,
-     * or with any registry entry, live or deleted? The registry is keyed by
-     * id, so writing a taken id would replace that block in place.
-     */
-    const collides = (doc, specs) => {
-        const seen = new Set();
-        const stack = [...specs];
-        while (stack.length > 0) {
-            const sp = stack.pop();
-            // A derived incarnation id (U+0000) is never a caller's.
-            if (seen.has(sp.id) || isIncarnationId(sp.id) || blockNodeOf(doc, sp.id) !== null)
-                return true;
-            seen.add(sp.id);
-            stack.push(...(sp.children ?? []));
+    restore(specs, null);
+    registryOf(doc).forEachAttr((node, id) => {
+        if (!keep.has(id) && isNodeLike(node) && !hasDeleteMark(node)) {
+            node.setAttr(DEL_PREFIX + doc.clientID, true);
         }
-        return false;
-    };
-    /**
-     * The seed writer's bulk insert (the document is written by document
-     * operations and, once, by the seed writer — `init`, the local
-     * materializer): `specs` (whole subtrees, in list order) at `dest` in one
-     * transaction, all-or-nothing — `false` without writing when the parent
-     * is not live or any id collides. Document operations never call it:
-     * they prepare their inserts (`insertBlocks` in the facade).
-     */
-    const insertBlocks = (doc, dest, specs) => {
-        if (specs.length === 0)
-            return true;
-        if (dest.parent !== null && !isLive(doc, dest.parent))
-            return false;
-        if (collides(doc, specs))
-            return false;
-        return doc.transact(() => {
-            const sibs = view(doc).kids.get(dest.parent) ?? [];
-            const at = Math.max(0, Math.min(dest.index, sibs.length));
-            const ranks = ranksAt(sibs, at, specs.length, doc.clientID, randOf(doc));
-            specs.forEach((sp, i) => materializeSpec(doc, sp, dest.parent, ranks[i]));
+    });
+});
+/**
+ * Materialize one spec subtree: the block owns its backing text (its
+ * stream from index 0); children recurse under a fresh sequential rank
+ * chain (a new block has no siblings to interleave with).
+ */
+export const materializeSpec = (doc, sp, parent, rank) => {
+    createBlock(doc, sp.id, sp.type, sp.data, { p: parent, r: rank }, [], sp.content ?? []);
+    let left;
+    for (const child of sp.children ?? []) {
+        const r = rankBetween(left, undefined, doc.clientID, randOf(doc));
+        materializeSpec(doc, child, sp.id, r);
+        left = r;
+    }
+};
+/**
+ * Does any id of `specs` (whole subtrees) collide — with another spec id,
+ * or with any registry entry, live or deleted? The registry is keyed by
+ * id, so writing a taken id would replace that block in place.
+ */
+export const collides = (doc, specs) => {
+    const seen = new Set();
+    const stack = [...specs];
+    while (stack.length > 0) {
+        const sp = stack.pop();
+        // A derived incarnation id (U+0000) is never a caller's.
+        if (seen.has(sp.id) || isIncarnationId(sp.id) || blockNodeOf(doc, sp.id) !== null)
             return true;
-        });
-    };
-    /**
-     * Split `id` at content `offset` into the new block `newId` placed at
-     * `place`: one boundary item for `newId` at the end of the gap at `offset`
-     * (fork patch YP7) and the merge claims that follow it re-inserted on the new block —
-     * no text is copied, so an offline edit to the tail keeps landing on the
-     * same items and displays in the new block after convergence. `tail` is
-     * the new block's type/data, decided once by the plan. Children are a
-     * separate step. `id` must have a stream or a claim ({@link ownText}).
-     */
-    const writeSplit = (doc, id, offset, newId, tail, place) => {
-        const { blocks, own } = view(doc);
-        const n = nonceOf(doc);
-        const claims = T.splitAt(blocks, own, id, offset, newId, n);
-        const data = tail.data === undefined ? undefined : cloneJson(tail.data);
-        createBlock(doc, newId, tail.type, data, place, claims, null, n);
-    };
-    /**
-     * Give the streamless block `id` its own text (`T.ownText`: a derived
-     * writer, a re-minted nonce) — before the first write that needs a stream.
-     */
-    const ownText = (doc, id) => T.ownText(doc, view(doc).blocks.get(id));
-    // ── queries ─────────────────────────────────────────────────────────
-    /**
-     * Canonical projection: pure derivation from replicated state — the
-     * visible tree of live blocks ordered by `(rank, id)`, children of a
-     * merged-away parent under its owner, those of a deleted parent in its
-     * slot ({@link displaySlotOf}). Content is each block's display.
-     */
-    const project = (doc) => ({ children: R.attach(doc).project() });
-    /**
-     * `positionOf` in a view: the display parent and the index among its
-     * visible children — a binary search by the block's display rank (the
-     * list's own order), not a scan of its siblings.
-     */
-    const positionInView = (v, id) => {
-        if (!isLiveIn(v, id))
-            return null;
-        const slot = displaySlotOf(v.own, v.placements, v.placements.get(id), id);
-        const dp = slot.parent;
-        const list = v.kids.get(dp) ?? [];
-        let [lo, hi] = [0, list.length];
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (bySlot(list[mid], { id, rank: slot.rank }) < 0)
-                lo = mid + 1;
-            else
-                hi = mid;
-        }
-        const index = list[lo]?.id === id ? lo : list.findIndex((s) => s.id === id);
-        return index < 0 ? null : { parent: dp, index };
-    };
-    /**
-     * `{parent, index}` of `id` in the visible tree, or null when hidden/absent.
-     * `parent` is the DISPLAY parent (merged-away ancestors resolve to their
-     * owner — see `displayParentOf`).
-     */
-    const positionOf = (doc, id) => positionInView(view(doc), id);
-    /** Pre-order ids of the visible tree — the document order. */
-    const listBlockIds = (doc) => [...view(doc).order.ids];
-    /** Flat text of a block's OWNED content (atoms render as ''). */
-    const blockText = (doc, id) => {
-        const v = view(doc);
-        return isLiveIn(v, id) ? T.blockTextOf(id, v.blocks, v.own) : null;
-    };
-    /**
-     * Engine identity of the registry entry (`client:clock` of its item), or
-     * null when the block is absent from the visible tree (deleted, or hidden
-     * under a deleted/unreachable ancestor).
-     */
-    const crdtId = (doc, id) => {
-        if (!isLive(doc, id))
-            return null;
-        const node = blockNodeOf(doc, id);
-        const item = node?._item;
-        if (!node || !item || item.deleted || !item.id)
-            return null;
-        return `${item.id.client}:${item.id.clock}`;
-    };
-    /** Engine handle for a logical id, or null when absent or delete-marked (debug surface). */
-    const resolveBlock = (doc, id) => liveNodeOf(doc, id);
-    return {
-        // constants
-        REGISTRY_KEY,
-        // records / projection internals (exported for tests + ADR probes)
-        registryOf,
-        blockNodeOf,
-        liveNodeOf,
-        isLive,
-        candidatesOf,
-        /** The doc's index as a `ModelView`. */
-        view,
-        resolvePlacements,
-        childrenIndex,
-        positionInView,
-        // write primitives (the document's prepared plans apply these)
-        buildInline,
-        isSelfOrDescendant,
-        ranksAt,
-        writePlacement,
-        withdrawOnUndo,
-        materializeSpec,
-        collides,
-        writeSplit,
-        ownText,
-        // the seed writer's bulk insert
-        insertBlocks,
-        insertBlock: (doc, dest, spec) => insertBlocks(doc, dest, [spec]),
-        restoreBlocks,
-        // queries
-        project,
-        positionOf,
-        listBlockIds,
-        blockText,
-        crdtId,
-        resolveBlock
-    };
+        seen.add(sp.id);
+        stack.push(...(sp.children ?? []));
+    }
+    return false;
 };
+/**
+ * The seed writer's bulk insert (the document is written by document
+ * operations and, once, by the seed writer — `init`, the local
+ * materializer): `specs` (whole subtrees, in list order) at `dest` in one
+ * transaction, all-or-nothing — `false` without writing when the parent
+ * is not live or any id collides. Document operations never call it:
+ * they prepare their inserts (`insertBlocks` in the facade).
+ */
+export const insertBlocks = (doc, dest, specs) => {
+    if (specs.length === 0)
+        return true;
+    if (dest.parent !== null && !isLive(doc, dest.parent))
+        return false;
+    if (collides(doc, specs))
+        return false;
+    return doc.transact(() => {
+        const sibs = view(doc).kids.get(dest.parent) ?? [];
+        const at = Math.max(0, Math.min(dest.index, sibs.length));
+        const ranks = ranksAt(sibs, at, specs.length, doc.clientID, randOf(doc));
+        specs.forEach((sp, i) => materializeSpec(doc, sp, dest.parent, ranks[i]));
+        return true;
+    });
+};
+/** {@link insertBlocks} of one spec. */
+export const insertBlock = (doc, dest, spec) => insertBlocks(doc, dest, [spec]);
+/**
+ * Split `id` at content `offset` into the new block `newId` placed at
+ * `place`: one boundary item for `newId` at the end of the gap at `offset`
+ * (fork patch YP7) and the merge claims that follow it re-inserted on the new block —
+ * no text is copied, so an offline edit to the tail keeps landing on the
+ * same items and displays in the new block after convergence. `tail` is
+ * the new block's type/data, decided once by the plan. Children are a
+ * separate step. `id` must have a stream or a claim ({@link ownText}).
+ */
+export const writeSplit = (doc, id, offset, newId, tail, place) => {
+    const { blocks, own } = view(doc);
+    const n = nonceOf(doc);
+    const claims = splitAt(blocks, own, id, offset, newId, n);
+    const data = tail.data === undefined ? undefined : cloneJson(tail.data);
+    createBlock(doc, newId, tail.type, data, place, claims, null, n);
+};
+/**
+ * Give the streamless block `id` its own text (`T.ownText`: a derived
+ * writer, a re-minted nonce) — before the first write that needs a stream.
+ */
+export const ownText = (doc, id) => ownTextOf(doc, view(doc).blocks.get(id));
+// ── queries ─────────────────────────────────────────────────────────
+/**
+ * Canonical projection: pure derivation from replicated state — the
+ * visible tree of live blocks ordered by `(rank, id)`, children of a
+ * merged-away parent under its owner, those of a deleted parent in its
+ * slot ({@link displaySlotOf}). Content is each block's display.
+ */
+export const project = (doc) => ({ children: indexOf(doc).project() });
+/**
+ * `positionOf` in a view: the display parent and the index among its
+ * visible children — a binary search by the block's display rank (the
+ * list's own order), not a scan of its siblings.
+ */
+export const positionInView = (v, id) => {
+    if (!isLiveIn(v, id))
+        return null;
+    const slot = displaySlotOf(v.own, v.placements, v.placements.get(id), id);
+    const dp = slot.parent;
+    const list = v.kids.get(dp) ?? [];
+    let [lo, hi] = [0, list.length];
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (bySlot(list[mid], { id, rank: slot.rank }) < 0)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    const index = list[lo]?.id === id ? lo : list.findIndex((s) => s.id === id);
+    return index < 0 ? null : { parent: dp, index };
+};
+/**
+ * `{parent, index}` of `id` in the visible tree, or null when hidden/absent.
+ * `parent` is the DISPLAY parent (merged-away ancestors resolve to their
+ * owner — see `displayParentOf`).
+ */
+export const positionOf = (doc, id) => positionInView(view(doc), id);
+/** Pre-order ids of the visible tree — the document order. */
+export const listBlockIds = (doc) => [...view(doc).order.ids];
+/** Flat text of a block's OWNED content (atoms render as ''). */
+export const blockText = (doc, id) => {
+    const v = view(doc);
+    return isLiveIn(v, id) ? blockTextOf(id, v.blocks, v.own) : null;
+};
+/**
+ * Engine identity of the registry entry (`client:clock` of its item), or
+ * null when the block is absent from the visible tree (deleted, or hidden
+ * under a deleted/unreachable ancestor).
+ */
+export const crdtId = (doc, id) => {
+    if (!isLive(doc, id))
+        return null;
+    const node = blockNodeOf(doc, id);
+    const item = node?._item;
+    if (!node || !item || item.deleted || !item.id)
+        return null;
+    return `${item.id.client}:${item.id.clock}`;
+};
+/** Engine handle for a logical id, or null when absent or delete-marked (debug surface). */
+export const resolveBlock = (doc, id) => liveNodeOf(doc, id);
+/**
+ * The placement model as one object (the public binding's `model`): the
+ * primitives above. Edytor's own modules import them directly.
+ */
+export const bindModel = (_Y) => ({
+    // constants
+    REGISTRY_KEY,
+    // records / projection internals (exported for tests + ADR probes)
+    registryOf,
+    blockNodeOf,
+    liveNodeOf,
+    isLive,
+    candidatesOf,
+    /** The doc's index as a `ModelView`. */
+    view,
+    resolvePlacements,
+    childrenIndex,
+    positionInView,
+    // write primitives (the document's prepared plans apply these)
+    buildInline,
+    isSelfOrDescendant,
+    ranksAt,
+    writePlacement,
+    withdrawOnUndo,
+    materializeSpec,
+    collides,
+    writeSplit,
+    ownText,
+    // the seed writer's bulk insert
+    insertBlocks,
+    insertBlock,
+    restoreBlocks,
+    // queries
+    project,
+    positionOf,
+    listBlockIds,
+    blockText,
+    crdtId,
+    resolveBlock
+});