edytor 0.1.0-next.21 → 0.1.0-next.23

package/dist/crdt/document.js

@@ -143,7 +143,7 @@
 import { DEV } from 'esm-env';
 import { Y } from './engine.js';
 import { bindAttribution } from './attribution/index.js';
-import { bindEdytorDoc, isInitialized, lineageDepthOf } from './edytor-doc.js';
+import { bindEdytorDoc, DEFAULT_HISTORY_LIMIT, isInitialized, lineageDepthOf } from './edytor-doc.js';
 import { assertAdmission, assertSchema, bindAdmission, checkSchema } from './admission.js';
 import { Awareness } from './protocols/awareness.js';
 import { callEach } from './protocols/observable.js';
@@ -199,12 +199,23 @@ export class DocumentDestroyedError extends Error {
  * does: from the socket's open, so a slow dial never counts).
  */
 export const DEFAULT_READINESS_BOUND = 1000;
-const normalizeRole = (role) => ({
-    void: role?.void === true,
-    island: role?.island === true,
-    lines: role?.lines === true,
-    ...(role?.layout === true && { layout: true })
-});
+const normalizeRole = (role) => {
+    const atomic = [
+        ...new Map((role?.atomic ?? []).map((p) => {
+            const path = typeof p === 'string' ? [p] : [...p];
+            return [JSON.stringify(path), path];
+        }))
+    ]
+        .sort(([a], [b]) => (a < b ? -1 : 1))
+        .map(([, path]) => path);
+    return {
+        void: role?.void === true,
+        island: role?.island === true,
+        lines: role?.lines === true,
+        ...(role?.layout === true && { layout: true }),
+        ...(atomic.length > 0 && { atomic })
+    };
+};
 const anonymousActor = () => ({
     id: `anon-${crypto.randomUUID()}`
 });
@@ -307,6 +318,8 @@ export class EdytorDocument {
     _defaultType;
     _historyOptions;
     _lineageDepth;
+    /** {@link DocumentOptions.requireHydration}: an empty document waits for a provider's `synced`. */
+    requireHydration;
     /** Attached providers keyed by transport target (O75): one per target. */
     _providers = new Map();
     _pendingSyncs = 0;
@@ -336,6 +349,7 @@ export class EdytorDocument {
         this._ownsAwareness = init.awareness === undefined;
         this._historyOptions = init.history;
         this._lineageDepth = init.lineage?.depth;
+        this.requireHydration = init.requireHydration === true;
         this.actor = init.actor ?? anonymousActor();
         // Durable actor identity is separate from the presence profile: the
         // `actor` field carries the stable id (U5/U6 stub seam), `user`
@@ -418,6 +432,14 @@ export class EdytorDocument {
     get historyCaptureTimeout() {
         return this._historyOptions?.captureTimeout;
     }
+    /**
+     * The undo steps this document's history keeps (P6): the configured
+     * `history.limit`, else {@link DEFAULT_HISTORY_LIMIT}. The `attachDocument`
+     * dedupe check reads it (a reattach naming another limit is a conflict).
+     */
+    get historyLimit() {
+        return this._historyOptions?.limit ?? DEFAULT_HISTORY_LIMIT;
+    }
     /**
      * The lineage ring depth this document was configured with — read by
      * the `attachDocument` dedupe compatibility check (a reattach naming
@@ -657,17 +679,17 @@ export class EdytorDocument {
         this._history = this.facade.createUndoManager({
             trackedOrigins: this._trackedOrigins,
             captureTimeout: this._historyOptions?.captureTimeout,
+            limit: this.historyLimit,
             captureTransaction: (transaction) => transaction.local !== false
         });
         return this._history;
     };
     /**
-     * Prune the undo/redo stacks — the document's retention surface. The
-     * engine keeps unbounded stacks: nothing is pruned implicitly (the
-     * `captureTimeout` merge window only fuses adjacent commits into one
-     * step). Call this to bound memory on long-lived documents, e.g. after
-     * a save checkpoint. No-op while history has not attached (there is
-     * nothing to clear — it does NOT force attach or throw on pending).
+     * Drop the undo/redo stacks. The undo stack already keeps only its
+     * newest `history.limit` steps (P6); call this where undo no longer makes
+     * sense, e.g. after a save checkpoint. No-op while history has not
+     * attached (there is nothing to clear — it does NOT force attach or throw
+     * on pending).
      */
     clearHistory = () => {
         if (this._destroyed) {
@@ -740,9 +762,12 @@ export class EdytorDocument {
      * decides again when it turns writable (the refusal propagates to the
      * reporting provider only).
      */
-    _decide = (value, report = false) => {
+    _decide = (value, report = false, synced = false) => {
         if (this._destroyed || this.ready)
             return;
+        // H12: an empty document waits for a provider that synced.
+        if (this.requireHydration && !synced && !isInitialized(this.doc))
+            return;
         const waiting = this._pendingSyncs > 0 || this._refusals.size > 0;
         if (waiting && !isInitialized(this.doc))
             return;
@@ -824,7 +849,7 @@ export class EdytorDocument {
                 synced: () => {
                     settle();
                     this._refusals.delete(target);
-                    this._decide(opts.value, true);
+                    this._decide(opts.value, true, true);
                 },
                 failed,
                 armBound: () => {
@@ -1017,9 +1042,16 @@ export const bindDocument = (Y) => {
             options.history.captureTimeout !== existing.historyCaptureTimeout) {
             throw new SemanticConflictError('history.captureTimeout', existing.historyCaptureTimeout, options.history.captureTimeout);
         }
+        if (options.history?.limit !== undefined && options.history.limit !== existing.historyLimit) {
+            throw new SemanticConflictError('history.limit', existing.historyLimit, options.history.limit);
+        }
         if (options.lineage?.depth !== undefined && options.lineage.depth !== existing.lineageDepth) {
             throw new SemanticConflictError('lineage.depth', existing.lineageDepth, options.lineage.depth);
         }
+        if (options.requireHydration !== undefined &&
+            options.requireHydration !== existing.requireHydration) {
+            throw new SemanticConflictError('requireHydration', existing.requireHydration, options.requireHydration);
+        }
         if (options.semantics !== undefined) {
             existing.adoptSemantics(options.semantics);
         }
@@ -1045,7 +1077,8 @@ export const bindDocument = (Y) => {
                 awareness: options.awareness,
                 semantics: options.semantics,
                 history: options.history,
-                lineage: options.lineage
+                lineage: options.lineage,
+                requireHydration: options.requireHydration
             });
             attached.set(document.doc, document);
             if (options.value !== undefined) {
@@ -1082,7 +1115,8 @@ export const bindDocument = (Y) => {
                 awareness: options.awareness,
                 semantics: options.semantics,
                 history: options.history,
-                lineage: options.lineage
+                lineage: options.lineage,
+                requireHydration: options.requireHydration
             });
             attached.set(doc, document);
             try {
@@ -1144,7 +1178,8 @@ export const bindDocument = (Y) => {
                 awareness: options.awareness,
                 semantics: options.semantics,
                 history: options.history,
-                lineage: options.lineage
+                lineage: options.lineage,
+                requireHydration: options.requireHydration
             });
             attached.set(doc, document);
             return document;

package/dist/crdt/edytor-doc.d.ts

@@ -98,6 +98,8 @@ export declare const assertUsableDoc: (doc: EngineDoc) => void;
  * 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 declare const DEFAULT_HISTORY_LIMIT = 200;
 export declare class EdytorDocDisposedError extends Error {
     constructor(service?: string);
 }
@@ -120,6 +122,14 @@ export type BlockRole = {
      * a `defaultChild`.
      */
     layout?: boolean;
+    /**
+     * Data paths written as one leaf (`data.atomic`, H8): a top-level key, or
+     * an array of keys for a nested one (`['link', ['media', 'source']]`). An
+     * assignment there, or anywhere under it, writes the whole value as one
+     * last-writer-wins leaf, so two concurrent assignments never merge into a
+     * value neither wrote: one wins whole.
+     */
+    atomic?: readonly (string | readonly string[])[];
 };
 /** Island-sealing policy for a walk in document order (R5; see `next`). */
 export type OrderPolicy = {
@@ -495,7 +505,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").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: import("./engine-api.js").EngineItemRef, stackItem: {
                 inserts: {
@@ -617,7 +627,17 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         checkSchema: () => SchemaProblem | null;
         assertSchema: () => void;
         dispose: () => void;
-        createUndoManager: (opts?: ConstructorParameters<EngineApi["UndoManager"]>[1]) => YUndoManager;
+        createUndoManager: (options?: ConstructorParameters<EngineApi["UndoManager"]>[1] & {
+            limit?: number;
+        }) => YUndoManager;
+        /**
+         * Drop every step of a history `createUndoManager` made (undo and
+         * redo) and release what they kept for their undo, as the history
+         * limit does (P6): the engine collects that content now, the doc's
+         * `gcFilter` still deciding. The room's validation history (H2) runs
+         * it after each frame.
+         */
+        releaseHistory: (um: YUndoManager) => void;
         project: () => import("./index.js").ProjectedDoc;
         toJSON: () => JSONDoc;
         blockJSON: (id: string) => JSONBlock;
@@ -696,6 +716,14 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         })[];
         onChange: (cb: (change: DocChange) => void) => (() => void);
     };
+    /**
+     * Keep, on `doc`, the text a replica may have to copy again (P11): its
+     * `gcFilter` then spares a deleted copy's content, as every facade's
+     * history does. A doc that only relays updates (the room) calls it
+     * before applying anything, so what it collects and encodes matches
+     * what an editing replica keeps.
+     */
+    keepCopies: (doc: EngineDoc) => void;
     /** The bound engine layers (same instances the facades use). */
     model: {
         REGISTRY_KEY: string;
@@ -712,7 +740,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").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: import("./engine-api.js").EngineItemRef, stackItem: {
             inserts: {

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.`);
@@ -341,6 +345,8 @@ export const bindEdytorDoc = (Y) => {
     const M = bindModel(Y);
     const T = bindText(Y);
     const D = bindDeletes(Y);
+    /** Each history's release of all its steps (`releaseHistory`). */
+    const releasers = new WeakMap();
     // U1 — compact per-block attribution writes (`attribution/block.ts`).
     // One bound instance per engine binding; its suppression memory is
     // per-doc (WeakMap-keyed), so facades on the same doc share it.
@@ -1071,10 +1077,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 +1109,49 @@ 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 release = (dropped) => {
+                if (dropped.length === 0)
+                    return;
+                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);
+            };
+            const trim = ({ type }) => {
+                const over = um.undoStack.length - limit;
+                if (type !== 'undo' || !(over > 0))
+                    return;
+                release(um.undoStack.splice(0, over));
+            };
+            um.on('stack-item-added', trim);
+            // `releaseHistory(um)`: every step dropped and released by the same rule.
+            releasers.set(um, () => release([...um.undoStack.splice(0), ...um.redoStack.splice(0)]));
             // 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 +1276,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 +1320,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 +1449,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 +1474,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 +1696,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 +1794,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 +2359,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 +2384,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 +2551,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),
@@ -2559,6 +2660,14 @@ export const bindEdytorDoc = (Y) => {
             assertSchema: () => assertSchema(doc),
             dispose,
             createUndoManager,
+            /**
+             * Drop every step of a history `createUndoManager` made (undo and
+             * redo) and release what they kept for their undo, as the history
+             * limit does (P6): the engine collects that content now, the doc's
+             * `gcFilter` still deciding. The room's validation history (H2) runs
+             * it after each frame.
+             */
+            releaseHistory: (um) => releasers.get(um)?.(),
             // reads — every id argument normalizes at ingress (O1)
             project: () => M.project(doc),
             toJSON,
@@ -2679,6 +2788,14 @@ export const bindEdytorDoc = (Y) => {
         SchemaMismatchError,
         /** Attach the per-doc facade. */
         create,
+        /**
+         * Keep, on `doc`, the text a replica may have to copy again (P11): its
+         * `gcFilter` then spares a deleted copy's content, as every facade's
+         * history does. A doc that only relays updates (the room) calls it
+         * before applying anything, so what it collects and encodes matches
+         * what an editing replica keeps.
+         */
+        keepCopies: (doc) => void D.scope(doc),
         /** The bound engine layers (same instances the facades use). */
         model: M,
         text: T,

package/dist/crdt/engine.d.ts

@@ -17,6 +17,12 @@ export type EngineSymbol =
 	| 'UpdateEncoderV1'
 	| 'writeIdSet'
 	| 'mergeUpdates'
+	| 'applyUpdateV2'
+	| 'encodeStateAsUpdateV2'
+	| 'mergeUpdatesV2'
+	| 'convertUpdateFormatV2ToV1'
+	| 'UpdateDecoderV1'
+	| 'UpdateEncoderV2'
 	| 'Skip'
 	| 'findIndexSS'
 	| 'createRelativePositionFromTypeIndex'

package/dist/crdt/engine.js

@@ -30,6 +30,13 @@ export const Y = {
 	UpdateEncoderV1: V.UpdateEncoderV1,
 	writeIdSet: V.writeIdSet,
 	mergeUpdates: V.mergeUpdates,
+	// storage in the v2 (columnar) encoding (P5): room rows and the IndexedDB store
+	applyUpdateV2: V.applyUpdateV2,
+	encodeStateAsUpdateV2: V.encodeStateAsUpdateV2,
+	mergeUpdatesV2: V.mergeUpdatesV2,
+	convertUpdateFormatV2ToV1: V.convertUpdateFormatV2ToV1,
+	UpdateDecoderV1: V.UpdateDecoderV1,
+	UpdateEncoderV2: V.UpdateEncoderV2,
 	Skip: V.Skip,
 	findIndexSS: V.findIndexSS,
 	createRelativePositionFromTypeIndex: V.createRelativePositionFromTypeIndex,

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 });
                 }