edytor 3.0.0 → 5.0.0

package/dist/crdt/edytor-doc.js

@@ -48,10 +48,10 @@
  */
 import { setMarkEdges } from './text/marks.js';
 import { keepingReplaced } from './incarnations.js';
+import { clientsOf } from './structs.js';
 import { SCHEMA } from './schema.js';
 import { bindModel, blockText, crdtId, listBlockIds, project, resolveBlock } from './placement/model.js';
 import { bindText } from './text/model.js';
-import { bindDeletes } from './text/deletes.js';
 import { bindPurge, readHorizon } from './purge.js';
 import { restoreDocument } from './restore.js';
 import { bindRuns, indexOf } from './text/runs.js';
@@ -84,15 +84,29 @@ export { DEFAULT_HISTORY_LIMIT } from './doc/history.js';
  * The per-doc facade factory over the engine `Y` (the editor's documents
  * use it directly; {@link bindDocModel} is the public binding around it).
  */
+/**
+ * Give `doc` edytor's rule — a registry value a concurrent creation replaced
+ * keeps its subtree (fork patch YP14, `keepingReplaced`) — or refuse it
+ * loudly when it has integrated updates without it: the engine decides what
+ * a replaced value keeps when it integrates, so a document that took updates
+ * under the engine's default could lose a subtree its peers keep, forever.
+ * Create it with `createDoc()` (or `createDocument`/`loadDocument`), never
+ * `new Y.Doc()`.
+ */
+export const adoptRules = (doc) => {
+    const d = doc;
+    if (d.keepReplaced == null && clientsOf(doc).size > 0)
+        throw new TypeError("edytor: this document took updates before it carried edytor's rules (create it with createDoc(), createDocument or loadDocument, not new Y.Doc())");
+    return keepingReplaced(d);
+};
 export const docFacade = (Y, layers) => {
-    const D = bindDeletes(Y);
     // Compact per-block attribution writes (`attribution/block.ts`).
     // One bound instance per engine binding; its suppression memory is
     // per-doc (WeakMap-keyed), so facades on the same doc share it.
     const BA = bindBlockAttribution(Y);
     const { init, seed } = bindSeed(Y, BA);
-    return (doc, config = {}) => {
-        keepingReplaced(doc);
+    const create = (doc, config = {}) => {
+        adoptRules(doc);
         setMarkEdges(doc, config.markEdge ?? (() => undefined));
         const roleOf = config.roleOf ?? (() => undefined);
         const defaultType = config.defaultType ?? 'paragraph';
@@ -109,21 +123,42 @@ export const docFacade = (Y, layers) => {
         // A layout displays only its items — its
         // `defaultChild` kind — and only two or more (`layout.*`). A table
         // displays only its rows and a row only its cells (`table.*`).
+        let kinds = new Map();
+        let declared;
         const roles = {
-            childless: (type) => roleOf(type)?.void === true,
-            island: (type) => roleOf(type)?.island === true,
-            container: (type) => !rendersContentOf(type) && roleOf(type)?.void !== true && roleOf(type)?.island !== true,
-            rendersContent: (type) => rendersContentOf(type),
-            defaultChild: (type) => (type !== null ? defaultChildOf(type) : undefined) ?? defaultType,
-            line: (type) => {
-                const role = roleOf(type);
-                return role?.island === true && role.lines === true ? defaultChildOf(type) : undefined;
+            of: (type) => {
+                let k = kinds.get(type);
+                if (k === undefined) {
+                    const role = type === null ? undefined : roleOf(type);
+                    const own = type === null ? undefined : defaultChildOf(type);
+                    const renders = type === null || rendersContentOf(type);
+                    kinds.set(type, (k = {
+                        childless: role?.void === true,
+                        island: role?.island === true,
+                        container: !renders && role?.void !== true && role?.island !== true,
+                        rendersContent: renders,
+                        child: own ?? defaultType,
+                        line: role?.island === true && role.lines === true ? own : undefined,
+                        layout: role?.layout === true ? own : undefined,
+                        table: role?.table === true ? own : undefined
+                    }));
+                }
+                return k;
             },
-            lineKinds: () => [...(config.kinds?.() ?? [])].flatMap((type) => roles.line(type) ?? []),
-            layout: (type) => (roleOf(type)?.layout === true ? defaultChildOf(type) : undefined),
-            layoutKinds: () => [...(config.kinds?.() ?? [])].filter((type) => roles.layout(type) !== undefined),
-            table: (type) => (roleOf(type)?.table === true ? defaultChildOf(type) : undefined),
-            tableKinds: () => [...(config.kinds?.() ?? [])].filter((type) => roles.table(type) !== undefined)
+            declared: () => {
+                if (declared === undefined) {
+                    const all = [...(config.kinds?.() ?? [])].map(roles.of);
+                    const rows = new Map(all.flatMap((k) => (k.table ? [[k.table, roles.of(k.table).child]] : [])));
+                    declared = {
+                        lines: new Set(all.flatMap((k) => k.line ?? [])),
+                        layouts: [...(config.kinds?.() ?? [])].filter((t) => roles.of(t).layout !== undefined),
+                        items: new Set(all.flatMap((k) => k.layout ?? [])),
+                        rows,
+                        cells: new Set(rows.values())
+                    };
+                }
+                return declared;
+            }
         };
         if (config.roleOf)
             runsView.roles(roles);
@@ -141,56 +176,55 @@ export const docFacade = (Y, layers) => {
             funnel.dispose();
             events.close();
         };
-        const { createUndoManager } = docHistory({ ...base, ...funnel, D, init });
+        const { createUndoManager } = docHistory({ ...base, ...funnel, init });
         const { anchorAt, followUndo, resolveAnchor } = docAnchors(reads);
         const steps = { ...shape, ...planSteps(shape) };
         const { plan } = steps;
-        // The prepared op families (`OpsContext`: the reads, capability and step writers).
-        const { insertBlocks, moveBlocks, unNestBlocks, unNestBlock, landingOf, liftOut, duplicateBlock } = moveOps(steps);
-        const { besideAt, placeBeside, wrapInLayout } = layoutOps(steps);
-        const { splitBlock, mergeBlocks, mergeBackward, mergeForward } = splitMergeOps(steps);
-        const { deleteBlocks, deleteBlock } = deleteOps(steps);
-        const { dataSteps, replaceData, setBlockType, patchData, setBlock } = metaOps(steps);
-        const { insertText, deleteText, formatRange, clearMarks, insertInline, removeInline } = contentOps(steps);
+        // The prepared op families (`OpsContext`: the reads, capability and step
+        // writers): every op they answer is a document write, but for the reads
+        // and step writers taken out here.
+        const { landingOf, ...moves } = moveOps(steps);
+        const { besideAt, ...layouts } = layoutOps(steps);
+        const { dataSteps, replaceData, ...metas } = metaOps(steps);
+        const deletes = deleteOps(steps);
         /** What range deletion and flow placement compose: the step writers and the ops. */
-        const ops = { ...steps, insertBlocks, deleteBlocks, dataSteps, replaceData };
+        const ops = { ...steps, ...moves, ...deletes, dataSteps, replaceData };
         /** Every document op, prepared — `apply(prepare.op(…))` is the op. */
         const prepare = {
-            insertBlocks,
-            moveBlocks,
+            ...moves,
+            ...layouts,
+            ...splitMergeOps(steps),
+            ...deletes,
+            ...metas,
+            ...contentOps(steps),
             /**
              * Move `id` to the last position under `parent` — under a container
              * it is no item of, under its last item (`nestParent`: Tab after a list).
              */
             nestBlock: (id, parent) => {
                 const at = nestParent([ref(id)], ref(parent));
-                return moveBlocks([id], { parent: at, index: childrenIds(at).length });
+                return moves.moveBlocks([id], { parent: at, index: childrenIds(at).length });
             },
-            unNestBlock,
-            unNestBlocks,
-            liftOut,
-            placeBeside,
-            wrapInLayout,
-            splitBlock,
-            mergeBlocks,
-            mergeBackward,
-            mergeForward,
-            deleteBlock,
-            setBlock,
-            setBlockType,
-            patchData,
-            duplicateBlock,
-            insertText,
-            deleteText,
-            formatRange,
-            clearMarks,
-            insertInline,
-            removeInline,
             /** Delete a block selection — one plan; only the members leave (`deleteBlocks` above). */
-            deleteBlocks: (ids) => deleteBlocks(ids),
+            deleteBlocks: (ids) => deletes.deleteBlocks(ids),
             ...rangeDeleteOps(ops),
             ...flowOps(ops)
         };
+        /**
+         * What a part built over this document reads beyond the facade (the
+         * shared suggestions, `doc/suggest.ts`): the reads, a facade over
+         * another doc (`create`, with this `config`);
+         * `v` counts its changes no index fact shows (in `version`), and
+         * `base`, when set, is the export `toJSON()` gives unless asked for
+         * the suggestions.
+         */
+        const part = {
+            ...reads,
+            config,
+            create: create,
+            v: 0,
+            base: undefined
+        };
         /**
          * Plans prepared at one version, as one plan (refused if any part is;
          * stamped with the oldest part's version, so `apply` refuses a stale
@@ -212,7 +246,11 @@ export const docFacade = (Y, layers) => {
          * omitted when empty): the one serializer, {@link blockJSON}, over the
          * root's visible children.
          */
-        const toJSON = () => {
+        const toJSON = (options) => {
+            // A part's export first (the shared suggestions': without the pending ones, `sugg.json.base`).
+            const base = !options?.suggestions && part.base?.();
+            if (base)
+                return base;
             const data = docData();
             const children = childrenIds(null).map(blockJSON);
             return Object.keys(data).length > 0
@@ -222,32 +260,17 @@ export const docFacade = (Y, layers) => {
         // ── facade object ─────────────────────────────────────────────────
         /** A read taking an id first: the id normalizes at ingress. */
         const byRef = (f) => (id, ...rest) => f(ref(id), ...rest);
-        const facade = {
-            // lifecycle
-            init: (opts) => write(() => init(doc, opts)),
-            /** Apply the deterministic seed of `value` and the document's `data` — the document's seed decision. */
-            seed: (value, data) => write(() => seed(doc, value, defaultType, data)),
-            isInitialized: () => isInitialized(doc),
-            /** Replicated `meta.v` schema version (the module-level read, bound). */
-            schemaVersion: () => schemaVersion(doc),
-            /**
-             * The schema gate for this doc — throws {@link SchemaMismatchError}
-             * on unversioned-content or unsupported-version state. Consumers
-             * (`Edytor.sync()`, packed consumers) call it before trusting
-             * a synced doc.
-             */
-            checkSchema: () => checkSchema(doc),
-            assertSchema: () => assertSchema(doc),
-            dispose,
-            createUndoManager,
+        /**
+         * The public operations (`DocumentOperations`), each name once: what
+         * an `EdytorDocument` forwards. The facade has them and the internal
+         * members below.
+         */
+        const api = {
             // reads — every id argument normalizes at ingress
             project: () => project(doc),
             toJSON,
             blockJSON: byRef(blockJSON),
             childrenIds: byRef(childrenIds),
-            /** Visible children of `parent` with their ranks, in `(rank, id)` order. */
-            childSlots: (parent) => view().kids.get(parent) ?? [],
-            slotOf: byRef(slotOf),
             positionOf: byRef(positionOf),
             pathOf: byRef(pathOf),
             parentOf: byRef((id) => positionOf(id)?.parent ?? null),
@@ -265,8 +288,6 @@ export const docFacade = (Y, layers) => {
              * O(1) per call; live-replicated (remote values read the same).
              */
             blockAttribution: byRef((id) => blockAttributionOf(doc, id)),
-            crdtId: byRef((id) => crdtId(doc, id)),
-            resolveBlock: byRef((id) => resolveBlock(doc, id)),
             displayLength: byRef(displayLength),
             contentItems: byRef(contentItems),
             hasBlock: byRef(hasBlock),
@@ -278,10 +299,6 @@ export const docFacade = (Y, layers) => {
             // caret anchors — backing-text-bound selection endpoints
             anchorAt: byRef(anchorAt),
             resolveAnchor,
-            followUndo,
-            // roles
-            /** Re-read the roles after `roleOf` answers differently (roles adopted later). */
-            rolesChanged: () => runsView.roles(roles),
             isVoid: byRef(isVoid),
             isIsland: byRef(isIsland),
             isLines: byRef(isLines),
@@ -317,10 +334,8 @@ export const docFacade = (Y, layers) => {
             nestParent: (ids, parent) => nestParent(ids.map(ref), ref(parent)),
             /** Where a block of `kind` at `id`'s place lands, and the containers it leaves (`liftOut`). */
             landingOf: (id, kind, after) => landingOf(ref(id), ref(kind), after),
-            defaultChild: byRef(defaultChild),
             // maintained runs (bound to this doc)
             runs: byRef(runsView.runs),
-            contentJSON: byRef(runsView.contentJSON),
             // events
             onChange,
             // every op — each returns an {@link OpResult}; `apply(prepare.op(…))`
@@ -333,10 +348,6 @@ export const docFacade = (Y, layers) => {
             // transactions (composed ops already run in one; expose for callers
             // that batch several ops into one undo step / one event)
             transact: (fn, origin) => write(() => doc.transact(fn, origin)),
-            // escape hatch for the history and debugging — the bound engine layers.
-            model: layers.model,
-            text: layers.text,
-            runsView,
             // ── model-state version ─────────────────────────────
             /**
              * The index version — bumps on every fold that changed derived
@@ -345,11 +356,57 @@ export const docFacade = (Y, layers) => {
              * post-write state — this is the read-your-writes contract.
              */
             get version() {
-                return runsView.version();
+                // A part's change may show in no index fact (a suggestion's decision).
+                return runsView.version() + part.v;
             }
         };
-        return facade;
+        const internal = {
+            // lifecycle
+            init: (opts) => write(() => init(doc, opts)),
+            /** Apply the deterministic seed of `value` and the document's `data` — the document's seed decision. */
+            seed: (value, data) => write(() => seed(doc, value, defaultType, data)),
+            isInitialized: () => isInitialized(doc),
+            /** Replicated `meta.v` schema version (the module-level read, bound). */
+            schemaVersion: () => schemaVersion(doc),
+            /**
+             * The schema gate for this doc — throws {@link SchemaMismatchError}
+             * on unversioned-content or unsupported-version state. Consumers
+             * (`Edytor.sync()`, packed consumers) call it before trusting
+             * a synced doc.
+             */
+            checkSchema: () => checkSchema(doc),
+            assertSchema: () => assertSchema(doc),
+            dispose,
+            createUndoManager,
+            /** @internal What a part built over the document reads and writes (`doc/suggest.ts`). */
+            part,
+            /** Visible children of `parent` with their ranks, in `(rank, id)` order. */
+            childSlots: (parent) => view().kids.get(parent) ?? [],
+            slotOf: byRef(slotOf),
+            crdtId: byRef((id) => crdtId(doc, id)),
+            resolveBlock: byRef((id) => resolveBlock(doc, id)),
+            followUndo,
+            // roles
+            /** Re-read the roles after `roleOf` answers differently (roles adopted later). */
+            rolesChanged: (place = true) => {
+                kinds = new Map();
+                declared = undefined;
+                if (place)
+                    runsView.roles(roles);
+            },
+            defaultChild: byRef(defaultChild),
+            contentJSON: byRef(runsView.contentJSON),
+            // escape hatch for the history and debugging — the bound engine layers.
+            model: layers.model,
+            text: layers.text,
+            runsView,
+            /** The public members' names (`EdytorDocument` forwards them). */
+            api: api
+        };
+        // The public members joined as they are (the `version` getter stays one).
+        return Object.defineProperties(internal, Object.getOwnPropertyDescriptors(api));
     };
+    return create;
 };
 /**
  * Bind the assembled model to a concrete engine surface. `Y` must be the
@@ -361,7 +418,6 @@ export const bindDocModel = (Y) => {
     const M = bindModel(Y);
     const T = bindText(Y);
     const R = bindRuns(Y);
-    const D = bindDeletes(Y);
     const { init, seed } = bindSeed(Y, bindBlockAttribution(Y));
     const create = docFacade(Y, { model: M, text: T });
     return {
@@ -390,14 +446,6 @@ export const bindDocModel = (Y) => {
          * not have integrated anything yet.
          */
         newDoc: (opts) => keepingReplaced(new Y.Doc(opts)),
-        /**
-         * Keep, on `doc`, the text a replica may have to copy again: its
-         * `gcFilter` then spares a deleted copy's content, as every facade's
-         * history does. A doc that only relays updates (the room) calls it
-         * before applying anything, so what it collects and encodes matches
-         * what an editing replica keeps.
-         */
-        keepCopies: (doc) => void D.scope(doc),
         /** The bound engine layers (same instances the facades use). */
         model: M,
         text: T,

package/dist/crdt/engine-api.d.ts

@@ -49,6 +49,10 @@ export type EngineItemRef = {
  */
 export interface EngineTransaction {
     changed?: Map<unknown, Set<string | null>>;
+    /** The visibility changes hold records made, in order: `client, clock, ±len` per item (`> 0` shown). */
+    holds?: number[];
+    /** The units whose mover changed (the fork's move records), in order: `client, clock, len` per item. */
+    moves?: number[];
 }
 /**
  * Structural minimum of the vendored `Y.Node` (v14) used by the placement
@@ -70,7 +74,34 @@ export interface EngineNode {
     forEachAttr(f: (value: unknown, key: string, node: EngineNode) => void): void;
     attrKeys(): IterableIterator<string>;
     insert(index: number, content: unknown): void;
-    delete(index: number, length?: number): void;
+    /**
+     * Delete `length` live units at `index`. With `into` (the document's
+     * records list), they are held by one record appended there instead (a
+     * delete its writer can take back), except those `fresh` names, which are
+     * removed. With `propose` (a suggestion's delete), each
+     * unit is sorted: `1` held as above (its author's own), `2` proposed (an
+     * id list appended to `propose.into`) or `3` stepped over; proposed and
+     * stepped-over units read gone until the engine's `unhide`.
+     */
+    delete(index: number, length?: number, into?: EngineNode | null, fresh?: unknown, propose?: {
+        into: EngineNode;
+        sort: (client: number, clock: number) => number;
+    } | null): void;
+    /** Append one hold record of `ids` (`client, clock, len` triples) to this records list: they read as deleted while it lives. */
+    hold(ids: number[]): void;
+    /**
+     * Move the units `ids` names (`client, clock, len` triples, in order) to
+     * live index `index` of this sequence: one move record there (the fork's
+     * `ContentMove`); `side` is its class among the items of its origin (`0`
+     * after, `1` before), `at` the chain it stands at for the sort of two
+     * records at one origin — the units from the root sequence down to the
+     * unit it stands at, outermost first (`null`: the first unit it names) —
+     * and `part` its order among the records standing there.
+     */
+    move(index: number, ids: number[], side?: number, part?: number, at?: ReadonlyArray<{
+        client: number;
+        clock: number;
+    }> | null): void;
 }
 /** Structural minimum of the vendored `Y.Doc`. */
 export interface EngineDoc {
@@ -98,6 +129,13 @@ export interface EngineDoc {
      */
     on(name: 'commit', f: (transaction: never) => void): void;
     off(name: 'commit', f: (transaction: never) => void): void;
+    /**
+     * Doc-level `beforeCommit` channel (the fork's) — fires once per
+     * outermost transaction, after its function returned and while the
+     * transaction is still open: a listener's writes join it.
+     */
+    on(name: 'beforeCommit', f: (transaction: never) => void): void;
+    off(name: 'beforeCommit', f: (transaction: never) => void): void;
     /** Doc destruction event — doc-scoped state must release on destroy. */
     on(name: 'destroy', f: () => void): void;
     off(name: 'destroy', f: () => void): void;

package/dist/crdt/engine.d.ts

@@ -30,7 +30,7 @@ export type EngineSymbol =
 	| 'followRedone'
 	| 'isParentOf'
 	| 'mergeIdSets'
-	| 'ContentAny'
-	| 'createID';
+	| 'createID'
+	| 'unhide';
 
 export declare const Y: Pick<typeof V, EngineSymbol>;

package/dist/crdt/engine.js

@@ -37,16 +37,15 @@ export const Y = {
 	createIdSet: V.createIdSet,
 	diffIdSet: V.diffIdSet,
 	insertIntoIdSet: V.insertIntoIdSet,
-	// text delete marks (`text/deletes.ts`, fork patch YP11)
+	// the document's undo manager (`doc/history.ts`, fork patch YP18)
 	iterateStructsByIdSet: V.iterateStructsByIdSet,
 	getItemCleanStart: V.getItemCleanStart,
 	redoItem: V.redoItem,
-	// the document's undo manager (`doc/history.ts`, fork patch YP18)
 	keepItem: V.keepItem,
 	followRedone: V.followRedone,
 	isParentOf: V.isParentOf,
 	mergeIdSets: V.mergeIdSets,
-	// a folded delete record appended after the one it replaces
-	ContentAny: V.ContentAny,
-	createID: V.createID
+	createID: V.createID,
+	// a suggestion's proposed deletion reads gone until its plan ends (fork patch YP32)
+	unhide: V.unhide
 };

package/dist/crdt/flow.d.ts

@@ -21,7 +21,7 @@
  * - a `whole` flow (a block-selection copy) goes after the block, replacing
  *   it when empty (`flow.whole`); over selected blocks the lines take their
  *   slot (`flow.slot`), and at a slot they are placed with nothing replaced
- *   (`flow.place`: an accepted suggestion), all at plain ranks (`insertBlocks`: their order
+ *   (`flow.place`: an accepted suggestion), as plain inserts (`insertBlocks`: their order
  *   against a peer's split beside them is not claimed); a void
  *   takes one run (`flow.void`);
  * - a table's cell is never split: it takes the lines a flow shows, nested
@@ -82,7 +82,7 @@ export type FlowContext = OpsContext & Pick<MoveOps, 'insertBlocks'> & Pick<Dele
  * paragraph (`doc.empty.virtual`) place the caret by it.
  */
 export declare const placedEnd: (roleOf: (kind: string) => {
-    void: boolean;
+    childless: boolean;
     rendersContent: boolean;
 }) => (s: BlockSpec) => DocPosition | undefined;
 /** `insertFlow`, prepared. */

package/dist/crdt/flow.js

@@ -14,7 +14,7 @@ const lengthOf = (l) => (l.content ?? []).reduce((n, i) => n + (i.kind === 'text
 export const placedEnd = (roleOf) => {
     const endOf = (s) => {
         const role = roleOf(s.type);
-        if (role.rendersContent && !role.void)
+        if (role.rendersContent && !role.childless)
             return { block: s.id, offset: lengthOf(s) };
         for (const kid of [...(s.children ?? [])].reverse()) {
             const at = endOf(kid);
@@ -27,15 +27,9 @@ export const placedEnd = (roleOf) => {
 };
 /** `insertFlow`, prepared. */
 export const flowOps = (c) => {
-    /** A kind's roles, as placement reads them. */
-    const roleOf = (kind) => ({
-        void: c.roles.childless(kind),
-        island: c.roles.island(kind),
-        rendersContent: c.roles.rendersContent(kind),
-        layout: c.roles.layout(kind)
-    });
+    const roleOf = c.roles.of;
     /** What a kind is in a table: the table, its row or its cell. */
-    const tableKind = (kind) => c.roles.table(kind) !== undefined
+    const tableKind = (kind) => roleOf(kind).table !== undefined
         ? 'table'
         : c.isRowKind(kind)
             ? 'row'
@@ -94,7 +88,9 @@ export const flowOps = (c) => {
                 const placed = specs(dest.parent);
                 const p = c.insertBlocks(dest, placed);
                 const at = endOf(placed.at(-1)) ?? { block: last().id, offset: lengthOf(last()) };
-                return 'writes' in p ? { ...c.plan(p.ids, [...pre, ...p.writes]), at } : p;
+                // The lines are placed while the replaced blocks still show (each step reads the
+                // display as it stands), then those go.
+                return 'writes' in p ? { ...c.plan(p.ids, [...p.writes, ...pre]), at } : p;
             };
             if ('replace' in target || 'slot' in target) {
                 let slot;
@@ -148,7 +144,7 @@ export const flowOps = (c) => {
             const apart = (l, under) => {
                 const kind = l.type && fit(under, l.type);
                 const role = kind ? roleOf(kind) : undefined;
-                return !!role && (!role.rendersContent || role.void || role.island);
+                return !!role && (!role.rendersContent || role.childless || role.island);
             };
             // At the end of a container's header whose body shows, what follows the caret
             // leads its children and the body stays, as Enter opens a first child
@@ -188,55 +184,53 @@ export const flowOps = (c) => {
                 return c.REFUSED;
             const writes = [];
             /** A joined line's children lead the block it joins; `moved` follow them. */
-            const kids = (to, l, moved = [], ranks = c.ranksFor(to, 0, (l?.children?.length ?? 0) + moved.length)) => {
+            const kids = (to, l, moved = []) => {
                 const k = l?.children?.length ?? 0;
                 if (k)
-                    writes.push({ op: 'insertBlocks', parent: to, index: 0, specs: l.children, ranks });
+                    writes.push({ op: 'insertBlocks', parent: to, index: 0, specs: l.children });
                 if (moved.length)
-                    writes.push({
-                        op: 'moveBlocks',
-                        ids: moved,
-                        parent: to,
-                        index: k,
-                        ranks: ranks.slice(k)
-                    });
+                    writes.push({ op: 'moveBlocks', ids: moved, parent: to, index: k });
             };
             /**
              * `l` joins `B` at `at`: its content, its kind when `B` shows no text (a header
              * keeps its own, as Enter does), its children first.
              */
-            const join = (l, at, ranks) => {
+            const join = (l, at) => {
                 const end = c.writeContent(writes, B, at, l.content);
                 const kind = l.type && fit(parent, l.type);
                 if (len === 0 && !header && kind && kind === l.type)
                     writes.push(...c.attr(B, TYPE, kind), ...(c.dataSteps(B, c.replaceData(l.data ?? {})) ?? []));
                 if (!shut)
-                    kids(B, l, [], ranks);
+                    kids(B, l);
                 return end;
             };
-            /** The placed lines at `at` under `home`, `ranks` theirs. */
-            const place = (at, ranks) => {
+            /** The placed lines at `at` under `home` (`split`: the tail of the split they come with). */
+            const place = (at, split) => {
                 if (placed.length)
-                    writes.push({ op: 'insertBlocks', parent: home, index: at, specs: placed, ranks });
+                    writes.push({
+                        op: 'insertBlocks',
+                        parent: home,
+                        index: at,
+                        specs: placed,
+                        ...(split !== undefined && { split })
+                    });
             };
             // Under a header, the first line's children, the placed lines and the rest, in order.
             const k = joinsHead ? (first.children?.length ?? 0) : 0;
-            const lead = inside ? c.ranksFor(B, 0, k + placed.length + 1) : [];
-            const slot = inside ? 0 : index + 1;
+            const slot = inside ? k : index + 1;
             // Where the placed lines end the caret: after their last shown line (`flow.apart`).
             const end = placed.length ? endOf(placed.at(-1)) : undefined;
             // Nothing before the position and the first line stands apart: the lines go before `B`,
             // which keeps its text and takes a joining last line, or goes when empty and not needed.
             if (!joinsHead && o === 0 && !inside) {
-                place(index, c.ranksFor(parent, index, placed.length, [], true));
+                place(index);
                 if (joinsTail) {
                     const at = join(last(), 0);
                     // A closed header's taken line's nested lines follow it, the caret ending them.
                     const after = shut ? specs(parent, last().children ?? []) : [];
                     if (after.length) {
-                        const ranks = c.ranksFor(parent, index + 1, after.length, [], true);
                         const slot = index + placed.length + 1;
-                        writes.push({ op: 'insertBlocks', parent, index: slot, specs: after, ranks });
+                        writes.push({ op: 'insertBlocks', parent, index: slot, specs: after });
                     }
                     const caret = after.length ? endOf(after.at(-1)) : undefined;
                     const touched = [...ids, B, ...after.map((s) => s.id)];
@@ -246,13 +240,13 @@ export const flowOps = (c) => {
                     return { ...c.plan(ids, [...writes, c.remove(B, [])]), at: end };
                 return { ...c.plan([...ids, B], writes), at: end ?? { block: B, offset: 0 } };
             }
-            const head = joinsHead ? join(first, o, inside ? lead.slice(0, k) : undefined) : o;
+            const head = joinsHead ? join(first, o) : o;
             if (lines.length === 1 && joinsHead)
                 return { ...c.plan([B], writes), at: { block: B, offset: head } };
             const moved = inside ? [] : c.childrenIds(B).filter((id) => !view.hidden?.(id));
             // Nothing after the position to keep, and the caret has a line: no split.
             if (!joinsTail && o === len && moved.length === 0 && end) {
-                place(slot, inside ? lead.slice(k, -1) : c.pieceRanks(B, o, placed.length));
+                place(slot);
                 return { ...c.plan([B, ...ids], writes), at: end };
             }
             // The rest of `B` stays in a shown line: the last line's block when it joins, else
@@ -266,9 +260,7 @@ export const flowOps = (c) => {
                 : bare || inside
                     ? { type: c.defaultChild(home), data: {} }
                     : { type: c.kindToCopy(B), data: c.blockDataOf(B) };
-            // By the offset the paste splits `B` at (SW12-crdt-4), as Enter's split.
-            const ranks = inside ? lead.slice(k) : c.pieceRanks(B, o, placed.length + 1);
-            const rank = ranks.pop();
+            // After `B` (under a header: after the first line's children); the placed lines go before it.
             const length = len - o;
             writes.push({
                 op: 'splitBlock',
@@ -278,10 +270,10 @@ export const flowOps = (c) => {
                 newId: T,
                 tail,
                 parent: home,
-                rank
+                index: slot
             });
             kids(T, joinsTail ? last() : undefined, moved);
-            place(slot, ranks);
+            place(slot, T);
             const at = joinsTail
                 ? { block: T, offset: c.writeContent(writes, T, 0, last().content) }
                 : (end ?? { block: T, offset: 0 });