@dabble/patches 0.7.18 → 0.7.20

package/dist/{BaseDoc-BRIP2YZp.d.ts → BaseDoc-CD5wZQMm.d.ts}

@@ -8,14 +8,16 @@ import { Change, PatchesSnapshot, DocSyncStatus, ChangeMutator } from './types.j
  * Uses a snapshot-based approach with revision tracking and rebasing
  * for handling concurrent edits.
  *
- * The `change()` method (inherited from BaseDoc) captures ops and emits them
- * via `onChange` - it does NOT apply locally. The OTAlgorithm handles packaging
- * ops into Changes, persisting them, and calling `applyChanges()` to update state.
+ * The `change()` method (inherited from BaseDoc) applies ops optimistically
+ * to `state` and emits them via `onChange`. The OTAlgorithm packages ops into
+ * Changes, persists them, and calls `applyChanges()` to confirm the optimistic
+ * update (shifting from the FIFO queue and skipping the state setter).
  *
  * ## State Model
  * - `_committedState`: Base state from server (at `_committedRev`)
  * - `_pendingChanges`: Local changes not yet committed by server
- * - `state` (getter from BaseDoc): Live state = committedState + pendingChanges applied
+ * - `_optimisticOps` (from BaseDoc): Ops applied by change() but not yet confirmed
+ * - `state`: Live state = committedState + pendingChanges + optimistic ops applied
  *
  * ## Wire Efficiency
  * For Worker-Tab communication, only changes are sent over the wire (not full state).
@@ -49,12 +51,17 @@ declare class OTDoc<T extends object = object> extends BaseDoc<T> {
      */
     import(snapshot: PatchesSnapshot<T>): void;
     /**
-     * Unified entry point for applying changes.
-     * Used for Worker→Tab communication where only changes are sent over the wire.
+     * Recomputes state from committed + pending + remaining optimistic ops.
+     */
+    protected _recomputeState(): void;
+    /**
+     * Confirms changes from the algorithm pipeline.
      *
-     * The method distinguishes between committed and pending changes using `committedAt`:
-     * - `committedAt > 0`: Server-committed change (apply to committed state)
-     * - `committedAt === 0`: Pending local change (append to pending)
+     * Distinguishes between committed and pending changes using `committedAt`:
+     * - `committedAt > 0`: Server-committed change (updates committed state, recomputes
+     *   with remaining optimistic ops preserved)
+     * - `committedAt === 0`: Local change confirmation (shifts from optimistic queue,
+     *   skips state update since change() already applied the ops)
      *
      * For server changes, all committed changes come first, followed by rebased pending.
      *
@@ -119,8 +126,8 @@ interface PatchesDoc<T extends object = object> extends ReadonlyStore<T> {
      */
     readonly onChange: Signal<(ops: JSONPatchOp[]) => void>;
     /**
-     * Captures an update to the document, emitting JSON Patch ops via onChange.
-     * Does NOT apply locally - the algorithm handles state updates.
+     * Captures an update to the document, applies it optimistically to state,
+     * and emits the ops via onChange for async persistence.
      * @param mutator Function that uses JSONPatch methods with type-safe paths.
      */
     change(mutator: ChangeMutator<T>): void;
@@ -130,15 +137,29 @@ interface PatchesDoc<T extends object = object> extends ReadonlyStore<T> {
  * Abstract base class for document implementations.
  * Contains shared state and methods used by both OTDoc and LWWDoc.
  *
- * The `change()` method captures ops and emits them via `onChange` - it does NOT
- * apply locally. The algorithm handles packaging ops, persisting them, and updating
- * the doc's state via `applyChanges()`.
+ * The `change()` method captures ops, applies them optimistically to `state`,
+ * and emits them via `onChange`. The algorithm handles packaging ops into Changes,
+ * persisting them, and confirming the optimistic update via `applyChanges()`.
+ *
+ * The mapping is strictly 1:1: one `change()` call produces one `applyChanges()`
+ * confirmation. A FIFO queue tracks outstanding optimistic ops so that
+ * `_recomputeState()` can reconstruct the full state (committed + pending +
+ * optimistic) when server changes arrive or during error recovery.
  *
- * Internal methods (updateSyncStatus, applyChanges, import) are on this class but not
- * on the PatchesDoc interface, as they're only used by Algorithm and PatchesSync.
+ * Internal methods (updateSyncStatus, applyChanges, import, rollbackOptimistic)
+ * are on this class but not on the PatchesDoc interface, as they're only used
+ * by Algorithm and PatchesSync.
  */
 declare abstract class BaseDoc<T extends object = object> extends ReadonlyStoreClass<T> implements PatchesDoc<T> {
     protected _id: string;
+    /**
+     * FIFO queue of ops applied optimistically by change() but not yet confirmed
+     * by applyChanges(). The 1:1 mapping between change() and applyChanges()
+     * means confirmation simply shifts from the front. The ops are stored (not
+     * just counted) so _recomputeState() can reconstruct the full state when
+     * server changes arrive during the optimistic window.
+     */
+    protected _optimisticOps: JSONPatchOp[][];
     /** Current sync status of this document. */
     readonly syncStatus: Store<DocSyncStatus>;
     /** Whether the document has completed its initial load. Sticky: once true, never reverts to false. */
@@ -164,11 +185,30 @@ declare abstract class BaseDoc<T extends object = object> extends ReadonlyStoreC
     /** Are there local changes that haven't been committed yet? */
     abstract get hasPending(): boolean;
     /**
-     * Captures an update to the document, emitting JSON Patch ops via onChange.
-     * Does NOT apply locally - the algorithm handles state updates via applyChanges.
+     * Captures an update to the document, applies it optimistically to state,
+     * and emits the ops via onChange for async persistence.
+     *
+     * State is updated synchronously (easy-signal's store.set() drains
+     * subscribers synchronously) so the UI sees changes immediately.
+     * The algorithm later confirms via applyChanges(), which shifts from
+     * the FIFO queue and skips the state update (avoiding double notifications).
+     *
      * @param mutator Function that uses JSONPatch methods with type-safe paths.
      */
     change(mutator: ChangeMutator<T>): void;
+    /**
+     * Rolls back all outstanding optimistic applies and recomputes state from
+     * confirmed state only. Called by Patches._handleDocChange when the
+     * algorithm rejects ops. Any remaining in-flight changes will apply
+     * normally via the fallback path in applyChanges().
+     */
+    rollbackOptimistic(): void;
+    /**
+     * Recomputes state from confirmed state (committed + pending) plus any
+     * remaining optimistic ops. Subclass-specific because each algorithm
+     * tracks committed/pending state differently.
+     */
+    protected abstract _recomputeState(): void;
     /**
      * Updates the sync status of the document.
      * Called by PatchesSync - not part of the app-facing PatchesDoc interface.
@@ -179,11 +219,11 @@ declare abstract class BaseDoc<T extends object = object> extends ReadonlyStoreC
     /** Latches _isLoaded to true when the doc has data or sync has resolved. */
     protected _checkLoaded(): void;
     /**
-     * Applies changes to the document state.
-     * Called by Algorithm for local changes and broadcasts - not part of PatchesDoc interface.
-     *
-     * For OT: Distinguishes committed (committedAt > 0) vs pending (committedAt === 0) changes.
-     * For LWW: Applies all ops from changes and updates metadata.
+     * Confirms changes from the algorithm pipeline.
+     * For local changes (committedAt === 0): shifts from the optimistic queue
+     * and skips the state update since change() already applied them.
+     * For server changes (committedAt > 0): updates committed state and
+     * recomputes with any remaining optimistic ops.
      *
      * @param changes Array of changes to apply.
      */

package/dist/algorithms/ot/shared/rebaseChanges.js

@@ -20,12 +20,13 @@ function rebaseChanges(serverChanges, localChanges) {
   );
   const baseRev = lastChange.rev;
   let rev = lastChange.rev;
-  return filteredLocalChanges.map((change) => {
+  const result = filteredLocalChanges.map((change) => {
     rev++;
     const ops = transformPatch.transform(change.ops).ops;
     if (!ops.length) return null;
     return { ...change, baseRev, rev, ops };
   }).filter(Boolean);
+  return result;
 }
 export {
   rebaseChanges

package/dist/client/BaseDoc.d.ts

@@ -1,6 +1,6 @@
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';
-export { B as BaseDoc } from '../BaseDoc-BRIP2YZp.js';
+export { B as BaseDoc } from '../BaseDoc-CD5wZQMm.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/BaseDoc.js

@@ -1,9 +1,18 @@
 import "../chunk-IZ2YBCUP.js";
 import { ReadonlyStoreClass, signal, store } from "easy-signal";
+import { applyPatch } from "../json-patch/applyPatch.js";
 import { createJSONPatch } from "../json-patch/createJSONPatch.js";
 import { isDocLoaded } from "../shared/utils.js";
 class BaseDoc extends ReadonlyStoreClass {
   _id;
+  /**
+   * FIFO queue of ops applied optimistically by change() but not yet confirmed
+   * by applyChanges(). The 1:1 mapping between change() and applyChanges()
+   * means confirmation simply shifts from the front. The ops are stored (not
+   * just counted) so _recomputeState() can reconstruct the full state when
+   * server changes arrive during the optimistic window.
+   */
+  _optimisticOps = [];
   /** Current sync status of this document. */
   syncStatus = store("unsynced");
   /** Whether the document has completed its initial load. Sticky: once true, never reverts to false. */
@@ -30,8 +39,14 @@ class BaseDoc extends ReadonlyStoreClass {
     return this._id;
   }
   /**
-   * Captures an update to the document, emitting JSON Patch ops via onChange.
-   * Does NOT apply locally - the algorithm handles state updates via applyChanges.
+   * Captures an update to the document, applies it optimistically to state,
+   * and emits the ops via onChange for async persistence.
+   *
+   * State is updated synchronously (easy-signal's store.set() drains
+   * subscribers synchronously) so the UI sees changes immediately.
+   * The algorithm later confirms via applyChanges(), which shifts from
+   * the FIFO queue and skips the state update (avoiding double notifications).
+   *
    * @param mutator Function that uses JSONPatch methods with type-safe paths.
    */
   change(mutator) {
@@ -39,8 +54,20 @@ class BaseDoc extends ReadonlyStoreClass {
     if (patch.ops.length === 0) {
       return;
     }
+    this.state = applyPatch(this.state, patch.ops, { strict: true });
+    this._optimisticOps.push(patch.ops);
     this.onChange.emit(patch.ops);
   }
+  /**
+   * Rolls back all outstanding optimistic applies and recomputes state from
+   * confirmed state only. Called by Patches._handleDocChange when the
+   * algorithm rejects ops. Any remaining in-flight changes will apply
+   * normally via the fallback path in applyChanges().
+   */
+  rollbackOptimistic() {
+    this._optimisticOps = [];
+    this._recomputeState();
+  }
   // --- Internal methods (not on PatchesDoc interface) ---
   /**
    * Updates the sync status of the document.

package/dist/client/ClientAlgorithm.d.ts

@@ -1,6 +1,6 @@
 import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
-import { a as PatchesDoc } from '../BaseDoc-BRIP2YZp.js';
+import { a as PatchesDoc } from '../BaseDoc-CD5wZQMm.js';
 import { PatchesStore, TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/LWWAlgorithm.d.ts

@@ -2,7 +2,7 @@ import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
 import { LWWClientStore } from './LWWClientStore.js';
-import { a as PatchesDoc } from '../BaseDoc-BRIP2YZp.js';
+import { a as PatchesDoc } from '../BaseDoc-CD5wZQMm.js';
 import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/LWWDoc.d.ts

@@ -1,5 +1,5 @@
 import { PatchesSnapshot, Change } from '../types.js';
-import { B as BaseDoc } from '../BaseDoc-BRIP2YZp.js';
+import { B as BaseDoc } from '../BaseDoc-CD5wZQMm.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
@@ -8,11 +8,14 @@ import 'easy-signal';
 /**
  * LWW (Last-Write-Wins) document implementation.
  *
- * The `change()` method (inherited from BaseDoc) captures ops and emits them
- * via `onChange` - it does NOT apply locally. The LWWAlgorithm handles:
- * - Packaging ops with timestamps
- * - Merging with pending fields
- * - Updating the doc's state via `applyChanges()`
+ * The `change()` method (inherited from BaseDoc) applies ops optimistically
+ * to `state` and emits them via `onChange`. The LWWAlgorithm packages ops
+ * with timestamps, persists them, and calls `applyChanges()` to confirm
+ * the optimistic update (shifting from the FIFO queue and skipping the state setter).
+ *
+ * Note: LWWAlgorithm adds `ts` (timestamp) metadata to ops before persisting.
+ * `applyPatch` ignores unknown op properties, so optimistic apply (raw ops)
+ * and confirmed apply (timestamped ops) produce identical state.
  *
  * Unlike OTDoc, LWWDoc doesn't need to track committed vs pending state
  * separately - the algorithm handles all conflict resolution by timestamp.
@@ -24,6 +27,8 @@ import 'easy-signal';
 declare class LWWDoc<T extends object = object> extends BaseDoc<T> {
     protected _committedRev: number;
     protected _hasPending: boolean;
+    /** Confirmed state (from algorithm pipeline), used to recompute after server changes. */
+    protected _baseState: T;
     /**
      * Creates an instance of LWWDoc.
      * @param id The unique identifier for this document.
@@ -40,13 +45,18 @@ declare class LWWDoc<T extends object = object> extends BaseDoc<T> {
      */
     import(snapshot: PatchesSnapshot<T>): void;
     /**
-     * Applies changes to the document state.
-     * Used for Worker-Tab communication where only changes are sent over the wire.
+     * Recomputes state from the base state plus remaining optimistic ops.
+     */
+    protected _recomputeState(): void;
+    /**
+     * Confirms changes from the algorithm pipeline.
      *
      * For LWW, all ops are applied in order. The method distinguishes between
      * committed and pending changes using `committedAt`:
-     * - `committedAt > 0`: Server-committed change (updates committedRev)
-     * - `committedAt === 0`: Pending local change (marks hasPending = true)
+     * - `committedAt > 0`: Server-committed change (updates committedRev, recomputes
+     *   state with remaining optimistic ops preserved)
+     * - `committedAt === 0`: Pending local change (shifts from optimistic queue,
+     *   skips state update since change() already applied the ops)
      *
      * @param changes Array of changes to apply
      * @param hasPending If provided, overrides the inferred pending state.

package/dist/client/LWWDoc.js

@@ -4,6 +4,8 @@ import { BaseDoc } from "./BaseDoc.js";
 class LWWDoc extends BaseDoc {
   _committedRev;
   _hasPending;
+  /** Confirmed state (from algorithm pipeline), used to recompute after server changes. */
+  _baseState;
   /**
    * Creates an instance of LWWDoc.
    * @param id The unique identifier for this document.
@@ -23,6 +25,7 @@ class LWWDoc extends BaseDoc {
       }
       this.state = currentState;
     }
+    this._baseState = this.state;
     this._checkLoaded();
   }
   /** Last committed revision number from the server. */
@@ -40,6 +43,7 @@ class LWWDoc extends BaseDoc {
   import(snapshot) {
     this._committedRev = snapshot.rev;
     this._hasPending = (snapshot.changes?.length ?? 0) > 0;
+    this._optimisticOps = [];
     let currentState = snapshot.state;
     if (snapshot.changes && snapshot.changes.length > 0) {
       for (const change of snapshot.changes) {
@@ -48,17 +52,29 @@ class LWWDoc extends BaseDoc {
         }
       }
     }
+    this._baseState = currentState;
     this._checkLoaded();
     this.state = currentState;
   }
   /**
-   * Applies changes to the document state.
-   * Used for Worker-Tab communication where only changes are sent over the wire.
+   * Recomputes state from the base state plus remaining optimistic ops.
+   */
+  _recomputeState() {
+    let newState = this._baseState;
+    for (const ops of this._optimisticOps) {
+      newState = applyPatch(newState, ops, { strict: true });
+    }
+    this.state = newState;
+  }
+  /**
+   * Confirms changes from the algorithm pipeline.
    *
    * For LWW, all ops are applied in order. The method distinguishes between
    * committed and pending changes using `committedAt`:
-   * - `committedAt > 0`: Server-committed change (updates committedRev)
-   * - `committedAt === 0`: Pending local change (marks hasPending = true)
+   * - `committedAt > 0`: Server-committed change (updates committedRev, recomputes
+   *   state with remaining optimistic ops preserved)
+   * - `committedAt === 0`: Pending local change (shifts from optimistic queue,
+   *   skips state update since change() already applied the ops)
    *
    * @param changes Array of changes to apply
    * @param hasPending If provided, overrides the inferred pending state.
@@ -66,17 +82,13 @@ class LWWDoc extends BaseDoc {
    */
   applyChanges(changes, hasPending) {
     if (changes.length === 0) return;
-    let currentState = this.state;
-    for (const change of changes) {
-      for (const op of change.ops) {
-        currentState = applyPatch(currentState, [op], { partial: true });
-      }
-    }
     let lastCommittedRev = this._committedRev;
     let hasPendingChanges = false;
+    let hasServerChanges = false;
     for (const change of changes) {
       if (change.committedAt > 0) {
         lastCommittedRev = change.rev;
+        hasServerChanges = true;
       } else {
         hasPendingChanges = true;
       }
@@ -84,7 +96,27 @@ class LWWDoc extends BaseDoc {
     this._committedRev = lastCommittedRev;
     this._hasPending = hasPending ?? hasPendingChanges;
     this._checkLoaded();
-    this.state = currentState;
+    if (hasServerChanges) {
+      let newBaseState = this._baseState;
+      for (const change of changes) {
+        for (const op of change.ops) {
+          newBaseState = applyPatch(newBaseState, [op], { partial: true });
+        }
+      }
+      this._baseState = newBaseState;
+      this._recomputeState();
+    } else {
+      for (const change of changes) {
+        for (const op of change.ops) {
+          this._baseState = applyPatch(this._baseState, [op], { partial: true });
+        }
+      }
+      if (this._optimisticOps.length > 0) {
+        this._optimisticOps.shift();
+      } else {
+        this._recomputeState();
+      }
+    }
   }
 }
 export {

package/dist/client/LWWInMemoryStore.js

@@ -158,9 +158,6 @@ class LWWInMemoryStore {
     for (const op of buf.sendingChange.ops) {
       buf.committedFields.set(op.path, op.value);
     }
-    if (buf.sendingChange.rev > buf.committedRev) {
-      buf.committedRev = buf.sendingChange.rev;
-    }
     buf.sendingChange = null;
   }
   /**

package/dist/client/LWWIndexedDBStore.js

@@ -243,10 +243,6 @@ class LWWIndexedDBStore {
       return;
     }
     await Promise.all(sending.change.ops.map((op) => committedOps.put({ ...op, docId })));
-    const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0, algorithm: "lww" };
-    if (sending.change.rev > docMeta.committedRev) {
-      await docsStore.put({ ...docMeta, committedRev: sending.change.rev });
-    }
     await sendingChanges.delete(docId);
     await tx.complete();
   }

package/dist/client/OTAlgorithm.d.ts

@@ -2,7 +2,7 @@ import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
 import { OTClientStore } from './OTClientStore.js';
-import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-BRIP2YZp.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-CD5wZQMm.js';
 import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/OTDoc.d.ts

@@ -1,5 +1,5 @@
 import '../types.js';
-export { O as OTDoc } from '../BaseDoc-BRIP2YZp.js';
+export { O as OTDoc } from '../BaseDoc-CD5wZQMm.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';

package/dist/client/OTDoc.js

@@ -1,6 +1,7 @@
 import "../chunk-IZ2YBCUP.js";
 import { createStateFromSnapshot } from "../algorithms/ot/client/createStateFromSnapshot.js";
 import { applyChanges as applyChangesToState } from "../algorithms/ot/shared/applyChanges.js";
+import { applyPatch } from "../json-patch/applyPatch.js";
 import { BaseDoc } from "./BaseDoc.js";
 class OTDoc extends BaseDoc {
   /** Base state from the server at the committed revision. */
@@ -21,7 +22,21 @@ class OTDoc extends BaseDoc {
     this._committedRev = snapshot?.rev ?? 0;
     this._pendingChanges = snapshot?.changes ?? [];
     if (this._pendingChanges.length > 0) {
-      this.state = applyChangesToState(this._committedState, this._pendingChanges);
+      try {
+        this.state = applyChangesToState(this._committedState, this._pendingChanges);
+      } catch {
+        let state = this._committedState;
+        const valid = [];
+        for (const c of this._pendingChanges) {
+          try {
+            state = applyPatch(state, c.ops, { strict: true });
+            valid.push(c);
+          } catch {
+          }
+        }
+        this._pendingChanges = valid;
+        this.state = state;
+      }
     }
     this._checkLoaded();
   }
@@ -48,16 +63,28 @@ class OTDoc extends BaseDoc {
     this._committedState = snapshot.state;
     this._committedRev = snapshot.rev;
     this._pendingChanges = snapshot.changes;
+    this._optimisticOps = [];
     this._checkLoaded();
     this.state = createStateFromSnapshot(snapshot);
   }
   /**
-   * Unified entry point for applying changes.
-   * Used for Worker→Tab communication where only changes are sent over the wire.
+   * Recomputes state from committed + pending + remaining optimistic ops.
+   */
+  _recomputeState() {
+    let newState = applyChangesToState(this._committedState, this._pendingChanges);
+    for (const ops of this._optimisticOps) {
+      newState = applyPatch(newState, ops, { strict: true });
+    }
+    this.state = newState;
+  }
+  /**
+   * Confirms changes from the algorithm pipeline.
    *
-   * The method distinguishes between committed and pending changes using `committedAt`:
-   * - `committedAt > 0`: Server-committed change (apply to committed state)
-   * - `committedAt === 0`: Pending local change (append to pending)
+   * Distinguishes between committed and pending changes using `committedAt`:
+   * - `committedAt > 0`: Server-committed change (updates committed state, recomputes
+   *   with remaining optimistic ops preserved)
+   * - `committedAt === 0`: Local change confirmation (shifts from optimistic queue,
+   *   skips state update since change() already applied the ops)
    *
    * For server changes, all committed changes come first, followed by rebased pending.
    *
@@ -76,11 +103,15 @@ class OTDoc extends BaseDoc {
       this._committedRev = serverChanges[serverChanges.length - 1].rev;
       this._pendingChanges = rebasedPending;
       this._checkLoaded();
-      this.state = applyChangesToState(this._committedState, this._pendingChanges);
+      this._recomputeState();
     } else {
       this._pendingChanges.push(...changes);
       this._checkLoaded();
-      this.state = applyChangesToState(this.state, changes);
+      if (this._optimisticOps.length > 0) {
+        this._optimisticOps.shift();
+      } else {
+        this.state = applyChangesToState(this.state, changes);
+      }
     }
   }
   /**

package/dist/client/Patches.d.ts

@@ -3,7 +3,7 @@ import { Unsubscriber } from 'easy-signal';
 import { JSONPatchOp } from '../json-patch/types.js';
 import { Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
-import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-BRIP2YZp.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-CD5wZQMm.js';
 import { AlgorithmName } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
@@ -46,6 +46,7 @@ interface ManagedDoc<T extends object> {
 declare class Patches {
     protected options: PatchesOptions;
     protected docs: Map<string, ManagedDoc<any>>;
+    private _changeQueues;
     readonly docOptions: PatchesDocOptions;
     readonly algorithms: Partial<Record<AlgorithmName, ClientAlgorithm>>;
     readonly defaultAlgorithm: AlgorithmName;
@@ -124,9 +125,12 @@ declare class Patches {
     close(): Promise<void>;
     /**
      * Internal handler for doc changes. Called when doc.onChange emits ops.
-     * Delegates to algorithm for packaging and persisting.
+     * Serializes calls per docId to prevent concurrent handleDocChange from
+     * creating changes with the same rev (which would overwrite each other
+     * in IndexedDB's [docId, rev] keyed pendingChanges store).
      */
     protected _handleDocChange<T extends object>(docId: string, ops: JSONPatchOp[], doc: PatchesDoc<T>, algorithm: ClientAlgorithm, metadata: Record<string, any>): Promise<void>;
+    private _processDocChange;
 }
 
 export { type OpenDocOptions, Patches, type PatchesOptions };

package/dist/client/Patches.js

@@ -14,6 +14,7 @@ class Patches {
     __runInitializers(_init, 5, this);
     __publicField(this, "options");
     __publicField(this, "docs", /* @__PURE__ */ new Map());
+    __publicField(this, "_changeQueues", /* @__PURE__ */ new Map());
     __publicField(this, "docOptions");
     __publicField(this, "algorithms");
     __publicField(this, "defaultAlgorithm");
@@ -148,6 +149,7 @@ class Patches {
     if (managed) {
       managed.unsubscribe();
       this.docs.delete(docId);
+      this._changeQueues.delete(docId);
       if (untrack) {
         await this.untrackDocs([docId]);
       }
@@ -186,6 +188,7 @@ class Patches {
   async close() {
     this.docs.forEach((managed) => managed.unsubscribe());
     this.docs.clear();
+    this._changeQueues.clear();
     await Promise.all(Object.values(this.algorithms).map((s) => s?.close()));
     this.onChange.clear();
     this.onDeleteDoc.clear();
@@ -196,14 +199,27 @@ class Patches {
   }
   /**
    * Internal handler for doc changes. Called when doc.onChange emits ops.
-   * Delegates to algorithm for packaging and persisting.
+   * Serializes calls per docId to prevent concurrent handleDocChange from
+   * creating changes with the same rev (which would overwrite each other
+   * in IndexedDB's [docId, rev] keyed pendingChanges store).
    */
-  async _handleDocChange(docId, ops, doc, algorithm, metadata) {
+  _handleDocChange(docId, ops, doc, algorithm, metadata) {
+    const prev = this._changeQueues.get(docId) ?? Promise.resolve();
+    const current = prev.then(() => this._processDocChange(docId, ops, doc, algorithm, metadata));
+    this._changeQueues.set(docId, current.catch(() => {
+    }));
+    return current;
+  }
+  async _processDocChange(docId, ops, doc, algorithm, metadata) {
     try {
       await algorithm.handleDocChange(docId, ops, doc, metadata);
       this.onChange.emit(docId);
     } catch (err) {
       console.error(`Error handling doc change for ${docId}:`, err);
+      const baseDoc = doc;
+      if (typeof baseDoc.rollbackOptimistic === "function") {
+        baseDoc.rollbackOptimistic();
+      }
       this.onError.emit(err, { docId });
     }
   }

package/dist/client/PatchesDoc.d.ts

@@ -1,6 +1,6 @@
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';
-export { O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-BRIP2YZp.js';
+export { O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-CD5wZQMm.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/factories.d.ts

@@ -1,6 +1,6 @@
 import { AlgorithmName } from './PatchesStore.js';
 import { Patches } from './Patches.js';
-import { P as PatchesDocOptions } from '../BaseDoc-BRIP2YZp.js';
+import { P as PatchesDocOptions } from '../BaseDoc-CD5wZQMm.js';
 import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/index.d.ts

@@ -1,4 +1,4 @@
-export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-BRIP2YZp.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-CD5wZQMm.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './IndexedDBStore.js';
 export { OTIndexedDBStore } from './OTIndexedDBStore.js';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Delta } from '@dabble/delta';
-export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from './BaseDoc-BRIP2YZp.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from './BaseDoc-CD5wZQMm.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './client/factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
 export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';

package/dist/net/PatchesSync.d.ts

@@ -14,7 +14,7 @@ import '@dabble/delta';
 import '../json-patch/types.js';
 import './PatchesClient.js';
 import '../utils/deferred.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 
 interface PatchesSyncState {
     online: boolean;

package/dist/net/index.d.ts

@@ -17,7 +17,7 @@ import 'easy-signal';
 import '../algorithms/ot/shared/changeBatching.js';
 import '../client/ClientAlgorithm.js';
 import '../json-patch/types.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';
 import '../client/Patches.js';
 import '../server/types.js';

package/dist/shared/doc-manager.d.ts

@@ -1,5 +1,5 @@
 import { Patches, OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-BRIP2YZp.js';
+import { a as PatchesDoc } from '../BaseDoc-CD5wZQMm.js';
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';

package/dist/solid/context.d.ts

@@ -7,7 +7,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';

package/dist/solid/doc-manager.d.ts

@@ -6,5 +6,5 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';

package/dist/solid/index.d.ts

@@ -11,7 +11,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../net/protocol/types.js';

package/dist/solid/primitives.d.ts

@@ -1,6 +1,6 @@
 import { Accessor } from 'solid-js';
 import { OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-BRIP2YZp.js';
+import { a as PatchesDoc } from '../BaseDoc-CD5wZQMm.js';
 import { JSONPatch } from '../json-patch/JSONPatch.js';
 import { ChangeMutator } from '../types.js';
 import 'easy-signal';

package/dist/vue/composables.d.ts

@@ -1,6 +1,6 @@
 import { ShallowRef, Ref, MaybeRef } from 'vue';
 import { OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-BRIP2YZp.js';
+import { a as PatchesDoc } from '../BaseDoc-CD5wZQMm.js';
 import { JSONPatch } from '../json-patch/JSONPatch.js';
 import { ChangeMutator } from '../types.js';
 import 'easy-signal';
@@ -77,7 +77,7 @@ interface UsePatchesDocReturn<T extends object> {
      * The underlying PatchesDoc instance.
      * Useful for advanced operations.
      */
-    doc: Ref<PatchesDoc<T> | undefined>;
+    doc: ShallowRef<PatchesDoc<T> | undefined>;
 }
 /**
  * Return type for usePatchesDoc composable (lazy mode).

package/dist/vue/composables.js

@@ -13,7 +13,7 @@ import { usePatchesContext } from "./provider.js";
 import { getDocManager } from "./doc-manager.js";
 function createDocReactiveState(options) {
   const { initialLoading = true, hasSyncContext = false, transformState, changeBehavior } = options;
-  const doc = ref(void 0);
+  const doc = shallowRef(void 0);
   const data = shallowRef(void 0);
   const loading = ref(initialLoading);
   const error = ref();

package/dist/vue/doc-manager.d.ts

@@ -6,5 +6,5 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';

package/dist/vue/index.d.ts

@@ -11,7 +11,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../net/protocol/types.js';

package/dist/vue/managed-docs.d.ts

@@ -6,7 +6,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';
 
 /**

package/dist/vue/provider.d.ts

@@ -7,7 +7,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BRIP2YZp.js';
+import '../BaseDoc-CD5wZQMm.js';
 import '../client/PatchesStore.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';

package/package.json

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