edytor 5.0.0 → 7.0.0

package/dist/crdt/protocol.js

@@ -30,9 +30,9 @@ export { bindCrdt } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
 export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
 // ── Message types, acknowledgements and chunks ─────────────────────────
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, CLOSE } from './providers/room.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, messageRebase, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate } from './protocols/sync.js';
-export { messageAccess, messagePermissionDenied, messageReadOnly, writeAccess, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
+export { messageAccess, messageEpoch, messagePermissionDenied, messageReadOnly, writeAccess, writeEpoch, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage } from './protocols/comments.js';
 export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries } from './protocols/awareness.js';
 // Minimal wire codec for frame bodies (lib0 — the codec the frames are

package/dist/crdt/protocols/auth.d.ts

@@ -28,6 +28,13 @@ export declare const writeReadOnly: (encoder: encoding.Encoder) => void;
  */
 export declare const messageAccess = 2;
 export declare const writeAccess: (encoder: encoding.Encoder, access: string) => void;
+/**
+ * The room's epoch (`room.reseed.protocol`), sent to a socket that dialed an
+ * older one, instead of anything else: the room asks it for its old
+ * document (`messageRebase`), then closes it `4410`.
+ */
+export declare const messageEpoch = 3;
+export declare const writeEpoch: (encoder: encoding.Encoder, epoch: number) => void;
 export type PermissionDeniedHandler = (ydoc: unknown, reason: string) => void;
 /**
  * Decode one auth payload. Returns the auth message subtype so the caller
@@ -35,4 +42,4 @@ export type PermissionDeniedHandler = (ydoc: unknown, reason: string) => void;
  * do not speak is protocol skew, and this stack's contract is that skew is
  * reported, not silently dropped (same rule as unknown sync subtypes).
  */
-export declare const readAuthMessage: (decoder: decoding.Decoder, y: unknown, permissionDeniedHandler: PermissionDeniedHandler, readOnlyHandler?: (ydoc: unknown) => void, accessHandler?: (access: string) => void) => number;
+export declare const readAuthMessage: (decoder: decoding.Decoder, y: unknown, permissionDeniedHandler: PermissionDeniedHandler, readOnlyHandler?: (ydoc: unknown) => void, accessHandler?: (access: string) => void, epochHandler?: (epoch: number) => void) => number;

package/dist/crdt/protocols/auth.js

@@ -36,13 +36,23 @@ export const writeAccess = (encoder, access) => {
     encoding.writeVarUint(encoder, messageAccess);
     encoding.writeVarString(encoder, access);
 };
+/**
+ * The room's epoch (`room.reseed.protocol`), sent to a socket that dialed an
+ * older one, instead of anything else: the room asks it for its old
+ * document (`messageRebase`), then closes it `4410`.
+ */
+export const messageEpoch = 3;
+export const writeEpoch = (encoder, epoch) => {
+    encoding.writeVarUint(encoder, messageEpoch);
+    encoding.writeVarUint(encoder, epoch);
+};
 /**
  * Decode one auth payload. Returns the auth message subtype so the caller
  * can surface unknown subtypes — a valid envelope carrying an auth type we
  * do not speak is protocol skew, and this stack's contract is that skew is
  * reported, not silently dropped (same rule as unknown sync subtypes).
  */
-export const readAuthMessage = (decoder, y, permissionDeniedHandler, readOnlyHandler, accessHandler) => {
+export const readAuthMessage = (decoder, y, permissionDeniedHandler, readOnlyHandler, accessHandler, epochHandler) => {
     const authMessageType = decoding.readVarUint(decoder);
     switch (authMessageType) {
         case messagePermissionDenied:
@@ -54,6 +64,9 @@ export const readAuthMessage = (decoder, y, permissionDeniedHandler, readOnlyHan
             break;
         case messageAccess:
             accessHandler?.(decoding.readVarString(decoder));
+            break;
+        case messageEpoch:
+            epochHandler?.(decoding.readVarUint(decoder));
     }
     return authMessageType;
 };

package/dist/crdt/protocols/awareness.js

@@ -94,41 +94,19 @@ export class Awareness extends IsolatedObservable {
     }
     setLocalState(state) {
         const clientID = this.clientID;
-        const currLocalMeta = this.meta.get(clientID);
-        const clock = currLocalMeta === undefined ? 0 : currLocalMeta.clock + 1;
         const prevState = this.states.get(clientID);
-        if (state === null) {
-            this.states.delete(clientID);
-        }
+        put(this, clientID, (this.meta.get(clientID)?.clock ?? -1) + 1, state, time.getUnixTime());
+        const changes = noChanges();
+        if (state === null)
+            changes.removed.push(clientID);
+        else if (prevState == null)
+            changes.added.push(clientID);
         else {
-            this.states.set(clientID, state);
-        }
-        this.meta.set(clientID, {
-            clock,
-            lastUpdated: time.getUnixTime()
-        });
-        const added = [];
-        const updated = [];
-        const filteredUpdated = [];
-        const removed = [];
-        if (state === null) {
-            removed.push(clientID);
+            changes.updated.push(clientID);
+            if (!jsonEquals(prevState, state))
+                changes.changed.push(clientID);
         }
-        else if (prevState == null) {
-            if (state != null) {
-                added.push(clientID);
-            }
-        }
-        else {
-            updated.push(clientID);
-            if (!jsonEquals(prevState, state)) {
-                filteredUpdated.push(clientID);
-            }
-        }
-        if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
-            this.emit('change', [{ added, updated: filteredUpdated, removed }, 'local']);
-        }
-        this.emit('update', [{ added, updated, removed }, 'local']);
+        emitChanges(this, changes, 'local', true);
     }
     setLocalStateField(field, value) {
         const state = this.getLocalState();
@@ -143,30 +121,40 @@ export class Awareness extends IsolatedObservable {
         return this.states;
     }
 }
+const noChanges = () => ({ added: [], updated: [], changed: [], removed: [] });
+/** Write client `clientID`'s `state` (`null`: removed) at `clock`, heard `now`. */
+const put = (awareness, clientID, clock, state, now) => {
+    if (state === null)
+        awareness.states.delete(clientID);
+    else
+        awareness.states.set(clientID, state);
+    awareness.meta.set(clientID, { clock, lastUpdated: now });
+};
+/**
+ * Emit a change: `change` when a client was added, removed or changed its
+ * state, `update` when one was touched at all (`always`: even when none was).
+ */
+const emitChanges = (awareness, { added, updated, changed, removed }, origin, always = false) => {
+    if (added.length > 0 || changed.length > 0 || removed.length > 0)
+        awareness.emit('change', [{ added, updated: changed, removed }, origin]);
+    if (always || added.length > 0 || updated.length > 0 || removed.length > 0)
+        awareness.emit('update', [{ added, updated, removed }, origin]);
+};
 /**
  * Mark (remote) clients as inactive and remove them from the list of active
  * peers. This change is propagated to remote clients.
  */
 export const removeAwarenessStates = (awareness, clients, origin) => {
-    const removed = [];
-    for (let i = 0; i < clients.length; i++) {
-        const clientID = clients[i];
+    const changes = noChanges();
+    for (const clientID of clients) {
         if (awareness.states.has(clientID)) {
             awareness.states.delete(clientID);
-            if (clientID === awareness.clientID) {
-                const curMeta = awareness.meta.get(clientID);
-                awareness.meta.set(clientID, {
-                    clock: curMeta.clock + 1,
-                    lastUpdated: time.getUnixTime()
-                });
-            }
-            removed.push(clientID);
+            if (clientID === awareness.clientID)
+                put(awareness, clientID, awareness.meta.get(clientID).clock + 1, null, time.getUnixTime());
+            changes.removed.push(clientID);
         }
     }
-    if (removed.length > 0) {
-        awareness.emit('change', [{ added: [], updated: [], removed }, origin]);
-        awareness.emit('update', [{ added: [], updated: [], removed }, origin]);
-    }
+    emitChanges(awareness, changes, origin);
 };
 /** The update carrying `clients`' entries of `awareness` (their states in `states`). */
 export const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => writeAwarenessEntries(clients.map((clientID) => ({
@@ -202,36 +190,19 @@ export const writeAwarenessEntries = (entries) => encoding.encode((encoder) => {
  */
 export const applyAwarenessUpdate = (awareness, update, origin) => {
     const timestamp = time.getUnixTime();
-    const added = [];
-    const updated = [];
-    const filteredUpdated = [];
-    const removed = [];
-    for (const entry of readAwarenessEntries(update)) {
-        const { clientID, state } = entry;
-        let { clock } = entry;
+    const changes = noChanges();
+    const { added, updated, changed, removed } = changes;
+    for (const { clientID, clock, state } of readAwarenessEntries(update)) {
         const clientMeta = awareness.meta.get(clientID);
         const prevState = awareness.states.get(clientID);
         const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
         if (currClock < clock ||
             (currClock === clock && state === null && awareness.states.has(clientID))) {
-            if (state === null) {
-                // never let a remote client remove this local state
-                if (clientID === awareness.clientID && awareness.getLocalState() != null) {
-                    // remote client removed the local state. Do not remove state. Broadcast a message
-                    // indicating that this client still exists by increasing the clock
-                    clock++;
-                }
-                else {
-                    awareness.states.delete(clientID);
-                }
-            }
-            else {
-                awareness.states.set(clientID, state);
-            }
-            awareness.meta.set(clientID, {
-                clock,
-                lastUpdated: timestamp
-            });
+            // Never let a remote client remove this local state: keep it and
+            // broadcast that this client still exists, by increasing the clock.
+            const local = awareness.getLocalState();
+            const keep = state === null && clientID === awareness.clientID && local != null;
+            put(awareness, clientID, keep ? clock + 1 : clock, keep ? local : state, timestamp);
             if (clientMeta === undefined && state !== null) {
                 added.push(clientID);
             }
@@ -239,17 +210,11 @@ export const applyAwarenessUpdate = (awareness, update, origin) => {
                 removed.push(clientID);
             }
             else if (state !== null) {
-                if (!jsonEquals(state, prevState)) {
-                    filteredUpdated.push(clientID);
-                }
+                if (!jsonEquals(state, prevState))
+                    changed.push(clientID);
                 updated.push(clientID);
             }
         }
     }
-    if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
-        awareness.emit('change', [{ added, updated: filteredUpdated, removed }, origin]);
-    }
-    if (added.length > 0 || updated.length > 0 || removed.length > 0) {
-        awareness.emit('update', [{ added, updated, removed }, origin]);
-    }
+    emitChanges(awareness, changes, origin);
 };

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

@@ -147,17 +147,12 @@ export declare const bindProviders: (Y: EngineApi) => {
             loadError: unknown;
             _storeTimeout: number;
             _storeTimeoutId: ReturnType<typeof setTimeout> | null;
-            _storeUpdate: (update: Uint8Array, origin: unknown) => void;
+            _unlisten: () => void;
             awareness: Awareness;
             bcconnected: boolean;
             disableBc: boolean;
             _ownsAwareness: boolean;
             _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
-            _awarenessUpdateHandler: (updates: {
-                added: number[];
-                updated: number[];
-                removed: number[];
-            }, origin: unknown) => void;
             get synced(): boolean;
             messageHandlers: Record<number, import("./room.js").RoomMessageHandler</*elided*/ any>>;
             readMessage: (buf: Uint8Array, emitSynced: boolean) => import("lib0-v14/encoding").Encoder;
@@ -165,7 +160,7 @@ export declare const bindProviders: (Y: EngineApi) => {
             connectBc(): void;
             disconnectBc(): void;
             destroy(): Promise<void>;
-            emit<N extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: N, args: Parameters<{
+            emit<N extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: N, args: Parameters<{
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: import("./room.js").ProtocolMismatch, provider: /*elided*/ any) => void;
                 'load-error': (error: unknown, provider: /*elided*/ any) => void;
@@ -174,7 +169,7 @@ export declare const bindProviders: (Y: EngineApi) => {
                 failed: (error: unknown, provider: /*elided*/ any) => void;
             }[N]>): void;
             _observers: Map<string, Set<any>>;
-            on<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
+            on<NAME extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: import("./room.js").ProtocolMismatch, provider: /*elided*/ any) => void;
                 'load-error': (error: unknown, provider: /*elided*/ any) => void;
@@ -189,7 +184,7 @@ export declare const bindProviders: (Y: EngineApi) => {
                 'schema-mismatch': (detail: import("./room.js").SchemaMismatchDetail, provider: /*elided*/ any) => void;
                 failed: (error: unknown, provider: /*elided*/ any) => void;
             }[NAME];
-            once<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
+            once<NAME extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: import("./room.js").ProtocolMismatch, provider: /*elided*/ any) => void;
                 'load-error': (error: unknown, provider: /*elided*/ any) => void;
@@ -197,7 +192,7 @@ export declare const bindProviders: (Y: EngineApi) => {
                 'schema-mismatch': (detail: import("./room.js").SchemaMismatchDetail, provider: /*elided*/ any) => void;
                 failed: (error: unknown, provider: /*elided*/ any) => void;
             }[NAME]): void;
-            off<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
+            off<NAME extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: import("./room.js").ProtocolMismatch, provider: /*elided*/ any) => void;
                 'load-error': (error: unknown, provider: /*elided*/ any) => void;
@@ -248,6 +243,7 @@ export declare const bindProviders: (Y: EngineApi) => {
                 deny(): void;
                 allow(): void;
             };
+            _rebasing: boolean;
             messageHandlers: Record<number, import("./room.js").RoomMessageHandler</*elided*/ any>>;
             hasSynced: boolean;
             whenSynced: Promise<unknown>;
@@ -258,14 +254,7 @@ export declare const bindProviders: (Y: EngineApi) => {
             _resync: ReturnType<typeof setInterval> | undefined;
             _connectTimer: ReturnType<typeof setTimeout> | undefined;
             _checkInterval: ReturnType<typeof setInterval>;
-            _updateHandler: (update: Uint8Array, origin: unknown, doc?: unknown, transaction?: {
-                local: boolean;
-            }) => void;
-            _awarenessUpdateHandler: (updates: {
-                added: number[];
-                updated: number[];
-                removed: number[];
-            }, origin: unknown) => void;
+            _unlisten: () => void;
             get url(): string;
             get unsaved(): number;
             get saved(): boolean;
@@ -275,11 +264,11 @@ export declare const bindProviders: (Y: EngineApi) => {
             destroy(): void;
             disconnect(): void;
             connect(): void;
-            emit<N extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
+            emit<N extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
             _observers: Map<string, Set<any>>;
-            on<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
-            once<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
-            off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            on<NAME extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
+            once<NAME extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            off<NAME extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
         };
     };
     watchComments: (server: string | null, roomName: string, listener: (message: import("../protocol.js").CommentMessage) => void) => (() => void);

package/dist/crdt/providers/index.js

@@ -1,6 +1,6 @@
 import { keepingReplaced } from '../incarnations.js';
 import { bindIndexeddbProvider } from './indexeddb.js';
-import { assertRoomId, SyncRefusedError } from './room.js';
+import { assertRoomId, CLOSE, SyncRefusedError } from './room.js';
 import { bindWebsocketProvider } from './websocket.js';
 export const bindProviders = (Y) => {
     const idb = bindIndexeddbProvider(Y);
@@ -50,7 +50,18 @@ export const bindProviders = (Y) => {
                 maxBackoffTime,
                 connectTimeout,
                 disableBc: disableBc || local !== undefined,
-                maxFrameBytes
+                maxFrameBytes,
+                // With a local copy, the dial waits for it: the epoch it names is the copy's.
+                connect: local === undefined
+            });
+            const dial = () => provider._destroyed || provider.connect();
+            // A re-seed (`room.reseed.protocol`, a `4410` refusal): the local copy goes,
+            // its deletion waiting for every tab's connection to close.
+            provider.on('refused', ({ code }) => {
+                if (code !== CLOSE.reseeded || !loaded)
+                    return;
+                void release?.();
+                void idb.clearDocument(persistName);
             });
             if (onExpired)
                 provider.on('expired', (state) => onExpired(state));
@@ -94,9 +105,17 @@ export const bindProviders = (Y) => {
                 });
             }
             let release = undefined;
+            // The store's load (or its failure) opens the dial.
+            const loaded = local &&
+                Object.assign((p) => local({
+                    ...p,
+                    synced: (x) => (p.synced(x), dial()),
+                    failed: (error, x) => (p.failed?.(error, x), dial())
+                }), local);
             try {
                 // Called directly (no `attach`), the store only persists: readiness is the socket's.
-                release = local && (attach ? attach(local) : local({ doc, awareness, synced: () => { } }));
+                release =
+                    loaded && (attach ? attach(loaded) : loaded({ doc, awareness, synced: () => { } }));
             }
             catch (error) {
                 provider.destroy();

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

@@ -45,17 +45,13 @@ export declare const bindIndexeddbProvider: (Y: EngineApi) => {
             loadError: unknown;
             _storeTimeout: number;
             _storeTimeoutId: ReturnType<typeof setTimeout> | null;
-            _storeUpdate: (update: Uint8Array, origin: unknown) => void;
+            /** @internal Removes the document and presence listeners (`room.listen`). */
+            _unlisten: () => void;
             awareness: Awareness;
             bcconnected: boolean;
             disableBc: boolean;
             _ownsAwareness: boolean;
             _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
-            _awarenessUpdateHandler: (updates: {
-                added: number[];
-                updated: number[];
-                removed: number[];
-            }, origin: unknown) => void;
             /** The lifetime hydration claim. */
             get synced(): boolean;
             /**
@@ -78,7 +74,7 @@ export declare const bindIndexeddbProvider: (Y: EngineApi) => {
              * close the DB. Does NOT remove stored data — `clearDocument` does.
              */
             destroy(): Promise<void>;
-            emit<N extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: N, args: Parameters<{
+            emit<N extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: N, args: Parameters<{
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: ProtocolMismatch, provider: /*elided*/ any) => void;
                 /** Fired when loading persisted state failed (e.g. a generation mismatch). `whenSynced` rejects. */
@@ -101,7 +97,7 @@ export declare const bindIndexeddbProvider: (Y: EngineApi) => {
                 failed: (error: unknown, provider: /*elided*/ any) => void;
             }[N]>): void;
             _observers: Map<string, Set<any>>;
-            on<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
+            on<NAME extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: ProtocolMismatch, provider: /*elided*/ any) => void;
                 /** Fired when loading persisted state failed (e.g. a generation mismatch). `whenSynced` rejects. */
@@ -144,7 +140,7 @@ export declare const bindIndexeddbProvider: (Y: EngineApi) => {
                  */
                 failed: (error: unknown, provider: /*elided*/ any) => void;
             }[NAME];
-            once<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
+            once<NAME extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: ProtocolMismatch, provider: /*elided*/ any) => void;
                 /** Fired when loading persisted state failed (e.g. a generation mismatch). `whenSynced` rejects. */
@@ -166,7 +162,7 @@ export declare const bindIndexeddbProvider: (Y: EngineApi) => {
                  */
                 failed: (error: unknown, provider: /*elided*/ any) => void;
             }[NAME]): void;
-            off<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
+            off<NAME extends "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                 synced: (provider: /*elided*/ any) => void;
                 'protocol-mismatch': (mismatch: ProtocolMismatch, provider: /*elided*/ any) => void;
                 /** Fired when loading persisted state failed (e.g. a generation mismatch). `whenSynced` rejects. */

package/dist/crdt/providers/indexeddb.js

@@ -41,7 +41,7 @@ import { IsolatedObservable } from '../protocols/observable.js';
 import { bindSync } from '../protocols/sync.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';
+import { beginDestroy, bindRoomProtocol, tabs, emitFailed, fault, initLifecycle, markSynced, quarantined } from './room.js';
 export const PREFERRED_TRIM_SIZE = 500;
 /**
  * Bind the IndexedDB persistence provider to the vendored v14 engine module.
@@ -175,13 +175,13 @@ export const bindIndexeddbProvider = (Y) => {
         loadError = null;
         _storeTimeout;
         _storeTimeoutId;
-        _storeUpdate;
+        /** @internal Removes the document and presence listeners (`room.listen`). */
+        _unlisten;
         awareness;
         bcconnected = false;
         disableBc;
         _ownsAwareness;
         _bcSubscriber;
-        _awarenessUpdateHandler;
         constructor(name, doc, options = {}) {
             super();
             this.doc = doc;
@@ -196,8 +196,6 @@ export const bindIndexeddbProvider = (Y) => {
             this._db = openContainer(this.dbName);
             this.destroy = this.destroy.bind(this);
             initLifecycle(this, this.destroy, () => room.depart(this));
-            this._bcSubscriber = room.bcSubscriber(this);
-            this._awarenessUpdateHandler = room.awarenessUpdateHandler(this);
             // Fail closed: no sync, no BC room join, whenSynced rejects, and
             // the terminal 'failed' fires — the provider can never reach
             // synced once loading its persisted state has failed.
@@ -216,7 +214,7 @@ export const bindIndexeddbProvider = (Y) => {
                 // A read-only doc's pre-hydration state is never persisted.
                 const beforeApplyUpdatesCallback = (updatesStore) => {
                     if (!quarantined(doc)) {
-                        rtop(updatesStore.add(encodeRow(Y.encodeStateAsUpdate(doc)))).catch((error) => this.emit('message-error', [error, this]));
+                        rtop(updatesStore.add(encodeRow(Y.encodeStateAsUpdate(doc)))).catch((error) => fault(this, error));
                     }
                 };
                 // Hydrated: join the room and claim `synced` (lifetime).
@@ -243,7 +241,7 @@ export const bindIndexeddbProvider = (Y) => {
                 .catch(onLoadError);
             this._storeTimeout = 1000;
             this._storeTimeoutId = null;
-            this._storeUpdate = (update, origin) => {
+            const storeUpdate = (update, origin) => {
                 // Outbound quarantine: a read-only doc is never persisted
                 // (`broadcastUpdate` applies the same rule to the room).
                 if (origin === this || quarantined(doc))
@@ -253,9 +251,7 @@ export const bindIndexeddbProvider = (Y) => {
                         const [updatesStore] = storesOf(this.db, [updatesStoreName]);
                         // Storage failures must surface — never an unobserved
                         // rejection (the error channel observes every failure mode).
-                        rtop(updatesStore.add(encodeRow(update))).catch((error) => {
-                            this.emit('message-error', [error, this]);
-                        });
+                        rtop(updatesStore.add(encodeRow(update))).catch((error) => fault(this, error));
                         if (++this._dbsize >= PREFERRED_TRIM_SIZE) {
                             if (this._storeTimeoutId !== null) {
                                 clearTimeout(this._storeTimeoutId);
@@ -264,7 +260,7 @@ export const bindIndexeddbProvider = (Y) => {
                                 this._storeTimeoutId = null;
                                 // The timed caller has no promise consumer — surface
                                 // compaction/storage failures on the error channel.
-                                storeState(this, false).catch((error) => this.emit('message-error', [error, this]));
+                                storeState(this, false).catch((error) => fault(this, error));
                             }, this._storeTimeout);
                         }
                     }
@@ -272,14 +268,13 @@ export const bindIndexeddbProvider = (Y) => {
                         // A synchronous transact failure (e.g. a handle closed
                         // mid-session) still lands on the error channel rather
                         // than propagating into the doc's update dispatch.
-                        this.emit('message-error', [error, this]);
+                        fault(this, error);
                     }
                 }
                 // Broadcast the update to other tabs
                 room.broadcastUpdate(this, update);
             };
-            doc.on('update', this._storeUpdate);
-            this.awareness.on('update', this._awarenessUpdateHandler);
+            this._unlisten = room.listen(this, storeUpdate);
             const onDocDestroy = () => void this.destroy();
             destroyWithDoc.set(this, onDocDestroy);
             doc.on('destroy', onDocDestroy);
@@ -324,11 +319,10 @@ export const bindIndexeddbProvider = (Y) => {
             if (this._storeTimeoutId) {
                 clearTimeout(this._storeTimeoutId);
             }
-            this.doc.off('update', this._storeUpdate);
+            this._unlisten();
             const onDocDestroy = destroyWithDoc.get(this);
             if (onDocDestroy)
                 this.doc.off('destroy', onDocDestroy);
-            this.awareness.off('update', this._awarenessUpdateHandler);
             this.disconnectBc();
             if (this._ownsAwareness) {
                 this.awareness.destroy();

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

@@ -61,6 +61,12 @@ export declare const messageChunk = 5;
  * room sends it only to a socket that subscribed.
  */
 export declare const messageComments = 6;
+/**
+ * Client → server, after a re-seed (`room.reseed.protocol`): the client's
+ * whole old document, its unsaved edits in it, for the room to rebase onto
+ * the current epoch. Sent only when the room asks (its epoch notice).
+ */
+export declare const messageRebase = 7;
 /** A WebSocket message limit on Cloudflare (32 MiB): a larger frame is sent as chunks. */
 export declare const MAX_FRAME_BYTES: number;
 /**
@@ -164,6 +170,14 @@ export declare const onPageLeave: (fn: () => void, phase: PageLeavePhase) => (()
 export declare const initLifecycle: (host: LifecycleHost, destroy: () => unknown, depart?: () => void) => void;
 /** The first sync — lifetime. Returns `true` only the first time. */
 export declare const markSynced: (host: LifecycleHost) => boolean;
+/** Report `error` on `provider`'s error channel (`'message-error'`): a frame, a payload or a storage failure. */
+export declare const fault: (provider: {
+    emit?(event: "message-error", args: [unknown, unknown]): void;
+}, error: unknown) => void;
+/** A message type no handler claims inside a valid envelope: protocol skew, reported, never dropped silently. */
+export declare const unknownType: (provider: {
+    emit?(event: "message-error", args: [unknown, unknown]): void;
+}, what: string, type: number) => void;
 /**
  * Terminal `'failed'` emission (the sync-failure contract): fires at
  * most once per provider, only while it has never synced — destroy before
@@ -195,6 +209,15 @@ export declare const CLOSE: {
     readonly denied: 4403;
     /** The dialed replica is bound to another user. */
     readonly replicaTaken: 4409;
+    /**
+     * The room re-seeded the document (`room.reseed.protocol`; the reason is
+     * the room's epoch): a refusal of this document, once a client with
+     * unsaved edits redialed and handed them over. The new epoch is a new
+     * document's. Also the answer to a copy the room cannot rebase (an
+     * epoch past the cuts it keeps, or a later one) and to an older epoch's
+     * content on a socket of the current one.
+     */
+    readonly reseeded: 4410;
     /**
      * A room quota refused the socket's write (`quota: document`,
      * `quota: rate`, `quota: frame`): the frame was not applied, and a
@@ -298,5 +321,8 @@ export declare const bindRoomProtocol: <P extends RoomProvider<P>>(syncProtocol:
     depart: (provider: P) => void;
     connectBc: (provider: P & BcMember) => void;
     disconnectBc: (provider: P & BcMember) => void;
+    listen: (provider: P & BcMember, onUpdate: (update: Uint8Array, origin: unknown, doc?: unknown, transaction?: {
+        local: boolean;
+    }) => void) => (() => void);
 };
 export {};