cry-synced-db-client 0.1.151 → 0.1.156

package/CHANGELOG.md

@@ -1,5 +1,138 @@
 # Versions
 
+## 0.1.156
+
+Three related fixes targeting **dirty-payload metadata leak** and
+**concurrent array merge corruption** observed in production
+(tenant *prvak*, obravnave with stale offline edits silently dropping
+field updates from a second device).
+
+### Bracket-by-_id array path notation in `computeDiff`
+
+Array element paths emitted by `computeDiff` now use bracket notation
+keyed by the element's `_id`:
+
+```diff
+- "koraki.0.diagnostika"     // position-based — corrupts on reorder
++ "koraki[<korakId>].diagnostika"  // identity-based — survives reorder
+```
+
+Why: with position-based dot notation, if device B reordered or
+inserted/removed earlier elements while device A was offline, A's
+upload of `koraki.0.field` would mongo `$set` the wrong element on
+the server.
+
+`tokenizePath()` is now exported and accepts both `.` and `[…]`
+delimiters. `setByPath` and `isDescendantOrEqual` updated to handle
+bracket segments.
+
+### `translateBracketPathsToIndex` (upload-time)
+
+`SyncEngine.uploadDirtyItems` translates bracket paths to mongo
+`$set`-compatible index paths just before upload, using the current
+local entity (post-sync, post-merge) as the source of truth for
+`_id → index` mapping. Paths whose `_id` cannot be resolved (concurrent
+deletion on the server) are dropped — preferring partial loss over
+silently writing to the wrong index.
+
+### Server-managed metadata excluded from dirty payloads
+
+`computeDiff` skips `_ts`, `_rev`, `_csq` at the top level. As a
+defense-in-depth, `SyncEngine.uploadDirtyItems` strips any path
+beginning with `_ts.`, `_rev.`, `_csq.` before upload (mitigates legacy
+dirty rows written by older library versions).
+
+Why: the BSON `Timestamp` shape `{t, i}` was being recursed into by
+`computeDiff`, emitting paths like `_ts.t` / `_ts.i`. These conflicted
+with mongo's `$currentDate` operator on the server — silent rejection
+left items dirty forever and blocked subsequent uploads.
+
+### `mergeObjectArrays` — server composition is authoritative
+
+When parent `_rev` says the server is newer (`parentServerWins=true`):
+
+1. **Drop local-only elements**. Per directive: *"če ima server višji
+   `_rev` in nima več elementa z nekim `_id`, client ne sme zopet
+   dodati tega zapisa v array"*. The server has authoritatively
+   removed the element; the client must not resurrect it.
+2. **Server's value wins on primitive conflicts inside surviving
+   sub-elements** (Option B — propagate `_rev` for *comparison only*,
+   never written into sub-objects).
+
+When local `_rev >= external _rev`, behavior is unchanged: union
+semantics preserve local-only elements (server is older / equal).
+
+### `mergeObjectArrays` — fail-fast on missing `_id`
+
+Per directive: array elements MUST carry `_id`. If any element on
+either side lacks `_id`, log `console.error` for each offender and
+fall back to **whole-array replace by higher `_rev`** (parent's verdict
+chooses local vs external). Prevents silent merge corruption when
+schemas regress.
+
+### `fixDotnetArrays` (legacy mitigation)
+
+Temporary upload-time scrubber dropping legacy position-based array
+paths (`field.<digit>(.…)?`) when `serverRev > baseRev`. Marked for
+removal after ~2026-05-15 once all clients have re-synced.
+
+## 0.1.155
+
+Two new `SyncedDbConfig` fields targeting **cross-device scope-exit**
+detection: situations where one device modifies a record so it no longer
+matches the positive `syncConfig.query` (e.g. status `'odprta'` →
+`'zaključena'` on a `{status: {$ne: 'zaključena'}}` query) while another
+device is offline at that moment. The filtered delta feed never re-ships
+the post-mutation row, so the second device's local cache otherwise
+goes stale forever.
+
+### `scopeExitLookbehindMs?: number` (default `0`)
+
+Default lookbehind window (ms) for server-assisted scope-exit detection
+in auto-eviction (`sync()` bundled) and `evictOutOfScopeRecordsAll`.
+When set (> 0), the scope-exit `findNewerMany` spec uses
+`_ts > now - scopeExitLookbehindMs` instead of `_ts > lastSyncTs`.
+
+Why: with the legacy `lastSyncTs` cursor, the scope-exit query
+`{$nor:[positiveQuery], _id:{$in:chunk}, _ts > lastSyncTs}` excluded any
+record whose server-side `_ts` predated the device's `lastSyncTs`.
+Typical cross-device close-out scenario: device A closes a record at T0,
+device B (offline at T0) reconnects at T1 and syncs many newer records,
+advancing `lastSyncTs` past T0 → server returned 0 scope-exit candidates
+forever even though the closed record was a clear scope-exit.
+
+Per-call override remains via
+`evictOutOfScopeRecords({outOfWindowLookbehindMs})` — now also falls
+back to global `scopeExitLookbehindMs` when no per-call value is given.
+
+Recommended for multi-device deployments: `3 * 24 * 3600 * 1000` (3 days).
+Combine with periodic `refreshDatabaseFromServer()` (e.g. when
+`lastInitialSync()` exceeds the same threshold) to cover drift older
+than the lookbehind window.
+
+### `evictOnWake?: boolean` (default `false`)
+
+When `true`, scope-exit eviction runs on every wake event (`sync()`
+whose `calledFrom` starts with `'wake-sync:'`), bypassing the
+`evictStaleRecordsEveryHrs` interval gate. The eviction is bundled into
+the wake sync's `findNewerManyStream` call — single RTT, same shape as
+existing 8h auto-eviction (`evictStaleRecordsEveryHrs` continues to gate
+non-wake syncs: interval auto-sync ticks, manual `sync()` calls without
+`'wake-sync:*'` prefix).
+
+Combine with `scopeExitLookbehindMs` to guarantee that any cross-device
+close-out within the lookbehind window becomes visible on the very next
+wake.
+
+### Implementation
+
+- `SyncedDb.ts` `_isAutoEvictionDue(calledFrom?)` — wake-sync trigger
+  bypasses interval gate when `evictOnWake = true`.
+- New private `_scopeExitTimestamp(collection)` — single source of truth
+  for the scope-exit query timestamp; honors `scopeExitLookbehindMs`.
+- `_collectScopeExitPlan` and single-collection `evictOutOfScopeRecords`
+  both route through the new helper.
+
 ## Unreleased
 
 ### `SyncSource` flag in `I_InMemDb.saveMany` / `deleteManyByIds`

package/dist/index.js

@@ -273,6 +273,241 @@ function applyQueryOpts(items, opts) {
   return result;
 }
 
+// src/utils/computeDiff.ts
+function isObjectIdLike(v) {
+  return !!(v && typeof v === "object" && (v._bsontype === "ObjectId" || v._bsontype === "ObjectID") && typeof v.toString === "function");
+}
+function isPlainObject(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (Array.isArray(v)) return false;
+  if (v instanceof Date) return false;
+  if (isObjectIdLike(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (a === void 0 || b === void 0) return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (isObjectIdLike(a) && isObjectIdLike(b)) {
+    return String(a) === String(b);
+  }
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEquals(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+    if (!deepEquals(a[k], b[k])) return false;
+  }
+  return true;
+}
+function allElementsHaveId(arr) {
+  if (arr.length === 0) return false;
+  for (const e of arr) {
+    if (!e || typeof e !== "object") return false;
+    if (e._id == null) return false;
+  }
+  return true;
+}
+function sameIdSequence(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (String(a[i]._id) !== String(b[i]._id)) return false;
+  }
+  return true;
+}
+function computeArrayDiff(existingArr, updateArr, basePath, diff) {
+  if (existingArr.length === 0) {
+    if (updateArr.length > 0) diff[basePath] = updateArr;
+    return;
+  }
+  if (!allElementsHaveId(existingArr) || !allElementsHaveId(updateArr)) {
+    if (!deepEquals(existingArr, updateArr)) {
+      diff[basePath] = updateArr;
+    }
+    return;
+  }
+  if (!sameIdSequence(existingArr, updateArr)) {
+    diff[basePath] = updateArr;
+    return;
+  }
+  for (let i = 0; i < updateArr.length; i++) {
+    const elementId = String(updateArr[i]._id);
+    computeDiffInto(
+      existingArr[i],
+      updateArr[i],
+      `${basePath}[${elementId}]`,
+      diff
+    );
+  }
+}
+function computeDiffInto(existing, update, basePath, diff) {
+  if (deepEquals(existing, update)) return;
+  if (update === null || update === void 0 || typeof update !== "object" || update instanceof Date || isObjectIdLike(update)) {
+    diff[basePath] = update;
+    return;
+  }
+  if (existing === null || existing === void 0 || typeof existing !== "object" || existing instanceof Date || isObjectIdLike(existing)) {
+    diff[basePath] = update;
+    return;
+  }
+  if (Array.isArray(update) !== Array.isArray(existing)) {
+    diff[basePath] = update;
+    return;
+  }
+  if (Array.isArray(update)) {
+    computeArrayDiff(existing, update, basePath, diff);
+    return;
+  }
+  if (!isPlainObject(update) || !isPlainObject(existing)) {
+    diff[basePath] = update;
+    return;
+  }
+  for (const key of Object.keys(update)) {
+    const childPath = basePath ? `${basePath}.${key}` : key;
+    computeDiffInto(existing[key], update[key], childPath, diff);
+  }
+}
+var SERVER_MANAGED_METADATA_KEYS = /* @__PURE__ */ new Set(["_ts", "_rev", "_csq"]);
+function computeDiff(existing, update) {
+  const diff = {};
+  if (!update || typeof update !== "object") return diff;
+  if (existing === null || existing === void 0) {
+    const cleaned = {};
+    for (const k of Object.keys(update)) {
+      if (SERVER_MANAGED_METADATA_KEYS.has(k)) continue;
+      cleaned[k] = update[k];
+    }
+    return cleaned;
+  }
+  for (const key of Object.keys(update)) {
+    if (SERVER_MANAGED_METADATA_KEYS.has(key)) continue;
+    computeDiffInto(existing[key], update[key], key, diff);
+  }
+  return diff;
+}
+function isDescendantOrEqual(path, candidate) {
+  if (path === candidate) return true;
+  if (!path.startsWith(candidate)) return false;
+  const next = path[candidate.length];
+  return next === "." || next === "[";
+}
+function tokenizePath(path) {
+  const out = [];
+  let buf = "";
+  for (let i = 0; i < path.length; i++) {
+    const ch = path[i];
+    if (ch === ".") {
+      if (buf) {
+        out.push(buf);
+        buf = "";
+      }
+    } else if (ch === "[") {
+      if (buf) {
+        out.push(buf);
+        buf = "";
+      }
+      const close = path.indexOf("]", i);
+      if (close < 0) {
+        buf += ch;
+        continue;
+      }
+      out.push(path.substring(i, close + 1));
+      i = close;
+    } else {
+      buf += ch;
+    }
+  }
+  if (buf) out.push(buf);
+  return out;
+}
+function setByPath(target2, path, value) {
+  if (target2 === null || target2 === void 0) return false;
+  const parts = tokenizePath(path);
+  let current = target2;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const next = navigateSegment(current, part);
+    if (next === void 0) return false;
+    current = next;
+  }
+  const last = parts[parts.length - 1];
+  return setSegment(current, last, value);
+}
+function navigateSegment(current, part) {
+  if (current === null || current === void 0) return void 0;
+  if (part.startsWith("[") && part.endsWith("]")) {
+    const idStr = part.slice(1, -1);
+    if (!Array.isArray(current)) return void 0;
+    return current.find((item) => item && String(item._id) === idStr);
+  }
+  if (/^\d+$/.test(part) && Array.isArray(current)) {
+    return current[Number(part)];
+  }
+  if (typeof current === "object") {
+    return current[part];
+  }
+  return void 0;
+}
+function setSegment(current, part, value) {
+  if (current === null || current === void 0) return false;
+  if (part.startsWith("[") && part.endsWith("]")) {
+    const idStr = part.slice(1, -1);
+    if (!Array.isArray(current)) return false;
+    const idx = current.findIndex((item) => item && String(item._id) === idStr);
+    if (idx < 0) return false;
+    current[idx] = value;
+    return true;
+  }
+  if (/^\d+$/.test(part) && Array.isArray(current)) {
+    current[Number(part)] = value;
+    return true;
+  }
+  if (typeof current === "object") {
+    current[part] = value;
+    return true;
+  }
+  return false;
+}
+function mergeDirtyPath(accumulated, newPath, newValue) {
+  for (const existingKey of Object.keys(accumulated)) {
+    if (existingKey === newPath) continue;
+    if (isDescendantOrEqual(newPath, existingKey)) {
+      const relativePath = newPath.substring(existingKey.length + 1);
+      const ok = setByPath(accumulated[existingKey], relativePath, newValue);
+      if (ok) return;
+      break;
+    }
+  }
+  const toDelete = [];
+  for (const existingKey of Object.keys(accumulated)) {
+    if (existingKey === newPath) continue;
+    if (isDescendantOrEqual(existingKey, newPath)) {
+      toDelete.push(existingKey);
+    }
+  }
+  for (const k of toDelete) delete accumulated[k];
+  accumulated[newPath] = newValue;
+}
+function mergeDirtyChanges(accumulated, newChanges) {
+  for (const path of Object.keys(newChanges)) {
+    mergeDirtyPath(accumulated, path, newChanges[path]);
+  }
+}
+
 // src/db/managers/InMemManager.ts
 var InMemManager = class {
   constructor(config) {
@@ -1303,7 +1538,7 @@ var CustomTransformerRegistry = class {
 var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
 var isUndefined = (payload) => typeof payload === "undefined";
 var isNull = (payload) => payload === null;
-var isPlainObject = (payload) => {
+var isPlainObject2 = (payload) => {
   if (typeof payload !== "object" || payload === null)
     return false;
   if (payload === Object.prototype)
@@ -1312,7 +1547,7 @@ var isPlainObject = (payload) => {
     return true;
   return Object.getPrototypeOf(payload) === Object.prototype;
 };
-var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
+var isEmptyObject = (payload) => isPlainObject2(payload) && Object.keys(payload).length === 0;
 var isArray = (payload) => Array.isArray(payload);
 var isString = (payload) => typeof payload === "string";
 var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
@@ -1625,7 +1860,7 @@ var setDeep = (object, path, mapper) => {
     if (isArray(parent)) {
       const index = +key;
       parent = parent[index];
-    } else if (isPlainObject(parent)) {
+    } else if (isPlainObject2(parent)) {
       parent = parent[key];
     } else if (isSet(parent)) {
       const row = +key;
@@ -1651,7 +1886,7 @@ var setDeep = (object, path, mapper) => {
   const lastKey = path[path.length - 1];
   if (isArray(parent)) {
     parent[+lastKey] = mapper(parent[+lastKey]);
-  } else if (isPlainObject(parent)) {
+  } else if (isPlainObject2(parent)) {
     parent[lastKey] = mapper(parent[lastKey]);
   }
   if (isSet(parent)) {
@@ -1736,7 +1971,7 @@ function applyReferentialEqualityAnnotations(plain, annotations, version) {
   }
   return plain;
 }
-var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+var isDeep = (object, superJson) => isPlainObject2(object) || isArray(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
 function addIdentity(object, path, identities) {
   const existingSet = identities.get(object);
   if (existingSet) {
@@ -1814,7 +2049,7 @@ var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPat
     transformedValue[index] = recursiveResult.transformedValue;
     if (isArray(recursiveResult.annotations)) {
       innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
-    } else if (isPlainObject(recursiveResult.annotations)) {
+    } else if (isPlainObject2(recursiveResult.annotations)) {
       forEach(recursiveResult.annotations, (tree, key) => {
         innerAnnotations[escapeKey(index) + "." + key] = tree;
       });
@@ -1844,7 +2079,7 @@ function isArray2(payload) {
 }
 
 // node_modules/is-what/dist/isPlainObject.js
-function isPlainObject2(payload) {
+function isPlainObject3(payload) {
   if (getType2(payload) !== "Object")
     return false;
   const prototype = Object.getPrototypeOf(payload);
@@ -1869,7 +2104,7 @@ function copy(target2, options = {}) {
   if (isArray2(target2)) {
     return target2.map((item) => copy(item, options));
   }
-  if (!isPlainObject2(target2)) {
+  if (!isPlainObject3(target2)) {
     return target2;
   }
   const props = Object.getOwnPropertyNames(target2);
@@ -2366,9 +2601,10 @@ function resolveConflict(local, external) {
   }
   return mergeObjects(local, external);
 }
-function mergeObjects(local, external) {
+function mergeObjects(local, external, parentServerWins = false) {
   const result = __spreadValues({}, local);
-  const serverWinsOnConflict = typeof local._rev === "number" && typeof external._rev === "number" && external._rev > local._rev;
+  const ownServerWins = typeof local._rev === "number" && typeof external._rev === "number" && external._rev > local._rev;
+  const serverWinsOnConflict = parentServerWins || ownServerWins;
   for (const key of Object.keys(external)) {
     if (key === "_id" || key === "_dirty") {
       continue;
@@ -2383,16 +2619,16 @@ function mergeObjects(local, external) {
       continue;
     }
     if (Array.isArray(localValue) && Array.isArray(externalValue)) {
-      result[key] = mergeArrays(localValue, externalValue);
-    } else if (isPlainObject3(localValue) && isPlainObject3(externalValue)) {
-      result[key] = mergeObjects(localValue, externalValue);
+      result[key] = mergeArrays(localValue, externalValue, serverWinsOnConflict);
+    } else if (isPlainObject4(localValue) && isPlainObject4(externalValue)) {
+      result[key] = mergeObjects(localValue, externalValue, serverWinsOnConflict);
     } else if (serverWinsOnConflict) {
       result[key] = externalValue;
     }
   }
   return result;
 }
-function mergeArrays(local, external) {
+function mergeArrays(local, external, parentServerWins = false) {
   if (local.length === 0) {
     return external.slice();
   }
@@ -2403,14 +2639,56 @@ function mergeArrays(local, external) {
     for (const item of external) set2.add(item);
     return Array.from(set2);
   }
-  if (isPlainObject3(firstLocal) || isPlainObject3(firstExternal)) {
-    return mergeObjectArrays(local, external);
+  if (isPlainObject4(firstLocal) || isPlainObject4(firstExternal)) {
+    return mergeObjectArrays(local, external, parentServerWins);
   }
   const set = new Set(local);
   for (const item of external) set.add(item);
   return Array.from(set);
 }
-function mergeObjectArrays(local, external) {
+function mergeObjectArrays(local, external, parentServerWins = false) {
+  const objectItemsMissingId = [];
+  for (const item of local) {
+    if (item && typeof item === "object" && item._id == null) {
+      objectItemsMissingId.push(item);
+    }
+  }
+  for (const item of external) {
+    if (item && typeof item === "object" && item._id == null) {
+      objectItemsMissingId.push(item);
+    }
+  }
+  if (objectItemsMissingId.length > 0) {
+    for (const item of objectItemsMissingId) {
+      console.error(
+        "[mergeObjectArrays] array element without _id \u2014 falling back to whole-array replace by higher _rev:",
+        item
+      );
+    }
+    return parentServerWins ? external.slice() : local.slice();
+  }
+  if (parentServerWins) {
+    const result2 = [];
+    for (const extItem of external) {
+      if (!extItem || typeof extItem !== "object") {
+        result2.push(extItem);
+        continue;
+      }
+      if ("_id" in extItem) {
+        const localIndex = local.findIndex(
+          (l) => l && typeof l === "object" && "_id" in l && String(l._id) === String(extItem._id)
+        );
+        if (localIndex >= 0) {
+          result2.push(mergeObjects(local[localIndex], extItem, parentServerWins));
+        } else {
+          result2.push(extItem);
+        }
+      } else {
+        result2.push(extItem);
+      }
+    }
+    return result2;
+  }
   const result = local.slice();
   const localIds = /* @__PURE__ */ new Map();
   for (let i = 0; i < local.length; i++) {
@@ -2427,7 +2705,7 @@ function mergeObjectArrays(local, external) {
     if ("_id" in extItem) {
       const localIndex = localIds.get(String(extItem._id));
       if (localIndex !== void 0) {
-        result[localIndex] = mergeObjects(result[localIndex], extItem);
+        result[localIndex] = mergeObjects(result[localIndex], extItem, parentServerWins);
       } else {
         result.push(extItem);
       }
@@ -2437,10 +2715,77 @@ function mergeObjectArrays(local, external) {
   }
   return result;
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
 }
 
+// src/utils/fixDotnetArrays.ts
+function hasArrayIndexPath(key) {
+  return /\.\d+(\.|$)/.test(key);
+}
+function fixDotnetArrays(changes, serverRev, baseRev) {
+  if (typeof serverRev !== "number" || typeof baseRev !== "number") {
+    return changes;
+  }
+  if (serverRev <= baseRev) {
+    return changes;
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(changes)) {
+    if (hasArrayIndexPath(key)) continue;
+    cleaned[key] = value;
+  }
+  return cleaned;
+}
+
+// src/utils/translateBracketPaths.ts
+function translateBracketPathsToIndex(changes, entity) {
+  const result = {};
+  for (const [key, value] of Object.entries(changes)) {
+    const translated = translateKey(key, entity);
+    if (translated !== null) {
+      result[translated] = value;
+    }
+  }
+  return result;
+}
+function translateKey(key, entity) {
+  const parts = tokenizePath(key);
+  const out = [];
+  let cursor = entity;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part.startsWith("[") && part.endsWith("]")) {
+      const idStr = part.slice(1, -1);
+      if (!Array.isArray(cursor)) return null;
+      const idx = cursor.findIndex(
+        (item) => item && String(item._id) === idStr
+      );
+      if (idx < 0) return null;
+      out.push(String(idx));
+      cursor = cursor[idx];
+      continue;
+    }
+    out.push(part);
+    if (cursor === null || cursor === void 0) {
+      for (let j = i + 1; j < parts.length; j++) {
+        const p = parts[j];
+        if (p.startsWith("[") && p.endsWith("]")) return null;
+        out.push(p);
+      }
+      return out.join(".");
+    }
+    if (/^\d+$/.test(part) && Array.isArray(cursor)) {
+      cursor = cursor[Number(part)];
+    } else if (typeof cursor === "object") {
+      cursor = cursor[part];
+    } else {
+      cursor = void 0;
+    }
+  }
+  return out.join(".");
+}
+
 // src/db/sync/SyncEngine.ts
 var _SyncEngine = class _SyncEngine {
   constructor(config) {
@@ -2652,7 +2997,8 @@ var _SyncEngine = class _SyncEngine {
         if (fullItem) {
           const delta = dirtyChangesMap.get(String(fullItem._id));
           if (delta) {
-            updates.push({ _id: fullItem._id, delta });
+            const currentServerRev = typeof fullItem._rev === "number" ? fullItem._rev : void 0;
+            updates.push({ _id: fullItem._id, delta, currentServerRev, fullItem });
           }
         } else if (id != null) {
           const delta = dirtyChangesMap.get(String(id));
@@ -2673,10 +3019,21 @@ var _SyncEngine = class _SyncEngine {
         collection: collectionName,
         batch: {
           updates: updates.map((item) => {
-            const _a2 = item.delta, { _ts, _rev } = _a2, changes = __objRest(_a2, ["_ts", "_rev"]);
+            const _a2 = item.delta, { _ts, _rev: dirtyBaseRev } = _a2, changes = __objRest(_a2, ["_ts", "_rev"]);
+            const stripped = {};
+            for (const [k, v] of Object.entries(changes)) {
+              if (k.startsWith("_ts.") || k.startsWith("_rev.") || k.startsWith("_csq.")) continue;
+              stripped[k] = v;
+            }
+            const fixed = fixDotnetArrays(
+              stripped,
+              item.currentServerRev,
+              typeof dirtyBaseRev === "number" ? dirtyBaseRev : void 0
+            );
+            const cleanedChanges = translateBracketPathsToIndex(fixed, item.fullItem);
             return {
               _id: item._id,
-              update: changes
+              update: cleanedChanges
             };
           }),
           deletes: []
@@ -3549,7 +3906,7 @@ var _SyncedDb = class _SyncedDb {
     this.syncOnlyCollections = null;
     // Sync metadata cache
     this.syncMetaCache = /* @__PURE__ */ new Map();
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     this.tenant = config.tenant;
     this.dexieDb = config.dexieDb;
     this.inMemDb = config.inMemDb;
@@ -3576,13 +3933,15 @@ var _SyncedDb = class _SyncedDb {
     this.onEvictionStart = config.onEvictionStart;
     this.onEviction = config.onEviction;
     this.evictStaleRecordsEveryHrs = (_e = config.evictStaleRecordsEveryHrs) != null ? _e : 0;
+    this.scopeExitLookbehindMs = (_f = config.scopeExitLookbehindMs) != null ? _f : 0;
+    this.evictOnWake = (_g = config.evictOnWake) != null ? _g : false;
     for (const col of config.collections) {
       this.collections.set(col.name, col);
     }
     this.inMemManager = new InMemManager({
       inMemDb: this.inMemDb,
       collections: this.collections,
-      useObjectMetadata: (_f = config.useObjectMetadata) != null ? _f : false
+      useObjectMetadata: (_h = config.useObjectMetadata) != null ? _h : false
     });
     this.leaderElection = new LeaderElectionManager({
       tenant: this.tenant,
@@ -3617,7 +3976,7 @@ var _SyncedDb = class _SyncedDb {
       tenant: this.tenant,
       instanceId: this.syncedDbInstanceId,
       windowId,
-      debounceMs: (_g = config.crossTabSyncDebounceMs) != null ? _g : 100,
+      debounceMs: (_i = config.crossTabSyncDebounceMs) != null ? _i : 100,
       callbacks: {
         onCrossTabSync: config.onCrossTabSync,
         onInfrastructureError: config.onInfrastructureError ? (type, message, error) => {
@@ -3643,8 +4002,8 @@ var _SyncedDb = class _SyncedDb {
     });
     this.connectionManager = new ConnectionManager({
       restInterface: this.restInterface,
-      restTimeoutMs: (_h = config.restTimeoutMs) != null ? _h : 9e4,
-      syncTimeoutMs: (_i = config.syncTimeoutMs) != null ? _i : 12e4,
+      restTimeoutMs: (_j = config.restTimeoutMs) != null ? _j : 9e4,
+      syncTimeoutMs: (_k = config.syncTimeoutMs) != null ? _k : 12e4,
       autoSyncIntervalMs: config.autoSyncIntervalMs,
       onlineRetryIntervalMs: config.onlineRetryIntervalMs,
       callbacks: {
@@ -3671,8 +4030,8 @@ var _SyncedDb = class _SyncedDb {
     });
     this.pendingChanges = new PendingChangesManager({
       tenant: this.tenant,
-      debounceDexieWritesMs: (_j = config.debounceDexieWritesMs) != null ? _j : 500,
-      debounceRestWritesMs: (_k = config.debounceRestWritesMs) != null ? _k : 100,
+      debounceDexieWritesMs: (_l = config.debounceDexieWritesMs) != null ? _l : 500,
+      debounceRestWritesMs: (_m = config.debounceRestWritesMs) != null ? _m : 100,
       callbacks: {
         onDexieWriteRequest: config.onDexieWriteRequest,
         onDexieWriteResult: config.onDexieWriteResult,
@@ -3749,8 +4108,8 @@ var _SyncedDb = class _SyncedDb {
     });
     if (config.wakeSyncEnabled) {
       this.wakeSync = new WakeSyncManager({
-        gapThresholdMs: (_l = config.wakeSyncGapThresholdMs) != null ? _l : 1e4,
-        debounceMs: (_m = config.wakeSyncDebounceMs) != null ? _m : 2e3,
+        gapThresholdMs: (_n = config.wakeSyncGapThresholdMs) != null ? _n : 1e4,
+        debounceMs: (_o = config.wakeSyncDebounceMs) != null ? _o : 2e3,
         callbacks: {
           onWakeSync: config.onWakeSync
         },
@@ -3765,7 +4124,7 @@ var _SyncedDb = class _SyncedDb {
     }
     if (config.networkStatusEnabled) {
       this.networkStatus = new NetworkStatusManager({
-        debounceMs: (_n = config.networkStatusDebounceMs) != null ? _n : 100,
+        debounceMs: (_p = config.networkStatusDebounceMs) != null ? _p : 100,
         callbacks: {
           onBrowserNetworkChange: config.onBrowserNetworkChange,
           onBrowserOnline: config.onBrowserOnline,
@@ -4327,10 +4686,12 @@ var _SyncedDb = class _SyncedDb {
         `SyncedDb.save: Object ${String(id)} not found in ${collection}, creating new`
       );
     }
+    const fullChanges = __spreadProps(__spreadValues({}, update), { _lastUpdaterId: this.updaterId });
+    const diff = computeDiff(existing, fullChanges);
     await this.dexieDb.addDirtyChange(
       collection,
       id,
-      __spreadProps(__spreadValues({}, update), { _lastUpdaterId: this.updaterId }),
+      diff,
       { _ts: existing == null ? void 0 : existing._ts, _rev: existing == null ? void 0 : existing._rev }
     );
     const newData = __spreadProps(__spreadValues({}, update), {
@@ -4534,7 +4895,7 @@ var _SyncedDb = class _SyncedDb {
       this.crossTabSync.startServerSync();
       let evictionPlan;
       let evictionServerFailed = false;
-      if (await this._isAutoEvictionDue()) {
+      if (await this._isAutoEvictionDue(calledFrom)) {
         try {
           evictionPlan = await this._collectScopeExitPlan("auto");
         } catch (err) {
@@ -4850,11 +5211,12 @@ var _SyncedDb = class _SyncedDb {
     let serverEvictedCount = 0;
     if (serverAssisted && serverCandidateIds.length > 0) {
       let scopeExitTimestamp;
-      const lookbehindMs = opts == null ? void 0 : opts.outOfWindowLookbehindMs;
-      if (lookbehindMs != null && lookbehindMs > 0) {
+      const callerLookbehindMs = opts == null ? void 0 : opts.outOfWindowLookbehindMs;
+      const effectiveLookbehindMs = callerLookbehindMs != null && callerLookbehindMs > 0 ? callerLookbehindMs : this.scopeExitLookbehindMs;
+      if (effectiveLookbehindMs > 0) {
         scopeExitTimestamp = Math.max(
           0,
-          Math.floor((Date.now() - lookbehindMs) / 1e3)
+          Math.floor((Date.now() - effectiveLookbehindMs) / 1e3)
         );
       } else {
         scopeExitTimestamp = (_d = (_c = this.syncMetaCache.get(collection)) == null ? void 0 : _c.lastSyncTs) != null ? _d : 0;
@@ -5010,7 +5372,7 @@ var _SyncedDb = class _SyncedDb {
    * callback is a reliable lifecycle marker.
    */
   async _collectScopeExitPlan(trigger) {
-    var _a, _b, _c;
+    var _a;
     const startTime = Date.now();
     const eligible = [];
     for (const [name, config] of this.collections) {
@@ -5060,7 +5422,7 @@ var _SyncedDb = class _SyncedDb {
         collection: name,
         config,
         query,
-        timestamp: (_c = (_b = this.syncMetaCache.get(name)) == null ? void 0 : _b.lastSyncTs) != null ? _c : 0,
+        timestamp: this._scopeExitTimestamp(name),
         evictIds,
         localEvictedCount: evictIds.length,
         serverEvictedCount: 0,
@@ -5168,14 +5530,44 @@ var _SyncedDb = class _SyncedDb {
     this.safeCallback(this.onEviction, info);
     return info;
   }
+  /**
+   * Compute the `timestamp` value used in server-assisted scope-exit
+   * `findNewerMany` specs for a given collection. Honors the global
+   * `scopeExitLookbehindMs` config: when > 0, the scope-exit query
+   * uses `_ts > now - lookbehindMs`; otherwise falls back to the
+   * collection's lastSyncTs cursor (legacy behavior).
+   *
+   * Per-call override (`evictOutOfScopeRecords({outOfWindowLookbehindMs})`)
+   * is computed at the call site — this helper covers the auto-eviction
+   * path and `evictOutOfScopeRecordsAll`.
+   */
+  _scopeExitTimestamp(collection) {
+    var _a, _b;
+    if (this.scopeExitLookbehindMs > 0) {
+      return Math.max(
+        0,
+        Math.floor((Date.now() - this.scopeExitLookbehindMs) / 1e3)
+      );
+    }
+    return (_b = (_a = this.syncMetaCache.get(collection)) == null ? void 0 : _a.lastSyncTs) != null ? _b : 0;
+  }
   /**
    * Whether auto-eviction is due to run on the next sync. Mirrors the
    * gating logic of the old `maybeAutoEvict` (interval check + persisted
    * `__lastEviction` cursor) but split out so `sync()` can pre-compute
    * the eviction plan BEFORE issuing the streamed `findNewerMany` —
    * letting scope-exit specs ride along on the same call.
+   *
+   * `calledFrom` is honored when `evictOnWake` is true: any sync whose
+   * `calledFrom` starts with `'wake-sync:'` forces eviction regardless
+   * of the `evictStaleRecordsEveryHrs` interval gate. This ensures
+   * cross-device scope-exit records become visible on the very next
+   * wake instead of waiting up to the configured interval.
    */
-  async _isAutoEvictionDue() {
+  async _isAutoEvictionDue(calledFrom) {
+    if (this.evictOnWake && (calledFrom == null ? void 0 : calledFrom.startsWith("wake-sync:"))) {
+      return true;
+    }
     if (this.evictStaleRecordsEveryHrs <= 0) return false;
     const intervalMs = this.evictStaleRecordsEveryHrs * 36e5;
     if (!this._lastEvictionDate) {
@@ -5656,7 +6048,7 @@ var DexieDb = class extends Dexie {
     const existing = await this.dirtyChanges.get([collection, stringId]);
     const now = Date.now();
     if (existing) {
-      Object.assign(existing.changes, changes);
+      mergeDirtyChanges(existing.changes, changes);
       existing.updatedAt = now;
       await this.dirtyChanges.put(existing);
     } else {
@@ -5684,7 +6076,7 @@ var DexieDb = class extends Dexie {
       const stringId = this.idToString(changeItem.id);
       const existing = existingEntries[i];
       if (existing) {
-        Object.assign(existing.changes, changeItem.changes);
+        mergeDirtyChanges(existing.changes, changeItem.changes);
         existing.updatedAt = now;
         toWrite.push(existing);
       } else {

package/dist/src/db/SyncedDb.d.ts

@@ -53,6 +53,8 @@ export declare class SyncedDb implements I_SyncedDb {
     private readonly onEvictionStart?;
     private readonly onEviction?;
     private readonly evictStaleRecordsEveryHrs;
+    private readonly scopeExitLookbehindMs;
+    private readonly evictOnWake;
     private _lastEvictionDate?;
     constructor(config: SyncedDbConfig);
     getInstanceId(): string;
@@ -295,12 +297,30 @@ export declare class SyncedDb implements I_SyncedDb {
      * info and still fires the callback so consumers see a lifecycle event.
      */
     private _applyScopeExitPlan;
+    /**
+     * Compute the `timestamp` value used in server-assisted scope-exit
+     * `findNewerMany` specs for a given collection. Honors the global
+     * `scopeExitLookbehindMs` config: when > 0, the scope-exit query
+     * uses `_ts > now - lookbehindMs`; otherwise falls back to the
+     * collection's lastSyncTs cursor (legacy behavior).
+     *
+     * Per-call override (`evictOutOfScopeRecords({outOfWindowLookbehindMs})`)
+     * is computed at the call site — this helper covers the auto-eviction
+     * path and `evictOutOfScopeRecordsAll`.
+     */
+    private _scopeExitTimestamp;
     /**
      * Whether auto-eviction is due to run on the next sync. Mirrors the
      * gating logic of the old `maybeAutoEvict` (interval check + persisted
      * `__lastEviction` cursor) but split out so `sync()` can pre-compute
      * the eviction plan BEFORE issuing the streamed `findNewerMany` —
      * letting scope-exit specs ride along on the same call.
+     *
+     * `calledFrom` is honored when `evictOnWake` is true: any sync whose
+     * `calledFrom` starts with `'wake-sync:'` forces eviction regardless
+     * of the `evictStaleRecordsEveryHrs` interval gate. This ensures
+     * cross-device scope-exit records become visible on the very next
+     * wake instead of waiting up to the configured interval.
      */
     private _isAutoEvictionDue;
     /**

package/dist/src/types/I_SyncedDb.d.ts

@@ -550,6 +550,39 @@ export interface SyncedDbConfig {
      * Default: 0 (disabled).
      */
     evictStaleRecordsEveryHrs?: number;
+    /**
+     * Default lookbehind window (ms) for server-assisted scope-exit detection
+     * in auto-eviction (`sync()` bundled) and `evictOutOfScopeRecordsAll`.
+     * When set (> 0), the scope-exit query uses `_ts > now - lookbehindMs`
+     * instead of `_ts > lastSyncTs`. This catches records whose server-side
+     * `_ts` predates `lastSyncTs` but still fail `$nor [positiveQuery]`
+     * server-side (typical cross-device close-out scenario where the local
+     * client was offline at the moment of mutation and findNewer's positive
+     * query never re-shipped the post-mutation row).
+     *
+     * Per-call override remains via `evictOutOfScopeRecords({outOfWindowLookbehindMs})`.
+     *
+     * Default: 0 (= use lastSyncTs cursor — current behavior).
+     * Recommended for multi-device deployments: 3 * 24 * 3600 * 1000 (3 days).
+     */
+    scopeExitLookbehindMs?: number;
+    /**
+     * Force scope-exit eviction on every wake event (`calledFrom` starts
+     * with `'wake-sync:'`), bypassing the `evictStaleRecordsEveryHrs`
+     * interval gate. Eviction is bundled into the wake sync's
+     * `findNewerManyStream` call (single RTT, same as positive sync).
+     *
+     * Combine with `scopeExitLookbehindMs` so the scope-exit query covers
+     * records mutated within the lookbehind window — guarantees that
+     * cross-device close-outs become visible to the local cache on the
+     * very next wake instead of waiting up to `evictStaleRecordsEveryHrs`.
+     *
+     * `evictStaleRecordsEveryHrs` still gates non-wake syncs (interval
+     * sync, manual `sync()` triggers without `'wake-sync:*'` prefix).
+     *
+     * Default: false.
+     */
+    evictOnWake?: boolean;
     /**
      * Callback fired before each eviction run begins, after the eligible
      * collection list has been resolved. Useful as a debug breadcrumb to

package/dist/src/utils/computeDiff.d.ts

@@ -0,0 +1,68 @@
+/**
+ * computeDiff — produces minimal MongoDB-style dot-notation paths
+ * representing the actual differences between `existing` and `update`.
+ *
+ * PURPOSE: Solves the "stale array upload" bug where a save() call
+ * with a full nested array captures unchanged fields into the dirty
+ * change. When the device later uploads, those unchanged fields
+ * overwrite concurrent edits made by other devices.
+ *
+ * INVARIANT: applyDiff(existing, computeDiff(existing, update)) deep-equals
+ * the merged result of `existing` ⊔ `update` (where update wins on conflicts,
+ * and missing keys in update preserve existing values).
+ *
+ * STRATEGY:
+ * - Primitives, Date, ObjectId: emit single path if value differs
+ * - Plain objects: recurse, accumulating paths
+ * - Arrays of objects with _id (same composition + order): element-wise diff
+ * - Arrays with composition or order changes: full replace at array path
+ * - Arrays of primitives or mixed types: full replace
+ *
+ * MongoDB native supports dot-notation in $set, so output paths can be
+ * passed directly to the server without protocol changes.
+ */
+/** Deep equality for values that may include Date, ObjectId, plain objects, arrays. */
+export declare function deepEquals(a: any, b: any): boolean;
+export declare function computeDiff(existing: Record<string, any> | null | undefined, update: Record<string, any>): Record<string, any>;
+/**
+ * Detect whether a `changes` object uses dot-notation paths (new format)
+ * or top-level keys with full nested values (legacy format).
+ *
+ * Used to decide whether smart path-based merging applies, or fall back
+ * to legacy Object.assign accumulation.
+ */
+export declare function hasDotNotationPaths(changes: Record<string, any>): boolean;
+/**
+ * Tokenize a dot-notation path that may contain bracket-id segments.
+ *
+ * "postavke[A].kolicina"   → ["postavke", "[A]", "kolicina"]
+ * "koraki.0.diag"          → ["koraki", "0", "diag"]
+ * "stranka.gsm"            → ["stranka", "gsm"]
+ * "arr[A].sub[B].field"    → ["arr", "[A]", "sub", "[B]", "field"]
+ */
+export declare function tokenizePath(path: string): string[];
+/**
+ * Smart-merge a single (path, value) entry into an accumulated dirty changes
+ * object. Resolves three relationships between the new path and existing keys:
+ *
+ * 1. New path is a DESCENDANT of an existing key (e.g. existing has "koraki",
+ *    new is "koraki.0.diag"): mutate the value inside the existing parent
+ *    rather than adding a conflicting child path.
+ *
+ * 2. New path is an ANCESTOR of existing keys (e.g. existing has "koraki.0.diag",
+ *    new is "koraki" with full array): remove the now-redundant descendants and
+ *    set the parent path. The new full value supersedes any field-level deltas.
+ *
+ * 3. New path is ORTHOGONAL to existing keys: simple set (Object.assign-equivalent).
+ *
+ * Used by DexieDb.addDirtyChange to accumulate changes across multiple save()
+ * calls without producing MongoDB-conflicting payloads (parent + child paths
+ * in same $set yields nondeterministic results).
+ */
+export declare function mergeDirtyPath(accumulated: Record<string, any>, newPath: string, newValue: any): void;
+/**
+ * Bulk-merge an entire changes object into the accumulator using path semantics.
+ * Order matters: paths are processed sequentially, so later entries can supersede
+ * earlier ones. This is acceptable because mergeDirtyPath is idempotent.
+ */
+export declare function mergeDirtyChanges(accumulated: Record<string, any>, newChanges: Record<string, any>): void;

package/dist/src/utils/fixDotnetArrays.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Detects whether a dirty change key contains an array index segment,
+ * e.g. `postavke.0.a`, `koraki.5.diag`, `arr.10`. Returns `true` if the
+ * key has any segment matching `^\d+$` between dots (or trailing).
+ *
+ * Examples:
+ *   "stranka.gsm"          → false (nested object navigation)
+ *   "postavke.0.a"         → true  (array index 0)
+ *   "koraki.5.diag.text"   → true  (array index 5)
+ *   "koraki.5"             → true  (whole element at index 5)
+ *   "koraki"               → false (top-level, full array)
+ *   "_ts.t"                → false (no digit segment)
+ *   "arr.10"               → true  (multi-digit index)
+ */
+export declare function hasArrayIndexPath(key: string): boolean;
+/**
+ * TEMPORARY mitigation: when server has advanced past client's base _rev
+ * (i.e., the dirty was emitted against a stale snapshot of the record),
+ * drop dirty keys that contain array-index dot-notation. Their position
+ * may no longer correspond to the element the client intended to modify.
+ *
+ * @param changes - dirty payload to be uploaded (top-level _ts/_rev already stripped)
+ * @param serverRev - current server _rev for this record (from local Dexie main
+ *                    AFTER the download phase brought it up to date)
+ * @param baseRev - dirty entry's `baseRev` (the _rev when client emitted the diff)
+ * @returns cleaned `changes` with array-index paths dropped if `serverRev > baseRev`,
+ *          otherwise the input unchanged.
+ */
+export declare function fixDotnetArrays(changes: Record<string, any>, serverRev: number | undefined, baseRev: number | undefined): Record<string, any>;

package/dist/src/utils/translateBracketPaths.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Translate every key in `changes` from bracket notation to mongo dot
+ * notation, resolving `[<_id>]` against the corresponding sub-array of
+ * `entity`. Drops keys whose `_id` cannot be resolved (= element was
+ * removed by another writer).
+ */
+export declare function translateBracketPathsToIndex(changes: Record<string, any>, entity: any): Record<string, any>;

package/package.json

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