cry-synced-db-client 0.1.159 → 0.1.160

package/dist/index.js

@@ -330,28 +330,67 @@ function sameIdSequence(a, b) {
   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 (existingArr.length === 0 && updateArr.length === 0) return;
+  if (!allElementsHaveId(updateArr) || existingArr.length > 0 && !allElementsHaveId(existingArr)) {
     if (!deepEquals(existingArr, updateArr)) {
       diff[basePath] = updateArr;
     }
     return;
   }
-  if (!sameIdSequence(existingArr, updateArr)) {
-    diff[basePath] = updateArr;
+  const existingIds = /* @__PURE__ */ new Set();
+  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));
+  let sameSet = existingIds.size === updateIds.size;
+  if (sameSet) {
+    for (const id of existingIds) {
+      if (!updateIds.has(id)) {
+        sameSet = false;
+        break;
+      }
+    }
+  }
+  if (sameSet) {
+    if (sameIdSequence(existingArr, updateArr)) {
+      for (let i = 0; i < updateArr.length; i++) {
+        const elementId = String(updateArr[i]._id);
+        computeDiffInto(
+          existingArr[i],
+          updateArr[i],
+          `${basePath}[${elementId}]`,
+          diff
+        );
+      }
+    } else {
+      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
-    );
+  for (const id of existingIds) {
+    if (!updateIds.has(id)) {
+      diff[`${basePath}[${id}]`] = void 0;
+    }
+  }
+  for (const updateEl of updateArr) {
+    const id = String(updateEl._id);
+    if (!existingIds.has(id)) {
+      diff[`${basePath}[${id}]`] = [updateEl];
+    }
+  }
+  if (existingArr.length > 0) {
+    const existingById = /* @__PURE__ */ new Map();
+    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)) {
+        computeDiffInto(
+          existingById.get(id),
+          updateEl,
+          `${basePath}[${id}]`,
+          diff
+        );
+      }
+    }
   }
 }
 function computeDiffInto(existing, update, basePath, diff) {
@@ -482,12 +521,62 @@ function setSegment(current, part, value) {
   }
   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;
+  }
+  const last = parts[parts.length - 1];
+  return deleteSegment(current, last);
+}
+function deleteSegment(current, part) {
+  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.splice(idx, 1);
+    return true;
+  }
+  if (/^\d+$/.test(part) && Array.isArray(current)) {
+    const idx = Number(part);
+    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;
+    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 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];
+      }
       const relativePath = newPath.substring(existingKey.length + 1);
-      const ok = setByPath(accumulated[existingKey], relativePath, newValue);
+      const ok = setByPath(mutationTarget, relativePath, newValue);
       if (ok) return;
       break;
     }
@@ -508,6 +597,51 @@ function mergeDirtyChanges(accumulated, newChanges) {
   }
 }
 
+// src/utils/normalizeUndefined.ts
+var SERVER_MANAGED_KEYS = /* @__PURE__ */ new Set(["_ts", "_rev", "_csq"]);
+function isObjectIdLike2(v) {
+  return !!(v && typeof v === "object" && (v._bsontype === "ObjectId" || v._bsontype === "ObjectID"));
+}
+function collectUnsetPaths(value) {
+  const paths = [];
+  walk(value, "", paths);
+  return paths;
+}
+function walk(node, prefix, paths) {
+  if (node === null || node === void 0) return;
+  if (typeof node !== "object") return;
+  if (node instanceof Date) return;
+  if (isObjectIdLike2(node)) return;
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      const element = node[i];
+      const childPath = childPathForArrayElement(prefix, element, i);
+      if (element === void 0) {
+        paths.push(childPath);
+      } else {
+        walk(element, childPath, paths);
+      }
+    }
+    return;
+  }
+  for (const key of Object.keys(node)) {
+    if (SERVER_MANAGED_KEYS.has(key)) continue;
+    const child = node[key];
+    const childPath = prefix ? `${prefix}.${key}` : key;
+    if (child === void 0) {
+      paths.push(childPath);
+    } else {
+      walk(child, childPath, paths);
+    }
+  }
+}
+function childPathForArrayElement(prefix, element, index) {
+  if (element !== null && element !== void 0 && typeof element === "object" && !Array.isArray(element) && !(element instanceof Date) && !isObjectIdLike2(element) && element._id != null) {
+    return `${prefix}[${String(element._id)}]`;
+  }
+  return prefix ? `${prefix}.${index}` : String(index);
+}
+
 // src/db/managers/InMemManager.ts
 var InMemManager = class {
   constructor(config) {
@@ -2755,62 +2889,19 @@ function fixDotnetArrays(changes, serverRev, baseRev) {
 }
 
 // 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(".");
+function translateBracketPathsToIndex(changes, _entity) {
+  return changes;
 }
 
 // src/utils/stripServerManaged.ts
-var SERVER_MANAGED_KEYS = /* @__PURE__ */ new Set(["_ts", "_rev", "_csq"]);
-function isObjectIdLike2(v) {
+var SERVER_MANAGED_KEYS2 = /* @__PURE__ */ new Set(["_ts", "_rev", "_csq"]);
+function isObjectIdLike3(v) {
   return !!(v && typeof v === "object" && (v._bsontype === "ObjectId" || v._bsontype === "ObjectID"));
 }
 function isServerManagedPath(key) {
   for (const part of tokenizePath(key)) {
     if (part.startsWith("[")) continue;
-    if (SERVER_MANAGED_KEYS.has(part)) return true;
+    if (SERVER_MANAGED_KEYS2.has(part)) return true;
   }
   return false;
 }
@@ -2821,10 +2912,10 @@ function scrubServerManagedDeep(value) {
   }
   if (typeof value !== "object") return value;
   if (value instanceof Date) return value;
-  if (isObjectIdLike2(value)) return value;
+  if (isObjectIdLike3(value)) return value;
   const out = {};
   for (const k of Object.keys(value)) {
-    if (SERVER_MANAGED_KEYS.has(k)) continue;
+    if (SERVER_MANAGED_KEYS2.has(k)) continue;
     out[k] = scrubServerManagedDeep(value[k]);
   }
   return out;
@@ -4820,7 +4911,11 @@ var _SyncedDb = class _SyncedDb {
     this.pendingChanges.schedule(collection, id, newData, 0, "save");
     const isWriteOnly = (_b = this.collections.get(collection)) == null ? void 0 : _b.writeOnly;
     const currentMem = isWriteOnly ? null : this.inMemDb.getById(collection, id);
-    const merged = __spreadValues(__spreadValues({}, currentMem || existing || { _id: id }), update);
+    const merged = _SyncedDb.applyDiffLocally(
+      currentMem != null ? currentMem : existing,
+      diff,
+      id
+    );
     if (!isWriteOnly && !(existing == null ? void 0 : existing._deleted) && !(existing == null ? void 0 : existing._archived)) {
       this.inMemManager.writeBatch(collection, [merged], "upsert", { source: "incremental" });
     }
@@ -4845,6 +4940,7 @@ var _SyncedDb = class _SyncedDb {
     this.ensureId(data, "insert", collection);
     _SyncedDb.ensureNestedIds(data);
     data = _SyncedDb.stringifyObjectIds(data);
+    const unsetPaths = collectUnsetPaths(data);
     const id = String(data._id);
     const existing = await this.dexieDb.getById(collection, id);
     if (existing && !existing._deleted && !existing._archived) {
@@ -4862,6 +4958,7 @@ var _SyncedDb = class _SyncedDb {
       _id: id,
       _lastUpdaterId: this.updaterId
     });
+    for (const path of unsetPaths) deleteByPath(newData, path);
     this.pendingChanges.schedule(collection, id, newData, 0, "insert");
     if (!((_a = this.collections.get(collection)) == null ? void 0 : _a.writeOnly)) {
       this.inMemManager.writeBatch(collection, [newData], "upsert", { source: "incremental" });
@@ -5945,6 +6042,64 @@ 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) {
+    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) seed[path] = value;
+    }
+    return seed;
+  }
+  /**
+   * 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;
+  }
   /**
    * Recursively walk `value` and ensure every plain object that appears
    * as an element of an array carries an `_id`. Missing `_id`s are
@@ -6345,14 +6500,6 @@ var C1 = new C1Type();
 C1.name = "MessagePack 0xC1";
 var sequentialMode = false;
 var inlineObjectReadThreshold = 2;
-var readStruct;
-var onLoadedStructures;
-var onSaveState;
-try {
-  new Function("");
-} catch (error) {
-  inlineObjectReadThreshold = Infinity;
-}
 var Unpackr = class _Unpackr {
   constructor(options) {
     if (options) {
@@ -6455,8 +6602,8 @@ var Unpackr = class _Unpackr {
     }
   }
   _mergeStructures(loadedStructures, existingStructures) {
-    if (onLoadedStructures)
-      loadedStructures = onLoadedStructures.call(this, loadedStructures);
+    if (this._onLoadedStructures)
+      loadedStructures = this._onLoadedStructures(loadedStructures);
     loadedStructures = loadedStructures || [];
     if (Object.isFrozen(loadedStructures))
       loadedStructures = loadedStructures.map((structure) => structure.slice(0));
@@ -6494,8 +6641,8 @@ function checkedRead(options) {
         currentStructures.length = sharedLength;
     }
     let result;
-    if (currentUnpackr.randomAccessStructure && src[position] < 64 && src[position] >= 32 && readStruct) {
-      result = readStruct(src, position, srcEnd, currentUnpackr);
+    if (currentUnpackr._readStruct && src[position] < 64 && src[position] >= 32) {
+      result = currentUnpackr._readStruct(src, position, srcEnd);
       src = null;
       if (!(options && options.lazy) && result)
         result = result.toJSON();
@@ -6784,10 +6931,16 @@ var validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
 function createStructureReader(structure, firstId) {
   function readObject() {
     if (readObject.count++ > inlineObjectReadThreshold) {
-      let readObject2 = structure.read = new Function("r", "return function(){return " + (currentUnpackr.freezeData ? "Object.freeze" : "") + "({" + structure.map((key) => key === "__proto__" ? "__proto_:r()" : validName.test(key) ? key + ":r()" : "[" + JSON.stringify(key) + "]:r()").join(",") + "})}")(read);
+      let optimizedReadObject;
+      try {
+        optimizedReadObject = structure.read = new Function("r", "return function(){return " + (currentUnpackr.freezeData ? "Object.freeze" : "") + "({" + structure.map((key) => key === "__proto__" ? "__proto_:r()" : validName.test(key) ? key + ":r()" : "[" + JSON.stringify(key) + "]:r()").join(",") + "})}")(read);
+      } catch (error) {
+        inlineObjectReadThreshold = Infinity;
+        return readObject();
+      }
       if (structure.highByte === 0)
         structure.read = createSecondByteReader(firstId, structure.read);
-      return readObject2();
+      return optimizedReadObject();
     }
     let object = {};
     for (let i = 0, l = structure.length; i < l; i++) {
@@ -7219,7 +7372,7 @@ currentExtensions[66] = (data) => {
       if (length <= 40) {
         let out = view.getBigUint64(start);
         for (let i = start + 8; i < end; i += 8) {
-          out <<= BigInt(/* @__PURE__ */ BigInt("64"));
+          out <<= BigInt(64);
           out |= view.getBigUint64(i);
         }
         return out;
@@ -7334,8 +7487,8 @@ currentExtensions[255] = (data) => {
     return /* @__PURE__ */ new Date("invalid");
 };
 function saveState(callback) {
-  if (onSaveState)
-    onSaveState();
+  if (currentUnpackr && currentUnpackr._onSaveState)
+    currentUnpackr._onSaveState();
   let savedSrcEnd = srcEnd;
   let savedPosition = position;
   let savedStringPosition = stringPosition;
@@ -7389,6 +7542,7 @@ var FLOAT32_OPTIONS = {
 };
 var f32Array = new Float32Array(1);
 var u8Array = new Uint8Array(f32Array.buffer, 0, 4);
+Unpackr.SUPPORTS_STRUCT_HOOKS = true;
 
 // node_modules/msgpackr/pack.js
 var textEncoder;
@@ -7410,7 +7564,6 @@ var targetView;
 var position2 = 0;
 var safeEnd;
 var bundledStrings2 = null;
-var writeStructSlots;
 var MAX_BUNDLE_SIZE = 21760;
 var hasNonLatin = /[\u0080-\uFFFF]/;
 var RECORD_SYMBOL = /* @__PURE__ */ Symbol("record-id");
@@ -7512,7 +7665,7 @@ var Packr = class extends Unpackr {
         hasSharedUpdate = false;
       let encodingError;
       try {
-        if (packr3.randomAccessStructure && value && typeof value === "object") {
+        if (packr3._writeStruct && value && typeof value === "object") {
           if (value.constructor === Object) writeStruct(value);
           else if (value.constructor !== Map && !Array.isArray(value) && !extensionClasses.some((extClass) => value instanceof extClass)) {
             writeStruct(value.toJSON ? value.toJSON() : value);
@@ -7575,7 +7728,7 @@ var Packr = class extends Unpackr {
           if (hasSharedUpdate && packr3.saveStructures) {
             let sharedLength = structures.sharedLength || 0;
             let returnBuffer = target.subarray(start, position2);
-            let newSharedData = prepareStructures(structures, packr3);
+            let newSharedData = (packr3._prepareStructures || prepareStructures)(structures, packr3);
             if (!encodingError) {
               if (packr3.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
                 return packr3.pack(value, encodeOptions);
@@ -7732,7 +7885,7 @@ var Packr = class extends Unpackr {
         position2 += length;
       } else if (type === "number") {
         if (value >>> 0 === value) {
-          if (value < 32 || value < 128 && this.useRecords === false || value < 64 && !this.randomAccessStructure) {
+          if (value < 32 || value < 128 && this.useRecords === false || value < 64 && !this._writeStruct) {
             target[position2++] = value;
           } else if (value < 256) {
             target[position2++] = 204;
@@ -8091,6 +8244,23 @@ var Packr = class extends Unpackr {
     const writeObject = checkUseRecords ? (object) => {
       checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
     } : writeRecord;
+    const writeStruct = (object) => {
+      let newPosition = packr3._writeStruct(object, target, start, position2, structures, makeRoom, (value, newPosition2, notifySharedUpdate) => {
+        if (notifySharedUpdate)
+          return hasSharedUpdate = true;
+        position2 = newPosition2;
+        let startTarget = target;
+        pack3(value);
+        resetStructures();
+        if (startTarget !== target) {
+          return { position: position2, targetView, target };
+        }
+        return position2;
+      });
+      if (newPosition === 0)
+        return writeObject(object);
+      position2 = newPosition;
+    };
     const makeRoom = (end) => {
       let newSize;
       if (end > 16777216) {
@@ -8191,23 +8361,6 @@ var Packr = class extends Unpackr {
         target[insertionOffset + start] = keysTarget[0];
       }
     };
-    const writeStruct = (object) => {
-      let newPosition = writeStructSlots(object, target, start, position2, structures, makeRoom, (value, newPosition2, notifySharedUpdate) => {
-        if (notifySharedUpdate)
-          return hasSharedUpdate = true;
-        position2 = newPosition2;
-        let startTarget = target;
-        pack3(value);
-        resetStructures();
-        if (startTarget !== target) {
-          return { position: position2, targetView, target };
-        }
-        return position2;
-      }, this);
-      if (newPosition === 0)
-        return writeObject(object);
-      position2 = newPosition;
-    };
   }
   useBuffer(buffer) {
     target = buffer;
@@ -8444,6 +8597,7 @@ function prepareStructures(structures, packr3) {
   };
   return structures;
 }
+Packr.SUPPORTS_STRUCT_HOOKS = true;
 var defaultPackr = new Packr({ useRecords: false });
 var pack = defaultPackr.pack;
 var encode = defaultPackr.pack;

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

@@ -403,6 +403,30 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private static stringifyObjectIds;
     private static isObjectIdLike;
+    /**
+     * 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.
+     */
+    private static applyDiffLocally;
+    /**
+     * 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`.
+     */
+    private static safeDeepClone;
     /**
      * Recursively walk `value` and ensure every plain object that appears
      * as an element of an array carries an `_id`. Missing `_id`s are

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

@@ -41,6 +41,34 @@ export declare function hasDotNotationPaths(changes: Record<string, any>): boole
  * "arr[A].sub[B].field"    → ["arr", "[A]", "sub", "[B]", "field"]
  */
 export declare function tokenizePath(path: string): string[];
+/**
+ * Set a value at a path within a nested target. Supports three segment forms:
+ *   - Numeric ("0", "1") → array index
+ *   - Bracket ("[<_id>]") → array element matched by `_id` field
+ *   - Plain ("field") → object key
+ *
+ * @returns true if the value was successfully set, false if path traversal failed.
+ */
+export declare function setByPath(target: any, path: string, value: any): boolean;
+/**
+ * Delete the value at `path` within `target`. Sibling of `setByPath` —
+ * navigates the same tokenized path forms (numeric, bracket-by-_id, plain),
+ * but the final segment removes the property/element instead of setting it.
+ *
+ * Used by `save()`/`insert()`/`upsert()` to honor the convention that an
+ * `undefined` value in the caller's `update` means "delete this field".
+ *
+ * Behavior on the last segment:
+ *   - plain key:        `delete obj[key]`
+ *   - numeric `"<idx>"` on array: `arr.splice(idx, 1)` (removes element)
+ *   - bracket `"[<_id>]"` on array of `_id`-keyed objects: splice the
+ *     matching element
+ *
+ * Returns `true` if a delete actually occurred. `false` if traversal failed
+ * (path leads through a missing/non-object value) or the target segment
+ * doesn't exist — caller can ignore.
+ */
+export declare function deleteByPath(target: any, path: string): boolean;
 /**
  * Smart-merge a single (path, value) entry into an accumulated dirty changes
  * object. Resolves three relationships between the new path and existing keys:
@@ -49,6 +77,13 @@ export declare function tokenizePath(path: string): string[];
  *    new is "koraki.0.diag"): mutate the value inside the existing parent
  *    rather than adding a conflicting child path.
  *
+ *    SPECIAL CASES for terminal-bracket existing keys (whole-element ops):
+ *      a) existing value is `undefined` (REMOVE marker) → drop new sub-field
+ *         silently. Element is gone, sub-field write is moot.
+ *      b) existing value is `[element]` (INSERT wrapper) → navigate INTO the
+ *         wrapped element[0], not into the array itself. The pending insert
+ *         absorbs the sub-field edit.
+ *
  * 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.

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

@@ -0,0 +1,10 @@
+/**
+ * Walk `value` recursively without mutation. Return the dot/bracket
+ * notation paths of every property whose value is `undefined`.
+ *
+ * The original `value` (and all nested objects/arrays) is left intact —
+ * `undefined` values stay in place so that downstream code (computeDiff,
+ * dirty-change storage, REST upload via msgpackr) can carry them through
+ * to cry-db, which natively routes `key: undefined` → `$unset` server-side.
+ */
+export declare function collectUnsetPaths(value: any): string[];

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

@@ -1,7 +1,11 @@
 /**
- * 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).
+ * Pass-through: returns changes unchanged. Server-side cry-db v2.4.33+
+ * `_applyBracketProcessing` handles all bracket forms atomically:
+ *   - terminal `arr[<id>]` with array value → idempotent `$concatArrays + $filter`
+ *   - terminal `arr[<id>]` with `undefined` → `$pull`
+ *   - terminal `arr[<id>]` with object → arrayFilter `$set`
+ *   - sub-field `arr[<id>].field` → arrayFilter `$set` (position-independent)
+ *
+ * Signature kept (with `_entity` unused) for backward-compat with callers.
  */
-export declare function translateBracketPathsToIndex(changes: Record<string, any>, entity: any): Record<string, any>;
+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.159",
+  "version": "0.1.160",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -30,19 +30,19 @@
     "bson": "^7.2.0",
     "cry-ebus-proxy": "^1.0.3",
     "dexie": "^4.4.2",
-    "esbuild": "^0.27.4",
+    "esbuild": "^0.28.0",
     "fake-indexeddb": "^6.2.5",
     "typescript": "^6",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.5"
   },
   "dependencies": {
-    "cry-db": "^2.4.32",
-    "cry-helpers": "^2.1.193",
-    "msgpackr": "^1.11.9",
+    "cry-db": "^2.4.33",
+    "cry-helpers": "^2.1.194",
+    "msgpackr": "^2.0.1",
     "notepack": "^0.0.2",
     "notepack.io": "^3.0.1",
     "superjson": "^2.2.6",
-    "undici": "^7.24.6"
+    "undici": "^8.2.0"
   },
   "peerDependencies": {
     "bson": "^6.0.0 || ^7.0.0",