edytor 2.0.0 → 4.0.0

package/dist/crdt/placement/keys.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Order keys — the in-memory keys the index sorts a parent's children by.
+ *
+ * A block's place is its slot in its parent's sequence (fork patch YP22:
+ * the engine orders slots and move records); nothing about the order is
+ * stored. The index still needs a comparable key per child, so that
+ * `displaySlotOf`'s promotion, the layout rules, `positionInView`'s binary
+ * search and `anchors.seam` keep working over `(rank, id)`-sorted lists:
+ * each child gets a key between its sequence neighbours' when it is placed
+ * (`keyBetween`), or a dense one when a whole sequence is read
+ * (`denseKey`). Keys are plain strings compared with `<`; they are local to
+ * one index and never leave it (two replicas may hold different keys for
+ * one order).
+ *
+ * Three key spaces compose with them:
+ *
+ * - a promoted child's key is its slot's key, {@link PROMOTED} and its own
+ *   ({@link promotedRank}): `PROMOTED` sorts below every key character, so
+ *   the promoted children follow the slot and precede the next sibling;
+ * - a merged-away block's children show after the owner's own children,
+ *   by the owner's claim order ({@link claimedRank}): {@link CLAIMED} sorts
+ *   above every key character;
+ * - a table's cells show in column order ({@link cellKey}).
+ */
+/** Sorts below every key character: the separator of a promoted child's key. */
+export declare const PROMOTED = "!";
+/**
+ * A key strictly between `a` and `b` (`undefined`: no bound). Both bounds
+ * are keys of this alphabet with `a < b`: place by place, a digit halfway
+ * between theirs when one fits, else `a`'s digit and one place deeper
+ * (classic fractional indexing). A key never ends in the lowest digit
+ * (`denseKey` writes none), so a key fits between any two.
+ */
+export declare const keyBetween: (a: string | undefined, b: string | undefined) => string;
+/** The `i`-th of a whole sequence's dense keys, in order (none ends in the lowest digit). */
+export declare const denseKey: (i: number) => string;
+/**
+ * The key of a block promoted into the slot keyed `slot` (read-time
+ * promotion, `del.blocks.promote`): after the slot, before every later key of
+ * the slot's list, in the promoted children's own order.
+ */
+export declare const promotedRank: (slot: string, rank: string) => string;
+/**
+ * The key of a child of a merged-away block shown under its owner: after the
+ * owner's own children, by the owner's claims (`path`: the claim index at
+ * each hop down to the child's parent), then the child's own key.
+ */
+export declare const claimedRank: (path: readonly number[], rank: string) => string;
+/**
+ * The key a table's cell displays at (`table.columns`): its column's
+ * position, before every unlisted column (`unlistedCellKey`) and the cells
+ * of no listed column (`LAST_CELL`).
+ */
+export declare const cellKey: (at: number) => string;
+/** A withdrawn cell's column the table no longer lists: after the listed ones, by `unlistedRank`. */
+export declare const unlistedCellKey: (hash: number) => string;
+/** A cell of no listed column: last (it does not display, `table.cell`). */
+export declare const LAST_CELL = "2";

package/dist/crdt/placement/keys.js

@@ -0,0 +1,90 @@
+/**
+ * Order keys — the in-memory keys the index sorts a parent's children by.
+ *
+ * A block's place is its slot in its parent's sequence (fork patch YP22:
+ * the engine orders slots and move records); nothing about the order is
+ * stored. The index still needs a comparable key per child, so that
+ * `displaySlotOf`'s promotion, the layout rules, `positionInView`'s binary
+ * search and `anchors.seam` keep working over `(rank, id)`-sorted lists:
+ * each child gets a key between its sequence neighbours' when it is placed
+ * (`keyBetween`), or a dense one when a whole sequence is read
+ * (`denseKey`). Keys are plain strings compared with `<`; they are local to
+ * one index and never leave it (two replicas may hold different keys for
+ * one order).
+ *
+ * Three key spaces compose with them:
+ *
+ * - a promoted child's key is its slot's key, {@link PROMOTED} and its own
+ *   ({@link promotedRank}): `PROMOTED` sorts below every key character, so
+ *   the promoted children follow the slot and precede the next sibling;
+ * - a merged-away block's children show after the owner's own children,
+ *   by the owner's claim order ({@link claimedRank}): {@link CLAIMED} sorts
+ *   above every key character;
+ * - a table's cells show in column order ({@link cellKey}).
+ */
+/**
+ * Order-preserving alphabet: charCode order equals numeric order (64
+ * characters, all safe inside a JSON string).
+ */
+const ALPHABET = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
+const BASE = ALPHABET.length;
+/** Sorts below every key character: the separator of a promoted child's key. */
+export const PROMOTED = '!';
+/** Sorts above every key character: the prefix of a merged-away block's children. */
+const CLAIMED = '~';
+/** The index of a key character in the alphabet (`-1`: none). */
+const digit = (s, i) => (i < s.length ? ALPHABET.indexOf(s[i]) : -1);
+/**
+ * A key strictly between `a` and `b` (`undefined`: no bound). Both bounds
+ * are keys of this alphabet with `a < b`: place by place, a digit halfway
+ * between theirs when one fits, else `a`'s digit and one place deeper
+ * (classic fractional indexing). A key never ends in the lowest digit
+ * (`denseKey` writes none), so a key fits between any two.
+ */
+export const keyBetween = (a, b) => {
+    let out = '';
+    for (let i = 0;; i++) {
+        // Past a bound's end: below every digit (`a`), above every digit (`b`).
+        const da = a !== undefined && i < a.length ? digit(a, i) : 0;
+        const db = b === undefined ? BASE : i < b.length ? digit(b, i) : 0;
+        if (db - da > 1)
+            return out + ALPHABET[da + ((db - da) >> 1)];
+        out += ALPHABET[da];
+        // Below `b` already at this place: it bounds the deeper places no more.
+        if (db - da === 1)
+            b = undefined;
+    }
+};
+/** The `i`-th of a whole sequence's dense keys, in order (none ends in the lowest digit). */
+export const denseKey = (i) => {
+    // Four places of 63 digits (the lowest left out): 15M positions of one length.
+    let out = '';
+    let x = i;
+    for (let k = 0; k < 4; k++) {
+        out = ALPHABET[1 + (x % (BASE - 1))] + out;
+        x = Math.floor(x / (BASE - 1));
+    }
+    return out;
+};
+/**
+ * The key of a block promoted into the slot keyed `slot` (read-time
+ * promotion, `del.blocks.promote`): after the slot, before every later key of
+ * the slot's list, in the promoted children's own order.
+ */
+export const promotedRank = (slot, rank) => slot + PROMOTED + rank;
+/**
+ * The key of a child of a merged-away block shown under its owner: after the
+ * owner's own children, by the owner's claims (`path`: the claim index at
+ * each hop down to the child's parent), then the child's own key.
+ */
+export const claimedRank = (path, rank) => path.map((i) => CLAIMED + denseKey(i)).join('') + PROMOTED + rank;
+/**
+ * The key a table's cell displays at (`table.columns`): its column's
+ * position, before every unlisted column (`unlistedCellKey`) and the cells
+ * of no listed column (`LAST_CELL`).
+ */
+export const cellKey = (at) => '0' + denseKey(at);
+/** A withdrawn cell's column the table no longer lists: after the listed ones, by `unlistedRank`. */
+export const unlistedCellKey = (hash) => '1' + denseKey(hash % 2 ** 24);
+/** A cell of no listed column: last (it does not display, `table.cell`). */
+export const LAST_CELL = '2';

package/dist/crdt/placement/model.d.ts

@@ -2,63 +2,71 @@
  * Placement engine — the Edytor document model on vendored Yjs v14.
  *
  * Architecture: every block is a stable registry entry keyed by its logical
- * id; displayed structure is DERIVED from per-block placement candidate
- * records, never from physical nesting.
+ * id; displayed structure is DERIVED from the order sequences (fork patch
+ * YP22), never from physical nesting.
  *
  * ```
  * doc.get('blocks')                        registry — flat map, block-id → node
+ *   │  [ {b: id}, {b: id}, R, … ]          its list part: the top-level blocks' home slots and move records
  *   └ <blockId>  node('block')             stable identity; survives every move
- *        ├ id / type / data / n            payload attrs (n: incarnation nonce)
+ *        ├ id / type / n                    payload attrs (n: incarnation nonce)
+ *        ├ d/<pointer>                      data leaves (`crdt/data.ts`)
  *        ├ del.<writer>                     per-writer delete marks (any live mark = deleted)
  *        ├ content → node('content')       BACKING text of a block created fresh
- *        ├ claims → node('claims')         ordered merge claims `{m}`
- *        └ at → node('at')                 placement candidate map
- *             └ "<seq>.<clientId>" → { p: parentId|null, r: rank }
+ *        │                                  (its streams' boundaries `{s, n}`, claim items `{m}`)
+ *        └ [ {b: child}, {p, i}, R, … ]    its list part: its children's home slots, its data
+ *                                           arrays' item slots, and move records
  * ```
  *
- * Placement record semantics (see docs/crdt-v14-move-adr.md):
+ * Placement semantics (`placement/slots.ts`, `placement/resolve.ts`):
  *
- * - `{p, r}` is written atomically as ONE attr value under an ever-increasing
- *   per-writer key `seq.clientId`. Parent and rank can never merge across
- *   records — the atomicity requirement.
- * - Winner per block = the max candidate under total order
- *   `(seq, clientId, blockId)` — LWW over replicated, delivery-order-free
- *   metadata. Candidates beyond the top two are tombstoned on write
- *   (compaction); the runner-up is kept as the acyclic fallback.
- * - Projection resolves placements greedily in that order: accept a
- *   candidate's parent edge iff its DISPLAY edge `owner(p)` cannot close a
- *   cycle through already accepted display edges; otherwise try the next
- *   candidate; a block with no acceptable candidate is rehomed at the root
- *   (deterministic, acyclic, pure — no repair writes). The acyclic relation
- *   is the COMPOSED one — raw placements are acyclic but merge claims can
- *   redirect a display edge back into the block's own subtree.
+ * - A block's home slot `{b: id}` is written once, at its creation, in its
+ *   parent's sequence right after its left sibling's unit (YATA's origin
+ *   rule). A move is one record in the destination's sequence naming the
+ *   moved blocks' home slots in order; each slot shows at the record that
+ *   wins its movers — the greatest `(priority, client, clock)` — and is
+ *   hidden at home; deleting a record (an undo) hands the slot to the next
+ *   record, else home. Replicas converge in any delivery order.
+ * - Projection resolves the display edges greedily in that order: a block's
+ *   candidates are its live records, strongest first, then its home slot,
+ *   and it takes the first whose DISPLAY parent chain cannot reach back to
+ *   the block through already accepted edges — the later move wins, and a
+ *   block whose move a cycle drops is back where it stood (its previous
+ *   record, else home); only a block every candidate of which closes a cycle
+ *   shows at the root after the last top-level block (deterministic,
+ *   acyclic, pure — no repair writes). The acyclic relation is the COMPOSED
+ *   one — raw edges are acyclic but merge claims can redirect a display edge
+ *   back into the block's own subtree.
  * - Delete marks `del.<writer>` are independent replicated attrs: a marked
- *   block is hidden regardless of which placement candidate wins — explicit
- *   deletion beats concurrent move. Deleting marks the block and every
- *   block it displays through merge claims, a whole-subtree delete
- *   every member; undo removes only the undoer's mark. An unmarked block
- *   under a marked one is promoted into its slot at read time
- *   (`displaySlotOf`), so a concurrent child is never hidden with it; a
- *   block under a void kind (`DisplayOwnership.childless`) likewise.
+ *   block is hidden regardless of where its slot shows — explicit deletion
+ *   beats concurrent move. Deleting marks the block and every block it
+ *   displays through merge claims, a whole-subtree delete every member; undo
+ *   removes only the undoer's mark. An unmarked block under a marked one is
+ *   promoted into its slot at read time (`displaySlotOf`), so a concurrent
+ *   child is never hidden with it; a block under a void kind
+ *   (`DisplayOwnership.childless`) likewise.
  *
  * Content ownership (`text/model.ts`): a block displays its stream —
  * delimited by boundary items in a backing text — then the displays of the
- * blocks it claims. A split inserts one boundary; a merge appends one claim;
- * no text is ever copied.
+ * blocks it claims. A split inserts one boundary; a merge one claim item at
+ * the end of the stream; no text is ever copied.
  *
  * The engine is the vendored one, read through `engine.js` (structural
  * types, `engine-api.ts`): this file never imports vendor `.js` (which
  * `pnpm check` must not traverse).
  *
- * Placement resolution is `placement/resolve.ts`, the source ranks
- * `placement/source.ts`, where a block displays `placement/display.ts`
- * (re-exported here); this module declares the model's types and its write
- * and read primitives, each a function edytor's modules import (the
- * public binding's `model` lists them, `bindModel`).
+ * The placement reads are `placement/resolve.ts` (the index decides), the sequences
+ * `placement/slots.ts`, the order keys `placement/keys.ts`, where a block
+ * displays `placement/display.ts` (re-exported here); this module declares
+ * the model's types and its write and read primitives, each a function
+ * edytor's modules import (the public binding's `model` lists them,
+ * `bindModel`).
  */
 import type { EngineApi, EngineDoc, EngineItemRef, EngineNode } from '../engine-api.js';
 import { REGISTRY_KEY } from '../schema.js';
 import { type Ownership, type TextBlockRec } from '../text/model.js';
+import { type BlockSlot, type Unit, type SeqItem, type Stamp } from './slots.js';
+import { type SlotRef } from './resolve.js';
 /** Logical block identifier — caller-assigned, immutable per block. */
 export type BlockId = string;
 /** Where a block goes: `parent` = logical block id or `null` for root. */
@@ -109,33 +117,23 @@ export type ProjectedDoc = {
     children: ProjectedBlock[];
 };
 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';
-/** Placement value written atomically as one attr: `{p, r}`. */
-export type PlacementValue = {
-    p: BlockId | null;
-    r: string;
-};
-/** A parsed placement candidate (key + value). */
-export type PlacementCand = {
-    key: string;
-    seq: number;
-    client: number;
-    p: BlockId | null;
-    r: string;
-};
+export type { SlotRef, Edge } from './resolve.js';
+export { promotedRank } from './keys.js';
+export { bySlot, childrenIndex, displayParentOf, displaySlotOf, documentOrder, isLiveIn } from './display.js';
 /**
- * Internal per-block record: the registry node plus decoded placement
- * candidates sorted by `(seq, client)` descending (index 0 = argmax), plus
- * the text-ownership facts (nonce, own text, merge claims).
+ * Internal per-block record: the registry node, its home slot (`null`: none
+ * found), plus the text-ownership facts (nonce, own text, merge claims).
  */
 export type BlockRec = TextBlockRec & {
     type: string;
     data: unknown;
-    cands: PlacementCand[];
+    home: SlotRef | null;
 };
-/** Resolved placement after acyclic acceptance. */
+/**
+ * Resolved placement after acyclic acceptance: the owner of the sequence
+ * that shows the block (`null`: the root) and its order key there (an
+ * in-memory key, `placement/keys.ts`: never stored).
+ */
 export type ResolvedPlacement = {
     parent: BlockId | null;
     rank: string;
@@ -180,12 +178,6 @@ export type DisplayOwnership = Ownership & {
      * it ({@link displaySlotOf}).
      */
     sheds?: (owner: BlockId, child: BlockId) => boolean;
-    /**
-     * The rank `id` displays at directly under `parent` (its placement's own
-     * parent) — `rank` unless it is a piece of a text (`order.split.text`,
-     * {@link textRanker}).
-     */
-    textRank?: (id: BlockId, parent: BlockId | null, rank: string) => string;
     /**
      * The rank `id` displays at directly under `owner`, its placement's own
      * parent, when a rule other than its placement orders it there (a
@@ -253,10 +245,11 @@ export declare const isLive: (doc: EngineDoc, id: BlockId) => boolean;
 /**
  * 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 declare const withdrawOnUndo: (doc: EngineDoc) => (item: EngineItemRef, stackItem: {
@@ -264,14 +257,6 @@ export declare const withdrawOnUndo: (doc: EngineDoc) => (item: EngineItemRef, s
         has(client: number, clock: number): boolean;
     };
 }) => boolean;
-/**
- * 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 declare const writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
 /** The doc's index as a `ModelView` — folded up to the open transaction's last write. */
 export declare const view: (doc: EngineDoc) => ModelView;
 /** A detached inline-atom node (inputs arrive normalized by the facade's ingress). */
@@ -282,48 +267,50 @@ export declare const buildInline: (atom: InlineSpec) => EngineNode;
  * (`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 declare const isSelfOrDescendant: (placements: Map<BlockId, ResolvedPlacement>, own: Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
 /**
- * `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).
+ * 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 declare const ranksAt: (siblings: readonly {
-    rank: string;
-}[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
+export declare const placeBlocks: (doc: EngineDoc, v: ModelView, parent: BlockId | null, left: BlockId | null, right: BlockId | null, slots: readonly BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: Unit | null) => void;
+/**
+ * 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 declare const moveBlocksTo: (doc: EngineDoc, v: ModelView, ids: readonly BlockId[], parent: BlockId | null, index: number, side?: number, part?: number, at?: BlockId | null) => void;
+/**
+ * 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 declare const insertSpecsAt: (doc: EngineDoc, v: ModelView, parent: BlockId | null, index: number, specs: readonly BlockSpec[], split?: Unit | null) => void;
 /**
  * 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 declare const restoreBlocks: (doc: EngineDoc, specs: BlockSpec[]) => void;
-/**
- * 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 declare const materializeSpec: (doc: EngineDoc, sp: BlockSpec, parent: BlockId | null, rank: string) => void;
 /**
  * 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
@@ -342,15 +329,17 @@ export declare const insertBlocks: (doc: EngineDoc, dest: Destination, specs: Bl
 /** {@link insertBlocks} of one spec. */
 export declare const insertBlock: (doc: EngineDoc, dest: Destination, spec: BlockSpec) => boolean;
 /**
- * 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 declare const writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: PlacementValue) => void;
+export declare const writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, parent: BlockId | null, index: number) => Unit;
 /**
  * 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.
@@ -361,7 +350,7 @@ export declare const ownText: (doc: EngineDoc, id: BlockId) => {
 };
 /**
  * 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.
  */
@@ -390,6 +379,17 @@ export declare const blockText: (doc: EngineDoc, id: BlockId) => string | null;
 export declare const crdtId: (doc: EngineDoc, id: BlockId) => string | null;
 /** Engine handle for a logical id, or null when absent or delete-marked (debug surface). */
 export declare const resolveBlock: (doc: EngineDoc, id: BlockId) => EngineNode | null;
+/**
+ * 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 declare const recordsOf: (doc: EngineDoc, node: EngineNode, v?: ModelView) => {
+    item: SeqItem;
+    stamp: Stamp;
+    wins: boolean;
+}[];
 /**
  * The placement model as one object (the public binding's `model`): the
  * primitives above. Edytor's own modules import them directly.
@@ -400,30 +400,31 @@ export declare const bindModel: (_Y: EngineApi) => {
     blockNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
     liveNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
     isLive: (doc: EngineDoc, id: BlockId) => boolean;
-    candidatesOf: (node: EngineNode) => PlacementCand[];
     /** The doc's index as a `ModelView`. */
     view: (doc: EngineDoc) => ModelView;
-    resolvePlacements: (blocks: Map<BlockId, BlockRec>, ownerOf?: (b: BlockId) => import("../text/model.js").Owner) => Map<BlockId, ResolvedPlacement>;
     childrenIndex: (placements: Map<BlockId, ResolvedPlacement>, own: DisplayOwnership) => Map<BlockId | null, ChildSlot[]>;
     positionInView: (v: ModelView, id: BlockId) => Destination | null;
     buildInline: (atom: InlineSpec) => EngineNode;
     isSelfOrDescendant: (placements: Map<BlockId, ResolvedPlacement>, own: Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
-    ranksAt: (siblings: readonly {
-        rank: string;
-    }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-    writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
+    placeBlocks: (doc: EngineDoc, v: ModelView, parent: BlockId | null, left: BlockId | null, right: BlockId | null, slots: readonly BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: Unit | null) => void;
+    moveBlocksTo: (doc: EngineDoc, v: ModelView, ids: readonly BlockId[], parent: BlockId | null, index: number, side?: number, part?: number, at?: BlockId | null) => void;
+    insertSpecsAt: (doc: EngineDoc, v: ModelView, parent: BlockId | null, index: number, specs: readonly BlockSpec[], split?: Unit | null) => void;
     withdrawOnUndo: (doc: EngineDoc) => (item: EngineItemRef, stackItem: {
         inserts: {
             has(client: number, clock: number): boolean;
         };
     }) => boolean;
-    materializeSpec: (doc: EngineDoc, sp: BlockSpec, parent: BlockId | null, rank: string) => void;
     collides: (doc: EngineDoc, specs: readonly BlockSpec[]) => boolean;
-    writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: PlacementValue) => void;
+    writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, parent: BlockId | null, index: number) => Unit;
     ownText: (doc: EngineDoc, id: BlockId) => {
         from: unknown;
         to: number;
     };
+    recordsOf: (doc: EngineDoc, node: EngineNode, v?: ModelView) => {
+        item: SeqItem;
+        stamp: Stamp;
+        wins: boolean;
+    }[];
     insertBlocks: (doc: EngineDoc, dest: Destination, specs: BlockSpec[]) => boolean;
     insertBlock: (doc: EngineDoc, dest: Destination, spec: BlockSpec) => boolean;
     restoreBlocks: (doc: EngineDoc, specs: BlockSpec[]) => void;