edytor 2.0.0 → 4.0.0

package/dist/crdt/data.js

@@ -1,10 +1,11 @@
 import { DATA_LEAF_PREFIX } from './schema.js';
-import { rankAfter } from './placement/rank.js';
 import { hash32 } from './rand.js';
 import { jsonEquals } from '../utils/json.js';
+import { entriesOf, isDataSlot, placeAfter, removeUnit, triples } from './placement/slots.js';
+import { asEngineDoc } from './structs.js';
 export const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-const tree = (v) => ({ v, k: new Map() });
-const kid = (t, s) => t.k.get(s) ?? t.k.set(s, tree()).get(s);
+const tree = (p = '', v) => ({ p, v, k: new Map() });
+const kid = (t, s) => t.k.get(s) ?? t.k.set(s, tree(t.p === '' ? s : `${t.p}/${s}`)).get(s);
 const enc = (k) => k.replace(/~/g, '~0').replace(/\//g, '~1');
 const dec = (s) => s.replace(/~1/g, '/').replace(/~0/g, '~');
 const itemish = (s) => /^~[a-z]/.test(s);
@@ -15,52 +16,50 @@ const itemish = (s) => /^~[a-z]/.test(s);
 export const keySegment = (k) => (k.startsWith('~') ? `~0${k.slice(1)}` : k);
 /** The object key a path segment names (`keySegment`'s inverse). */
 export const segmentKey = (s) => (s.startsWith('~0') ? `~${s.slice(2)}` : s);
-/** A rank's characters (`placement/rank.ts`: variable-length digits, `!` before a tie). */
-const RANK = /^[-\w?!]+$/;
 const index = (k) => (/^(0|[1-9]\d*)$/.test(k) ? Number(k) : -1);
-const rank = (v) => (typeof v === 'string' && RANK.test(v) ? v : undefined);
-/** Item `id`'s place: where a move put it (`id>`), else where it was made (`id#`). */
-const placeOf = (t, id) => rank(t.k.get(`${id}>`)?.v) ?? rank(t.k.get(`${id}#`)?.v);
-/** `t`'s live items (made, `id#`, and not removed: a move never revives one), in order. */
-const itemsOf = (t) => {
-    const out = [];
-    for (const [s, c] of t.k)
-        if (s.endsWith('#') && itemish(s) && rank(c.v))
-            out.push({ id: s.slice(0, -1), rank: placeOf(t, s.slice(0, -1)) });
-    // ` ` sorts below every rank character: a rank before its extensions, then by id.
-    return out.sort((a, b) => (`${a.rank} ${a.id}` < `${b.rank} ${b.id}` ? -1 : 1));
-};
+/** `t`'s live items in order. */
+const itemsOf = (t) => t.items ?? [];
 const isArr = (t) => Array.isArray(t.v) || itemsOf(t).length > 0;
 /** The item `seg` names among `items`: by its id (`~…`) or by its index. */
-const itemAt = (items, seg) => itemish(seg) ? items.find((i) => i.id === seg) : items[index(seg)];
+const itemAt = (items, seg) => itemish(seg) ? items.find((i) => i === seg) : items[index(seg)];
 /** Whether `t` holds a non-empty object or array as one leaf (no subtree under it). */
-const closed = (t) => t.k.size === 0 && t.v !== null && typeof t.v === 'object' && Object.keys(t.v).length > 0;
-/** `t` with a container leaf's value as its subtree: its keys, or derived items. */
+const closed = (t) => t.k.size === 0 &&
+    itemsOf(t).length === 0 &&
+    t.v !== null &&
+    typeof t.v === 'object' &&
+    Object.keys(t.v).length > 0;
+/** `t` with a container leaf's value as its subtree: its keys, or derived items (slotless until written). */
 const open = (t) => {
     if (closed(t)) {
         const value = t.v;
         t.v = undefined;
         derived.assign(t, value);
+        if (t.items !== undefined)
+            t.unslotted = new Set(t.items);
     }
     return t;
 };
 /** The JSON `t` reads as (`undefined` for nothing): a fresh value. */
 const valueOf = (t) => {
     if (closed(t))
-        return valueOf(open(tree(t.v)));
+        return valueOf(open(tree(t.p, t.v)));
     const items = itemsOf(t);
     if (items.length)
-        return items.map(({ id }) => valueOf(t.k.get(id) ?? tree()) ?? null);
+        return items.map((id) => valueOf(t.k.get(id) ?? tree()) ?? null);
     const keys = [...t.k]
         .map(([s, c]) => [dec(s), itemish(s) ? undefined : valueOf(c)])
         .filter(([, v]) => v !== undefined);
     // Own properties only: a `__proto__` key (a peer's too) is data, never a prototype.
     return keys.length ? Object.fromEntries(keys) : t.v;
 };
-const treeOf = (leaves) => {
+const treeOf = (leaves, slots) => {
     const root = tree();
     for (const [key, v] of [...leaves].sort(([a], [b]) => (a < b ? -1 : 1)))
         key.slice(DATA_LEAF_PREFIX.length).split('/').reduce(kid, root).v = v;
+    for (const [p, ids] of slots) {
+        const t = p === '' ? root : p.split('/').reduce(kid, root);
+        t.items = ids;
+    }
     return root;
 };
 const leavesFrom = (t, prefix = DATA_LEAF_PREFIX, out = new Map()) => {
@@ -142,50 +141,74 @@ const canon = (v) => JSON.stringify(v, (_, x) => (isObject(x) ? Object.fromEntri
 /** New items holding `values`. */
 const added = (values) => values.map((value) => ({ value }));
 /**
- * The tree edits. New items take ids and ranks from `rand` and `client`;
- * without `rand` they are derived from their indexes and `client` (a new
- * array's hash), so equal values write equal items everywhere.
+ * The tree edits. New items take ids from `rand`; without `rand` they are
+ * derived from their indexes and `client` (a new array's hash), so equal
+ * values write equal items everywhere. The sequence writes they need
+ * (slots, moves, removals) go to `out`.
  */
-const edits = (rand, client = 0) => {
-    const pick = rand ?? (() => 0);
+const edits = (rand, client = 0, out) => {
     const fresh = (t, i) => {
         for (;;) {
             const id = rand
                 ? `~${Math.floor(36 ** 7 * (10 + 26 * rand())).toString(36)}`
                 : `~l${i++}.${client.toString(36)}`;
-            if (![id, `${id}#`, `${id}>`].some((s) => t.k.has(s)))
+            if (!t.k.has(id) && !itemsOf(t).includes(id))
                 return id;
         }
     };
-    const remove = (t, id) => [id, `${id}#`, `${id}>`].forEach((s) => t.k.delete(s));
+    const remove = (t, id) => {
+        const item = t.k.get(id);
+        if (item !== undefined)
+            drop(item);
+        t.k.delete(id);
+        if (t.items !== undefined)
+            t.items = t.items.filter((x) => x !== id);
+        if (t.unslotted?.delete(id) !== true)
+            out?.push({ seq: 'remove', path: t.p, ids: [id] });
+    };
+    /** What `t` held goes with it: the slots of every array at or under it. */
+    const drop = (t) => {
+        for (const id of itemsOf(t))
+            remove(t, id);
+        for (const c of t.k.values())
+            drop(c);
+    };
     /**
-     * A rank in `(left, right)`. After an item this client placed, it is in
-     * the client's run there (`rankAfter`): what it inserts after its own
-     * items stays together, as `Y.Array` keeps an insert after its origin,
-     * whatever a peer inserts in that gap meanwhile. Elsewhere a plain rank.
+     * Give `entries` (kept items, moved items, new values) their places in
+     * `t`, in order: each new item's slot and each moved item's record go
+     * right after the entry before it (YATA's origin rule keeps what one
+     * writer puts after an item together, whatever a peer inserts there
+     * meanwhile), consecutive ones as one write.
      */
-    const between = (left, right) => rankAfter(left, right, client, pick);
-    /** Give `entries` (kept items, moved items, new values) their places in `t`, in order. */
     const lay = (t, entries) => {
-        let left;
-        let right;
-        let r = -1; // the next kept entry, whose place bounds the run before it
+        const ids = [];
+        let after = null;
+        let run = null;
         for (let p = 0; p < entries.length; p++) {
             const e = entries[p];
-            if (e.keep) {
-                left = placeOf(t, e.id);
-                continue;
+            let id = e.id;
+            let seq = null;
+            if (id === undefined) {
+                id = fresh(t, p);
+                assign(kid(t, id), e.value);
+                seq = 'insert';
             }
-            if (r < p) {
-                for (r = p + 1; r < entries.length && !entries[r].keep; r++)
-                    ;
-                right = r < entries.length ? placeOf(t, entries[r].id) : undefined;
+            else if (t.unslotted?.delete(id))
+                seq = 'insert';
+            else if (!e.keep)
+                seq = 'move';
+            ids.push(id);
+            if (seq !== null && out !== undefined) {
+                if (run !== null && run.seq === seq)
+                    run.ids.push(id);
+                else
+                    out.push((run = { seq, path: t.p, after, ids: [id] }));
             }
-            const id = e.id ?? fresh(t, p);
-            left = kid(t, `${id}${e.id ? '>' : '#'}`).v = between(left, left !== undefined && right !== undefined && left >= right ? undefined : right);
-            if (e.id === undefined)
-                assign(kid(t, id), e.value);
+            else
+                run = null;
+            after = id;
         }
+        t.items = ids;
     };
     /** Make `t` read as `value`, writing only what differs: objects key by key, arrays item by item. */
     const assign = (t, value) => {
@@ -193,16 +216,20 @@ const edits = (rand, client = 0) => {
             return arrange(t, value);
         // Anything else replaces what `t` held, but an object's equal keys.
         const object = isObject(value) && Object.keys(value).length > 0;
+        for (const id of itemsOf(t))
+            remove(t, id);
         for (const s of [...t.k.keys()])
-            if (!object || itemish(s) || !Object.hasOwn(value, dec(s)))
+            if (!object || itemish(s) || !Object.hasOwn(value, dec(s))) {
+                drop(t.k.get(s));
                 t.k.delete(s);
+            }
         t.v = object ? undefined : Array.isArray(value) ? [] : value;
         if (object)
             for (const [k, v] of Object.entries(value))
                 assign(kid(t, enc(k)), v);
         // A new array's items derive from it: two peers making the same one make one.
         if (Array.isArray(value))
-            edits(undefined, hash32(canon(value))).lay(t, added(value));
+            edits(undefined, hash32(canon(value)), out).lay(t, added(value));
     };
     /**
      * An array reassigned: the items a longest common run keeps equal stay;
@@ -211,23 +238,23 @@ const edits = (rand, client = 0) => {
      */
     const arrange = (t, next) => {
         const old = itemsOf(t);
-        const was = old.map(({ id }) => canon(valueOf(t.k.get(id) ?? tree()) ?? null));
+        const was = old.map((id) => canon(valueOf(t.k.get(id) ?? tree()) ?? null));
         const entries = [];
         let [i, j] = [0, 0];
         for (const [mi, mj] of [...common(was, next.map(canon)), [old.length, next.length]]) {
             for (let n = 0; n < Math.max(mi - i, mj - j); n++) {
                 const o = i + n < mi ? old[i + n] : undefined;
                 if (j + n >= mj)
-                    remove(t, o.id);
-                else if (!o)
+                    remove(t, o);
+                else if (o === undefined)
                     entries.push({ value: next[j + n] });
                 else {
-                    entries.push({ id: o.id, keep: true });
-                    assign(kid(t, o.id), next[j + n]);
+                    entries.push({ id: o, keep: true });
+                    assign(kid(t, o), next[j + n]);
                 }
             }
             if (mi < old.length)
-                entries.push({ id: old[mi].id, keep: true });
+                entries.push({ id: old[mi], keep: true });
             [i, j] = [mi + 1, mj + 1];
         }
         t.v = [];
@@ -243,7 +270,7 @@ const edits = (rand, client = 0) => {
                 return t;
             if (isArr(open(t))) {
                 const item = itemAt(itemsOf(t), k);
-                t = item && kid(t, item.id);
+                t = item === undefined ? undefined : kid(t, item);
             }
             else if (itemish(k))
                 return undefined;
@@ -260,7 +287,7 @@ const edits = (rand, client = 0) => {
         if (!at)
             return false;
         const items = isArr(at) ? itemsOf(at) : undefined;
-        const list = items?.map(({ id }) => ({ id, keep: true })) ?? [];
+        const list = items?.map((id) => ({ id, keep: true })) ?? [];
         const k = path.at(-1);
         if (order) {
             const ids = Array.isArray(order) ? order.map((i) => list[i]?.id) : [];
@@ -289,9 +316,14 @@ const edits = (rand, client = 0) => {
                 return false; // an item where no array is
             if (value !== undefined)
                 assign(reach(at, [k]), value);
-            // The last key of an object deleted keeps the object.
-            else if (at.k.delete(enc(segmentKey(k))) && at !== root && valueOf(at) === undefined)
-                at.v = {};
+            else {
+                const gone = at.k.get(enc(segmentKey(k)));
+                if (gone !== undefined)
+                    drop(gone);
+                // The last key of an object deleted keeps the object.
+                if (at.k.delete(enc(segmentKey(k))) && at !== root && valueOf(at) === undefined)
+                    at.v = {};
+            }
             return true;
         }
         else {
@@ -319,104 +351,180 @@ const leavesOf = (node) => {
             out.set(key, node.getAttr(key));
     return out;
 };
-/** The leaves of `value` under `prefix`; its arrays' items derived from them. */
-const leavesOfValue = (value, prefix = DATA_LEAF_PREFIX) => {
+/** The data slots of `node`'s sequence as displayed: per array path, its item ids in order (an id once), and each id's entries. */
+const slotsOf = (node) => {
+    const slots = new Map();
+    const entries = new Map();
+    if (node.doc == null)
+        return { slots, entries };
+    for (const e of entriesOf(asEngineDoc(node.doc), node)) {
+        if (!isDataSlot(e.value))
+            continue;
+        const { p, i } = e.value;
+        const key = `${p}\u0000${i}`;
+        const list = entries.get(key);
+        if (list === undefined) {
+            entries.set(key, [e]);
+            const ids = slots.get(p);
+            if (ids === undefined)
+                slots.set(p, [i]);
+            else
+                ids.push(i);
+        }
+        else
+            list.push(e);
+    }
+    return { slots, entries };
+};
+/** The leaves of `value` under `prefix`, and the slots of its arrays' items, derived from them. */
+const writesOfValue = (value) => {
     const t = tree();
-    derived.assign(t, value);
-    return leavesFrom(t, prefix);
+    const out = [];
+    edits(undefined, 0, out).assign(t, value);
+    return [...leavesFrom(t), ...out];
 };
-/** A new node's data, as leaves. */
-export const dataLeaves = (data) => leavesOfValue(isObject(data) ? data : {});
+/** A new node's data, as the writes that give it (its leaves and its arrays' slots). */
+export const dataWrites = (data) => writesOfValue(isObject(data) ? data : {});
 /** A path of the data as a leaf key (`d/` and its pointer). */
 export const leafKey = (path) => DATA_LEAF_PREFIX + path.map((k) => enc(k)).join('/');
+/** A path of the data as a slot's `p` (its pointer without `d/`). */
+const slotPath = (key) => key.slice(DATA_LEAF_PREFIX.length);
 /**
- * `leaves` with every atomic path (`data.atomic`: a leaf key a kind
- * declares) holding one leaf: the value of everything at and under it.
+ * The leaves of `root` with every atomic path (`data.atomic`: a leaf key a
+ * kind declares) holding one leaf: the value of everything at and under it.
  */
-const collapse = (leaves, atomic) => {
-    if (atomic.length === 0)
-        return leaves;
-    const root = treeOf(leaves);
+const collapse = (root, atomic) => {
     for (const key of atomic) {
         let t = root;
-        for (const s of key.slice(DATA_LEAF_PREFIX.length).split('/'))
+        for (const s of slotPath(key).split('/'))
             t = t?.k.get(s);
-        if (t === undefined || t.k.size === 0)
+        if (t === undefined || (t.k.size === 0 && itemsOf(t).length === 0))
             continue;
         t.v = valueOf(t);
         t.k.clear();
+        t.items = undefined;
+        t.unslotted = undefined;
     }
     return leavesFrom(root);
 };
+/** Whether `path` (a slot's `p`) lies at or under one of the atomic leaf keys. */
+const underAtomic = (path, atomic) => atomic.some((key) => {
+    const a = slotPath(key);
+    return path === a || path.startsWith(`${a}/`);
+});
 /** `node`'s data (`undefined` when it has none). */
-export const readData = (node) => valueOf(treeOf(leavesOf(node)));
+export const readData = (node) => valueOf(treeOf(leavesOf(node), slotsOf(node).slots));
 /**
  * The ids of the items of the array at `path` (keys, item indexes or ids)
  * in `node`'s data, in order; `[]` where no array is.
  */
-export const itemIds = (node, path) => idsAt(treeOf(leavesOf(node)), path);
+export const itemIds = (node, path) => idsAt(treeOf(leavesOf(node), slotsOf(node).slots), path);
 const idsAt = (root, path) => {
     let t = root;
     for (const k of path)
         if (t && isArr(open(t))) {
             const item = itemAt(itemsOf(t), k);
-            t = item && t.k.get(item.id);
+            t = item === undefined ? undefined : t.k.get(item);
         }
         else
             t = itemish(k) ? undefined : t?.k.get(enc(segmentKey(k)));
-    return t ? itemsOf(open(t)).map(({ id }) => id) : [];
+    return t ? itemsOf(open(t)) : [];
 };
 /**
  * `node`'s data as it reads once `patches` are applied (nothing written),
  * with the ids of the array items at a path (`itemIds`): an item a patch
- * makes has no id yet (`''`), so a later patch names it by index.
+ * makes has no slot yet (`''`), so a later patch names it by index.
  * `null` when a patch fits no value.
  */
 export const previewData = (node, patches) => {
     const base = node ? leavesOf(node) : new Map();
-    const root = treeOf(base);
+    const { slots } = node ? slotsOf(node) : { slots: new Map() };
+    const root = treeOf(base, slots);
     if (!patches.every((p) => edits().apply(root, p)))
         return null;
-    const known = new Set([...base.keys()].flatMap((key) => key.split('/')));
+    const known = new Set([...slots.values()].flat());
     return {
         data: valueOf(root) ?? {},
-        ids: (path) => idsAt(root, path).map((id) => (known.has(`${id}#`) ? id : ''))
+        ids: (path) => idsAt(root, path).map((id) => (known.has(id) ? id : ''))
     };
 };
 /** `data` with `patches` applied in order, as a fresh value (a root patch replaces it); `null` when one fits no value. */
 export const applyPatch = (data, patches) => {
-    const root = treeOf(dataLeaves(data));
+    const root = tree();
+    derived.assign(root, data);
     if (!patches.every((p) => derived.apply(root, p)))
         return null;
     return valueOf(root) ?? {};
 };
 /**
- * The attr writes that give `node` the data `patches` make of its own (new
- * items get ids from `rand`, ranks from `client`), or `null` when a patch
- * fits no value there: only the leaves of the keys and items a patch
- * touches change, so a concurrent edit of another key or item is kept. An
- * atomic path is written as one leaf and the leaves under it are deleted.
- * An unchanged value writes nothing.
+ * The writes that give `node` the data `patches` make of its own (new
+ * items get ids from `rand`), or `null` when a patch fits no value there:
+ * only the leaves of the keys and items a patch touches change, so a
+ * concurrent edit of another key or item is kept, and only the slots of
+ * the items it makes, moves or removes. An atomic path is written as one
+ * leaf and the leaves and slots under it are dropped. An unchanged value
+ * writes nothing.
  */
 export const patchWrites = (node, patches, client = 0, rand, atomic = []) => {
     const now = leavesOf(node);
-    const root = treeOf(now);
+    const { slots } = slotsOf(node);
+    const root = treeOf(now, slots);
     const before = valueOf(root);
-    const { apply } = edits(rand, client);
+    const seq = [];
+    const { apply } = edits(rand, client, seq);
     if (!patches.every((p) => apply(root, p)))
         return null;
     if (jsonEquals(before, valueOf(root)))
         return [];
-    const want = collapse(leavesFrom(root), atomic);
-    return [...new Set([...now.keys(), ...want.keys()])]
+    const want = collapse(root, atomic);
+    const leaves = [...new Set([...now.keys(), ...want.keys()])]
         .filter((key) => !jsonEquals(now.get(key), want.get(key)))
         .map((key) => [key, want.get(key)]);
+    return [...leaves, ...seq.filter((w) => !underAtomic(w.path, atomic))];
 };
-/** Write `writes` on `node` (a detached one too: a block or atom being created). */
-export const writeLeaves = (node, writes) => {
-    for (const [key, value] of writes)
-        if (value === undefined)
-            node.deleteAttr(key);
-        else
-            node.setAttr(key, value);
+/**
+ * Write `writes` on `node`: its attrs, and its arrays' slots in its one
+ * sequence (`placement/slots.ts`). On a detached node (a block or atom being
+ * created) the slots are appended in order; on an integrated one each write
+ * goes after the item it names, read from the sequence as it stands.
+ */
+export const writeData = (node, writes) => {
+    let appended = 0;
+    for (const w of writes) {
+        if (Array.isArray(w)) {
+            const [key, value] = w;
+            if (value === undefined)
+                node.deleteAttr(key);
+            else
+                node.setAttr(key, value);
+            continue;
+        }
+        const { seq, path, ids } = w;
+        const payloads = ids.map((i) => ({ p: path, i }));
+        if (node.doc == null) {
+            // A new node: its items in order, none to move or remove yet.
+            if (seq === 'insert') {
+                node.insert(appended, payloads);
+                appended += payloads.length;
+            }
+            continue;
+        }
+        const doc = asEngineDoc(node.doc);
+        const { slots, entries } = slotsOf(node);
+        /** Every displayed slot of item `id` of the array (two peers may have written one). */
+        const of = (id) => entries.get(`${path}\u0000${id}`) ?? [];
+        if (seq === 'remove') {
+            for (const id of ids)
+                for (const e of of(id))
+                    removeUnit(doc, e.unit);
+            continue;
+        }
+        // After the item named; at the array's start: before its first item.
+        const { after } = w;
+        placeAfter(doc, node, after === null ? null : (of(after)[0] ?? null), after === null ? (of(slots.get(path)?.[0])[0] ?? null) : null, seq === 'insert' ? payloads : null, seq === 'move'
+            ? triples(ids.flatMap((id) => of(id)
+                .slice(0, 1)
+                .map((e) => e.unit)))
+            : null);
+    }
 };

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

@@ -2,7 +2,7 @@
  * Block deletion (`del.blocks.promote`): only the members leave, the
  * unselected children of a deleted block take its slot.
  */
-import { type BlockId } from '../placement/model.js';
+import type { BlockId } from '../placement/model.js';
 import type { Prepared } from './types.js';
 import type { OpsContext } from './steps.js';
 /** The delete ops of one facade, prepared. */

package/dist/crdt/doc/delete.js

@@ -1,12 +1,7 @@
-/**
- * Block deletion (`del.blocks.promote`): only the members leave, the
- * unselected children of a deleted block take its slot.
- */
-import { promotedRank } from '../placement/model.js';
 import { ref } from './plan.js';
 /** The delete ops of one facade, prepared. */
 export const deleteOps = (c) => {
-    const { view, blockTypeOf, childrenIds, positionOf, ancestorsOf, itemKindOf, isLayout, isLayoutItem, isTable, isTableRow, live, REFUSED, plan, moveTo, settle, emptyingAll, emptied, deleting, remove } = c;
+    const { view, blockTypeOf, childrenIds, positionOf, ancestorsOf, itemKindOf, isLayout, isLayoutItem, isTable, isTableRow, live, REFUSED, plan, settle, emptyingAll, emptied, deleting, remove } = c;
     /**
      * Delete a set of blocks (`del.blocks.promote`): this writer's mark on
      * every member and on what it displays through merge claims (wins over
@@ -52,41 +47,29 @@ export const deleteOps = (c) => {
             const pos = positionOf(root);
             const chunk = [];
             const kept = [];
-            // Each kept child moves to the rank read-time promotion gives it
-            // (`promotedRank`), so a block a peer puts under a member meanwhile
-            // takes the slot in the member's order among them. Right after the
-            // root: a flow placed in the root's slot precedes them.
-            const walk = (b, slotRank) => {
+            // The kept children keep their home slots: the read shows them in the
+            // root's slot, in its order (a block a peer puts under a member
+            // meanwhile takes the slot in that order too); only their kinds are
+            // written, as the slot's parent settles them.
+            const walk = (b) => {
                 chunk.push(b);
                 for (const kid of kids.get(b) ?? []) {
-                    const rank = promotedRank(slotRank, kid.rank);
                     if (set.has(kid.id))
-                        walk(kid.id, rank);
+                        walk(kid.id);
                     else
-                        kept.push({ id: kid.id, from: b, rank });
+                        kept.push({ id: kid.id, from: b });
                 }
             };
-            walk(root, kids.get(pos.parent)[pos.index].rank);
+            walk(root);
             members.push(...chunk);
             if (kept.length > 0)
                 promoting.add(root);
-            // A layout shows only its items: a deleted item's blocks land right
-            // after it, where read-time promotion shows them (`layout.only-items`).
+            // A layout shows only its items: a deleted item's blocks show right
+            // after the layout (`layout.only-items`), settled for its parent.
             const item = pos.parent === null ? undefined : itemKindOf(pos.parent);
-            const at = (k) => item !== undefined && blockTypeOf(k.id) !== item;
-            const out = kept.filter(at);
-            const inside = kept.filter((k) => !at(k));
-            const lpos = out.length > 0 ? positionOf(pos.parent) : null;
-            const lrank = lpos && kids.get(lpos.parent)[lpos.index].rank;
+            const out = (k) => item !== undefined && blockTypeOf(k.id) !== item;
             return [
-                ...moveTo(inside.map((k) => k.id), pos.parent, pos.index + 1, inside.map((k) => k.rank)),
-                ...inside.flatMap((k) => settle(k.from, [k.id], pos.parent)),
-                ...(lpos === null
-                    ? []
-                    : [
-                        ...moveTo(out.map((k) => k.id), lpos.parent, lpos.index + 1, out.map((k) => promotedRank(lrank, k.rank))),
-                        ...out.flatMap((k) => settle(k.from, [k.id], lpos.parent))
-                    ]),
+                ...kept.flatMap((k) => settle(k.from, [k.id], out(k) ? positionOf(pos.parent).parent : pos.parent)),
                 deleting(root, chunk)
             ];
         });

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

@@ -2,13 +2,14 @@ import type { BlockAttributionApi } from '../attribution/block.js';
 import type { EdytorDocConfig, OpResult, Prepared } from './types.js';
 import type { DocBase, DocReads } from './reads.js';
 /**
- * Raised when a mutating facade op runs after `dispose()` — disposal is
- * terminal for writes (reads stay dead-safe: a stale handle may still be
- * inspected while its document outlives the facade). The facade-level
- * counterpart of `DocumentDestroyedError` — kept in this module because a
- * bare `bindEdytorDoc` facade has no document layer above it.
+ * Raised when an operation runs against a torn-down document: every attach
+ * reference released, or its facade disposed (terminal for writes; reads
+ * stay dead-safe: a stale handle may still be inspected). Distinct from
+ * `DocumentNotReadyError`: destroyed is terminal, pending may still resolve.
+ * Kept in this module because a bare `bindEdytorDoc` facade has no document
+ * layer above it.
  */
-export declare class EdytorDocDisposedError extends Error {
+export declare class DocumentDestroyedError extends Error {
     constructor(service?: string);
 }
 /** What the write funnel writes with: the reads, the attribution writer and the facade's configuration. */