@dabble/patches 0.8.6 → 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.js

@@ -318,8 +318,8 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [serialGate],
             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) ?? [];
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.8.6",
+  "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": {