cry-synced-db-client 0.1.190 → 0.1.193

package/dist/index.js

@@ -288,80 +288,107 @@ function applyQueryOpts(items, opts) {
   return result;
 }
 
-// src/utils/computeDiff.ts
+// node_modules/cry-db/dist/utils.mjs
 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;
+  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 === 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 (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;
+    if (a.length !== b.length)
+      return false;
     for (let i = 0; i < a.length; i++) {
-      if (!deepEquals(a[i], b[i])) return false;
+      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;
+  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;
+    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;
+  if (arr.length === 0)
+    return false;
   for (const e of arr) {
-    if (!e || typeof e !== "object") return false;
-    if (e._id == null) return false;
+    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;
+  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;
+    if (String(a[i]._id) !== String(b[i]._id))
+      return false;
   }
   return true;
 }
 function containsIdArrayDescendant(value) {
-  if (value === null || typeof value !== "object") return false;
-  if (value instanceof Date || isObjectIdLike(value)) return false;
+  if (value === null || typeof value !== "object")
+    return false;
+  if (value instanceof Date || isObjectIdLike(value))
+    return false;
   if (Array.isArray(value)) {
-    if (value.length > 0 && allElementsHaveId(value)) return true;
+    if (value.length > 0 && allElementsHaveId(value))
+      return true;
     for (const v of value) {
-      if (containsIdArrayDescendant(v)) return true;
+      if (containsIdArrayDescendant(v))
+        return true;
     }
     return false;
   }
-  if (!isPlainObject(value)) return false;
+  if (!isPlainObject(value))
+    return false;
   for (const key of Object.keys(value)) {
-    if (containsIdArrayDescendant(value[key])) return true;
+    if (containsIdArrayDescendant(value[key]))
+      return true;
   }
   return false;
 }
 function computeArrayDiff(existingArr, updateArr, basePath, diff) {
-  if (existingArr.length === 0 && updateArr.length === 0) return;
+  if (existingArr.length === 0 && updateArr.length === 0)
+    return;
   if (!allElementsHaveId(updateArr) || existingArr.length > 0 && !allElementsHaveId(existingArr)) {
     if (!deepEquals(existingArr, updateArr)) {
       diff[basePath] = updateArr;
@@ -369,9 +396,11 @@ function computeArrayDiff(existingArr, updateArr, basePath, diff) {
     return;
   }
   const existingIds = /* @__PURE__ */ new Set();
-  for (const e of existingArr) existingIds.add(String(e._id));
+  for (const e of existingArr)
+    existingIds.add(String(e._id));
   const updateIds = /* @__PURE__ */ new Set();
-  for (const u of updateArr) updateIds.add(String(u._id));
+  for (const u of updateArr)
+    updateIds.add(String(u._id));
   let sameSet = existingIds.size === updateIds.size;
   if (sameSet) {
     for (const id of existingIds) {
@@ -412,7 +441,8 @@ function computeArrayDiff(existingArr, updateArr, basePath, diff) {
   }
   if (existingArr.length > 0) {
     const existingById = /* @__PURE__ */ new Map();
-    for (const e of existingArr) existingById.set(String(e._id), e);
+    for (const e of existingArr)
+      existingById.set(String(e._id), e);
     for (const updateEl of updateArr) {
       const id = String(updateEl._id);
       if (existingIds.has(id)) {
@@ -422,19 +452,15 @@ function computeArrayDiff(existingArr, updateArr, basePath, diff) {
             diff[elementPath] = updateEl;
           }
         } else {
-          computeDiffInto(
-            existingById.get(id),
-            updateEl,
-            elementPath,
-            diff
-          );
+          computeDiffInto(existingById.get(id), updateEl, elementPath, diff);
         }
       }
     }
   }
 }
 function computeDiffInto(existing, update, basePath, diff) {
-  if (deepEquals(existing, update)) return;
+  if (deepEquals(existing, update))
+    return;
   if (update === null || update === void 0 || typeof update !== "object" || update instanceof Date || isObjectIdLike(update)) {
     diff[basePath] = update;
     return;
@@ -465,32 +491,26 @@ function computeDiffInto(existing, update, basePath, diff) {
   }
 }
 var SERVER_MANAGED_METADATA_KEYS = /* @__PURE__ */ new Set(["_ts", "_rev", "_csq"]);
-function computeDiff(existing, update) {
+function computeObjDiff(existing, update) {
   const diff = {};
-  if (!update || typeof update !== "object") return 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;
+      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;
+    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 pathsOverlap(a, b) {
-  return isDescendantOrEqual(a, b) || isDescendantOrEqual(b, a);
-}
 function tokenizePath(path) {
   const out = [];
   let buf = "";
@@ -517,60 +537,27 @@ function tokenizePath(path) {
       buf += ch;
     }
   }
-  if (buf) out.push(buf);
+  if (buf)
+    out.push(buf);
   return out;
 }
-function setByPath(target2, path, value, opts) {
-  if (target2 === null || target2 === void 0) return false;
-  const autoCreate = (opts == null ? void 0 : opts.autoCreate) !== false;
-  const parts = tokenizePath(path);
-  const pathHasArrayShape = parts.some(
-    (p) => p.startsWith("[") && p.endsWith("]") || /^\d+$/.test(p)
-  );
-  const canAutoCreate = autoCreate && !pathHasArrayShape;
-  let current = target2;
-  const created = [];
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    let next = navigateSegment(current, part);
-    const isMissing = next === void 0 || next === null;
-    if (isMissing && canAutoCreate) {
-      if (isPlainObjectContainer(current)) {
-        current[part] = {};
-        created.push({ container: current, key: part });
-        next = current[part];
-      } else {
-        return false;
-      }
-    } else if (isMissing) {
-      return false;
-    } else if (autoCreate && !pathHasArrayShape && !isPlainObjectContainer(next) && !Array.isArray(next)) {
-      return false;
-    }
-    current = next;
-  }
-  const last = parts[parts.length - 1];
-  const ok = setSegment(current, last, value);
-  if (!ok && created.length > 0) {
-    for (let i = created.length - 1; i >= 0; i--) {
-      const { container, key } = created[i];
-      delete container[key];
-    }
-  }
-  return ok;
-}
 function isPlainObjectContainer(value) {
-  if (value === null || value === void 0) return false;
-  if (typeof value !== "object") return false;
-  if (Array.isArray(value)) return false;
+  if (value === null || value === void 0)
+    return false;
+  if (typeof value !== "object")
+    return false;
+  if (Array.isArray(value))
+    return false;
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
 function navigateSegment(current, part) {
-  if (current === null || current === void 0) return void 0;
+  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;
+    if (!Array.isArray(current))
+      return void 0;
     return current.find((item) => item && String(item._id) === idStr);
   }
   if (/^\d+$/.test(part) && Array.isArray(current)) {
@@ -582,17 +569,22 @@ function navigateSegment(current, part) {
   return void 0;
 }
 function setSegment(current, part, value) {
-  if (current === null || current === void 0) return false;
+  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;
+    if (!Array.isArray(current))
+      return false;
     const idx = current.findIndex((item) => item && String(item._id) === idStr);
     if (Array.isArray(value) && value.length === 1 && value[0] && typeof value[0] === "object" && String(value[0]._id) === idStr) {
-      if (idx >= 0) current[idx] = value[0];
-      else current.push(value[0]);
+      if (idx >= 0)
+        current[idx] = value[0];
+      else
+        current.push(value[0]);
       return true;
     }
-    if (idx < 0) return false;
+    if (idx < 0)
+      return false;
     current[idx] = value;
     return true;
   }
@@ -606,127 +598,243 @@ function setSegment(current, part, value) {
   }
   return false;
 }
-function deleteByPath(target2, path) {
-  if (target2 === null || target2 === void 0) return false;
+function setByPath(target2, path, value, opts) {
+  if (target2 === null || target2 === void 0)
+    return false;
+  const autoCreate = (opts === null || opts === void 0 ? void 0 : opts.autoCreate) !== false;
   const parts = tokenizePath(path);
-  if (parts.length === 0) return false;
+  const pathHasArrayShape = parts.some((p) => p.startsWith("[") && p.endsWith("]") || /^\d+$/.test(p));
+  const canAutoCreate = autoCreate && !pathHasArrayShape;
   let current = target2;
+  const created = [];
   for (let i = 0; i < parts.length - 1; i++) {
-    const next = navigateSegment(current, parts[i]);
-    if (next === void 0 || next === null) return false;
+    const part = parts[i];
+    let next = navigateSegment(current, part);
+    const isMissing = next === void 0 || next === null;
+    if (isMissing && canAutoCreate) {
+      if (isPlainObjectContainer(current)) {
+        current[part] = {};
+        created.push({ container: current, key: part });
+        next = current[part];
+      } else {
+        return false;
+      }
+    } else if (isMissing) {
+      return false;
+    } else if (autoCreate && !pathHasArrayShape && !isPlainObjectContainer(next) && !Array.isArray(next)) {
+      return false;
+    }
     current = next;
   }
   const last = parts[parts.length - 1];
-  return deleteSegment(current, last);
+  const ok = setSegment(current, last, value);
+  if (!ok && created.length > 0) {
+    for (let i = created.length - 1; i >= 0; i--) {
+      const { container, key } = created[i];
+      delete container[key];
+    }
+  }
+  return ok;
 }
 function deleteSegment(current, part) {
-  if (current === null || current === void 0) return false;
+  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;
+    if (!Array.isArray(current))
+      return false;
     const idx = current.findIndex((item) => item && String(item._id) === idStr);
-    if (idx < 0) return false;
+    if (idx < 0)
+      return false;
     current.splice(idx, 1);
     return true;
   }
   if (/^\d+$/.test(part) && Array.isArray(current)) {
     const idx = Number(part);
-    if (idx < 0 || idx >= current.length) return false;
+    if (idx < 0 || idx >= current.length)
+      return false;
     current.splice(idx, 1);
     return true;
   }
   if (typeof current === "object") {
-    if (!Object.prototype.hasOwnProperty.call(current, part)) return false;
+    if (!Object.prototype.hasOwnProperty.call(current, part))
+      return false;
     delete current[part];
     return true;
   }
   return false;
 }
-function isTerminalBracketKey(path) {
-  const tokens = tokenizePath(path);
-  const last = tokens[tokens.length - 1];
-  return !!(last && last.length >= 2 && last.charCodeAt(0) === 91 && last.charCodeAt(last.length - 1) === 93);
-}
-function canExpandArrayToBrackets(value) {
-  if (!Array.isArray(value) || value.length === 0) return false;
-  for (const el of value) {
-    if (el === null || typeof el !== "object") return false;
-    if (el._id == null) return false;
+function deleteByPath(target2, path) {
+  if (target2 === null || target2 === void 0)
+    return false;
+  const parts = tokenizePath(path);
+  if (parts.length === 0)
+    return false;
+  let current = target2;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const next = navigateSegment(current, parts[i]);
+    if (next === void 0 || next === null)
+      return false;
+    current = next;
   }
-  return true;
+  const last = parts[parts.length - 1];
+  return deleteSegment(current, last);
 }
-function pickLayerTarget(newPath, newValue) {
-  if (!isTerminalBracketKey(newPath)) return null;
-  if (newValue === void 0) return null;
-  if (Array.isArray(newValue) && newValue.length === 1 && newValue[0] && typeof newValue[0] === "object") {
-    return newValue[0];
+function safeDeepClone(value) {
+  if (value === null || value === void 0)
+    return value;
+  if (typeof value !== "object")
+    return value;
+  if (value instanceof Date)
+    return new Date(value.getTime());
+  if (isObjectIdLike(value))
+    return value;
+  if (Array.isArray(value)) {
+    const out2 = new Array(value.length);
+    for (let i = 0; i < value.length; i++)
+      out2[i] = safeDeepClone(value[i]);
+    return out2;
   }
-  if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
-    return newValue;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    return value;
+  const out = {};
+  for (const key of Object.keys(value)) {
+    out[key] = safeDeepClone(value[key]);
   }
-  return null;
+  return out;
 }
-function mergeDirtyPath(accumulated, newPath, newValue) {
-  for (const existingKey of Object.keys(accumulated)) {
-    if (existingKey === newPath) continue;
-    if (isDescendantOrEqual(newPath, existingKey)) {
-      const existingValue = accumulated[existingKey];
-      const existingIsTerminal = isTerminalBracketKey(existingKey);
-      if (existingIsTerminal && existingValue === void 0) {
-        return;
-      }
-      let mutationTarget = existingValue;
-      if (existingIsTerminal && Array.isArray(existingValue) && existingValue.length === 1) {
-        mutationTarget = existingValue[0];
-      }
-      if (!existingIsTerminal && (existingValue === null || existingValue === void 0)) {
-        accumulated[existingKey] = {};
-        mutationTarget = accumulated[existingKey];
-      }
-      if (!existingIsTerminal && newPath[existingKey.length] === "[" && canExpandArrayToBrackets(existingValue)) {
-        delete accumulated[existingKey];
-        for (const el of existingValue) {
-          accumulated[`${existingKey}[${String(el._id)}]`] = [el];
-        }
-        mergeDirtyPath(accumulated, newPath, newValue);
-        return;
-      }
-      const sepChar = newPath[existingKey.length];
-      const relativePath = sepChar === "[" ? newPath.substring(existingKey.length) : newPath.substring(existingKey.length + 1);
-      const ok = setByPath(mutationTarget, relativePath, newValue);
-      if (ok) return;
-      delete accumulated[existingKey];
-      accumulated[newPath] = newValue;
+function materializeBracketPath(seed, path, value, collection, id) {
+  const tokens = tokenizePath(path);
+  const firstToken = tokens[0];
+  const dropSilently = typeof firstToken === "string" && firstToken.startsWith("_");
+  const drop = (reason) => {
+    if (dropSilently)
       return;
+    console.error(`[cry-db] applyObjDiff: dropping bracket-path diff entry (${reason})`, { collection, _id: String(id), path, value });
+  };
+  if (tokens.length < 2) {
+    drop(`unsupported token count ${tokens.length}`);
+    return;
+  }
+  if (firstToken === void 0 || firstToken.startsWith("[")) {
+    drop("first segment is not a plain field");
+    return;
+  }
+  let bracketIdx = -1;
+  for (let i = 1; i < tokens.length; i++) {
+    if (tokens[i].startsWith("[")) {
+      bracketIdx = i;
+      break;
     }
   }
-  const descendants = [];
-  for (const existingKey of Object.keys(accumulated)) {
-    if (existingKey === newPath) continue;
-    if (isDescendantOrEqual(existingKey, newPath)) {
-      descendants.push(existingKey);
+  if (bracketIdx < 0) {
+    drop("no bracket segment found");
+    return;
+  }
+  for (let i = bracketIdx + 1; i < tokens.length; i++) {
+    if (tokens[i].startsWith("[")) {
+      drop("nested bracket path");
+      return;
     }
   }
-  const layerInto = pickLayerTarget(newPath, newValue);
-  if (layerInto && descendants.length > 0) {
-    for (const desc of descendants) {
-      const sepChar = desc[newPath.length];
-      const relativePath = sepChar === "[" ? desc.substring(newPath.length) : desc.substring(newPath.length + 1);
-      const descValue = accumulated[desc];
-      if (descValue === void 0) {
-        deleteByPath(layerInto, relativePath);
-      } else {
-        setByPath(layerInto, relativePath, descValue);
-      }
+  if (dropSilently && bracketIdx > 1) {
+    return;
+  }
+  const prefixTokens = tokens.slice(0, bracketIdx);
+  const bracketToken = tokens[bracketIdx];
+  const suffixTokens = tokens.slice(bracketIdx + 1);
+  const bracketId = bracketToken.slice(1, -1);
+  if (bracketId.length === 0) {
+    drop("empty bracket id");
+    return;
+  }
+  let parent = seed;
+  for (let i = 0; i < prefixTokens.length - 1; i++) {
+    const seg = prefixTokens[i];
+    const cur = parent[seg];
+    if (cur === void 0 || cur === null) {
+      parent[seg] = {};
+    } else if (typeof cur !== "object" || Array.isArray(cur) || cur instanceof Date) {
+      drop(`existing intermediate "${prefixTokens.slice(0, i + 1).join(".")}" is not a plain object`);
+      return;
     }
+    parent = parent[seg];
+  }
+  const lastPrefixSeg = prefixTokens[prefixTokens.length - 1];
+  let arr = parent[lastPrefixSeg];
+  if (arr != null && !Array.isArray(arr)) {
+    drop(`existing "${prefixTokens.join(".")}" is not an array`);
+    return;
+  }
+  if (arr == null) {
+    arr = [];
+    parent[lastPrefixSeg] = arr;
+  }
+  if (suffixTokens.length === 0) {
+    let element = value;
+    if (Array.isArray(value) && value.length === 1 && value[0] != null && typeof value[0] === "object") {
+      element = value[0];
+    }
+    if (element == null || typeof element !== "object" || Array.isArray(element)) {
+      drop("value is not a single element or wire-form wrapper");
+      return;
+    }
+    if (element._id == null) {
+      element._id = bracketId;
+    }
+    const replaceIdx = arr.findIndex((it) => it != null && typeof it === "object" && String(it._id) === bracketId);
+    if (replaceIdx >= 0) {
+      arr[replaceIdx] = element;
+    } else {
+      arr.push(element);
+    }
+    return;
+  }
+  const buildNestedSubTree = (segs, leaf) => {
+    let acc = leaf;
+    for (let i = segs.length - 1; i >= 0; i--) {
+      acc = { [segs[i]]: acc };
+    }
+    return acc;
+  };
+  const existingIdx = arr.findIndex((it) => it != null && typeof it === "object" && String(it._id) === bracketId);
+  if (existingIdx >= 0) {
+    let cur = arr[existingIdx];
+    for (let i = 0; i < suffixTokens.length - 1; i++) {
+      const seg = suffixTokens[i];
+      const next = cur[seg];
+      if (next == null || typeof next !== "object" || Array.isArray(next)) {
+        cur[seg] = {};
+      }
+      cur = cur[seg];
+    }
+    cur[suffixTokens[suffixTokens.length - 1]] = value;
+  } else {
+    const subTree = buildNestedSubTree(suffixTokens, value);
+    arr.push(__spreadValues({ _id: bracketId }, subTree));
   }
-  for (const k of descendants) delete accumulated[k];
-  accumulated[newPath] = newValue;
 }
-function mergeDirtyChanges(accumulated, newChanges) {
-  for (const path of Object.keys(newChanges)) {
-    mergeDirtyPath(accumulated, path, newChanges[path]);
+function applyObjDiff(base, diff, fallbackId, collection) {
+  const seed = base ? safeDeepClone(base) : { _id: fallbackId };
+  if (seed._id == null)
+    seed._id = fallbackId;
+  for (const path of Object.keys(diff)) {
+    const value = diff[path];
+    if (value === void 0) {
+      deleteByPath(seed, path);
+      continue;
+    }
+    if (!path.includes(".") && !path.includes("[")) {
+      seed[path] = value;
+      continue;
+    }
+    const ok = setByPath(seed, path, value);
+    if (ok)
+      continue;
+    materializeBracketPath(seed, path, value, collection, fallbackId);
   }
+  return seed;
 }
 
 // src/utils/normalizeUndefined.ts
@@ -3303,6 +3411,99 @@ var _SyncEngine = class _SyncEngine {
       throw err;
     }
   }
+  /**
+   * Adopt cry-db `mustRefresh` records (≥ 2.5.0) into Dexie + in-mem.
+   *
+   * The server returns the full, sanitized post-write record when it resolved a
+   * placeholder (`SEQ_*`/`__hashed__*`) or a concurrent write advanced `_rev`
+   * past the client's base. Per the cry-db contract we REPLACE the local record
+   * with it, THEN re-apply any still-unsynced local edits to OTHER fields on top
+   * ("apply mustRefresh before the merge so they're reconciled, not clobbered").
+   *
+   * "Other fields" = dirty paths NOT in the just-uploaded snapshot (authored
+   * during the round-trip). Uploaded paths — including a resolved SEQ/hash
+   * placeholder — are owned by the server record and must NOT be re-applied,
+   * else the placeholder would clobber the resolved value. Re-applied paths are
+   * kept dirty (rebased on the server's new `_rev`) so they upload next sync.
+   *
+   * @param uploadedById  path→value the client sent per id (the upload snapshot)
+   * @param dirtyBefore   dirty entries captured BEFORE the success-clear
+   */
+  async adoptMustRefresh(collection, mustRefresh, uploadedById, dirtyBefore) {
+    var _a;
+    if ((_a = this.collections.get(collection)) == null ? void 0 : _a.writeOnly) return;
+    const dexieSave = [];
+    const dexieDeleteIds = [];
+    const memUpsert = [];
+    const memDelete = [];
+    const reAddDirty = [];
+    for (const record of mustRefresh) {
+      if (record._deleted || record._archived) {
+        dexieDeleteIds.push(record._id);
+        memDelete.push({ _id: record._id });
+        continue;
+      }
+      const uploaded = uploadedById.get(String(record._id));
+      const dirtyEntry = dirtyBefore.get(String(record._id));
+      const remaining = {};
+      if (dirtyEntry) {
+        for (const path of Object.keys(dirtyEntry.changes)) {
+          if (!uploaded || !(path in uploaded)) {
+            remaining[path] = dirtyEntry.changes[path];
+          }
+        }
+      }
+      const hasRemaining = Object.keys(remaining).length > 0;
+      const merged = hasRemaining ? applyObjDiff(
+        record,
+        remaining,
+        record._id,
+        collection
+      ) : record;
+      dexieSave.push(merged);
+      memUpsert.push(merged);
+      if (hasRemaining) {
+        reAddDirty.push({
+          id: record._id,
+          changes: remaining,
+          baseMeta: {
+            _ts: record._ts,
+            _rev: record._rev
+          }
+        });
+      }
+    }
+    if (dexieSave.length > 0) await this.dexieDb.saveMany(collection, dexieSave);
+    if (dexieDeleteIds.length > 0) {
+      await this.dexieDb.deleteMany(collection, dexieDeleteIds);
+    }
+    if (memUpsert.length > 0) {
+      this.deps.writeToInMemBatch(collection, memUpsert, "upsert", { source: "incremental" });
+    }
+    if (memDelete.length > 0) {
+      this.deps.writeToInMemBatch(collection, memDelete, "delete", { source: "incremental" });
+    }
+    if (reAddDirty.length > 0) {
+      await this.dexieDb.addDirtyChangesBatch(collection, reAddDirty);
+    }
+  }
+  /**
+   * Build the per-id upload snapshot (`_id` → sent `update`) for one collection
+   * from the request batches — used by `adoptMustRefresh` to tell apart
+   * server-reconciled paths from local edits made during the round-trip.
+   */
+  uploadedSnapshotFor(collectionBatches, collection) {
+    const out = /* @__PURE__ */ new Map();
+    for (const batch of collectionBatches) {
+      for (const b of batch) {
+        if (b.collection !== collection) continue;
+        for (const u of b.batch.updates) {
+          out.set(String(u._id), u.update);
+        }
+      }
+    }
+    return out;
+  }
   /**
    * Upload dirty items for all collections.
    */
@@ -3417,7 +3618,11 @@ var _SyncEngine = class _SyncEngine {
             continue;
           }
         }
-        mappedUpdates.push(candidate);
+        mappedUpdates.push({
+          _id: candidate._id,
+          _rev: dirtyBaseRev != null ? dirtyBaseRev : 0,
+          update: candidate.update
+        });
       }
       if (mappedUpdates.length === 0) continue;
       collectionBatches.push([{
@@ -3466,8 +3671,12 @@ var _SyncEngine = class _SyncEngine {
     for (const result of results) {
       const {
         collection,
-        results: { inserted, updated, deleted, errors: errors2, warnings }
+        results: { inserted, updated, deleted, errors: errors2, warnings, mustRefresh }
       } = result;
+      const mustRefreshIds = /* @__PURE__ */ new Set();
+      if (mustRefresh && mustRefresh.length > 0) {
+        for (const r of mustRefresh) mustRefreshIds.add(String(r._id));
+      }
       const erroredIds = /* @__PURE__ */ new Set();
       if (errors2 && errors2.length > 0) {
         for (const e of errors2) erroredIds.add(String(e._id));
@@ -3503,6 +3712,8 @@ var _SyncEngine = class _SyncEngine {
           `[SyncEngine] Sync upload [${collection}]: ${ambiguous.length} id(s) appeared in BOTH inserted/updated/deleted AND errors[] \u2014 keeping dirty for safety. _ids: ${ambiguous.join(", ")}`
         );
       }
+      const dirtyBeforeRefresh = mustRefreshIds.size > 0 ? await this.dexieDb.getDirtyChangesBatch(collection, [...mustRefreshIds]) : /* @__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);
       }
@@ -3523,6 +3734,7 @@ var _SyncEngine = class _SyncEngine {
           for (let i = 0; i < insertedAndUpdated.length; i++) {
             const entity = insertedAndUpdated[i];
             const dexieItem = dexieItems[i];
+            if (mustRefreshIds.has(String(entity._id))) continue;
             if (dexieItem) {
               dexieItem._rev = entity._rev;
               dexieItem._ts = entity._ts;
@@ -3570,6 +3782,14 @@ var _SyncEngine = class _SyncEngine {
         sentCount += deleted.length;
         collectionSentCount += deleted.length;
       }
+      if (mustRefresh && mustRefresh.length > 0) {
+        await this.adoptMustRefresh(
+          collection,
+          mustRefresh,
+          uploadedByIdRefresh,
+          dirtyBeforeRefresh
+        );
+      }
       if (collectionSentCount > 0) {
         collectionSentCounts[collection] = collectionSentCount;
       }
@@ -3664,7 +3884,11 @@ var _SyncEngine = class _SyncEngine {
       batch: {
         updates: updates.map((item) => {
           const _a = item.delta, { _ts, _rev } = _a, changes = __objRest(_a, ["_ts", "_rev"]);
-          return { _id: item._id, update: changes };
+          return {
+            _id: item._id,
+            _rev: typeof _rev === "number" ? _rev : 0,
+            update: changes
+          };
         }),
         deletes: []
       }
@@ -3676,7 +3900,7 @@ var _SyncEngine = class _SyncEngine {
     let sentCount = 0;
     for (const result of results) {
       const {
-        results: { inserted, updated, deleted, errors: errors2, warnings }
+        results: { inserted, updated, deleted, errors: errors2, warnings, mustRefresh }
       } = result;
       const erroredIds = /* @__PURE__ */ new Set();
       if (errors2 && errors2.length > 0) {
@@ -3725,9 +3949,20 @@ var _SyncEngine = class _SyncEngine {
           `[SyncEngine] Sync upload [${collection}]: ${ambiguous.length} id(s) appeared in BOTH inserted/updated/deleted AND errors[] \u2014 keeping dirty for safety. _ids: ${ambiguous.join(", ")}`
         );
       }
+      const refreshIds = (mustRefresh != null ? mustRefresh : []).map((r) => String(r._id));
+      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);
       }
+      if (mustRefresh && mustRefresh.length > 0) {
+        await this.adoptMustRefresh(
+          collection,
+          mustRefresh,
+          uploadedByIdRefresh,
+          dirtyBeforeRefresh
+        );
+      }
       sentCount += allSuccessIds.length;
     }
     return { sentCount };
@@ -4456,6 +4691,8 @@ var _SyncedDb = class _SyncedDb {
     this.syncOnlyCollections = null;
     // Sync metadata cache
     this.syncMetaCache = /* @__PURE__ */ new Map();
+    // Per-collection hydration status (powers getPreloadStatus / onPreloadStatusChange)
+    this.preloadStatusMap = /* @__PURE__ */ new Map();
     this._pendingFullResync = false;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     this.tenant = config.tenant;
@@ -4475,6 +4712,7 @@ var _SyncedDb = class _SyncedDb {
     this.onDexieSyncStart = config.onDexieSyncStart;
     this.onDexieSyncEnd = config.onDexieSyncEnd;
     this.onSyncProgress = config.onSyncProgress;
+    this.onPreloadStatusChange = config.onPreloadStatusChange;
     this.onServerSyncStart = config.onServerSyncStart;
     this.onServerSyncEnd = config.onServerSyncEnd;
     this.onConflictResolved = config.onConflictResolved;
@@ -4494,6 +4732,7 @@ var _SyncedDb = class _SyncedDb {
     this.evictOnWake = (_g = config.evictOnWake) != null ? _g : false;
     for (const col of config.collections) {
       this.collections.set(col.name, col);
+      if (!col.writeOnly) this.preloadStatusMap.set(col.name, { state: "pending", itemCount: 0 });
     }
     this.inMemManager = new InMemManager({
       inMemDb: this.inMemDb,
@@ -4794,6 +5033,9 @@ var _SyncedDb = class _SyncedDb {
       const existing = this.collections.get(spec.name);
       if (existing && !existing.temporaryConfig) continue;
       this.collections.set(spec.name, spec);
+      if (!spec.writeOnly && !this.preloadStatusMap.has(spec.name)) {
+        this.preloadStatusMap.set(spec.name, { state: "pending", itemCount: 0 });
+      }
       if (this.syncOnlyCollections) {
         this.syncOnlyCollections.add(spec.name);
       }
@@ -4914,8 +5156,10 @@ var _SyncedDb = class _SyncedDb {
     for (const [name] of this.collections) {
       if (this.isSyncAllowed(name) && !prevAllowed.has(name)) {
         newlyAllowed.push(name);
+        this.preloadStatusMap.set(name, { state: "pending", itemCount: 0 });
       }
     }
+    this.emitPreloadStatusChange();
     if (newlyAllowed.length > 0) {
       await this.loadCollectionsToInMem(newlyAllowed, "setSyncOnlyTheseCollections");
     }
@@ -5573,7 +5817,7 @@ var _SyncedDb = class _SyncedDb {
       );
     }
     const fullChanges = __spreadProps(__spreadValues({}, update), { _lastUpdaterId: this.updaterId });
-    const diff = computeDiff(existing, fullChanges);
+    const diff = computeObjDiff(existing, fullChanges);
     await this.dexieDb.addDirtyChange(
       collection,
       id,
@@ -5582,7 +5826,7 @@ var _SyncedDb = class _SyncedDb {
     );
     const isWriteOnly = (_b = this.collections.get(collection)) == null ? void 0 : _b.writeOnly;
     const currentMem = isWriteOnly ? null : this.inMemDb.getById(collection, id);
-    const merged = _SyncedDb.applyDiffLocally(
+    const merged = applyObjDiff(
       currentMem != null ? currentMem : existing,
       diff,
       id,
@@ -5844,6 +6088,7 @@ var _SyncedDb = class _SyncedDb {
       }
     } finally {
       this.syncLock = false;
+      this.emitPreloadStatusChange();
     }
   }
   async processQueuedWsUpdates() {
@@ -5860,8 +6105,8 @@ var _SyncedDb = class _SyncedDb {
   // ==================== Batch Operations ====================
   /**
    * Run each batch entry through the standard `upsert()` pipeline so every
-   * write — single or batched — goes through `computeDiff` →
-   * `applyDiffLocally` → in-mem write + Dexie schedule + dirty change.
+   * write — single or batched — goes through `computeObjDiff` →
+   * `applyObjDiff` → in-mem write + Dexie schedule + dirty change.
    *
    * Server upload remains batched: dirty entries accumulated by the per-item
    * calls coalesce into one `updateCollections` request at the next sync
@@ -6660,7 +6905,11 @@ var _SyncedDb = class _SyncedDb {
       async () => {
         while (queue.length > 0) {
           const name = queue.shift();
-          const items = await this.loadCollectionToInMem(name);
+          let items = 0;
+          try {
+            items = await this.loadCollectionToInMem(name);
+          } catch (e) {
+          }
           totalItems += items;
           loaded++;
           this.safeCallback(this.onSyncProgress, {
@@ -6682,7 +6931,73 @@ var _SyncedDb = class _SyncedDb {
     });
     return totalItems;
   }
+  /**
+   * Hydrate a single collection from Dexie, recording the outcome in
+   * {@link preloadStatusMap} (hydrated / failed) for {@link getPreloadStatus}.
+   * Rethrows on failure so existing callers (e.g. the `Promise.allSettled` in
+   * addCollectionsToSync, the per-collection try/catch in loadCollectionsToInMem)
+   * keep their current behavior.
+   */
   async loadCollectionToInMem(name) {
+    var _a;
+    try {
+      const count = await this._hydrateCollectionFromDexie(name);
+      this.preloadStatusMap.set(name, { state: "hydrated", itemCount: count, hydratedAt: /* @__PURE__ */ new Date() });
+      this.emitPreloadStatusChange();
+      return count;
+    } catch (err) {
+      const prev = this.preloadStatusMap.get(name);
+      this.preloadStatusMap.set(name, {
+        state: "failed",
+        itemCount: (_a = prev == null ? void 0 : prev.itemCount) != null ? _a : 0,
+        hydratedAt: prev == null ? void 0 : prev.hydratedAt,
+        lastError: err instanceof Error ? err.message : String(err)
+      });
+      this.emitPreloadStatusChange();
+      throw err;
+    }
+  }
+  /**
+   * Per-collection hydration status + rolled-up aggregate, over readable
+   * (non-`writeOnly`), in-scope collections. See {@link I_SyncedDb.getPreloadStatus}.
+   */
+  getPreloadStatus() {
+    var _a, _b;
+    const collections = [];
+    let readyCount = 0;
+    let failedCount = 0;
+    let pendingCount = 0;
+    for (const name of this.collections.keys()) {
+      if (!this.isSyncAllowed(name)) continue;
+      const rec = (_a = this.preloadStatusMap.get(name)) != null ? _a : { state: "pending", itemCount: 0 };
+      const everDownloaded = !!((_b = this.syncMetaCache.get(name)) == null ? void 0 : _b.lastSyncTs);
+      const ready = rec.state === "hydrated" && (rec.itemCount > 0 || everDownloaded);
+      if (rec.state === "failed") failedCount++;
+      else if (ready) readyCount++;
+      else pendingCount++;
+      collections.push({
+        name,
+        state: rec.state,
+        itemCount: rec.itemCount,
+        ready,
+        hydratedAt: rec.hydratedAt,
+        lastError: rec.lastError,
+        everDownloaded
+      });
+    }
+    const expectedCount = collections.length;
+    let aggregate;
+    if (expectedCount === 0) aggregate = "idle";
+    else if (readyCount === expectedCount) aggregate = "full";
+    else if (failedCount === expectedCount) aggregate = "failed";
+    else aggregate = "partial";
+    return { aggregate, collections, expectedCount, readyCount, failedCount, pendingCount };
+  }
+  /** Emit onPreloadStatusChange with a fresh snapshot (skips computation when no listener). */
+  emitPreloadStatusChange() {
+    if (this.onPreloadStatusChange) this.safeCallback(this.onPreloadStatusChange, this.getPreloadStatus());
+  }
+  async _hydrateCollectionFromDexie(name) {
     const allItems = [];
     await this.dexieDb.forEachBatch(name, 2e3, async (chunk) => {
       for (let i = 0; i < chunk.length; i++) {
@@ -6709,7 +7024,7 @@ var _SyncedDb = class _SyncedDb {
           if (key === "_id" || key === "_ts" || key === "_rev") continue;
           diff[key] = dirtyItem[key];
         }
-        const merged = _SyncedDb.applyDiffLocally(
+        const merged = applyObjDiff(
           existing != null ? existing : null,
           diff,
           id,
@@ -6900,224 +7215,6 @@ var _SyncedDb = class _SyncedDb {
   static isObjectIdLike(v) {
     return !!(v && typeof v === "object" && (v._bsontype === "ObjectId" || typeof v.toHexString === "function"));
   }
-  /**
-   * Mongo-symmetric local apply: starting from `base` (a safe deep clone of
-   * `currentMem` or `existing`), walk each `(path, value)` entry of `diff`:
-   *
-   *   - `value === undefined`  →  `deleteByPath`  (mongo `$unset` symmetric)
-   *   - otherwise              →  `setByPath`     (mongo `$set` symmetric)
-   *
-   * The result is what an equivalent server-side `$set` + `$unset` would
-   * have produced. Replaces the previous shallow `{ ...currentMem, ...update }`
-   * merge which dropped nested fields the caller's `update` didn't mention.
-   *
-   * Returns a new object (the cloned-and-mutated `base`); never mutates
-   * the input `base` reference.
-   */
-  static applyDiffLocally(base, diff, fallbackId, collection) {
-    const seed = base ? _SyncedDb.safeDeepClone(base) : { _id: fallbackId };
-    if (seed._id == null) seed._id = fallbackId;
-    for (const path of Object.keys(diff)) {
-      const value = diff[path];
-      if (value === void 0) {
-        deleteByPath(seed, path);
-        continue;
-      }
-      if (!path.includes(".") && !path.includes("[")) {
-        seed[path] = value;
-        continue;
-      }
-      const ok = setByPath(seed, path, value);
-      if (ok) continue;
-      _SyncedDb.materializeBracketPath(seed, path, value, collection, fallbackId);
-    }
-    return seed;
-  }
-  /**
-   * Fallback for `setByPath` failures inside `applyDiffLocally`. Materializes
-   * missing array containers AND missing intermediate plain objects so the
-   * diff entry can land locally instead of being dropped.
-   *
-   * Supported path shape (tokenizes to `[…plain prefix, [<id>], …plain suffix]`):
-   *
-   *   • Single-segment prefix:
-   *     - `polje[<id>] = <obj>`           →  seed.polje = [<obj>]
-   *     - `polje[<id>].field = <v>`       →  seed.polje = [{_id, field: <v>}]
-   *     - `polje[<id>].a.b.c = <v>`       →  seed.polje = [{_id, a: {b: {c: <v>}}}]
-   *
-   *   • Multi-segment plain prefix:
-   *     - `outer.polje[<id>] = <obj>`              →  seed.outer = {polje: [<obj>]}
-   *     - `outer.inner.polje[<id>].field = <v>`    →  seed.outer = {inner: {polje: [{_id, field: <v>}]}}
-   *
-   *   • Existing matching `_id` on the target array: walk into the element
-   *     and create missing intermediates on the way down; set the leaf
-   *     without pushing a duplicate element.
-   *
-   * Dropped:
-   *   • Multi-bracket paths (e.g. `polje[a].sub[b]`, `outer[a].sub.inner[b]`)
-   *     — require shape knowledge the fallback can't reconstruct. Server
-   *     applies the path; next sync hydrates the canonical state locally.
-   *   • Existing intermediate that is a non-plain value (Date, primitive,
-   *     array where an object is expected).
-   *
-   * `_`-prefixed first segment (e.g. `_redundanca…`): for shapes that
-   * extend BEYOND the originally-supported single-segment prefix, the
-   * drop is **silent** and unconditional — these fields are server-
-   * mirrored and local materialization could create state that diverges
-   * from the canonical server form. Simple single-segment shapes
-   * (`_field[<id>]`, `_field[<id>].sub`, `_field[<id>].sub.deep…`) still
-   * materialize as before.
-   *
-   * Replaces the pre-fix blind `seed[path] = value` fallback that stamped
-   * literal bracket-keyed top-level properties (e.g. `"postavke[<id>]": [<el>]`)
-   * onto Dexie rows and in-mem state, persisting forever through subsequent
-   * `safeDeepClone`-based save cycles.
-   */
-  static materializeBracketPath(seed, path, value, collection, id) {
-    const tokens = tokenizePath(path);
-    const firstToken = tokens[0];
-    const dropSilently = typeof firstToken === "string" && firstToken.startsWith("_");
-    const drop = (reason) => {
-      if (dropSilently) return;
-      console.error(
-        `[SyncedDb] applyDiffLocally: dropping bracket-path diff entry (${reason})`,
-        { collection, _id: String(id), path, value }
-      );
-    };
-    if (tokens.length < 2) {
-      drop(`unsupported token count ${tokens.length}`);
-      return;
-    }
-    if (firstToken === void 0 || firstToken.startsWith("[")) {
-      drop("first segment is not a plain field");
-      return;
-    }
-    let bracketIdx = -1;
-    for (let i = 1; i < tokens.length; i++) {
-      if (tokens[i].startsWith("[")) {
-        bracketIdx = i;
-        break;
-      }
-    }
-    if (bracketIdx < 0) {
-      drop("no bracket segment found");
-      return;
-    }
-    for (let i = bracketIdx + 1; i < tokens.length; i++) {
-      if (tokens[i].startsWith("[")) {
-        drop("nested bracket path");
-        return;
-      }
-    }
-    if (dropSilently && bracketIdx > 1) {
-      return;
-    }
-    const prefixTokens = tokens.slice(0, bracketIdx);
-    const bracketToken = tokens[bracketIdx];
-    const suffixTokens = tokens.slice(bracketIdx + 1);
-    const bracketId = bracketToken.slice(1, -1);
-    if (bracketId.length === 0) {
-      drop("empty bracket id");
-      return;
-    }
-    let parent = seed;
-    for (let i = 0; i < prefixTokens.length - 1; i++) {
-      const seg = prefixTokens[i];
-      const cur = parent[seg];
-      if (cur === void 0 || cur === null) {
-        parent[seg] = {};
-      } else if (typeof cur !== "object" || Array.isArray(cur) || cur instanceof Date) {
-        drop(
-          `existing intermediate "${prefixTokens.slice(0, i + 1).join(".")}" is not a plain object`
-        );
-        return;
-      }
-      parent = parent[seg];
-    }
-    const lastPrefixSeg = prefixTokens[prefixTokens.length - 1];
-    let arr = parent[lastPrefixSeg];
-    if (arr != null && !Array.isArray(arr)) {
-      drop(`existing "${prefixTokens.join(".")}" is not an array`);
-      return;
-    }
-    if (arr == null) {
-      arr = [];
-      parent[lastPrefixSeg] = arr;
-    }
-    if (suffixTokens.length === 0) {
-      let element = value;
-      if (Array.isArray(value) && value.length === 1 && value[0] != null && typeof value[0] === "object") {
-        element = value[0];
-      }
-      if (element == null || typeof element !== "object" || Array.isArray(element)) {
-        drop("value is not a single element or wire-form wrapper");
-        return;
-      }
-      if (element._id == null) {
-        element._id = bracketId;
-      }
-      const replaceIdx = arr.findIndex(
-        (it) => it != null && typeof it === "object" && String(it._id) === bracketId
-      );
-      if (replaceIdx >= 0) {
-        arr[replaceIdx] = element;
-      } else {
-        arr.push(element);
-      }
-      return;
-    }
-    const buildNestedSubTree = (segs, leaf) => {
-      let acc = leaf;
-      for (let i = segs.length - 1; i >= 0; i--) {
-        acc = { [segs[i]]: acc };
-      }
-      return acc;
-    };
-    const existingIdx = arr.findIndex(
-      (it) => it != null && typeof it === "object" && String(it._id) === bracketId
-    );
-    if (existingIdx >= 0) {
-      let cur = arr[existingIdx];
-      for (let i = 0; i < suffixTokens.length - 1; i++) {
-        const seg = suffixTokens[i];
-        const next = cur[seg];
-        if (next == null || typeof next !== "object" || Array.isArray(next)) {
-          cur[seg] = {};
-        }
-        cur = cur[seg];
-      }
-      cur[suffixTokens[suffixTokens.length - 1]] = value;
-    } else {
-      const subTree = buildNestedSubTree(suffixTokens, value);
-      arr.push(__spreadValues({ _id: bracketId }, subTree));
-    }
-  }
-  /**
-   * Deep clone for `applyDiffLocally`. Recurses into plain objects and
-   * arrays; preserves `Date` (cloned to avoid shared reference) and
-   * `ObjectId`-like values by reference (their internal Buffer state is
-   * immutable from our perspective). Other class instances pass through
-   * by reference. Avoids `structuredClone` because it throws on class
-   * instances like bson `ObjectId`.
-   */
-  static safeDeepClone(value) {
-    if (value === null || value === void 0) return value;
-    if (typeof value !== "object") return value;
-    if (value instanceof Date) return new Date(value.getTime());
-    if (_SyncedDb.isObjectIdLike(value)) return value;
-    if (Array.isArray(value)) {
-      const out2 = new Array(value.length);
-      for (let i = 0; i < value.length; i++) out2[i] = _SyncedDb.safeDeepClone(value[i]);
-      return out2;
-    }
-    const proto = Object.getPrototypeOf(value);
-    if (proto !== Object.prototype && proto !== null) return value;
-    const out = {};
-    for (const key of Object.keys(value)) {
-      out[key] = _SyncedDb.safeDeepClone(value[key]);
-    }
-    return out;
-  }
   /**
    * Asserts write-only collection has online connectivity for reads.
    * @throws Error if offline
@@ -7173,6 +7270,105 @@ var SyncedDb = _SyncedDb;
 
 // src/db/DexieDb.ts
 import Dexie from "dexie";
+
+// src/utils/computeDiff.ts
+function isDescendantOrEqual(path, candidate) {
+  if (path === candidate) return true;
+  if (!path.startsWith(candidate)) return false;
+  const next = path[candidate.length];
+  return next === "." || next === "[";
+}
+function pathsOverlap(a, b) {
+  return isDescendantOrEqual(a, b) || isDescendantOrEqual(b, a);
+}
+function isTerminalBracketKey(path) {
+  const tokens = tokenizePath(path);
+  const last = tokens[tokens.length - 1];
+  return !!(last && last.length >= 2 && last.charCodeAt(0) === 91 && last.charCodeAt(last.length - 1) === 93);
+}
+function canExpandArrayToBrackets(value) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  for (const el of value) {
+    if (el === null || typeof el !== "object") return false;
+    if (el._id == null) return false;
+  }
+  return true;
+}
+function pickLayerTarget(newPath, newValue) {
+  if (!isTerminalBracketKey(newPath)) return null;
+  if (newValue === void 0) return null;
+  if (Array.isArray(newValue) && newValue.length === 1 && newValue[0] && typeof newValue[0] === "object") {
+    return newValue[0];
+  }
+  if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+    return newValue;
+  }
+  return null;
+}
+function mergeDirtyPath(accumulated, newPath, newValue) {
+  for (const existingKey of Object.keys(accumulated)) {
+    if (existingKey === newPath) continue;
+    if (isDescendantOrEqual(newPath, existingKey)) {
+      const existingValue = accumulated[existingKey];
+      const existingIsTerminal = isTerminalBracketKey(existingKey);
+      if (existingIsTerminal && existingValue === void 0) {
+        return;
+      }
+      let mutationTarget = existingValue;
+      if (existingIsTerminal && Array.isArray(existingValue) && existingValue.length === 1) {
+        mutationTarget = existingValue[0];
+      }
+      if (!existingIsTerminal && (existingValue === null || existingValue === void 0)) {
+        accumulated[existingKey] = {};
+        mutationTarget = accumulated[existingKey];
+      }
+      if (!existingIsTerminal && newPath[existingKey.length] === "[" && canExpandArrayToBrackets(existingValue)) {
+        delete accumulated[existingKey];
+        for (const el of existingValue) {
+          accumulated[`${existingKey}[${String(el._id)}]`] = [el];
+        }
+        mergeDirtyPath(accumulated, newPath, newValue);
+        return;
+      }
+      const sepChar = newPath[existingKey.length];
+      const relativePath = sepChar === "[" ? newPath.substring(existingKey.length) : newPath.substring(existingKey.length + 1);
+      const ok = setByPath(mutationTarget, relativePath, newValue);
+      if (ok) return;
+      delete accumulated[existingKey];
+      accumulated[newPath] = newValue;
+      return;
+    }
+  }
+  const descendants = [];
+  for (const existingKey of Object.keys(accumulated)) {
+    if (existingKey === newPath) continue;
+    if (isDescendantOrEqual(existingKey, newPath)) {
+      descendants.push(existingKey);
+    }
+  }
+  const layerInto = pickLayerTarget(newPath, newValue);
+  if (layerInto && descendants.length > 0) {
+    for (const desc of descendants) {
+      const sepChar = desc[newPath.length];
+      const relativePath = sepChar === "[" ? desc.substring(newPath.length) : desc.substring(newPath.length + 1);
+      const descValue = accumulated[desc];
+      if (descValue === void 0) {
+        deleteByPath(layerInto, relativePath);
+      } else {
+        setByPath(layerInto, relativePath, descValue);
+      }
+    }
+  }
+  for (const k of descendants) delete accumulated[k];
+  accumulated[newPath] = newValue;
+}
+function mergeDirtyChanges(accumulated, newChanges) {
+  for (const path of Object.keys(newChanges)) {
+    mergeDirtyPath(accumulated, path, newChanges[path]);
+  }
+}
+
+// src/db/DexieDb.ts
 var SYNC_META_TABLE = "_sync_meta";
 var DIRTY_CHANGES_TABLE = "_dirty_changes";
 var META_ONLY_DIRTY_KEYS = /* @__PURE__ */ new Set([