edytor 3.0.0 → 4.0.0

package/dist/crdt/doc/meta.js

@@ -7,11 +7,11 @@ import { randOf } from '../rand.js';
 import { TYPE } from '../schema.js';
 import { asBlockSpec, asContentItem, sanitizeSpec, sanitizeWireJson } from '../../utils/json.js';
 import { patchWrites, leafKey, isObject } from '../data.js';
-import { collides, promotedRank, ranksAt } from '../placement/model.js';
+import { collides } from '../placement/model.js';
 import { ref, refused, sanitizeItem } from './plan.js';
 /** The meta ops of one facade, prepared. */
 export const metaOps = (c) => {
-    const { doc, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, is, isVoid, displayLength, live, contentTarget, REFUSED, plan, moveTo, attr, leavingIsland, settle, remove, atomOf, writeContent } = c;
+    const { doc, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, is, isVoid, displayLength, live, contentTarget, REFUSED, plan, attr, leavingIsland, settle, remove, atomOf, writeContent } = c;
     /**
      * The data step of `patches` (sanitized) on a block, one of its atoms or
      * the document (`crdt/data.ts`): none when it changes nothing, `null`
@@ -23,12 +23,12 @@ export const metaOps = (c) => {
         // A block kind's atomic paths are written as one leaf each (`data.atomic`).
         const type = inlineId === undefined && id !== undefined ? blockTypeOf(id) : undefined;
         const atomic = (type === undefined ? undefined : roleOf(type)?.atomic) ?? [];
-        const leaves = node
+        const writes = node
             ? patchWrites(node, patches, doc.clientID, randOf(doc), atomic.map((p) => leafKey(typeof p === 'string' ? [p] : p)))
             : [];
-        if (leaves === null)
+        if (writes === null)
             return null; // a patch fits no value there
-        if (leaves.length === 0)
+        if (writes.length === 0)
             return [];
         const offset = inlineId === undefined ? undefined : atomOf(id, inlineId)?.at;
         return [
@@ -37,7 +37,7 @@ export const metaOps = (c) => {
                 ...(id !== undefined && { id }),
                 ...(inlineId !== undefined && { inlineId, offset }),
                 ops: patches,
-                leaves
+                writes
             }
         ];
     };
@@ -65,10 +65,8 @@ export const metaOps = (c) => {
     /**
      * The target role decides: nothing renders a void's children,
      * so a block retyped to a void kind hands them to the slot right after
-     * it, as the kind they show there (`settledKind`). Each moves to the
-     * rank the read-time
-     * shedding gives it (`promotedRank`), so a child a peer adds
-     * meanwhile keeps its place in the void's order among them. An island
+     * it, as the kind they show there (`settledKind`), in their order (where
+     * the read-time shedding shows a child a peer adds meanwhile). An island
      * declared `lines` retyped to an ordinary kind keeps its lines, each
      * retyped to the new kind's default child (the document's where that
      * renders no content): no line kind outside its island. Any other
@@ -95,12 +93,11 @@ export const metaOps = (c) => {
         }
         if (!roles.childless(type) || moved.length === 0 || pos === null)
             return steps;
-        const slotRank = kids.get(pos.parent)[pos.index].rank;
-        const ids = moved.map((k) => k.id);
+        // The children keep their home slots: the read shows them in the void's
+        // slot (`conc.void-children`), settled for its parent.
         return [
             ...steps,
-            ...moveTo(ids, pos.parent, pos.index + 1, moved.map((k) => promotedRank(slotRank, k.rank))),
-            ...settle(id, ids, pos.parent)
+            ...settle(id, moved.map((k) => k.id), pos.parent)
         ];
     };
     /** Set the block type (attr write — the block keeps its identity; see `retypeSteps`). */
@@ -187,10 +184,8 @@ export const metaOps = (c) => {
         if (children !== undefined) {
             for (const kid of childrenIds(id))
                 writes.push(remove(kid));
-            // Every current child is deleted, so the new ones rank from an empty list.
-            const ranks = ranksAt([], 0, children.length, doc.clientID, randOf(doc));
             if (children.length > 0)
-                writes.push({ op: 'insertBlocks', parent: id, index: 0, specs: children, ranks });
+                writes.push({ op: 'insertBlocks', parent: id, index: 0, specs: children });
         }
         return plan([id], writes);
     };

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

@@ -1,7 +1,7 @@
 import { type JSONBlock } from '../../utils/json.js';
 import { type BlockId, type BlockSpec, type Destination } from '../placement/model.js';
 import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
+import { type OpsContext } from './steps.js';
 /** The moves ops of one facade, prepared. */
 export declare const moveOps: (c: OpsContext) => {
     insertBlocks: (dest: Destination, specs: readonly (BlockSpec | JSONBlock)[]) => Prepared;

package/dist/crdt/doc/moves.js

@@ -7,9 +7,10 @@ import { id as newId } from '../../utils.js';
 import { asBlockSpec, sanitizeSpec } from '../../utils/json.js';
 import { collides } from '../placement/model.js';
 import { ref } from './plan.js';
+import { PART } from './steps.js';
 /** The moves ops of one facade, prepared. */
 export const moveOps = (c) => {
-    const { doc, blockTypeOf, blockDataOf, childrenIds, positionOf, isVoid, isIsland, isLine, contentItems, live, canPlace, isContainer, fits, kindToCopy, REFUSED, HEAD, KEPT, WITH, SELF, AFTER, plan, ranksFor, moveTo, move, exitRanks, leaving, settledKind, settle, landing, emptying, emptied } = c;
+    const { doc, blockTypeOf, blockDataOf, childrenIds, positionOf, isVoid, isIsland, isLine, contentItems, live, canPlace, isContainer, fits, kindToCopy, REFUSED, plan, moveTo, move, leaving, settledKind, settle, landing, emptying, emptied } = c;
     /**
      * Insert blocks (specs may carry children/content/data; the batch is
      * all-or-nothing). A spec is a `BlockSpec` or the `JSONBlock` that
@@ -29,8 +30,7 @@ export const moveOps = (c) => {
             return plan([], []);
         if ((parent !== null && !live(parent)) || collides(doc, clean))
             return REFUSED;
-        const ranks = ranksFor(parent, dest.index, clean.length, [], true);
-        return plan(clean.map((s) => s.id), [{ op: 'insertBlocks', parent, index: dest.index, specs: clean, ranks }]);
+        return plan(clean.map((s) => s.id), [{ op: 'insertBlocks', parent, index: dest.index, specs: clean }]);
     };
     /**
      * Grouped move — one step, per-member conflict resolution; refused
@@ -80,8 +80,7 @@ export const moveOps = (c) => {
         const retype = settle(from, moved, ppos.parent);
         if (isContainer(from))
             return splitOut(moved, [from], [], false, retype);
-        const out = leaving(from, true, moved);
-        const writes = [...moveTo(moved, ppos.parent, ppos.index + 1, out), ...retype];
+        const writes = [...moveTo(moved, ppos.parent, ppos.index + 1, leaving(true)), ...retype];
         const adopts = after.length > 0 &&
             !isVoid(last) &&
             !isIsland(last) &&
@@ -123,13 +122,11 @@ export const moveOps = (c) => {
     const splitOut = (ids, levels, specs, keep, retype = []) => {
         const moved = keep ? [] : [...ids];
         const placed = [...moved, ...specs.map((s) => s.id)];
-        const insert = (at, index, s, ranks) => s.length ? [{ op: 'insertBlocks', parent: at, index, specs: s, ranks }] : [];
+        const insert = (at, index, s) => s.length ? [{ op: 'insertBlocks', parent: at, index, specs: s }] : [];
         const last = ids.at(-1);
         const { parent, index } = positionOf(levels.at(-1) ?? last);
-        if (levels.length === 0) {
-            const ranks = ranksFor(parent, index + 1, specs.length, [], true);
-            return plan(placed, [...insert(parent, index + 1, specs, ranks), ...retype]);
-        }
+        if (levels.length === 0)
+            return plan(placed, [...insert(parent, index + 1, specs), ...retype]);
         // Bottom up: what stays before the split at each level (the level
         // itself, or a new head holding it), and whether anything follows it.
         const heads = [];
@@ -141,10 +138,8 @@ export const moveOps = (c) => {
         for (const level of levels) {
             const kids = childrenIds(level);
             const at = kids.indexOf(child);
-            const lead = [
-                ...kids.slice(0, keep && child === last ? at + 1 : at).filter((k) => !moved.includes(k)),
-                ...(before && !before.head ? [before.id] : [])
-            ];
+            const stays = (keep && child === last) || (before !== null && !before.head);
+            const lead = kids.slice(0, at + (stays ? 1 : 0)).filter((k) => !moved.includes(k));
             if (!follows && at + 1 < kids.length)
                 [follows, next] = [true, kids[at + 1]];
             if ((lead.length > 0 || before?.head) && follows) {
@@ -160,27 +155,52 @@ export const moveOps = (c) => {
                 before = lead.length > 0 ? { id: level } : null;
             child = level;
         }
-        // Ranked by where each comes from in the outermost level: the
-        // head right before the first block (with `keep`, right before it
-        // leaves), the blocks, then `specs` after the last — with `keep`,
-        // right before the block after it, so a peer's head that takes the
-        // block they follow sorts before them.
+        // Written in one gap, each right after the block before it, as an
+        // after-record out of the level's slot or a before-record into the gap
+        // before it (`leaving`): the engine's sort decides their order against
+        // a peer's records there (fork patch YP22, `sourceOrder`: the block a
+        // record stands at, then its part), so a peer's heads, pieces, lifts
+        // and new blocks in the same gap keep the serial order whatever the
+        // client ids (`del.merge.container`). The head stands at the first block
+        // (with `keep`, at it: `with`), the blocks at themselves, the new
+        // blocks after the last (`after`) — or, kept before the block that
+        // follows, at that block (`kept`). The records are written last first,
+        // so each stands before the one written before it, in the order the
+        // sort gives them; the head and the new blocks are created in the
+        // innermost level right after the block they stand at (their home,
+        // hidden while their records show them) and moved out by them.
         const outside = before !== null && !before.head;
-        let gap = index + (outside ? 1 : 0);
-        const ranks = exitRanks(levels.at(-1), outside, [
-            ...(before?.head ? [{ at: ids[0], part: [keep ? WITH : HEAD] }] : []),
-            ...moved.map((id) => ({ at: id, part: [SELF] })),
-            ...specs.map((_, i) => keep && !outside ? { at: next, part: [KEPT, i] } : { at: last, part: [AFTER, i] })
-        ]);
-        const writes = before?.head
-            ? insert(parent, gap++, [before.head], ranks.splice(0, 1))
-            : [];
+        const side = leaving(outside);
+        const gap = index + (outside ? 1 : 0);
+        const at = moved[0] ?? last;
+        const kids0 = childrenIds(levels[0]);
+        const home = kids0.indexOf(last) + 1;
+        const specIds = specs.map((sp) => sp.id);
+        const [stands, part] = keep && !outside ? [next, PART.kept] : [last, PART.after];
+        // One record per run of adjacent blocks, each standing at its first: a
+        // block a peer's move takes out of a run leaves the others at their own place.
+        const runs = [];
+        for (const id of moved) {
+            const run = runs.at(-1);
+            if (run !== undefined && kids0.indexOf(run.at(-1)) + 1 === kids0.indexOf(id))
+                run.push(id);
+            else
+                runs.push([id]);
+        }
+        const writes = [
+            ...insert(levels[0], home, specs),
+            ...(before?.head ? insert(levels[0], home, [before.head]) : []),
+            ...moveTo(specIds, parent, gap, side, stands, part),
+            ...runs.reverse().flatMap((run) => moveTo(run, parent, gap, side, run[0], PART.self)),
+            ...(before?.head
+                ? moveTo([before.head.id], parent, gap, side, at, keep ? PART.with : PART.head)
+                : [])
+        ];
         for (const { spec, kids, inner } of heads.reverse()) {
-            const inside = ranksFor(spec.id, 0, kids.length + (inner ? 1 : 0));
-            writes.push(...moveTo(kids, spec.id, 0, inside.slice(0, kids.length)), ...(inner ? insert(spec.id, kids.length, [inner], inside.slice(-1)) : []));
+            writes.push(...moveTo(kids, spec.id, 0), ...(inner ? insert(spec.id, kids.length, [inner]) : []));
         }
-        const mine = ranks.splice(0, moved.length);
-        writes.push(...moveTo(moved, parent, gap, mine), ...insert(parent, gap + moved.length, specs, ranks), ...retype);
+        writes.push(...retype);
+        void next;
         return plan(placed, emptying(levels[0], moved, writes, landing(parent)));
     };
     /**

package/dist/crdt/doc/reads.js

@@ -301,8 +301,8 @@ export const docReads = (c) => {
     const hasBlock = (id) => blockNodeOf(doc, id) !== null;
     /** The one liveness answer (`isLive`): `id` renders in `project()`. O(depth). */
     const live = (id) => isLive(doc, id);
-    /** A live block that can hold content: it has a claims list (a streamless block gets its own text on first write). */
-    const contentTarget = (id) => live(id) && view().blocks.get(id)?.claimsNode !== undefined;
+    /** A live block that can hold content (a streamless block gets its own text on first write). */
+    const contentTarget = (id) => live(id) && view().blocks.has(id);
     return {
         dataNode,
         blockJSON,

package/dist/crdt/doc/seed.js

@@ -3,7 +3,7 @@ import { hash32, setDocRand } from '../rand.js';
 import { keepingReplaced } from '../incarnations.js';
 import { asEngineDoc, asYDoc } from '../structs.js';
 import { DOC_DATA_ROOT, SCHEMA } from '../schema.js';
-import { dataLeaves, isObject, writeLeaves } from '../data.js';
+import { dataWrites, isObject, writeData } from '../data.js';
 import { jsonBlockToSpec, sanitizeSpec, sanitizeWireJson, sanitizeWireString } from '../../utils/json.js';
 import { isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION } from './gate.js';
 /** Origin of the seed update's apply — non-local, like any integrated update. */
@@ -100,7 +100,7 @@ export const bindSeed = (Y, BA) => {
         };
         scratch.transact(() => {
             specs.forEach(records);
-            writeLeaves(scratch.get(DOC_DATA_ROOT), dataLeaves(own));
+            writeData(scratch.get(DOC_DATA_ROOT), dataWrites(own));
         });
         return Y.encodeStateAsUpdate(raw);
     };

package/dist/crdt/doc/split-merge.js

@@ -11,7 +11,7 @@ import { blockNodeOf, isSelfOrDescendant } from '../placement/model.js';
 import { ref } from './plan.js';
 /** The split-merge ops of one facade, prepared. */
 export const splitMergeOps = (c) => {
-    const { doc, view, childrenIds, positionOf, isVoid, isCellKind, blockTypeOf, insideIsland, isLayoutItem, next, previous, displayLength, contentTarget, isContainer, fits, canMerge, rendersContent, kindToCopy, REFUSED, plan, ranksFor, moveTo, move, pieceRanks, leaving, settledKind, settle, landing, emptying, emptied, merge, clamp } = c;
+    const { doc, view, childrenIds, positionOf, isVoid, isCellKind, blockTypeOf, insideIsland, isLayoutItem, next, previous, displayLength, contentTarget, isContainer, fits, canMerge, rendersContent, kindToCopy, REFUSED, plan, moveTo, move, leaving, settledKind, settle, landing, emptying, emptied, merge, clamp } = c;
     /**
      * Split `id` at content `offset` into a new sibling `newId` (one boundary
      * item and the claims that follow it, no text copied; children follow).
@@ -26,7 +26,7 @@ export const splitMergeOps = (c) => {
         const born = ref(newId);
         const pos = positionOf(id);
         const rec = view().blocks.get(id);
-        if (pos === null || isVoid(id) || !rendersContent(id) || !rec?.claimsNode)
+        if (pos === null || isVoid(id) || !rendersContent(id) || rec === undefined)
             return REFUSED;
         // A table's cell holds its lines as line breaks: it never splits (`table.split`).
         if (isCellKind(blockTypeOf(id)))
@@ -39,7 +39,6 @@ export const splitMergeOps = (c) => {
         const t = tail
             ? { type, data: tail.data && sanitizeWireJson(tail.data) }
             : { type, data: readData(rec.node) };
-        const [rank] = pieceRanks(id, at, 1);
         const length = displayLength(id) - at;
         const split = {
             op: 'splitBlock',
@@ -49,7 +48,7 @@ export const splitMergeOps = (c) => {
             newId: born,
             tail: t,
             parent: pos.parent,
-            rank: rank
+            index: pos.index + 1
         };
         return plan([born], [split, ...move(childrenIds(id), born, 0)]);
     };
@@ -58,11 +57,11 @@ export const splitMergeOps = (c) => {
      * children ADOPTED as `into`'s last children — an island's take
      * `into`'s default child, like a baseline merge's — and `from` is
      * hidden via the claim (undo restores it). The children stay under
-     * `from`, ranked after `into`'s children, and display under `into`
-     * through the claim: a concurrent delete of `into` voids the
-     * claim and `from` comes back with its children, never below them.
-     * Role rules are `canMerge`'s; a merge that would close a display
-     * cycle is refused. `ids`: `into`.
+     * `from` and display under `into` through the claim, after `into`'s
+     * own children (the display's claim order): a concurrent delete of
+     * `into` voids the claim and `from` comes back with its children,
+     * never below them. Role rules are `canMerge`'s; a merge that would
+     * close a display cycle is refused. `ids`: `into`.
      */
     const mergeBlocks = (fromId, intoId) => {
         const from = ref(fromId);
@@ -74,9 +73,8 @@ export const splitMergeOps = (c) => {
             return REFUSED;
         const kids = childrenIds(from);
         const retype = settle(from, kids, into);
-        const adopt = moveTo(kids, from, kids.length, ranksFor(into, Infinity, kids.length, kids));
         // A list its only item leaves goes, as with every sibling op.
-        return plan([into], emptied([from], [merge(from, into), ...adopt, ...retype], landing(into)));
+        return plan([into], emptied([from], [merge(from, into), ...retype], landing(into)));
     };
     /**
      * Baseline-shaped merge (both `mergeBackward` and `mergeForward`):
@@ -84,7 +82,7 @@ export const splitMergeOps = (c) => {
      * NOT adopted into `into` — and take the kind they show there
      * (`settledKind`: an island's children its parent's default child, a
      * paragraph in a list its item); then `from`'s content claims
-     * into `into`. Ranked after `from`, not at it: a concurrent delete of
+     * into `into`. Placed after `from`, not at it: a concurrent delete of
      * `into` revives `from` above its former children.
      */
     const mergeUnnesting = (from, into) => {
@@ -93,8 +91,7 @@ export const splitMergeOps = (c) => {
             return REFUSED;
         const kids = childrenIds(from);
         const retype = settle(from, kids, pos.parent);
-        const out = leaving(from, true, kids);
-        return plan([into], [...moveTo(kids, pos.parent, pos.index + 1, out), ...retype, merge(from, into)]);
+        return plan([into], [...moveTo(kids, pos.parent, pos.index + 1, leaving(true)), ...retype, merge(from, into)]);
     };
     /** Remove `container`, left empty, for the key at `id` (refused if it holds text). */
     const gone = (id, container) => {
@@ -143,7 +140,7 @@ export const splitMergeOps = (c) => {
             if (!fits(slot.parent, settledKind(prev, id, slot.parent)))
                 return REFUSED;
             const lift = [
-                ...moveTo([id], slot.parent, slot.index, leaving(prev, false, [id])),
+                ...moveTo([id], slot.parent, slot.index, leaving(false)),
                 ...settle(prev, [id], slot.parent)
             ];
             return plan([id], emptying(prev, [id], lift, landing(slot.parent)));

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

@@ -1,28 +1,40 @@
+/**
+ * The step writers every prepared op composes: the plan itself, moves (a
+ * move's place and side), type steps and the kind a block shows where it
+ * lands (`settle`), the containers and layouts a write leaves empty
+ * (`emptying`, `dissolving`), delete and merge steps, and display spans of a
+ * block's content.
+ */
 import { TYPE } from '../schema.js';
 import { type BlockId, type ContentItem } from '../placement/model.js';
 import type { Plan, PlanStep } from './types.js';
 import type { DocBase, DocReads } from './reads.js';
 import type { DocCapability } from './capability.js';
 /** What the step writers read: the reads and the structural capability. */
+/**
+ * A record's order among the records standing at one block, for the
+ * engine's sort of two records at one origin (fork patch YP22): what a split
+ * of a list around a block writes there — a new head list holding the items
+ * before it (`head`), new blocks placed after the items before it, which
+ * stay (`kept`), a head holding those items and the block (`with`), the
+ * block itself leaving (`self`), new blocks after it (`after`) — in the
+ * order every serial run of the gestures gives (`del.merge.container`).
+ */
+export declare const PART: {
+    readonly head: 0;
+    readonly kept: 1;
+    readonly with: 2;
+    readonly self: 3;
+    readonly after: 4;
+};
 export type StepsContext = DocBase & DocReads & DocCapability;
 /** The step writers of one facade. */
 export declare const planSteps: (c: StepsContext) => {
     REFUSED: import("./types.js").OpResult;
-    HEAD: number;
-    KEPT: number;
-    WITH: number;
-    SELF: number;
-    AFTER: number;
     plan: (ids: readonly BlockId[], writes: PlanStep[]) => Plan;
-    ranksFor: (parent: BlockId | null, index: number, count: number, exclude?: readonly BlockId[], run?: boolean) => string[];
-    moveTo: (ids: BlockId[], parent: BlockId | null, index: number, ranks: string[]) => PlanStep[];
+    moveTo: (ids: BlockId[], parent: BlockId | null, index: number, side?: 0 | 1, at?: BlockId, part?: number) => PlanStep[];
     move: (ids: BlockId[], parent: BlockId | null, index: number) => PlanStep[];
-    exitRanks: (outer: BlockId, after: boolean, parts: readonly {
-        at: BlockId;
-        part: readonly number[];
-    }[]) => string[];
-    pieceRanks: (id: BlockId, at: number, count: number) => string[];
-    leaving: (outer: BlockId, after: boolean, ids: readonly BlockId[]) => string[];
+    leaving: (after: boolean) => 0 | 1;
     attr: (id: BlockId, key: typeof TYPE, value: string) => PlanStep[];
     leavingIsland: (island: BlockId, kind: string | undefined, to: string) => string | undefined;
     settledKind: (from: BlockId | null, kid: BlockId, parent: BlockId | null) => string | undefined;

package/dist/crdt/doc/steps.js

@@ -1,17 +1,27 @@
 /**
- * The step writers every prepared op composes: the plan itself, ranks (a
- * move's, a source rank by where blocks come from, a split's pieces), type
- * steps and the kind a block shows where it lands (`settle`), the
- * containers and layouts a write leaves empty (`emptying`, `dissolving`),
- * delete and merge steps, and display spans of a block's content.
+ * The step writers every prepared op composes: the plan itself, moves (a
+ * move's place and side), type steps and the kind a block shows where it
+ * lands (`settle`), the containers and layouts a write leaves empty
+ * (`emptying`, `dissolving`), delete and merge steps, and display spans of a
+ * block's content.
  */
-import { randOf } from '../rand.js';
 import { TYPE } from '../schema.js';
-import { blockNodeOf, positionInView, promotedRank, ranksAt, SOURCE_SIDE, sourceRank } from '../placement/model.js';
+import { blockNodeOf } from '../placement/model.js';
 import { REFUSED, effectOf } from './plan.js';
+/** What the step writers read: the reads and the structural capability. */
+/**
+ * A record's order among the records standing at one block, for the
+ * engine's sort of two records at one origin (fork patch YP22): what a split
+ * of a list around a block writes there — a new head list holding the items
+ * before it (`head`), new blocks placed after the items before it, which
+ * stay (`kept`), a head holding those items and the block (`with`), the
+ * block itself leaving (`self`), new blocks after it (`after`) — in the
+ * order every serial run of the gestures gives (`del.merge.container`).
+ */
+export const PART = { head: 0, kept: 1, with: 2, self: 3, after: 4 };
 /** The step writers of one facade. */
 export const planSteps = (c) => {
-    const { doc, runsView, roles, rendersContentOf, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, is, isIsland, itemKindOf, isLayout, displayLength, contentItems, live, isContainer, fitted, emptiable, rendersContent, defaultChild } = c;
+    const { doc, runsView, roles, rendersContentOf, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, is, isIsland, itemKindOf, isLayout, displayLength, contentItems, live, isContainer, fitted, emptiable, defaultChild } = c;
     // ── prepared ops ─────────────────────────────────────────────
     // Every op is `prepare` (pure: `refused`, or a plan of named steps plus
     // its effect summary, against the current version) then `apply(plan)`;
@@ -19,124 +29,52 @@ export const planSteps = (c) => {
     // whole command before any write and a refusal refuses before one.
     // Each prepare normalizes its inputs once, here at ingress: ids
     // and strings as the wire would deliver them, payloads cloned.
-    /** `exitRanks` parts, in their order at one block. */
-    const [HEAD, KEPT, WITH, SELF, AFTER] = [0, 1, 2, 3, 5];
     const plan = (ids, writes) => ({
         ids,
         writes,
         effect: effectOf(writes),
         version: runsView.version()
     });
-    /** This client's next clock: what its source ranks are tied by (`sourceRank`). */
-    const clock = () => doc.store?.getClock(doc.clientID) ?? 0;
-    /**
-     * `count` ranks at `index` among `parent`'s children, the moving
-     * `exclude` left out. `run`: new blocks, which extend this client's run
-     * after a block it ranked (`order.insert.run`); a move never does
-     * (the rank-growth guard).
-     */
-    const ranksFor = (parent, index, count, exclude = [], run = false) => {
-        const v = view();
-        const all = v.kids.get(parent) ?? [];
-        // The moving blocks' own slots left out: index → the list's index past them.
-        const gone = exclude
-            .map((id) => positionInView(v, id))
-            .filter((p) => p !== null && p.parent === parent)
-            .map((p) => p.index)
-            .sort((a, b) => a - b);
-        const raw = (i) => {
-            for (const g of gone)
-                if (g <= i)
-                    i++;
-            return i;
-        };
-        const at = Math.max(0, Math.min(index, all.length - gone.length));
-        const pair = [at > 0 ? all[raw(at - 1)] : undefined, all[raw(at)]];
-        return ranksAt(pair, 1, count, doc.clientID, randOf(doc), run);
-    };
     /**
-     * Move `ids` to `ranks` under `parent` (`index`: the slot hooks see).
+     * Move `ids` to display index `index` among `parent`'s children (the
+     * slot hooks see). `side`: the move record's class among the items of
+     * its origin (`placement/slots.ts`) — `0`, the blocks stand after what
+     * precedes them (a move; blocks leaving a block for the gap after it:
+     * its children, a list's last items); `1`, before what follows them
+     * (blocks leaving a block for the gap before it: a list's first item
+     * lifted out). In one gap every serial order of the gestures puts a
+     * split's pieces first, then the after-records, then the before-records
+     * (`del.merge.container`), which the engine's sort gives whatever the
+     * client ids.
      * Every planned move carries the type steps that keep what the moved
      * blocks show: one displayed out of an island as another kind than its
      * stored one (`displayType`) gets that kind written, so leaving the
      * island's slot never brings the island's child kind back.
+     * `at`, `part`: the block the record stands at and its order among the
+     * records standing there, for the engine's sort of two records at one
+     * origin (`PART`; by default the first moved block, as itself).
      */
-    const moveTo = (ids, parent, index, ranks) => ids.length === 0
+    const moveTo = (ids, parent, index, side = 0, at, part) => ids.length === 0
         ? []
         : [
-            { op: 'moveBlocks', ids, parent, index, ranks },
+            {
+                op: 'moveBlocks',
+                ids,
+                parent,
+                index,
+                ...(side === 1 && { side }),
+                ...(at !== undefined && { at }),
+                ...(part !== undefined && { part })
+            },
             ...ids.flatMap((id) => {
                 const shown = runsView.displayType(id);
                 return shown === undefined ? [] : attr(id, TYPE, shown);
             })
         ];
     /** Move `ids` to `index` among `parent`'s children. */
-    const move = (ids, parent, index) => moveTo(ids, parent, index, ranksFor(parent, index, ids.length, ids));
-    /**
-     * Ranks for blocks leaving `outer` for the gap right before it (`after`:
-     * right after it), in the order they come from (`sourceRank`):
-     * two peers that split or lift out of the same list at once keep the
-     * text in its order, whatever their client ids. Each part names the
-     * block in `outer` it stands at (`at`; one that shows no text of its
-     * own, a list, stands at its first item) and its `part` there:
-     * - `HEAD`: a new list holding the items before `at`;
-     * - `KEPT`, index: a block placed after the items before `at`, which
-     *   stay (a divider inserted after an item: a peer's head that takes
-     *   them sorts before it);
-     * - `WITH`: a new list holding the items before `at` and `at` (`keep`);
-     * - `SELF`: `at` itself leaving (`SELF + 1` when it stands at its first item);
-     * - `AFTER`, index: a block placed after it.
-     * A degenerate gap ranks them as any insert.
-     */
-    const exitRanks = (outer, after, parts) => {
-        const { kids } = view();
-        const { parent, index } = positionOf(outer);
-        const sibs = kids.get(parent) ?? [];
-        const gap = after ? index + 1 : index;
-        const ranks = [];
-        for (let { at, part } of parts) {
-            const own = at;
-            while (!rendersContent(at) && childrenIds(at).length > 0)
-                at = childrenIds(at)[0];
-            if (part[0] === SELF && at !== own)
-                part = [SELF + 1];
-            const path = [];
-            for (let c = at; c !== outer; c = positionOf(c).parent) {
-                const pos = positionOf(c);
-                path.unshift(kids.get(pos.parent)[pos.index].rank);
-            }
-            const side = after ? SOURCE_SIDE.after : SOURCE_SIDE.before;
-            const rank = sourceRank(sibs[gap - 1]?.rank, sibs[gap]?.rank, side, path, part, doc.clientID, clock());
-            if (rank === null)
-                return ranksFor(parent, gap, parts.length);
-            ranks.push(rank);
-        }
-        return ranks;
-    };
-    /**
-     * Ranks for the `count` blocks a split of `id` at `at` puts right after
-     * it (Enter, a paste of several lines), by where it splits
-     * (SW12-crdt-1, SW12-crdt-4): two peers splitting one block at once
-     * keep its pieces in text order, whatever their client ids. Counted
-     * from the end — the text after the split point, most first — so a
-     * peer's own edit before its split point (typing, then Enter; a paste
-     * over a selection) does not move it; an unseen edit after
-     * it does (the residual, in the delete contract).
-     */
-    const pieceRanks = (id, at, count) => {
-        const { parent, index } = positionOf(id);
-        const sibs = view().kids.get(parent) ?? [];
-        const ranks = [];
-        for (let i = 0; i < count; i++) {
-            const rank = sourceRank(sibs[index]?.rank, sibs[index + 1]?.rank, SOURCE_SIDE.pieces, [], [at - displayLength(id), i], doc.clientID, clock());
-            if (rank === null)
-                return ranksFor(parent, index + 1, count);
-            ranks.push(rank);
-        }
-        return ranks;
-    };
-    /** `exitRanks` for `ids` themselves leaving `outer`. */
-    const leaving = (outer, after, ids) => exitRanks(outer, after, ids.map((at) => ({ at, part: [SELF] })));
+    const move = (ids, parent, index) => moveTo(ids, parent, index);
+    /** The side of blocks leaving a block for the gap right after it (`after`) or right before it. */
+    const leaving = (after) => (after ? 0 : 1);
     /**
      * A type step, planned only when the kind differs (the one same-value
      * guard). A kind counts as the same only when the block is stored and
@@ -241,10 +179,10 @@ export const planSteps = (c) => {
      * with one item or none — `gone` (blocks the plan removes) and
      * `leaving` (blocks it moves) no longer count, an item `writes` move or
      * insert into it does. With one left, the layout and that item are
-     * deleted and the item's children moved to the layout's slot at the
-     * rank `layout.single` reads (`promotedRank` of the layout's, then the
-     * item's), as the kind they show there (`settle`); with none, the
-     * layout is deleted. One plan with the write that caused it.
+     * deleted and the item's children moved right after the layout, where
+     * `layout.single` shows them, as the kind they show there (`settle`);
+     * with none, the layout is deleted. One plan with the write that caused
+     * it.
      */
     const dissolving = (gone, leaving, writes) => {
         const away = new Set([...gone, ...leaving]);
@@ -269,17 +207,17 @@ export const planSteps = (c) => {
             const items = slots.filter((k) => !away.has(k.id) && blockTypeOf(k.id) === item);
             if (items.length + arriving > 1)
                 continue;
-            const { parent, index } = positionOf(layout);
-            const rank = kids.get(parent)[index].rank;
+            const { parent } = positionOf(layout);
             const last = items[0];
             if (last === undefined) {
                 out.push(deleting(layout, [layout]));
                 continue;
             }
+            // Its blocks keep their home slots: the read shows them in the layout's
+            // slot (`layout.single`), settled for its parent.
             const moved = (kids.get(last.id) ?? []).filter((k) => !away.has(k.id));
             const ids = moved.map((k) => k.id);
-            const ranks = moved.map((k) => promotedRank(rank, promotedRank(last.rank, k.rank)));
-            out.push(...moveTo(ids, parent, index + 1, ranks), ...settle(last.id, ids, parent), deleting(layout, [layout, last.id]));
+            out.push(...settle(last.id, ids, parent), deleting(layout, [layout, last.id]));
         }
         return out;
     };
@@ -349,17 +287,9 @@ export const planSteps = (c) => {
     const emptied = (leaving, writes, kept) => emptyingAll(leaving.map((id) => positionOf(id).parent), leaving, writes, kept);
     return {
         REFUSED,
-        HEAD,
-        KEPT,
-        WITH,
-        SELF,
-        AFTER,
         plan,
-        ranksFor,
         moveTo,
         move,
-        exitRanks,
-        pieceRanks,
         leaving,
         attr,
         leavingIsland,