@dabble/patches 0.4.5 → 0.4.7

package/dist/net/PatchesSync.js

@@ -1,393 +1,298 @@
-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);
+import {
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __publicField,
+  __runInitializers
+} from "../chunk-IZ2YBCUP.js";
+var __receiveCommittedChanges_dec, _syncDoc_dec, _init;
+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 { blockable } from "../utils/concurrency.js";
+import { PatchesWebSocket } from "./websocket/PatchesWebSocket.js";
+import { onlineState } from "./websocket/onlineState.js";
+_syncDoc_dec = [blockable], __receiveCommittedChanges_dec = [blockable];
+class PatchesSync {
+  constructor(patches, url, options) {
+    this.options = options;
+    __runInitializers(_init, 5, this);
+    __publicField(this, "ws");
+    __publicField(this, "patches");
+    __publicField(this, "store");
+    __publicField(this, "maxPayloadBytes");
+    __publicField(this, "trackedDocs");
+    __publicField(this, "_state", { online: false, connected: false, syncing: null });
+    /**
+     * Signal emitted when the sync state changes.
+     */
+    __publicField(this, "onStateChange", signal());
+    /**
+     * Signal emitted when an error occurs.
+     */
+    __publicField(this, "onError", signal());
+    this.patches = patches;
+    this.store = patches.store;
+    this.maxPayloadBytes = patches.docOptions?.maxPayloadBytes;
+    this.ws = new PatchesWebSocket(url, options?.websocket);
+    this._state.online = onlineState.isOnline;
+    this.trackedDocs = new Set(patches.trackedDocs);
+    onlineState.onOnlineChange((online) => this.updateState({ online }));
+    this.ws.onStateChange(this._handleConnectionChange.bind(this));
+    this.ws.onChangesCommitted(this._receiveCommittedChanges.bind(this));
+    patches.onTrackDocs(this._handleDocsTracked.bind(this));
+    patches.onUntrackDocs(this._handleDocsUntracked.bind(this));
+    patches.onDeleteDoc(this._handleDocDeleted.bind(this));
+  }
+  /**
+   * Gets the current sync state.
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * 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);
     }
-    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] = _;
-        }
+  }
+  /**
+   * 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.connect();
+    } catch (err) {
+      console.error("PatchesSync connection failed:", err);
+      this.updateState({ connected: false, syncing: err instanceof Error ? err : new Error(String(err)) });
+      this.onError.emit(err);
+      throw err;
     }
-    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 { 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.
- */
-let PatchesSync = (() => {
-    let _instanceExtraInitializers = [];
-    let _syncDoc_decorators;
-    let __receiveCommittedChanges_decorators;
-    return class PatchesSync {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _syncDoc_decorators = [blockable];
-            __receiveCommittedChanges_decorators = [blockable];
-            __esDecorate(this, 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(this, 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(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        options = __runInitializers(this, _instanceExtraInitializers);
-        ws;
-        patches;
-        store;
-        maxPayloadBytes;
-        trackedDocs;
-        _state = { online: false, connected: false, syncing: null };
-        /**
-         * Signal emitted when the sync state changes.
-         */
-        onStateChange = signal();
-        /**
-         * Signal emitted when an error occurs.
-         */
-        onError = signal();
-        constructor(patches, url, options) {
-            this.options = options;
-            this.patches = patches;
-            this.store = patches.store;
-            this.maxPayloadBytes = patches.docOptions?.maxPayloadBytes;
-            this.ws = new PatchesWebSocket(url, options?.websocket);
-            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));
-        }
-        /**
-         * Gets the current sync state.
-         */
-        get state() {
-            return this._state;
-        }
-        /**
-         * 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.connect();
-            }
-            catch (err) {
-                console.error('PatchesSync connection failed:', err);
-                this.updateState({ connected: false, syncing: err instanceof Error ? err : new Error(String(err)) });
-                this.onError.emit(err);
-                throw err;
-            }
+  }
+  /**
+   * 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 {
+      const tracked = await this.store.listDocs(true);
+      const activeDocs = tracked.filter((t) => !t.deleted);
+      const deletedDocs = tracked.filter((t) => t.deleted);
+      const activeDocIds = activeDocs.map((t) => t.docId);
+      this.trackedDocs = new Set(activeDocIds);
+      if (activeDocIds.length > 0) {
+        try {
+          const subscribeIds = this.options?.subscribeFilter?.(activeDocIds) || activeDocIds;
+          if (subscribeIds.length) {
+            await this.ws.subscribe(subscribeIds);
+          }
+        } catch (err) {
+          console.warn("Error subscribing to active docs during sync:", err);
+          this.onError.emit(err);
         }
-        /**
-         * Disconnects from the WebSocket server and stops syncing.
-         */
-        disconnect() {
-            this.ws.disconnect();
-            this.updateState({ connected: false, syncing: null });
+      }
+      const activeSyncPromises = activeDocIds.map((id) => this.syncDoc(id));
+      const deletePromises = deletedDocs.map(async ({ docId }) => {
+        try {
+          console.info(`Attempting server delete for tombstoned doc: ${docId}`);
+          await this.ws.deleteDoc(docId);
+          await this.store.confirmDeleteDoc(docId);
+          console.info(`Successfully deleted and untracked doc: ${docId}`);
+        } catch (err) {
+          console.warn(`Server delete failed for ${docId}, keeping tombstone:`, err);
+          this.onError.emit(err, { docId });
         }
-        /**
-         * Syncs all known docs when initially connected.
-         */
-        async syncAllKnownDocs() {
-            if (!this.state.connected)
-                return;
-            this.updateState({ 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) {
-                    try {
-                        const subscribeIds = this.options?.subscribeFilter?.(activeDocIds) || activeDocIds;
-                        if (subscribeIds.length) {
-                            await this.ws.subscribe(subscribeIds);
-                        }
-                    }
-                    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.error(`Error syncing doc ${docId}:`, err);
-                this.onError.emit(err, { docId });
-                if (doc) {
-                    doc.updateSyncing(err instanceof Error ? err : new Error(String(err)));
-                }
-            }
-        }
-        /**
-         * 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 {
-                // 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.error(`Flush failed for doc ${docId}:`, err);
-                this.onError.emit(err, { docId });
-                throw err; // Re-throw so caller (like syncAll) knows it failed
-            }
-        }
-        /**
-         * 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 {
-                await this._applyServerChangesToDoc(docId, serverChanges);
-            }
-            catch (err) {
-                this.onError.emit(err, { docId });
-            }
-        }
-        /**
-         * 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 {
-                console.warn(`Offline: Server delete for doc ${docId} deferred.`);
-            }
-        }
-        _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();
-            }
+      });
+      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);
+    }
+  }
+  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);
+      } else {
+        const [committedRev] = await this.store.getLastRevs(docId);
+        if (committedRev) {
+          const serverChanges = await this.ws.getChangesSince(docId, committedRev);
+          if (serverChanges.length > 0) {
+            await this._applyServerChangesToDoc(docId, serverChanges);
+          }
+        } else {
+          const snapshot = await this.ws.getDoc(docId);
+          await this.store.saveDoc(docId, snapshot);
         }
-        async _handleDocsTracked(docIds) {
-            const newIds = docIds.filter(id => !this.trackedDocs.has(id));
-            if (!newIds.length)
-                return;
-            newIds.forEach(id => this.trackedDocs.add(id));
-            let subscribeIds = newIds;
-            // If a subscribe filter is provided, filter out docs that are already tracked
-            if (this.options?.subscribeFilter) {
-                const alreadyTracked = this.options.subscribeFilter([...this.trackedDocs]);
-                subscribeIds = subscribeIds.filter(id => !alreadyTracked.includes(id));
-            }
-            if (this.state.connected) {
-                try {
-                    if (subscribeIds.length) {
-                        await this.ws.subscribe(subscribeIds);
-                    }
-                    // 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);
-                }
-            }
+      }
+      if (doc) {
+        doc.updateSyncing(null);
+      }
+    } catch (err) {
+      console.error(`Error syncing doc ${docId}:`, err);
+      this.onError.emit(err, { docId });
+      if (doc) {
+        doc.updateSyncing(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }
+  /**
+   * 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 {
+      let pending = await this.store.getPendingChanges(docId);
+      if (!pending.length) {
+        return;
+      }
+      const batches = breakIntoBatches(pending, this.maxPayloadBytes);
+      for (const batch of batches) {
+        if (!this.state.connected) {
+          throw new Error("Disconnected during flush");
         }
-        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);
-                }
-            }
+        const range = [batch[0].rev, batch[batch.length - 1].rev];
+        const committed = await this.ws.commitChanges(docId, batch);
+        await this._applyServerChangesToDoc(docId, committed, range);
+        pending = await this.store.getPendingChanges(docId);
+      }
+    } catch (err) {
+      console.error(`Flush failed for doc ${docId}:`, err);
+      this.onError.emit(err, { docId });
+      throw err;
+    }
+  }
+  async _receiveCommittedChanges(docId, serverChanges) {
+    try {
+      await this._applyServerChangesToDoc(docId, serverChanges);
+    } catch (err) {
+      this.onError.emit(err, { docId });
+    }
+  }
+  /**
+   * 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) {
+    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) {
+      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);
+    }
+    const { state, rev, changes: rebasedPendingChanges } = applyCommittedChanges(currentSnapshot, serverChanges);
+    if (doc) {
+      if (doc.committedRev === serverChanges[0].rev - 1) {
+        doc.applyCommittedChanges(serverChanges, rebasedPendingChanges);
+      } else {
+        doc.import({ state, rev, changes: rebasedPendingChanges });
+      }
+    }
+    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) {
+    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 {
+      console.warn(`Offline: Server delete for doc ${docId} deferred.`);
+    }
+  }
+  _handleConnectionChange(connectionState) {
+    const isConnected = connectionState === "connected";
+    const isConnecting = connectionState === "connecting";
+    const newSyncingState = isConnected ? this._state.syncing : isConnecting ? this._state.syncing : null;
+    this.updateState({ connected: isConnected, syncing: newSyncingState });
+    if (isConnected) {
+      void this.syncAllKnownDocs();
+    }
+  }
+  async _handleDocsTracked(docIds) {
+    const newIds = docIds.filter((id) => !this.trackedDocs.has(id));
+    if (!newIds.length) return;
+    newIds.forEach((id) => this.trackedDocs.add(id));
+    let subscribeIds = newIds;
+    if (this.options?.subscribeFilter) {
+      const alreadyTracked = this.options.subscribeFilter([...this.trackedDocs]);
+      subscribeIds = subscribeIds.filter((id) => !alreadyTracked.includes(id));
+    }
+    if (this.state.connected) {
+      try {
+        if (subscribeIds.length) {
+          await this.ws.subscribe(subscribeIds);
         }
-    };
-})();
-export { PatchesSync };
+        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);
+      }
+    }
+  }
+  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);
+      }
+    }
+  }
+}
+_init = __decoratorStart(null);
+__decorateElement(_init, 1, "syncDoc", _syncDoc_dec, PatchesSync);
+__decorateElement(_init, 1, "_receiveCommittedChanges", __receiveCommittedChanges_dec, PatchesSync);
+__decoratorMetadata(_init, PatchesSync);
+export {
+  PatchesSync
+};