edytor 3.0.0 → 4.0.0

package/dist/crdt/doc/funnel.js

@@ -1,13 +1,7 @@
-/**
- * The write funnel: every facade write goes through `write` (disposal and the
- * document's writable guard), and every prepared plan through `apply` — one
- * transaction, its result read from what the transaction wrote, and the
- * frame's one attribution pass.
- */
-import { blockNodeOf, buildInline, materializeSpec, ownText, view as modelView, writePlacement, writeSplit } from '../placement/model.js';
-import { ENTRY_FACET } from '../text/runs.js';
-import { AT, DEL_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
-import { writeLeaves } from '../data.js';
+import { blockNodeOf, buildInline, insertSpecsAt, moveBlocksTo, ownText, view as modelView, writeSplit } from '../placement/model.js';
+import { ENTRY_FACET, SEQ_FACET } from '../text/runs.js';
+import { DEL_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
+import { writeData } from '../data.js';
 import { NOOP } from './plan.js';
 import { claimInto, deleteRange, formatRangeIn, insertIntoText } from '../text/model.js';
 /**
@@ -55,8 +49,8 @@ export const writeFunnel = (c) => {
     // Each apply opens a frame that tracks the index's folds. When it
     // closes, ONE pass over the facets the fold saw stamps attribution: a
     // block whose registry entry was created gets its `createdBy` record; a block whose content, claims, type or data
-    // changed gets a contributor stamp; moves and delete marks stamp
-    // nothing. Two intents the effects cannot name are recorded by their
+    // changed gets a contributor stamp; moves (a record or a slot in a
+    // block's sequence) and delete marks stamp nothing. Two intents the effects cannot name are recorded by their
     // steps: a split-born block inherits its source's contributors, and a
     // merge survivor unions the absorbed block's. With no configured
     // `actor` the funnel writes no attribution at all.
@@ -74,9 +68,12 @@ export const writeFunnel = (c) => {
             else
                 for (const facet of facets)
                     if (!facet.startsWith(DEL_PREFIX) &&
-                        ![ENTRY_FACET, AT, ID, LAST_CHANGED_ATTR].includes(facet))
+                        ![ENTRY_FACET, SEQ_FACET, ID, LAST_CHANGED_ATTR].includes(facet))
                         changed.add(id);
         }
+        // A merge changed its survivor (its claim item, written quietly, is no edit of the text holding it).
+        for (const [into] of f.unions)
+            changed.add(into);
         for (const id of created) {
             const node = blockNodeOf(doc, id);
             if (node !== null)
@@ -93,38 +90,46 @@ export const writeFunnel = (c) => {
     /**
      * A streamless block gets its own text before the first write that
      * needs a stream (`ownText`: a writer derived from its dead
-     * incarnation); its attribution record follows the re-minted nonce.
+     * incarnation); its attribution record follows the re-minted nonce. A
+     * claim item needs the block's own stream (`claim`); text, any piece of
+     * its display.
      */
-    const needStream = (id) => {
-        if ((modelView(doc).own.display(id) ?? []).length > 0)
+    const needStream = (id, claim = false) => {
+        const { own } = modelView(doc);
+        if (claim ? own.streamOf(id) !== undefined : (own.display(id) ?? []).length > 0)
             return;
         const { from, to } = ownText(doc, id);
         BA.retarget(doc, id, from, to);
     };
     /** One planned step, written (the plan decided it; writers never refuse). */
     const writeStep = (w, f) => {
-        // Structural steps need no view: delete marks and placements write one node.
+        // Delete marks need no view: they write one node.
         if (w.op === 'deleteBlock')
             return w.marks.forEach((id) => blockNodeOf(doc, id).setAttr(DEL_PREFIX + doc.clientID, true));
         if (w.op === 'splitBlock' || w.op === 'insertText' || w.op === 'insertInline')
             needStream(w.id);
-        const { blocks, own } = modelView(doc);
+        // A claim item goes at the end of the stream of the block merged into.
+        if (w.op === 'mergeBlocks')
+            needStream(w.into, true);
+        const v = modelView(doc);
+        const { blocks, own } = v;
         const node = (id) => blockNodeOf(doc, id);
         switch (w.op) {
             case 'insertBlocks':
-                return w.specs.forEach((sp, i) => materializeSpec(doc, sp, w.parent, w.ranks[i]));
+                return insertSpecsAt(doc, v, w.parent, w.index, w.specs, w.split === undefined ? null : (f.bounds.get(w.split) ?? null));
             case 'moveBlocks':
-                return w.ids.forEach((id, i) => writePlacement(doc, node(id), w.parent, w.ranks[i]));
+                return moveBlocksTo(doc, v, w.ids, w.parent, w.index, w.side ?? 0, w.part ?? 0, w.at ?? null);
             case 'splitBlock':
                 f.inherit.set(w.newId, w.id);
-                return writeSplit(doc, w.id, w.offset, w.newId, w.tail, { p: w.parent, r: w.rank });
+                f.bounds.set(w.newId, writeSplit(doc, w.id, w.offset, w.newId, w.tail, w.parent, w.index));
+                return;
             case 'mergeBlocks':
                 f.unions.push([w.into, w.from]);
-                return claimInto(blocks, own, w.from, w.into);
+                return f.quiet(() => claimInto(own, w.from, w.into));
             case 'setBlockType':
                 return void node(w.id).setAttr(TYPE, w.type);
             case 'patchData':
-                return writeLeaves(dataNode(w.id, w.inlineId), w.leaves);
+                return writeData(dataNode(w.id, w.inlineId), w.writes);
             case 'insertText':
                 return insertIntoText(doc, blocks, own, w.id, w.offset, w.text, w.marks);
             case 'insertInline':
@@ -150,7 +155,7 @@ export const writeFunnel = (c) => {
         }
         return write(() => doc.transact(() => {
             const frame = runsView.track();
-            const f = { inherit: new Map(), unions: [] };
+            const f = { inherit: new Map(), bounds: new Map(), unions: [], quiet: frame.quiet };
             try {
                 for (const w of p.writes)
                     writeStep(w, f);

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

@@ -17,15 +17,15 @@
  *
  * ```
  * doc.get('blocks')                      registry — flat map, blockId → node('block')
- *   └ <blockId>                           id/n/type/data/del + content/claims/at
- *                                         (n: incarnation nonce)
+ *   └ <blockId>                           n/type/d/…/del./wd./l + content
+ *                                         (n: incarnation nonce; the id is the key)
  * doc.get('meta')                        version record root
  *   ├ v : number                          SCHEMA_VERSION (LWW attr — concurrent init converges)
  *   └ schema : 'edytor-doc'               SCHEMA_NAME
  * ```
  */
 import type { EngineDoc } from '../engine-api.js';
-export declare const SCHEMA_VERSION: 6;
+export declare const SCHEMA_VERSION: 10;
 export declare const SCHEMA_NAME: "edytor-doc";
 export declare const META_KEY: "meta";
 /**

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

@@ -1,5 +1,4 @@
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
-import type { TextDeletes } from '../text/deletes.js';
 import { type IdSetOf, type StoreStruct } from '../structs.js';
 import { type WriteFunnel } from './funnel.js';
 import type { DocBase } from './reads.js';
@@ -33,15 +32,12 @@ export type HistoryOptions = {
     }) => boolean;
 };
 /** What a history is made over: the document and the rules of its replay. */
-type Rules = {
+export type Rules = {
     Y: EngineApi;
     doc: EngineDoc;
     scope: EngineNode[];
-    /** The text delete marks' restore and apply rules (`text/deletes.ts`). */
-    marks: {
-        restoreFilter(item: unknown): boolean;
-        onApply(tr: unknown, step: StackItem): void;
-    };
+    /** The records list a replay's text holds go to (fork patch YP20). */
+    records: EngineNode;
     /** Whether an item a replay would delete is withdrawn instead (`hist.undo.withdraw`). */
     withdraw(item: StoreStruct, step: StackItem): boolean;
     /** Repair the attrs a replay left undefined. */
@@ -85,16 +81,36 @@ export declare class UndoManager {
     redo(): StackItem | null;
     /** Drop every step (undo and redo) and release what they kept for their replay. */
     clear(): void;
+    /**
+     * The session ends: its page left for good (`hist.release.end`). Every
+     * step is dropped and released as a dropped step is (`#release`: what
+     * they kept is collected, the text this writer's records hold is
+     * deleted for good), in one transaction that, when a step marked a block
+     * deleted or withdrawn, also appends one release record (the
+     * {@link RELEASE_ROOT} list): its id names this writer and the clock the
+     * history ended at, so the room's purge removes what those marks hide at
+     * its next tick, past the horizon or not. Then the manager stops
+     * capturing (it is destroyed; the document attaches a fresh one if asked).
+     * A history that captured nothing writes nothing. Only for a page that
+     * cannot come back: a page the back/forward cache keeps, or one that
+     * only lost its connection, keeps its history.
+     */
+    end(): void;
     destroy: () => void;
 }
 /** What a facade's history is made over: its doc, the write funnel and the bound engine layers. */
 export type HistoryContext = DocBase & Pick<WriteFunnel, 'write' | 'disposed'> & {
-    D: TextDeletes;
     /** Stamp the version record before the history attaches. */
     init: (doc: EngineDoc) => void;
 };
+/**
+ * The document's history rules over `doc` (the one set every history of an
+ * edytor document runs): its scope (the block registry, the text hold
+ * records, the document's data), the records a replay's text holds go to,
+ * the withdraw rule (`hist.undo.withdraw`) and the attr repair below.
+ */
+export declare const historyRules: (Y: EngineApi, doc: EngineDoc) => Rules;
 /** The history factory of one facade. */
 export declare const docHistory: (c: HistoryContext) => {
     createUndoManager: (options?: HistoryOptions) => UndoManager;
 };
-export {};

package/dist/crdt/doc/history.js

@@ -1,18 +1,21 @@
 /**
  * The document's history: the one undo manager (fork patch YP18 removed the
  * engine's). It captures the tracked local transactions that write in its
- * scope (the block registry, the text delete marks, the document's data)
+ * scope (the block registry, the text hold records, the document's data)
  * into steps, and an undo or a redo replays a step in one transaction over
- * the engine's struct primitives (`redoItem`, `keepItem`). Its rules: text
- * comes back as the delete marks allow (`hist.undo.restore`), an undone
+ * the engine's struct primitives (`redoItem`, `keepItem`). Its rules: a text
+ * delete is a hold record (fork patch YP20), so undoing it deletes the record
+ * and the text shows again unless another writer's record holds it
+ * (`hist.undo.restore`); undoing typing holds the typed text; an undone
  * creation is withdrawn (`hist.undo.withdraw`), an overwritten attr is
- * repaired, the stack keeps `limit` steps, and the purge horizon drops the
- * steps below it (`hist.purge.horizon`).
+ * repaired, the stack keeps `limit` steps, the purge horizon drops the
+ * steps below it (`hist.purge.horizon`), and a session's end releases them
+ * all (`hist.release.end`).
  */
 import { getUnixTime } from 'lib0-v14/time';
-import { ownTextIds } from '../text/model.js';
+import { openSteps, ownTextIds } from '../text/model.js';
 import { readHorizon } from '../purge.js';
-import { BLOCK_NODE, DATA_LEAF_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
+import { BLOCK_NODE, CONTENT_NODE, DATA_LEAF_PREFIX, DEL_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, RELEASE_ROOT, TEXT_DELETES_ROOT, TYPE, WITHDRAW_PREFIX } from '../schema.js';
 import { changedUnder, collectable, collectNow, collects, dropSearchMarkers, engineOps, walkIdSet } from '../structs.js';
 import { isInitialized } from './gate.js';
 import { DocumentDestroyedError } from './funnel.js';
@@ -37,6 +40,13 @@ const REPAIRED = {
     [BLOCK_NODE]: [TYPE, LAST_CHANGED_ATTR],
     [INLINE_NODE]: [TYPE]
 };
+/** A unit of a block's text: a character or an inline atom (what a hold record holds). */
+const isUnit = (it) => {
+    const content = it.content;
+    return (it.parentSub === null &&
+        it.parent?.name === CONTENT_NODE &&
+        (typeof content?.str === 'string' || content?.type?.name === INLINE_NODE));
+};
 /**
  * A document's undo manager: the undo and redo stacks of the tracked local
  * transactions in its scope. `undo()`/`redo()` replay the top step and
@@ -64,6 +74,10 @@ export class UndoManager {
     /** What dropped steps released (an item is released once every step that deleted it is gone). */
     #released;
     #horizon;
+    /** A captured step wrote a block's delete or withdraw mark: the session's end records its release. */
+    #marked = false;
+    /** The session ended (`end()`): nothing more is released. */
+    #ended = false;
     constructor(rules, options = {}) {
         this.#rules = rules;
         this.#ops = engineOps(rules.Y);
@@ -78,7 +92,19 @@ export class UndoManager {
         this.trackedOrigins.add(this);
         this.#ops.on(rules.doc, 'afterTransaction', this.#afterTransaction);
         this.#ops.on(rules.doc, 'destroy', this.destroy);
+        const open = openSteps.get(rules.doc) ?? new Set();
+        openSteps.set(rules.doc, open.add(this.#open));
     }
+    /** What the step still capturing inserted (`null`: none is open): a text delete there removes. */
+    #open = () => {
+        const top = this.undoStack.at(-1);
+        const open = top !== undefined &&
+            !this.undoing &&
+            !this.redoing &&
+            this.lastChange > 0 &&
+            getUnixTime() - this.lastChange < this.captureTimeout;
+        return open ? top.inserts : null;
+    };
     /** Be told of every step taken into a stack (added, or the open one updated). Returns the unsubscribe. */
     observe(f) {
         this.#observers.add(f);
@@ -118,8 +144,39 @@ export class UndoManager {
     clear() {
         this.#release([...this.undoStack.splice(0), ...this.redoStack.splice(0)]);
     }
+    /**
+     * The session ends: its page left for good (`hist.release.end`). Every
+     * step is dropped and released as a dropped step is (`#release`: what
+     * they kept is collected, the text this writer's records hold is
+     * deleted for good), in one transaction that, when a step marked a block
+     * deleted or withdrawn, also appends one release record (the
+     * {@link RELEASE_ROOT} list): its id names this writer and the clock the
+     * history ended at, so the room's purge removes what those marks hide at
+     * its next tick, past the horizon or not. Then the manager stops
+     * capturing (it is destroyed; the document attaches a fresh one if asked).
+     * A history that captured nothing writes nothing. Only for a page that
+     * cannot come back: a page the back/forward cache keeps, or one that
+     * only lost its connection, keeps its history.
+     */
+    end() {
+        if (this.#ended)
+            return;
+        this.#ended = true;
+        const dropped = [...this.undoStack.splice(0), ...this.redoStack.splice(0)];
+        const marked = this.#marked;
+        if (dropped.length > 0 || marked)
+            this.doc.transact(() => {
+                this.#release(dropped);
+                if (marked) {
+                    const records = this.doc.get(RELEASE_ROOT);
+                    records.insert(records.length, [true]);
+                }
+            }, HISTORY_TRIM);
+        this.destroy();
+    }
     destroy = () => {
         this.trackedOrigins.delete(this);
+        openSteps.get(this.doc)?.delete(this.#open);
         this.#ops.off(this.doc, 'afterTransaction', this.#afterTransaction);
         this.#ops.off(this.doc, 'destroy', this.destroy);
         this.#observers.clear();
@@ -164,6 +221,14 @@ export class UndoManager {
             stack.push(new StackItem(tr.insertSet, tr.deleteSet));
         if (!undoing && !redoing)
             this.lastChange = now;
+        // A block's delete or withdraw mark: what it hides waits for this
+        // history (its end releases it to the purge, `end()`).
+        if (!this.#marked)
+            for (const keys of tr.changed.values())
+                for (const key of keys)
+                    if (typeof key === 'string' &&
+                        (key.startsWith(DEL_PREFIX) || key.startsWith(WITHDRAW_PREFIX)))
+                        this.#marked = true;
         // What the step deleted is kept from collection while a step may bring it back.
         ops.iterate(tr, tr.deleteSet, (item) => {
             if (ops.isItem(item) && this.#inScope(item))
@@ -190,13 +255,14 @@ export class UndoManager {
     }
     /**
      * Replay the top step of `stack` in one transaction (origin: this
-     * manager): what it inserted is deleted (or withdrawn), what it deleted
-     * comes back (text as its delete marks allow), the overwritten attrs are
+     * manager): what it inserted is deleted (text: held by a record of this
+     * writer; a block: withdrawn), what it deleted comes back (a text delete
+     * was a record: deleting it shows the text), the overwritten attrs are
      * repaired. A step that changes nothing is skipped for the one below.
      */
     #pop(stack) {
         const ops = this.#ops;
-        const { marks, withdraw, repair } = this.#rules;
+        const { records, withdraw, repair } = this.#rules;
         const deletedByHistory = (id) => [this.undoStack, this.redoStack].some((s) => s.some((step) => step.deletes.has(id.client, id.clock)));
         this.doc.transact((transaction) => {
             const tr = transaction;
@@ -204,11 +270,18 @@ export class UndoManager {
                 const step = stack.pop();
                 const restore = new Set();
                 const remove = [];
+                const held = [];
                 let changed = false;
                 ops.iterate(tr, step.inserts, (struct) => {
                     if (!ops.isItem(struct))
                         return;
                     const item = ops.latest(tr, struct);
+                    // An atom the step inserted is held whole: its attrs stay with it.
+                    const atom = item.parent?._item;
+                    if (atom?.id &&
+                        isUnit(atom) &&
+                        step.inserts.has(atom.id.client, atom.id.clock))
+                        return;
                     if (!item.deleted && this.#inScope(item))
                         remove.push(item);
                 });
@@ -218,25 +291,27 @@ export class UndoManager {
                     // Created and deleted within the step: nothing to bring back.
                     if (step.inserts.has(struct.id.client, struct.id.clock))
                         return;
-                    // Text comes back through the delete marks (`onApply`): withheld here.
-                    if (!marks.restoreFilter(struct))
-                        changed = true;
-                    else
-                        restore.add(struct);
+                    // Text a record holds stays hidden: the record decides (removed with its node).
+                    if ((struct.holds ?? 0) > 0)
+                        return;
+                    restore.add(struct);
                 });
                 for (const item of restore)
                     changed = ops.redo(tr, item, restore, step.inserts, deletedByHistory) !== null || changed;
                 // Children before parents: more is known when an item is judged.
                 for (let i = remove.length - 1; i >= 0; i--) {
-                    if (!withdraw(remove[i], step))
-                        ops.remove(tr, remove[i]);
+                    const item = remove[i];
+                    // Text the step wrote is held, never removed: a redo shows it again where it was.
+                    if (isUnit(item))
+                        held.push(item.id.client, item.id.clock, item.length);
+                    else if (!withdraw(item, step))
+                        ops.remove(tr, item);
                     changed = true;
                 }
+                records.hold(held);
                 this.currStackItem = changed ? step : null;
-                if (changed) {
-                    marks.onApply(tr, step);
+                if (changed)
                     repair(step);
-                }
             }
             tr.changed.forEach((keys, node) => {
                 if (keys.has(null))
@@ -250,8 +325,8 @@ export class UndoManager {
     /**
      * Release what dropped steps kept for their replay: the engine collects
      * that content now, as it would have at the delete without a history
-     * (the doc's `gcFilter` still decides: a text copy another replica may
-     * have to copy again stays, `text/deletes.ts`). An item is released only
+     * (the doc's `gcFilter` still decides), and the text their hold records
+     * hold is deleted for good. An item is released only
      * once every step that deleted part of it was dropped (the engine merges
      * deleted items across steps): never split, so the store keeps its
      * merged items. Only the items themselves are released: a kept
@@ -269,6 +344,8 @@ export class UndoManager {
             return (released.clients.get(st.id.client)?.getIds() ?? []).some((r) => r.clock <= st.id.clock && end <= r.clock + r.len);
         };
         const gc = collects(doc);
+        const ops = this.#ops;
+        const { records } = this.#rules;
         doc.transact((tr) => {
             for (const step of dropped)
                 walkIdSet(Y, doc, step.deletes, (st) => {
@@ -279,6 +356,32 @@ export class UndoManager {
                     if (gc && it.deleted && collectable(doc, it))
                         collectNow(it, tr);
                 });
+            // A dropped step's text deletes can never be undone here: what this
+            // writer's live records hold is deleted for good, as the purge does,
+            // and the engine collects it (`hist.delete-marks.release`). A record
+            // a captured remote frame wrote (the room's validation) is its
+            // writer's to take back.
+            const own = ops.idSet();
+            for (const step of dropped)
+                walkIdSet(Y, doc, step.inserts, (st, from, to) => {
+                    if (st.parent === records && !st.deleted && st.id.client === doc.clientID)
+                        own.add(st.id.client, from, to - from);
+                });
+            const held = ops.idSet();
+            ops.iterate(tr, own, (st) => {
+                const ids = st.content?.ids;
+                if (st.deleted || ids === undefined)
+                    return;
+                for (let i = 0; i < ids.length; i += 3)
+                    held.add(ids[i], ids[i + 1], ids[i + 2]);
+                ops.remove(tr, st);
+            });
+            ops.iterate(tr, held, (it) => {
+                if (it.removed !== false)
+                    return;
+                ops.remove(tr, it);
+                dropSearchMarkers(it.parent);
+            });
         }, HISTORY_TRIM);
     }
     /**
@@ -310,9 +413,13 @@ export class UndoManager {
         this.#release(dropped);
     }
 }
-/** The history factory of one facade. */
-export const docHistory = (c) => {
-    const { Y, doc, D, init, write, disposed } = c;
+/**
+ * The document's history rules over `doc` (the one set every history of an
+ * edytor document runs): its scope (the block registry, the text hold
+ * records, the document's data), the records a replay's text holds go to,
+ * the withdraw rule (`hist.undo.withdraw`) and the attr repair below.
+ */
+export const historyRules = (Y, doc) => {
     /**
      * Undo repair, inside the replay's transaction. A replayed step
      * deletes its own attr write and re-creates the value that write
@@ -350,9 +457,25 @@ export const docHistory = (c) => {
                     node.setAttr(key, value);
         }
     };
+    // The text hold records are in scope (an undo deletes the undoer's
+    // own, fork patch YP20). An undone creation withdraws the block instead
+    // of deleting it (`hist.undo.withdraw`).
+    const records = doc.get(TEXT_DELETES_ROOT);
+    return {
+        Y,
+        doc,
+        scope: [registryOf(doc), records, doc.get(DOC_DATA_ROOT)],
+        records,
+        withdraw: withdrawOnUndo(doc),
+        repair: repairAttrs
+    };
+};
+/** The history factory of one facade. */
+export const docHistory = (c) => {
+    const { Y, doc, init, write, disposed } = c;
     /**
      * The document's undo manager, SCOPED TO THE BLOCK REGISTRY (with the
-     * text delete marks and the document's data), attached only after the
+     * text hold records and the document's data), attached only after the
      * doc carries the schema version record:
      *
      * - the `meta` root (version stamp, schema name) is outside the scope,
@@ -373,20 +496,7 @@ export const docHistory = (c) => {
             if (!isInitialized(doc))
                 init(doc);
         });
-        // Text delete marks (`text/deletes.ts`): the marks are in scope (an undo
-        // removes the undoer's own), and the history restores text only as the
-        // marks allow. An undone creation withdraws the block instead of
-        // deleting it (`hist.undo.withdraw`).
-        const marks = D.history(doc, () => um);
-        const um = new UndoManager({
-            Y,
-            doc,
-            scope: [registryOf(doc), D.scope(doc), doc.get(DOC_DATA_ROOT)],
-            marks,
-            withdraw: withdrawOnUndo(doc),
-            repair: repairAttrs
-        }, options);
-        return um;
+        return new UndoManager(historyRules(Y, doc), options);
     };
     return { createUndoManager };
 };

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,