@dabble/patches 0.2.32 → 0.3.0

package/dist/net/PatchesSync.js

@@ -1,300 +1,378 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { isEqual } from '@dabble/delta';
+import { applyCommittedChanges } from '../algorithms/client/applyCommittedChanges.js';
+import { breakIntoBatches } from '../algorithms/client/batching.js';
 import { Patches } from '../client/Patches.js';
 import { signal } from '../event-signal.js';
-import { breakIntoBatches } from '../utils/batching.js';
+import { blockable } from '../utils/concurrency.js';
 import { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
 import { onlineState } from './websocket/onlineState.js';
 /**
  * Handles WebSocket connection, document subscriptions, and syncing logic between
  * the Patches instance and the server.
  */
-export class PatchesSync {
-    constructor(url, patches, options = {}) {
-        this.isFlushing = new Set();
-        this.globalSyncTimeout = null;
-        this._state = { online: false, connected: false, syncing: null };
-        // Signals
-        this.onStateChange = signal();
-        this.onError = signal();
-        // --- Event Handlers ---
-        this._handleOnlineChange = (isOnline) => {
-            this.setState({ online: isOnline });
-            if (isOnline && this.state.connected) {
-                this.scheduleGlobalSync();
+let PatchesSync = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _syncDoc_decorators;
+    let __receiveCommittedChanges_decorators;
+    return _a = class PatchesSync {
+            constructor(patches, url, wsOptions) {
+                this.ws = __runInitializers(this, _instanceExtraInitializers);
+                this._state = { online: false, connected: false, syncing: null };
+                /**
+                 * Signal emitted when the sync state changes.
+                 */
+                this.onStateChange = signal();
+                /**
+                 * Signal emitted when an error occurs.
+                 */
+                this.onError = signal();
+                this.patches = patches;
+                this.store = patches.store;
+                this.maxPayloadBytes = patches.docOptions?.maxPayloadBytes;
+                this.ws = new PatchesWebSocket(url, wsOptions);
+                this._state.online = onlineState.isOnline;
+                this.trackedDocs = new Set(patches.trackedDocs);
+                // --- Event Listeners ---
+                onlineState.onOnlineChange(online => this.updateState({ online }));
+                this.ws.onStateChange(this._handleConnectionChange.bind(this));
+                this.ws.onChangesCommitted(this._receiveCommittedChanges.bind(this));
+                // Listen to Patches for tracking changes
+                patches.onTrackDocs(this._handleDocsTracked.bind(this));
+                patches.onUntrackDocs(this._handleDocsUntracked.bind(this));
+                patches.onDeleteDoc(this._handleDocDeleted.bind(this));
             }
-        };
-        this._handleConnectionChange = (connectionState) => {
-            const isConnected = connectionState === 'connected';
-            const isConnecting = connectionState === 'connecting';
-            // Preserve syncing state if moving from connecting -> connected
-            // Reset syncing if disconnected or errored
-            const newSyncingState = isConnected
-                ? this._state.syncing // Preserve
-                : isConnecting
-                    ? this._state.syncing // Preserve during connecting phase too
-                    : null; // Reset
-            this.setState({ connected: isConnected, syncing: newSyncingState });
-            if (isConnected) {
-                // Sync everything on connect/reconnect
-                void this.syncAllKnownDocs();
+            /**
+             * Gets the current sync state.
+             */
+            get state() {
+                return this._state;
             }
-        };
-        this._handleDocsTracked = async (docIds) => {
-            const newIds = docIds.filter(id => !this.trackedDocs.has(id));
-            if (!newIds.length)
-                return;
-            newIds.forEach(id => this.trackedDocs.add(id));
-            if (this.state.connected) {
+            /**
+             * Updates the sync state.
+             * @param update - The partial state to update.
+             */
+            updateState(update) {
+                const newState = { ...this._state, ...update };
+                if (!isEqual(this._state, newState)) {
+                    this._state = newState;
+                    this.onStateChange.emit(this._state);
+                }
+            }
+            /**
+             * Connects to the WebSocket server and starts syncing if online. If not online, it will wait for online state.
+             */
+            async connect() {
                 try {
-                    await this.ws.subscribe(newIds);
-                    // Trigger sync for newly tracked docs immediately
-                    await Promise.all(newIds.map(id => this.syncDoc(id)));
+                    await this.ws.connect();
                 }
                 catch (err) {
-                    console.warn(`Failed to subscribe/sync newly tracked docs: ${newIds.join(', ')}`, err);
+                    console.error('PatchesSync connection failed:', err);
+                    this.updateState({ connected: false, syncing: err instanceof Error ? err : new Error(String(err)) });
                     this.onError.emit(err);
-                    // State remains tracked locally, will retry on next sync
+                    throw err;
                 }
             }
-        };
-        this._handleDocsUntracked = async (docIds) => {
-            const existingIds = docIds.filter(id => this.trackedDocs.has(id));
-            if (!existingIds.length)
-                return;
-            existingIds.forEach(id => this.trackedDocs.delete(id));
-            if (this.state.connected) {
+            /**
+             * Disconnects from the WebSocket server and stops syncing.
+             */
+            disconnect() {
+                this.ws.disconnect();
+                this.updateState({ connected: false, syncing: null });
+            }
+            /**
+             * Syncs all known docs when initially connected.
+             */
+            async syncAllKnownDocs() {
+                if (!this.state.connected)
+                    return;
+                this.updateState({ syncing: 'updating' });
                 try {
-                    await this.ws.unsubscribe(existingIds);
+                    const tracked = await this.store.listDocs(true); // Include deleted docs
+                    const activeDocs = tracked.filter(t => !t.deleted);
+                    const deletedDocs = tracked.filter(t => t.deleted);
+                    const activeDocIds = activeDocs.map((t) => t.docId);
+                    // Ensure tracked set reflects only active docs for subscription purposes
+                    this.trackedDocs = new Set(activeDocIds);
+                    // Subscribe to active docs
+                    if (activeDocIds.length > 0) {
+                        try {
+                            await this.ws.subscribe(activeDocIds);
+                        }
+                        catch (err) {
+                            console.warn('Error subscribing to active docs during sync:', err);
+                            this.onError.emit(err);
+                        }
+                    }
+                    // Sync each active doc
+                    const activeSyncPromises = activeDocIds.map((id) => this.syncDoc(id));
+                    // Attempt to delete docs marked with tombstones
+                    const deletePromises = deletedDocs.map(async ({ docId }) => {
+                        try {
+                            console.info(`Attempting server delete for tombstoned doc: ${docId}`);
+                            await this.ws.deleteDoc(docId);
+                            // If server delete succeeds, remove tombstone and all data locally
+                            await this.store.confirmDeleteDoc(docId);
+                            console.info(`Successfully deleted and untracked doc: ${docId}`);
+                        }
+                        catch (err) {
+                            // If server delete fails (e.g., offline, already deleted), keep tombstone for retry
+                            console.warn(`Server delete failed for ${docId}, keeping tombstone:`, err);
+                            this.onError.emit(err, { docId });
+                        }
+                    });
+                    // Wait for all sync and delete operations
+                    await Promise.all([...activeSyncPromises, ...deletePromises]);
+                    this.updateState({ syncing: null });
+                }
+                catch (error) {
+                    console.error('Error during global sync:', error);
+                    this.updateState({ syncing: error instanceof Error ? error : new Error(String(error)) });
+                    this.onError.emit(error);
+                }
+            }
+            /**
+             * Syncs a single document.
+             * @param docId The ID of the document to sync.
+             */
+            async syncDoc(docId) {
+                if (!this.state.connected)
+                    return;
+                const doc = this.patches.getOpenDoc(docId);
+                if (doc) {
+                    doc.updateSyncing('updating');
+                }
+                try {
+                    const pending = await this.store.getPendingChanges(docId);
+                    if (pending.length > 0) {
+                        await this.flushDoc(docId); // flushDoc handles setting flushing state
+                    }
+                    else {
+                        // No pending, just check for server changes
+                        const [committedRev] = await this.store.getLastRevs(docId);
+                        if (committedRev) {
+                            const serverChanges = await this.ws.getChangesSince(docId, committedRev);
+                            if (serverChanges.length > 0) {
+                                // Apply server changes with proper rebasing
+                                await this._applyServerChangesToDoc(docId, serverChanges);
+                            }
+                        }
+                        else {
+                            const snapshot = await this.ws.getDoc(docId);
+                            await this.store.saveDoc(docId, snapshot);
+                        }
+                    }
+                    if (doc) {
+                        doc.updateSyncing(null);
+                    }
                 }
                 catch (err) {
-                    console.warn(`Failed to unsubscribe docs: ${existingIds.join(', ')}`, err);
-                    // Continue with local untrack
+                    console.error(`Error syncing doc ${docId}:`, err);
+                    this.onError.emit(err, { docId });
+                    if (doc) {
+                        doc.updateSyncing(err instanceof Error ? err : new Error(String(err)));
+                    }
                 }
             }
-        };
-        this.patches = patches;
-        this.store = patches.store;
-        this.options = options;
-        this.ws = new PatchesWebSocket(url, options.wsOptions);
-        this._state.online = onlineState.isOnline;
-        this.trackedDocs = new Set(patches.trackedDocs);
-        // Set maxPayloadBytes on Patches docOptions if provided
-        if (options.maxPayloadBytes) {
-            patches.updateDocOptions({ maxPayloadBytes: options.maxPayloadBytes });
-        }
-        // --- Event Listeners ---
-        onlineState.onOnlineChange(this._handleOnlineChange);
-        this.ws.onStateChange(this._handleConnectionChange);
-        this.ws.onChangesCommitted(({ docId, changes }) => {
-            // Persist first, then notify Patches instance to update PatchesDoc
-            this.store
-                .saveCommittedChanges(docId, changes)
-                .then(() => this.patches.applyServerChanges(docId, changes))
-                .catch((err) => this.onError.emit(err, { docId }));
-        });
-        // Forward errors to Patches error signal
-        this.onError((err, context) => {
-            patches.onError.emit(err, context);
-        });
-        // Listen to Patches for tracking changes
-        patches.onTrackDocs(this._handleDocsTracked);
-        patches.onUntrackDocs(this._handleDocsUntracked);
-        patches.onDeleteDoc(this._handleDocDeleted);
-    }
-    get state() {
-        return this._state;
-    }
-    setState(update) {
-        const newState = { ...this._state, ...update };
-        if (JSON.stringify(this._state) !== JSON.stringify(newState)) {
-            this._state = newState;
-            this.onStateChange.emit(this._state);
-        }
-    }
-    // --- Connection & Lifecycle ---
-    async connect() {
-        try {
-            await this.ws.connect();
-            // _handleConnectionChange handles state update and sync trigger
-        }
-        catch (err) {
-            console.error('PatchesSync connection failed:', err);
-            this.setState({ connected: false, syncing: err instanceof Error ? err : new Error(String(err)) });
-            this.onError.emit(err);
-            throw err;
-        }
-    }
-    disconnect() {
-        if (this.globalSyncTimeout)
-            clearTimeout(this.globalSyncTimeout);
-        this.ws.disconnect();
-        this.setState({ connected: false, syncing: null });
-    }
-    // --- Doc Tracking & Subscription (Now handled via signals) ---
-    // --- Syncing Logic ---
-    scheduleGlobalSync() {
-        if (this.globalSyncTimeout)
-            clearTimeout(this.globalSyncTimeout);
-        this.globalSyncTimeout = setTimeout(() => {
-            this.globalSyncTimeout = null;
-            void this.syncAllKnownDocs();
-        }, 300);
-    }
-    async syncAllKnownDocs() {
-        if (!this.state.connected)
-            return;
-        this.setState({ syncing: 'updating' });
-        try {
-            const tracked = await this.store.listDocs(true); // Include deleted docs
-            const activeDocs = tracked.filter(t => !t.deleted);
-            const deletedDocs = tracked.filter(t => t.deleted);
-            const activeDocIds = activeDocs.map((t) => t.docId);
-            // Ensure tracked set reflects only active docs for subscription purposes
-            this.trackedDocs = new Set(activeDocIds);
-            // Subscribe to active docs
-            if (activeDocIds.length > 0) {
+            /**
+             * Flushes a document to the server.
+             * @param docId The ID of the document to flush.
+             */
+            async flushDoc(docId) {
+                if (!this.trackedDocs.has(docId)) {
+                    throw new Error(`Document ${docId} is not tracked`);
+                }
+                if (!this.state.connected) {
+                    throw new Error('Not connected to server');
+                }
                 try {
-                    await this.ws.subscribe(activeDocIds);
+                    // Get changes from store or memory
+                    let pending = await this.store.getPendingChanges(docId);
+                    if (!pending.length) {
+                        return; // Nothing to flush
+                    }
+                    const batches = breakIntoBatches(pending, this.maxPayloadBytes);
+                    for (const batch of batches) {
+                        if (!this.state.connected) {
+                            throw new Error('Disconnected during flush');
+                        }
+                        const range = [batch[0].rev, batch[batch.length - 1].rev];
+                        const committed = await this.ws.commitChanges(docId, batch);
+                        // Apply the committed changes using the sync algorithm (already saved to store)
+                        await this._applyServerChangesToDoc(docId, committed, range);
+                        // Fetch remaining pending for next batch or check completion
+                        pending = await this.store.getPendingChanges(docId);
+                    }
                 }
                 catch (err) {
-                    console.warn('Error subscribing to active docs during sync:', err);
-                    this.onError.emit(err);
+                    console.error(`Flush failed for doc ${docId}:`, err);
+                    this.onError.emit(err, { docId });
+                    throw err; // Re-throw so caller (like syncAll) knows it failed
                 }
             }
-            // Sync each active doc
-            const activeSyncPromises = activeDocIds.map((id) => this.syncDoc(id));
-            // Attempt to delete docs marked with tombstones
-            const deletePromises = deletedDocs.map(async ({ docId }) => {
+            /**
+             * Receives committed changes from the server and applies them to the document. This is a blockable function, so it
+             * is separate from applyServerChangesToDoc, which is called by other blockable functions. Ensuring this is blockable
+             * ensures that while a doc is sending changes to the server, it isn't receiving changes from the server which could
+             * cause a race condition.
+             */
+            async _receiveCommittedChanges(docId, serverChanges) {
                 try {
-                    console.info(`Attempting server delete for tombstoned doc: ${docId}`);
-                    await this.ws.deleteDoc(docId);
-                    // If server delete succeeds, remove tombstone and all data locally
-                    await this.store.confirmDeleteDoc(docId);
-                    console.info(`Successfully deleted and untracked doc: ${docId}`);
+                    await this._applyServerChangesToDoc(docId, serverChanges);
                 }
                 catch (err) {
-                    // If server delete fails (e.g., offline, already deleted), keep tombstone for retry
-                    console.warn(`Server delete failed for ${docId}, keeping tombstone:`, err);
                     this.onError.emit(err, { docId });
                 }
-            });
-            // Wait for all sync and delete operations
-            await Promise.all([...activeSyncPromises, ...deletePromises]);
-            this.setState({ syncing: null });
-        }
-        catch (error) {
-            console.error('Error during global sync:', error);
-            this.setState({ syncing: error instanceof Error ? error : new Error(String(error)) });
-            this.onError.emit(error);
-        }
-    }
-    async syncDoc(docId) {
-        if (this.isFlushing.has(docId))
-            return; // Already flushing
-        if (!this.state.connected)
-            return;
-        try {
-            const pending = await this.store.getPendingChanges(docId);
-            if (pending.length > 0) {
-                await this.flushDoc(docId); // flushDoc handles setting flushing state
             }
-            else {
-                // No pending, just check for server changes
-                const [committedRev] = await this.store.getLastRevs(docId);
-                if (committedRev) {
-                    const serverChanges = await this.ws.getChangesSince(docId, committedRev);
-                    if (serverChanges.length > 0) {
-                        await this.store.saveCommittedChanges(docId, serverChanges);
-                        this.patches.applyServerChanges(docId, serverChanges);
+            /**
+             * Applies server changes to a document using the centralized sync algorithm.
+             * This ensures consistent OT behavior regardless of whether the doc is open in memory.
+             */
+            async _applyServerChangesToDoc(docId, serverChanges, sentPendingRange) {
+                // 1. Get current document snapshot from store
+                const currentSnapshot = await this.store.getDoc(docId);
+                if (!currentSnapshot) {
+                    console.warn(`Cannot apply server changes to non-existent doc: ${docId}`);
+                    return;
+                }
+                const doc = this.patches.getOpenDoc(docId);
+                if (doc) {
+                    // Ensure we have all the changes, stored and in-memory (newly created but not yet persisted)
+                    const inMemoryPendingChanges = doc?.getPendingChanges();
+                    const latestRev = currentSnapshot.changes[currentSnapshot.changes.length - 1]?.rev || currentSnapshot.rev;
+                    const newChanges = inMemoryPendingChanges.filter(change => change.rev > latestRev);
+                    currentSnapshot.changes.push(...newChanges);
+                }
+                // 2. Use the pure algorithm to calculate the new state
+                const { state, rev, changes: rebasedPendingChanges } = applyCommittedChanges(currentSnapshot, serverChanges);
+                // 3. If the doc is open in memory, update it with the new state
+                if (doc) {
+                    if (doc.committedRev === serverChanges[0].rev - 1) {
+                        // We can update the doc's snapshot
+                        doc.applyCommittedChanges(serverChanges, rebasedPendingChanges);
+                    }
+                    else {
+                        // We have to do a full state update
+                        doc.import({ state, rev, changes: rebasedPendingChanges });
+                    }
+                }
+                // 4. Save changes to store (if not already saved)
+                await Promise.all([
+                    this.store.saveCommittedChanges(docId, serverChanges, sentPendingRange),
+                    this.store.replacePendingChanges(docId, rebasedPendingChanges),
+                ]);
+            }
+            /**
+             * Initiates the deletion process for a document both locally and on the server.
+             * This now delegates the local tombstone marking to Patches.
+             */
+            async _handleDocDeleted(docId) {
+                // Attempt server delete if online
+                if (this.state.connected) {
+                    try {
+                        await this.ws.deleteDoc(docId);
+                        await this.store.confirmDeleteDoc(docId);
+                    }
+                    catch (err) {
+                        console.error(`Server delete failed for doc ${docId}, will retry on reconnect/resync.`, err);
+                        this.onError.emit(err, { docId });
+                        throw err;
                     }
                 }
                 else {
-                    const snapshot = await this.ws.getDoc(docId);
-                    await this.store.saveDoc(docId, snapshot);
+                    console.warn(`Offline: Server delete for doc ${docId} deferred.`);
                 }
             }
-        }
-        catch (err) {
-            console.error(`Error syncing doc ${docId}:`, err);
-            this.onError.emit(err, { docId });
-            // Don't let one doc failure stop others in global sync
-        }
-    }
-    async flushDoc(docId) {
-        if (!this.trackedDocs.has(docId)) {
-            throw new Error(`Document ${docId} is not tracked`);
-        }
-        if (this.isFlushing.has(docId)) {
-            throw new Error(`Document ${docId} is already being flushed`);
-        }
-        if (!this.state.connected) {
-            throw new Error('Not connected to server');
-        }
-        this.isFlushing.add(docId);
-        if (this.state.syncing !== 'updating') {
-            this.setState({ syncing: 'updating' });
-        }
-        try {
-            // Get changes from Patches for this doc
-            let pending = await this.store.getPendingChanges(docId);
-            if (!pending.length) {
-                // Try to get from memory if available
-                pending = this.patches.getDocChanges(docId);
-                if (!pending.length) {
-                    this.isFlushing.delete(docId);
-                    return; // Nothing to flush
+            _handleConnectionChange(connectionState) {
+                const isConnected = connectionState === 'connected';
+                const isConnecting = connectionState === 'connecting';
+                // Preserve syncing state if moving from connecting -> connected
+                // Reset syncing if disconnected or errored
+                const newSyncingState = isConnected
+                    ? this._state.syncing // Preserve
+                    : isConnecting
+                        ? this._state.syncing // Preserve during connecting phase too
+                        : null; // Reset
+                this.updateState({ connected: isConnected, syncing: newSyncingState });
+                if (isConnected) {
+                    // Sync everything on connect/reconnect
+                    void this.syncAllKnownDocs();
                 }
             }
-            const batches = breakIntoBatches(pending, this.options.maxPayloadBytes);
-            for (const batch of batches) {
-                if (!this.state.connected) {
-                    throw new Error('Disconnected during flush');
+            async _handleDocsTracked(docIds) {
+                const newIds = docIds.filter(id => !this.trackedDocs.has(id));
+                if (!newIds.length)
+                    return;
+                newIds.forEach(id => this.trackedDocs.add(id));
+                if (this.state.connected) {
+                    try {
+                        await this.ws.subscribe(newIds);
+                        // Trigger sync for newly tracked docs immediately
+                        await Promise.all(newIds.map(id => this.syncDoc(id)));
+                    }
+                    catch (err) {
+                        console.warn(`Failed to subscribe/sync newly tracked docs: ${newIds.join(', ')}`, err);
+                        this.onError.emit(err);
+                    }
                 }
-                const range = [batch[0].rev, batch[batch.length - 1].rev];
-                const committed = await this.ws.commitChanges(docId, batch);
-                // Persist committed + remove pending in store
-                await this.store.saveCommittedChanges(docId, committed, range);
-                // Notify Patches to update PatchesDoc
-                this.patches.applyServerChanges(docId, committed);
-                // Fetch remaining pending for next batch or check completion
-                pending = await this.store.getPendingChanges(docId);
-            }
-        }
-        catch (err) {
-            console.error(`Flush failed for doc ${docId}:`, err);
-            this.onError.emit(err, { docId });
-            // Let Patches know about the failure
-            this.patches.handleSendFailure(docId);
-            // Don't clear flushing flag, let next sync attempt retry
-            throw err; // Re-throw so caller (like syncAll) knows it failed
-        }
-        finally {
-            this.isFlushing.delete(docId);
-            // Update global sync state if nothing else is flushing
-            if (this.isFlushing.size === 0 && this.state.syncing === 'updating') {
-                this.setState({ syncing: null });
-            }
-        }
-    }
-    // --- Server Operations ---
-    /**
-     * Initiates the deletion process for a document both locally and on the server.
-     * This now delegates the local tombstone marking to Patches.
-     */
-    async _handleDocDeleted(docId) {
-        // Attempt server delete if online
-        if (this.state.connected) {
-            try {
-                await this.ws.deleteDoc(docId);
-                await this.store.confirmDeleteDoc(docId);
             }
-            catch (err) {
-                console.error(`Server delete failed for doc ${docId}, will retry on reconnect/resync.`, err);
-                this.onError.emit(err, { docId });
-                throw err;
+            async _handleDocsUntracked(docIds) {
+                const existingIds = docIds.filter(id => this.trackedDocs.has(id));
+                if (!existingIds.length)
+                    return;
+                existingIds.forEach(id => this.trackedDocs.delete(id));
+                if (this.state.connected) {
+                    try {
+                        await this.ws.unsubscribe(existingIds);
+                    }
+                    catch (err) {
+                        console.warn(`Failed to unsubscribe docs: ${existingIds.join(', ')}`, err);
+                    }
+                }
             }
-        }
-        else {
-            console.warn(`Offline: Server delete for doc ${docId} deferred.`);
-        }
-    }
-}
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _syncDoc_decorators = [blockable];
+            __receiveCommittedChanges_decorators = [blockable];
+            __esDecorate(_a, null, _syncDoc_decorators, { kind: "method", name: "syncDoc", static: false, private: false, access: { has: obj => "syncDoc" in obj, get: obj => obj.syncDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, __receiveCommittedChanges_decorators, { kind: "method", name: "_receiveCommittedChanges", static: false, private: false, access: { has: obj => "_receiveCommittedChanges" in obj, get: obj => obj._receiveCommittedChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { PatchesSync };

package/dist/net/websocket/AuthorizationProvider.d.ts

@@ -40,7 +40,14 @@ export interface AuthorizationProvider<T extends AuthContext = AuthContext> {
     canAccess(ctx: T | undefined, docId: string, kind: Access, method: string, params?: Record<string, any>): boolean | Promise<boolean>;
 }
 /**
- * A permissive provider that authorises every action.  Used as the default so
- * existing callers that don't care about auth continue to work unchanged.
+ * A permissive provider that authorises every action.
+ * WARNING: This should only be used for development/testing purposes.
+ * Never use this in production as it allows unrestricted access.
  */
 export declare const allowAll: AuthorizationProvider;
+/**
+ * A secure default provider that denies all access.
+ * This forces developers to explicitly implement proper authorization.
+ * Use this as the default to ensure security by default.
+ */
+export declare const denyAll: AuthorizationProvider;