edytor 0.1.0-next.21 → 0.1.0-next.22

package/dist/crdt/edytor-doc.js

@@ -118,7 +118,7 @@ import { bindBlockAttribution, blockAttributionOf } from './attribution/block.js
 import { isLegacyDoc } from './migration/legacy-schema.js';
 import { rangeDeleteOps } from './rangeDelete.js';
 import { flowOps } from './flow.js';
-import { dataLeaves, isObject, itemIds, patchWrites, readData, writeLeaves } from './data.js';
+import { dataLeaves, isObject, itemIds, leafKey, patchWrites, readData, writeLeaves } from './data.js';
 import { id as newId } from '../utils.js';
 import { cloneJsonSafe, jsonBlockToSpec, jsonEquals, sanitizeSpec, sanitizeWireJson, sanitizeWireString } from '../utils/json.js';
 // ── schema manifest ─────────────────────────────────────────────────────
@@ -249,6 +249,10 @@ export const assertUsableDoc = (doc) => {
  * counterpart of `DocumentDestroyedError` — kept in this module because a
  * bare `bindEdytorDoc` facade has no document layer above it.
  */
+/** The undo steps a document's history keeps by default (P6): older ones are released. */
+export const DEFAULT_HISTORY_LIMIT = 200;
+/** The origin of the transaction that releases a dropped history step's content. */
+const HISTORY_TRIM = Symbol('edytor.history.trim');
 export class EdytorDocDisposedError extends Error {
     constructor(service) {
         super(`EdytorDoc${service ? `.${service}` : ''}: facade is disposed.`);
@@ -1071,10 +1075,11 @@ export const bindEdytorDoc = (Y) => {
                         node.setAttr(key, value);
             }
         };
-        const createUndoManager = (opts = {}) => {
+        const createUndoManager = (options = {}) => {
             if (disposed) {
                 throw new EdytorDocDisposedError('createUndoManager');
             }
+            const { limit = DEFAULT_HISTORY_LIMIT, ...opts } = options;
             write(() => {
                 if (!isInitialized(doc))
                     init(doc);
@@ -1102,6 +1107,43 @@ export const bindEdytorDoc = (Y) => {
             };
             um.on('stack-item-added', skipOwnText);
             um.on('stack-item-updated', skipOwnText);
+            // P6: the undo stack keeps its newest `limit` steps. A step that
+            // falls off releases what it kept for its undo (its deleted items),
+            // and the engine collects their content now, as it would have at
+            // the delete without a history (the doc's `gcFilter` still decides:
+            // a text copy another replica may have to copy again stays, P11).
+            // An item is released only once every step that deleted part of it
+            // fell off (the engine merges deleted items across steps): never
+            // split, so the store keeps its merged items. Only the items
+            // themselves are released: a kept container's flag may guard a
+            // newer step's items inside it.
+            const released = Y.createIdSet();
+            const covered = (st) => {
+                const end = st.id.clock + st.length;
+                return (released.clients.get(st.id.client)?.getIds() ?? []).some((r) => r.clock <= st.id.clock && end <= r.clock + r.len);
+            };
+            const trim = ({ type }) => {
+                const over = um.undoStack.length - limit;
+                if (type !== 'undo' || !(over > 0))
+                    return;
+                const dropped = um.undoStack.splice(0, over);
+                for (const step of dropped)
+                    Y.insertIntoIdSet(released, step.deletes);
+                const gc = doc.gc;
+                const keepIt = doc.gcFilter;
+                doc.transact((tr) => {
+                    for (const step of dropped)
+                        walkIdSetStructs(Y, doc, step.deletes, (st) => {
+                            const it = st;
+                            if (it.content === undefined || it.keep !== true || !covered(it))
+                                return;
+                            it.keep = false;
+                            if (gc && it.deleted && keepIt(it))
+                                it.gc(tr, false);
+                        });
+                }, HISTORY_TRIM);
+            };
+            um.on('stack-item-added', trim);
             // Lineage for undo/redo (O19, F4): the replay displaces the state
             // every block the popped stack item touches, so each one's subtree
             // is captured (`force`: lost whoever owns `l`) from the history
@@ -1226,7 +1268,7 @@ export const bindEdytorDoc = (Y) => {
             const i = T.resolveAnchor(doc, text, anchor.a);
             if (i === null)
                 return null;
-            const s = own.streamsIn(anchor.b).find((x) => x.start <= i && i <= x.end);
+            const s = own.streamAt(anchor.b, i);
             const owner = s === undefined ? DEAD : own.ownerOf(s.block);
             if (typeof owner !== 'string' || !isLiveIn(view(), owner))
                 return null;
@@ -1270,11 +1312,30 @@ export const bindEdytorDoc = (Y) => {
         });
         /** This client's next clock: what its source ranks are tied by (`sourceRank`, DW-05). */
         const clock = () => doc.store?.getClock(doc.clientID) ?? 0;
-        /** `count` ranks at `index` among `parent`'s children, the moving `exclude` left out. */
-        const ranksFor = (parent, index, count, exclude = []) => {
-            const sibs = (view().kids.get(parent) ?? []).filter((k) => !exclude.includes(k.id));
-            const at = Math.max(0, Math.min(index, sibs.length));
-            return M.ranksAt(sibs, at, count, doc.clientID, randOf(doc));
+        /**
+         * `count` ranks at `index` among `parent`'s children, the moving
+         * `exclude` left out. `run`: new blocks, which extend this client's run
+         * after a block it ranked (H1, `order.insert.run`); a move never does
+         * (the rank-growth guard).
+         */
+        const ranksFor = (parent, index, count, exclude = [], run = false) => {
+            const v = view();
+            const all = v.kids.get(parent) ?? [];
+            // The moving blocks' own slots left out: index → the list's index past them.
+            const gone = exclude
+                .map((id) => M.positionInView(v, id))
+                .filter((p) => p !== null && p.parent === parent)
+                .map((p) => p.index)
+                .sort((a, b) => a - b);
+            const raw = (i) => {
+                for (const g of gone)
+                    if (g <= i)
+                        i++;
+                return i;
+            };
+            const at = Math.max(0, Math.min(index, all.length - gone.length));
+            const pair = [at > 0 ? all[raw(at - 1)] : undefined, all[raw(at)]];
+            return M.ranksAt(pair, 1, count, doc.clientID, randOf(doc), run);
         };
         /**
          * Move `ids` to `ranks` under `parent` (`index`: the slot hooks see).
@@ -1380,7 +1441,12 @@ export const bindEdytorDoc = (Y) => {
         const dataSteps = (target, patches) => {
             const [id, inlineId] = typeof target === 'object' && target ? [target.block, target.atom] : [target ?? undefined];
             const node = dataNode(id, inlineId);
-            const leaves = node ? patchWrites(node, patches, doc.clientID, randOf(doc)) : [];
+            // A block kind's atomic paths are written as one leaf each (`data.atomic`, H8).
+            const type = inlineId === undefined && id !== undefined ? blockTypeOf(id) : undefined;
+            const atomic = (type === undefined ? undefined : roleOf(type)?.atomic) ?? [];
+            const leaves = node
+                ? patchWrites(node, patches, doc.clientID, randOf(doc), atomic.map((p) => leafKey(typeof p === 'string' ? [p] : p)))
+                : [];
             if (leaves === null)
                 return null; // a patch fits no value there
             if (leaves.length === 0)
@@ -1400,6 +1466,26 @@ export const bindEdytorDoc = (Y) => {
         const replaceData = (data) => [
             { path: [], value: sanitizeWireJson(data) }
         ];
+        /**
+         * `data`'s leaves as sets over `current` (`data.retype.keep`, H4): a
+         * plain object's keys, recursively where `current` holds an object
+         * there too; anything else (an array, a primitive, an empty object, an
+         * object where `current` holds none) as one value at its path. Nothing
+         * else under the root is touched.
+         */
+        const leafSets = (data, current) => {
+            const out = [];
+            const plainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+            const walk = (v, at, path) => {
+                if (plainObject(v) && Object.keys(v).length > 0 && (path.length === 0 || plainObject(at)))
+                    for (const [k, x] of Object.entries(v))
+                        walk(x, plainObject(at) ? at[k] : undefined, [...path, k]);
+                else if (path.length > 0)
+                    out.push({ path, value: v });
+            };
+            walk(sanitizeWireJson(data), current, []);
+            return out;
+        };
         /**
          * The kind `kid` shows once it leaves `from` for a slot under `parent`
          * — the island and container rules, one answer:
@@ -1602,7 +1688,7 @@ export const bindEdytorDoc = (Y) => {
                 return plan([], []);
             if ((parent !== null && !live(parent)) || M.collides(doc, clean))
                 return REFUSED;
-            const ranks = ranksFor(parent, dest.index, clean.length);
+            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 }]);
         };
         /**
@@ -1700,7 +1786,7 @@ export const bindEdytorDoc = (Y) => {
             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);
+                const ranks = ranksFor(parent, index + 1, specs.length, [], true);
                 return plan(placed, [...insert(parent, index + 1, specs, ranks), ...retype]);
             }
             // Bottom up: what stays before the split at each level (the level
@@ -2265,8 +2351,11 @@ export const bindEdytorDoc = (Y) => {
             return steps ? plan(t === null ? [] : [typeof t === 'string' ? t : t.block], steps) : REFUSED;
         };
         /**
-         * Baseline `setBlock`: `type`/`data` update the block in place;
-         * `content`/`children` REPLACE wholesale — explicit replacement is a
+         * Baseline `setBlock`: `type` updates the block in place and `data`
+         * sets the leaves it names, removing none (`data.retype.keep`, H4: a
+         * retype keeps the block's properties, as Notion's Turn into does;
+         * `setBlockData` replaces them); `content`/`children` REPLACE
+         * wholesale — explicit replacement is a
          * new-identity operation; a retype to a void kind without `children`
          * unnests the current ones (`retypeSteps`). All-or-nothing (D-12): children
          * for a block that is `void` after the write, or a replacement id that
@@ -2287,13 +2376,16 @@ export const bindEdytorDoc = (Y) => {
                 return REFUSED;
             if (children !== undefined && M.collides(doc, children))
                 return refused('id-collision');
+            const data = value.data === undefined ? [] : dataSteps(id, leafSets(value.data, blockDataOf(id)));
+            if (data === null)
+                return REFUSED;
             const writes = [
                 ...(type === undefined
                     ? []
                     : children === undefined
                         ? retypeSteps(id, type)
                         : attr(id, TYPE, type)),
-                ...((value.data !== undefined && dataSteps(id, replaceData(value.data))) || [])
+                ...data
             ];
             if (content !== undefined) {
                 const length = displayLength(id);
@@ -2451,6 +2543,7 @@ export const bindEdytorDoc = (Y) => {
             insideItem: (id) => insideItem(id),
             tailOf: (id) => ({ type: kindToCopy(id), data: blockDataOf(id) }),
             ranksFor,
+            insertRanks: (parent, index, count) => ranksFor(parent, index, count, [], true),
             pieceRanks,
             redata: (id, data) => dataSteps(id, replaceData(data)) ?? [],
             deleteBlocks: (ids, filled) => deleteBlocks(ids, false, filled),

package/dist/crdt/flow.d.ts

@@ -87,6 +87,8 @@ export type FlowContext = RangeDeleteContext & {
     insideItem: (id: BlockId) => boolean;
     tailOf: (id: BlockId) => SplitTail;
     ranksFor: (parent: BlockId | null, index: number, count: number) => string[];
+    /** `ranksFor` for new blocks: after a block this client ranked, in its run there (H1). */
+    insertRanks: (parent: BlockId | null, index: number, count: number) => string[];
     /** Ranks for the `count` blocks a split of `id` at `at` puts after it, by that offset. */
     pieceRanks: (id: BlockId, at: number, count: number) => string[];
     redata: (id: BlockId, data: Record<string, unknown>) => PlanStep[];

package/dist/crdt/flow.js

@@ -190,13 +190,13 @@ export const flowOps = (c) => ({
         // 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));
+            place(index, c.insertRanks(parent, index, placed.length));
             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);
+                    const ranks = c.insertRanks(parent, index + 1, after.length);
                     const slot = index + placed.length + 1;
                     writes.push({ op: 'insertBlocks', parent, index: slot, specs: after, ranks });
                 }

package/dist/crdt/index.d.ts

@@ -168,7 +168,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 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) => 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;
                 withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                     inserts: {
@@ -277,7 +277,9 @@ export declare const bindCrdt: (Y: EngineApi) => {
             checkSchema: () => import("./edytor-doc.js").SchemaProblem | null;
             assertSchema: () => void;
             dispose: () => void;
-            createUndoManager: (opts?: ConstructorParameters<EngineApi["UndoManager"]>[1]) => import("./engine-api.js").YUndoManager;
+            createUndoManager: (options?: ConstructorParameters<EngineApi["UndoManager"]>[1] & {
+                limit?: number;
+            }) => import("./engine-api.js").YUndoManager;
             project: () => import("./index.js").ProjectedDoc;
             toJSON: () => import("./index.js").JSONDoc;
             blockJSON: (id: string) => import("./index.js").JSONBlock;
@@ -360,7 +362,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
             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) => 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;
             withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                 inserts: {
@@ -627,7 +629,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
 };
 export type Crdt = ReturnType<typeof bindCrdt>;
 export type { EngineApi, EngineDoc, EngineNode, EngineDeepEvent, EngineTransaction, EngineItemRef, YNode, YItem } from './engine-api.js';
-export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError } from './edytor-doc.js';
+export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError, DEFAULT_HISTORY_LIMIT } from './edytor-doc.js';
 export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion, type GenerationRecord } from './protocols/envelope.js';
 export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, MAX_FRAME_BYTES, chunkFrame, createChunkReader } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate, type SyncProtocol } from './protocols/sync.js';

package/dist/crdt/index.js

@@ -155,7 +155,7 @@ export const bindCrdt = (Y) => {
 // hibernation), the store-before-ack frame (`messageSaved`) and the bounded
 // catch-up codec (`chunkFrame`/`createChunkReader`, `messageChunk`).
 // `pnpm check:worker` keeps this graph Worker-safe.
-export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError } from './edytor-doc.js';
+export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError, DEFAULT_HISTORY_LIMIT } from './edytor-doc.js';
 export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
 export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, MAX_FRAME_BYTES, chunkFrame, createChunkReader } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate } from './protocols/sync.js';

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

@@ -342,6 +342,14 @@ export declare const displayParentOf: (own: DisplayOwnership, pl: ResolvedPlacem
  * promoted one ({@link displaySlotOf}).
  */
 export declare const childrenIndex: (placements: Map<BlockId, ResolvedPlacement>, own: DisplayOwnership) => Map<BlockId | null, ChildSlot[]>;
+/** The order of a children list: by rank, ties by id. */
+export declare const bySlot: (a: {
+    id: BlockId;
+    rank: string;
+}, b: {
+    id: BlockId;
+    rank: string;
+}) => number;
 /**
  * Document order (O7): ONE pre-order over the visible blocks of a children
  * index — `ids` in reading order, `at` the position of each id. Every
@@ -376,7 +384,7 @@ export declare const bindModel: (Y: EngineApi) => {
     isSelfOrDescendant: (placements: Map<BlockId, ResolvedPlacement>, own: Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
     ranksAt: (siblings: readonly {
         rank: string;
-    }[], index: number, count: number, clientId: number, rand?: () => number) => string[];
+    }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
     writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
     withdrawOnUndo: (doc: EngineDoc) => (item: EngineItemRef, stackItem: {
         inserts: {

package/dist/crdt/placement/model.js

@@ -1,4 +1,4 @@
-import { decodeRank, encodeRank, rankBetween, RANK_VMIN } from './rank.js';
+import { decodeRank, encodeRank, rankAfter, rankBetween, RANK_VMIN } from './rank.js';
 import { AT, AT_NODE, BLOCK_NODE, CONTENT, CONTENT_NODE, DEL_PREFIX, hasDeleteMark, ID, CLAIMS, CLAIMS_NODE, INLINE_NODE, isNodeLike, NONCE, REGISTRY_KEY, TYPE, WITHDRAW_PREFIX } from '../schema.js';
 import { nonceOf, randOf } from '../rand.js';
 import { bindRuns } from '../text/runs.js';
@@ -409,11 +409,12 @@ export const childrenIndex = (placements, own) => {
         else
             index.set(parent, [slot]);
     }
-    for (const bucket of index.values()) {
-        bucket.sort((a, b) => a.rank === b.rank ? a.id.localeCompare(b.id) : a.rank < b.rank ? -1 : 1);
-    }
+    for (const bucket of index.values())
+        bucket.sort(bySlot);
     return index;
 };
+/** The order of a children list: by rank, ties by id. */
+export const bySlot = (a, b) => (a.rank === b.rank ? a.id.localeCompare(b.id) : a.rank < b.rank ? -1 : 1);
 export const documentOrder = (kids) => {
     const ids = [];
     const at = new Map();
@@ -559,9 +560,10 @@ export const bindModel = (Y) => {
      * so each new member takes `left` verbatim: it JOINS the tie and the
      * `(rank, id)` display sort orders the whole group deterministically.
      * On a valid seam the emitted chain is `rankBetween(left, right)` then
-     * `rankBetween(prev, right)`.
+     * `rankBetween(prev, right)` — with `run`, `rankAfter` (an insert: after a
+     * block this client ranked, in its run there, H1).
      */
-    const ranksAt = (siblings, index, count, clientId, rand) => {
+    const ranksAt = (siblings, index, count, clientId, rand, run = false) => {
         let left = siblings[index - 1]?.rank;
         const right = siblings[index]?.rank;
         if (left !== undefined && right !== undefined && left >= right) {
@@ -569,7 +571,10 @@ export const bindModel = (Y) => {
         }
         const out = [];
         for (let i = 0; i < count; i++) {
-            const r = rankBetween(left, right, clientId, rand);
+            // An insert extends this client's run after a block it ranked (H1).
+            const r = run
+                ? rankAfter(left, right, clientId, rand)
+                : rankBetween(left, right, clientId, rand);
             out.push(r);
             left = r;
         }
@@ -749,12 +754,26 @@ export const bindModel = (Y) => {
      * slot ({@link displaySlotOf}). Content is each block's display (R2).
      */
     const project = (doc) => ({ children: R.attach(doc).project() });
-    /** `positionOf` in a view: the display parent and the index among its visible children. */
+    /**
+     * `positionOf` in a view: the display parent and the index among its
+     * visible children — a binary search by the block's display rank (the
+     * list's own order), not a scan of its siblings.
+     */
     const positionInView = (v, id) => {
         if (!isLiveIn(v, id))
             return null;
-        const dp = displayParentOf(v.own, v.placements.get(id), v.placements, id);
-        const index = (v.kids.get(dp) ?? []).findIndex((s) => s.id === id);
+        const slot = displaySlotOf(v.own, v.placements, v.placements.get(id), id);
+        const dp = slot.parent;
+        const list = v.kids.get(dp) ?? [];
+        let [lo, hi] = [0, list.length];
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (bySlot(list[mid], { id, rank: slot.rank }) < 0)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        const index = list[lo]?.id === id ? lo : list.findIndex((s) => s.id === id);
         return index < 0 ? null : { parent: dp, index };
     };
     /**

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

@@ -55,3 +55,23 @@ export declare const decodeRank: (rank: string) => RankSeg[];
 /** Encode segments back to the persisted string form. */
 export declare const encodeRank: (segs: readonly RankSeg[]) => string;
 export declare const rankBetween: (left: string | undefined, right: string | undefined, clientId: number, rand?: () => number) => string;
+/**
+ * The digit of the run marker data arrays wrote up to 0.1.0-next.21 (a run
+ * of that form is the marker segment, then ranks of the client's own): still
+ * read as a run, so what a client inserts there stays in it.
+ */
+export declare const RANK_RUN: number;
+/**
+ * A rank in `(left, right)` for an insert right after `left` — one rule for
+ * array items (`crdt/data.ts`) and inserted blocks (H1, `order.insert.run`).
+ * When `client` made `left`, the rank is in the client's run after it: `left`
+ * itself as the prefix, then one segment of the run band — or, when `left`
+ * is already a member of the client's run, that run's prefix and a member
+ * between `left` and the next one. So what one client inserts after its own
+ * items stays together whatever a peer inserts in that gap meanwhile: a
+ * peer's rank there is either no extension of the run's prefix (it sorts
+ * after the whole run) or one whose next digit is above the band (YATA's
+ * origin rule, as `Y.Array` keeps an insert after its origin). Elsewhere, or
+ * when the run rank would not sort below `right`, a plain {@link rankBetween}.
+ */
+export declare const rankAfter: (left: string | undefined, right: string | undefined, client: number, rand?: () => number) => string;

package/dist/crdt/placement/rank.js

@@ -207,3 +207,82 @@ export const rankBetween = (left, right, clientId, rand = Math.random) => {
         path.push(lSeg);
     }
 };
+/**
+ * The digit of the run marker data arrays wrote up to 0.1.0-next.21 (a run
+ * of that form is the marker segment, then ranks of the client's own): still
+ * read as a run, so what a client inserts there stays in it.
+ */
+export const RANK_RUN = -(2 ** 39);
+/**
+ * A run member's digit lies in `(RANK_RUN, RANK_RUN + RUN_BAND)`: below every
+ * digit a plain rank extends a prefix with (`0`, an append's), far above the
+ * digit minimum. A run opens at {@link RUN_START}, the middle of the band, so
+ * its members can be inserted before and after one another.
+ */
+const RUN_BAND = 2 ** 38;
+const RUN_START = RANK_RUN + 2 ** 37;
+const inRun = (v) => v > RANK_RUN && v < RANK_RUN + RUN_BAND;
+/**
+ * A rank in `(left, right)` for an insert right after `left` — one rule for
+ * array items (`crdt/data.ts`) and inserted blocks (H1, `order.insert.run`).
+ * When `client` made `left`, the rank is in the client's run after it: `left`
+ * itself as the prefix, then one segment of the run band — or, when `left`
+ * is already a member of the client's run, that run's prefix and a member
+ * between `left` and the next one. So what one client inserts after its own
+ * items stays together whatever a peer inserts in that gap meanwhile: a
+ * peer's rank there is either no extension of the run's prefix (it sorts
+ * after the whole run) or one whose next digit is above the band (YATA's
+ * origin rule, as `Y.Array` keeps an insert after its origin). Elsewhere, or
+ * when the run rank would not sort below `right`, a plain {@link rankBetween}.
+ */
+export const rankAfter = (left, right, client, rand = Math.random) => {
+    const plain = () => rankBetween(left, right, client, rand);
+    if (left === undefined)
+        return plain();
+    const segs = decodeRank(left);
+    const last = segs.at(-1);
+    const bottom = encodeRank([{ v: RANK_RUN, t: 0 }]);
+    const top = encodeRank([{ v: RANK_RUN + RUN_BAND, t: 0 }]);
+    /**
+     * `prefix` and a rank after `after` (`undefined`: the run opens) in the
+     * run: inside the band when `band`. Opening, it takes the band's middle,
+     * or a digit below the run's first member; at the run's end it appends as
+     * an open end does (a window, not half the band); else between the two.
+     */
+    const own = (prefix, after, band) => {
+        const tail = (r) => r && r.length > prefix.length && r.startsWith(prefix) ? r.slice(prefix.length) : undefined;
+        let next = tail(right);
+        if (band && next !== undefined && next > top)
+            next = undefined;
+        let mine;
+        if (after === undefined) {
+            if (next === undefined)
+                mine = encodeRank([{ v: RUN_START, t: client }]);
+            else if (band && next > bottom)
+                mine = rankBetween(bottom, next, client, rand);
+            else
+                return plain();
+        }
+        else if (next === undefined && band) {
+            const append = rankBetween(after, undefined, client, rand);
+            mine = append < top ? append : rankBetween(after, top, client, rand);
+        }
+        else
+            mine = rankBetween(after, next, client, rand);
+        const rank = prefix + mine;
+        return right === undefined || rank < right ? rank : plain();
+    };
+    // A member of the client's run: the next member, inside the band.
+    if (last.t === client && inRun(last.v))
+        return own(encodeRank(segs.slice(0, -1)), encodeRank([last]), true);
+    // A run of the earlier form (the marker, then the client's ranks): stays in it.
+    const k = segs.findLastIndex((g) => g.v === RANK_RUN);
+    if (k >= 0 && segs[k].t === client) {
+        const prefix = encodeRank(segs.slice(0, k + 1));
+        return own(prefix, left.length > prefix.length ? left.slice(prefix.length) : undefined, false);
+    }
+    // A rank the client made: its run opens right after it.
+    if (last.t === client)
+        return own(left, undefined, true);
+    return plain();
+};

package/dist/crdt/structs.d.ts

@@ -25,7 +25,11 @@ export type StoreStruct = {
     /** `null` for sequence items; an attr name for map-entry items. */
     parentSub: string | null;
     parent: unknown;
+    left?: StoreStruct | null;
     right?: StoreStruct | null;
+    content?: {
+        arr?: unknown[];
+    };
     countable?: boolean;
     keep?: boolean;
     redone?: {
@@ -75,6 +79,12 @@ export declare const structAt: (Y: EngineApi, structs: readonly StoreStruct[], c
  * partial walk. `clientsOf` throws first when the store itself is absent.
  */
 export declare const walkIdSetStructs: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct) => boolean | void) => boolean;
+/**
+ * {@link walkIdSetStructs}, clipped: `fn(struct, from, to)` gets the clock
+ * range `[from, to)` of the struct the id set covers (a struct can reach past
+ * a range a diff of two id sets cut).
+ */
+export declare const walkIdSetRanges: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct, from: number, to: number) => void) => boolean;
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`
@@ -104,3 +114,10 @@ export declare const nextClock: (doc: EngineDoc, client: number) => number;
  * undefined until the missing update arrives.
  */
 export declare const holdsPending: (doc: EngineDoc) => boolean;
+/**
+ * The transactions the engine has opened and not finished cleaning up
+ * (vendor-internal `doc._transactionCleanups`), in order: the open one, and
+ * those started during an earlier one's cleanup, whose bodies already ran
+ * and whose observers have not.
+ */
+export declare const queuedTransactions: (doc: EngineDoc) => readonly unknown[];

package/dist/crdt/structs.js

@@ -75,6 +75,40 @@ export const walkIdSetStructs = (Y, doc, idSet, fn) => {
     });
     return complete;
 };
+/**
+ * {@link walkIdSetStructs}, clipped: `fn(struct, from, to)` gets the clock
+ * range `[from, to)` of the struct the id set covers (a struct can reach past
+ * a range a diff of two id sets cut).
+ */
+export const walkIdSetRanges = (Y, doc, idSet, fn) => {
+    const clients = clientsOf(doc);
+    let complete = true;
+    idSet.clients.forEach((ranges, client) => {
+        const structs = clients.get(client);
+        if (structs === undefined) {
+            complete = false;
+            return;
+        }
+        for (const r of ranges.getIds()) {
+            const end = r.clock + r.len;
+            let i;
+            try {
+                i = Y.findIndexSS(structs, r.clock);
+            }
+            catch {
+                complete = false;
+                continue;
+            }
+            for (; i < structs.length; i++) {
+                const s = structs[i];
+                if (s.id.clock >= end)
+                    break;
+                fn(s, Math.max(r.clock, s.id.clock), Math.min(end, s.id.clock + s.length));
+            }
+        }
+    });
+    return complete;
+};
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`
@@ -117,3 +151,10 @@ export const holdsPending = (doc) => {
     const store = doc.store;
     return (store?.pendingStructs ?? null) !== null || (store?.pendingDs ?? null) !== null;
 };
+/**
+ * The transactions the engine has opened and not finished cleaning up
+ * (vendor-internal `doc._transactionCleanups`), in order: the open one, and
+ * those started during an earlier one's cleanup, whose bodies already ran
+ * and whose observers have not.
+ */
+export const queuedTransactions = (doc) => doc._transactionCleanups ?? [];

package/dist/crdt/text/model.d.ts

@@ -195,9 +195,15 @@ export type Stream = {
 };
 /** Scan `text` (live space, renderer-free) for its boundary items. */
 export declare const scanText: (home: BlockId, text: EngineNode) => TextRow;
+export declare const byId: (a: string, b: string) => number;
 /** Each block's delimiting boundary: the lowest-id live boundary whose nonce matches its record. */
 export declare const delimiters: (blocks: ReadonlyMap<BlockId, Pick<TextBlockRec, "n">>, rows: Iterable<TextRow>) => Map<BlockId, string>;
-/** The streams of one text, in text order: the home's head (unless delimited elsewhere), then one per delimiting boundary. */
+/**
+ * The streams of one text, in text order: the home's head (unless delimited
+ * elsewhere), then one per delimiting boundary — one sweep over the
+ * boundaries (each non-delimiting one is an inert boundary of the stream it
+ * sits in).
+ */
 export declare const placeText: (row: TextRow, delim: ReadonlyMap<BlockId, string>) => Stream[];
 /** A displayed piece: `[i0, i1)` of `text` (home `t`) holds content only; `block` owns its stream. */
 export type Seg = {
@@ -221,6 +227,8 @@ export type Ownership = {
     streamOf: (b: BlockId) => Stream | undefined;
     /** The streams of `home`'s text, in text order. */
     streamsIn: (home: BlockId) => readonly Stream[];
+    /** The stream of `home`'s text whose `[start, end]` holds live index `i` (the first, at a seam). */
+    streamAt: (home: BlockId, i: number) => Stream | undefined;
     /** `display(b)` as boundary-free pieces in reading order; `null` when hidden or dead. */
     display: (b: BlockId) => Seg[] | null;
 };