edytor 3.0.0 → 5.0.0

package/dist/crdt/placement/model.js

@@ -1,27 +1,19 @@
-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 { BLOCK_NODE, CONTENT, CONTENT_NODE, DEL_PREFIX, hasDeleteMark, ID, INLINE_NODE, isNodeLike, NONCE, REGISTRY_KEY, TYPE, WITHDRAW_PREFIX } from '../schema.js';
+import { nonceOf } from '../rand.js';
 import { indexOf } from '../text/runs.js';
 import { Y } from '../engine.js';
 import { writeRunMarks } from '../text/marks.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 { blockTextOf, DEAD, deleteClaims, newNode, ownText as ownTextOf, splitAt } from '../text/model.js';
+import { cloneJsonSafe } from '../../utils/json.js';
+import { dataWrites, patchWrites, writeData } from '../data.js';
 import { incarnationNode, isIncarnationId } from '../incarnations.js';
-import { engineOps } from '../structs.js';
+import { engineOps, firstItem, storeOf } from '../structs.js';
+import { anchorOf, isBlockSlot, isRecord, nodeOf, placeAfter, sameUnit, shownBy, stampOf, triples, unitOf, unitsOf } from './slots.js';
+import { ownerOfNode, slotOwner } from './resolve.js';
 export { REGISTRY_KEY };
-export { candidatesOf, resolvePlacements } from './resolve.js';
-export { promotedRank, sourceRank, SOURCE_SIDE } from './source.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';
-/**
- * Bind the placement model to a concrete engine surface.
- *
- * `Y` must be the vendored v14 module (`import * as Y from
- * 'lib/crdt/vendor/yjs'`). Consumers inject it so this file stays free of
- * runtime vendor imports (see `engine-api.ts`).
- */
+export { promotedRank } from './keys.js';
+export { bySlot, childrenIndex, displayParentOf, displaySlotOf, documentOrder, isLiveIn } from './display.js';
+import { bySlot, childrenIndex, displaySlotOf, displayParentOf, isLiveIn } from './display.js';
 const { isKeptReplaced } = engineOps(Y);
 // ── registry / record access ────────────────────────────────────────
 export const registryOf = (doc) => doc.get(REGISTRY_KEY);
@@ -47,14 +39,24 @@ 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
+ * structure (attrs, its home slot in its parent's sequence, the content
+ * node) stay and the undoer's withdraw mark is written on it; what the step
+ * wrote inside the content node (the undoer's own text, atoms, boundaries,
+ * claims) is deleted as usual, and so are the move records and data slots
+ * the step wrote in the created node's sequence. The index shows a withdrawn
  * block while it holds another writer's content.
  */
 export const withdrawOnUndo = (doc) => (item, stackItem) => {
     const registry = registryOf(doc);
+    const created = (id) => {
+        const node = registry.getAttr(id);
+        const entry = isNodeLike(node) ? node._item : null;
+        return !!entry?.id && stackItem.inserts.has(entry.id.client, entry.id.clock);
+    };
+    // A home slot of a block the step created stays with the block (withdrawn, not gone).
+    const seq = item;
+    if (seq?.parentSub === null && seq.content?.arr !== undefined)
+        return seq.content.arr.every((v) => isBlockSlot(v) && created(v.b));
     let below = null;
     let cur = item;
     while (cur?.parent !== registry) {
@@ -63,33 +65,18 @@ export const withdrawOnUndo = (doc) => (item, stackItem) => {
         if (cur === null)
             return false;
     }
-    if (!cur.id || !stackItem.inserts.has(cur.id.client, cur.id.clock))
+    if (!cur.id || cur.parentSub === null || !stackItem.inserts.has(cur.id.client, cur.id.clock))
         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.
- */
-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 });
+    // The created node's own attrs stay (its content node among them); the records and data
+    // slots of its sequence go, and so does what the step wrote inside the content node.
+    if (below === item)
+        return below.parentSub !== null;
+    return below.parentSub !== CONTENT;
 };
 // ── derived state ───────────────────────────────────────────────────
 /** The doc's index as a `ModelView` — folded up to the open transaction's last write. */
@@ -100,7 +87,7 @@ export const buildInline = (atom) => {
     const node = newNode(INLINE_NODE);
     node.setAttr(ID, atom.id);
     node.setAttr(TYPE, atom.type);
-    writeLeaves(node, dataLeaves(atom.data));
+    writeData(node, dataWrites(atom.data));
     return node;
 };
 // ── structural predicates ───────────────────────────────────────────
@@ -110,7 +97,7 @@ export const buildInline = (atom) => {
  * (`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
+ * redirect — this is exactly the relation the index's placements keep
  * acyclic: a merge that would close a cycle is refused without mutation.
  */
 export const isSelfOrDescendant = (placements, own, id, maybeAncestor) => {
@@ -133,62 +120,152 @@ export const isSelfOrDescendant = (placements, own, id, maybeAncestor) => {
 // ── write primitives ────────────────────────────────────────────────
 // The document's prepared plans decide every write; these only
 // perform one planned step and never refuse. Must run inside a transaction.
+/** The sequence node of `parent` (`null`: the root's). */
+const sequenceOf = (doc, parent) => parent === null ? registryOf(doc) : blockNodeOf(doc, parent);
 /**
- * `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).
+ * The block slots item `it` shows as `v` reads it: a record's, the units
+ * whose block's accepted edge is it, in the order it names them; a slot
+ * item's, those shown at home (moved away or not: a cycle may send one back).
  */
-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 shownIn = (doc, v, it) => {
+    const registry = registryOf(doc);
+    const via = isRecord(it) ? it : null;
+    return unitsOf(doc, it, (_, value, unit) => {
+        if (!isBlockSlot(value))
+            return false;
+        const b = slotOwner(registry, isKeptReplaced, value.b, unit.c);
+        const home = v.blocks.get(b)?.home;
+        return !!home && sameUnit(home, unit) && v.accepted(b)?.via === via;
+    });
+};
+/** The entry block `id` displays as in `v` (its home slot, or its unit at the record it shows at), or `null`. */
+const anchorIn = (doc, v, id) => {
+    const home = v.blocks.get(id)?.home;
+    if (home === undefined || home === null)
+        return null;
+    const edge = v.accepted(id);
+    // At the root's tail (a cycle): the engine's place, the nearest one there is.
+    if (edge === null)
+        return anchorOf(doc, home);
+    if (edge.via === null) {
+        const u = unitOf(doc, home);
+        return u === null ? null : { value: u.value, unit: home, via: null, at: 0 };
     }
-    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 shownIn(doc, v, edge.via).find((e) => sameUnit(e.unit, home)) ?? null;
+};
+/** The entry right before `e` in its sequence as `v` reads it (`e`'s record's previous unit, else the nearest shown to the left). */
+const beforeIn = (doc, v, e) => {
+    const start = e.via ?? unitOf(doc, e.unit).item;
+    const own = shownIn(doc, v, start);
+    // A record's unit before `e`'s place; a slot item's last unit before `e`.
+    const before = e.via === null
+        ? own.findLast((x) => x.unit.k < e.unit.k)
+        : e.at > 0
+            ? (own[e.at - 1] ?? null)
+            : undefined;
+    if (before !== undefined)
+        return before;
+    for (let p = start.left; p !== null; p = p.left) {
+        const list = shownIn(doc, v, p);
+        if (list.length > 0)
+            return list[list.length - 1];
+    }
+    return null;
+};
+/**
+ * Write `slots` (new blocks' home slots) and/or a move of `moved` (their
+ * home units, as `client, clock, len` triples) under `parent`, right after
+ * the displayed child `left` (`null`: first) and before `right`: into the
+ * sequence that holds `left`'s displaying unit (a promoted or claimed
+ * neighbour's own parent), after it — or before `right`'s — else into
+ * `parent`'s own sequence. `side` is the record's class among the items of
+ * its origin (`placement/slots.ts`: `0` after, `1` before).
+ */
+export const placeBlocks = (doc, v, parent, left, right, slots, moved = null, side = 0, part = 0, at = null) => {
+    // Where `v` shows its blocks: a unit a cycle sent back elsewhere is neither an anchor nor carried.
+    const shown = (r) => shownIn(doc, v, r);
+    // The record stands at `at` (else its first unit), named with the home slots above it.
+    const chain = (first) => unitChain(doc, v, at ?? first);
+    const l = left === null ? null : anchorIn(doc, v, left);
+    if (l !== null)
+        return void placeAfter(doc, nodeOf(doc, l), l, null, slots, moved, side, part, chain, shown);
+    const r = right === null ? null : anchorIn(doc, v, right);
+    if (r !== null)
+        return void placeAfter(doc, nodeOf(doc, r), beforeIn(doc, v, r), r, slots, moved, side, part, chain, shown);
+    placeAfter(doc, sequenceOf(doc, parent), null, null, slots, moved, side, part, chain, shown);
+};
+/**
+ * The chain a move record names for the engine's sort (fork patch YP22):
+ * the home slots from the root sequence down to unit `u`, outermost first —
+ * the slot of the block owning `u`'s sequence, that block's parent's, …
+ * Home slots never move, so every writer names one chain for one unit.
+ */
+const unitChain = (doc, v, u) => {
+    const out = [u];
+    const item = unitOf(doc, u)?.item;
+    let owner = item === undefined
+        ? null
+        : ownerOfNode(registryOf(doc), isKeptReplaced, item.parent);
+    for (let n = 0; owner != null && n < 4096; n++) {
+        const home = v.blocks.get(owner)?.home;
+        if (!home)
+            break;
+        out.unshift({ c: home.c, k: home.k });
+        owner = home.parent;
     }
     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).
+ * The displayed children of `parent` in `v` around display index `index`
+ * (the `exclude`d left out): the one before it and the one at it, the
+ * neighbours {@link placeBlocks} writes between.
  */
-const createBlock = (doc, id, type, data, place, claims, items, n = nonceOf(doc)) => {
+const around = (v, parent, index, exclude = []) => {
+    const all = v.kids.get(parent) ?? [];
+    const list = exclude.length === 0 ? all : all.filter((k) => !exclude.includes(k.id));
+    const i = Math.max(0, Math.min(index, list.length));
+    return [list[i - 1]?.id ?? null, list[i]?.id ?? null];
+};
+/**
+ * Move `ids` (in order) to display index `index` among `parent`'s children
+ * (themselves left out): one record naming their home slots, after the
+ * child before that index. `at` is the block the record stands at for the
+ * engine's sort of two records at one origin (its home slot; `null`: the
+ * first moved) and `part` its order among the records standing there.
+ */
+export const moveBlocksTo = (doc, v, ids, parent, index, side = 0, part = 0, at = null) => {
+    const units = ids.flatMap((id) => {
+        const home = v.blocks.get(id)?.home;
+        return home ? [home] : [];
+    });
+    if (units.length === 0)
+        return;
+    const anchor = at === null ? null : (v.blocks.get(at)?.home ?? null);
+    placeBlocks(doc, v, parent, ...around(v, parent, index, ids), null, triples(units), side, part, anchor);
+};
+/**
+ * One registry entry: the block node with its own backing text holding
+ * `items` (none for a split-born block: its stream lives in the text it was
+ * split from) and, in its sequence, its children's home slots in order (each
+ * child's node created the same way). Pre-integration writes materialize
+ * when the node integrates (the registry write comes last). The block's own
+ * home slot is the caller's ({@link placeBlocks}).
+ */
+const createBlock = (doc, sp, items, n = nonceOf(doc)) => {
+    // The block's id is its registry key: the node writes none of its own.
     const node = newNode(BLOCK_NODE);
-    node.setAttr(ID, id);
     node.setAttr(NONCE, n);
-    node.setAttr(TYPE, type);
-    writeLeaves(node, dataLeaves(data));
+    node.setAttr(TYPE, sp.type);
+    writeData(node, dataWrites(sp.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);
+    const children = sp.children ?? [];
+    if (children.length > 0)
+        node.insert(node.length, children.map((c) => ({ b: c.id })));
+    for (const child of children)
+        createBlock(doc, child, child.content ?? []);
+    registryOf(doc).setAttr(sp.id, node);
     if (content !== null)
         markText(doc, content, items);
 };
@@ -211,36 +288,55 @@ const textOf = (items) => {
 const markText = (doc, content, items) => writeRunMarks(doc, content, 0, items.map((item) => item.kind === 'text'
     ? { length: item.text.length, marks: item.marks }
     : { length: 1 }));
+/**
+ * Materialize `specs` (whole subtrees, in order) under `parent` at display
+ * index `index`: each spec's node with its children, then their home slots
+ * in one run after the child before that index. `split`: the boundary of
+ * the split these blocks come with (a paste's lines at a split point), their
+ * slots' sort key among the slots of one origin ({@link BlockSlot}).
+ */
+export const insertSpecsAt = (doc, v, parent, index, specs, split = null) => {
+    if (specs.length === 0)
+        return;
+    const [left, right] = around(v, parent, index);
+    for (const sp of specs)
+        createBlock(doc, sp, sp.content ?? []);
+    placeBlocks(doc, v, parent, left, right, specs.map((sp) => (split === null ? { b: sp.id } : { b: sp.id, s: [split.c, split.k] })));
+};
 /**
  * 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
+ * place and content are rewritten in place — its claims deleted, a
+ * fresh own text holding the spec's content; 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
+ * block gets this writer's delete mark. The places are written in the
+ * tree's order 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 { blocks, own } = view(doc);
     const keep = new Set();
     const restore = (list, parent) => {
-        let rank;
+        let left = null;
         for (const sp of list) {
             keep.add(sp.id);
             let node = blockNodeOf(doc, sp.id);
+            const v = view(doc);
             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);
+                createBlock(doc, { ...sp, children: [] }, []);
+                placeBlocks(doc, v, parent, left, null, [{ b: sp.id }]);
+                node = blockNodeOf(doc, sp.id);
             }
-            else if (own.streamOf(sp.id)?.home !== sp.id && own.streamOf(sp.id) !== undefined) {
-                node.setAttr(NONCE, nonceOf(doc));
+            else {
+                deleteClaims(doc, blocks.get(sp.id)?.claims ?? []);
+                if (own.streamOf(sp.id)?.home !== sp.id && own.streamOf(sp.id) !== undefined)
+                    node.setAttr(NONCE, nonceOf(doc));
+                const home = v.blocks.get(sp.id)?.home;
+                if (home)
+                    placeBlocks(doc, v, parent, left, null, null, triples([home]));
             }
             for (const key of [...node.attrKeys()]) {
                 if (key.startsWith(DEL_PREFIX) || key.startsWith(WITHDRAW_PREFIX))
@@ -248,13 +344,11 @@ export const restoreBlocks = (doc, specs) => doc.transact(() => {
             }
             if (node.getAttr(TYPE) !== sp.type)
                 node.setAttr(TYPE, sp.type);
-            writeLeaves(node, patchWrites(node, [{ path: [], value: sp.data ?? {} }]) ?? []);
+            writeData(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);
+            left = sp.id;
             restore(sp.children ?? [], sp.id);
         }
     };
@@ -265,20 +359,6 @@ export const restoreBlocks = (doc, specs) => doc.transact(() => {
         }
     });
 });
-/**
- * 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
@@ -313,30 +393,35 @@ export const insertBlocks = (doc, dest, specs) => {
     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]));
+        insertSpecsAt(doc, view(doc), dest.parent, dest.index, specs);
         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}).
+ * Split `id` at content `offset` into the new block `newId` placed under
+ * `parent` at display `index`: one boundary item for `newId` at the end of
+ * the gap at `offset` (fork patch YP7) and the merge claims that follow it
+ * written again in the new block's stream — 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}).
+ * Returns the split's boundary unit (the key of the slots a paste adds at it).
  */
-export const writeSplit = (doc, id, offset, newId, tail, place) => {
-    const { blocks, own } = view(doc);
+export const writeSplit = (doc, id, offset, newId, tail, parent, index) => {
+    const v = 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);
+    // The boundary is the split's first write: its id is this writer's next.
+    const bound = { c: doc.clientID, k: storeOf(doc).getClock(doc.clientID) };
+    splitAt(doc, v.blocks, v.own, id, offset, newId, n);
+    const data = tail.data === undefined ? undefined : cloneJsonSafe(tail.data);
+    createBlock(doc, { id: newId, type: tail.type, data }, null, n);
+    // The tail's slot carries its boundary (`BlockSlot.s`): two peers' splits of
+    // one block sort by their boundaries' order in the text, in the gap after it.
+    placeBlocks(doc, v, parent, ...around(v, parent, index), [{ b: newId, s: [bound.c, bound.k] }]);
+    return bound;
 };
 /**
  * Give the streamless block `id` its own text (`T.ownText`: a derived
@@ -346,7 +431,7 @@ 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
+ * visible tree of live blocks in their sequences' order, 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.
  */
@@ -402,6 +487,22 @@ export const crdtId = (doc, id) => {
 };
 /** Engine handle for a logical id, or null when absent or delete-marked (debug surface). */
 export const resolveBlock = (doc, id) => liveNodeOf(doc, id);
+/**
+ * The live move records of `node`'s sequence (the room's purge, tests):
+ * each with its stamp and whether some unit still shows at it — the
+ * engine's mover of a unit, or (with `v`) the record a block shows at in
+ * `v` (a cycle sent it back to an older one).
+ */
+export const recordsOf = (doc, node, v) => {
+    const out = [];
+    for (let it = firstItem(node); it !== null; it = it.right) {
+        if (it.deleted || !isRecord(it))
+            continue;
+        const wins = (v !== undefined && shownIn(doc, v, it).length > 0) || shownBy(doc, it).length > 0;
+        out.push({ item: it, stamp: stampOf(it), wins });
+    }
+    return out;
+};
 /**
  * The placement model as one object (the public binding's `model`): the
  * primitives above. Edytor's own modules import them directly.
@@ -414,22 +515,21 @@ export const bindModel = (_Y) => ({
     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,
+    placeBlocks,
+    moveBlocksTo,
+    insertSpecsAt,
     withdrawOnUndo,
-    materializeSpec,
     collides,
     writeSplit,
     ownText,
+    recordsOf,
     // the seed writer's bulk insert
     insertBlocks,
     insertBlock,