edytor 2.0.0 → 4.0.0

package/dist/crdt/doc/layout.js

@@ -8,7 +8,7 @@ import { sanitizeSpec } from '../../utils/json.js';
 import { ref } from './plan.js';
 /** The layout ops of one facade, prepared. */
 export const layoutOps = (c) => {
-    const { roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isIsland, isLines, insideIsland, isLayout, isLayoutItem, holdsLayout, insideItem, live, canPlace, isContainer, fits, fitsIn, REFUSED, plan, ranksFor, moveTo, landing, emptied } = c;
+    const { roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isIsland, isLines, insideIsland, isLayout, isLayoutItem, holdsLayout, insideItem, live, canPlace, isContainer, fits, fitsIn, REFUSED, plan, moveTo, landing, emptied } = c;
     /** The layout kind a new layout takes: `kind` when it is one, else the only one the roles declare. */
     const layoutKind = (kind) => {
         if (kind !== undefined)
@@ -62,8 +62,8 @@ export const layoutOps = (c) => {
      * an item, a layout or a block holding one, a block that does not
      * fit an item, a block or a layout inside an island, and, wrapping,
      * when there is no layout kind. The sources are cleaned in the same
-     * plan (`emptying`, `dissolving`); plain ranks (a move). `ids`: the
-     * moved blocks.
+     * plan (`emptying`, `dissolving`); a plain move. `ids`: the moved
+     * blocks.
      */
     const placeBeside = (ids, target, side, kind) => {
         const moved = ids.map(ref);
@@ -98,25 +98,20 @@ export const layoutOps = (c) => {
         if (layout !== null && (isIsland(layout) || insideIsland(layout, v)))
             return REFUSED;
         const fresh = spec(item);
-        const into = (parent) => moveTo(moved, parent, 0, ranksFor(parent, 0, moved.length));
+        const into = (parent) => moveTo(moved, parent, 0);
         let writes;
         let kept;
         if (layout !== null) {
-            const ranks = ranksFor(layout, index, 1);
-            writes = [
-                { op: 'insertBlocks', parent: layout, index, specs: [fresh], ranks },
-                ...into(fresh.id)
-            ];
+            writes = [{ op: 'insertBlocks', parent: layout, index, specs: [fresh] }, ...into(fresh.id)];
             kept = new Set([fresh.id, ...landing(layout)]);
         }
         else {
             const pos = positionOf(at);
             const host = spec(item);
             const wrapper = { ...spec(wrap), children: right ? [host, fresh] : [fresh, host] };
-            const ranks = ranksFor(pos.parent, pos.index, 1);
             writes = [
-                { op: 'insertBlocks', parent: pos.parent, index: pos.index, specs: [wrapper], ranks },
-                ...moveTo([at], host.id, 0, ranksFor(host.id, 0, 1)),
+                { op: 'insertBlocks', parent: pos.parent, index: pos.index, specs: [wrapper] },
+                ...moveTo([at], host.id, 0),
                 ...into(fresh.id)
             ];
             kept = new Set([wrapper.id, host.id, fresh.id, ...landing(pos.parent)]);
@@ -134,8 +129,8 @@ export const layoutOps = (c) => {
      * fewer items than blocks, blocks of different parents, an item, a
      * layout or a block holding one, where the layout does not fit
      * (`fits`: in a list, a code block) or lands inside an item or an
-     * island, and for a block that does not fit an item. Plain ranks (a
-     * move). `ids`: the new layout.
+     * island, and for a block that does not fit an item. A plain move.
+     * `ids`: the new layout.
      */
     const wrapInLayout = (ids, kind, columns = ids.length) => {
         const blocks = ids.map(ref);
@@ -165,14 +160,8 @@ export const layoutOps = (c) => {
         const wrapper = { ...spec(wrap), children: items };
         const at = positionOf(ordered[0]).index;
         const writes = [
-            {
-                op: 'insertBlocks',
-                parent,
-                index: at,
-                specs: [wrapper],
-                ranks: ranksFor(parent, at, 1)
-            },
-            ...ordered.flatMap((id, i) => moveTo([id], items[i].id, 0, ranksFor(items[i].id, 0, 1)))
+            { op: 'insertBlocks', parent, index: at, specs: [wrapper] },
+            ...ordered.flatMap((id, i) => moveTo([id], items[i].id, 0))
         ];
         const kept = new Set([
             wrapper.id,

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;