json-diff-ts 5.0.0-alpha.9 → 5.0.0

package/dist/index.cjs

@@ -58,6 +58,375 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/atomPath.ts
+function formatFilterLiteral(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`Cannot format non-finite number as filter literal: ${value}`);
+    return String(value);
+  }
+  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+  throw new Error(`Cannot format filter literal for type ${typeof value}`);
+}
+function parseFilterLiteral(s) {
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (s === "null") return null;
+  if (s.startsWith("'") && s.endsWith("'")) {
+    const [value, end] = extractQuotedString(s, 1);
+    if (end !== s.length - 1) throw new Error(`Invalid filter literal: ${s}`);
+    return value;
+  }
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+    const value = Number(s);
+    if (!Number.isFinite(value)) throw new Error(`Invalid non-finite filter literal: ${s}`);
+    return value;
+  }
+  throw new Error(`Invalid filter literal: ${s}`);
+}
+function extractQuotedString(s, start) {
+  const result = [];
+  let i = start;
+  while (i < s.length) {
+    if (s[i] === "'") {
+      if (i + 1 < s.length && s[i + 1] === "'") {
+        result.push("'");
+        i += 2;
+      } else {
+        return [result.join(""), i];
+      }
+    } else {
+      result.push(s[i]);
+      i += 1;
+    }
+  }
+  throw new Error("Unterminated quoted string");
+}
+function findFilterClose(s, from) {
+  let i = from;
+  while (i < s.length) {
+    if (s[i] === "'") {
+      i += 1;
+      while (i < s.length) {
+        if (s[i] === "'") {
+          if (i + 1 < s.length && s[i + 1] === "'") {
+            i += 2;
+          } else {
+            i += 1;
+            break;
+          }
+        } else {
+          i += 1;
+        }
+      }
+    } else if (s[i] === ")" && i + 1 < s.length && s[i + 1] === "]") {
+      return i;
+    } else {
+      i += 1;
+    }
+  }
+  return -1;
+}
+var NESTED_PATH_RE = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function parseFilter(inner) {
+  if (inner.startsWith("@==")) return { type: "valueFilter", value: parseFilterLiteral(inner.slice(3)) };
+  if (!inner.startsWith("@.") && !inner.startsWith("@['")) throw new Error(`Invalid filter expression: ${inner}`);
+  let quoted = false;
+  let eq = -1;
+  for (let i = 1; i < inner.length; i++) {
+    if (inner[i] === "'") {
+      if (quoted && inner[i + 1] === "'") {
+        i++;
+        continue;
+      }
+      quoted = !quoted;
+    } else if (!quoted && inner.slice(i, i + 2) === "==") {
+      eq = i;
+      break;
+    }
+  }
+  if (eq === -1) throw new Error(`Invalid filter: missing '==' in ${inner}`);
+  const access = inner.slice(1, eq);
+  let members;
+  try {
+    members = parseAtomPath("$" + access).slice(1);
+  } catch {
+    throw new Error(`Invalid property name in filter: ${inner}`);
+  }
+  if (!members.length || members.some((member) => member.type !== "property")) throw new Error(`Invalid property name in filter: ${inner}`);
+  const names = members.map((member) => member.name);
+  const property = names.join(".");
+  const value = parseFilterLiteral(inner.slice(eq + 2));
+  if (names.length === 1 && access.startsWith("[")) return { type: "keyFilter", property, value, literalKey: true };
+  if (names.some((name) => !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name))) return { type: "keyFilter", property, value, memberPath: names };
+  return { type: "keyFilter", property, value };
+}
+function parseAtomPath(path) {
+  if (!path.startsWith("$")) {
+    throw new Error(`Path must start with '$': ${path}`);
+  }
+  const segments = [{ type: "root" }];
+  let i = 1;
+  while (i < path.length) {
+    if (path[i] === ".") {
+      i += 1;
+      const start = i;
+      while (i < path.length && /[a-zA-Z0-9_]/.test(path[i])) {
+        i += 1;
+      }
+      if (i === start) throw new Error(`Empty property name at position ${i} in: ${path}`);
+      if (!/^[a-zA-Z_]/.test(path.slice(start, i))) throw new Error(`Invalid dot property in: ${path}`);
+      segments.push({ type: "property", name: path.slice(start, i) });
+    } else if (path[i] === "[") {
+      if (i + 1 >= path.length) throw new Error(`Unexpected end of path after '[': ${path}`);
+      if (path[i + 1] === "?") {
+        const closingIdx = findFilterClose(path, i + 2);
+        if (closingIdx === -1) throw new Error(`Unterminated filter expression in: ${path}`);
+        const inner = path.slice(i + 3, closingIdx);
+        segments.push(parseFilter(inner));
+        i = closingIdx + 2;
+      } else if (path[i + 1] === "'") {
+        const [key, endIdx] = extractQuotedString(path, i + 2);
+        if (path[endIdx + 1] !== "]") throw new Error(`Expected ']' after bracket property in: ${path}`);
+        segments.push({ type: "property", name: key });
+        i = endIdx + 2;
+      } else if (/\d/.test(path[i + 1])) {
+        const end = path.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated array index in: ${path}`);
+        const indexStr = path.slice(i + 1, end);
+        if (indexStr.length > 1 && indexStr[0] === "0") {
+          throw new Error(`Leading zeros not allowed in array index: [${indexStr}]`);
+        }
+        if (!/^(0|[1-9]\d*)$/.test(indexStr) || !Number.isSafeInteger(Number(indexStr))) {
+          throw new Error(`Invalid array index: [${indexStr}]`);
+        }
+        segments.push({ type: "index", index: Number(indexStr) });
+        i = end + 1;
+      } else {
+        throw new Error(`Unexpected character after '[': '${path[i + 1]}' in: ${path}`);
+      }
+    } else {
+      throw new Error(`Unexpected character '${path[i]}' at position ${i} in: ${path}`);
+    }
+  }
+  return segments;
+}
+var SIMPLE_PROPERTY_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function formatMemberAccess(name) {
+  if (SIMPLE_PROPERTY_RE.test(name)) {
+    return `.${name}`;
+  }
+  return `['${name.replace(/'/g, "''")}']`;
+}
+function buildAtomPath(segments) {
+  let result = "";
+  for (const seg of segments) {
+    switch (seg.type) {
+      case "root":
+        result += "$";
+        break;
+      case "property":
+        result += formatMemberAccess(seg.name);
+        break;
+      case "index":
+        result += `[${seg.index}]`;
+        break;
+      case "keyFilter": {
+        let memberAccess;
+        if (seg.memberPath) {
+          memberAccess = seg.memberPath.map(formatMemberAccess).join("");
+        } else if (seg.literalKey) {
+          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
+        } else if (NESTED_PATH_RE.test(seg.property)) {
+          memberAccess = `.${seg.property}`;
+        } else {
+          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
+        }
+        result += `[?(@${memberAccess}==${formatFilterLiteral(seg.value)})]`;
+        break;
+      }
+      case "valueFilter":
+        result += `[?(@==${formatFilterLiteral(seg.value)})]`;
+        break;
+    }
+  }
+  return result;
+}
+function normalizeLegacyFilterOperator(inner) {
+  let quoted = false;
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === "'") {
+      if (quoted && inner[i + 1] === "'") {
+        i++;
+        continue;
+      }
+      quoted = !quoted;
+    } else if (inner[i] === "=" && !quoted) {
+      let end = i + 1;
+      while (inner[end] === "=") end++;
+      inner = inner.slice(0, i) + "==" + inner.slice(end);
+      break;
+    }
+  }
+  return inner;
+}
+function canonicalizeFilterForAtom(inner) {
+  inner = normalizeLegacyFilterOperator(inner);
+  if (inner.startsWith("@.")) {
+    const eqIdx = inner.indexOf("==");
+    if (eqIdx === -1) return `[?(${inner})]`;
+    const key = inner.slice(2, eqIdx);
+    const valuePart = inner.slice(eqIdx);
+    if (NESTED_PATH_RE.test(key)) {
+      return `[?(@.${key}${valuePart})]`;
+    }
+    return `[?(@['${key.replace(/'/g, "''")}']${valuePart})]`;
+  }
+  return `[?(${inner})]`;
+}
+function canonicalizeFilterForV4(inner) {
+  if (inner.startsWith("@['")) {
+    const [key, endIdx] = extractQuotedString(inner, 3);
+    const rest = inner.slice(endIdx + 2);
+    if (rest.startsWith("==")) {
+      const literal = rest.slice(2);
+      const normalizedLiteral = normalizeToStringQuoted(literal);
+      return `[?(@['${key.replace(/'/g, "''")}']==${normalizedLiteral})]`;
+    }
+    return `[?(${inner})]`;
+  }
+  return normalizeFilterToStringLiterals(`[?(${inner})]`);
+}
+function normalizeToStringQuoted(literal) {
+  if (literal.startsWith("'") && literal.endsWith("'")) {
+    return literal;
+  }
+  const value = parseFilterLiteral(literal);
+  const stringValue = String(value).replace(/'/g, "''");
+  return `'${stringValue}'`;
+}
+function atomicPathToAtomPath(atomicPath) {
+  if (atomicPath === "$.$root") return "$";
+  if (atomicPath.startsWith("$.$root.") || atomicPath.startsWith("$.$root[")) {
+    atomicPath = "$" + atomicPath.slice(7);
+  }
+  if (!atomicPath.startsWith("$")) {
+    throw new Error(`Atomic path must start with '$': ${atomicPath}`);
+  }
+  let result = "$";
+  let i = 1;
+  while (i < atomicPath.length) {
+    if (atomicPath[i] === ".") {
+      i += 1;
+      const start = i;
+      while (i < atomicPath.length && atomicPath[i] !== "." && atomicPath[i] !== "[") {
+        i += 1;
+      }
+      const name = atomicPath.slice(start, i);
+      result += formatMemberAccess(name);
+    } else if (atomicPath[i] === "[") {
+      if (atomicPath[i + 1] === "?") {
+        const closingIdx = findFilterClose(atomicPath, i + 2);
+        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomicPath}`);
+        const inner = atomicPath.slice(i + 3, closingIdx);
+        result += canonicalizeFilterForAtom(inner);
+        i = closingIdx + 2;
+      } else if (atomicPath[i + 1] === "'") {
+        const [key, endIdx] = extractQuotedString(atomicPath, i + 2);
+        if (atomicPath[endIdx + 1] !== "]") throw new Error(`Expected ']' in: ${atomicPath}`);
+        result += formatMemberAccess(key);
+        i = endIdx + 2;
+      } else if (/\d/.test(atomicPath[i + 1])) {
+        const end = atomicPath.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
+        result += atomicPath.slice(i, end + 1);
+        i = end + 1;
+      } else {
+        const end = atomicPath.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
+        const name = atomicPath.slice(i + 1, end);
+        result += `['${name.replace(/'/g, "''")}']`;
+        i = end + 1;
+      }
+    } else {
+      throw new Error(`Unexpected character '${atomicPath[i]}' in atomic path: ${atomicPath}`);
+    }
+  }
+  return result;
+}
+function atomPathToAtomicPath(atomPath) {
+  if (!atomPath.startsWith("$")) {
+    throw new Error(`Atom path must start with '$': ${atomPath}`);
+  }
+  if (atomPath === "$") {
+    return "$.$root";
+  }
+  let result = "$";
+  let i = 1;
+  while (i < atomPath.length) {
+    if (atomPath[i] === ".") {
+      i += 1;
+      const start = i;
+      while (i < atomPath.length && /[a-zA-Z0-9_]/.test(atomPath[i])) {
+        i += 1;
+      }
+      result += "." + atomPath.slice(start, i);
+    } else if (atomPath[i] === "[") {
+      if (atomPath[i + 1] === "?") {
+        const closingIdx = findFilterClose(atomPath, i + 2);
+        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomPath}`);
+        const inner = atomPath.slice(i + 3, closingIdx);
+        result += canonicalizeFilterForV4(inner);
+        i = closingIdx + 2;
+      } else if (atomPath[i + 1] === "'") {
+        const [key, endIdx] = extractQuotedString(atomPath, i + 2);
+        if (atomPath[endIdx + 1] !== "]") throw new Error(`Expected ']' in: ${atomPath}`);
+        result += key.includes(".") && !/[[\]'\\]/.test(key) && !/^\d/.test(key) ? `[${key}]` : `['${key.replace(/'/g, "''")}']`;
+        i = endIdx + 2;
+      } else if (/\d/.test(atomPath[i + 1])) {
+        const end = atomPath.indexOf("]", i);
+        if (end === -1) throw new Error(`Unterminated bracket in: ${atomPath}`);
+        result += atomPath.slice(i, end + 1);
+        i = end + 1;
+      } else {
+        throw new Error(`Unexpected character after '[' in: ${atomPath}`);
+      }
+    } else {
+      throw new Error(`Unexpected character '${atomPath[i]}' in atom path: ${atomPath}`);
+    }
+  }
+  return result;
+}
+function normalizeFilterToStringLiterals(filter) {
+  const eqIdx = filter.indexOf("==");
+  if (eqIdx === -1) return filter;
+  const literalStart = eqIdx + 2;
+  const literalEnd = filter.length - 2;
+  const literal = filter.slice(literalStart, literalEnd);
+  if (literal.startsWith("'") && literal.endsWith("'")) {
+    return filter;
+  }
+  const value = parseFilterLiteral(literal);
+  const stringValue = String(value).replace(/'/g, "''");
+  return filter.slice(0, literalStart) + `'${stringValue}'` + filter.slice(literalEnd);
+}
+function extractKeyFromAtomicPath(atomicPath) {
+  if (atomicPath === "$.$root") return "$root";
+  const last = parseAtomPath(atomicPathToAtomPath(atomicPath)).at(-1);
+  switch (last.type) {
+    case "property":
+      return last.name;
+    case "index":
+      return String(last.index);
+    case "keyFilter":
+    case "valueFilter":
+      return String(last.value);
+    default:
+      return atomicPath;
+  }
+}
+
 // src/helpers.ts
 function splitJSONPath(path) {
   const parts = [];
@@ -94,9 +463,11 @@ function arrayIntersection(first, second) {
   return first.filter((item) => secondSet.has(item));
 }
 function keyBy(arr, getKey2) {
-  const result = {};
+  const result = /* @__PURE__ */ Object.create(null);
   for (const [index, item] of Object.entries(arr)) {
-    result[String(getKey2(item, false, Number(index)))] = item;
+    const key = String(getKey2(item, false, Number(index)));
+    if (Object.prototype.hasOwnProperty.call(result, key)) throw new Error(`Duplicate array identity: ${key}`);
+    result[key] = item;
   }
   return result;
 }
@@ -122,7 +493,7 @@ var Operation = /* @__PURE__ */ ((Operation2) => {
 })(Operation || {});
 function diff(oldObj, newObj, options = {}) {
   let embeddedObjKeys = options.arrayIdentityKeys ?? options.embeddedObjKeys;
-  const { keysToSkip, treatTypeChangeAsReplace } = options;
+  const { keysToSkip, keysToInclude, treatTypeChangeAsReplace } = options;
   if (embeddedObjKeys instanceof Map) {
     embeddedObjKeys = new Map(
       Array.from(embeddedObjKeys.entries()).map(([key, value]) => [
@@ -138,6 +509,7 @@ function diff(oldObj, newObj, options = {}) {
   return compare(oldObj, newObj, [], [], {
     embeddedObjKeys,
     keysToSkip: keysToSkip ?? [],
+    keysToInclude,
     treatTypeChangeAsReplace: treatTypeChangeAsReplace ?? true
   });
 }
@@ -156,7 +528,7 @@ var applyChangeset = (obj, changeset) => {
 };
 var revertChangeset = (obj, changeset) => {
   if (changeset) {
-    changeset.reverse().forEach((change) => {
+    [...changeset].reverse().forEach((change) => {
       const { value, type } = change;
       if (!change.changes || value === null && type === "REMOVE" /* REMOVE */) {
         revertLeafChange(obj, change);
@@ -177,27 +549,16 @@ var atomizeChangeset = (obj, path = "$", embeddedKey, embeddedKeyIsPath) => {
       if (atomicChange) {
         return atomicChange;
       }
+      if (!obj.changes) {
+        return [{ ...obj, path, valueType: getTypeOfObj(obj.value) }];
+      }
     } else {
       path = append(path, obj.key);
     }
     return atomizeChangeset(obj.changes || obj, path, obj.embeddedKey, obj.embeddedKeyIsPath);
   } else {
     const valueType = getTypeOfObj(obj.value);
-    let finalPath = path;
-    if (!finalPath.endsWith(`[${obj.key}]`)) {
-      let endsWithFilterValue = false;
-      const filterEndIdx = path.lastIndexOf(")]");
-      if (filterEndIdx !== -1) {
-        const filterStartIdx = path.lastIndexOf("==", filterEndIdx);
-        if (filterStartIdx !== -1) {
-          const filterValue = path.slice(filterStartIdx + 2, filterEndIdx).replaceAll(/(^'|'$)/g, "");
-          endsWithFilterValue = filterValue === String(obj.key);
-        }
-      }
-      if (!endsWithFilterValue) {
-        finalPath = append(path, obj.key);
-      }
-    }
+    const finalPath = append(path, obj.key);
     return [
       {
         ...obj,
@@ -233,86 +594,33 @@ var handleArray = (obj, path, embeddedKey, embeddedKeyIsPath) => {
   return obj.reduce((memo, change) => [...memo, ...atomizeChangeset(change, path, embeddedKey, embeddedKeyIsPath)], []);
 };
 var unatomizeChangeset = (changes) => {
-  if (!Array.isArray(changes)) {
-    changes = [changes];
-  }
-  const changesArr = [];
-  changes.forEach((change) => {
-    const obj = {};
-    let ptr = obj;
-    const segments = splitJSONPath(change.path);
-    if (segments.length === 1) {
-      ptr.key = change.key;
-      ptr.type = change.type;
-      ptr.value = change.value;
-      ptr.oldValue = change.oldValue;
-      changesArr.push(ptr);
-    } else {
-      for (let i = 1; i < segments.length; i++) {
-        const segment = segments[i];
-        const result = /^([^[\]]+)\[\?\(@(?:\.?([^=[]*)|(?:\['([^']*(?:''[^']*)*)'\]))=+'([^']*(?:''[^']*)*)'\)\]$|^(.+)\[(\d+)\]$/.exec(segment);
-        if (result) {
-          let key;
-          let embeddedKey;
-          let arrKey;
-          let isPath;
-          if (result[1]) {
-            key = result[1];
-            embeddedKey = result[3]?.replace(/''/g, "'") || result[2] || "$value";
-            isPath = !result[3] && !!result[2] && result[2].includes(".") && NESTED_PATH_RE.test(result[2]) ? true : void 0;
-            arrKey = result[4]?.replace(/''/g, "'");
-          } else {
-            key = result[5];
-            embeddedKey = "$index";
-            arrKey = Number(result[6]);
-          }
-          if (i === segments.length - 1) {
-            ptr.key = key;
-            ptr.embeddedKey = embeddedKey;
-            if (isPath) ptr.embeddedKeyIsPath = true;
-            ptr.type = "UPDATE" /* UPDATE */;
-            ptr.changes = [
-              {
-                type: change.type,
-                key: arrKey,
-                value: change.value,
-                oldValue: change.oldValue
-              }
-            ];
-          } else {
-            ptr.key = key;
-            ptr.embeddedKey = embeddedKey;
-            if (isPath) ptr.embeddedKeyIsPath = true;
-            ptr.type = "UPDATE" /* UPDATE */;
-            const newPtr = {};
-            ptr.changes = [
-              {
-                type: "UPDATE" /* UPDATE */,
-                key: arrKey,
-                changes: [newPtr]
-              }
-            ];
-            ptr = newPtr;
-          }
-        } else {
-          if (i === segments.length - 1) {
-            ptr.key = segment;
-            ptr.type = change.type;
-            ptr.value = change.value;
-            ptr.oldValue = change.oldValue;
-          } else {
-            ptr.key = segment;
-            ptr.type = "UPDATE" /* UPDATE */;
-            const newPtr = {};
-            ptr.changes = [newPtr];
-            ptr = newPtr;
-          }
-        }
+  return (Array.isArray(changes) ? changes : [changes]).map((change) => {
+    const segments = parseAtomPath(atomicPathToAtomPath(change.path)).slice(1);
+    const buildChange = (key, offset) => {
+      const segment = segments[offset];
+      if (!segment) {
+        return { key, type: change.type, value: change.value, oldValue: change.oldValue };
       }
-      changesArr.push(obj);
-    }
+      if (segment.type === "property") {
+        return { key, type: "UPDATE" /* UPDATE */, changes: [buildChange(segment.name, offset + 1)] };
+      }
+      if (segment.type === "index" || segment.type === "keyFilter" || segment.type === "valueFilter") {
+        const embeddedKey = segment.type === "index" ? "$index" : segment.type === "valueFilter" ? "$value" : segment.property;
+        const childKey = segment.type === "index" ? String(segment.index) : String(segment.value);
+        const isPath = segment.type === "keyFilter" && !segment.literalKey && segment.property.includes(".");
+        return {
+          key,
+          type: "UPDATE" /* UPDATE */,
+          embeddedKey,
+          ...isPath ? { embeddedKeyIsPath: true } : {},
+          changes: [buildChange(childKey, offset + 1)]
+        };
+      }
+      throw new Error(`Unexpected root segment in: ${change.path}`);
+    };
+    const first = segments[0];
+    return first?.type === "property" ? buildChange(first.name, 1) : buildChange(first ? "$root" : change.key, 0);
   });
-  return changesArr;
 };
 var getTypeOfObj = (obj) => {
   if (obj === void 0) {
@@ -327,32 +635,15 @@ var getKey = (path) => {
   const left = path.at(-1);
   return left ?? "$root";
 };
+var shouldComparePath = (path, options) => {
+  if (options.keysToSkip?.some((skip) => path === skip || path.startsWith(skip + "."))) return false;
+  return options.keysToInclude === void 0 || options.keysToInclude.some(
+    (include) => path === "" || path === include || path.startsWith(include + ".") || include.startsWith(path + ".")
+  );
+};
 var compare = (oldObj, newObj, path, keyPath, options) => {
   let changes = [];
-  const currentPath = keyPath.join(".");
-  if (options.keysToSkip?.some((skipPath) => {
-    if (currentPath === skipPath) {
-      return true;
-    }
-    if (skipPath.includes(".") && skipPath.startsWith(currentPath + ".")) {
-      return false;
-    }
-    if (skipPath.includes(".")) {
-      const skipParts = skipPath.split(".");
-      const currentParts = currentPath.split(".");
-      if (currentParts.length >= skipParts.length) {
-        for (let i = 0; i < skipParts.length; i++) {
-          if (skipParts[i] !== currentParts[i]) {
-            return false;
-          }
-        }
-        return true;
-      }
-    }
-    return false;
-  })) {
-    return changes;
-  }
+  if (!shouldComparePath(keyPath.join("."), options)) return changes;
   const typeOfOldObj = getTypeOfObj(oldObj);
   const typeOfNewObj = getTypeOfObj(newObj);
   if (options.treatTypeChangeAsReplace && typeOfOldObj !== typeOfNewObj) {
@@ -440,6 +731,7 @@ var compareObject = (oldObj, newObj, path, keyPath, skipPath = false, options =
   for (k of intersectionKeys) {
     newPath = path.concat([k]);
     newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
+    if (!shouldComparePath(newKeyPath.join("."), options)) continue;
     const diffs = compare(oldObj[k], newObj[k], newPath, newKeyPath, options);
     if (diffs.length) {
       changes = changes.concat(diffs);
@@ -450,7 +742,7 @@ var compareObject = (oldObj, newObj, path, keyPath, skipPath = false, options =
     newPath = path.concat([k]);
     newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
     const currentPath = newKeyPath.join(".");
-    if (options.keysToSkip?.some((skipPath2) => currentPath === skipPath2 || currentPath.startsWith(skipPath2 + "."))) {
+    if (!shouldComparePath(currentPath, options)) {
       continue;
     }
     changes.push({
@@ -464,7 +756,7 @@ var compareObject = (oldObj, newObj, path, keyPath, skipPath = false, options =
     newPath = path.concat([k]);
     newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
     const currentPath = newKeyPath.join(".");
-    if (options.keysToSkip?.some((skipPath2) => currentPath === skipPath2 || currentPath.startsWith(skipPath2 + "."))) {
+    if (!shouldComparePath(currentPath, options)) {
       continue;
     }
     changes.push({
@@ -488,7 +780,7 @@ var compareArray = (oldObj, newObj, path, keyPath, options) => {
   if (diffs.length) {
     const resolvedKey = isFunctionKey ? uniqKey(newObj[0] ?? oldObj[0], true) : uniqKey;
     const sampleEl = newObj[0] ?? oldObj[0];
-    const isNestedPath = typeof resolvedKey === "string" && resolvedKey.includes(".") && NESTED_PATH_RE.test(resolvedKey) && (isFunctionKey || !(sampleEl != null && typeof sampleEl === "object" && resolvedKey in sampleEl));
+    const isNestedPath = typeof resolvedKey === "string" && resolvedKey.includes(".") && NESTED_PATH_RE2.test(resolvedKey) && (isFunctionKey || !(sampleEl != null && typeof sampleEl === "object" && resolvedKey in sampleEl));
     return [
       {
         type: "UPDATE" /* UPDATE */,
@@ -524,9 +816,10 @@ var getObjectKey = (embeddedObjKeys, keyPath) => {
   return void 0;
 };
 var convertArrayToObj = (arr, uniqKey) => {
-  let obj = {};
+  let obj = /* @__PURE__ */ Object.create(null);
   if (uniqKey === "$value") {
     arr.forEach((value) => {
+      if (Object.prototype.hasOwnProperty.call(obj, String(value))) throw new Error(`Duplicate array value identity: ${value}`);
       obj[value] = value;
     });
   } else if (uniqKey === "$index") {
@@ -535,7 +828,7 @@ var convertArrayToObj = (arr, uniqKey) => {
       obj[i] = value;
     }
   } else {
-    const maybeNestedPath = typeof uniqKey === "string" && uniqKey.includes(".") && NESTED_PATH_RE.test(uniqKey);
+    const maybeNestedPath = typeof uniqKey === "string" && uniqKey.includes(".") && NESTED_PATH_RE2.test(uniqKey);
     const keyFunction = typeof uniqKey === "string" ? maybeNestedPath ? (item) => item != null && typeof item === "object" && uniqKey in item ? item[uniqKey] : resolveProperty(item, uniqKey, true) : (item) => item[uniqKey] : uniqKey;
     obj = keyBy(arr, keyFunction);
   }
@@ -690,12 +983,23 @@ var revertLeafChange = (obj, change, embeddedKey = "$index", isPath) => {
     case "UPDATE" /* UPDATE */:
       return modifyKeyValue(obj, key, oldValue);
     case "REMOVE" /* REMOVE */:
-      return addKeyValue(obj, key, value);
+      return addKeyValue(obj, key, value, embeddedKey);
   }
 };
 var revertArrayChange = (arr, change) => {
-  for (const subchange of change.changes) {
-    if (subchange.value != null || subchange.type === "REMOVE" /* REMOVE */) {
+  let changes = change.changes;
+  if (change.embeddedKey === "$index") {
+    changes = [...changes].sort((a, b) => {
+      if (a.type === "ADD" /* ADD */ && b.type === "ADD" /* ADD */) {
+        return Number(b.key) - Number(a.key);
+      }
+      if (a.type === "ADD" /* ADD */) return -1;
+      if (b.type === "ADD" /* ADD */) return 1;
+      return Number(a.key) - Number(b.key);
+    });
+  }
+  for (const subchange of changes) {
+    if (!subchange.changes) {
       revertLeafChange(arr, subchange, change.embeddedKey, change.embeddedKeyIsPath);
     } else {
       let element;
@@ -727,14 +1031,17 @@ var revertBranchChange = (obj, change) => {
   }
 };
 function append(basePath, nextSegment) {
+  if (!nextSegment || /[[\]'\\]/.test(nextSegment) || /^\d/.test(nextSegment)) {
+    return `${basePath}['${nextSegment.replace(/'/g, "''")}']`;
+  }
   return nextSegment.includes(".") ? `${basePath}[${nextSegment}]` : `${basePath}.${nextSegment}`;
 }
 var IDENT_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var NESTED_PATH_RE = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-function filterExpression(basePath, filterKey, filterValue, isPath) {
-  const escapedValue = `'${filterValue.replace(/'/g, "''")}'`;
+var NESTED_PATH_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function filterExpression(basePath, filterKey, filterValue2, isPath) {
+  const escapedValue = `'${filterValue2.replace(/'/g, "''")}'`;
   let memberAccess;
-  if (isPath && NESTED_PATH_RE.test(filterKey)) {
+  if (isPath && NESTED_PATH_RE2.test(filterKey)) {
     memberAccess = "." + filterKey;
   } else if (IDENT_RE.test(filterKey)) {
     memberAccess = `.${filterKey}`;
@@ -838,394 +1145,169 @@ var comparisonToDict = (node) => {
       const obj = /* @__PURE__ */ Object.create(null);
       for (const [key, child] of Object.entries(
         node.value
-      )) {
-        if (child == null) continue;
-        obj[key] = comparisonToDict(child);
-      }
-      result.value = obj;
-    }
-  } else {
-    if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
-      result.value = node.value;
-    }
-    if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
-      result.oldValue = node.oldValue;
-    }
-  }
-  return result;
-};
-var IDENT_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var comparisonToFlatList = (node, options = {}) => {
-  const results = [];
-  flattenNode(node, "$", options.includeUnchanged ?? false, results);
-  return results;
-};
-function flattenNode(node, path, includeUnchanged, results) {
-  if (node.type === "CONTAINER" /* CONTAINER */) {
-    if (Array.isArray(node.value)) {
-      for (let i = 0; i < node.value.length; i++) {
-        const child = node.value[i];
-        if (child == null) continue;
-        flattenNode(child, `${path}[${i}]`, includeUnchanged, results);
-      }
-    } else if (node.value && typeof node.value === "object") {
-      for (const [key, child] of Object.entries(
-        node.value
-      )) {
-        if (child == null) continue;
-        const childPath = IDENT_RE2.test(key) ? `${path}.${key}` : `${path}['${key.replace(/'/g, "''")}']`;
-        flattenNode(child, childPath, includeUnchanged, results);
-      }
-    }
-    return;
-  }
-  if (node.type === "UNCHANGED" /* UNCHANGED */ && !includeUnchanged) {
-    return;
-  }
-  const entry = { path, type: node.type };
-  if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
-    entry.value = node.value;
-  }
-  if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
-    entry.oldValue = node.oldValue;
-  }
-  results.push(entry);
-}
-
-// src/atomPath.ts
-function formatFilterLiteral(value) {
-  if (value === null) return "null";
-  if (typeof value === "boolean") return String(value);
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new Error(`Cannot format non-finite number as filter literal: ${value}`);
-    return String(value);
-  }
-  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
-  throw new Error(`Cannot format filter literal for type ${typeof value}`);
-}
-function parseFilterLiteral(s) {
-  if (s === "true") return true;
-  if (s === "false") return false;
-  if (s === "null") return null;
-  if (s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1).replace(/''/g, "'");
-  }
-  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
-    return Number(s);
-  }
-  throw new Error(`Invalid filter literal: ${s}`);
-}
-function extractQuotedString(s, start) {
-  const result = [];
-  let i = start;
-  while (i < s.length) {
-    if (s[i] === "'") {
-      if (i + 1 < s.length && s[i + 1] === "'") {
-        result.push("'");
-        i += 2;
-      } else {
-        return [result.join(""), i];
-      }
-    } else {
-      result.push(s[i]);
-      i += 1;
-    }
-  }
-  throw new Error("Unterminated quoted string");
-}
-function findFilterClose(s, from) {
-  let i = from;
-  while (i < s.length) {
-    if (s[i] === "'") {
-      i += 1;
-      while (i < s.length) {
-        if (s[i] === "'") {
-          if (i + 1 < s.length && s[i + 1] === "'") {
-            i += 2;
-          } else {
-            i += 1;
-            break;
-          }
-        } else {
-          i += 1;
-        }
-      }
-    } else if (s[i] === ")" && i + 1 < s.length && s[i + 1] === "]") {
-      return i;
-    } else {
-      i += 1;
-    }
-  }
-  return -1;
-}
-var NESTED_PATH_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-function parseFilter(inner) {
-  if (inner.startsWith("@.")) {
-    const eq = inner.indexOf("==");
-    if (eq === -1) throw new Error(`Invalid filter: missing '==' in ${inner}`);
-    const key = inner.slice(2, eq);
-    if (!key || !NESTED_PATH_RE2.test(key)) {
-      throw new Error(`Invalid property name in filter: '${key}'. Use bracket notation for non-identifier keys: @['${key}']`);
-    }
-    return { type: "keyFilter", property: key, value: parseFilterLiteral(inner.slice(eq + 2)) };
-  }
-  if (inner.startsWith("@['")) {
-    const [key, endIdx] = extractQuotedString(inner, 3);
-    const valStart = endIdx + 4;
-    return { type: "keyFilter", property: key, value: parseFilterLiteral(inner.slice(valStart)), literalKey: true };
-  }
-  if (inner.startsWith("@==")) {
-    return { type: "valueFilter", value: parseFilterLiteral(inner.slice(3)) };
-  }
-  throw new Error(`Invalid filter expression: ${inner}`);
-}
-function parseAtomPath(path) {
-  if (!path.startsWith("$")) {
-    throw new Error(`Path must start with '$': ${path}`);
-  }
-  const segments = [{ type: "root" }];
-  let i = 1;
-  while (i < path.length) {
-    if (path[i] === ".") {
-      i += 1;
-      const start = i;
-      while (i < path.length && /[a-zA-Z0-9_]/.test(path[i])) {
-        i += 1;
-      }
-      if (i === start) throw new Error(`Empty property name at position ${i} in: ${path}`);
-      segments.push({ type: "property", name: path.slice(start, i) });
-    } else if (path[i] === "[") {
-      if (i + 1 >= path.length) throw new Error(`Unexpected end of path after '[': ${path}`);
-      if (path[i + 1] === "?") {
-        const closingIdx = findFilterClose(path, i + 2);
-        if (closingIdx === -1) throw new Error(`Unterminated filter expression in: ${path}`);
-        const inner = path.slice(i + 3, closingIdx);
-        segments.push(parseFilter(inner));
-        i = closingIdx + 2;
-      } else if (path[i + 1] === "'") {
-        const [key, endIdx] = extractQuotedString(path, i + 2);
-        if (path[endIdx + 1] !== "]") throw new Error(`Expected ']' after bracket property in: ${path}`);
-        segments.push({ type: "property", name: key });
-        i = endIdx + 2;
-      } else if (/\d/.test(path[i + 1])) {
-        const end = path.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated array index in: ${path}`);
-        const indexStr = path.slice(i + 1, end);
-        if (indexStr.length > 1 && indexStr[0] === "0") {
-          throw new Error(`Leading zeros not allowed in array index: [${indexStr}]`);
-        }
-        segments.push({ type: "index", index: Number(indexStr) });
-        i = end + 1;
-      } else {
-        throw new Error(`Unexpected character after '[': '${path[i + 1]}' in: ${path}`);
-      }
-    } else {
-      throw new Error(`Unexpected character '${path[i]}' at position ${i} in: ${path}`);
-    }
-  }
-  return segments;
-}
-var SIMPLE_PROPERTY_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function formatMemberAccess(name) {
-  if (SIMPLE_PROPERTY_RE.test(name)) {
-    return `.${name}`;
-  }
-  return `['${name.replace(/'/g, "''")}']`;
-}
-function buildAtomPath(segments) {
-  let result = "";
-  for (const seg of segments) {
-    switch (seg.type) {
-      case "root":
-        result += "$";
-        break;
-      case "property":
-        result += formatMemberAccess(seg.name);
-        break;
-      case "index":
-        result += `[${seg.index}]`;
-        break;
-      case "keyFilter": {
-        let memberAccess;
-        if (seg.literalKey) {
-          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
-        } else if (NESTED_PATH_RE2.test(seg.property)) {
-          memberAccess = `.${seg.property}`;
-        } else {
-          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
-        }
-        result += `[?(@${memberAccess}==${formatFilterLiteral(seg.value)})]`;
-        break;
+      )) {
+        if (child == null) continue;
+        obj[key] = comparisonToDict(child);
       }
-      case "valueFilter":
-        result += `[?(@==${formatFilterLiteral(seg.value)})]`;
-        break;
+      result.value = obj;
     }
-  }
-  return result;
-}
-function canonicalizeFilterForAtom(inner) {
-  if (inner.startsWith("@.")) {
-    const eqIdx = inner.indexOf("==");
-    if (eqIdx === -1) return `[?(${inner})]`;
-    const key = inner.slice(2, eqIdx);
-    const valuePart = inner.slice(eqIdx);
-    if (NESTED_PATH_RE2.test(key)) {
-      return `[?(@.${key}${valuePart})]`;
+  } else {
+    if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
+      result.value = node.value;
     }
-    return `[?(@['${key.replace(/'/g, "''")}']${valuePart})]`;
-  }
-  return `[?(${inner})]`;
-}
-function canonicalizeFilterForV4(inner) {
-  if (inner.startsWith("@['")) {
-    const [key, endIdx] = extractQuotedString(inner, 3);
-    const rest = inner.slice(endIdx + 2);
-    if (rest.startsWith("==")) {
-      const literal = rest.slice(2);
-      const normalizedLiteral = normalizeToStringQuoted(literal);
-      return `[?(@.${key}==${normalizedLiteral})]`;
+    if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
+      result.oldValue = node.oldValue;
     }
-    return `[?(${inner})]`;
-  }
-  return normalizeFilterToStringLiterals(`[?(${inner})]`);
-}
-function normalizeToStringQuoted(literal) {
-  if (literal.startsWith("'") && literal.endsWith("'")) {
-    return literal;
-  }
-  const value = parseFilterLiteral(literal);
-  const stringValue = String(value).replace(/'/g, "''");
-  return `'${stringValue}'`;
-}
-function atomicPathToAtomPath(atomicPath) {
-  if (atomicPath === "$.$root") return "$";
-  if (atomicPath.startsWith("$.$root.")) return "$" + atomicPath.slice(7);
-  if (!atomicPath.startsWith("$")) {
-    throw new Error(`Atomic path must start with '$': ${atomicPath}`);
   }
-  let result = "$";
-  let i = 1;
-  while (i < atomicPath.length) {
-    if (atomicPath[i] === ".") {
-      i += 1;
-      const start = i;
-      while (i < atomicPath.length && atomicPath[i] !== "." && atomicPath[i] !== "[") {
-        i += 1;
+  return result;
+};
+var IDENT_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var comparisonToFlatList = (node, options = {}) => {
+  const results = [];
+  flattenNode(node, "$", options.includeUnchanged ?? false, results);
+  return results;
+};
+function flattenNode(node, path, includeUnchanged, results) {
+  if (node.type === "CONTAINER" /* CONTAINER */) {
+    if (Array.isArray(node.value)) {
+      for (let i = 0; i < node.value.length; i++) {
+        const child = node.value[i];
+        if (child == null) continue;
+        flattenNode(child, `${path}[${i}]`, includeUnchanged, results);
       }
-      const name = atomicPath.slice(start, i);
-      result += formatMemberAccess(name);
-    } else if (atomicPath[i] === "[") {
-      if (atomicPath[i + 1] === "?") {
-        const closingIdx = findFilterClose(atomicPath, i + 2);
-        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomicPath}`);
-        const inner = atomicPath.slice(i + 3, closingIdx);
-        result += canonicalizeFilterForAtom(inner);
-        i = closingIdx + 2;
-      } else if (atomicPath[i + 1] === "'" || /\d/.test(atomicPath[i + 1])) {
-        const end = atomicPath.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
-        result += atomicPath.slice(i, end + 1);
-        i = end + 1;
-      } else {
-        const end = atomicPath.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated bracket in: ${atomicPath}`);
-        const name = atomicPath.slice(i + 1, end);
-        result += `['${name.replace(/'/g, "''")}']`;
-        i = end + 1;
+    } else if (node.value && typeof node.value === "object") {
+      for (const [key, child] of Object.entries(
+        node.value
+      )) {
+        if (child == null) continue;
+        const childPath = IDENT_RE2.test(key) ? `${path}.${key}` : `${path}['${key.replace(/'/g, "''")}']`;
+        flattenNode(child, childPath, includeUnchanged, results);
       }
-    } else {
-      throw new Error(`Unexpected character '${atomicPath[i]}' in atomic path: ${atomicPath}`);
     }
+    return;
   }
-  return result;
-}
-function atomPathToAtomicPath(atomPath) {
-  if (!atomPath.startsWith("$")) {
-    throw new Error(`Atom path must start with '$': ${atomPath}`);
+  if (node.type === "UNCHANGED" /* UNCHANGED */ && !includeUnchanged) {
+    return;
   }
-  if (atomPath === "$") {
-    return "$.$root";
+  const entry = { path, type: node.type };
+  if (node.type === "UNCHANGED" /* UNCHANGED */ || node.type === "ADD" /* ADD */ || node.type === "UPDATE" /* UPDATE */) {
+    entry.value = node.value;
   }
-  let result = "$";
-  let i = 1;
-  while (i < atomPath.length) {
-    if (atomPath[i] === ".") {
-      i += 1;
-      const start = i;
-      while (i < atomPath.length && /[a-zA-Z0-9_]/.test(atomPath[i])) {
-        i += 1;
-      }
-      result += "." + atomPath.slice(start, i);
-    } else if (atomPath[i] === "[") {
-      if (atomPath[i + 1] === "?") {
-        const closingIdx = findFilterClose(atomPath, i + 2);
-        if (closingIdx === -1) throw new Error(`Unterminated filter in: ${atomPath}`);
-        const inner = atomPath.slice(i + 3, closingIdx);
-        result += canonicalizeFilterForV4(inner);
-        i = closingIdx + 2;
-      } else if (atomPath[i + 1] === "'") {
-        const [key, endIdx] = extractQuotedString(atomPath, i + 2);
-        if (atomPath[endIdx + 1] !== "]") throw new Error(`Expected ']' in: ${atomPath}`);
-        result += `[${key}]`;
-        i = endIdx + 2;
-      } else if (/\d/.test(atomPath[i + 1])) {
-        const end = atomPath.indexOf("]", i);
-        if (end === -1) throw new Error(`Unterminated bracket in: ${atomPath}`);
-        result += atomPath.slice(i, end + 1);
-        i = end + 1;
-      } else {
-        throw new Error(`Unexpected character after '[' in: ${atomPath}`);
-      }
-    } else {
-      throw new Error(`Unexpected character '${atomPath[i]}' in atom path: ${atomPath}`);
-    }
+  if (node.type === "REMOVE" /* REMOVE */ || node.type === "UPDATE" /* UPDATE */) {
+    entry.oldValue = node.oldValue;
   }
-  return result;
+  results.push(entry);
 }
-function normalizeFilterToStringLiterals(filter) {
-  const eqIdx = filter.indexOf("==");
-  if (eqIdx === -1) return filter;
-  const literalStart = eqIdx + 2;
-  const literalEnd = filter.length - 2;
-  const literal = filter.slice(literalStart, literalEnd);
-  if (literal.startsWith("'") && literal.endsWith("'")) {
-    return filter;
+
+// src/atomValidation.ts
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || ancestors.has(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) return false;
+  if (Object.getOwnPropertySymbols(value).length) return false;
+  if (Array.isArray(value) && Object.keys(value).length !== value.length) return false;
+  ancestors.add(value);
+  const valid = Object.values(value).every((child) => isJsonValue(child, ancestors));
+  ancestors.delete(value);
+  return valid;
+}
+
+// src/atomApply.ts
+var owns = (obj, key) => obj !== null && typeof obj === "object" && Object.prototype.hasOwnProperty.call(obj, key);
+function filterValue(item, filter) {
+  if (filter.type === "valueFilter") return item;
+  const keys = filter.memberPath ?? (filter.literalKey ? [filter.property] : filter.property.split("."));
+  return keys.reduce((value, key) => owns(value, key) ? value[key] : void 0, item);
+}
+function locate(parent, segment, adding = false) {
+  if (segment.type === "property") {
+    if (parent === null || typeof parent !== "object" || Array.isArray(parent)) {
+      throw new Error(`Cannot access property '${segment.name}' on non-object`);
+    }
+    const exists = owns(parent, segment.name);
+    if (adding ? exists : !exists) throw new Error(`Property '${segment.name}' ${exists ? "already exists" : "does not exist"}`);
+    return segment.name;
+  }
+  if (!Array.isArray(parent)) {
+    const names = { index: "access index", keyFilter: "apply key filter", valueFilter: "apply value filter" };
+    throw new Error(`Cannot ${names[segment.type]} on non-array`);
+  }
+  if (segment.type === "index") {
+    const limit = adding ? parent.length : parent.length - 1;
+    if (segment.index > limit) throw new Error(`Array index ${segment.index} is out of bounds`);
+    return segment.index;
+  }
+  const matches = parent.flatMap((item, index) => filterValue(item, segment) === segment.value ? [index] : []);
+  if (matches.length > 1) throw new Error("Array filter matches multiple elements");
+  if (adding) {
+    if (matches.length) throw new Error("Array filter target already exists");
+    return parent.length;
+  }
+  if (!matches.length) throw new Error("Array filter does not match an element");
+  return matches[0];
+}
+function resolve(obj, segments) {
+  return segments.reduce((current, segment) => current[locate(current, segment)], obj);
+}
+function selectors(path) {
+  return parseAtomPath(path).slice(1);
+}
+function setOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function applyValue(obj, op) {
+  const segments = selectors(op.path);
+  if (segments.length === 0) {
+    if (op.op === "add" && obj !== null) throw new Error("Root add requires a null source");
+    if (op.op !== "add" && obj === null) throw new Error("Root remove/replace requires a non-null source");
+    if (op.op === "remove") return null;
+    const value = structuredClone(op.value);
+    if (op.op === "replace" && obj && value && typeof obj === "object" && typeof value === "object" && !Array.isArray(obj) && !Array.isArray(value)) {
+      for (const key2 of Object.keys(obj)) delete obj[key2];
+      for (const key2 of Object.keys(value)) setOwn(obj, key2, value[key2]);
+      return obj;
+    }
+    return value;
+  }
+  const last = segments.at(-1);
+  const parent = resolve(obj, segments.slice(0, -1));
+  const key = locate(parent, last, op.op === "add");
+  if (op.op !== "remove" && last.type === "keyFilter" && filterValue(op.value, last) !== last.value) {
+    throw new Error("Keyed-array value does not match its identity filter");
+  }
+  if (op.op === "add" && last.type === "valueFilter" && op.value !== last.value) {
+    throw new Error("Added value does not match its value filter");
+  }
+  if (op.op === "remove") {
+    if (Array.isArray(parent)) parent.splice(Number(key), 1);
+    else delete parent[key];
+  } else {
+    const value = structuredClone(op.value);
+    if (Array.isArray(parent) && op.op === "add") parent.splice(Number(key), 0, value);
+    else setOwn(parent, key, value);
   }
-  const value = parseFilterLiteral(literal);
-  const stringValue = String(value).replace(/'/g, "''");
-  return filter.slice(0, literalStart) + `'${stringValue}'` + filter.slice(literalEnd);
+  return obj;
 }
-function extractKeyFromAtomicPath(atomicPath) {
-  if (atomicPath === "$.$root") return "$root";
-  if (atomicPath.endsWith(")]")) {
-    const filterStart = atomicPath.lastIndexOf("[?(");
-    if (filterStart !== -1) {
-      const inner = atomicPath.slice(filterStart + 3, atomicPath.length - 2);
-      if (inner.startsWith("@==")) {
-        const val = parseFilterLiteral(inner.slice(3));
-        return String(val);
-      }
-      const eqIdx = inner.indexOf("==");
-      if (eqIdx !== -1) {
-        const val = parseFilterLiteral(inner.slice(eqIdx + 2));
-        return String(val);
+function applyAtomOperations(obj, atom) {
+  let result = obj;
+  for (const op of atom.operations) {
+    if (op.op === "move" || op.op === "copy") {
+      const value = resolve(result, selectors(op.from));
+      const add = { op: "add", path: op.path, value };
+      if (op.op === "move") {
+        const remove = { op: "remove", path: op.from };
+        const probe = applyValue(structuredClone(result), remove);
+        applyValue(probe, add);
+        result = applyValue(result, remove);
       }
+      result = applyValue(result, add);
+    } else {
+      result = applyValue(result, op);
     }
   }
-  if (atomicPath.endsWith("]")) {
-    const bracketStart = atomicPath.lastIndexOf("[");
-    if (bracketStart !== -1) {
-      const inner = atomicPath.slice(bracketStart + 1, atomicPath.length - 1);
-      if (/^\d+$/.test(inner)) return inner;
-      return inner;
-    }
-  }
-  const lastDot = atomicPath.lastIndexOf(".");
-  if (lastDot > 0) {
-    return atomicPath.slice(lastDot + 1);
-  }
-  return atomicPath;
+  return result;
 }
 
 // src/jsonAtom.ts
@@ -1238,8 +1320,8 @@ function validateAtom(atom) {
   if (d.format !== "json-atom") {
     errors.push(`Invalid or missing format: expected 'json-atom', got '${d.format}'`);
   }
-  if (typeof d.version !== "number") {
-    errors.push(`Missing or invalid version: expected number, got '${typeof d.version}'`);
+  if (d.version !== 1) {
+    errors.push(`Missing or invalid version: expected 1, got '${d.version}'`);
   }
   if (!Array.isArray(d.operations)) {
     errors.push("Missing or invalid operations: expected array");
@@ -1256,6 +1338,18 @@ function validateAtom(atom) {
       if (typeof op.path !== "string") {
         errors.push(`operations[${i}]: path must be a string`);
       }
+      for (const field of ["value", "oldValue"]) {
+        if (field in op && !isJsonValue(op[field])) errors.push(`operations[${i}]: ${field} must be a JSON value`);
+      }
+      for (const field of ["path", ...["move", "copy"].includes(op.op) ? ["from"] : []]) {
+        if (typeof op[field] === "string") {
+          try {
+            parseAtomPath(op[field]);
+          } catch (error) {
+            errors.push(`operations[${i}]: invalid ${field}: ${error.message}`);
+          }
+        }
+      }
       if (op.op === "add") {
         if (!("value" in op)) {
           errors.push(`operations[${i}]: add operation must have value`);
@@ -1280,11 +1374,13 @@ function validateAtom(atom) {
         if ("oldValue" in op) {
           errors.push(`operations[${i}]: move operation must not have oldValue`);
         }
-        if (typeof op.from === "string" && typeof op.path === "string") {
-          if (op.from === op.path) {
+        if (typeof op.from === "string" && typeof op.path === "string" && !errors.length) {
+          const from = buildAtomPath(parseAtomPath(op.from));
+          const path = buildAtomPath(parseAtomPath(op.path));
+          if (from === path) {
             errors.push(`operations[${i}]: move operation from must not equal path (self-move)`);
           }
-          if (op.from !== "$" && (op.path.startsWith(op.from + ".") || op.path.startsWith(op.from + "["))) {
+          if (path.startsWith(from + ".") || path.startsWith(from + "[")) {
             errors.push(`operations[${i}]: move operation path must not be a subtree of from`);
           }
         }
@@ -1309,11 +1405,16 @@ function diffAtom(oldObj, newObj, options = {}) {
   });
   const operations = [];
   walkChanges(changeset, "$", oldObj, newObj, operations, options);
-  return {
-    format: "json-atom",
-    version: 1,
-    operations
-  };
+  if (operations.length === 1 && operations[0].path === "$") {
+    if (oldObj === null && newObj !== null) operations[0] = { op: "add", path: "$", value: newObj };
+    if (newObj === null && oldObj !== null) {
+      operations[0] = { op: "remove", path: "$", ...options.reversible === false ? {} : { oldValue: oldObj } };
+    }
+  }
+  const atom = { format: "json-atom", version: 1, operations };
+  const validation = validateAtom(atom);
+  if (!validation.valid) throw new Error(`Cannot produce JSON Atom: ${validation.errors.join(", ")}`);
+  return atom;
 }
 function mergeTypeChangePairs(changes) {
   const result = [];
@@ -1334,6 +1435,7 @@ function mergeTypeChangePairs(changes) {
   }
   return result;
 }
+var NESTED_PATH_RE3 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
 var SIMPLE_PROPERTY_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 function appendCanonicalProperty(basePath, name) {
   if (SIMPLE_PROPERTY_RE2.test(name)) {
@@ -1344,47 +1446,51 @@ function appendCanonicalProperty(basePath, name) {
 function walkChanges(changes, basePath, oldCtx, newCtx, ops, options) {
   const merged = mergeTypeChangePairs(changes);
   for (const change of merged) {
+    const isRoot = change.key === "$root" && basePath === "$" && (oldCtx === null || newCtx === null || typeof oldCtx !== "object" || typeof newCtx !== "object" || Array.isArray(oldCtx) || Array.isArray(newCtx));
     if (change.isMergedReplace) {
       const mc = change;
-      const path = mc.key === "$root" ? "$" : appendCanonicalProperty(basePath, mc.key);
+      const path = isRoot ? "$" : appendCanonicalProperty(basePath, mc.key);
       const op = { op: "replace", path, value: mc.addValue };
       if (options.reversible !== false) {
         op.oldValue = mc.removeValue;
       }
       ops.push(op);
     } else if (change.changes) {
-      const childPath = change.key === "$root" ? "$" : appendCanonicalProperty(basePath, change.key);
-      const childOld = change.key === "$root" ? oldCtx : oldCtx?.[change.key];
-      const childNew = change.key === "$root" ? newCtx : newCtx?.[change.key];
+      const childPath = isRoot ? "$" : appendCanonicalProperty(basePath, change.key);
+      const childOld = isRoot ? oldCtx : oldCtx?.[change.key];
+      const childNew = isRoot ? newCtx : newCtx?.[change.key];
       if (change.embeddedKey) {
-        const orderedChildChanges = orderArrayChildChanges(change.changes, change.embeddedKey);
-        for (const childChange of orderedChildChanges) {
-          const filterPath = buildCanonicalFilterPath(
-            childPath,
-            change.embeddedKey,
-            childChange.key,
-            childOld,
-            childNew,
-            childChange,
-            change.embeddedKeyIsPath
-          );
-          if (childChange.changes) {
-            const oldEl = findElement(childOld, change.embeddedKey, childChange.key);
-            const newEl = findElement(childNew, change.embeddedKey, childChange.key);
-            walkChanges(childChange.changes, filterPath, oldEl, newEl, ops, options);
-          } else {
-            emitLeafOp(childChange, filterPath, ops, options);
-          }
-        }
+        walkArrayChanges(change, childPath, childOld, childNew, ops, options);
       } else {
         walkChanges(change.changes, childPath, childOld, childNew, ops, options);
       }
     } else {
-      const path = change.key === "$root" ? "$" : appendCanonicalProperty(basePath, change.key);
+      const path = isRoot ? "$" : appendCanonicalProperty(basePath, change.key);
       emitLeafOp(change, path, ops, options);
     }
   }
 }
+function walkArrayChanges(change, path, oldArr, newArr, ops, options) {
+  const ordered = orderArrayChildChanges(change.changes, change.embeddedKey);
+  for (const child of mergeTypeChangePairs(ordered)) {
+    const childPath = buildCanonicalFilterPath(path, change.embeddedKey, child.key, oldArr, newArr, child, change.embeddedKeyIsPath);
+    if (child.isMergedReplace) {
+      ops.push({
+        op: "replace",
+        path: childPath,
+        value: child.addValue,
+        ...options.reversible === false ? {} : { oldValue: child.removeValue }
+      });
+    } else if (child.changes) {
+      const oldEl = findElement(oldArr, change.embeddedKey, child.key, change.embeddedKeyIsPath);
+      const newEl = findElement(newArr, change.embeddedKey, child.key, change.embeddedKeyIsPath);
+      if (child.embeddedKey) walkArrayChanges(child, childPath, oldEl, newEl, ops, options);
+      else walkChanges(child.changes, childPath, oldEl, newEl, ops, options);
+    } else {
+      emitLeafOp(child, childPath, ops, options);
+    }
+  }
+}
 function orderArrayChildChanges(changes, embeddedKey) {
   if (embeddedKey !== "$index") {
     return changes;
@@ -1499,7 +1605,7 @@ function findActualValue(oldArr, newArr, stringKey, opType) {
   }
   return stringKey;
 }
-function findElement(arr, embeddedKey, changeKey) {
+function findElement(arr, embeddedKey, changeKey, isPath = false) {
   if (!arr || !Array.isArray(arr)) return void 0;
   if (embeddedKey === "$index") {
     return arr[Number(changeKey)];
@@ -1510,7 +1616,7 @@ function findElement(arr, embeddedKey, changeKey) {
   if (typeof embeddedKey === "function") {
     return arr.find((item) => String(embeddedKey(item)) === changeKey);
   }
-  return arr.find((item) => item && String(item[embeddedKey]) === changeKey);
+  return arr.find((item) => item && String(resolveNestedKey(item, embeddedKey, isPath)) === changeKey);
 }
 function resolveNestedKey(item, key, isPath) {
   if (isPath) {
@@ -1575,9 +1681,30 @@ function toAtom(changeset, options = {}) {
         throw new Error(`Unknown operation type: ${atom.type}`);
     }
   });
-  const operations = mergeConsecutiveOps(rawOps);
+  const operations = orderLegacyIndexRemoves(mergeConsecutiveOps(rawOps));
   return { format: "json-atom", version: 1, operations };
 }
+function orderLegacyIndexRemoves(operations) {
+  const groups = /* @__PURE__ */ new Map();
+  operations.forEach((operation, slot) => {
+    if (operation.op !== "remove") return;
+    const segments = parseAtomPath(operation.path);
+    const last = segments.at(-1);
+    if (last.type !== "index") return;
+    const parent = buildAtomPath(segments.slice(0, -1));
+    const group = groups.get(parent) ?? [];
+    group.push({ slot, index: last.index, operation });
+    groups.set(parent, group);
+  });
+  const result = [...operations];
+  for (const group of groups.values()) {
+    const ordered = [...group].sort((a, b) => b.index - a.index);
+    group.forEach((entry, index) => {
+      result[entry.slot] = ordered[index].operation;
+    });
+  }
+  return result;
+}
 function mergeConsecutiveOps(ops) {
   const result = [];
   let i = 0;
@@ -1670,8 +1797,13 @@ function invertAtom(atom) {
         return { op: "remove", path: op.path, oldValue: op.value, ...extensions };
       case "remove":
         return { op: "add", path: op.path, value: op.oldValue, ...extensions };
-      case "replace":
-        return { op: "replace", path: op.path, value: op.oldValue, oldValue: op.value, ...extensions };
+      case "replace": {
+        if (op.path === "$" && op.value === null) return { op: "add", path: "$", value: op.oldValue, ...extensions };
+        const segments = parseAtomPath(op.path);
+        const last = segments.at(-1);
+        if (last.type === "valueFilter") last.value = op.value;
+        return { op: "replace", path: buildAtomPath(segments), value: op.oldValue, oldValue: op.value, ...extensions };
+      }
       case "move":
         return { op: "move", from: op.path, path: op.from, ...extensions };
       case "copy":
@@ -1689,134 +1821,10 @@ function invertAtom(atom) {
   }
   return envelope;
 }
-var NESTED_PATH_RE3 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-function resolveValueAtPath(obj, atomPath) {
-  const segments = parseAtomPath(atomPath);
-  let current = obj;
-  for (const seg of segments) {
-    switch (seg.type) {
-      case "root":
-        break;
-      case "property":
-        if (current == null || typeof current !== "object") {
-          throw new Error(`Cannot access property '${seg.name}' on ${current === null ? "null" : typeof current} at path: ${atomPath}`);
-        }
-        current = current[seg.name];
-        break;
-      case "index":
-        if (!Array.isArray(current)) {
-          throw new Error(`Cannot access index ${seg.index} on non-array at path: ${atomPath}`);
-        }
-        current = current[seg.index];
-        break;
-      case "keyFilter": {
-        if (!Array.isArray(current)) {
-          throw new Error(`Cannot apply key filter on non-array at path: ${atomPath}`);
-        }
-        const prop = seg.property;
-        const isPath = !seg.literalKey && prop.includes(".") && NESTED_PATH_RE3.test(prop);
-        current = current.find((el) => {
-          const resolved = isPath ? prop.split(".").reduce((c, s) => c?.[s], el) : el[prop];
-          return JSON.stringify(resolved) === JSON.stringify(seg.value);
-        });
-        break;
-      }
-      case "valueFilter": {
-        if (!Array.isArray(current)) {
-          throw new Error(`Cannot apply value filter on non-array at path: ${atomPath}`);
-        }
-        current = current.find((el) => JSON.stringify(el) === JSON.stringify(seg.value));
-        break;
-      }
-    }
-  }
-  return current;
-}
 function applyAtom(obj, atom) {
   const validation = validateAtom(atom);
-  if (!validation.valid) {
-    throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
-  }
-  let result = obj;
-  for (const op of atom.operations) {
-    if (op.op === "move") {
-      const value = resolveValueAtPath(result, op.from);
-      const removeOp = { op: "remove", path: op.from, oldValue: value };
-      if (removeOp.path === "$") {
-        result = applyRootOp(result, removeOp);
-      } else {
-        const removeChange = atomOpToAtomicChange(removeOp);
-        applyChangeset(result, unatomizeChangeset([removeChange]));
-      }
-      const addOp = { op: "add", path: op.path, value };
-      if (addOp.path === "$") {
-        result = applyRootOp(result, addOp);
-      } else {
-        const addChange = atomOpToAtomicChange(addOp);
-        applyChangeset(result, unatomizeChangeset([addChange]));
-      }
-    } else if (op.op === "copy") {
-      const source = resolveValueAtPath(result, op.from);
-      const value = source === void 0 ? void 0 : JSON.parse(JSON.stringify(source));
-      const addOp = { op: "add", path: op.path, value };
-      if (addOp.path === "$") {
-        result = applyRootOp(result, addOp);
-      } else {
-        const addChange = atomOpToAtomicChange(addOp);
-        applyChangeset(result, unatomizeChangeset([addChange]));
-      }
-    } else if (op.path === "$") {
-      result = applyRootOp(result, op);
-    } else {
-      const atomicChange = atomOpToAtomicChange(op);
-      const miniChangeset = unatomizeChangeset([atomicChange]);
-      applyChangeset(result, miniChangeset);
-    }
-  }
-  return result;
-}
-function applyRootOp(obj, op) {
-  switch (op.op) {
-    case "add":
-      return op.value;
-    case "remove":
-      return null;
-    case "replace": {
-      if (typeof obj === "object" && obj !== null && !Array.isArray(obj) && typeof op.value === "object" && op.value !== null && !Array.isArray(op.value)) {
-        for (const key of Object.keys(obj)) {
-          delete obj[key];
-        }
-        Object.assign(obj, op.value);
-        return obj;
-      }
-      return op.value;
-    }
-    /* istanbul ignore next -- exhaustive switch */
-    default:
-      throw new Error(`Unknown operation: ${op.op}`);
-  }
-}
-function atomOpToAtomicChange(op) {
-  const atomicPath = atomPathToAtomicPath(op.path);
-  const key = extractKeyFromAtomicPath(atomicPath);
-  switch (op.op) {
-    case "add":
-      return { type: "ADD" /* ADD */, key, path: atomicPath, valueType: getValueType(op.value), value: op.value };
-    case "remove":
-      return { type: "REMOVE" /* REMOVE */, key, path: atomicPath, valueType: getValueType(op.oldValue), value: op.oldValue };
-    case "replace":
-      return {
-        type: "UPDATE" /* UPDATE */,
-        key,
-        path: atomicPath,
-        valueType: getValueType(op.value),
-        value: op.value,
-        oldValue: op.oldValue
-      };
-    /* istanbul ignore next -- exhaustive switch */
-    default:
-      throw new Error(`Unknown operation: ${op.op}`);
-  }
+  if (!validation.valid) throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
+  return applyAtomOperations(obj, atom);
 }
 function revertAtom(obj, atom) {
   const inverse = invertAtom(atom);
@@ -1824,10 +1832,11 @@ function revertAtom(obj, atom) {
 }
 
 // src/atomHelpers.ts
-var OP_SPEC_KEYS = /* @__PURE__ */ new Set(["op", "path", "value", "oldValue"]);
+var OP_SPEC_KEYS = /* @__PURE__ */ new Set(["op", "path", "from", "value", "oldValue"]);
 var ATOM_SPEC_KEYS = /* @__PURE__ */ new Set(["format", "version", "operations"]);
 function operationSpecDict(op) {
   const result = { op: op.op, path: op.path };
+  if ("from" in op) result.from = op.from;
   if ("value" in op) result.value = op.value;
   if ("oldValue" in op) result.oldValue = op.oldValue;
   return result;