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

package/dist/crdt/providers/index.js

@@ -1,5 +1,5 @@
 import { bindIndexeddbProvider } from './indexeddb.js';
-import { assertRoomId } from './room.js';
+import { assertRoomId, SyncRefusedError } from './room.js';
 import { bindWebsocketProvider } from './websocket.js';
 export const bindProviders = (Y) => {
     const idb = bindIndexeddbProvider(Y);
@@ -39,7 +39,7 @@ export const bindProviders = (Y) => {
         const persistName = options.persist === false ? undefined : (options.persistName ?? `edytor:${room}`);
         const sync = (payload) => {
             const { doc, awareness, synced, failed, attach, armBound, holdBound } = payload;
-            const { params, WebSocketPolyfill, maxBackoffTime, connectTimeout, disableBc, onExpired } = options;
+            const { params, WebSocketPolyfill, maxBackoffTime, connectTimeout, disableBc, onExpired, maxFrameBytes } = options;
             const local = persistName !== undefined && typeof indexedDB !== 'undefined'
                 ? localSync(persistName, { disableBc })
                 : undefined;
@@ -49,7 +49,8 @@ export const bindProviders = (Y) => {
                 WebSocketPolyfill,
                 maxBackoffTime,
                 connectTimeout,
-                disableBc: disableBc || local !== undefined
+                disableBc: disableBc || local !== undefined,
+                maxFrameBytes
             });
             if (onExpired)
                 provider.on('expired', (state) => onExpired(state));
@@ -106,7 +107,89 @@ export const bindProviders = (Y) => {
         };
         return Object.assign(sync, { bound: Infinity, target: `websocket:${room}`, persistName });
     };
+    /** `[serverUrl (no trailing slash), room]` of a target, the room id checked. */
+    const targetOf = (options) => {
+        const [server, room] = 'server' in options ? [options.server, options.room] : [options.serverUrl, options.roomName];
+        assertRoomId(room);
+        return [server.replace(/\/+$/, ''), room];
+    };
+    /**
+     * Keep a document fresh without opening it (H12): load its local store
+     * (the one `createWebsocketSync` keeps, `edytor:<server>/<room>` unless
+     * `persistName` names another), dial the room once, take what it lacks
+     * and hand it what the store holds that the room lacks, wait until the
+     * room stored it, then close. Resolves with whether the room sent
+     * anything new; rejects with the room's refusal (`SyncRefusedError`),
+     * after `timeout`, or where there is no IndexedDB.
+     */
+    const prefetch = (options) => {
+        const [serverUrl, room] = targetOf(options);
+        if (typeof indexedDB === 'undefined') {
+            return Promise.reject(new TypeError('prefetch needs IndexedDB to keep the document'));
+        }
+        const doc = new Y.Doc();
+        const local = new idb.IndexeddbPersistence(options.persistName ?? `edytor:${serverUrl}/${room}`, doc, { disableBc: true });
+        let socket = null;
+        /** Prefetch's one timer: its deadline (`timeout`), cleared when it closes. */
+        let deadline;
+        const close = async () => {
+            clearTimeout(deadline);
+            socket?.destroy();
+            await local.destroy();
+            doc.destroy();
+        };
+        return new Promise((resolve, reject) => {
+            const fail = (error) => void close().then(() => reject(error));
+            deadline = setTimeout(() => fail(new Error(`prefetch of ${room} timed out`)), options.timeout ?? 30_000);
+            local.whenSynced.then(() => {
+                const before = Y.encodeStateVector(doc);
+                const provider = (socket = new ws.WebsocketProvider(serverUrl, room, doc, {
+                    params: options.params,
+                    WebSocketPolyfill: options.WebSocketPolyfill,
+                    maxBackoffTime: options.maxBackoffTime,
+                    connectTimeout: options.connectTimeout,
+                    maxFrameBytes: options.maxFrameBytes,
+                    disableBc: true
+                }));
+                // A prefetch is nobody's presence.
+                provider.awareness.setLocalState(null);
+                const done = () => {
+                    if (!provider.synced || !provider.saved)
+                        return;
+                    const after = Y.encodeStateVector(doc);
+                    const updated = after.length !== before.length || after.some((b, i) => b !== before[i]);
+                    void close().then(() => resolve({ updated }));
+                };
+                provider.on('synced', done);
+                provider.on('saved', done);
+                provider.on('refused', (refusal) => fail(refusal));
+                done();
+            }, fail);
+        });
+    };
+    /**
+     * When the room last stored a change (ms since the epoch), or `null`
+     * (H12): one authorized HTTP `GET <server>/<room>?lastUpdated`, which
+     * `routeDocumentSocket` answers without opening the document. Compare
+     * it with when a document was last fetched to decide whether to
+     * `prefetch` it. Throws on an HTTP error (`403` refused, `401` expired).
+     */
+    const lastUpdated = async (options) => {
+        const [serverUrl, room] = targetOf(options);
+        const url = new URL(`${serverUrl.replace(/^ws/, 'http')}/${encodeURIComponent(room)}`);
+        for (const [key, value] of Object.entries(options.params ?? {}))
+            url.searchParams.set(key, value);
+        url.searchParams.set('lastUpdated', '1');
+        const response = await (options.fetch ?? fetch)(url.toString());
+        if (!response.ok) {
+            throw new Error(`lastUpdated of ${room}: ${response.status} ${await response.text()}`);
+        }
+        const { lastUpdated: at } = (await response.json());
+        return typeof at === 'number' ? at : null;
+    };
     return {
+        prefetch,
+        lastUpdated,
         IndexeddbPersistence: idb.IndexeddbPersistence,
         WebsocketProvider: ws.WebsocketProvider,
         storeState: idb.storeState,

package/dist/crdt/providers/indexeddb.js

@@ -41,8 +41,8 @@ import * as encoding from 'lib0-v14/encoding';
 import { Awareness } from '../protocols/awareness.js';
 import { IsolatedObservable } from '../protocols/observable.js';
 import { bindSync } from '../protocols/sync.js';
-import { generationDbName } from '../protocols/envelope.js';
-import { CUSTOM as customStoreName, decodeRow, encodeRow, openContainer, UPDATES as updatesStoreName, verifyOrStamp } from './container.js';
+import { GENERATION_KEY, generationDbName, STORED_GENERATION_RECORD } from '../protocols/envelope.js';
+import { CUSTOM as customStoreName, encodeRow, openContainer, readRow, snapshotRow, UPDATES as updatesStoreName, verifyOrStamp } from './container.js';
 import { beginDestroy, bindRoomProtocol, emitFailed, initLifecycle, markSynced, quarantined } from './room.js';
 export const PREFERRED_TRIM_SIZE = 500;
 /**
@@ -64,37 +64,75 @@ export const bindIndexeddbProvider = (Y) => {
     /**
      * Apply all stored update rows (from `_dbref` on) to the doc. Verifies the
      * generation record before touching the doc — rows from a foreign (v13 or
-     * otherwise-mismatched) generation are never applied.
+     * otherwise-mismatched) generation are never applied. The storage
+     * transaction reads everything it needs first (rows, last key, count):
+     * a snapshot row inflates asynchronously (P5), after it ends.
      */
     const fetchUpdates = (idbPersistence, beforeApplyUpdatesCallback = () => { }, afterApplyUpdatesCallback = () => { }) => {
         const db = idbPersistence.db;
         const [updatesStore, customStore] = idb.transact(db, [updatesStoreName, customStoreName]);
         return verifyOrStamp(idbPersistence.name, updatesStore, customStore)
             .then(() => idb.getAll(updatesStore, idb.createIDBKeyRangeLowerBound(idbPersistence._dbref, false)))
-            .then((updates) => {
-            if (!idbPersistence._destroyed) {
+            .then((rows) => {
+            // The pre-hydration state row is written before the last key is read.
+            if (!idbPersistence._destroyed)
                 beforeApplyUpdatesCallback(updatesStore);
-                Y.transact(idbPersistence.doc, () => {
-                    updates.forEach((update) => Y.applyUpdate(idbPersistence.doc, decodeRow(update)));
-                }, idbPersistence, false);
-                afterApplyUpdatesCallback(updatesStore);
-            }
+            return promise
+                .all([idb.getLastKey(updatesStore), idb.count(updatesStore)])
+                .then(([lastKey, cnt]) => {
+                idbPersistence._dbref = lastKey + 1;
+                idbPersistence._dbsize = cnt;
+                return promise.all(rows.map(readRow));
+            });
         })
-            .then(() => idb.getLastKey(updatesStore).then((lastKey) => {
-            idbPersistence._dbref = lastKey + 1;
-        }))
-            .then(() => idb.count(updatesStore).then((cnt) => {
-            idbPersistence._dbsize = cnt;
-        }))
-            .then(() => updatesStore);
+            .then((updates) => {
+            if (idbPersistence._destroyed)
+                return;
+            Y.transact(idbPersistence.doc, () => {
+                for (const update of updates) {
+                    if (update instanceof Uint8Array)
+                        Y.applyUpdate(idbPersistence.doc, update);
+                    else
+                        Y.applyUpdateV2(idbPersistence.doc, update.v2);
+                }
+            }, idbPersistence, false);
+            afterApplyUpdatesCallback();
+        });
+    };
+    /** One transaction: the snapshot row, the rows below `below` deleted, the record stamped `'v2'`. */
+    const writeSnapshot = (idbPersistence, row, below) => {
+        const db = idbPersistence.db;
+        const [updatesStore, customStore] = idb.transact(db, [updatesStoreName, customStoreName]);
+        // Track transaction commit: listeners attach while it is still active.
+        const tx = updatesStore.transaction;
+        const transactionDone = promise.create((resolve, reject) => {
+            tx.addEventListener('complete', () => resolve(undefined));
+            tx.addEventListener('abort', () => reject(new Error(`IndexedDB transaction aborted${tx.error ? `: ${String(tx.error)}` : ''}`)));
+        });
+        return promise
+            .all([
+            idb
+                // A structured-clone object row (lib0 types rows as binary).
+                .addAutoKey(updatesStore, row)
+                .then(() => idb.del(updatesStore, idb.createIDBKeyRangeUpperBound(below, true)))
+                .then(() => idb.rtop(customStore.put({ ...STORED_GENERATION_RECORD }, GENERATION_KEY)))
+                .then(() => idb.count(updatesStore).then((cnt) => {
+                idbPersistence._dbsize = cnt;
+            })),
+            transactionDone
+        ])
+            .then(() => undefined);
     };
     /**
      * Persist the current state: fetch pending rows, then (when `forceStore`
      * or past `PREFERRED_TRIM_SIZE`) append a compacted snapshot and delete
-     * the rows it subsumes.
+     * the rows it subsumes. The snapshot is v2, gzip-compressed where the
+     * platform can (P5), and the container's generation record is stamped
+     * with its storage format in the same transaction.
      *
      * Every applied row is represented in the snapshot, so deleting
-     * `key < _dbref` is always safe; a read-only document (outbound
+     * `key < _dbref` (read before the snapshot is compressed: rows stored
+     * meanwhile stay) is always safe; a read-only document (outbound
      * quarantine) never compacts.
      *
      * The returned promise settles only after the storage transaction
@@ -108,32 +146,14 @@ export const bindIndexeddbProvider = (Y) => {
         // Deferred: a synchronous transact/fetch failure (closed or
         // missing handle) must surface as a rejection, not a throw.
         .then(() => fetchUpdates(idbPersistence))
-        .then((updatesStore) => {
+        .then(() => {
         if (quarantined(idbPersistence.doc))
             return undefined;
         if (!forceStore && idbPersistence._dbsize < PREFERRED_TRIM_SIZE) {
             return undefined;
         }
-        // Track transaction commit: listeners attach while the
-        // transaction is still active — this callback runs inside
-        // the last fetch request's success microtask, before the
-        // transaction can finish.
-        const tx = updatesStore.transaction;
-        const transactionDone = promise.create((resolve, reject) => {
-            tx.addEventListener('complete', () => resolve(undefined));
-            tx.addEventListener('abort', () => reject(new Error(`IndexedDB transaction aborted${tx.error ? `: ${String(tx.error)}` : ''}`)));
-        });
-        return promise
-            .all([
-            idb
-                .addAutoKey(updatesStore, encodeRow(Y.encodeStateAsUpdate(idbPersistence.doc)))
-                .then(() => idb.del(updatesStore, idb.createIDBKeyRangeUpperBound(idbPersistence._dbref, true)))
-                .then(() => idb.count(updatesStore).then((cnt) => {
-                idbPersistence._dbsize = cnt;
-            })),
-            transactionDone
-        ])
-            .then(() => undefined);
+        const below = idbPersistence._dbref;
+        return snapshotRow(Y.encodeStateAsUpdateV2(idbPersistence.doc)).then((row) => idbPersistence._destroyed ? undefined : writeSnapshot(idbPersistence, row, below));
     });
     /**
      * Delete a v14 generation database by LOGICAL name (the `edytor-v14:`

package/dist/crdt/providers/room.d.ts

@@ -20,13 +20,23 @@ export declare const MAX_FRAME_BYTES: number;
  * receiver applies the reassembled frame only once `end` arrives.
  */
 export declare const chunkFrame: (whole: Uint8Array, maxFrameBytes?: number) => Uint8Array[];
+/** A chunk sequence announces a frame larger than its reader takes ({@link createChunkReader}). */
+export declare class ChunkLimitError extends Error {
+    readonly total: number;
+    readonly limit: number;
+    constructor(total: number, limit: number);
+}
+/** A chunk part or end with no sequence started (one lost, or never sent). */
+export declare class ChunkSequenceError extends Error {
+}
 /**
  * The receiving half of {@link chunkFrame}, one per connection: feed it
  * each chunk frame's body (after the message type); it returns the whole
  * frame on `end`, `null` before. An out-of-order or oversized sequence
- * throws and resets.
+ * throws and resets; a sequence announcing more than `maxBytes` throws
+ * {@link ChunkLimitError} at its start, before anything is buffered.
  */
-export declare const createChunkReader: () => (decoder: decoding.Decoder) => Uint8Array | null;
+export declare const createChunkReader: (maxBytes?: number) => (decoder: decoding.Decoder) => Uint8Array | null;
 export type ProtocolMismatch = {
     expected: number;
     found: number | null;
@@ -93,6 +103,12 @@ export declare const CLOSE: {
     readonly denied: 4403;
     /** The dialed replica is bound to another user. */
     readonly replicaTaken: 4409;
+    /**
+     * A room quota refused the socket's write (`quota: document`,
+     * `quota: rate`, `quota: frame`): the frame was not applied, and a
+     * redial would resend it and meet the same quota.
+     */
+    readonly quota: 4413;
 };
 /**
  * Whether a room (document) id can reach its own room: 1–256 characters,

package/dist/crdt/providers/room.js

@@ -87,28 +87,46 @@ export const chunkFrame = (whole, maxFrameBytes = MAX_FRAME_BYTES) => {
     frames.push(frame(messageChunk, (e) => encoding.writeVarUint(e, chunkEnd)));
     return frames;
 };
+/** A chunk sequence announces a frame larger than its reader takes ({@link createChunkReader}). */
+export class ChunkLimitError extends Error {
+    total;
+    limit;
+    constructor(total, limit) {
+        super(`chunked frame of ${total} bytes exceeds ${limit}`);
+        this.total = total;
+        this.limit = limit;
+        this.name = 'ChunkLimitError';
+    }
+}
+/** A chunk part or end with no sequence started (one lost, or never sent). */
+export class ChunkSequenceError extends Error {
+}
 /**
  * The receiving half of {@link chunkFrame}, one per connection: feed it
  * each chunk frame's body (after the message type); it returns the whole
  * frame on `end`, `null` before. An out-of-order or oversized sequence
- * throws and resets.
+ * throws and resets; a sequence announcing more than `maxBytes` throws
+ * {@link ChunkLimitError} at its start, before anything is buffered.
  */
-export const createChunkReader = () => {
+export const createChunkReader = (maxBytes = Infinity) => {
     let parts = null;
     let total = 0;
     let received = 0;
     return (decoder) => {
         const kind = decoding.readVarUint(decoder);
         if (kind === chunkStart) {
-            parts = [];
+            parts = null;
             total = decoding.readVarUint(decoder);
+            if (total > maxBytes)
+                throw new ChunkLimitError(total, maxBytes);
+            parts = [];
             received = 0;
             return null;
         }
         const current = parts;
         parts = null;
         if (current === null)
-            throw new Error(`chunk ${kind} without a start`);
+            throw new ChunkSequenceError(`chunk ${kind} without a start`);
         if (kind === chunkPart) {
             const bytes = decoding.readVarUint8Array(decoder);
             received += bytes.length;
@@ -205,7 +223,13 @@ export const CLOSE = {
     /** The host's authorization denied the dial. */
     denied: 4403,
     /** The dialed replica is bound to another user. */
-    replicaTaken: 4409
+    replicaTaken: 4409,
+    /**
+     * A room quota refused the socket's write (`quota: document`,
+     * `quota: rate`, `quota: frame`): the frame was not applied, and a
+     * redial would resend it and meet the same quota.
+     */
+    quota: 4413
 };
 /**
  * Whether a room (document) id can reach its own room: 1–256 characters,

package/dist/crdt/providers/websocket.d.ts

@@ -90,6 +90,12 @@ export type WebsocketProviderOptions = {
     connectTimeout?: number;
     /** Opt out of cross-tab sync over the BroadcastChannel (on by default). */
     disableBc?: boolean;
+    /**
+     * Largest frame sent whole (default 32 MiB, Cloudflare's WebSocket
+     * message limit): a larger one — a reconnect's backlog, a big paste —
+     * goes out as a chunk sequence the room reassembles (H6).
+     */
+    maxFrameBytes?: number;
 };
 export type WebsocketProviderApi = InstanceType<ReturnType<typeof bindWebsocketProvider>['WebsocketProvider']>;
 /**
@@ -97,7 +103,7 @@ export type WebsocketProviderApi = InstanceType<ReturnType<typeof bindWebsocketP
  */
 export declare const bindWebsocketProvider: (Y: EngineApi) => {
     WebsocketProvider: {
-        new (serverUrl: string, roomname: string, doc: YDoc, { connect, awareness, params, WebSocketPolyfill, resyncInterval, maxBackoffTime, connectTimeout, disableBc }?: WebsocketProviderOptions): {
+        new (serverUrl: string, roomname: string, doc: YDoc, { connect, awareness, params, WebSocketPolyfill, resyncInterval, maxBackoffTime, connectTimeout, disableBc, maxFrameBytes }?: WebsocketProviderOptions): {
             serverUrl: string;
             roomname: string;
             doc: YDoc;
@@ -106,6 +112,8 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
             maxBackoffTime: number;
             /** ms a dial may take to open (`Infinity`: no limit). */
             connectTimeout: number;
+            /** Largest frame sent whole; larger ones are chunked. */
+            maxFrameBytes: number;
             _WS: WebsocketPolyfill;
             shouldConnect: boolean;
             ws: WebSocket | null;

package/dist/crdt/providers/websocket.js

@@ -6,7 +6,8 @@
  * Retained surface (D-24 G-e): `status`/`synced`/`connection-*` events,
  * `connect()`/`disconnect()`, awareness injection, auth `params` (read at
  * every dial, so a refreshed token reaches the next connection),
- * `WebSocketPolyfill`, exponential-backoff reconnect (`maxBackoffTime`,
+ * `WebSocketPolyfill`, outbound chunking of frames over `maxFrameBytes` (H6),
+ * exponential-backoff reconnect (`maxBackoffTime`,
  * growing to 30 s for a room that stays unreachable), liveness (a text
  * `ping` after 15 s of silence; a text `pong` counts as heard),
  * `resyncInterval`, and the BroadcastChannel leg (cross-tab sync, on by
@@ -54,7 +55,7 @@ import { Awareness, removeAwarenessStates } from '../protocols/awareness.js';
 import { IsolatedObservable } from '../protocols/observable.js';
 import { messagePermissionDenied, messageReadOnly, READ_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
 import { bindSync } from '../protocols/sync.js';
-import { assertRoomId, beginDestroy, bindRoomProtocol, CLOSE, createChunkReader, emitFailed, initLifecycle, isRefusal, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageSaved, messageSync, SyncRefusedError } from './room.js';
+import { assertRoomId, beginDestroy, bindRoomProtocol, chunkFrame, CLOSE, createChunkReader, emitFailed, initLifecycle, isRefusal, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
 import { ATTRIBUTION_ROOT } from '../schema.js';
 import { ATTRIBUTION_ORIGIN } from '../attribution/attribution.js';
 // @todo - this should depend on awareness.outdatedTime
@@ -72,11 +73,21 @@ const defaultConnectTimeout = 10000;
  */
 export const bindWebsocketProvider = (Y) => {
     const syncProtocol = bindSync(Y);
+    /**
+     * One frame on `ws`: whole, or as a chunk sequence when it is larger
+     * than `maxFrameBytes` (H6). A text frame (the keepalive) goes as it is.
+     */
+    const sendOn = (provider, ws, buf) => {
+        if (typeof buf === 'string')
+            return ws.send(buf);
+        for (const piece of chunkFrame(buf, provider.maxFrameBytes))
+            ws.send(piece);
+    };
     /** Traffic for the server goes out on the socket while it is open. */
     const send = (provider, buf) => {
         const ws = provider.ws;
         if (provider.wsconnected && ws && ws.readyState === ws.OPEN)
-            ws.send(buf);
+            sendOn(provider, ws, buf);
     };
     /** Traffic for the other tabs goes out on the channel. */
     const toTabs = (provider, buf) => {
@@ -390,7 +401,7 @@ export const bindWebsocketProvider = (Y) => {
                 if (event.data === 'pong')
                     return;
                 try {
-                    room.readMessage(provider, new Uint8Array(event.data), true, (buf) => websocket.send(buf));
+                    room.readMessage(provider, new Uint8Array(event.data), true, (buf) => sendOn(provider, websocket, buf));
                 }
                 catch (error) {
                     provider.emit('message-error', [error, provider]);
@@ -409,7 +420,7 @@ export const bindWebsocketProvider = (Y) => {
                 provider.emit('status', [{ status: 'connected' }]);
                 // The join rule: say hello; the members answer what we lack.
                 for (const buf of room.hello(provider))
-                    websocket.send(buf);
+                    sendOn(provider, websocket, buf);
             };
             provider.emit('status', [{ status: 'connecting' }]);
         }
@@ -423,6 +434,8 @@ export const bindWebsocketProvider = (Y) => {
         maxBackoffTime;
         /** ms a dial may take to open (`Infinity`: no limit). */
         connectTimeout;
+        /** Largest frame sent whole; larger ones are chunked. */
+        maxFrameBytes;
         _WS;
         shouldConnect;
         ws = null;
@@ -457,7 +470,7 @@ export const bindWebsocketProvider = (Y) => {
         _checkInterval;
         _updateHandler;
         _awarenessUpdateHandler;
-        constructor(serverUrl, roomname, doc, { connect = true, awareness = new Awareness(doc), params = {}, WebSocketPolyfill = WebSocket, resyncInterval = 0, maxBackoffTime = 2500, connectTimeout = defaultConnectTimeout, disableBc = false } = {}) {
+        constructor(serverUrl, roomname, doc, { connect = true, awareness = new Awareness(doc), params = {}, WebSocketPolyfill = WebSocket, resyncInterval = 0, maxBackoffTime = 2500, connectTimeout = defaultConnectTimeout, disableBc = false, maxFrameBytes = MAX_FRAME_BYTES } = {}) {
             assertRoomId(roomname);
             super();
             this.serverUrl = serverUrl.replace(/\/+$/, '');
@@ -469,6 +482,8 @@ export const bindWebsocketProvider = (Y) => {
             this.params = params;
             this.maxBackoffTime = maxBackoffTime;
             this.connectTimeout = connectTimeout;
+            this.maxFrameBytes =
+                Number.isInteger(maxFrameBytes) && maxFrameBytes > 64 ? maxFrameBytes : MAX_FRAME_BYTES;
             this._WS = WebSocketPolyfill;
             this.shouldConnect = connect;
             initLifecycle(this, () => this.destroy(), () => room.depart(this));

package/dist/crdt/storage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The storage codec (P5) — what the room's rows and the IndexedDB store
+ * hold, apart from the wire (which stays v1 until the schema generation
+ * that changes it). Snapshots are written in the v2 (columnar) encoding
+ * and gzip-compressed where the platform has `CompressionStream`; update
+ * rows stay v1 (smaller for one keystroke). A compressed record starts
+ * with gzip's magic `1f 8b`, which no v2 update does (its first byte is
+ * the encoder's feature flag, `00`), so a v2 container's snapshot says
+ * itself whether it is compressed. Worker-safe: no timers, every
+ * platform API feature-detected.
+ */
+/** Whether `bytes` are gzip (its magic `1f 8b`). */
+export declare const isGzip: (bytes: Uint8Array) => boolean;
+/** Whether this platform compresses (`CompressionStream`). */
+export declare const canCompress: () => boolean;
+/** `bytes` gzip-compressed, or `null` where the platform has no `CompressionStream`. */
+export declare const gzip: (bytes: Uint8Array) => Promise<Uint8Array | null>;
+/** `bytes` as stored: inflated when gzip, else as they are. */
+export declare const gunzip: (bytes: Uint8Array) => Promise<Uint8Array>;
+/** `bytes` compressed when that makes them smaller (and the platform can), else as they are. */
+export declare const packed: (bytes: Uint8Array) => Promise<Uint8Array>;

package/dist/crdt/storage.js

@@ -0,0 +1,37 @@
+/**
+ * The storage codec (P5) — what the room's rows and the IndexedDB store
+ * hold, apart from the wire (which stays v1 until the schema generation
+ * that changes it). Snapshots are written in the v2 (columnar) encoding
+ * and gzip-compressed where the platform has `CompressionStream`; update
+ * rows stay v1 (smaller for one keystroke). A compressed record starts
+ * with gzip's magic `1f 8b`, which no v2 update does (its first byte is
+ * the encoder's feature flag, `00`), so a v2 container's snapshot says
+ * itself whether it is compressed. Worker-safe: no timers, every
+ * platform API feature-detected.
+ */
+/** Whether `bytes` are gzip (its magic `1f 8b`). */
+export const isGzip = (bytes) => bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b;
+const platform = globalThis;
+/** Run `bytes` through a (de)compression stream. */
+const through = async (bytes, transform) => {
+    const stream = new Response(bytes).body.pipeThrough(transform);
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+};
+/** Whether this platform compresses (`CompressionStream`). */
+export const canCompress = () => typeof platform.CompressionStream === 'function';
+/** `bytes` gzip-compressed, or `null` where the platform has no `CompressionStream`. */
+export const gzip = async (bytes) => platform.CompressionStream ? through(bytes, new platform.CompressionStream('gzip')) : null;
+/** `bytes` as stored: inflated when gzip, else as they are. */
+export const gunzip = async (bytes) => {
+    if (!isGzip(bytes))
+        return bytes;
+    if (!platform.DecompressionStream) {
+        throw new Error('a compressed record needs DecompressionStream, which this platform lacks');
+    }
+    return through(bytes, new platform.DecompressionStream('gzip'));
+};
+/** `bytes` compressed when that makes them smaller (and the platform can), else as they are. */
+export const packed = async (bytes) => {
+    const out = await gzip(bytes);
+    return out !== null && out.length < bytes.length ? out : bytes;
+};

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