edytor 3.0.0 → 5.0.0

package/dist/crdt/doc/layout.js

@@ -8,12 +8,12 @@ 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)
-            return roles.layout(kind) === undefined ? undefined : kind;
-        const kinds = [...roles.layoutKinds()];
+            return roles.of(kind).layout === undefined ? undefined : kind;
+        const kinds = roles.declared().layouts;
         return kinds.length === 1 ? kinds[0] : undefined;
     };
     /** A fresh empty block of `type`. */
@@ -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);
@@ -90,7 +90,7 @@ export const layoutOps = (c) => {
             }
         }
         const wrap = layout === null ? layoutKind(kind && ref(kind)) : blockTypeOf(layout);
-        const item = wrap === undefined ? undefined : roles.layout(wrap);
+        const item = wrap === undefined ? undefined : roles.of(wrap).layout;
         if (wrap === undefined || item === undefined)
             return REFUSED;
         if (moved.some((id) => !fitsIn(item, blockTypeOf(id))))
@@ -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);
@@ -150,14 +145,14 @@ export const layoutOps = (c) => {
         if (blocks.some((id) => isLayoutItem(id) || holdsLayout(id)))
             return REFUSED;
         const wrap = layoutKind(kind && ref(kind));
-        const item = wrap === undefined ? undefined : roles.layout(wrap);
+        const item = wrap === undefined ? undefined : roles.of(wrap).layout;
         if (wrap === undefined || item === undefined || !fits(parent, wrap))
             return REFUSED;
         if (parent !== null && (insideItem(parent, v) || isIsland(parent) || insideIsland(parent, v)))
             return REFUSED;
         if (blocks.some((id) => !fitsIn(item, blockTypeOf(id))))
             return REFUSED;
-        const fill = roles.defaultChild(item);
+        const fill = roles.of(item).child;
         if (columns > blocks.length && !fitsIn(item, fill))
             return REFUSED;
         const ordered = blocks.toSorted((a, b) => positionOf(a).index - positionOf(b).index);
@@ -165,14 +160,8 @@ export const layoutOps = (c) => {
         const wrapper = { ...spec(wrap), children: items };
         const at = positionOf(ordered[0]).index;
         const writes = [
-            {
-                op: 'insertBlocks',
-                parent,
-                index: at,
-                specs: [wrapper],
-                ranks: ranksFor(parent, at, 1)
-            },
-            ...ordered.flatMap((id, i) => moveTo([id], items[i].id, 0, ranksFor(items[i].id, 0, 1)))
+            { op: 'insertBlocks', parent, index: at, specs: [wrapper] },
+            ...ordered.flatMap((id, i) => moveTo([id], items[i].id, 0))
         ];
         const kept = new Set([
             wrapper.id,

package/dist/crdt/doc/meta.js

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

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

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

package/dist/crdt/doc/moves.js

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

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

@@ -1,6 +1,6 @@
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
 import { type BlockId, type ContentItem, type Destination, type ModelView } from '../placement/model.js';
-import type { DisplayRoles, RunView } from '../text/runs.js';
+import type { DisplayRoles, KindRole, RunView } from '../text/runs.js';
 import { type DataPatch } from '../data.js';
 import { type JSONBlock } from '../../utils/json.js';
 import type { BlockRole, DataTarget, JsonObj, OrderPolicy } from './types.js';
@@ -40,7 +40,7 @@ export declare const docReads: (c: DocBase) => {
         parent: BlockId | null;
         rank: string;
     } | null;
-    is: (id: BlockId, role: (type: string) => boolean) => boolean;
+    kindOf: (id: BlockId) => KindRole | undefined;
     isVoid: (id: BlockId) => boolean;
     isIsland: (id: BlockId) => boolean;
     isLines: (id: BlockId) => boolean;

package/dist/crdt/doc/reads.js

@@ -121,15 +121,15 @@ export const docReads = (c) => {
         return slot.parent === DEAD ? pl : slot;
     };
     // ── roles (island/void) ───────────────────────────────────────────
-    /** The role table's answer for `id`'s shown kind (`false` without one). */
-    const is = (id, role) => {
+    /** The role of `id`'s shown kind (`undefined` without one). */
+    const kindOf = (id) => {
         const t = blockTypeOf(id);
-        return t !== undefined && role(t);
+        return t === undefined ? undefined : roles.of(t);
     };
-    const isVoid = (id) => is(id, roles.childless);
-    const isIsland = (id) => is(id, roles.island);
+    const isVoid = (id) => kindOf(id)?.childless === true;
+    const isIsland = (id) => kindOf(id)?.island === true;
     /** An island that holds only lines (a code block: its role says `lines`). */
-    const isLines = (id) => is(id, (type) => roles.line(type) !== undefined);
+    const isLines = (id) => kindOf(id)?.line !== undefined;
     /** Nearest island-typed display ancestor of `id`, or null. */
     const islandOf = (id, v = view()) => ancestorsOf(id, v).find((a) => isIsland(a)) ?? null;
     /** True iff `id` sits strictly inside an island subtree. */
@@ -139,45 +139,35 @@ export const docReads = (c) => {
         const parent = positionOf(id)?.parent;
         return parent != null && isLines(parent);
     };
-    /** The child kind `role` gives `id`'s kind: a layout's item kind, a table's row kind. */
-    const childKindOf = (role) => (id) => {
-        const type = blockTypeOf(id);
-        return type === undefined ? undefined : roles[role](type);
-    };
-    /** `id` is of its parent's `kindOf` kind, directly in it (a column, a row). */
-    const childOf = (kindOf) => (id) => {
+    /** `id` is of its parent's `kind` kind, directly in it (a column, a row, a cell). */
+    const childOf = (kind) => (id) => {
         const parent = positionOf(id)?.parent;
-        return parent != null && blockTypeOf(id) === kindOf(parent);
+        const k = parent == null ? undefined : kindOf(parent);
+        return parent != null && blockTypeOf(id) === (k && kind(k));
     };
     /** The item kind of `id` when it is a layout (its role says `layout`): its default child. */
-    const itemKindOf = childKindOf('layout');
+    const itemKindOf = (id) => kindOf(id)?.layout;
     /** `id` is a layout (`layout.*`). */
     const isLayout = (id) => itemKindOf(id) !== undefined;
     /** `id` is a layout item: of its layout's item kind, directly in it (a column). */
-    const isLayoutItem = childOf(itemKindOf);
+    const isLayoutItem = childOf((k) => k.layout);
     /** `id` is a layout or holds one in its shown subtree (`layout.nest`). */
     const holdsLayout = (id) => isLayout(id) || childrenIds(id).some(holdsLayout);
     /** `id` is a layout item or sits inside one. */
     const insideItem = (id, v) => [id, ...ancestorsOf(id, v)].some(isLayoutItem);
     // ── tables (`table.*`) ────────────────────────────────────────────
-    /** The row kind of `id` when it is a table (its role says `table`): its default child. */
-    const rowKindOf = childKindOf('table');
     /** `id` is a table (`table.*`). */
-    const isTable = (id) => rowKindOf(id) !== undefined;
+    const isTable = (id) => kindOf(id)?.table !== undefined;
     /** `type` is a row kind of a table kind the roles declare (`tableRow`). */
-    const isRowKind = (type) => type !== undefined && [...roles.tableKinds()].some((t) => roles.table(t) === type);
+    const isRowKind = (type) => type !== undefined && roles.declared().rows.has(type);
     /** `type` is a cell kind: the default child of a row kind (`tableCell`). */
-    const isCellKind = (type) => type !== undefined &&
-        [...roles.tableKinds()].some((t) => {
-            const row = roles.table(t);
-            return row !== undefined && roles.defaultChild(row) === type;
-        });
+    const isCellKind = (type) => type !== undefined && roles.declared().cells.has(type);
     /** `id` is a table's row: of its table's row kind, directly in it. */
-    const isTableRow = childOf(rowKindOf);
+    const isTableRow = childOf((k) => k.table);
     /** `id` is a table's cell: of its row's cell kind, directly in a row of a table. */
     const isTableCell = (id) => {
         const row = positionOf(id)?.parent;
-        return (row != null && isTableRow(row) && blockTypeOf(id) === roles.defaultChild(blockTypeOf(row)));
+        return row != null && isTableRow(row) && blockTypeOf(id) === kindOf(row).child;
     };
     /** The table `id` is, or whose row or cell it is; `null` for any other block. */
     const tableOf = (id) => {
@@ -301,8 +291,8 @@ export const docReads = (c) => {
     const hasBlock = (id) => blockNodeOf(doc, id) !== null;
     /** The one liveness answer (`isLive`): `id` renders in `project()`. O(depth). */
     const live = (id) => isLive(doc, id);
-    /** A live block that can hold content: it has a claims list (a streamless block gets its own text on first write). */
-    const contentTarget = (id) => live(id) && view().blocks.get(id)?.claimsNode !== undefined;
+    /** A live block that can hold content (a streamless block gets its own text on first write). */
+    const contentTarget = (id) => live(id) && view().blocks.has(id);
     return {
         dataNode,
         blockJSON,
@@ -317,7 +307,7 @@ export const docReads = (c) => {
         pathOf,
         ancestorsOf,
         slotOf,
-        is,
+        kindOf,
         isVoid,
         isIsland,
         isLines,

package/dist/crdt/doc/seed.js

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

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

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