cry-synced-db-client 2.0.8 → 2.0.10

package/dist/index.js

@@ -3592,6 +3592,42 @@ var SyncEngine = class {
     }
     return out;
   }
+  /**
+   * 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
+   * the just-uploaded delta should already be present with the uploaded
+   * value. A mismatch means the re-read row still lags the server-confirmed
+   * write — either a legitimate NEWER local edit landed after the upload
+   * snapshot was taken (its own pending write will re-assert it), or a
+   * residual race in the flush/re-fetch ordering. Either way, stamping the
+   * new _rev onto such a row is exactly the mechanism that canonized stale
+   * content in the 2026-07-17 vbptuj/obravnave incident, so it must be
+   * observable in production logs. Comparison is deliberately limited to
+   * plain scalar top-level keys: dot/bracket paths and object/array values
+   * are skipped (deep-equality cost + mongo key-order make them unreliable
+   * for a hot-path check).
+   */
+  warnIfRowLagsUploadedDelta(collection, freshItem, uploaded) {
+    if (!uploaded) return;
+    const mismatches = [];
+    for (const key of Object.keys(uploaded)) {
+      if (key === "_id" || key === "_lastUpdaterId") continue;
+      if (key.includes(".") || key.includes("[")) continue;
+      const up = uploaded[key];
+      if (up !== null && typeof up === "object") continue;
+      const local = freshItem[key];
+      if (local !== up) {
+        mismatches.push(
+          `${key} (local=${JSON.stringify(local)}, uploaded=${JSON.stringify(up)})`
+        );
+      }
+    }
+    if (mismatches.length > 0) {
+      console.warn(
+        `[SyncEngine] ACK writeback: re-read row lags uploaded delta for ${collection}:${String(freshItem._id)} \u2014 ${mismatches.join(", ")}`
+      );
+    }
+  }
   /**
    * Upload dirty items for all collections.
    */
@@ -3803,6 +3839,7 @@ var SyncEngine = class {
       }
       throw err;
     }
+    await this.deps.flushAllPendingChanges();
     let sentCount = 0;
     const collectionSentCounts = {};
     for (const result of results) {
@@ -3914,10 +3951,16 @@ var SyncEngine = class {
           const inMemUpdateBatch = [];
           if (saveIds.length > 0) {
             const freshItems = await this.dexieDb.getByIds(collection, saveIds);
+            const uploadedById = this.uploadedSnapshotFor(collectionBatches, collection);
             for (const freshItem of freshItems) {
               if (!freshItem) continue;
               const revTs = revById.get(String(freshItem._id));
               if (!revTs) continue;
+              this.warnIfRowLagsUploadedDelta(
+                collection,
+                freshItem,
+                uploadedById.get(String(freshItem._id))
+              );
               freshItem._rev = revTs.rev;
               freshItem._ts = revTs.ts;
               dexieSaveBatch.push(freshItem);
@@ -5979,12 +6022,26 @@ var _SyncedDb = class _SyncedDb {
    * @param calledFrom Diagnostic tag threaded through to upload callbacks
    */
   async flushToServer(calledFrom) {
-    if (!this.initialized) return;
-    if (!this.connectionManager.canSync()) return;
-    this.pendingChanges.cancelRestUploadTimer();
-    await this.pendingChanges.flushAll();
-    await this.pendingChanges.awaitRestUpload();
-    await this.syncEngine.uploadDirtyItems(calledFrom);
+    try {
+      if (!this.initialized) return;
+      if (!this.connectionManager.canSync()) return;
+      this.pendingChanges.cancelRestUploadTimer();
+      await this.pendingChanges.flushAll();
+      await this.pendingChanges.awaitRestUpload();
+      await this.syncEngine.uploadDirtyItems(calledFrom);
+    } catch (err) {
+      console.error(`[SyncedDb] flushToServer ${(err == null ? void 0 : err.rejectMessage) || (err == null ? void 0 : err.message) || ""}`, {
+        err,
+        calledFrom,
+        callstack: (() => {
+          try {
+            return new Error().stack;
+          } catch (e) {
+            return void 0;
+          }
+        })()
+      });
+    }
   }
   /**
    * Returns when all collections were last successfully synced

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

@@ -54,6 +54,22 @@ export declare class SyncEngine implements I_SyncEngine {
      * server-reconciled paths from local edits made during the round-trip.
      */
     private uploadedSnapshotFor;
+    /**
+     * 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
+     * the just-uploaded delta should already be present with the uploaded
+     * value. A mismatch means the re-read row still lags the server-confirmed
+     * write — either a legitimate NEWER local edit landed after the upload
+     * snapshot was taken (its own pending write will re-assert it), or a
+     * residual race in the flush/re-fetch ordering. Either way, stamping the
+     * new _rev onto such a row is exactly the mechanism that canonized stale
+     * content in the 2026-07-17 vbptuj/obravnave incident, so it must be
+     * observable in production logs. Comparison is deliberately limited to
+     * plain scalar top-level keys: dot/bracket paths and object/array values
+     * are skipped (deep-equality cost + mongo key-order make them unreliable
+     * for a hot-path check).
+     */
+    private warnIfRowLagsUploadedDelta;
     /**
      * Upload dirty items for all collections.
      */

package/package.json

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