edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/providers/index.js

@@ -13,8 +13,8 @@ export const bindProviders = (Y) => {
             provider.on('failed', failed);
         return () => provider.destroy();
     }, { bound: Infinity, target: `indexeddb:${name}` });
-    /** A document stored only here: a generation-4 store of `name` converts into it (the cutover). */
-    const createIndexeddbSync = (name) => localSync(name, { convertPrevious: true });
+    /** A document stored only here. */
+    const createIndexeddbSync = (name) => localSync(name);
     /**
      * The socket, and by default a local store beside it. The store is its
      * own provider on the document (`attach`), so the document's readiness
@@ -107,116 +107,7 @@ 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.
-     * The target is `{ server, room }`; the names before them are refused, in
-     * a message that names the `caller` it was passed to.
-     */
-    const targetOf = (caller, options) => {
-        const { server, room } = options;
-        if (typeof server !== 'string' || typeof room !== 'string')
-            throw new TypeError(`${caller}: the target is \`server\` and \`room\` (\`serverUrl\` and \`roomName\` are gone)`);
-        assertRoomId(room);
-        return [server.replace(/\/+$/, ''), room];
-    };
-    /**
-     * Keep a document fresh without opening it: 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('prefetch', options);
-        if (typeof indexedDB === 'undefined') {
-            return Promise.reject(new TypeError('prefetch needs IndexedDB to keep the document'));
-        }
-        const doc = keepingReplaced(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`:
-     * 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('lastUpdated', 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;
-    };
-    /**
-     * The room's document as JSON, or `null` when it stores nothing yet:
-     * one authorized HTTP `GET <server>/<room>?snapshot`, which
-     * `routeDocumentSocket` answers from the room's live document. Show it
-     * while a view's own copy hydrates: `<Edytor snapshot>`. Throws on an
-     * HTTP error (`403` refused, `401` expired).
-     */
-    const documentSnapshot = async (options) => {
-        const [serverUrl, room] = targetOf('documentSnapshot', 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('snapshot', '1');
-        const response = await (options.fetch ?? fetch)(url.toString());
-        if (!response.ok) {
-            throw new Error(`snapshot of ${room}: ${response.status} ${await response.text()}`);
-        }
-        const { lastUpdated: at, document } = (await response.json());
-        return typeof at === 'number' ? document : null;
-    };
     return {
-        prefetch,
-        lastUpdated,
-        documentSnapshot,
         IndexeddbPersistence: idb.IndexeddbPersistence,
         WebsocketProvider: ws.WebsocketProvider,
         watchComments: ws.watchComments,
@@ -227,3 +118,107 @@ export const bindProviders = (Y) => {
         createWebsocketSync
     };
 };
+/**
+ * `[serverUrl (no trailing slash), room]` of a target, the room id checked.
+ * The target is `{ server, room }`; the names before them are refused, in
+ * a message that names the `caller` it was passed to.
+ */
+export const targetOf = (caller, options) => {
+    const { server, room } = options;
+    if (typeof server !== 'string' || typeof room !== 'string')
+        throw new TypeError(`${caller}: the target is \`server\` and \`room\``);
+    assertRoomId(room);
+    return [server.replace(/\/+$/, ''), room];
+};
+/**
+ * Keep a document fresh without opening it: 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. Over the provider
+ * classes of `stack` (bound to `Y`).
+ */
+export const prefetchWith = (Y, stack, options) => {
+    const [serverUrl, room] = targetOf('prefetch', options);
+    if (typeof indexedDB === 'undefined') {
+        return Promise.reject(new TypeError('prefetch needs IndexedDB to keep the document'));
+    }
+    const doc = keepingReplaced(new Y.Doc());
+    const local = new stack.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 stack.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);
+    });
+};
+/**
+ * One authorized HTTP `GET <server>/<room>?<key>` (`lastUpdated`,
+ * `snapshot`), which `routeDocumentSocket` answers without a socket: its
+ * JSON. Throws on an HTTP error (`403` refused, `401` expired).
+ */
+const query = async (caller, key, options) => {
+    const [serverUrl, room] = targetOf(caller, options);
+    const url = new URL(`${serverUrl.replace(/^ws/, 'http')}/${encodeURIComponent(room)}`);
+    for (const [name, value] of Object.entries(options.params ?? {}))
+        url.searchParams.set(name, value);
+    url.searchParams.set(key, '1');
+    const response = await (options.fetch ?? fetch)(url.toString());
+    if (!response.ok) {
+        throw new Error(`${key} of ${room}: ${response.status} ${await response.text()}`);
+    }
+    return (await response.json());
+};
+/**
+ * When the room last stored a change (ms since the epoch), or `null`:
+ * `?lastUpdated`, answered 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).
+ */
+export const lastUpdated = async (options) => {
+    const { lastUpdated: at } = await query('lastUpdated', 'lastUpdated', options);
+    return typeof at === 'number' ? at : null;
+};
+/**
+ * The room's document as JSON, or `null` when it stores nothing yet:
+ * `?snapshot`, answered from the room's live document. Show it while a
+ * view's own copy hydrates: `<Edytor snapshot>`. Throws on an HTTP error
+ * (`403` refused, `401` expired).
+ */
+export const documentSnapshot = async (options) => {
+    const { lastUpdated: at, document } = await query('documentSnapshot', 'snapshot', options);
+    return typeof at === 'number' ? document : null;
+};

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

@@ -16,16 +16,6 @@ export type IndexeddbPersistenceOptions = {
     awareness?: Awareness;
     /** Stay off the BroadcastChannel room (no cross-tab sync): storage only. */
     disableBc?: boolean;
-    /**
-     * Convert the generation-4 store of the same name (`edytor-v14:<name>`)
-     * into this one when this one is empty (the generation cutover): its
-     * visible document is read as JSON and seeded as this generation's.
-     * For a document stored only here; a document a room keeps takes its
-     * state from the room instead (two replicas seeding different
-     * conversions of one document would collide). Default `false`;
-     * `createIndexeddbSync` sets it.
-     */
-    convertPrevious?: boolean;
 };
 export type IndexeddbProvider = ReturnType<typeof bindIndexeddbProvider>;
 /** Instance type of the bound provider class. */
@@ -60,7 +50,7 @@ export declare const bindIndexeddbProvider: (Y: EngineApi) => {
             bcconnected: boolean;
             disableBc: boolean;
             _ownsAwareness: boolean;
-            _bcSubscriber: (data: ArrayBuffer, origin: unknown) => void;
+            _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
             _awarenessUpdateHandler: (updates: {
                 added: number[];
                 updated: number[];
@@ -201,6 +191,6 @@ export declare const bindIndexeddbProvider: (Y: EngineApi) => {
         };
     };
     storeState: (idbPersistence: IdbPersistenceLike, forceStore?: boolean) => Promise<undefined>;
-    clearDocument: (name: string) => Promise<any>;
+    clearDocument: (name: string) => Promise<void>;
     PREFERRED_TRIM_SIZE: number;
 };

package/dist/crdt/providers/indexeddb.js

@@ -5,8 +5,8 @@
  *
  * Semantics preserved from the v13 provider:
  *
- * - `updates` object store (auto-increment keys) holds raw V1 update rows
- *   wrapped in a fresh ArrayBuffer (`container.ts`); `custom` holds the
+ * - `updates` object store (auto-increment keys) holds update rows, each
+ *   in a fresh ArrayBuffer (`container.ts`); `custom` holds the
  *   generation record.
  * - `PREFERRED_TRIM_SIZE = 500`: past it, a debounced `storeState` appends a
  *   compacted `encodeStateAsUpdate` snapshot and deletes prior rows. Every
@@ -21,8 +21,8 @@
  *
  * The generation gate (see `protocols/envelope.ts`):
  *
- * - STORAGE: the database name is `edytor-v14-g5:<name>` (`edytor-v14:<name>` up to schema generation 4); legacy v13
- *   databases (`<name>`) are never opened here. A `generation` record
+ * - STORAGE: the database name is `edytor-v14-g<schema>:<name>`; another
+ *   generation's database is never opened here. A `generation` record
  *   (engine, protocol, schema) in `custom` is written on creation and
  *   verified before any row is applied — a container of another
  *   generation fails the load; nothing inside a row is inspected.
@@ -34,64 +34,20 @@
  * The engine module is injected (`bindIndexeddbProvider(Y)`) — `src/lib`
  * never runtime-imports the vendored `.js`.
  */
-import * as idb from 'lib0-v14/indexeddb';
 import * as promise from 'lib0-v14/promise';
-import * as bc from 'lib0-v14/broadcastchannel';
 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 { GENERATION_KEY, generationDbName, PREVIOUS_GENERATION_PREFIX, STORED_GENERATION_RECORD } from '../protocols/envelope.js';
-import { bindGenerations } from '../migration/generation.js';
-import { CUSTOM as customStoreName, encodeRow, openContainer, openIfExists, readRow, snapshotRow, UPDATES as updatesStoreName, verifyOrStamp } from './container.js';
-import { beginDestroy, bindRoomProtocol, emitFailed, initLifecycle, markSynced, quarantined } from './room.js';
+import { generationDbName } from '../protocols/envelope.js';
+import { CUSTOM as customStoreName, encodeRow, lastKey, openContainer, readRow, rtop, snapshotRow, storesOf, UPDATES as updatesStoreName, verifyOrStamp } from './container.js';
+import { beginDestroy, bindRoomProtocol, tabs, emitFailed, initLifecycle, markSynced, quarantined } from './room.js';
 export const PREFERRED_TRIM_SIZE = 500;
 /**
  * Bind the IndexedDB persistence provider to the vendored v14 engine module.
  */
 export const bindIndexeddbProvider = (Y) => {
     const syncProtocol = bindSync(Y);
-    const generations = bindGenerations(Y);
-    /**
-     * The generation cutover of a local store (`IndexeddbPersistenceOptions.convertPrevious`):
-     * when `db` is empty and the generation-4 store of `name` exists, its
-     * visible document is read as JSON and this generation's seed of it is
-     * written as `db`'s first row, with the generation record, in one
-     * transaction. The generation-4 store is left as it was.
-     */
-    const convertPrevious = async (name, db) => {
-        const [updates, custom] = idb.transact(db, [updatesStoreName, customStoreName], 'readonly');
-        // Both requests before either settles: one transaction.
-        const reads = [idb.get(custom, GENERATION_KEY), idb.count(updates)];
-        const found = await reads[0];
-        if (found !== undefined || (await reads[1]) > 0)
-            return;
-        const old = await openIfExists(PREVIOUS_GENERATION_PREFIX + name);
-        if (old === null)
-            return;
-        try {
-            if (!old.objectStoreNames.contains(customStoreName))
-                return;
-            const [oldUpdates, oldCustom] = idb.transact(old, [updatesStoreName, customStoreName], 'readonly');
-            const reads = [idb.get(oldCustom, GENERATION_KEY), idb.getAll(oldUpdates)];
-            const record = await reads[0];
-            const stored = await reads[1];
-            if (!generations.isPreviousGenerationRecord(record))
-                return;
-            const rows = await promise.all(stored.map(readRow));
-            if (rows.length === 0)
-                return;
-            const seed = generations.seedOf(generations.previousJSONWith(rows));
-            const [newUpdates, newCustom] = idb.transact(db, [updatesStoreName, customStoreName]);
-            await promise.all([
-                idb.rtop(newCustom.put({ ...STORED_GENERATION_RECORD }, GENERATION_KEY)),
-                idb.addAutoKey(newUpdates, encodeRow(seed))
-            ]);
-        }
-        finally {
-            old.close();
-        }
-    };
     /**
      * The shared room protocol — dispatch, the join rule, awareness
      * flow, BC subscriber + join/leave, the lifecycle. This provider keeps
@@ -112,17 +68,15 @@ export const bindIndexeddbProvider = (Y) => {
      */
     const fetchUpdates = (idbPersistence, beforeApplyUpdatesCallback = () => { }, afterApplyUpdatesCallback = () => { }) => {
         const db = idbPersistence.db;
-        const [updatesStore, customStore] = idb.transact(db, [updatesStoreName, customStoreName]);
+        const [updatesStore, customStore] = storesOf(db, [updatesStoreName, customStoreName]);
         return verifyOrStamp(idbPersistence.name, updatesStore, customStore)
-            .then(() => idb.getAll(updatesStore, idb.createIDBKeyRangeLowerBound(idbPersistence._dbref, false)))
+            .then(() => rtop(updatesStore.getAll(IDBKeyRange.lowerBound(idbPersistence._dbref, false))))
             .then((rows) => {
             // The pre-hydration state row is written before the last key is read.
             if (!idbPersistence._destroyed)
                 beforeApplyUpdatesCallback(updatesStore);
-            return promise
-                .all([idb.getLastKey(updatesStore), idb.count(updatesStore)])
-                .then(([lastKey, cnt]) => {
-                idbPersistence._dbref = lastKey + 1;
+            return Promise.all([lastKey(updatesStore), rtop(updatesStore.count())]).then(([last, cnt]) => {
+                idbPersistence._dbref = Number(last) + 1;
                 idbPersistence._dbsize = cnt;
                 return promise.all(rows.map(readRow));
             });
@@ -131,20 +85,16 @@ export const bindIndexeddbProvider = (Y) => {
             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);
-                }
+                for (const update of updates)
+                    Y.applyUpdate(idbPersistence.doc, update);
             }, idbPersistence, false);
             afterApplyUpdatesCallback();
         });
     };
-    /** One transaction: the snapshot row, the rows below `below` deleted, the record stamped `'v2'`. */
+    /** One transaction: the snapshot row, the rows below `below` deleted. */
     const writeSnapshot = (idbPersistence, row, below) => {
         const db = idbPersistence.db;
-        const [updatesStore, customStore] = idb.transact(db, [updatesStoreName, customStoreName]);
+        const [updatesStore] = storesOf(db, [updatesStoreName]);
         // Track transaction commit: listeners attach while it is still active.
         const tx = updatesStore.transaction;
         const transactionDone = promise.create((resolve, reject) => {
@@ -153,12 +103,9 @@ export const bindIndexeddbProvider = (Y) => {
         });
         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) => {
+            rtop(updatesStore.add(row))
+                .then(() => rtop(updatesStore.delete(IDBKeyRange.upperBound(below, true))))
+                .then(() => rtop(updatesStore.count()).then((cnt) => {
                 idbPersistence._dbsize = cnt;
             })),
             transactionDone
@@ -168,9 +115,8 @@ export const bindIndexeddbProvider = (Y) => {
     /**
      * 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 snapshot is v2, gzip-compressed where the
-     * platform can, and the container's generation record is stamped
-     * with its storage format in the same transaction.
+     * the rows it subsumes. The snapshot is gzip-compressed where the
+     * platform can and that makes it smaller.
      *
      * Every applied row is represented in the snapshot, so deleting
      * `key < _dbref` (read before the snapshot is compressed: rows stored
@@ -195,13 +141,13 @@ export const bindIndexeddbProvider = (Y) => {
             return undefined;
         }
         const below = idbPersistence._dbref;
-        return snapshotRow(Y.encodeStateAsUpdateV2(idbPersistence.doc)).then((row) => idbPersistence._destroyed ? undefined : writeSnapshot(idbPersistence, row, below));
+        return snapshotRow(Y.encodeStateAsUpdate(idbPersistence.doc)).then((row) => idbPersistence._destroyed ? undefined : writeSnapshot(idbPersistence, row, below));
     });
     /**
-     * Delete a v14 generation database by LOGICAL name (the `edytor-v14-g5:`
-     * prefix is applied here; a generation-4 store, `edytor-v14:`, is left). Never touches the legacy v13 database.
+     * Delete this generation's database by LOGICAL name (the generation
+     * prefix is applied here; another generation's store is left).
      */
-    const clearDocument = (name) => idb.deleteDB(generationDbName(name));
+    const clearDocument = (name) => rtop(indexedDB.deleteDatabase(generationDbName(name))).then(() => undefined);
     /**
      * Each provider's doc-`destroy` listener: it ends the provider (it never
      * rejects: the close is caught). Kept off the class, so it is not part
@@ -247,12 +193,7 @@ export const bindIndexeddbProvider = (Y) => {
             this.awareness = options.awareness ?? new Awareness(doc);
             this._ownsAwareness = !options.awareness;
             this.disableBc = options.disableBc === true;
-            this._db = openContainer(this.dbName).then((db) => options.convertPrevious === true
-                ? convertPrevious(name, db).then(() => db, (error) => {
-                    db.close();
-                    throw error;
-                })
-                : db);
+            this._db = openContainer(this.dbName);
             this.destroy = this.destroy.bind(this);
             initLifecycle(this, this.destroy, () => room.depart(this));
             this._bcSubscriber = room.bcSubscriber(this);
@@ -275,9 +216,7 @@ export const bindIndexeddbProvider = (Y) => {
                 // A read-only doc's pre-hydration state is never persisted.
                 const beforeApplyUpdatesCallback = (updatesStore) => {
                     if (!quarantined(doc)) {
-                        idb
-                            .addAutoKey(updatesStore, encodeRow(Y.encodeStateAsUpdate(doc)))
-                            .catch((error) => this.emit('message-error', [error, this]));
+                        rtop(updatesStore.add(encodeRow(Y.encodeStateAsUpdate(doc)))).catch((error) => this.emit('message-error', [error, this]));
                     }
                 };
                 // Hydrated: join the room and claim `synced` (lifetime).
@@ -311,10 +250,10 @@ export const bindIndexeddbProvider = (Y) => {
                     return;
                 if (this.db) {
                     try {
-                        const [updatesStore] = idb.transact(this.db, [updatesStoreName]);
+                        const [updatesStore] = storesOf(this.db, [updatesStoreName]);
                         // Storage failures must surface — never an unobserved
                         // rejection (the error channel observes every failure mode).
-                        idb.addAutoKey(updatesStore, encodeRow(update)).catch((error) => {
+                        rtop(updatesStore.add(encodeRow(update))).catch((error) => {
                             this.emit('message-error', [error, this]);
                         });
                         if (++this._dbsize >= PREFERRED_TRIM_SIZE) {
@@ -362,7 +301,7 @@ export const bindIndexeddbProvider = (Y) => {
         readMessage = (buf, emitSynced) => room.readMessage(this, buf, emitSynced);
         broadcastMessage(buf) {
             if (this.bcconnected) {
-                bc.publish(this.dbName, buf, this);
+                tabs.publish(this.dbName, buf, this);
             }
         }
         /** Join the BC room (after hydration; again after `disconnectBc`). */

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

@@ -1,3 +1,46 @@
+/**
+ * Room protocol — the transport-agnostic half of the two providers.
+ *
+ * Both providers speak the same enveloped protocol
+ * (`protocols/envelope.ts`) — the IndexedDB provider on one
+ * BroadcastChannel room per document, the websocket provider on its
+ * socket plus the same BroadcastChannel room (cross-tab, on by default): the generation word,
+ * the message-type dispatch, the sync handler, and the awareness
+ * publish/query flow are identical between them — this module is their
+ * ONE owner. It owns:
+ *
+ * - the two schema rules that bytes of a proven generation
+ *   still need: the inbound refusal of an update that writes a foreign
+ *   schema stamp (reported, never integrated), and the outbound quarantine
+ *   of a read-only document (it answers no state request, publishes no
+ *   update);
+ * - ONE join rule, derived from state vectors, identical on the socket and
+ *   the BroadcastChannel and correct behind an opaque relay: joining
+ *   sends a hello (Step1 + presence); a Step1 is answered with a Step2 and,
+ *   when the asker holds anything we lack, with our own Step1. Once two
+ *   replicas have each received one Step1 from the other, each holds the
+ *   other's state — no periodic resync is needed for that;
+ * - the provider lifecycle: `hasSynced` (lifetime) apart from a
+ *   transport's `connected`/`synced` (transient), the terminal `failed`
+ *   (once, never after `hasSynced`), `whenSynced`, the destroy guard, and
+ *   the departure announcement (leaving the page destroys the provider,
+ *   which announces its presence removal on every transport it speaks).
+ *
+ * `bindRoomProtocol(syncProtocol, behavior)` is bound once per provider
+ * class; the returned handle takes the provider instance on every call.
+ * Real per-provider differences stay in the behavior hooks:
+ *
+ * - `broadcast` — ws sends room traffic on its socket and the BC channel;
+ *   idb's on the BC channel (`roomChannel`).
+ * - `tabOrigin` — ws applies an update heard from another tab under its own
+ *   origin, so it can relay that update to the server (idb skips it: the
+ *   other tab stored it in the same database).
+ * - `heard` — ws claims its connection's `synced` when it holds a member's
+ *   state (an applied Step2, or a Step1 it covers, received on the
+ *   socket); idb's `synced` is its local-hydration claim.
+ * - `handlers` — ws adds `messageAuth` (the auth reply exists only on a
+ *   server socket — a BC room has no authority to deny).
+ */
 import * as encoding from 'lib0-v14/encoding';
 import * as decoding from 'lib0-v14/decoding';
 import { type Awareness, type AwarenessUpdate } from '../protocols/awareness.js';
@@ -69,6 +112,18 @@ export type SchemaMismatchDetail = {
     docName: string;
     problem: SchemaProblem;
 };
+/** A tab channel's subscriber: the bytes and who published them (`null`: another tab). */
+type TabSubscriber = (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
+/**
+ * The tabs of one browser, by room name: one `BroadcastChannel` per room,
+ * shared by this tab's subscribers. A publish reaches the other tabs and,
+ * at once, this tab's other subscribers (with the publisher as origin).
+ */
+export declare const tabs: {
+    subscribe: (room: string, f: TabSubscriber) => void;
+    unsubscribe: (room: string, f: TabSubscriber) => void;
+    publish: (room: string, data: Uint8Array | ArrayBuffer, origin?: unknown) => void;
+};
 /** The outbound quarantine: a read-only document does not spread. */
 export declare const quarantined: (doc: YDoc) => boolean;
 /** The lifecycle a provider carries — installed by {@link initLifecycle}. */
@@ -189,7 +244,7 @@ export type RoomProvider<P> = LifecycleHost & {
 /** A provider that joins the BroadcastChannel room. */
 export type BcMember = {
     bcconnected: boolean;
-    _bcSubscriber: (data: ArrayBuffer, origin: unknown) => void;
+    _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
 };
 /** Per-provider hooks — the real differences between the two transports. */
 export type RoomBehavior<P> = {
@@ -220,7 +275,7 @@ export type RoomBehavior<P> = {
 export declare const bindRoomProtocol: <P extends RoomProvider<P>>(syncProtocol: SyncProtocol, behavior: RoomBehavior<P>) => {
     messageHandlers: Record<number, RoomMessageHandler<P>>;
     readMessage: (provider: P, buf: Uint8Array, emitSynced: boolean, send?: (frame: Uint8Array) => void) => encoding.Encoder;
-    bcSubscriber: (provider: P) => (data: ArrayBuffer, origin: unknown) => void;
+    bcSubscriber: (provider: P) => (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
     awarenessUpdateHandler: (provider: P) => ({ added, updated, removed }: AwarenessUpdate, origin: unknown) => void;
     broadcastUpdate: (provider: P, update: Uint8Array, via?: (provider: P, buf: Uint8Array) => void) => void;
     step1: (provider: P) => Uint8Array<ArrayBufferLike>;
@@ -229,3 +284,4 @@ export declare const bindRoomProtocol: <P extends RoomProvider<P>>(syncProtocol:
     connectBc: (provider: P & BcMember) => void;
     disconnectBc: (provider: P & BcMember) => void;
 };
+export {};