@dabble/patches 0.8.5 → 0.8.7

package/dist/client/LWWInMemoryStore.d.ts

@@ -31,7 +31,7 @@ declare class LWWInMemoryStore implements LWWClientStore {
     listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
     /**
      * Saves the current document state to storage.
-     * Clears all committed fields, pending ops, and sending change.
+     * Clears committed fields (subsumed by the snapshot) but preserves pending ops.
      */
     saveDoc(docId: string, docState: PatchesState): Promise<void>;
     /**
@@ -71,7 +71,13 @@ declare class LWWInMemoryStore implements LWWClientStore {
      */
     saveSendingChange(docId: string, change: Change): Promise<void>;
     /**
-     * Clear sendingChange after server ack, move ops to committed.
+     * Move sending ops to committed, then clear the sending slot.
+     * committedRev is NOT updated here — applyServerChanges owns that using the
+     * server's actual rev. Updating it here would bump the rev above the server's
+     * real value for noop changes (where the server doesn't create a new rev).
+     *
+     * Call this BEFORE applyServerChanges so that server corrections (which run
+     * after) overwrite any stale ops for fields the server won via LWW.
      */
     confirmSendingChange(docId: string): Promise<void>;
     /**

package/dist/client/LWWInMemoryStore.js

@@ -51,14 +51,15 @@ class LWWInMemoryStore {
   }
   /**
    * Saves the current document state to storage.
-   * Clears all committed fields, pending ops, and sending change.
+   * Clears committed fields (subsumed by the snapshot) but preserves pending ops.
    */
   async saveDoc(docId, docState) {
+    const existing = this.docs.get(docId);
     this.docs.set(docId, {
       snapshot: { state: docState.state, rev: docState.rev },
       committedFields: /* @__PURE__ */ new Map(),
-      pendingOps: /* @__PURE__ */ new Map(),
-      sendingChange: null,
+      pendingOps: existing?.pendingOps ?? /* @__PURE__ */ new Map(),
+      sendingChange: existing?.sendingChange ?? null,
       committedRev: docState.rev
     });
   }
@@ -150,7 +151,13 @@ class LWWInMemoryStore {
     buf.pendingOps.clear();
   }
   /**
-   * Clear sendingChange after server ack, move ops to committed.
+   * Move sending ops to committed, then clear the sending slot.
+   * committedRev is NOT updated here — applyServerChanges owns that using the
+   * server's actual rev. Updating it here would bump the rev above the server's
+   * real value for noop changes (where the server doesn't create a new rev).
+   *
+   * Call this BEFORE applyServerChanges so that server corrections (which run
+   * after) overwrite any stale ops for fields the server won via LWW.
    */
   async confirmSendingChange(docId) {
     const buf = this.docs.get(docId);
@@ -158,10 +165,6 @@ class LWWInMemoryStore {
     for (const op of buf.sendingChange.ops) {
       buf.committedFields.set(op.path, op.value);
     }
-    const changeRev = buf.sendingChange.rev;
-    if (changeRev !== void 0 && changeRev > buf.committedRev) {
-      buf.committedRev = changeRev;
-    }
     buf.sendingChange = null;
   }
   /**

package/dist/client/LWWIndexedDBStore.d.ts

@@ -73,7 +73,7 @@ declare class LWWIndexedDBStore implements LWWClientStore {
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
     /**
      * Saves the current document state to storage.
-     * Clears all committed fields and pending ops.
+     * Clears committed fields (subsumed by the snapshot) but preserves pending ops.
      */
     saveDoc(docId: string, docState: PatchesState): Promise<void>;
     /**
@@ -101,7 +101,13 @@ declare class LWWIndexedDBStore implements LWWClientStore {
      */
     saveSendingChange(docId: string, change: Change): Promise<void>;
     /**
-     * Clear sendingChange after server ack, move ops to committed.
+     * Move sending ops to committed, then clear the sending slot.
+     * committedRev is NOT updated here — applyServerChanges owns that using the
+     * server's actual rev. Updating it here would bump the rev above the server's
+     * real value for noop changes (where the server doesn't create a new rev).
+     *
+     * Call this BEFORE applyServerChanges so that server corrections (which run
+     * after) overwrite any stale ops for fields the server won via LWW.
      */
     confirmSendingChange(docId: string): Promise<void>;
     /**

package/dist/client/LWWIndexedDBStore.js

@@ -122,17 +122,15 @@ class LWWIndexedDBStore {
     };
   }
   async saveDoc(docId, docState) {
-    const [tx, snapshots, committedOps, pendingOps, sendingChanges, docsStore] = await this.db.transaction(
-      ["snapshots", "committedOps", "pendingOps", "sendingChanges", "docs"],
+    const [tx, snapshots, committedOps, docsStore] = await this.db.transaction(
+      ["snapshots", "committedOps", "docs"],
       "readwrite"
     );
     const { rev, state } = docState;
     await Promise.all([
       docsStore.put({ docId, committedRev: rev, algorithm: "lww" }),
       snapshots.put({ docId, state, rev }),
-      this.deleteFieldsForDoc(committedOps, docId),
-      this.deleteFieldsForDoc(pendingOps, docId),
-      sendingChanges.delete(docId)
+      this.deleteFieldsForDoc(committedOps, docId)
     ]);
     await tx.complete();
   }
@@ -233,8 +231,8 @@ class LWWIndexedDBStore {
     await tx.complete();
   }
   async confirmSendingChange(docId) {
-    const [tx, sendingChanges, committedOps, docsStore] = await this.db.transaction(
-      ["sendingChanges", "committedOps", "docs"],
+    const [tx, sendingChanges, committedOps] = await this.db.transaction(
+      ["sendingChanges", "committedOps"],
       "readwrite"
     );
     const sending = await sendingChanges.get(docId);
@@ -243,13 +241,6 @@ class LWWIndexedDBStore {
       return;
     }
     await Promise.all(sending.change.ops.map((op) => committedOps.put({ ...op, docId })));
-    const changeRev = sending.change.rev;
-    if (changeRev !== void 0) {
-      const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0, algorithm: "lww" };
-      if (changeRev > docMeta.committedRev) {
-        await docsStore.put({ ...docMeta, committedRev: changeRev });
-      }
-    }
     await sendingChanges.delete(docId);
     await tx.complete();
   }

package/dist/client/OTInMemoryStore.js

@@ -31,10 +31,11 @@ class OTInMemoryStore {
   }
   // ─── Writes ────────────────────────────────────────────────────────────
   async saveDoc(docId, snapshot) {
+    const existing = this.docs.get(docId);
     this.docs.set(docId, {
       snapshot,
       committed: [],
-      pending: []
+      pending: existing?.pending ?? []
     });
   }
   async savePendingChanges(docId, changes) {

package/dist/client/OTIndexedDBStore.js

@@ -119,8 +119,7 @@ class OTIndexedDBStore {
     await Promise.all([
       docsStore.put({ docId, committedRev: rev, algorithm: "ot" }),
       snapshots.put({ docId, state, rev }),
-      committedChanges.delete([docId, 0], [docId, Infinity]),
-      pendingChanges.delete([docId, 0], [docId, Infinity])
+      committedChanges.delete([docId, 0], [docId, Infinity])
     ]);
     await tx.complete();
   }

package/dist/net/PatchesSync.d.ts

@@ -144,7 +144,7 @@ declare class PatchesSync extends ReadonlyStoreClass<PatchesSyncState> {
     protected _handleConnectionChange(connectionState: ConnectionState): void;
     protected _handleDocsTracked(docIds: string[], algorithmName?: AlgorithmName): Promise<void>;
     protected _handleDocsUntracked(docIds: string[]): Promise<void>;
-    protected _handleDocChange(docId: string): Promise<void>;
+    protected _handleDocChange(docId: string): void;
     /**
      * Unified handler for remote document deletion (both real-time notifications and offline discovery).
      * Cleans up local state and notifies the application with any pending changes that were lost.

package/dist/net/PatchesSync.js

@@ -12,7 +12,7 @@ import { breakChangesIntoBatches } from "../algorithms/ot/shared/changeBatching.
 import { BaseDoc } from "../client/BaseDoc.js";
 import { Patches } from "../client/Patches.js";
 import { isDocLoaded } from "../shared/utils.js";
-import { blockable } from "../utils/concurrency.js";
+import { blockable, serialGate } from "../utils/concurrency.js";
 import { ErrorCodes, StatusError } from "./error.js";
 import { PatchesWebSocket } from "./websocket/PatchesWebSocket.js";
 import { onlineState } from "./websocket/onlineState.js";
@@ -22,7 +22,7 @@ const EMPTY_DOC_STATE = {
   syncStatus: "unsynced",
   isLoaded: false
 };
-class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable], __receiveCommittedChanges_dec = [blockable], _a) {
+class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [serialGate], __receiveCommittedChanges_dec = [blockable], _a) {
   constructor(patches, urlOrConnection, options) {
     super({
       online: onlineState.isOnline,
@@ -232,7 +232,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     }
   }
   async syncDoc(docId) {
-    if (!this.state.connected) return;
+    if (!this.state.connected || !this.trackedDocs.has(docId)) return;
     this._updateDocSyncState(docId, { syncStatus: "syncing" });
     const doc = this.patches.getOpenDoc(docId);
     const algorithm = this._getAlgorithm(docId);
@@ -318,8 +318,8 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
             openDoc.import({ ...snapshot, changes: [] });
           }
         } else {
-          await this._applyServerChangesToDoc(docId, committed);
           await algorithm.confirmSent(docId, changeBatch);
+          await this._applyServerChangesToDoc(docId, committed);
         }
         pending = await algorithm.getPendingToSend(docId) ?? [];
       }
@@ -460,11 +460,11 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
       }
     }
   }
-  async _handleDocChange(docId) {
+  _handleDocChange(docId) {
     if (!this.trackedDocs.has(docId)) return;
     this._updateDocSyncState(docId, { hasPending: true });
     if (!this.state.connected) return;
-    await this.syncDoc(docId);
+    this.syncDoc(docId);
   }
   /**
    * Unified handler for remote document deletion (both real-time notifications and offline discovery).

package/dist/server/LWWBranchManager.d.ts

@@ -5,10 +5,10 @@ import { LWWServer } from './LWWServer.js';
 import { LWWStoreBackend, BranchingStoreBackend } from './types.js';
 import 'easy-signal';
 import '../net/websocket/AuthorizationProvider.js';
-import '../net/protocol/types.js';
+import '../json-patch/types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../json-patch/types.js';
+import '../net/protocol/types.js';
 import './PatchesServer.js';
 
 /**

package/dist/server/LWWServer.d.ts

@@ -4,10 +4,10 @@ import { Change, CommitChangesOptions, DeleteDocOptions, ChangeInput, ChangeMuta
 import { PatchesServer } from './PatchesServer.js';
 import { LWWStoreBackend } from './types.js';
 import '../net/websocket/AuthorizationProvider.js';
-import '../net/protocol/types.js';
+import '../json-patch/types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../json-patch/types.js';
+import '../net/protocol/types.js';
 
 /**
  * Configuration options for LWWServer.

package/dist/server/types.d.ts

@@ -1,5 +1,5 @@
 import { JSONPatchOp } from '../json-patch/types.js';
-import { VersionMetadata, Change, ListVersionsOptions, EditableVersionMetadata, ListChangesOptions, DocumentTombstone, Branch } from '../types.js';
+import { DocumentTombstone, VersionMetadata, Change, ListVersionsOptions, EditableVersionMetadata, ListChangesOptions, Branch } from '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 

package/dist/utils/concurrency.d.ts

@@ -18,6 +18,33 @@ declare function blocking<T extends (docId: string, ...args: any[]) => Promise<a
  * Also, a Typescript decorator for functions whose response should be blocked when needed.
  */
 declare function blockableResponse<T extends (docId: string, ...args: any[]) => Promise<any>>(target: T): T;
+/**
+ * Wraps a function so that only one invocation per key runs at a time.
+ * While in-flight, any additional calls for the same key are collapsed into
+ * exactly one queued follow-up. When the in-flight call finishes, the follow-up
+ * runs once (picking up all work that accumulated in the window). Further calls
+ * while the follow-up is itself in-flight queue another single follow-up, and
+ * so on — naturally serialising all work without ever dropping it.
+ *
+ * Contrast with `singleInvocation(true)`, which collapses concurrent calls but
+ * does not schedule a follow-up, so work that arrives mid-flight is lost until
+ * the next external trigger.
+ *
+ * ### Example
+ * ```ts
+ * const syncDoc = serialGate(async (docId: string) => {
+ *   const pending = await store.getPending(docId);
+ *   await server.commit(docId, pending);
+ * });
+ *
+ * // Three rapid calls: only one commitChanges in-flight at a time,
+ * // one follow-up picks up everything that arrived during the window.
+ * syncDoc('doc1');
+ * syncDoc('doc1');
+ * syncDoc('doc1');
+ * ```
+ */
+declare function serialGate<T extends (key: string, ...args: any[]) => Promise<void>>(target: T): T;
 /**
  * Wrap a function to only return the result of the first call.
  *
@@ -30,4 +57,4 @@ declare function blockableResponse<T extends (docId: string, ...args: any[]) =>
 declare function singleInvocation<T extends (...args: any[]) => Promise<any>>(target: T): T;
 declare function singleInvocation<T extends (...args: any[]) => Promise<any>>(matchOnFirstArg: boolean): (target: T) => T;
 
-export { blockable, blockableResponse, blocking, releaseConcurrency, singleInvocation };
+export { blockable, blockableResponse, blocking, releaseConcurrency, serialGate, singleInvocation };

package/dist/utils/concurrency.js

@@ -27,6 +27,39 @@ function blockableResponse(target) {
     return concurrency(args[0]).blockResponse(target.apply(this, args));
   };
 }
+function serialGate(target) {
+  const instances = /* @__PURE__ */ new WeakMap();
+  function getState(thisArg) {
+    let state = instances.get(thisArg);
+    if (!state) {
+      state = { inFlight: /* @__PURE__ */ new Map(), queued: /* @__PURE__ */ new Set() };
+      instances.set(thisArg, state);
+    }
+    return state;
+  }
+  function run(thisArg, key, args) {
+    const { inFlight, queued } = getState(thisArg);
+    const promise = target.apply(thisArg, [key, ...args]).finally(() => {
+      if (inFlight.get(key) === promise) {
+        inFlight.delete(key);
+        if (queued.has(key)) {
+          queued.delete(key);
+          run(thisArg, key, args);
+        }
+      }
+    });
+    inFlight.set(key, promise);
+    return promise;
+  }
+  return function(key, ...args) {
+    const { inFlight, queued } = getState(this);
+    if (inFlight.has(key)) {
+      queued.add(key);
+      return inFlight.get(key);
+    }
+    return run(this, key, args);
+  };
+}
 function singleInvocation(matchOnFirstArgOrTarget) {
   if (typeof matchOnFirstArgOrTarget === "function") {
     return singleInvocation(false)(matchOnFirstArgOrTarget);
@@ -50,5 +83,6 @@ export {
   blockableResponse,
   blocking,
   releaseConcurrency,
+  serialGate,
   singleInvocation
 };

package/dist/vue/composables.js

@@ -100,13 +100,21 @@ function _usePatchesDocEager(docId, options) {
   });
   let unsubscribe = null;
   if (autoClose) {
+    let unmounted = false;
     manager.openDoc(patches, docId, openDocOpts).then((patchesDoc) => {
+      if (unmounted) {
+        manager.closeDoc(patches, docId, shouldUntrack);
+        return;
+      }
       unsubscribe = setupDoc(patchesDoc);
     }).catch((err) => {
-      baseReturn.error.value = err;
-      baseReturn.loading.value = false;
+      if (!unmounted) {
+        baseReturn.error.value = err;
+        baseReturn.loading.value = false;
+      }
     });
     onBeforeUnmount(() => {
+      unmounted = true;
       unsubscribe?.();
       manager.closeDoc(patches, docId, shouldUntrack);
     });
@@ -219,6 +227,7 @@ function providePatchesDoc(name, docId, options = {}) {
   });
   const currentDocId = ref(unref(docId));
   let unsubscribe = null;
+  let providerUnmounted = false;
   async function initDoc(id) {
     currentDocId.value = id;
     unsubscribe?.();
@@ -226,10 +235,16 @@ function providePatchesDoc(name, docId, options = {}) {
     if (autoClose) {
       try {
         const patchesDoc = await manager.openDoc(patches, id, openDocOpts);
+        if (providerUnmounted || currentDocId.value !== id) {
+          manager.closeDoc(patches, id, shouldUntrack);
+          return;
+        }
         unsubscribe = setupDoc(patchesDoc);
       } catch (err) {
-        baseReturn.error.value = err;
-        baseReturn.loading.value = false;
+        if (!providerUnmounted && currentDocId.value === id) {
+          baseReturn.error.value = err;
+          baseReturn.loading.value = false;
+        }
       }
     } else {
       try {
@@ -264,6 +279,7 @@ function providePatchesDoc(name, docId, options = {}) {
     });
   }
   onBeforeUnmount(async () => {
+    providerUnmounted = true;
     unsubscribe?.();
     if (autoClose) {
       await manager.closeDoc(patches, currentDocId.value, shouldUntrack);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {