cry-synced-db-client 2.0.7 → 2.0.9

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);
@@ -8279,6 +8322,13 @@ function canExpandArrayToBrackets(value) {
   }
   return true;
 }
+function unwrapWholeElement(value) {
+  if (Array.isArray(value)) {
+    return value.length === 1 && value[0] && typeof value[0] === "object" ? value[0] : null;
+  }
+  if (value && typeof value === "object") return value;
+  return null;
+}
 function pickLayerTarget(newPath, newValue) {
   if (!isTerminalBracketKey(newPath)) return null;
   if (newValue === void 0) return null;
@@ -8345,6 +8395,15 @@ function mergeDirtyPath(accumulated, newPath, newValue) {
     }
   }
   for (const k of descendants) delete accumulated[k];
+  if (newValue !== void 0 && isTerminalBracketKey(newPath) && Object.prototype.hasOwnProperty.call(accumulated, newPath)) {
+    const existingValue = accumulated[newPath];
+    const existingElement = unwrapWholeElement(existingValue);
+    const newElement = unwrapWholeElement(newValue);
+    if (existingElement && newElement && (Array.isArray(existingValue) || Array.isArray(newValue))) {
+      accumulated[newPath] = [newElement];
+      return;
+    }
+  }
   accumulated[newPath] = newValue;
 }
 function mergeDirtyChanges(accumulated, newChanges) {

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.7",
+  "version": "2.0.9",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",