edytor 3.0.0 → 5.0.0

package/dist/crdt/restore.js

@@ -1,7 +1,8 @@
-import { blockNodeOf, materializeSpec, ranksAt, view as modelView, writePlacement } from './placement/model.js';
+import { blockNodeOf, insertSpecsAt, moveBlocksTo, view as modelView } from './placement/model.js';
+import { suggestionsOf } from './doc/suggest.js';
 import { DEL_PREFIX, TYPE, WITHDRAW_PREFIX } from './schema.js';
-import { common, patchWrites, writeLeaves } from './data.js';
-import { canonKey } from './text/model.js';
+import { common, patchWrites, writeData } from './data.js';
+import { canonKey, deleteClaims } from './text/model.js';
 import { randOf } from './rand.js';
 import { toBlockSpec } from '../utils/json.js';
 /** `items` one unit each (a character with its marks, or an atom), keyed for comparison. */
@@ -117,15 +118,8 @@ export const restoreDocument = (doc, facade, json) => {
         const { blocks } = modelView(doc);
         for (const rec of blocks.values()) {
             // A deleted holder's claims are void (and stay so): only the others.
-            if (rec.deleted || rec.claimsNode === undefined)
-                continue;
-            // The claims its list stores (an anchor may show one in another block).
-            const named = (rec.listClaims ?? rec.claims)
-                .filter((claim) => all.has(claim.m))
-                .map((c) => c.seqIndex)
-                .filter((at) => at >= 0);
-            for (const at of named.sort((a, b) => b - a))
-                rec.claimsNode.delete(at, 1);
+            if (!rec.deleted)
+                deleteClaims(doc, rec.claims.filter((claim) => all.has(claim.m)));
         }
     }
     // 2 · Type and data, per leaf, where they differ.
@@ -135,7 +129,7 @@ export const restoreDocument = (doc, facade, json) => {
             continue;
         if (n.getAttr(TYPE) !== spec.type)
             n.setAttr(TYPE, spec.type);
-        writeLeaves(n, patchWrites(n, [{ path: [], value: spec.data ?? {} }], doc.clientID, randOf(doc)) ?? []);
+        writeData(n, patchWrites(n, [{ path: [], value: spec.data ?? {} }], doc.clientID, randOf(doc)) ?? []);
     }
     // 3 · Places, parent by parent in snapshot order (the root first).
     const parents = [[null, specs]];
@@ -145,36 +139,28 @@ export const restoreDocument = (doc, facade, json) => {
         if (list.length === 0)
             continue;
         const slots = facade.childSlots(parent);
-        const index = new Map(slots.map((slot, i) => [slot.id, i]));
         // What a longest common run of the two orders keeps stays where it is.
         const kept = new Set(common(slots.map((slot) => slot.id), list.map((spec) => spec.id)).map(([, j]) => j));
-        let prev;
+        let prev = null;
         list.forEach((spec, i) => {
             if (kept.has(i)) {
-                prev = slots[index.get(spec.id)].rank;
+                prev = spec.id;
                 return;
             }
-            let next;
-            for (let j = i + 1; j < list.length; j++)
-                if (kept.has(j)) {
-                    next = slots[index.get(list[j].id)].rank;
-                    break;
-                }
-            const bounds = [
-                ...(prev === undefined ? [] : [{ rank: prev }]),
-                ...(next === undefined ? [] : [{ rank: next }])
-            ];
-            const [rank] = ranksAt(bounds, prev === undefined ? 0 : 1, 1, doc.clientID, randOf(doc));
+            const v = modelView(doc);
+            // Right after the block before it in the snapshot (the list as it stands, the block itself left out).
+            const shown = (v.kids.get(parent) ?? []).map((k) => k.id).filter((id) => id !== spec.id);
+            const at = prev === null ? 0 : shown.indexOf(prev) + 1;
             const n = node(spec.id);
             if (n === null) {
-                materializeSpec(doc, { ...spec, children: [] }, parent, rank);
+                insertSpecsAt(doc, v, parent, at, [{ ...spec, children: [] }]);
                 report.created++;
             }
             else {
-                writePlacement(doc, n, parent, rank);
+                moveBlocksTo(doc, v, [spec.id], parent, at);
                 report.moved++;
             }
-            prev = rank;
+            prev = spec.id;
         });
     }
     // 4 · Content, where it differs: own claims removed, the stream rewritten.
@@ -183,10 +169,9 @@ export const restoreDocument = (doc, facade, json) => {
         let have = unitsOf(facade.contentItems(id));
         if (have.length === want.length && have.every((u, i) => u.key === want[i].key))
             continue;
-        const rec = modelView(doc).blocks.get(id);
-        const claims = rec?.claimsNode;
-        if (claims !== undefined && claims.length > 0) {
-            claims.delete(0, claims.length);
+        const claims = modelView(doc).blocks.get(id)?.claims ?? [];
+        if (claims.some((c) => c.stamp.c >= 0)) {
+            deleteClaims(doc, claims);
             have = unitsOf(facade.contentItems(id));
         }
         rewriteContent(facade, id, have, want);
@@ -212,5 +197,13 @@ export const restoreDocument = (doc, facade, json) => {
     }
     // 6 · The document's data.
     facade.apply(facade.prepare.patchData(null, [{ path: [], value: json.data ?? {} }]));
+    // 7 · Pending suggestions are dropped (`sugg.restore`): the version holds
+    // none (its document without them), so what the restore left of them —
+    // their proposals — is rejected, in the restore's step (its undo brings
+    // them back).
+    // (Built over the facade, its shared suggestions: `doc/suggest.ts`.)
+    const suggest = facade.part && suggestionsOf(facade);
+    if (suggest)
+        suggest.run(suggest.decide(suggest.changes(), false));
     return report;
 };

package/dist/crdt/schema.d.ts

@@ -5,7 +5,7 @@
  * facade module.
  */
 import type { EngineNode } from './engine-api.js';
-/** A replicated value that is a node (a block, its content, claims or `at` map, an atom). */
+/** A replicated value that is a node (a block, its content, an atom). */
 export declare const isNodeLike: (v: unknown) => v is EngineNode;
 /** Flat block registry root: blockId → node('block') (`SCHEMA.roots.registry`). */
 export declare const REGISTRY_KEY = "blocks";
@@ -13,21 +13,19 @@ export declare const REGISTRY_KEY = "blocks";
 export declare const META_ROOT_KEY = "meta";
 /** Attribution metadata root (`SCHEMA.roots.attribution`). */
 export declare const ATTRIBUTION_ROOT = "attribution";
-/** The per-block attribution root — `b/<blockId>` records (`SCHEMA.roots.blockAttribution`). */
-export declare const BLOCK_ATTR_ROOT = "blockattr";
 /**
- * Per-writer text delete marks (`text/deletes.ts`): one record per text
- * delete, naming the characters it deleted; its writer is the record's
- * engine client. In the history's scope, so an undo removes the undoer's
- * own mark and a redo writes it again.
+ * The per-block attribution root — one record per block, keyed by the block's
+ * id (`SCHEMA.roots.blockAttribution`): the string table writes the id once
+ * for its registry entry and its record (fork patch YP24).
  */
-export declare const TEXT_DELETES_ROOT = "textdel";
+export declare const BLOCK_ATTR_ROOT = "blockattr";
 /**
- * Restoration records (`text/deletes.ts`): which characters an undo's copies
- * restore, one attr per record (keyed by its writer and clock). Outside the
- * history's scope: a record is never removed.
+ * The text hold records (fork patch YP20): a text delete appends one record
+ * naming the characters it hides; its writer is the record's engine client.
+ * A character shows while no live record holds it. In the history's scope,
+ * so an undo deletes the undoer's own record and a redo writes it again.
  */
-export declare const RESTORED_ROOT = "restored";
+export declare const TEXT_DELETES_ROOT = "textdel";
 /**
  * The document's own data (`crdt/data.ts`): its leaves, as a block's. In the
  * history's scope.
@@ -41,13 +39,29 @@ export declare const DOC_DATA_ROOT = "docdata";
  */
 export declare const HORIZON_ROOT = "horizon";
 export declare const HORIZON_ATTR = "h";
+/**
+ * The ended histories (`hist.release.end`): a list of release records, one
+ * item per session whose history ended (its page left for good). A
+ * record's engine id names its writer and the clock it ended at: what that
+ * writer deleted before it (its delete and withdraw marks, its text hold
+ * records) no history can bring back, so the room's purge removes it at
+ * its next tick, past the horizon or not. The purge drops a record the
+ * horizon covers.
+ */
+export declare const RELEASE_ROOT = "released";
+/**
+ * The shared suggestions (`crdt/doc/suggest.ts`): attr `<id>` is one
+ * suggestion's record node, written by its writer (a client id bound to its
+ * author): its creation time `at`, `via` and `lbl`, and a list of id lists
+ * (fork patch YP31: its writer's proposed deletions, anyone else's settled
+ * ranges) and proposed operations. In the history's scope.
+ */
+export declare const SUGGEST_ROOT = "suggest";
 /** Named node roles (`SCHEMA.nodes`). */
 export declare const BLOCK_NODE = "block";
 export declare const CONTENT_NODE = "content";
-export declare const CLAIMS_NODE = "claims";
-export declare const AT_NODE = "at";
 export declare const INLINE_NODE = "inline";
-/** Attr keys on a block node (`SCHEMA.blockAttrs`). */
+/** Attr keys on a block node (`SCHEMA.blockAttrs`); `id` is an atom's own (a block's id is its registry key). */
 export declare const ID = "id";
 export declare const TYPE = "type";
 /** A block's or atom's whole data, as documents before 0.1.0-next.6 stored it: no longer read; the room's purge deletes it. */
@@ -84,14 +98,9 @@ export declare const hasWithdrawMark: (node: {
 /** The per-block `lastChangedBy` LWW attr (`SCHEMA.blockAttrs.lastChanged`). */
 export declare const LAST_CHANGED_ATTR = "l";
 export declare const CONTENT = "content";
-/** Ordered merge claims `{m: blockId}`. */
-export declare const CLAIMS = "claims";
-export declare const AT = "at";
-/** `b/<blockId>` record-key prefix on the `blockattr` root. */
-export declare const REC_PREFIX = "b/";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
-    readonly version: 6;
+    readonly version: 11;
     readonly name: "edytor-doc";
     readonly roots: {
         readonly registry: "blocks";

package/dist/crdt/schema.js

@@ -1,4 +1,4 @@
-/** A replicated value that is a node (a block, its content, claims or `at` map, an atom). */
+/** A replicated value that is a node (a block, its content, an atom). */
 export const isNodeLike = (v) => v != null && typeof v.getAttr === 'function';
 /** Flat block registry root: blockId → node('block') (`SCHEMA.roots.registry`). */
 export const REGISTRY_KEY = 'blocks';
@@ -6,21 +6,19 @@ export const REGISTRY_KEY = 'blocks';
 export const META_ROOT_KEY = 'meta';
 /** Attribution metadata root (`SCHEMA.roots.attribution`). */
 export const ATTRIBUTION_ROOT = 'attribution';
-/** The per-block attribution root — `b/<blockId>` records (`SCHEMA.roots.blockAttribution`). */
-export const BLOCK_ATTR_ROOT = 'blockattr';
 /**
- * Per-writer text delete marks (`text/deletes.ts`): one record per text
- * delete, naming the characters it deleted; its writer is the record's
- * engine client. In the history's scope, so an undo removes the undoer's
- * own mark and a redo writes it again.
+ * The per-block attribution root — one record per block, keyed by the block's
+ * id (`SCHEMA.roots.blockAttribution`): the string table writes the id once
+ * for its registry entry and its record (fork patch YP24).
  */
-export const TEXT_DELETES_ROOT = 'textdel';
+export const BLOCK_ATTR_ROOT = 'blockattr';
 /**
- * Restoration records (`text/deletes.ts`): which characters an undo's copies
- * restore, one attr per record (keyed by its writer and clock). Outside the
- * history's scope: a record is never removed.
+ * The text hold records (fork patch YP20): a text delete appends one record
+ * naming the characters it hides; its writer is the record's engine client.
+ * A character shows while no live record holds it. In the history's scope,
+ * so an undo deletes the undoer's own record and a redo writes it again.
  */
-export const RESTORED_ROOT = 'restored';
+export const TEXT_DELETES_ROOT = 'textdel';
 /**
  * The document's own data (`crdt/data.ts`): its leaves, as a block's. In the
  * history's scope.
@@ -34,13 +32,29 @@ export const DOC_DATA_ROOT = 'docdata';
  */
 export const HORIZON_ROOT = 'horizon';
 export const HORIZON_ATTR = 'h';
+/**
+ * The ended histories (`hist.release.end`): a list of release records, one
+ * item per session whose history ended (its page left for good). A
+ * record's engine id names its writer and the clock it ended at: what that
+ * writer deleted before it (its delete and withdraw marks, its text hold
+ * records) no history can bring back, so the room's purge removes it at
+ * its next tick, past the horizon or not. The purge drops a record the
+ * horizon covers.
+ */
+export const RELEASE_ROOT = 'released';
+/**
+ * The shared suggestions (`crdt/doc/suggest.ts`): attr `<id>` is one
+ * suggestion's record node, written by its writer (a client id bound to its
+ * author): its creation time `at`, `via` and `lbl`, and a list of id lists
+ * (fork patch YP31: its writer's proposed deletions, anyone else's settled
+ * ranges) and proposed operations. In the history's scope.
+ */
+export const SUGGEST_ROOT = 'suggest';
 /** Named node roles (`SCHEMA.nodes`). */
 export const BLOCK_NODE = 'block';
 export const CONTENT_NODE = 'content';
-export const CLAIMS_NODE = 'claims';
-export const AT_NODE = 'at';
 export const INLINE_NODE = 'inline';
-/** Attr keys on a block node (`SCHEMA.blockAttrs`). */
+/** Attr keys on a block node (`SCHEMA.blockAttrs`); `id` is an atom's own (a block's id is its registry key). */
 export const ID = 'id';
 export const TYPE = 'type';
 /** A block's or atom's whole data, as documents before 0.1.0-next.6 stored it: no longer read; the room's purge deletes it. */
@@ -73,16 +87,18 @@ export const hasWithdrawMark = (node) => [...node.attrKeys()].some((key) => key.
 /** The per-block `lastChangedBy` LWW attr (`SCHEMA.blockAttrs.lastChanged`). */
 export const LAST_CHANGED_ATTR = 'l';
 export const CONTENT = 'content';
-/** Ordered merge claims `{m: blockId}`. */
-export const CLAIMS = 'claims';
-export const AT = 'at';
-/** `b/<blockId>` record-key prefix on the `blockattr` root. */
-export const REC_PREFIX = 'b/';
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export const SCHEMA = {
-    // 6: one update encoding (the columnar one) on the wire and in storage;
-    // a container or frame of an earlier generation is refused.
-    version: 6,
+    // 7: a text delete is a hold record (fork patch YP20) on the wire and in
+    // storage; 8: a merge claim is an item `{m}` in a backing text (fork patch
+    // YP21), a block has no `claims` list; 9: a block's place is its home slot
+    // in its parent's sequence and a move is a move record (fork patch YP22),
+    // a block has no `at` map and an array item no rank; 10: the update encoding
+    // writes each distinct string once (fork patch YP24); 11: a hold record
+    // inside a nested node holds nothing (fork patch YP31: a suggestion's
+    // proposals and decisions). A container or frame of an earlier generation
+    // is refused.
+    version: 11,
     name: 'edytor-doc',
     roots: { registry: REGISTRY_KEY, meta: META_ROOT_KEY },
     metaAttrs: { version: 'v', schema: 'schema' }

package/dist/crdt/storage.d.ts

@@ -4,7 +4,7 @@
  * when that makes them smaller (`CompressionStream`, in every supported
  * browser, Node and Workers). A compressed record starts with gzip's magic
  * `1f 8b`, which no update does (its first byte is the encoder's feature
- * flag, `00`), so a record says itself whether it is compressed.
+ * flag, the encoding: `01`), so a record says itself whether it is compressed.
  * Worker-safe: no timers.
  */
 /** Whether `bytes` are gzip (its magic `1f 8b`). */

package/dist/crdt/storage.js

@@ -4,7 +4,7 @@
  * when that makes them smaller (`CompressionStream`, in every supported
  * browser, Node and Workers). A compressed record starts with gzip's magic
  * `1f 8b`, which no update does (its first byte is the encoder's feature
- * flag, `00`), so a record says itself whether it is compressed.
+ * flag, the encoding: `01`), so a record says itself whether it is compressed.
  * Worker-safe: no timers.
  */
 /** Whether `bytes` are gzip (its magic `1f 8b`). */

package/dist/crdt/structs.d.ts

@@ -24,6 +24,16 @@ export type StoreStruct = {
         client: number;
         clock: number;
     } | null;
+    /** Live hold records naming the item (fork patch YP20): a held item reads as deleted. */
+    holds?: number;
+    /** Whether the engine deleted it (`deleted` also covers a held or moved item). */
+    removed?: boolean;
+    /** Removed or held: shown nowhere (fork patch YP22; a moved item shows at its mover). */
+    gone?: boolean;
+    /** The live move records naming the item (fork patch YP22), `null` at home. */
+    movers?: StoreStruct[] | null;
+    /** The record that shows the item (the greatest `(priority, client, clock)` of `movers`). */
+    mover?: StoreStruct | null;
 };
 /**
  * The engine's IdSet shape (insertSet/deleteSet): per-client range lists —
@@ -85,8 +95,6 @@ export declare const followRedone: (Y: EngineApi, doc: EngineDoc, id: {
  * drops them the same way after a pop.
  */
 export declare const dropSearchMarkers: (node: unknown) => void;
-/** The clock `client`'s next struct gets in `doc`. */
-export declare const nextClock: (doc: EngineDoc, client: number) => number;
 /**
  * Whether `doc` holds updates it cannot integrate yet (vendor-internal
  * `store.pendingStructs`/`pendingDs`): an out-of-order delivery can apply
@@ -141,6 +149,11 @@ export type StoreLike = {
 };
 /** The doc's struct store (vendor `store`). */
 export declare const storeOf: (doc: EngineDoc | YDoc) => StoreLike;
+/**
+ * Whether `doc` holds every id `client:clock … clock+len-1` (none past its
+ * clock, none in a gap the engine fills later: vendor `store.skips`).
+ */
+export declare const holdsIds: (doc: EngineDoc, client: number, clock: number, len: number) => boolean;
 /** Whether `doc` collects deleted content at all (vendor `gc`). */
 export declare const collects: (doc: EngineDoc | YDoc) => boolean;
 /** Whether `doc`'s collection filter lets it collect `item` (vendor `gcFilter`). */
@@ -156,11 +169,6 @@ export declare const keepFromCollection: <I = StoreStruct>(doc: EngineDoc | YDoc
  * {@link collects} and {@link collectable}.
  */
 export declare const collectNow: (item: object, tr: unknown) => void;
-/**
- * Listen to `doc`'s transaction events (vendor `beforeTransaction`,
- * `afterTransaction`), with the caller's view of a transaction.
- */
-export declare const onTransaction: <T>(doc: EngineDoc | YDoc, event: "beforeTransaction" | "afterTransaction", f: (tr: T) => void) => void;
 /**
  * Whether a transaction changed one of `nodes` or a node under one: its
  * `changed` types and their ancestors (what a deep observer of `nodes`
@@ -189,8 +197,6 @@ export declare const engineOps: (Y: EngineApi) => {
     insertInto: (into: IdSetLike, from: IdSetLike) => void;
     /** Each struct `ids` covers, split at its edges, inside `tr`. */
     iterate: <I = StoreStruct>(tr: unknown, ids: IdSetLike, f: (item: I) => void) => void;
-    /** The item starting at `client:clock`, split there, inside `tr`. */
-    cleanStart: <I = StoreStruct>(tr: unknown, client: number, clock: number) => I;
     /**
      * Re-create deleted `item` (`redoItem`, fork patch YP18): its copy, or
      * `null` when it cannot come back. `items` are re-created with it (a
@@ -206,6 +212,8 @@ export declare const engineOps: (Y: EngineApi) => {
     merge: (sets: IdSetLike[]) => IdSetOf;
     /** Whether a store struct is an item (not a GC or a Skip). */
     isItem: (struct: unknown) => struct is StoreStruct;
+    /** Show again what a suggestion's deletes in `tr` proposed (fork patch YP32). */
+    unhide: (tr: unknown) => void;
     /** Whether `item` sits in `node`'s subtree. */
     inside: (node: EngineNode, item: StoreStruct) => boolean;
     /** Keep `item` (and its parents) from collection (`keepItem`). */
@@ -217,12 +225,6 @@ export declare const engineOps: (Y: EngineApi) => {
     /** Listen to a doc event (vendor `on`/`off`), with the caller's view of its arguments. */
     on: (doc: EngineDoc, event: string, f: (...args: never[]) => void) => void;
     off: (doc: EngineDoc, event: string, f: (...args: never[]) => void) => void;
-    /**
-     * Integrate a new item holding `content` right after `left` (its
-     * origin: `left`'s last id) in `parent`, written by `client` at
-     * `clock`, inside `tr`.
-     */
-    appendAfter: (tr: unknown, left: StoreStruct, parent: EngineNode, client: number, clock: number, content: unknown[]) => void;
     /** Whether `item` is a node value a concurrent write replaced and its doc keeps. */
     isKeptReplaced: (item: unknown) => boolean;
 };

package/dist/crdt/structs.js

@@ -121,12 +121,6 @@ export const dropSearchMarkers = (node) => {
     if (markers)
         markers.length = 0;
 };
-/** The clock `client`'s next struct gets in `doc`. */
-export const nextClock = (doc, client) => {
-    const structs = clientsOf(doc).get(client);
-    const last = structs?.[structs.length - 1];
-    return last === undefined ? 0 : last.id.clock + last.length;
-};
 /**
  * Whether `doc` holds updates it cannot integrate yet (vendor-internal
  * `store.pendingStructs`/`pendingDs`): an out-of-order delivery can apply
@@ -177,6 +171,14 @@ export const sequenceLength = (node) => node._length;
 export const itemOf = (node) => node._item;
 /** The doc's struct store (vendor `store`). */
 export const storeOf = (doc) => doc.store;
+/**
+ * Whether `doc` holds every id `client:clock … clock+len-1` (none past its
+ * clock, none in a gap the engine fills later: vendor `store.skips`).
+ */
+export const holdsIds = (doc, client, clock, len) => {
+    const store = doc;
+    return (clock + len <= store.store.getClock(client) && !store.store.skips.intersects(client, clock, len));
+};
 /** Whether `doc` collects deleted content at all (vendor `gc`). */
 export const collects = (doc) => doc.gc;
 /** Whether `doc`'s collection filter lets it collect `item` (vendor `gcFilter`). */
@@ -196,11 +198,6 @@ export const keepFromCollection = (doc, keep) => {
  * {@link collects} and {@link collectable}.
  */
 export const collectNow = (item, tr) => item.gc(tr, false);
-/**
- * Listen to `doc`'s transaction events (vendor `beforeTransaction`,
- * `afterTransaction`), with the caller's view of a transaction.
- */
-export const onTransaction = (doc, event, f) => doc.on(event, f);
 /**
  * Whether a transaction changed one of `nodes` or a node under one: its
  * `changed` types and their ancestors (what a deep observer of `nodes`
@@ -229,8 +226,6 @@ export const engineOps = (Y) => {
         insertInto: (into, from) => Y.insertIntoIdSet(into, from),
         /** Each struct `ids` covers, split at its edges, inside `tr`. */
         iterate: (tr, ids, f) => Y.iterateStructsByIdSet(tr, ids, f),
-        /** The item starting at `client:clock`, split there, inside `tr`. */
-        cleanStart: (tr, client, clock) => Y.getItemCleanStart(tr, Y.createID(client, clock)),
         /**
          * Re-create deleted `item` (`redoItem`, fork patch YP18): its copy, or
          * `null` when it cannot come back. `items` are re-created with it (a
@@ -243,6 +238,8 @@ export const engineOps = (Y) => {
         merge: (sets) => Y.mergeIdSets(sets),
         /** Whether a store struct is an item (not a GC or a Skip). */
         isItem: (struct) => struct instanceof Y.Item,
+        /** Show again what a suggestion's deletes in `tr` proposed (fork patch YP32). */
+        unhide: (tr) => Y.unhide(tr),
         /** Whether `item` sits in `node`'s subtree. */
         inside: (node, item) => Y.isParentOf(asYNode(node), item),
         /** Keep `item` (and its parents) from collection (`keepItem`). */
@@ -262,15 +259,6 @@ export const engineOps = (Y) => {
         /** Listen to a doc event (vendor `on`/`off`), with the caller's view of its arguments. */
         on: (doc, event, f) => doc.on(event, f),
         off: (doc, event, f) => doc.off(event, f),
-        /**
-         * Integrate a new item holding `content` right after `left` (its
-         * origin: `left`'s last id) in `parent`, written by `client` at
-         * `clock`, inside `tr`.
-         */
-        appendAfter: (tr, left, parent, client, clock, content) => {
-            const item = new Y.Item(Y.createID(client, clock), left, left.lastId, null, null, asYNode(parent), null, new Y.ContentAny(content));
-            item.integrate(tr, 0);
-        },
         /** Whether `item` is a node value a concurrent write replaced and its doc keeps. */
         isKeptReplaced: (item) => Y.isKeptReplaced(item)
     };

package/dist/crdt/text/index/cache.js

@@ -32,12 +32,16 @@ export const indexCache = (ix) => {
         get foldedStructs() {
             return foldStats.structs;
         },
+        get placements() {
+            return foldStats.placed;
+        },
         reset() {
             debug.recomputes = 0;
             debug.recomputed.clear();
             foldStats.folds = 0;
             foldStats.pairs = 0;
             foldStats.structs = 0;
+            foldStats.placed = 0;
             rangeStats.items = 0;
             rangeStats.markers = 0;
         }

package/dist/crdt/text/index/claims.js

@@ -1,4 +1,4 @@
-import { DEAD, claimGraph, cmpStamp } from '../model.js';
+import { DEAD, cmpStamp } from '../model.js';
 import { addTo, dropFrom } from './shared.js';
 /** The claim graph of one doc's index, over its state. */
 export const indexClaims = (ix) => {
@@ -16,7 +16,6 @@ export const indexClaims = (ix) => {
     const topInv = new Map();
     /** Claimed block → the blocks whose claims list names it (live or not). */
     const claimersOf = new Map();
-    let ownersBuilt = false;
     /** The max-stamp claim on `m` held by a live block. */
     const topClaim = (m) => {
         let best;
@@ -91,32 +90,12 @@ export const indexClaims = (ix) => {
             addTo(displaysMap, to, b);
     };
     const ensureOwners = () => {
-        if (!ownersBuilt) {
-            ownersBuilt = true;
-            ownerSeeds.clear();
-            const graph = claimGraph(blocks);
-            owners.clear();
-            for (const [b, o] of graph.owners)
-                if (blocks.has(b))
-                    owners.set(b, o);
-            topOf.clear();
-            topInv.clear();
-            claimersOf.clear();
-            for (const [holder, rec] of blocks)
-                for (const c of rec.claims)
-                    addTo(claimersOf, c.m, holder);
-            for (const m of claimersOf.keys())
-                setTop(m, topClaim(m));
-            displaysMap.clear();
-            for (const b of blocks.keys())
-                setDisplay(b, undefined, owners.get(b));
-            return;
-        }
         if (ownerSeeds.size === 0)
             return;
         // The tops a seed's claims (now, and those it dropped: noted in `claimersOf` changes) decide.
         const affected = new Set();
         const stack = [];
+        const seeds = [...ownerSeeds];
         for (const x of ownerSeeds) {
             stack.push(x);
             for (const m of claimTargets.get(x) ?? [])
@@ -150,6 +129,17 @@ export const indexClaims = (ix) => {
             setDisplay(x, was, now);
             ownerChanged.add(x);
         }
+        // A holder whose claims changed re-slots what shows through them: their
+        // order among its claims is the key of the blocks shown under it
+        // (`claimedRank`) — under its owner when it is itself merged away.
+        for (const x of seeds) {
+            if (!blocks.has(x))
+                continue;
+            ownerChanged.add(x);
+            const o = owners.get(x);
+            if (typeof o === 'string' && o !== x)
+                ownerChanged.add(o);
+        }
     };
     /** The claims each seed held before its record changed (their tops are re-decided too). */
     const claimTargets = new Map();

package/dist/crdt/text/index/fold.d.ts

@@ -1,6 +1,5 @@
-import { type BlockId } from '../../placement/model.js';
+import type { BlockId } from '../../placement/model.js';
 import type { ContentRun } from '../runs.js';
-import type { IndexAnchored } from './anchored.js';
 import type { IndexCache } from './cache.js';
 import type { IndexClaims } from './claims.js';
 import type { IndexPlacement } from './placement.js';
@@ -9,7 +8,7 @@ import type { FoldCtx, IndexState, Tx } from './state.js';
 import type { IndexStreams } from './streams.js';
 import type { IndexLayout } from './layout.js';
 /** The fold of one doc's index, over every part it folds into. */
-export declare const indexFold: (ix: IndexState & IndexClaims & IndexStreams & IndexAnchored & IndexLayout & IndexPlacement & IndexRecords & IndexCache) => {
+export declare const indexFold: (ix: IndexState & IndexClaims & IndexStreams & IndexLayout & IndexPlacement & IndexRecords & IndexCache) => {
     runs: (b: BlockId) => readonly ContentRun[];
     settle: (affected: Iterable<BlockId>, ctx: FoldCtx | null) => void;
     syncPending: (tr: Tx | null | undefined) => boolean;