@dabble/patches 0.8.18 → 0.8.20

package/dist/{BaseDoc-BT18xPxU.d.ts → BaseDoc-CXHXcW18.d.ts}

@@ -47,7 +47,16 @@ declare class OTDoc<T extends object = object> extends BaseDoc<T> {
     getPendingChanges(): Change[];
     /**
      * Imports document state from a snapshot (e.g., for recovery when out of sync).
-     * Resets state and treats all imported changes as pending.
+     * Resets committed/pending state from the snapshot but PRESERVES outstanding
+     * optimistic ops (re-applied on top of the new state, dropping any that fail).
+     *
+     * Why preserve optimistic ops: import() can be called by sync recovery /
+     * cross-tab snapshot broadcast paths while the user is mid-typing. Wiping
+     * `_optimisticOps` would silently regress the input back to the snapshot
+     * value, causing visible "text jumps" and lost characters.
+     *
+     * Stale-snapshot guard: snapshots older than the current `_committedRev`
+     * are ignored — we already know more than the caller does.
      */
     import(snapshot: PatchesSnapshot<T>): void;
     /**
@@ -237,4 +246,4 @@ declare abstract class BaseDoc<T extends object = object> extends ReadonlyStoreC
     abstract import(snapshot: PatchesSnapshot<T>): void;
 }
 
-export { BaseDoc as B, OTDoc as O, type PatchesDoc as P, type PatchesDocOptions as a };
+export { BaseDoc as B, OTDoc as O, type PatchesDocOptions as P, type PatchesDoc as a };

package/dist/algorithms/ot/server/createVersion.d.ts

@@ -1,5 +1,5 @@
 import { OTStoreBackend } from '../../../server/types.js';
-import { EditableVersionMetadata, Change, VersionMetadata } from '../../../types.js';
+import { EditableVersionMetadata, VersionMetadata, Change } from '../../../types.js';
 import '../../../json-patch/types.js';
 import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';

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-BT18xPxU.js';
+export { B as BaseDoc } from '../BaseDoc-CXHXcW18.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/ClientAlgorithm.d.ts

@@ -1,6 +1,6 @@
 import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
-import { P as PatchesDoc } from '../BaseDoc-BT18xPxU.js';
+import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.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 { P as PatchesDoc } from '../BaseDoc-BT18xPxU.js';
+import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
 import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/LWWAlgorithm.js

@@ -26,7 +26,12 @@ class LWWAlgorithm {
     const committedRev = doc?.committedRev ?? await this.store.getCommittedRev(docId);
     const changes = [createChange(committedRev, committedRev + 1, timedOps, metadata)];
     if (doc) {
-      doc.applyChanges(changes, true);
+      const existingByPath = new Map(existingOps.map((op) => [op.path, op]));
+      const retiredInFlightOps = opsToSave.map((op) => existingByPath.get(op.path)).filter((op) => op !== void 0);
+      doc.applyChanges(changes, true, {
+        inFlightOpsOverride: opsToSave,
+        retiredInFlightOps
+      });
     }
     return changes;
   }

package/dist/client/LWWDoc.d.ts

@@ -1,8 +1,8 @@
+import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
-import { B as BaseDoc } from '../BaseDoc-BT18xPxU.js';
+import { B as BaseDoc } from '../BaseDoc-CXHXcW18.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../json-patch/types.js';
 import 'easy-signal';
 
 /**
@@ -29,6 +29,22 @@ declare class LWWDoc<T extends object = object> extends BaseDoc<T> {
     protected _hasPending: boolean;
     /** Confirmed state (from algorithm pipeline), used to recompute after server changes. */
     protected _baseState: T;
+    /**
+     * Content keys of pending local ops that have been applied to `_baseState` via the
+     * local-confirmation path (`committedAt === 0`) but not yet echoed back from the server.
+     *
+     * We key by op CONTENT (JSON.stringify) rather than by Change id because the LWW
+     * algorithm coalesces pending ops in its store and reissues a fresh sending Change
+     * (with a new id) in `getPendingToSend()`. The server then echoes that re-issued id
+     * back, so id-based echo detection would always fail. Op content (path + op + value
+     * + ts) survives the reissue intact, since the LWW algorithm preserves the original
+     * timestamped ops end-to-end.
+     *
+     * On a pure echo we skip both `_baseState += ops` (already applied locally) and
+     * `_recomputeState()` (would just produce a structurally-identical state with a
+     * fresh object identity, causing a spurious store emit mid-typing).
+     */
+    protected _inFlightOpKeys: Set<string>;
     /**
      * Creates an instance of LWWDoc.
      * @param id The unique identifier for this document.
@@ -41,7 +57,16 @@ declare class LWWDoc<T extends object = object> extends BaseDoc<T> {
     get hasPending(): boolean;
     /**
      * Imports document state from a snapshot (e.g., for recovery when out of sync).
-     * Resets state completely from the snapshot.
+     * Resets `_baseState` from the snapshot but PRESERVES outstanding optimistic ops
+     * (re-applied on top of the new state, dropping any that fail).
+     *
+     * Why preserve optimistic ops: import() can be called by sync recovery /
+     * cross-tab snapshot broadcast paths while the user is mid-typing. Wiping
+     * `_optimisticOps` would silently regress the input back to the snapshot
+     * value, causing visible "text jumps" and lost characters.
+     *
+     * Stale-snapshot guard: snapshots older than the current `_committedRev`
+     * are ignored — we already know more than the caller does.
      */
     import(snapshot: PatchesSnapshot<T>): void;
     /**
@@ -61,8 +86,27 @@ declare class LWWDoc<T extends object = object> extends BaseDoc<T> {
      * @param changes Array of changes to apply
      * @param hasPending If provided, overrides the inferred pending state.
      *   Used by LWWAlgorithm which knows the true pending state from the store.
+     * @param options Algorithm-only escape hatches for in-flight echo tracking:
+     *   - `inFlightOpsOverride`: tracks these ops in `_inFlightOpKeys` (and uses
+     *     them for echo detection) on local-confirm changes, INSTEAD of `c.ops`.
+     *     Required for combinable ops (`@inc`/`@bit`/`@max`/`@min`) where the
+     *     local-confirm Change carries the user's raw intent op but the algorithm
+     *     ships a consolidated op to the server. Without the override, the server
+     *     echo of the consolidated op wouldn't match any tracked key and we'd
+     *     emit a spurious recompute.
+     *   - `retiredInFlightOps`: drops these keys from `_inFlightOpKeys` on the
+     *     same call. Used by the algorithm to prune prior pending-op keys at
+     *     paths that are about to be overwritten by `inFlightOpsOverride`,
+     *     preventing unbounded orphan accumulation during fast typing into the
+     *     same field.
+     *
+     *   External callers (Worker-Tab sync, tests) should leave `options` undefined
+     *   and the legacy `c.ops`-based tracker will run.
      */
-    applyChanges(changes: Change[], hasPending?: boolean): void;
+    applyChanges(changes: Change[], hasPending?: boolean, options?: {
+        inFlightOpsOverride?: JSONPatchOp[];
+        retiredInFlightOps?: JSONPatchOp[];
+    }): void;
 }
 
 export { LWWDoc };

package/dist/client/LWWDoc.js

@@ -6,6 +6,22 @@ class LWWDoc extends BaseDoc {
   _hasPending;
   /** Confirmed state (from algorithm pipeline), used to recompute after server changes. */
   _baseState;
+  /**
+   * Content keys of pending local ops that have been applied to `_baseState` via the
+   * local-confirmation path (`committedAt === 0`) but not yet echoed back from the server.
+   *
+   * We key by op CONTENT (JSON.stringify) rather than by Change id because the LWW
+   * algorithm coalesces pending ops in its store and reissues a fresh sending Change
+   * (with a new id) in `getPendingToSend()`. The server then echoes that re-issued id
+   * back, so id-based echo detection would always fail. Op content (path + op + value
+   * + ts) survives the reissue intact, since the LWW algorithm preserves the original
+   * timestamped ops end-to-end.
+   *
+   * On a pure echo we skip both `_baseState += ops` (already applied locally) and
+   * `_recomputeState()` (would just produce a structurally-identical state with a
+   * fresh object identity, causing a spurious store emit mid-typing).
+   */
+  _inFlightOpKeys = /* @__PURE__ */ new Set();
   /**
    * Creates an instance of LWWDoc.
    * @param id The unique identifier for this document.
@@ -19,6 +35,7 @@ class LWWDoc extends BaseDoc {
     if (snapshot?.changes && snapshot.changes.length > 0) {
       const allOps = snapshot.changes.flatMap((c) => c.ops);
       this.state = applyPatch(this.state, allOps, { partial: true });
+      for (const op of allOps) this._inFlightOpKeys.add(opKey(op));
     }
     this._baseState = this.state;
     this._checkLoaded();
@@ -33,23 +50,43 @@ class LWWDoc extends BaseDoc {
   }
   /**
    * Imports document state from a snapshot (e.g., for recovery when out of sync).
-   * Resets state completely from the snapshot.
+   * Resets `_baseState` from the snapshot but PRESERVES outstanding optimistic ops
+   * (re-applied on top of the new state, dropping any that fail).
+   *
+   * Why preserve optimistic ops: import() can be called by sync recovery /
+   * cross-tab snapshot broadcast paths while the user is mid-typing. Wiping
+   * `_optimisticOps` would silently regress the input back to the snapshot
+   * value, causing visible "text jumps" and lost characters.
+   *
+   * Stale-snapshot guard: snapshots older than the current `_committedRev`
+   * are ignored — we already know more than the caller does.
    */
   import(snapshot) {
+    if (snapshot.rev < this._committedRev) return;
     this._committedRev = snapshot.rev;
     this._hasPending = (snapshot.changes?.length ?? 0) > 0;
-    this._optimisticOps = [];
-    let currentState = snapshot.state;
+    this._inFlightOpKeys.clear();
+    let baseState = snapshot.state;
     if (snapshot.changes && snapshot.changes.length > 0) {
-      currentState = applyPatch(
-        currentState,
-        snapshot.changes.flatMap((c) => c.ops),
-        { partial: true }
-      );
+      const allOps = snapshot.changes.flatMap((c) => c.ops);
+      baseState = applyPatch(baseState, allOps, { partial: true });
+      for (const op of allOps) this._inFlightOpKeys.add(opKey(op));
+    }
+    this._baseState = baseState;
+    let nextState = baseState;
+    if (this._optimisticOps.length > 0) {
+      const surviving = [];
+      for (const ops of this._optimisticOps) {
+        try {
+          nextState = applyPatch(nextState, ops, { strict: true });
+          surviving.push(ops);
+        } catch {
+        }
+      }
+      this._optimisticOps = surviving;
     }
-    this._baseState = currentState;
     this._checkLoaded();
-    this.state = currentState;
+    this.state = nextState;
   }
   /**
    * Recomputes state from the base state plus remaining optimistic ops.
@@ -74,8 +111,24 @@ class LWWDoc extends BaseDoc {
    * @param changes Array of changes to apply
    * @param hasPending If provided, overrides the inferred pending state.
    *   Used by LWWAlgorithm which knows the true pending state from the store.
+   * @param options Algorithm-only escape hatches for in-flight echo tracking:
+   *   - `inFlightOpsOverride`: tracks these ops in `_inFlightOpKeys` (and uses
+   *     them for echo detection) on local-confirm changes, INSTEAD of `c.ops`.
+   *     Required for combinable ops (`@inc`/`@bit`/`@max`/`@min`) where the
+   *     local-confirm Change carries the user's raw intent op but the algorithm
+   *     ships a consolidated op to the server. Without the override, the server
+   *     echo of the consolidated op wouldn't match any tracked key and we'd
+   *     emit a spurious recompute.
+   *   - `retiredInFlightOps`: drops these keys from `_inFlightOpKeys` on the
+   *     same call. Used by the algorithm to prune prior pending-op keys at
+   *     paths that are about to be overwritten by `inFlightOpsOverride`,
+   *     preventing unbounded orphan accumulation during fast typing into the
+   *     same field.
+   *
+   *   External callers (Worker-Tab sync, tests) should leave `options` undefined
+   *   and the legacy `c.ops`-based tracker will run.
    */
-  applyChanges(changes, hasPending) {
+  applyChanges(changes, hasPending, options) {
     if (changes.length === 0) return;
     let lastCommittedRev = this._committedRev;
     let hasPendingChanges = false;
@@ -91,7 +144,20 @@ class LWWDoc extends BaseDoc {
     this._committedRev = lastCommittedRev;
     this._hasPending = hasPending ?? hasPendingChanges;
     this._checkLoaded();
+    const isPureEcho = hasServerChanges && !hasPendingChanges && changes.every((c) => c.ops.every((op) => this._inFlightOpKeys.has(opKey(op))));
+    if (options?.retiredInFlightOps) {
+      for (const op of options.retiredInFlightOps) this._inFlightOpKeys.delete(opKey(op));
+    }
+    for (const c of changes) {
+      if (c.committedAt > 0) {
+        for (const op of c.ops) this._inFlightOpKeys.delete(opKey(op));
+      } else {
+        const opsToTrack = options?.inFlightOpsOverride ?? c.ops;
+        for (const op of opsToTrack) this._inFlightOpKeys.add(opKey(op));
+      }
+    }
     if (hasServerChanges) {
+      if (isPureEcho) return;
       const allOps = changes.flatMap((c) => c.ops);
       this._baseState = applyPatch(this._baseState, allOps, { partial: true });
       this._recomputeState();
@@ -106,6 +172,9 @@ class LWWDoc extends BaseDoc {
     }
   }
 }
+function opKey(op) {
+  return JSON.stringify(op);
+}
 export {
   LWWDoc
 };

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 { a as PatchesDocOptions, P as PatchesDoc } from '../BaseDoc-BT18xPxU.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-CXHXcW18.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-BT18xPxU.js';
+export { O as OTDoc } from '../BaseDoc-CXHXcW18.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';

package/dist/client/OTDoc.js

@@ -57,15 +57,36 @@ class OTDoc extends BaseDoc {
   }
   /**
    * Imports document state from a snapshot (e.g., for recovery when out of sync).
-   * Resets state and treats all imported changes as pending.
+   * Resets committed/pending state from the snapshot but PRESERVES outstanding
+   * optimistic ops (re-applied on top of the new state, dropping any that fail).
+   *
+   * Why preserve optimistic ops: import() can be called by sync recovery /
+   * cross-tab snapshot broadcast paths while the user is mid-typing. Wiping
+   * `_optimisticOps` would silently regress the input back to the snapshot
+   * value, causing visible "text jumps" and lost characters.
+   *
+   * Stale-snapshot guard: snapshots older than the current `_committedRev`
+   * are ignored — we already know more than the caller does.
    */
   import(snapshot) {
+    if (snapshot.rev < this._committedRev) return;
     this._committedState = snapshot.state;
     this._committedRev = snapshot.rev;
     this._pendingChanges = snapshot.changes;
-    this._optimisticOps = [];
     this._checkLoaded();
-    this.state = createStateFromSnapshot(snapshot);
+    let newState = createStateFromSnapshot(snapshot);
+    if (this._optimisticOps.length > 0) {
+      const surviving = [];
+      for (const ops of this._optimisticOps) {
+        try {
+          newState = applyPatch(newState, ops, { strict: true });
+          surviving.push(ops);
+        } catch {
+        }
+      }
+      this._optimisticOps = surviving;
+    }
+    this.state = newState;
   }
   /**
    * Recomputes state from committed + pending + remaining optimistic ops.
@@ -99,11 +120,15 @@ class OTDoc extends BaseDoc {
       if (this._committedRev !== serverChanges[0].rev - 1) {
         throw new Error("Cannot apply committed changes to a doc that is not at the correct revision");
       }
+      const priorPendingIds = new Set(this._pendingChanges.map((c) => c.id));
+      const isPureEcho = serverChanges.length > 0 && serverChanges.every((c) => priorPendingIds.has(c.id));
       this._committedState = applyChangesToState(this._committedState, serverChanges);
       this._committedRev = serverChanges[serverChanges.length - 1].rev;
       this._pendingChanges = rebasedPending;
       this._checkLoaded();
-      this._recomputeState();
+      if (!isPureEcho) {
+        this._recomputeState();
+      }
     } else {
       this._pendingChanges.push(...changes);
       this._checkLoaded();

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 { a as PatchesDocOptions, P as PatchesDoc } from '../BaseDoc-BT18xPxU.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
 import { AlgorithmName } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/PatchesBranchClient.d.ts

@@ -8,7 +8,7 @@ import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
 import './ClientAlgorithm.js';
-import '../BaseDoc-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.js';
 
 interface PatchesBranchClientOptions {
     /** Algorithm to use for the branch document (defaults to the Patches instance default). */

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, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
+export { O as OTDoc, a as PatchesDoc, P as PatchesDocOptions } from '../BaseDoc-CXHXcW18.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 { a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
+import { P as PatchesDocOptions } from '../BaseDoc-CXHXcW18.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, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, P as PatchesDocOptions } from '../BaseDoc-CXHXcW18.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmExternalDBPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches, upgradePatchesDB } 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, P as PatchesDoc, a as PatchesDocOptions } from './BaseDoc-BT18xPxU.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, P as PatchesDocOptions } from './BaseDoc-CXHXcW18.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmExternalDBPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches, upgradePatchesDB } from './client/factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
 export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';

package/dist/json-patch/applyPatch.js

@@ -3,6 +3,7 @@ import { getTypes } from "./ops/index.js";
 import { runWithObject } from "./state.js";
 import { exit } from "./utils/exit.js";
 import { getType } from "./utils/getType.js";
+import { isSoftOp, pathExistsInState } from "./utils/softWrites.js";
 function applyPatch(object, patches, opts = {}, custom) {
   if (patches.length === 0) {
     return object;
@@ -14,6 +15,9 @@ function applyPatch(object, patches, opts = {}, custom) {
   return runWithObject(object, types, patches.length > 1, (state) => {
     for (let i = 0, imax = patches.length; i < imax; i++) {
       const patch = patches[i];
+      if (isSoftOp(patch) && pathExistsInState(state.root[""], patch.path)) {
+        continue;
+      }
       const handler = getType(state, patch)?.apply;
       const error = handler ? handler(state, "" + patch.path, patch.from || patch.value) : `[op:${patch.op}] unknown`;
       if (error) {

package/dist/json-patch/utils/index.d.ts

@@ -8,7 +8,7 @@ export { isAdd, mapAndFilterOps, transformRemove, updateRemovedOps } from './ops
 export { getArrayIndex, getArrayPrefixAndIndex, getIndexAndEnd, getPrefix, getPrefixAndProp, getProp, getPropAfter, isArrayPath } from './paths.js';
 export { EMPTY, EMPTY_ARRAY, getValue, pluck, pluckWithShallowCopy } from './pluck.js';
 export { shallowCopy } from './shallowCopy.js';
-export { filterSoftWritesAgainstState, isEmptyContainer, updateSoftWrites } from './softWrites.js';
+export { filterSoftWritesAgainstState, isEmptyContainer, isSoftOp, pathExistsInState, updateSoftWrites } from './softWrites.js';
 export { toArrayIndex } from './toArrayIndex.js';
 export { toKeys } from './toKeys.js';
 export { updateArrayIndexes } from './updateArrayIndexes.js';

package/dist/json-patch/utils/softWrites.d.ts

@@ -7,10 +7,17 @@ declare function isEmptyContainer(value: any): boolean;
  * for any value that already exists.
  */
 declare function updateSoftWrites(overPath: string, ops: JSONPatchOp[], originalValue: any): JSONPatchOp[];
+/**
+ * Returns true when an op carries soft semantics — either an explicit
+ * `soft: true` flag, or an empty-container `add` (treated as initialization
+ * by convention). Mirrors the check used by the LWW consolidation algorithm.
+ */
+declare function isSoftOp(op: JSONPatchOp): boolean;
 /**
  * Filters out soft writes that would overwrite existing data in state.
  * Used when baseRev: 0 is jumped forward, bypassing normal transformation.
  */
 declare function filterSoftWritesAgainstState(ops: JSONPatchOp[], state: any): JSONPatchOp[];
+declare function pathExistsInState(state: any, path: string): boolean;
 
-export { filterSoftWritesAgainstState, isEmptyContainer, updateSoftWrites };
+export { filterSoftWritesAgainstState, isEmptyContainer, isSoftOp, pathExistsInState, updateSoftWrites };

package/dist/json-patch/utils/softWrites.js

@@ -16,10 +16,12 @@ function updateSoftWrites(overPath, ops, originalValue) {
     return op;
   });
 }
+function isSoftOp(op) {
+  return op.soft === true || op.op === "add" && isEmptyContainer(op.value);
+}
 function filterSoftWritesAgainstState(ops, state) {
   return ops.filter((op) => {
-    const isSoft = op.soft || op.op === "add" && isEmptyContainer(op.value);
-    if (!isSoft) return true;
+    if (!isSoftOp(op)) return true;
     return !pathExistsInState(state, op.path);
   });
 }
@@ -37,5 +39,7 @@ function pathExistsInState(state, path) {
 export {
   filterSoftWritesAgainstState,
   isEmptyContainer,
+  isSoftOp,
+  pathExistsInState,
   updateSoftWrites
 };

package/dist/net/PatchesSync.d.ts

@@ -13,7 +13,7 @@ import { WebSocketOptions } from './websocket/WebSocketTransport.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
-import '../BaseDoc-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.js';
 import '../utils/deferred.js';
 
 interface PatchesSyncState {

package/dist/net/index.d.ts

@@ -22,7 +22,7 @@ import '../algorithms/ot/shared/changeBatching.js';
 import '../client/BranchClientStore.js';
 import '../client/ClientAlgorithm.js';
 import '../json-patch/types.js';
-import '../BaseDoc-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.js';
 import '../client/PatchesStore.js';
 import '../client/Patches.js';
 import '../server/types.js';

package/dist/server/branchUtils.d.ts

@@ -1,5 +1,5 @@
 import { ApiDefinition } from '../net/protocol/JSONRPCServer.js';
-import { EditableBranchMetadata, Branch, CreateBranchMetadata } from '../types.js';
+import { EditableBranchMetadata, CreateBranchMetadata, Branch } from '../types.js';
 import 'easy-signal';
 import '../net/websocket/AuthorizationProvider.js';
 import './types.js';

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

@@ -1,5 +1,5 @@
 import { Patches, OpenDocOptions } from '../client/Patches.js';
-import { P as PatchesDoc } from '../BaseDoc-BT18xPxU.js';
+import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.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-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.js';
 import '../client/PatchesStore.js';
 import '../algorithms/ot/shared/changeBatching.js';
 import '../client/BranchClientStore.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-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.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-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../algorithms/ot/shared/changeBatching.js';

package/dist/solid/primitives.d.ts

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

package/dist/vue/composables.d.ts

@@ -1,6 +1,6 @@
-import { ShallowRef, Ref, MaybeRef, MaybeRefOrGetter } from 'vue';
+import { ShallowRef, Ref, MaybeRefOrGetter, MaybeRef } from 'vue';
 import { OpenDocOptions } from '../client/Patches.js';
-import { P as PatchesDoc } from '../BaseDoc-BT18xPxU.js';
+import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
 import { ChangeMutator } from '../types.js';
 import 'easy-signal';
 import '../json-patch/types.js';

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-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.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-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../algorithms/ot/shared/changeBatching.js';

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

@@ -1,4 +1,4 @@
-import { ShallowRef, Ref } from 'vue';
+import { Ref, ShallowRef } from 'vue';
 import { OpenDocOptions } from '../client/Patches.js';
 import 'easy-signal';
 import '../json-patch/types.js';
@@ -6,7 +6,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.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-BT18xPxU.js';
+import '../BaseDoc-CXHXcW18.js';
 import '../client/PatchesStore.js';
 import '../algorithms/ot/shared/changeBatching.js';
 import '../client/BranchClientStore.js';

package/package.json

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