edytor 1.0.0-rc.2 → 1.0.0

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

package/dist/crdt/providers/room.js

@@ -41,10 +41,8 @@
  * - `handlers` — ws adds `messageAuth` (the auth reply exists only on a
  *   server socket — a BC room has no authority to deny).
  */
-import * as bc from 'lib0-v14/broadcastchannel';
 import * as encoding from 'lib0-v14/encoding';
 import * as decoding from 'lib0-v14/decoding';
-import * as env from 'lib0-v14/environment';
 import * as promise from 'lib0-v14/promise';
 import { applyAwarenessUpdate, encodeAwarenessUpdate } from '../protocols/awareness.js';
 import { BARE_REPLY_LENGTH, frame, GENERATION, writeProtocolVersion } from '../protocols/envelope.js';
@@ -171,6 +169,37 @@ export const createChunkReader = (maxBytes = Infinity, admit = () => true) => {
 };
 /** An awareness frame carrying `clients`' entries of `states` (default: their current ones). */
 const awarenessFrame = (awareness, clients, states) => frame(messageAwareness, (e) => encoding.writeVarUint8Array(e, encodeAwarenessUpdate(awareness, clients, states)));
+const channels = new Map();
+const channelNamed = (room) => {
+    let c = channels.get(room);
+    if (c === undefined) {
+        const subs = new Set();
+        const bc = new BroadcastChannel(room);
+        bc.onmessage = (e) => subs.forEach((sub) => sub(e.data, null));
+        channels.set(room, (c = { bc, subs }));
+    }
+    return c;
+};
+/**
+ * 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 const tabs = {
+    subscribe: (room, f) => void channelNamed(room).subs.add(f),
+    unsubscribe: (room, f) => {
+        const c = channels.get(room);
+        if (c?.subs.delete(f) && c.subs.size === 0) {
+            c.bc.close();
+            channels.delete(room);
+        }
+    },
+    publish: (room, data, origin = null) => {
+        const c = channelNamed(room);
+        c.bc.postMessage(data);
+        c.subs.forEach((sub) => sub(data, origin));
+    }
+};
 /** The outbound quarantine: a read-only document does not spread. */
 export const quarantined = (doc) => checkSchema(asEngineDoc(doc)) !== null;
 /**
@@ -201,7 +230,7 @@ export const initLifecycle = (host, destroy, depart = () => { }) => {
     }
     else {
         const leave = () => void destroy();
-        const proc = (env.isNode ? globalThis.process : undefined) ?? {};
+        const proc = globalThis.process ?? {};
         proc.on?.('exit', leave);
         host._leave = () => proc.off?.('exit', leave);
     }
@@ -344,21 +373,9 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
                 // valid envelope surfaces through 'message-error'.
                 // A pending forged stamp this update would release is discarded
                 // (`discarded`) and reported the same way.
-                // A SyncStep2 is v2 on the wire: converted, then the one inbound path.
-                const payload = decoding.readVarUint8Array(decoder);
+                const update = decoding.readVarUint8Array(decoder);
                 const origin = emitSynced ? provider : (behavior.tabOrigin?.(provider) ?? provider);
                 const onError = (error) => provider.emit?.('message-error', [error, provider]);
-                let update;
-                try {
-                    update =
-                        syncMessageType === syncProtocol.messageYjsSyncStep2
-                            ? syncProtocol.step2Update(payload)
-                            : payload;
-                }
-                catch (error) {
-                    onError(error);
-                    return;
-                }
                 const { applied, problem, discarded } = syncProtocol.applyRemote(provider.doc, update, origin, onError);
                 const refused = problem ?? discarded;
                 if (refused) {
@@ -426,7 +443,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
     const channelOf = (provider) => behavior.roomChannel(provider);
     /** The BC subscriber: replies go back on the room channel. */
     const bcSubscriber = (provider) => {
-        const send = (buf) => bc.publish(channelOf(provider), buf, provider);
+        const send = (buf) => tabs.publish(channelOf(provider), buf, provider);
         return (data, origin) => {
             if (origin === provider)
                 return;
@@ -434,7 +451,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
                 readMessage(provider, new Uint8Array(data), false, send);
             }
             catch (error) {
-                // lib0 delivers same-tab publishes synchronously — a malformed
+                // same-tab publishes are delivered synchronously — a malformed
                 // message must not propagate into the publisher's call stack.
                 provider.emit?.('message-error', [error, provider]);
             }
@@ -477,12 +494,12 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
     const connectBc = (provider) => {
         const channel = channelOf(provider);
         if (!provider.bcconnected) {
-            bc.subscribe(channel, provider._bcSubscriber);
+            tabs.subscribe(channel, provider._bcSubscriber);
             provider.bcconnected = true;
         }
         const [sv, presence] = hello(provider);
         for (const buf of [sv, frame(messageQueryAwareness, () => { }), presence]) {
-            bc.publish(channel, buf, provider);
+            tabs.publish(channel, buf, provider);
         }
     };
     /** The departure announcement — our presence, removed — on every transport the provider speaks. */
@@ -491,7 +508,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
     const disconnectBc = (provider) => {
         depart(provider);
         if (provider.bcconnected) {
-            bc.unsubscribe(channelOf(provider), provider._bcSubscriber);
+            tabs.unsubscribe(channelOf(provider), provider._bcSubscriber);
             provider.bcconnected = false;
         }
     };

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

@@ -122,7 +122,7 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
             bcChannel: string;
             bcconnected: boolean;
             disableBc: boolean;
-            _bcSubscriber: (data: ArrayBuffer, origin: unknown) => void;
+            _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
             /** The transaction origin of updates heard from another tab. */
             _fromTab: {};
             wsUnsuccessfulReconnects: number;

package/dist/crdt/providers/websocket.js

@@ -31,7 +31,7 @@
  * via `'protocol-mismatch'`. A v13
  * y-websocket server in the room therefore cannot feed updates to this
  * provider (and vice versa) — see docs/crdt-v14-providers.md §server
- * classification: only an OPAQUE v1-update relay stays compatible; a server
+ * classification: only an OPAQUE relay stays compatible; a server
  * that participates in sync (like upstream `y-websocket-server`) must itself
  * run the vendored v14 engine + v14 protocol modules.
  *
@@ -46,7 +46,6 @@
  * re-sends a Step1 on the live socket for harnesses that drop frames
  * there (TCP never does).
  */
-import * as bc from 'lib0-v14/broadcastchannel';
 import * as decoding from 'lib0-v14/decoding';
 import * as time from 'lib0-v14/time';
 import * as math from 'lib0-v14/math';
@@ -57,7 +56,7 @@ import { messagePermissionDenied, messageReadOnly, READ_ONLY_DENIAL, readAuthMes
 import { bindSync } from '../protocols/sync.js';
 import { readCommentsMessage, writeCommentsSubscribe } from '../protocols/comments.js';
 import { frame } from '../protocols/envelope.js';
-import { assertRoomId, beginDestroy, bindRoomProtocol, chunkFrame, CLOSE, createChunkReader, emitFailed, initLifecycle, isRefusal, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
+import { assertRoomId, beginDestroy, bindRoomProtocol, tabs, chunkFrame, CLOSE, createChunkReader, emitFailed, initLifecycle, isRefusal, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
 import { asEngineDoc } from '../structs.js';
 import { ATTRIBUTION_ROOT } from '../schema.js';
 import { ATTRIBUTION_ORIGIN } from '../attribution/attribution.js';
@@ -95,7 +94,7 @@ export const bindWebsocketProvider = (Y) => {
     /** Traffic for the other tabs goes out on the channel. */
     const toTabs = (provider, buf) => {
         if (provider.bcconnected)
-            bc.publish(provider.bcChannel, buf, provider);
+            tabs.publish(provider.bcChannel, buf, provider);
     };
     /** Room traffic goes to the server and to the other tabs. */
     const broadcast = (provider, buf) => {

package/dist/crdt/purge.d.ts

@@ -13,8 +13,8 @@
  * held), a text delete mark record, a placement candidate.
  */
 import type { EngineApi, EngineDoc } from './engine-api.js';
-import type { PlacementModel } from './placement/model.js';
-import type { TextEngine } from './text/model.js';
+import { type PlacementModel } from './placement/model.js';
+import { type TextEngine } from './text/model.js';
 /** The horizon: the time and encoded state vector of the room's epoch (`room.purge.timing`). */
 export type Horizon = {
     at: number;

package/dist/crdt/purge.js

@@ -1,5 +1,8 @@
+import { view as modelView } from './placement/model.js';
+import { purgeStreams } from './text/model.js';
 import { AT, BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, isNodeLike, REC_PREFIX, REGISTRY_KEY, WITHDRAW_PREFIX } from './schema.js';
 import { bindDeletes } from './text/deletes.js';
+import { deleteIndex } from './text/delete-index.js';
 import { baseIdOf, isIncarnationId } from './incarnations.js';
 import { attrItems, firstItem } from './structs.js';
 const mapOf = (node) => attrItems(node);
@@ -12,14 +15,74 @@ export const readHorizon = (doc) => {
 };
 export const bindPurge = (Y) => {
     const D = bindDeletes(Y);
+    const { rootSpans, holders, dropMarks, recordsIn, copiesOf, liveRoots, forget, collect } = deleteIndex(Y);
+    /**
+     * Whether every live mark holding a character of `spans` was written
+     * where `old` says (a withdrawn block's content was deleted
+     * before the horizon). Characters no mark holds count as old.
+     */
+    const heldBefore = (doc, spans, old) => {
+        const s = D.state(doc);
+        return spans
+            .flatMap((sp) => rootSpans(s, sp))
+            .every((r) => holders(s, r).every((mark) => old(mark.client, mark.clock)));
+    };
+    /**
+     * The text's part (`room.purge.what`), inside the purge
+     * transaction: delete every text delete mark record `old` names, and
+     * every restoration record `old` names whose copies are all deleted
+     * and that no remaining mark holds; its copies are forgotten (the
+     * `gcFilter` no longer keeps them) and collected. Writes no mark.
+     */
+    const purgeText = (doc, old) => {
+        const s = D.state(doc);
+        const tr = s.doc._transaction;
+        if (tr === null)
+            throw new Error('purge: outside a transaction');
+        const spans = [];
+        const dropped = [];
+        for (let it = firstItem(s.marks); it; it = it.right)
+            if (!it.deleted)
+                for (let j = 0; j < it.length; j++) {
+                    const r = { client: it.id.client, clock: it.id.clock + j };
+                    if (!old(r.client, r.clock))
+                        continue;
+                    dropped.push(r);
+                    const last = spans[spans.length - 1];
+                    if (last !== undefined && last.c === r.client && last.k + last.n === r.clock)
+                        last.n++;
+                    else
+                        spans.push({ c: r.client, k: r.clock, n: 1 });
+                }
+        dropMarks(s, dropped);
+        const marks = dropped.length;
+        D.remove(tr, spans);
+        const doomed = [];
+        attrItems(s.restored).forEach((it, key) => {
+            if (it.deleted || !old(it.id.client, it.id.clock))
+                return;
+            const [record, bytes] = recordsIn(it, null)[0] ?? [];
+            if (bytes === undefined)
+                return;
+            const copies = copiesOf(record, bytes);
+            const dead = copies.every((e) => liveRoots(s, { c: e.c, k: e.k, n: e.n, rk: e.k }).length === 0 &&
+                holders(s, { c: e.rc, k: e.rk, n: e.n }).length === 0);
+            if (dead)
+                doomed.push({ key, copies });
+        });
+        for (const { key, copies } of doomed) {
+            s.restored.deleteAttr(key);
+            forget(s, copies);
+            collect(s, tr, copies);
+        }
+        return { marks, records: doomed.length };
+    };
     /**
      * Purge from `doc` (through `facade`, the facade over it) what was
      * deleted before `horizon`, and write the horizon record. Runs inside the
      * caller's transaction.
      */
     const purge = (doc, facade, horizon) => {
-        const M = facade.model;
-        const T = facade.text;
         const report = {
             removed: 0,
             emptied: 0,
@@ -32,7 +95,7 @@ export const bindPurge = (Y) => {
         const vector = Y.decodeStateVector(horizon.sv);
         const old = (client, clock) => clock < (vector.get(client) ?? 0);
         const oldItem = (item) => item !== undefined && !item.deleted && old(item.id.client, item.id.clock);
-        const view = M.view(doc);
+        const view = modelView(doc);
         const { blocks, own, placements } = view;
         const marks = (node, prefix) => [...node.attrKeys()]
             .filter((key) => key.startsWith(prefix))
@@ -93,7 +156,7 @@ export const bindPurge = (Y) => {
                 if (dead.has(id))
                     continue;
                 const s = own.streamOf(id);
-                if (s !== undefined && !D.heldBefore(doc, regionSpans(s), old))
+                if (s !== undefined && !heldBefore(doc, regionSpans(s), old))
                     continue;
                 const left = (children.get(id) ?? []).every((child) => {
                     const rec = blocks.get(child);
@@ -157,7 +220,7 @@ export const bindPurge = (Y) => {
         // A deleted block that stays: its stream's text (boundaries kept), its
         // data leaves and its claims.
         const emptied = [...dead].filter((id) => !removable.has(id));
-        T.purgeStreams(emptied.flatMap((id) => {
+        purgeStreams(emptied.flatMap((id) => {
             const s = own.streamOf(id);
             return s === undefined || s.end - s.start <= s.inert.length ? [] : [s];
         }));
@@ -250,7 +313,7 @@ export const bindPurge = (Y) => {
             report.candidates += rec.cands.length - 1;
         }
         // Text delete marks and restoration records past the horizon.
-        const text = D.purge(doc, old);
+        const text = purgeText(doc, old);
         report.marks = text.marks;
         report.records = text.records;
         // The horizon record, last.