cry-synced-db-client 2.0.10 → 2.0.11

package/dist/index.js

@@ -3231,6 +3231,17 @@ function stripServerManagedFromChanges(changes) {
 
 // src/db/sync/SyncEngine.ts
 var SUPRESS_DB_WARNINGS = true;
+function sameDirtyValue(a, b) {
+  if (a === b) return true;
+  if (a !== null && b !== null && typeof a === "object" && typeof b === "object") {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch (e) {
+      return false;
+    }
+  }
+  return false;
+}
 var SyncEngine = class {
   constructor(config) {
     var _a;
@@ -3592,6 +3603,72 @@ var SyncEngine = class {
     }
     return out;
   }
+  /**
+   * Clear dirty entries for server-ACKed ids WITHOUT losing edits authored
+   * during the upload round-trip. SyncedDb.save() merges new diffs into the
+   * SAME dirty entry the in-flight upload read from (addDirtyChange runs at
+   * save()-time, not at flush-time), so a wholesale per-id delete destroys
+   * the only upload tracking of any edit that landed between getDirty and
+   * this clear — its content stays in the row (flushAllPendingChanges before
+   * the re-fetch sees it) at the ACKed _rev, never re-uploads, and no
+   * equal-rev echo ever repairs the server (mirror of the 2026-07-17
+   * incident; regression test: test/ackClearsRoundTripDirty.test.ts).
+   *
+   * Re-add rule: keep exactly the paths that are NEW or CHANGED relative to
+   * the upload-start snapshot (`dirtyAtUpload`). Everything unchanged is
+   * dropped — it was either uploaded+ACKed, or deliberately NOT sent
+   * (fixDotnetArrays stale-drop, preprocessDirtyItem transform); re-adding
+   * the latter would bypass that protection AND rebase it onto the fresh
+   * _rev so the staleness detection never fires again (regression witness:
+   * test/concurrentArrayMerge.test.ts LEGACY case). Comparison is against
+   * the upload-start snapshot, NOT against the sent payload: the payload
+   * holds STRIPPED values (nested _ts/_rev/_csq removed) and possibly
+   * translated keys, so it would false-positive every object/array path
+   * into a re-add loop (regression witness: test/stuckDirtyDirectInject).
+   *
+   * Skipped ids: server-deleted (local row is gone — re-adding would
+   * resurrect an upload) and mustRefresh (adoptMustRefresh re-adds its own
+   * remainder from dirtyBeforeRefresh).
+   */
+  async clearAckedDirtyPreservingRoundTripEdits(collection, allSuccessIds, ackedEntities, deletedEntities, mustRefreshIds, dirtyAtUpload) {
+    var _a;
+    if (allSuccessIds.length === 0) return;
+    const dirtyBeforeClear = await this.dexieDb.getDirtyChangesBatch(
+      collection,
+      allSuccessIds
+    );
+    await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
+    const deletedIds = /* @__PURE__ */ new Set();
+    for (const e of deletedEntities) deletedIds.add(String(e._id));
+    const ackedById = /* @__PURE__ */ new Map();
+    for (const e of ackedEntities) ackedById.set(String(e._id), e);
+    const reAdd = [];
+    for (const [sid, entry] of dirtyBeforeClear) {
+      if (deletedIds.has(sid) || mustRefreshIds.has(sid)) continue;
+      const atUpload = dirtyAtUpload.get(sid);
+      const remaining = {};
+      for (const path of Object.keys(entry.changes)) {
+        const value = entry.changes[path];
+        if (atUpload && path in atUpload && sameDirtyValue(value, atUpload[path])) {
+          continue;
+        }
+        remaining[path] = value;
+      }
+      if (Object.keys(remaining).length === 0) continue;
+      const ack = ackedById.get(sid);
+      reAdd.push({
+        id: sid,
+        changes: remaining,
+        baseMeta: {
+          _ts: (_a = ack == null ? void 0 : ack._ts) != null ? _a : entry.baseTs,
+          _rev: typeof (ack == null ? void 0 : ack._rev) === "number" ? ack._rev : entry.baseRev
+        }
+      });
+    }
+    if (reAdd.length > 0) {
+      await this.dexieDb.addDirtyChangesBatch(collection, reAdd);
+    }
+  }
   /**
    * Diagnostic guard for the ACK writeback path: after pending writes have
    * been flushed and the row re-read, every plain scalar top-level field of
@@ -3632,8 +3709,9 @@ var SyncEngine = class {
    * Upload dirty items for all collections.
    */
   async uploadDirtyItems(calledFrom) {
-    var _a, _b;
+    var _b, _c, _d;
     const collectionBatches = [];
+    const dirtyAtUploadByCollection = /* @__PURE__ */ new Map();
     for (const [collectionName] of this.collections)
       try {
         const dirtyChanges = await this.dexieDb.getDirty(collectionName);
@@ -3642,6 +3720,12 @@ var SyncEngine = class {
         for (const dirtyItem of dirtyChanges) {
           dirtyChangesMap.set(String(dirtyItem._id), dirtyItem);
         }
+        const atUpload = /* @__PURE__ */ new Map();
+        for (const [sid, dc] of dirtyChangesMap) {
+          const _a = dc, { _id, _ts, _rev } = _a, changes = __objRest(_a, ["_id", "_ts", "_rev"]);
+          atUpload.set(sid, changes);
+        }
+        dirtyAtUploadByCollection.set(collectionName, atUpload);
         const updates = [];
         const skipped = [];
         const ids = dirtyChanges.map((dc) => dc._id);
@@ -3829,7 +3913,7 @@ var SyncEngine = class {
         for (const b of batch) {
           const allIds = [];
           for (const u of b.batch.updates) allIds.push(u._id);
-          for (const d of b.batch.deletes) allIds.push((_a = d._id) != null ? _a : d);
+          for (const d of b.batch.deletes) allIds.push((_b = d._id) != null ? _b : d);
           const newlyStuck = await this.dexieDb.incrementDirtyUploadAttempts(
             b.collection,
             allIds
@@ -3891,7 +3975,14 @@ var SyncEngine = class {
       ]) : /* @__PURE__ */ new Map();
       const uploadedByIdRefresh = mustRefreshIds.size > 0 ? this.uploadedSnapshotFor(collectionBatches, collection) : /* @__PURE__ */ new Map();
       if (allSuccessIds.length > 0) {
-        await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
+        await this.clearAckedDirtyPreservingRoundTripEdits(
+          collection,
+          allSuccessIds,
+          inserted.concat(updated),
+          deleted,
+          mustRefreshIds,
+          (_c = dirtyAtUploadByCollection.get(collection)) != null ? _c : /* @__PURE__ */ new Map()
+        );
       }
       const sentIdsForCollection = /* @__PURE__ */ new Set();
       for (const batch of collectionBatches) {
@@ -3917,7 +4008,7 @@ var SyncEngine = class {
         await this.callOnDirtyItemStuck(collection, newlyStuck, calledFrom);
       }
       let collectionSentCount = 0;
-      const isWriteOnly = (_b = this.collections.get(collection)) == null ? void 0 : _b.writeOnly;
+      const isWriteOnly = (_d = this.collections.get(collection)) == null ? void 0 : _d.writeOnly;
       const insertedAndUpdated = inserted.concat(updated);
       if (insertedAndUpdated.length > 0) {
         const idsToCheck = [];
@@ -4098,6 +4189,11 @@ var SyncEngine = class {
     for (const dirtyItem of dirtyItems) {
       dirtyChangesMap.set(String(dirtyItem._id), dirtyItem);
     }
+    const dirtyAtUpload = /* @__PURE__ */ new Map();
+    for (const [sid, dc] of dirtyChangesMap) {
+      const _a = dc, { _id, _ts, _rev } = _a, changes = __objRest(_a, ["_id", "_ts", "_rev"]);
+      dirtyAtUpload.set(sid, changes);
+    }
     const updates = [];
     for (const fullItem of fullItems) {
       if (!fullItem) continue;
@@ -4115,7 +4211,7 @@ var SyncEngine = class {
           collection,
           batch: {
             updates: updates.map((item) => {
-              const _a = item.delta, { _ts, _rev } = _a, changes = __objRest(_a, ["_ts", "_rev"]);
+              const _a2 = item.delta, { _ts, _rev } = _a2, changes = __objRest(_a2, ["_ts", "_rev"]);
               return {
                 _id: item._id,
                 _rev: typeof _rev === "number" ? _rev : 0,
@@ -4187,7 +4283,14 @@ var SyncEngine = class {
       const dirtyBeforeRefresh = refreshIds.length > 0 ? await this.dexieDb.getDirtyChangesBatch(collection, refreshIds) : /* @__PURE__ */ new Map();
       const uploadedByIdRefresh = refreshIds.length > 0 ? this.uploadedSnapshotFor(collectionBatches, collection) : /* @__PURE__ */ new Map();
       if (allSuccessIds.length > 0) {
-        await this.dexieDb.clearDirtyChangesBatch(collection, allSuccessIds);
+        await this.clearAckedDirtyPreservingRoundTripEdits(
+          collection,
+          allSuccessIds,
+          inserted.concat(updated),
+          deleted,
+          new Set(refreshIds),
+          dirtyAtUpload
+        );
       }
       const sentIdsForCollection = /* @__PURE__ */ new Set();
       for (const batch of collectionBatches) {

package/dist/src/db/sync/SyncEngine.d.ts

@@ -54,6 +54,34 @@ export declare class SyncEngine implements I_SyncEngine {
      * server-reconciled paths from local edits made during the round-trip.
      */
     private uploadedSnapshotFor;
+    /**
+     * Clear dirty entries for server-ACKed ids WITHOUT losing edits authored
+     * during the upload round-trip. SyncedDb.save() merges new diffs into the
+     * SAME dirty entry the in-flight upload read from (addDirtyChange runs at
+     * save()-time, not at flush-time), so a wholesale per-id delete destroys
+     * the only upload tracking of any edit that landed between getDirty and
+     * this clear — its content stays in the row (flushAllPendingChanges before
+     * the re-fetch sees it) at the ACKed _rev, never re-uploads, and no
+     * equal-rev echo ever repairs the server (mirror of the 2026-07-17
+     * incident; regression test: test/ackClearsRoundTripDirty.test.ts).
+     *
+     * Re-add rule: keep exactly the paths that are NEW or CHANGED relative to
+     * the upload-start snapshot (`dirtyAtUpload`). Everything unchanged is
+     * dropped — it was either uploaded+ACKed, or deliberately NOT sent
+     * (fixDotnetArrays stale-drop, preprocessDirtyItem transform); re-adding
+     * the latter would bypass that protection AND rebase it onto the fresh
+     * _rev so the staleness detection never fires again (regression witness:
+     * test/concurrentArrayMerge.test.ts LEGACY case). Comparison is against
+     * the upload-start snapshot, NOT against the sent payload: the payload
+     * holds STRIPPED values (nested _ts/_rev/_csq removed) and possibly
+     * translated keys, so it would false-positive every object/array path
+     * into a re-add loop (regression witness: test/stuckDirtyDirectInject).
+     *
+     * Skipped ids: server-deleted (local row is gone — re-adding would
+     * resurrect an upload) and mustRefresh (adoptMustRefresh re-adds its own
+     * remainder from dirtyBeforeRefresh).
+     */
+    private clearAckedDirtyPreservingRoundTripEdits;
     /**
      * Diagnostic guard for the ACK writeback path: after pending writes have
      * been flushed and the row re-read, every plain scalar top-level field of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cry-synced-db-client",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",