edytor 3.0.0 → 4.0.0

package/dist/crdt/engine.js

@@ -37,16 +37,13 @@ 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
 };

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

package/dist/crdt/flow.js

@@ -94,7 +94,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;
@@ -188,55 +190,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 +246,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 +266,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 +276,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 });

package/dist/crdt/index.d.ts

@@ -75,7 +75,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
     Awareness: typeof _Awareness;
     doc: {
         SCHEMA: {
-            readonly version: 6;
+            readonly version: 10;
             readonly name: "edytor-doc";
             readonly roots: {
                 readonly registry: "blocks";
@@ -86,7 +86,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 readonly schema: "schema";
             };
         };
-        SCHEMA_VERSION: 6;
+        SCHEMA_VERSION: 10;
         SCHEMA_NAME: "edytor-doc";
         META_KEY: "meta";
         init: (doc: import("./engine-api.js").EngineDoc, opts?: {
@@ -150,29 +150,30 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 blockNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
                 liveNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
                 isLive: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => boolean;
-                candidatesOf: (node: import("./engine-api.js").EngineNode) => import("./placement/model.js").PlacementCand[];
                 view: (doc: import("./engine-api.js").EngineDoc) => import("./placement/model.js").ModelView;
-                resolvePlacements: (blocks: Map<import("./index.js").BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: import("./index.js").BlockId) => import("./text/model.js").Owner) => Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>;
                 childrenIndex: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<import("./index.js").BlockId | null, import("./placement/model.js").ChildSlot[]>;
                 positionInView: (v: import("./placement/model.js").ModelView, id: import("./index.js").BlockId) => import("./index.js").Destination | null;
                 buildInline: (atom: import("./index.js").InlineSpec) => import("./engine-api.js").EngineNode;
                 isSelfOrDescendant: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: import("./index.js").BlockId, maybeAncestor: import("./index.js").BlockId) => boolean;
-                ranksAt: (siblings: readonly {
-                    rank: string;
-                }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-                writePlacement: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, p: import("./index.js").BlockId | null, r: string) => void;
+                placeBlocks: (doc: import("./engine-api.js").EngineDoc, v: import("./placement/model.js").ModelView, parent: import("./index.js").BlockId | null, left: import("./index.js").BlockId | null, right: import("./index.js").BlockId | null, slots: readonly import("./placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("./placement/slots.js").Unit | null) => void;
+                moveBlocksTo: (doc: import("./engine-api.js").EngineDoc, v: import("./placement/model.js").ModelView, ids: readonly import("./index.js").BlockId[], parent: import("./index.js").BlockId | null, index: number, side?: number, part?: number, at?: import("./index.js").BlockId | null) => void;
+                insertSpecsAt: (doc: import("./engine-api.js").EngineDoc, v: import("./placement/model.js").ModelView, parent: import("./index.js").BlockId | null, index: number, specs: readonly import("./index.js").BlockSpec[], split?: import("./placement/slots.js").Unit | null) => void;
                 withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                     inserts: {
                         has(client: number, clock: number): boolean;
                     };
                 }) => boolean;
-                materializeSpec: (doc: import("./engine-api.js").EngineDoc, sp: import("./index.js").BlockSpec, parent: import("./index.js").BlockId | null, rank: string) => void;
                 collides: (doc: import("./engine-api.js").EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
-                writeSplit: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId, offset: number, newId: import("./index.js").BlockId, tail: import("./placement/model.js").SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+                writeSplit: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId, offset: number, newId: import("./index.js").BlockId, tail: import("./placement/model.js").SplitTail, parent: import("./index.js").BlockId | null, index: number) => import("./placement/slots.js").Unit;
                 ownText: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => {
                     from: unknown;
                     to: number;
                 };
+                recordsOf: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, v?: import("./placement/model.js").ModelView) => {
+                    item: import("./placement/slots.js").SeqItem;
+                    stamp: import("./placement/slots.js").Stamp;
+                    wins: boolean;
+                }[];
                 insertBlocks: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
                 insertBlock: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
                 restoreBlocks: (doc: import("./engine-api.js").EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
@@ -204,8 +205,8 @@ export declare const bindCrdt: (Y: EngineApi) => {
                     at: number;
                     node: import("./engine-api.js").EngineNode;
                 } | null;
-                splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
-                claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+                splitAt: (doc: import("./engine-api.js").EngineDoc, blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => void;
+                claimInto: (own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
                 ownText: (doc: import("./engine-api.js").EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
                     from: unknown;
                     to: number;
@@ -225,7 +226,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 keep?: boolean;
                 after?: readonly import("./index.js").BlockSpec[];
             } | undefined) => import("./edytor-doc.js").OpResult;
-            placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => import("./edytor-doc.js").OpResult;
+            placeBeside: (ids: readonly string[], target: string, side: "left" | "right", kind?: string | undefined) => import("./edytor-doc.js").OpResult;
             wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => import("./edytor-doc.js").OpResult;
             splitBlock: (id: string, offset: number, newId: string, tail?: import("./placement/model.js").SplitTail | undefined) => import("./edytor-doc.js").OpResult;
             mergeBlocks: (fromId: string, intoId: string) => import("./edytor-doc.js").OpResult;
@@ -348,11 +349,10 @@ export declare const bindCrdt: (Y: EngineApi) => {
             onChange: (cb: (change: import("./edytor-doc.js").DocChange) => void) => (() => void);
         };
         newDoc: (opts?: ConstructorParameters<EngineApi["Doc"]>[0]) => YDoc;
-        keepCopies: (doc: import("./engine-api.js").EngineDoc) => void;
         purge: (doc: import("./engine-api.js").EngineDoc, facade: {
             model: import("./placement/model.js").PlacementModel;
             text: import("./text/model.js").TextEngine;
-        }, horizon: import("./purge.js").Horizon) => import("./purge.js").PurgeReport;
+        }, horizon: import("./purge.js").Horizon | null) => import("./purge.js").PurgeReport;
         horizonOf: (doc: import("./engine-api.js").EngineDoc) => import("./purge.js").Horizon | null;
         restoreTo: <Plan>(doc: import("./engine-api.js").EngineDoc, facade: import("./restore.js").RestoreFacade<Plan>, json: import("./index.js").JSONDoc) => import("./restore.js").RestoreReport;
         model: {
@@ -361,29 +361,30 @@ export declare const bindCrdt: (Y: EngineApi) => {
             blockNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
             liveNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
             isLive: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => boolean;
-            candidatesOf: (node: import("./engine-api.js").EngineNode) => import("./placement/model.js").PlacementCand[];
             view: (doc: import("./engine-api.js").EngineDoc) => import("./placement/model.js").ModelView;
-            resolvePlacements: (blocks: Map<import("./index.js").BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: import("./index.js").BlockId) => import("./text/model.js").Owner) => Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>;
             childrenIndex: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<import("./index.js").BlockId | null, import("./placement/model.js").ChildSlot[]>;
             positionInView: (v: import("./placement/model.js").ModelView, id: import("./index.js").BlockId) => import("./index.js").Destination | null;
             buildInline: (atom: import("./index.js").InlineSpec) => import("./engine-api.js").EngineNode;
             isSelfOrDescendant: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: import("./index.js").BlockId, maybeAncestor: import("./index.js").BlockId) => boolean;
-            ranksAt: (siblings: readonly {
-                rank: string;
-            }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-            writePlacement: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, p: import("./index.js").BlockId | null, r: string) => void;
+            placeBlocks: (doc: import("./engine-api.js").EngineDoc, v: import("./placement/model.js").ModelView, parent: import("./index.js").BlockId | null, left: import("./index.js").BlockId | null, right: import("./index.js").BlockId | null, slots: readonly import("./placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("./placement/slots.js").Unit | null) => void;
+            moveBlocksTo: (doc: import("./engine-api.js").EngineDoc, v: import("./placement/model.js").ModelView, ids: readonly import("./index.js").BlockId[], parent: import("./index.js").BlockId | null, index: number, side?: number, part?: number, at?: import("./index.js").BlockId | null) => void;
+            insertSpecsAt: (doc: import("./engine-api.js").EngineDoc, v: import("./placement/model.js").ModelView, parent: import("./index.js").BlockId | null, index: number, specs: readonly import("./index.js").BlockSpec[], split?: import("./placement/slots.js").Unit | null) => void;
             withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                 inserts: {
                     has(client: number, clock: number): boolean;
                 };
             }) => boolean;
-            materializeSpec: (doc: import("./engine-api.js").EngineDoc, sp: import("./index.js").BlockSpec, parent: import("./index.js").BlockId | null, rank: string) => void;
             collides: (doc: import("./engine-api.js").EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
-            writeSplit: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId, offset: number, newId: import("./index.js").BlockId, tail: import("./placement/model.js").SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+            writeSplit: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId, offset: number, newId: import("./index.js").BlockId, tail: import("./placement/model.js").SplitTail, parent: import("./index.js").BlockId | null, index: number) => import("./placement/slots.js").Unit;
             ownText: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => {
                 from: unknown;
                 to: number;
             };
+            recordsOf: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, v?: import("./placement/model.js").ModelView) => {
+                item: import("./placement/slots.js").SeqItem;
+                stamp: import("./placement/slots.js").Stamp;
+                wins: boolean;
+            }[];
             insertBlocks: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
             insertBlock: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
             restoreBlocks: (doc: import("./engine-api.js").EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
@@ -415,8 +416,8 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 at: number;
                 node: import("./engine-api.js").EngineNode;
             } | null;
-            splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
-            claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+            splitAt: (doc: import("./engine-api.js").EngineDoc, blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => void;
+            claimInto: (own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
             ownText: (doc: import("./engine-api.js").EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
                 from: unknown;
                 to: number;

package/dist/crdt/index.js

@@ -109,7 +109,7 @@ export { SchemaMismatchError, UndecodableUpdateError } from './admission.js';
 // the public read vocabulary; ordinary editing writes no per-edit
 // attribution.
 export {} from './attribution/index.js';
-// Compact per-BLOCK attribution read vocabulary (`b/<blockId>`
+// Compact per-BLOCK attribution read vocabulary (`blockattr` `<blockId>`
 // records + the block-node `l` attr — see `attribution/block.ts`).
 // `document.attribution.block(id)` / `document.blockAttribution(id)`
 // are the read entry points.

package/dist/crdt/placement/display.d.ts

@@ -1,38 +1,13 @@
 /**
  * Where a block displays: its display slot (read-time promotion out of a
  * deleted, childless or passing parent, the line and layout rules), the
- * children index and document order built from it, the text order of a
- * text's pieces (`textRanker`), liveness, and the inverse of the claim
- * owners. Pure over replicated state and the ownership the caller passes.
+ * children index and document order built from it, liveness, and the
+ * inverse of the claim owners. Pure over replicated state and the
+ * ownership the caller passes. The order of a text's pieces is the slots'
+ * (`order.split.text`: a split-born slot's key, fork patch YP22).
  */
 import { type Owner } from '../text/model.js';
-import type { BlockId, BlockRec, ChildSlot, DisplayOwnership, DocOrder, ModelView, ResolvedPlacement } from './model.js';
-/**
- * Split pieces in text order (`order.split.text`): the blocks whose streams lie in one
- * backing text and that still stand where they were made (their winning
- * placement is their first candidate, `1.<client>`: no move, outdent or
- * lift since) under one parent show in their streams' order in that text —
- * the order of the boundaries that delimit them, the same on every
- * replica — at the ranks they hold between them: the i-th of them in the
- * text takes the i-th smallest of their ranks. Ranks written at a split
- * (`sourceRank`) are a guess made on one replica's text; the boundaries are
- * the replicated fact, so two peers splitting one block at once keep the
- * text's order whatever each saw (an unseen edit after one's own split
- * point included). A block moved since stands where it was moved.
- *
- * `inText(home)`: the blocks of `home`'s text, in text order (segment 0's
- * first). Memoized per (text, parent) until `forget(home)`.
- */
-export declare const textRanker: (blocks: ReadonlyMap<BlockId, BlockRec>, placements: ReadonlyMap<BlockId, ResolvedPlacement>, homeOf: (b: BlockId) => BlockId | undefined, inText: (home: BlockId) => readonly BlockId[]) => {
-    rank: (id: BlockId, parent: BlockId | null, rank: string) => string;
-    /**
-     * Decide `home`'s text again (its segments or a member's placement
-     * changed); the blocks whose text-order rank changed.
-     */
-    regroup: (home: BlockId) => Set<BlockId>;
-    /** Drop what was decided for `home`'s text (every one, without it). */
-    forget: (home?: BlockId) => void;
-};
+import type { BlockId, ChildSlot, DisplayOwnership, DocOrder, ModelView, ResolvedPlacement } from './model.js';
 /**
  * THE liveness answer: `id` carries no live delete mark, owns
  * itself (`own.hidden` covers both: a delete-marked or unknown block owns

package/dist/crdt/placement/display.js

@@ -1,144 +1,13 @@
 /**
  * Where a block displays: its display slot (read-time promotion out of a
  * deleted, childless or passing parent, the line and layout rules), the
- * children index and document order built from it, the text order of a
- * text's pieces (`textRanker`), liveness, and the inverse of the claim
- * owners. Pure over replicated state and the ownership the caller passes.
+ * children index and document order built from it, liveness, and the
+ * inverse of the claim owners. Pure over replicated state and the
+ * ownership the caller passes. The order of a text's pieces is the slots'
+ * (`order.split.text`: a split-born slot's key, fork patch YP22).
  */
 import { DEAD } from '../text/model.js';
-import { promotedRank } from './source.js';
-/**
- * Split pieces in text order (`order.split.text`): the blocks whose streams lie in one
- * backing text and that still stand where they were made (their winning
- * placement is their first candidate, `1.<client>`: no move, outdent or
- * lift since) under one parent show in their streams' order in that text —
- * the order of the boundaries that delimit them, the same on every
- * replica — at the ranks they hold between them: the i-th of them in the
- * text takes the i-th smallest of their ranks. Ranks written at a split
- * (`sourceRank`) are a guess made on one replica's text; the boundaries are
- * the replicated fact, so two peers splitting one block at once keep the
- * text's order whatever each saw (an unseen edit after one's own split
- * point included). A block moved since stands where it was moved.
- *
- * `inText(home)`: the blocks of `home`'s text, in text order (segment 0's
- * first). Memoized per (text, parent) until `forget(home)`.
- */
-export const textRanker = (blocks, placements, homeOf, inText) => {
-    const memo = new Map();
-    const keysOf = new Map();
-    /** `b` stands where it was made: its placement is its first candidate's. */
-    const unmoved = (b) => {
-        const c = blocks.get(b)?.cands[0];
-        const pl = placements.get(b);
-        if (c === undefined || pl === undefined || c.seq !== 1 || c.r !== pl.rank)
-            return false;
-        return pl.parent === (c.p !== null && !blocks.has(c.p) ? null : c.p);
-    };
-    const group = (home, parent) => {
-        const members = [];
-        for (const b of inText(home))
-            if (placements.get(b)?.parent === parent && unmoved(b))
-                members.push(b);
-        const out = new Map();
-        if (members.length < 2)
-            return out;
-        const rankOf = (b) => placements.get(b).rank;
-        // One client's blocks keep its own order (it ranked them knowing each
-        // other); the text decides between different clients' (concurrent
-        // splits). Each client's members, sorted by rank, fill that client's
-        // places in the text order.
-        const byClient = new Map();
-        for (const b of members) {
-            const c = blocks.get(b).cands[0].client;
-            const list = byClient.get(c);
-            if (list === undefined)
-                byClient.set(c, [b]);
-            else
-                list.push(b);
-        }
-        if (byClient.size < 2)
-            return out;
-        for (const list of byClient.values())
-            list.sort((x, y) => bySlot({ id: x, rank: rankOf(x) }, { id: y, rank: rankOf(y) }));
-        const next = new Map();
-        const order = members.map((b) => {
-            const c = blocks.get(b).cands[0].client;
-            const i = next.get(c) ?? 0;
-            next.set(c, i + 1);
-            return byClient.get(c)[i];
-        });
-        const ranks = members.map(rankOf).sort();
-        order.forEach((b, i) => out.set(b, ranks[i]));
-        return out;
-    };
-    return {
-        rank: (id, parent, rank) => {
-            const home = homeOf(id);
-            // A text no other block shares (most blocks' own): nothing to order.
-            if (home === undefined || inText(home).length < 2)
-                return rank;
-            const key = `${home}\u0000${parent}`;
-            let ranks = memo.get(key);
-            if (ranks === undefined) {
-                memo.set(key, (ranks = group(home, parent)));
-                let keys = keysOf.get(home);
-                if (keys === undefined)
-                    keysOf.set(home, (keys = new Set()));
-                keys.add(key);
-            }
-            return ranks.get(id) ?? rank;
-        },
-        /**
-         * Decide `home`'s text again (its segments or a member's placement
-         * changed); the blocks whose text-order rank changed.
-         */
-        regroup: (home) => {
-            const before = new Map();
-            for (const key of keysOf.get(home) ?? [])
-                for (const [b, r] of memo.get(key) ?? [])
-                    before.set(b, r);
-            for (const key of keysOf.get(home) ?? [])
-                memo.delete(key);
-            const keys = new Set();
-            keysOf.set(home, keys);
-            const changed = new Set();
-            const parents = new Set();
-            const row = inText(home);
-            if (row.length >= 2)
-                for (const b of row) {
-                    const pl = placements.get(b);
-                    if (pl !== undefined)
-                        parents.add(pl.parent);
-                }
-            for (const parent of parents) {
-                const key = `${home}\u0000${parent}`;
-                const ranks = group(home, parent);
-                memo.set(key, ranks);
-                keys.add(key);
-                for (const [b, r] of ranks)
-                    if (before.get(b) !== r)
-                        changed.add(b);
-            }
-            for (const [b, r] of before) {
-                const now = memo.get(`${home}\u0000${placements.get(b)?.parent}`)?.get(b);
-                if (now !== r)
-                    changed.add(b);
-            }
-            return changed;
-        },
-        /** Drop what was decided for `home`'s text (every one, without it). */
-        forget: (home) => {
-            if (home === undefined) {
-                memo.clear();
-                keysOf.clear();
-                return;
-            }
-            for (const key of keysOf.get(home) ?? [])
-                memo.delete(key);
-            keysOf.delete(home);
-        }
-    };
-};
+import { claimedRank, promotedRank } from './keys.js';
 /**
  * THE liveness answer: `id` carries no live delete mark, owns
  * itself (`own.hidden` covers both: a delete-marked or unknown block owns
@@ -201,15 +70,13 @@ export const isLiveIn = (v, id) => {
  */
 export const displaySlotOf = (own, placements, pl, id) => {
     let { parent, rank } = pl;
-    // A piece of a text shown under its own placement's parent takes its text-order rank;
-    // a table's cell its column's (`table.columns`).
+    // A table's cell shown under its own placement's parent takes its column's rank
+    // (`table.columns`). Shown under its parent's claim owner (the parent merged away),
+    // it follows the owner's own children, by the claims down to its parent (`claimedRank`).
     const direct = (owner) => {
         if (owner !== pl.parent)
-            return rank;
-        const ruled = owner === null ? undefined : own.slotRank?.(owner, id, rank);
-        if (ruled !== undefined)
-            return ruled;
-        return own.textRank === undefined ? rank : own.textRank(id, owner, rank);
+            return claimedRank(claimPath(own, owner, pl.parent), rank);
+        return (owner === null ? undefined : own.slotRank?.(owner, id, rank)) ?? rank;
     };
     let reset = null;
     /** The first parent it is promoted out of (a deleted or childless one). */
@@ -240,8 +107,20 @@ export const displaySlotOf = (own, placements, pl, id) => {
         // Promoted into a container: it shows as one of its items.
         if (shows && reset === null && promoted !== null && own.container?.(owner) === true)
             reset = promoted;
+        // Under its parent's claim owner — promoted there or not — it is keyed in the
+        // owner's claimed space: the keys are local to one index, so a key of
+        // `parent`'s sequence compares with the owner's own children's on no replica
+        // but this one.
         if (shows)
-            return { parent: owner, rank: hops === 0 ? direct(owner) : rank, reset };
+            return {
+                parent: owner,
+                rank: owner !== parent
+                    ? claimedRank(claimPath(own, owner, parent), rank)
+                    : hops === 0
+                        ? direct(owner)
+                        : rank,
+                reset
+            };
         promoted ??= out;
         const up = placements.get(out);
         if (up === undefined || hops > placements.size)
@@ -253,6 +132,22 @@ export const displaySlotOf = (own, placements, pl, id) => {
     }
     return { parent: null, rank: pl.parent === null ? direct(null) : rank, reset };
 };
+/**
+ * The claims from `owner` down to `parent` (a block it displays through
+ * merge claims), as each holder's claim index: the order the merged blocks'
+ * children take after the owner's own children.
+ */
+const claimPath = (own, owner, parent) => {
+    const path = [];
+    for (let cur = parent, hops = 0; cur !== null && cur !== owner && hops < 256; hops++) {
+        const holder = own.top(cur);
+        if (holder === undefined)
+            break;
+        path.unshift(Math.max(0, own.claimIndex(holder, cur)));
+        cur = holder;
+    }
+    return path;
+};
 /**
  * The slot of `b` when it is a line — it displays (or, deleted, would
  * display) directly under a `lines` island ({@link DisplayOwnership.lined}) — else

package/dist/crdt/placement/keys.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Order keys — the in-memory keys the index sorts a parent's children by.
+ *
+ * A block's place is its slot in its parent's sequence (fork patch YP22:
+ * the engine orders slots and move records); nothing about the order is
+ * stored. The index still needs a comparable key per child, so that
+ * `displaySlotOf`'s promotion, the layout rules, `positionInView`'s binary
+ * search and `anchors.seam` keep working over `(rank, id)`-sorted lists:
+ * each child gets a key between its sequence neighbours' when it is placed
+ * (`keyBetween`), or a dense one when a whole sequence is read
+ * (`denseKey`). Keys are plain strings compared with `<`; they are local to
+ * one index and never leave it (two replicas may hold different keys for
+ * one order).
+ *
+ * Three key spaces compose with them:
+ *
+ * - a promoted child's key is its slot's key, {@link PROMOTED} and its own
+ *   ({@link promotedRank}): `PROMOTED` sorts below every key character, so
+ *   the promoted children follow the slot and precede the next sibling;
+ * - a merged-away block's children show after the owner's own children,
+ *   by the owner's claim order ({@link claimedRank}): {@link CLAIMED} sorts
+ *   above every key character;
+ * - a table's cells show in column order ({@link cellKey}).
+ */
+/** Sorts below every key character: the separator of a promoted child's key. */
+export declare const PROMOTED = "!";
+/**
+ * A key strictly between `a` and `b` (`undefined`: no bound). Both bounds
+ * are keys of this alphabet with `a < b`: place by place, a digit halfway
+ * between theirs when one fits, else `a`'s digit and one place deeper
+ * (classic fractional indexing). A key never ends in the lowest digit
+ * (`denseKey` writes none), so a key fits between any two.
+ */
+export declare const keyBetween: (a: string | undefined, b: string | undefined) => string;
+/** The `i`-th of a whole sequence's dense keys, in order (none ends in the lowest digit). */
+export declare const denseKey: (i: number) => string;
+/**
+ * The key of a block promoted into the slot keyed `slot` (read-time
+ * promotion, `del.blocks.promote`): after the slot, before every later key of
+ * the slot's list, in the promoted children's own order.
+ */
+export declare const promotedRank: (slot: string, rank: string) => string;
+/**
+ * The key of a child of a merged-away block shown under its owner: after the
+ * owner's own children, by the owner's claims (`path`: the claim index at
+ * each hop down to the child's parent), then the child's own key.
+ */
+export declare const claimedRank: (path: readonly number[], rank: string) => string;
+/**
+ * The key a table's cell displays at (`table.columns`): its column's
+ * position, before every unlisted column (`unlistedCellKey`) and the cells
+ * of no listed column (`LAST_CELL`).
+ */
+export declare const cellKey: (at: number) => string;
+/** A withdrawn cell's column the table no longer lists: after the listed ones, by `unlistedRank`. */
+export declare const unlistedCellKey: (hash: number) => string;
+/** A cell of no listed column: last (it does not display, `table.cell`). */
+export declare const LAST_CELL = "2";