state-sync-log 0.9.0 → 0.10.0

package/dist/state-sync-log.esm.mjs

@@ -1,28 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-function getFinalizedEpochAndCheckpoint(yCheckpoint) {
-  let maxEpoch = -1;
-  let best = null;
-  let bestTxCount = -1;
-  let bestClientId = "";
-  for (const [key, cp] of yCheckpoint.entries()) {
-    const { epoch, clientId } = parseCheckpointKey(key);
-    if (epoch > maxEpoch) {
-      maxEpoch = epoch;
-      best = cp;
-      bestTxCount = cp.txCount;
-      bestClientId = clientId;
-    } else if (epoch === maxEpoch) {
-      if (cp.txCount > bestTxCount || cp.txCount === bestTxCount && clientId < bestClientId) {
-        best = cp;
-        bestTxCount = cp.txCount;
-        bestClientId = clientId;
-      }
-    }
-  }
-  return { finalizedEpoch: maxEpoch, checkpoint: best };
-}
 class StateSyncLogError extends Error {
   constructor(msg) {
     super(msg);
@@ -32,88 +10,232 @@ class StateSyncLogError extends Error {
 function failure(message) {
   throw new StateSyncLogError(message);
 }
-function checkpointKeyDataToKey(data) {
-  return `${data.epoch};${data.txCount};${data.clientId}`;
+const PROXY_DRAFT = /* @__PURE__ */ Symbol.for("__CREATEOPS_PROXY_DRAFT__");
+var DraftType = /* @__PURE__ */ ((DraftType2) => {
+  DraftType2[DraftType2["Object"] = 0] = "Object";
+  DraftType2[DraftType2["Array"] = 1] = "Array";
+  return DraftType2;
+})(DraftType || {});
+function latest(proxyDraft) {
+  var _a;
+  return (_a = proxyDraft.copy) != null ? _a : proxyDraft.original;
 }
-function parseCheckpointKey(key) {
-  const i1 = key.indexOf(";");
-  const i2 = key.indexOf(";", i1 + 1);
-  if (i1 === -1 || i2 === -1) {
-    failure(`Malformed checkpoint key: ${key}`);
+function isDraft(target) {
+  return !!getProxyDraft(target);
+}
+function getProxyDraft(value) {
+  var _a;
+  if (typeof value !== "object" || value === null) return null;
+  return (_a = value[PROXY_DRAFT]) != null ? _a : null;
+}
+function getValue(value) {
+  var _a;
+  const proxyDraft = getProxyDraft(value);
+  return proxyDraft ? (_a = proxyDraft.copy) != null ? _a : proxyDraft.original : value;
+}
+function isDraftable(value) {
+  if (value === null || typeof value !== "object") return false;
+  return Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype;
+}
+function getType(target) {
+  return Array.isArray(target) ? DraftType.Array : DraftType.Object;
+}
+function get(target, key) {
+  return target[key];
+}
+function set(target, key, value) {
+  target[key] = value;
+}
+function has(target, key) {
+  return Object.hasOwn(target, key);
+}
+function peek(target, key) {
+  const state = getProxyDraft(target);
+  const source = state ? latest(state) : target;
+  return source[key];
+}
+function isEqual(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
   }
-  return {
-    epoch: Number.parseInt(key.substring(0, i1), 10),
-    txCount: Number.parseInt(key.substring(i1 + 1, i2), 10),
-    clientId: key.substring(i2 + 1)
-  };
+  return x !== x && y !== y;
 }
-function createCheckpoint(yTx, yCheckpoint, clientState, activeEpoch, currentState, myClientId) {
-  const { checkpoint: prevCP } = getFinalizedEpochAndCheckpoint(yCheckpoint);
-  const newWatermarks = prevCP ? { ...prevCP.watermarks } : {};
-  const sortedTxs = clientState.stateCalculator.getSortedTxs();
-  let endIndex = sortedTxs.length;
-  while (endIndex > 0 && sortedTxs[endIndex - 1].txTimestamp.epoch > activeEpoch) {
-    endIndex--;
+function revokeProxy(proxyDraft) {
+  if (!proxyDraft) return;
+  while (proxyDraft.finalities.revoke.length > 0) {
+    const revoke = proxyDraft.finalities.revoke.pop();
+    revoke();
   }
-  const activeTxs = sortedTxs.slice(0, endIndex);
-  if (activeTxs.length === 0) {
-    return;
+}
+function getPath(target, path = []) {
+  var _a;
+  if (Object.hasOwn(target, "key") && target.key !== void 0) {
+    const parentCopy = (_a = target.parent) == null ? void 0 : _a.copy;
+    if (parentCopy) {
+      const proxyDraft = getProxyDraft(get(parentCopy, target.key));
+      if (proxyDraft !== null && proxyDraft.original !== target.original) {
+        return null;
+      }
+    }
+    path.push(target.key);
   }
-  let minWallClock = Number.POSITIVE_INFINITY;
-  let txCount = 0;
-  for (const entry of activeTxs) {
-    const ts = entry.txTimestamp;
-    if (ts.wallClock < minWallClock) {
-      minWallClock = ts.wallClock;
+  if (target.parent) {
+    return getPath(target.parent, path);
+  }
+  path.reverse();
+  return path;
+}
+function getPathOrThrow(target) {
+  const path = getPath(target);
+  if (!path) {
+    throw failure("Cannot determine path for operation");
+  }
+  return path;
+}
+function getAllPathsForDraft(rootDraft, targetDraft) {
+  const result = [];
+  function search(current2, currentPath) {
+    if (current2 === targetDraft) {
+      result.push([...currentPath]);
     }
-    const newWm = newWatermarks[ts.clientId] ? { ...newWatermarks[ts.clientId] } : { maxClock: -1, maxWallClock: 0 };
-    if (ts.clock > newWm.maxClock) {
-      newWm.maxClock = ts.clock;
-      newWm.maxWallClock = ts.wallClock;
+    const source = latest(current2);
+    if (!source || typeof source !== "object") return;
+    const keys = Array.isArray(source) ? Array.from({ length: source.length }, (_, i) => i) : Object.keys(source);
+    for (const key of keys) {
+      const value = source[key];
+      const childDraft = getProxyDraft(value);
+      if (childDraft) {
+        search(childDraft, [...currentPath, key]);
+      }
     }
-    newWatermarks[ts.clientId] = newWm;
-    txCount++;
   }
-  for (const clientId in newWatermarks) {
-    if (minWallClock - newWatermarks[clientId].maxWallClock > clientState.retentionWindowMs) {
-      delete newWatermarks[clientId];
+  search(rootDraft, []);
+  return result;
+}
+function getDescriptor(target, key) {
+  if (key in target) {
+    let prototype = Reflect.getPrototypeOf(target);
+    while (prototype) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+      if (descriptor) return descriptor;
+      prototype = Reflect.getPrototypeOf(prototype);
     }
   }
-  const cpKey = checkpointKeyDataToKey({
-    epoch: activeEpoch,
-    txCount,
-    clientId: myClientId
-  });
-  yCheckpoint.set(cpKey, {
-    state: currentState,
-    // Responsibility for cloning is moved to the caller if needed
-    watermarks: newWatermarks,
-    txCount,
-    minWallClock
-  });
-  const keysToDelete = [];
-  for (const entry of activeTxs) {
-    yTx.delete(entry.txTimestampKey);
-    keysToDelete.push(entry.txTimestampKey);
+  return void 0;
+}
+const propIsEnum = Object.prototype.propertyIsEnumerable;
+function shallowCopy(original2) {
+  if (Array.isArray(original2)) {
+    return Array.prototype.concat.call(original2);
+  }
+  const copy = {};
+  for (const key of Object.keys(original2)) {
+    copy[key] = original2[key];
+  }
+  for (const key of Object.getOwnPropertySymbols(original2)) {
+    if (propIsEnum.call(original2, key)) {
+      copy[key] = original2[key];
+    }
   }
-  clientState.stateCalculator.removeTxs(keysToDelete);
+  return copy;
 }
-function pruneCheckpoints(yCheckpoint, finalizedEpoch) {
-  let canonicalKey = null;
-  let bestTxCount = -1;
-  for (const [key] of yCheckpoint.entries()) {
-    const { epoch, txCount } = parseCheckpointKey(key);
-    if (epoch === finalizedEpoch && txCount > bestTxCount) {
-      canonicalKey = key;
-      bestTxCount = txCount;
+function ensureShallowCopy(target) {
+  var _a;
+  if (target.copy) return;
+  target.copy = shallowCopy(target.original);
+  target.assignedMap = (_a = target.assignedMap) != null ? _a : /* @__PURE__ */ new Map();
+}
+function deepClone$1(target) {
+  if (!isDraftable(target)) {
+    return isDraft(target) ? getValue(target) : target;
+  }
+  if (Array.isArray(target)) {
+    return target.map(deepClone$1);
+  }
+  const copy = {};
+  for (const key in target) {
+    if (has(target, key)) {
+      copy[key] = deepClone$1(target[key]);
     }
   }
-  for (const key of yCheckpoint.keys()) {
-    if (key !== canonicalKey) {
-      yCheckpoint.delete(key);
+  return copy;
+}
+function markChanged(target) {
+  if (!target.operated) {
+    target.operated = true;
+    if (target.parent) {
+      markChanged(target.parent);
+    }
+  }
+}
+function forEach(target, callback) {
+  if (Array.isArray(target)) {
+    for (let i = 0; i < target.length; i++) {
+      callback(i, target[i], target);
+    }
+  } else {
+    for (const key of Reflect.ownKeys(target)) {
+      callback(key, target[key], target);
     }
   }
 }
+function handleValue(target, handledSet) {
+  if (!isDraftable(target) || isDraft(target) || handledSet.has(target) || Object.isFrozen(target)) {
+    return;
+  }
+  handledSet.add(target);
+  forEach(target, (key, value) => {
+    var _a;
+    if (isDraft(value)) {
+      const proxyDraft = getProxyDraft(value);
+      ensureShallowCopy(proxyDraft);
+      const updatedValue = ((_a = proxyDraft.assignedMap) == null ? void 0 : _a.size) || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+      set(target, key, updatedValue);
+    } else {
+      handleValue(value, handledSet);
+    }
+  });
+}
+function getCurrent(target) {
+  const proxyDraft = getProxyDraft(target);
+  if (!isDraftable(target)) return target;
+  if (proxyDraft && !proxyDraft.operated) {
+    return proxyDraft.original;
+  }
+  let currentValue;
+  function ensureShallowCopyLocal() {
+    currentValue = shallowCopy(target);
+  }
+  if (proxyDraft) {
+    proxyDraft.finalized = true;
+    try {
+      ensureShallowCopyLocal();
+    } finally {
+      proxyDraft.finalized = false;
+    }
+  } else {
+    currentValue = target;
+  }
+  forEach(currentValue, (key, value) => {
+    if (proxyDraft && isEqual(get(proxyDraft.original, key), value)) {
+      return;
+    }
+    const newValue = getCurrent(value);
+    if (newValue !== value) {
+      if (currentValue === target) {
+        ensureShallowCopyLocal();
+      }
+      set(currentValue, key, newValue);
+    }
+  });
+  return currentValue;
+}
+function current(target) {
+  if (!isDraft(target)) {
+    throw new Error(`current() is only used for Draft, parameter: ${target}`);
+  }
+  return getCurrent(target);
+}
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -381,6 +503,636 @@ function lazy(fn) {
     return value;
   };
 }
+function parseArrayIndex(key) {
+  const n = Number(key);
+  if (!Number.isInteger(n) || n < 0) {
+    return null;
+  }
+  return n;
+}
+function pushOp(proxyDraft, op) {
+  const rootDraft = proxyDraft.finalities.rootDraft;
+  if (!rootDraft) {
+    throw failure("rootDraft is not set - cannot emit op");
+  }
+  if (proxyDraft.aliasCount <= 1) {
+    proxyDraft.finalities.ops.push(op);
+    return;
+  }
+  const allPaths = getAllPathsForDraft(rootDraft, proxyDraft);
+  for (const path of allPaths) {
+    const adjustedOp = { ...op, path };
+    proxyDraft.finalities.ops.push(adjustedOp);
+  }
+}
+function incAliasCount(value) {
+  const draft = getProxyDraft(value);
+  if (draft) draft.aliasCount++;
+}
+function decAliasCount(value) {
+  const draft = getProxyDraft(value);
+  if (draft) draft.aliasCount--;
+}
+function normalizeIndex(index, len, defaultValue) {
+  if (index === void 0) return defaultValue;
+  return index < 0 ? Math.max(len + index, 0) : Math.min(index, len);
+}
+const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin"
+]);
+function createArrayMethodWrapper(proxyDraft, proxyRef, method) {
+  return function(...args) {
+    ensureShallowCopy(proxyDraft);
+    markChanged(proxyDraft);
+    const arr = proxyDraft.copy;
+    const originalLength = arr.length;
+    const proxy = proxyRef;
+    switch (method) {
+      case "push": {
+        for (const arg of args) {
+          incAliasCount(arg);
+        }
+        const result = arr.push(...args);
+        pushOp(proxyDraft, {
+          kind: "splice",
+          path: getPathOrThrow(proxyDraft),
+          index: originalLength,
+          deleteCount: 0,
+          inserts: args.map(deepClone$1)
+        });
+        return result;
+      }
+      case "pop": {
+        if (originalLength === 0) {
+          return arr.pop();
+        }
+        const returnValue = proxy[originalLength - 1];
+        decAliasCount(arr[originalLength - 1]);
+        arr.pop();
+        pushOp(proxyDraft, {
+          kind: "splice",
+          path: getPathOrThrow(proxyDraft),
+          index: originalLength - 1,
+          deleteCount: 1,
+          inserts: []
+        });
+        return returnValue;
+      }
+      case "shift": {
+        if (originalLength === 0) {
+          return arr.shift();
+        }
+        const returnValue = proxy[0];
+        decAliasCount(arr[0]);
+        arr.shift();
+        pushOp(proxyDraft, {
+          kind: "splice",
+          path: getPathOrThrow(proxyDraft),
+          index: 0,
+          deleteCount: 1,
+          inserts: []
+        });
+        return returnValue;
+      }
+      case "unshift": {
+        for (const arg of args) {
+          incAliasCount(arg);
+        }
+        const result = arr.unshift(...args);
+        pushOp(proxyDraft, {
+          kind: "splice",
+          path: getPathOrThrow(proxyDraft),
+          index: 0,
+          deleteCount: 0,
+          inserts: args.map(deepClone$1)
+        });
+        return result;
+      }
+      case "splice": {
+        const start = args[0];
+        const deleteCountArg = args[1];
+        const inserts = args.slice(2);
+        const index = start === void 0 ? 0 : start < 0 ? Math.max(originalLength + start, 0) : start;
+        const deleteCount = deleteCountArg != null ? deleteCountArg : originalLength - index;
+        const returnValues = [];
+        for (let i = 0; i < deleteCount && index + i < originalLength; i++) {
+          returnValues.push(proxy[index + i]);
+          decAliasCount(arr[index + i]);
+        }
+        for (const insert of inserts) {
+          incAliasCount(insert);
+        }
+        arr.splice(...args);
+        pushOp(proxyDraft, {
+          kind: "splice",
+          path: getPathOrThrow(proxyDraft),
+          index: start != null ? start : 0,
+          deleteCount: deleteCountArg != null ? deleteCountArg : originalLength,
+          inserts: inserts.map(deepClone$1)
+        });
+        return returnValues;
+      }
+      case "fill": {
+        const fillValue = args[0];
+        const startArg = args[1];
+        const endArg = args[2];
+        const len = originalLength;
+        const start = normalizeIndex(startArg, len, 0);
+        const end = normalizeIndex(endArg, len, len);
+        const fillCount = end - start;
+        if (fillCount > 0) {
+          const fillValues = Array(fillCount).fill(fillValue);
+          proxy.splice(start, fillCount, ...fillValues);
+        }
+        return proxy;
+      }
+      case "sort": {
+        const compareFn = args[0];
+        const sorted = [...arr].sort(compareFn);
+        if (originalLength > 0) {
+          proxy.splice(0, originalLength, ...sorted);
+        }
+        return proxy;
+      }
+      case "reverse": {
+        const reversed = [...arr].reverse();
+        if (originalLength > 0) {
+          proxy.splice(0, originalLength, ...reversed);
+        }
+        return proxy;
+      }
+      case "copyWithin": {
+        const targetArg = args[0];
+        const startArg = args[1];
+        const endArg = args[2];
+        const len = originalLength;
+        const targetIdx = normalizeIndex(targetArg, len, 0);
+        const startIdx = normalizeIndex(startArg, len, 0);
+        const endIdx = normalizeIndex(endArg, len, len);
+        const copyCount = Math.min(endIdx - startIdx, len - targetIdx);
+        if (copyCount > 0) {
+          const elementsToCopy = arr.slice(startIdx, startIdx + copyCount);
+          proxy.splice(targetIdx, copyCount, ...elementsToCopy);
+        }
+        return proxy;
+      }
+      default:
+        return arr[method](...args);
+    }
+  };
+}
+const proxyHandler = {
+  get(target, key, receiver) {
+    var _a, _b;
+    const copy = (_a = target.copy) == null ? void 0 : _a[key];
+    if (copy && target.finalities.draftsCache.has(copy)) {
+      return copy;
+    }
+    if (key === PROXY_DRAFT) return target;
+    const source = latest(target);
+    if (target.type === DraftType.Array && typeof key === "string" && MUTATING_ARRAY_METHODS.has(key)) {
+      const originalMethod = source[key];
+      if (typeof originalMethod === "function") {
+        return createArrayMethodWrapper(target, receiver, key);
+      }
+    }
+    if (!has(source, key)) {
+      const desc = getDescriptor(source, key);
+      return desc ? "value" in desc ? desc.value : (_b = desc.get) == null ? void 0 : _b.call(target.proxy) : void 0;
+    }
+    const value = source[key];
+    if (target.finalized || !isDraftable(value)) {
+      return value;
+    }
+    if (value === peek(target.original, key)) {
+      ensureShallowCopy(target);
+      const nestedKey = target.type === DraftType.Array ? Number(key) : key;
+      target.copy[key] = createDraft$1({
+        original: target.original[key],
+        parentDraft: target,
+        key: nestedKey,
+        finalities: target.finalities
+      });
+      return target.copy[key];
+    }
+    if (isDraft(value)) {
+      target.finalities.draftsCache.add(value);
+    }
+    return value;
+  },
+  set(target, key, value) {
+    var _a;
+    if (typeof key === "symbol") {
+      throw new Error(`Cannot set symbol properties on drafts`);
+    }
+    let opKey = key;
+    if (target.type === DraftType.Array) {
+      if (key === "length") {
+        opKey = "length";
+      } else {
+        const numKey = typeof key === "number" ? key : parseArrayIndex(key);
+        if (numKey === null) {
+          throw new Error(`Only supports setting array indices and the 'length' property.`);
+        }
+        opKey = numKey;
+        const source = latest(target);
+        if (numKey > source.length) {
+          throw new Error(
+            `Cannot create sparse array. Index ${numKey} is out of bounds for array of length ${source.length}.`
+          );
+        }
+      }
+    }
+    const desc = getDescriptor(latest(target), key);
+    if (desc == null ? void 0 : desc.set) {
+      desc.set.call(target.proxy, value);
+      return true;
+    }
+    const current2 = peek(latest(target), key);
+    const currentProxyDraft = getProxyDraft(current2);
+    if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
+      target.copy[key] = value;
+      target.assignedMap = (_a = target.assignedMap) != null ? _a : /* @__PURE__ */ new Map();
+      target.assignedMap.set(key, false);
+      return true;
+    }
+    if (isEqual(value, current2) && (value !== void 0 || has(target.original, key))) {
+      return true;
+    }
+    ensureShallowCopy(target);
+    markChanged(target);
+    if (has(target.original, key) && isEqual(value, target.original[key])) {
+      target.assignedMap.delete(key);
+    } else {
+      target.assignedMap.set(key, true);
+    }
+    const copy = target.copy;
+    decAliasCount(copy[key]);
+    incAliasCount(value);
+    copy[key] = value;
+    if (target.type === DraftType.Array && opKey === "length") {
+      const oldLength = target.original.length;
+      const newLength = value;
+      if (newLength !== oldLength) {
+        pushOp(target, {
+          kind: "set",
+          path: getPathOrThrow(target),
+          key: "length",
+          value: newLength
+        });
+      }
+    } else {
+      pushOp(target, {
+        kind: "set",
+        path: getPathOrThrow(target),
+        key: opKey,
+        value: deepClone$1(value)
+      });
+    }
+    return true;
+  },
+  has(target, key) {
+    return key in latest(target);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(latest(target));
+  },
+  getOwnPropertyDescriptor(target, key) {
+    const source = latest(target);
+    const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+    if (!descriptor) return descriptor;
+    return {
+      writable: true,
+      configurable: target.type !== DraftType.Array || key !== "length",
+      enumerable: descriptor.enumerable,
+      value: source[key]
+    };
+  },
+  getPrototypeOf(target) {
+    return Reflect.getPrototypeOf(target.original);
+  },
+  setPrototypeOf() {
+    throw new Error(`Cannot call 'setPrototypeOf()' on drafts`);
+  },
+  defineProperty() {
+    throw new Error(`Cannot call 'defineProperty()' on drafts`);
+  },
+  deleteProperty(target, key) {
+    var _a;
+    if (typeof key === "symbol") {
+      throw new Error(`Cannot delete symbol properties from drafts`);
+    }
+    if (target.type === DraftType.Array) {
+      return proxyHandler.set.call(this, target, key, void 0, target.proxy);
+    }
+    const current2 = peek(latest(target), key);
+    const existed = current2 !== void 0 || key in target.original;
+    if (existed) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap.set(key, false);
+      pushOp(target, {
+        kind: "delete",
+        path: getPathOrThrow(target),
+        key
+      });
+      const copy = target.copy;
+      decAliasCount(copy[key]);
+      delete copy[key];
+    } else {
+      target.assignedMap = (_a = target.assignedMap) != null ? _a : /* @__PURE__ */ new Map();
+      target.assignedMap.delete(key);
+    }
+    return true;
+  }
+};
+function createDraft$1(options) {
+  const { original: original2, parentDraft, key, finalities } = options;
+  const type = getType(original2);
+  const proxyDraft = {
+    type,
+    finalized: false,
+    parent: parentDraft != null ? parentDraft : null,
+    original: original2,
+    copy: null,
+    proxy: null,
+    finalities,
+    aliasCount: 1
+  };
+  if (key !== void 0 || "key" in options) {
+    proxyDraft.key = key;
+  }
+  const { proxy, revoke } = Proxy.revocable(
+    type === DraftType.Array ? Object.assign([], proxyDraft) : proxyDraft,
+    proxyHandler
+  );
+  finalities.revoke.push(revoke);
+  proxyDraft.proxy = proxy;
+  if (parentDraft) {
+    parentDraft.finalities.draft.push(() => {
+      const copy = parentDraft.copy;
+      if (!copy) return;
+      const draft = get(copy, key);
+      const childProxyDraft = getProxyDraft(draft);
+      if (childProxyDraft) {
+        let updatedValue = childProxyDraft.original;
+        if (childProxyDraft.operated) {
+          updatedValue = getValue(draft);
+        }
+        childProxyDraft.finalized = true;
+        set(copy, key, updatedValue);
+      }
+    });
+  }
+  return proxy;
+}
+function finalizeDraft(result, returnedValue) {
+  var _a;
+  const proxyDraft = getProxyDraft(result);
+  const hasReturnedValue = returnedValue.length > 0;
+  if (proxyDraft == null ? void 0 : proxyDraft.operated) {
+    while (proxyDraft.finalities.draft.length > 0) {
+      const finalize = proxyDraft.finalities.draft.pop();
+      finalize();
+    }
+    proxyDraft.finalized = true;
+  }
+  const state = hasReturnedValue ? returnedValue[0] : proxyDraft ? proxyDraft.operated ? proxyDraft.copy : proxyDraft.original : result;
+  if (proxyDraft && state && typeof state === "object") {
+    handleValue(state, proxyDraft.finalities.handledSet);
+  }
+  const ops = (_a = proxyDraft == null ? void 0 : proxyDraft.finalities.ops) != null ? _a : [];
+  if (proxyDraft) {
+    revokeProxy(proxyDraft);
+  }
+  return [state, ops];
+}
+function draftify(baseState) {
+  const finalities = {
+    draft: [],
+    revoke: [],
+    handledSet: /* @__PURE__ */ new WeakSet(),
+    draftsCache: /* @__PURE__ */ new WeakSet(),
+    ops: [],
+    rootDraft: null
+    // Will be set by createDraft
+  };
+  if (!isDraftable(baseState)) {
+    throw new Error(`createOps() only supports plain objects and arrays.`);
+  }
+  const draft = createDraft$1({
+    original: baseState,
+    parentDraft: null,
+    finalities
+  });
+  finalities.rootDraft = getProxyDraft(draft);
+  return [
+    draft,
+    (returnedValue = []) => {
+      return finalizeDraft(draft, returnedValue);
+    }
+  ];
+}
+function createOps(base, mutate) {
+  const state = isDraft(base) ? current(base) : base;
+  if (!isDraftable(state)) {
+    throw new Error(`createOps() only supports plain objects and arrays.`);
+  }
+  const [draft, finalize] = draftify(state);
+  let result;
+  try {
+    result = mutate(draft);
+  } catch (error) {
+    revokeProxy(getProxyDraft(draft));
+    throw error;
+  }
+  const proxyDraft = getProxyDraft(draft);
+  if (result !== void 0 && !isDraft(result)) {
+    if (!isEqual(result, draft) && proxyDraft.operated) {
+      throw new Error(
+        `Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`
+      );
+    }
+    if (result !== void 0) {
+      const [, ops2] = finalize([]);
+      return { nextState: result, ops: ops2 };
+    }
+  }
+  if (result === draft || result === void 0) {
+    const [nextState2, ops2] = finalize([]);
+    return { nextState: nextState2, ops: ops2 };
+  }
+  const returnedProxyDraft = getProxyDraft(result);
+  if (returnedProxyDraft) {
+    if (returnedProxyDraft.operated) {
+      throw new Error(`Cannot return a modified child draft.`);
+    }
+    const [, ops2] = finalize([]);
+    return { nextState: current(result), ops: ops2 };
+  }
+  const [nextState, ops] = finalize([]);
+  return { nextState, ops };
+}
+function original(target) {
+  const proxyDraft = getProxyDraft(target);
+  if (!proxyDraft) {
+    throw new Error(`original() is only used for a draft, parameter: ${target}`);
+  }
+  return proxyDraft.original;
+}
+function addToSet(draft, value) {
+  const proxyDraft = getProxyDraft(draft);
+  if (!proxyDraft) {
+    throw new Error(`addToSet() can only be used on draft arrays`);
+  }
+  ensureShallowCopy(proxyDraft);
+  markChanged(proxyDraft);
+  const arr = proxyDraft.copy;
+  if (arr.some((item) => item === value || deepEqual(item, value))) {
+    return;
+  }
+  arr.push(value);
+  pushOp(proxyDraft, {
+    kind: "addToSet",
+    path: getPathOrThrow(proxyDraft),
+    value: deepClone(value)
+  });
+}
+function deleteFromSet(draft, value) {
+  const proxyDraft = getProxyDraft(draft);
+  if (!proxyDraft) {
+    throw new Error(`deleteFromSet() can only be used on draft arrays`);
+  }
+  ensureShallowCopy(proxyDraft);
+  markChanged(proxyDraft);
+  const arr = proxyDraft.copy;
+  const hasValue = arr.some((item) => item === value || deepEqual(item, value));
+  if (!hasValue) {
+    return;
+  }
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (arr[i] === value || deepEqual(arr[i], value)) {
+      arr.splice(i, 1);
+    }
+  }
+  pushOp(proxyDraft, {
+    kind: "deleteFromSet",
+    path: getPathOrThrow(proxyDraft),
+    value: deepClone(value)
+  });
+}
+function getFinalizedEpochAndCheckpoint(yCheckpoint) {
+  let maxEpoch = -1;
+  let best = null;
+  let bestTxCount = -1;
+  let bestClientId = "";
+  for (const [key, cp] of yCheckpoint.entries()) {
+    const { epoch, clientId } = parseCheckpointKey(key);
+    if (epoch > maxEpoch) {
+      maxEpoch = epoch;
+      best = cp;
+      bestTxCount = cp.txCount;
+      bestClientId = clientId;
+    } else if (epoch === maxEpoch) {
+      if (cp.txCount > bestTxCount || cp.txCount === bestTxCount && clientId < bestClientId) {
+        best = cp;
+        bestTxCount = cp.txCount;
+        bestClientId = clientId;
+      }
+    }
+  }
+  return { finalizedEpoch: maxEpoch, checkpoint: best };
+}
+function checkpointKeyDataToKey(data) {
+  return `${data.epoch};${data.txCount};${data.clientId}`;
+}
+function parseCheckpointKey(key) {
+  const i1 = key.indexOf(";");
+  const i2 = key.indexOf(";", i1 + 1);
+  if (i1 === -1 || i2 === -1) {
+    failure(`Malformed checkpoint key: ${key}`);
+  }
+  return {
+    epoch: Number.parseInt(key.substring(0, i1), 10),
+    txCount: Number.parseInt(key.substring(i1 + 1, i2), 10),
+    clientId: key.substring(i2 + 1)
+  };
+}
+function createCheckpoint(yTx, yCheckpoint, clientState, activeEpoch, currentState, myClientId) {
+  const { checkpoint: prevCP } = getFinalizedEpochAndCheckpoint(yCheckpoint);
+  const newWatermarks = prevCP ? { ...prevCP.watermarks } : {};
+  const sortedTxs = clientState.stateCalculator.getSortedTxs();
+  let endIndex = sortedTxs.length;
+  while (endIndex > 0 && sortedTxs[endIndex - 1].txTimestamp.epoch > activeEpoch) {
+    endIndex--;
+  }
+  const activeTxs = sortedTxs.slice(0, endIndex);
+  if (activeTxs.length === 0) {
+    return;
+  }
+  let minWallClock = Number.POSITIVE_INFINITY;
+  let txCount = 0;
+  for (const entry of activeTxs) {
+    const ts = entry.txTimestamp;
+    if (ts.wallClock < minWallClock) {
+      minWallClock = ts.wallClock;
+    }
+    const newWm = newWatermarks[ts.clientId] ? { ...newWatermarks[ts.clientId] } : { maxClock: -1, maxWallClock: 0 };
+    if (ts.clock > newWm.maxClock) {
+      newWm.maxClock = ts.clock;
+      newWm.maxWallClock = ts.wallClock;
+    }
+    newWatermarks[ts.clientId] = newWm;
+    txCount++;
+  }
+  for (const clientId in newWatermarks) {
+    if (minWallClock - newWatermarks[clientId].maxWallClock > clientState.retentionWindowMs) {
+      delete newWatermarks[clientId];
+    }
+  }
+  const cpKey = checkpointKeyDataToKey({
+    epoch: activeEpoch,
+    txCount,
+    clientId: myClientId
+  });
+  yCheckpoint.set(cpKey, {
+    state: currentState,
+    // Responsibility for cloning is moved to the caller if needed
+    watermarks: newWatermarks,
+    txCount,
+    minWallClock
+  });
+  const keysToDelete = [];
+  for (const entry of activeTxs) {
+    yTx.delete(entry.txTimestampKey);
+    keysToDelete.push(entry.txTimestampKey);
+  }
+  clientState.stateCalculator.removeTxs(keysToDelete);
+}
+function pruneCheckpoints(yCheckpoint, finalizedEpoch) {
+  let canonicalKey = null;
+  let bestTxCount = -1;
+  for (const [key] of yCheckpoint.entries()) {
+    const { epoch, txCount } = parseCheckpointKey(key);
+    if (epoch === finalizedEpoch && txCount > bestTxCount) {
+      canonicalKey = key;
+      bestTxCount = txCount;
+    }
+  }
+  for (const key of yCheckpoint.keys()) {
+    if (key !== canonicalKey) {
+      yCheckpoint.delete(key);
+    }
+  }
+}
 function createDraft(base) {
   return {
     root: base,
@@ -419,46 +1171,62 @@ function ensureOwnedPath(ctx, path) {
   if (path.length === 0) {
     return ctx.root;
   }
-  let current = ctx.root;
+  let current2 = ctx.root;
   for (let i = 0; i < path.length; i++) {
     const segment = path[i];
     const isArrayIndex = typeof segment === "number";
     if (isArrayIndex) {
-      if (!Array.isArray(current)) {
+      if (!Array.isArray(current2)) {
         failure(`Expected array at path segment ${segment}`);
       }
-      if (segment < 0 || segment >= current.length) {
+      if (segment < 0 || segment >= current2.length) {
         failure(`Index ${segment} out of bounds`);
       }
     } else {
-      if (!isObject(current) || Array.isArray(current)) {
+      if (!isObject(current2) || Array.isArray(current2)) {
         failure(`Expected object at path segment "${segment}"`);
       }
-      if (!(segment in current)) {
+      if (!(segment in current2)) {
         failure(`Property "${segment}" does not exist`);
       }
     }
-    const child = current[segment];
+    const child = current2[segment];
     if (child === null || typeof child !== "object") {
       failure(`Cannot traverse through primitive at path segment ${segment}`);
     }
-    current = ensureOwned(ctx, current, segment, child);
+    current2 = ensureOwned(ctx, current2, segment, child);
   }
-  return current;
+  return current2;
 }
 function draftSet(ctx, path, key, value) {
   const container = ensureOwnedPath(ctx, path);
-  if (Array.isArray(container)) {
-    failure("set requires object container");
+  if (!isObject(container)) {
+    failure("set requires object or array container");
+  }
+  let finalKey = key;
+  if (Array.isArray(container) && typeof key === "string" && key !== "length") {
+    const numKey = parseArrayIndex(key);
+    if (numKey === null) {
+      failure(`Cannot set non-numeric property "${key}" on array`);
+    }
+    finalKey = numKey;
   }
-  container[key] = value;
+  container[finalKey] = value;
 }
 function draftDelete(ctx, path, key) {
   const container = ensureOwnedPath(ctx, path);
-  if (Array.isArray(container)) {
-    failure("delete requires object container");
+  if (!isObject(container)) {
+    failure("delete requires object or array container");
+  }
+  let finalKey = key;
+  if (Array.isArray(container) && typeof key === "string") {
+    const numKey = parseArrayIndex(key);
+    if (numKey === null) {
+      failure(`Cannot delete non-numeric property "${key}" from array`);
+    }
+    finalKey = numKey;
   }
-  delete container[key];
+  delete container[finalKey];
 }
 function draftSplice(ctx, path, index, deleteCount, inserts) {
   const container = ensureOwnedPath(ctx, path);
@@ -535,50 +1303,50 @@ function computeReconcileOps(currentState, targetState) {
   diffValue(currentState, targetState, [], ops);
   return ops;
 }
-function diffValue(current, target, path, ops) {
-  if (current === target) return;
-  const currentType = typeof current;
+function diffValue(current2, target, path, ops) {
+  if (current2 === target) return;
+  const currentType = typeof current2;
   const targetType = typeof target;
-  if (current === null || target === null || currentType !== "object" || targetType !== "object") {
+  if (current2 === null || target === null || currentType !== "object" || targetType !== "object") {
     emitReplace(path, target, ops);
     return;
   }
-  const currentIsArray = Array.isArray(current);
+  const currentIsArray = Array.isArray(current2);
   const targetIsArray = Array.isArray(target);
   if (currentIsArray !== targetIsArray) {
     emitReplace(path, target, ops);
     return;
   }
   if (currentIsArray) {
-    diffArray(current, target, path, ops);
+    diffArray(current2, target, path, ops);
   } else {
-    diffObject(current, target, path, ops);
+    diffObject(current2, target, path, ops);
   }
 }
-function diffObject(current, target, path, ops) {
-  for (const key in current) {
-    if (Object.hasOwn(current, key) && !Object.hasOwn(target, key)) {
+function diffObject(current2, target, path, ops) {
+  for (const key in current2) {
+    if (Object.hasOwn(current2, key) && !Object.hasOwn(target, key)) {
       ops.push({ kind: "delete", path, key });
     }
   }
   for (const key in target) {
     if (Object.hasOwn(target, key)) {
       const targetVal = target[key];
-      if (!Object.hasOwn(current, key)) {
+      if (!Object.hasOwn(current2, key)) {
         ops.push({ kind: "set", path, key, value: targetVal });
-      } else if (current[key] !== targetVal) {
-        diffValue(current[key], targetVal, [...path, key], ops);
+      } else if (current2[key] !== targetVal) {
+        diffValue(current2[key], targetVal, [...path, key], ops);
       }
     }
   }
 }
-function diffArray(current, target, path, ops) {
-  const currentLen = current.length;
+function diffArray(current2, target, path, ops) {
+  const currentLen = current2.length;
   const targetLen = target.length;
   const minLen = currentLen < targetLen ? currentLen : targetLen;
   for (let i = 0; i < minLen; i++) {
-    if (current[i] !== target[i]) {
-      diffValue(current[i], target[i], [...path, i], ops);
+    if (current2[i] !== target[i]) {
+      diffValue(current2[i], target[i], [...path, i], ops);
     }
   }
   if (targetLen > currentLen) {
@@ -1254,43 +2022,61 @@ function createStateSyncLog(options) {
   };
 }
 function resolvePath(state, path) {
-  let current = state;
+  let current2 = state;
   for (const segment of path) {
     if (typeof segment === "string") {
-      if (!isObject(current) || Array.isArray(current)) {
+      if (!isObject(current2) || Array.isArray(current2)) {
         failure(`Expected object at path segment "${segment}"`);
       }
-      if (!(segment in current)) {
+      if (!(segment in current2)) {
         failure(`Property "${segment}" does not exist`);
       }
-      current = current[segment];
+      current2 = current2[segment];
     } else {
-      if (!Array.isArray(current)) {
+      if (!Array.isArray(current2)) {
         failure(`Expected array at path segment ${segment}`);
       }
-      if (segment < 0 || segment >= current.length) {
+      if (segment < 0 || segment >= current2.length) {
         failure(`Index ${segment} out of bounds`);
       }
-      current = current[segment];
+      current2 = current2[segment];
     }
   }
-  return current;
+  return current2;
 }
 function applyOp(state, op, cloneValues) {
   const container = resolvePath(state, op.path);
   switch (op.kind) {
-    case "set":
-      if (!isObject(container) || Array.isArray(container)) {
-        failure("set requires object container");
+    case "set": {
+      if (!isObject(container)) {
+        failure("set requires object or array container");
+      }
+      let key = op.key;
+      if (Array.isArray(container) && typeof key === "string" && key !== "length") {
+        const numKey = parseArrayIndex(key);
+        if (numKey === null) {
+          failure(`Cannot set non-numeric property "${key}" on array`);
+        }
+        key = numKey;
       }
-      container[op.key] = cloneValues ? deepClone(op.value) : op.value;
+      container[key] = cloneValues ? deepClone(op.value) : op.value;
       break;
-    case "delete":
-      if (!isObject(container) || Array.isArray(container)) {
-        failure("delete requires object container");
+    }
+    case "delete": {
+      if (!isObject(container)) {
+        failure("delete requires object or array container");
       }
-      delete container[op.key];
+      let key = op.key;
+      if (Array.isArray(container) && typeof key === "string") {
+        const numKey = parseArrayIndex(key);
+        if (numKey === null) {
+          failure(`Cannot delete non-numeric property "${key}" from array`);
+        }
+        key = numKey;
+      }
+      delete container[key];
       break;
+    }
     case "splice": {
       if (!Array.isArray(container)) {
         failure("splice requires array container");
@@ -1333,7 +2119,14 @@ function applyOps(ops, target, options) {
   }
 }
 export {
+  addToSet,
   applyOps,
-  createStateSyncLog
+  createOps,
+  createStateSyncLog,
+  current,
+  deleteFromSet,
+  isDraft,
+  isDraftable,
+  original
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"state-sync-log.esm.mjs","sources":["../src/checkpointUtils.ts","../src/error.ts","../src/checkpoints.ts","../../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js","../../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js","../../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.browser.js","../../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js","../src/utils.ts","../src/draft.ts","../src/reconcile.ts","../src/txTimestamp.ts","../src/SortedTxEntry.ts","../src/StateCalculator.ts","../src/clientState.ts","../src/txLog.ts","../src/createStateSyncLog.ts","../src/operations.ts"],"sourcesContent":["import * as Y from \"yjs\"\nimport { type CheckpointRecord, parseCheckpointKey } from \"./checkpoints\"\n\n/**\n * Determines the finalized epoch and its canonical checkpoint in a single pass.\n *\n * Policy A: The finalized epoch is the most recent epoch with a checkpoint.\n * Canonical checkpoint: The checkpoint with highest txCount for that epoch\n * (tie-break: lowest clientId alphabetically).\n *\n * Returns { finalizedEpoch: -1, checkpoint: null } if no checkpoints exist.\n */\nexport function getFinalizedEpochAndCheckpoint(yCheckpoint: Y.Map<CheckpointRecord>): {\n  finalizedEpoch: number\n  checkpoint: CheckpointRecord | null\n} {\n  let maxEpoch = -1\n  let best: CheckpointRecord | null = null\n  let bestTxCount = -1\n  let bestClientId = \"\"\n\n  for (const [key, cp] of yCheckpoint.entries()) {\n    const { epoch, clientId } = parseCheckpointKey(key)\n\n    if (epoch > maxEpoch) {\n      // New highest epoch - reset best checkpoint tracking\n      maxEpoch = epoch\n      best = cp\n      bestTxCount = cp.txCount\n      bestClientId = clientId\n    } else if (epoch === maxEpoch) {\n      // Same epoch - check if this is a better canonical checkpoint\n      // Primary: higher txCount wins\n      // Secondary (tie-break): lower clientId (alphabetically) wins\n      if (cp.txCount > bestTxCount || (cp.txCount === bestTxCount && clientId < bestClientId)) {\n        best = cp\n        bestTxCount = cp.txCount\n        bestClientId = clientId\n      }\n    }\n  }\n\n  return { finalizedEpoch: maxEpoch, checkpoint: best }\n}\n","export class StateSyncLogError extends Error {\n  constructor(msg: string) {\n    super(msg)\n\n    // Set the prototype explicitly for better instanceof support\n    Object.setPrototypeOf(this, StateSyncLogError.prototype)\n  }\n}\n\nexport function failure(message: string): never {\n  throw new StateSyncLogError(message)\n}\n","import * as Y from \"yjs\"\nimport { ClientId } from \"./ClientId\"\nimport { getFinalizedEpochAndCheckpoint } from \"./checkpointUtils\"\nimport { ClientState } from \"./clientState\"\nimport { failure } from \"./error\"\nimport { JSONObject } from \"./json\"\nimport { TxRecord } from \"./TxRecord\"\nimport { TxTimestampKey } from \"./txTimestamp\"\n\n/**\n * Watermarking for deduplication and pruning.\n * - maxClock: All txs from this client with clock <= maxClock are FINALIZED.\n * - maxWallClock: The last time we saw this client active (for pruning).\n */\ntype ClientWatermark = Readonly<{\n  maxClock: number\n  maxWallClock: number\n}>\n\n/**\n * Watermarks for all clients.\n */\nexport type ClientWatermarks = Record<ClientId, ClientWatermark>\n\n/**\n * A snapshot of the state at the end of a specific epoch.\n */\nexport type CheckpointRecord = {\n  state: JSONObject // The document state\n  watermarks: ClientWatermarks // Dedup/Pruning info\n  txCount: number // Tie-breaker for canonical selection\n  minWallClock: number // Reference time for this epoch (deterministic pruning)\n}\n\n/**\n * Unique ID for a checkpoint.\n * Format: `${epoch};${txCount};${clientId}`\n */\nexport type CheckpointKey = string\n\n/**\n * Data extracted from a checkpoint key.\n */\nexport type CheckpointKeyData = {\n  epoch: number\n  txCount: number\n  clientId: ClientId\n}\n\n/**\n * Converts checkpoint key data components to a key string.\n */\nfunction checkpointKeyDataToKey(data: CheckpointKeyData): CheckpointKey {\n  return `${data.epoch};${data.txCount};${data.clientId}`\n}\n\n/**\n * Helper to parse checkpoint keys.\n * Checkpoint keys have format: `${epoch};${txCount};${clientId}`\n * Throws if key is malformed.\n */\nexport function parseCheckpointKey(key: CheckpointKey): CheckpointKeyData {\n  const i1 = key.indexOf(\";\")\n  const i2 = key.indexOf(\";\", i1 + 1)\n\n  if (i1 === -1 || i2 === -1) {\n    failure(`Malformed checkpoint key: ${key}`)\n  }\n\n  return {\n    epoch: Number.parseInt(key.substring(0, i1), 10),\n    txCount: Number.parseInt(key.substring(i1 + 1, i2), 10),\n    clientId: key.substring(i2 + 1),\n  }\n}\n\n/**\n * Called periodically (e.g. by a server or leader client) to finalize the epoch.\n */\nexport function createCheckpoint(\n  yTx: Y.Map<TxRecord>,\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  clientState: ClientState,\n  activeEpoch: number,\n  currentState: JSONObject,\n  myClientId: string\n): void {\n  // 1. Start with previous watermarks (from finalized epoch = activeEpoch - 1)\n  const { checkpoint: prevCP } = getFinalizedEpochAndCheckpoint(yCheckpoint)\n  const newWatermarks = prevCP ? { ...prevCP.watermarks } : {}\n\n  // Get active txs using cached sorted order (filter by epoch)\n  // FILTER IS REQUIRED:\n  // Although we are finalizing 'activeEpoch', other peers may have already\n  // advanced to the next epoch and started syncing those txs.\n  // We must ensure this checkpoint ONLY contains txs from 'activeEpoch'.\n  // Using stateCalculator.getSortedTxs avoids redundant key parsing (timestamps are cached).\n  //\n  // OPTIMIZATION: Since sortedTxs is sorted by epoch (primary key) and past epochs\n  // are pruned, we only need to find the right boundary. Future epochs are rare,\n  // so a simple linear search from the right is efficient (typically 0-1 iterations).\n  const sortedTxs = clientState.stateCalculator.getSortedTxs()\n\n  // Find end boundary by searching from right (skip any future epoch entries)\n  let endIndex = sortedTxs.length\n  while (endIndex > 0 && sortedTxs[endIndex - 1].txTimestamp.epoch > activeEpoch) {\n    endIndex--\n  }\n\n  // Slice from start to endIndex (past epochs are pruned, so these are all activeEpoch)\n  const activeTxs = sortedTxs.slice(0, endIndex)\n\n  if (activeTxs.length === 0) {\n    return // Do nothing if no txs (prevents empty epochs)\n  }\n\n  // 2. Update watermarks based on OBSERVED active txs and calculate minWallClock\n  // NOTE: We cannot use activeTxs[0].txTimestamp.wallClock for minWallClock because\n  // txs are sorted by Lamport clock (epoch → clock → clientId), not by wallClock.\n  // A client may have a high Lamport clock but early wallClock due to clock drift\n  // or receiving many messages before emitting.\n  let minWallClock = Number.POSITIVE_INFINITY\n  let txCount = 0\n  for (const entry of activeTxs) {\n    const ts = entry.txTimestamp\n\n    // Track min wallClock for deterministic pruning reference\n    if (ts.wallClock < minWallClock) {\n      minWallClock = ts.wallClock\n    }\n\n    const newWm = newWatermarks[ts.clientId]\n      ? { ...newWatermarks[ts.clientId] }\n      : { maxClock: -1, maxWallClock: 0 }\n\n    if (ts.clock > newWm.maxClock) {\n      newWm.maxClock = ts.clock\n      newWm.maxWallClock = ts.wallClock\n    }\n    newWatermarks[ts.clientId] = newWm\n    txCount++\n  }\n\n  // 3. Prune Inactive Watermarks (Deterministic)\n  // Uses minWallClock so all clients agree on exactly who to prune.\n  for (const clientId in newWatermarks) {\n    if (minWallClock - newWatermarks[clientId].maxWallClock > clientState.retentionWindowMs) {\n      delete newWatermarks[clientId]\n    }\n  }\n\n  // 4. Save Checkpoint\n  const cpKey = checkpointKeyDataToKey({\n    epoch: activeEpoch,\n    txCount,\n    clientId: myClientId,\n  })\n  yCheckpoint.set(cpKey, {\n    state: currentState, // Responsibility for cloning is moved to the caller if needed\n    watermarks: newWatermarks,\n    txCount,\n    minWallClock,\n  })\n\n  // 5. Early tx pruning (Optimization)\n  // Delete all txs from the now-finalized epoch\n  // This reduces memory pressure instead of waiting for cleanupLog\n  const keysToDelete: TxTimestampKey[] = []\n  for (const entry of activeTxs) {\n    yTx.delete(entry.txTimestampKey)\n    keysToDelete.push(entry.txTimestampKey)\n  }\n  clientState.stateCalculator.removeTxs(keysToDelete)\n}\n\n/**\n * Garbage collects old checkpoints.\n * Should be called periodically to prevent unbounded growth of yCheckpoint.\n *\n * Keeps only the canonical checkpoint for the finalized epoch.\n * Everything else is deleted (old epochs + non-canonical).\n *\n * Note: The active epoch never has checkpoints - creating a checkpoint\n * for an epoch immediately makes it finalized.\n */\nexport function pruneCheckpoints(\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  finalizedEpoch: number\n): void {\n  // Find the canonical checkpoint and its key in one pass\n  let canonicalKey: CheckpointKey | null = null\n  let bestTxCount = -1\n\n  for (const [key] of yCheckpoint.entries()) {\n    const { epoch, txCount } = parseCheckpointKey(key)\n    if (epoch === finalizedEpoch && txCount > bestTxCount) {\n      canonicalKey = key\n      bestTxCount = txCount\n    }\n  }\n\n  // Delete everything except the canonical checkpoint\n  for (const key of yCheckpoint.keys()) {\n    if (key !== canonicalKey) {\n      yCheckpoint.delete(key)\n    }\n  }\n}\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","export const urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n","/* @ts-self-types=\"./index.d.ts\" */\nimport { urlAlphabet as scopedUrlAlphabet } from './url-alphabet/index.js'\nexport { urlAlphabet } from './url-alphabet/index.js'\nexport let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))\nexport let customRandom = (alphabet, defaultSize, getRandom) => {\n  let mask = (2 << Math.log2(alphabet.length - 1)) - 1\n  let step = -~((1.6 * mask * defaultSize) / alphabet.length)\n  return (size = defaultSize) => {\n    let id = ''\n    while (true) {\n      let bytes = getRandom(step)\n      let j = step | 0\n      while (j--) {\n        id += alphabet[bytes[j] & mask] || ''\n        if (id.length >= size) return id\n      }\n    }\n  }\n}\nexport let customAlphabet = (alphabet, size = 21) =>\n  customRandom(alphabet, size | 0, random)\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)))\n  while (size--) {\n    id += scopedUrlAlphabet[bytes[size] & 63]\n  }\n  return id\n}\n","'use strict'\nmodule.exports = rfdc\n\nfunction copyBuffer (cur) {\n  if (cur instanceof Buffer) {\n    return Buffer.from(cur)\n  }\n\n  return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length)\n}\n\nfunction rfdc (opts) {\n  opts = opts || {}\n  if (opts.circles) return rfdcCircles(opts)\n\n  const constructorHandlers = new Map()\n  constructorHandlers.set(Date, (o) => new Date(o))\n  constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)))\n  constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)))\n  if (opts.constructorHandlers) {\n    for (const handler of opts.constructorHandlers) {\n      constructorHandlers.set(handler[0], handler[1])\n    }\n  }\n\n  let handler = null\n\n  return opts.proto ? cloneProto : clone\n\n  function cloneArray (a, fn) {\n    const keys = Object.keys(a)\n    const a2 = new Array(keys.length)\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i]\n      const cur = a[k]\n      if (typeof cur !== 'object' || cur === null) {\n        a2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        a2[k] = handler(cur, fn)\n      } else if (ArrayBuffer.isView(cur)) {\n        a2[k] = copyBuffer(cur)\n      } else {\n        a2[k] = fn(cur)\n      }\n    }\n    return a2\n  }\n\n  function clone (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, clone)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, clone)\n    }\n    const o2 = {}\n    for (const k in o) {\n      if (Object.hasOwnProperty.call(o, k) === false) continue\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, clone)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        o2[k] = clone(cur)\n      }\n    }\n    return o2\n  }\n\n  function cloneProto (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, cloneProto)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, cloneProto)\n    }\n    const o2 = {}\n    for (const k in o) {\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, cloneProto)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        o2[k] = cloneProto(cur)\n      }\n    }\n    return o2\n  }\n}\n\nfunction rfdcCircles (opts) {\n  const refs = []\n  const refsNew = []\n\n  const constructorHandlers = new Map()\n  constructorHandlers.set(Date, (o) => new Date(o))\n  constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)))\n  constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)))\n  if (opts.constructorHandlers) {\n    for (const handler of opts.constructorHandlers) {\n      constructorHandlers.set(handler[0], handler[1])\n    }\n  }\n\n  let handler = null\n  return opts.proto ? cloneProto : clone\n\n  function cloneArray (a, fn) {\n    const keys = Object.keys(a)\n    const a2 = new Array(keys.length)\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i]\n      const cur = a[k]\n      if (typeof cur !== 'object' || cur === null) {\n        a2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        a2[k] = handler(cur, fn)\n      } else if (ArrayBuffer.isView(cur)) {\n        a2[k] = copyBuffer(cur)\n      } else {\n        const index = refs.indexOf(cur)\n        if (index !== -1) {\n          a2[k] = refsNew[index]\n        } else {\n          a2[k] = fn(cur)\n        }\n      }\n    }\n    return a2\n  }\n\n  function clone (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, clone)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, clone)\n    }\n    const o2 = {}\n    refs.push(o)\n    refsNew.push(o2)\n    for (const k in o) {\n      if (Object.hasOwnProperty.call(o, k) === false) continue\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, clone)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        const i = refs.indexOf(cur)\n        if (i !== -1) {\n          o2[k] = refsNew[i]\n        } else {\n          o2[k] = clone(cur)\n        }\n      }\n    }\n    refs.pop()\n    refsNew.pop()\n    return o2\n  }\n\n  function cloneProto (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, cloneProto)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, cloneProto)\n    }\n    const o2 = {}\n    refs.push(o)\n    refsNew.push(o2)\n    for (const k in o) {\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, cloneProto)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        const i = refs.indexOf(cur)\n        if (i !== -1) {\n          o2[k] = refsNew[i]\n        } else {\n          o2[k] = cloneProto(cur)\n        }\n      }\n    }\n    refs.pop()\n    refsNew.pop()\n    return o2\n  }\n}\n","import equal from \"fast-deep-equal\"\nimport { nanoid } from \"nanoid\"\nimport rfdc from \"rfdc\"\nimport type { JSONValue } from \"./json\"\n\nconst clone = rfdc({ proto: true })\n\n/**\n * Deep equality check for JSONValues.\n * Used for addToSet / deleteFromSet operations.\n */\nexport function deepEqual(a: JSONValue, b: JSONValue): boolean {\n  return equal(a, b)\n}\n\n/**\n * Generates a unique ID using nanoid.\n */\nexport function generateID(): string {\n  return nanoid()\n}\n\n/**\n * Checks if a value is an object (typeof === \"object\" && !== null).\n */\nexport function isObject(value: unknown): value is object {\n  return value !== null && typeof value === \"object\"\n}\n\n/**\n * Deep clones a JSON-serializable value.\n * Optimized: primitives are returned as-is.\n */\nexport function deepClone<T>(value: T): T {\n  // Primitives don't need cloning\n  if (value === null || typeof value !== \"object\") {\n    return value\n  }\n  return clone(value)\n}\n\n/**\n * Creates a lazy memoized getter.\n */\nexport function lazy<T>(fn: () => T): () => T {\n  let computed = false\n  let value: T\n  return () => {\n    if (!computed) {\n      value = fn()\n      computed = true\n    }\n    return value\n  }\n}\n","import { failure } from \"./error\"\nimport type { JSONObject, JSONRecord, JSONValue, Path } from \"./json\"\nimport type { Op, ValidateFn } from \"./operations\"\nimport { TxRecord } from \"./TxRecord\"\nimport { deepEqual, isObject } from \"./utils\"\n\n/**\n * A draft context for copy-on-write immutable updates.\n *\n * This provides Immer/Mutative-like semantics without the proxy overhead:\n * - The original base state is never mutated\n * - Objects are cloned lazily on first mutation (copy-on-write)\n * - Once an object is cloned (\"owned\"), it can be mutated directly\n * - If no changes are made, the original reference is preserved (structural sharing)\n */\nexport interface DraftContext<T extends JSONObject> {\n  /** The current root (may be the original base or a cloned version) */\n  root: T\n  /** The original base state (never mutated) */\n  base: T\n  /** Set of objects that have been cloned and are safe to mutate */\n  ownedObjects: WeakSet<object>\n  /** Optimization: fast check if root is already owned */\n  isRootOwned: boolean\n}\n\n/**\n * Creates a new draft context from a base state.\n * The base state will never be mutated.\n */\nexport function createDraft<T extends JSONObject>(base: T): DraftContext<T> {\n  return {\n    root: base,\n    base,\n    ownedObjects: new Set(),\n    isRootOwned: false,\n  }\n}\n\n/**\n * Checks if the draft was modified (root !== base).\n */\nexport function isDraftModified<T extends JSONObject>(ctx: DraftContext<T>): boolean {\n  return ctx.root !== ctx.base\n}\n\nfunction shallowClone<T extends object>(obj: T): T {\n  if (Array.isArray(obj)) {\n    return obj.slice() as unknown as T\n  }\n  const clone = {} as T\n  const keys = Object.keys(obj)\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i]\n    ;(clone as any)[key] = (obj as any)[key]\n  }\n  return clone\n}\n\n/**\n * Ensures an object is owned (cloned if necessary) and returns the owned version.\n * Also updates the parent to point to the cloned child.\n */\nfunction ensureOwned<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  parent: JSONObject,\n  key: string | number,\n  child: JSONRecord | JSONValue[]\n): JSONRecord | JSONValue[] {\n  if (ctx.ownedObjects.has(child)) {\n    return child\n  }\n  const cloned = shallowClone(child)\n  ;(parent as any)[key] = cloned\n  ctx.ownedObjects.add(cloned)\n  return cloned\n}\n\n/**\n * Ensures all objects along the path are owned (cloned if necessary).\n * Returns the container at the end of the path.\n * Throws if the path is invalid.\n */\nfunction ensureOwnedPath<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path\n): JSONRecord | JSONValue[] {\n  // Ensure root is owned first\n  if (!ctx.isRootOwned) {\n    ctx.root = shallowClone(ctx.root as unknown as object) as T\n    ctx.ownedObjects.add(ctx.root)\n    ctx.isRootOwned = true\n  }\n\n  if (path.length === 0) {\n    return ctx.root\n  }\n\n  let current: JSONRecord | JSONValue[] = ctx.root\n\n  for (let i = 0; i < path.length; i++) {\n    const segment = path[i]\n    const isArrayIndex = typeof segment === \"number\"\n\n    // Validate container type\n    if (isArrayIndex) {\n      if (!Array.isArray(current)) {\n        failure(`Expected array at path segment ${segment}`)\n      }\n      if (segment < 0 || segment >= current.length) {\n        failure(`Index ${segment} out of bounds`)\n      }\n    } else {\n      if (!isObject(current) || Array.isArray(current)) {\n        failure(`Expected object at path segment \"${segment}\"`)\n      }\n      if (!(segment in current)) {\n        failure(`Property \"${segment}\" does not exist`)\n      }\n    }\n\n    const child: JSONValue = (current as any)[segment]\n\n    // Validate child is traversable\n    if (child === null || typeof child !== \"object\") {\n      failure(`Cannot traverse through primitive at path segment ${segment}`)\n    }\n\n    // Ensure child is owned and continue\n    current = ensureOwned(ctx, current, segment, child as JSONRecord | JSONValue[])\n  }\n\n  return current\n}\n\n/**\n * Applies a single \"set\" operation to the draft with copy-on-write.\n */\nexport function draftSet<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  key: string,\n  value: JSONValue\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (Array.isArray(container)) {\n    failure(\"set requires object container\")\n  }\n  ;(container as JSONRecord)[key] = value\n}\n\n/**\n * Applies a single \"delete\" operation to the draft with copy-on-write.\n */\nexport function draftDelete<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  key: string\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (Array.isArray(container)) {\n    failure(\"delete requires object container\")\n  }\n  delete (container as JSONRecord)[key]\n}\n\n/**\n * Applies a single \"splice\" operation to the draft with copy-on-write.\n */\nexport function draftSplice<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  index: number,\n  deleteCount: number,\n  inserts: readonly JSONValue[]\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (!Array.isArray(container)) {\n    failure(\"splice requires array container\")\n  }\n  const safeIndex = Math.min(index, container.length)\n  if (inserts.length === 0) {\n    container.splice(safeIndex, deleteCount)\n  } else if (inserts.length === 1) {\n    container.splice(safeIndex, deleteCount, inserts[0])\n  } else {\n    container.splice(safeIndex, deleteCount, ...inserts)\n  }\n}\n\n/**\n * Applies a single \"addToSet\" operation to the draft with copy-on-write.\n */\nexport function draftAddToSet<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  value: JSONValue\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (!Array.isArray(container)) {\n    failure(\"addToSet requires array container\")\n  }\n  if (!container.some((item) => deepEqual(item, value))) {\n    container.push(value)\n  }\n}\n\n/**\n * Applies a single \"deleteFromSet\" operation to the draft with copy-on-write.\n */\nexport function draftDeleteFromSet<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  value: JSONValue\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (!Array.isArray(container)) {\n    failure(\"deleteFromSet requires array container\")\n  }\n  // Remove all matching items (iterate backwards to avoid index shifting)\n  for (let i = container.length - 1; i >= 0; i--) {\n    if (deepEqual(container[i], value)) {\n      container.splice(i, 1)\n    }\n  }\n}\n\n/**\n * Applies a single operation to the draft with copy-on-write.\n */\nexport function applyOpToDraft<T extends JSONObject>(ctx: DraftContext<T>, op: Op): void {\n  switch (op.kind) {\n    case \"set\":\n      draftSet(ctx, op.path, op.key, op.value)\n      break\n    case \"delete\":\n      draftDelete(ctx, op.path, op.key)\n      break\n    case \"splice\":\n      draftSplice(ctx, op.path, op.index, op.deleteCount, op.inserts)\n      break\n    case \"addToSet\":\n      draftAddToSet(ctx, op.path, op.value)\n      break\n    case \"deleteFromSet\":\n      draftDeleteFromSet(ctx, op.path, op.value)\n      break\n    default:\n      throw failure(`Unknown operation kind: ${(op as any).kind}`)\n  }\n}\n\n/**\n * Applies a single transaction to a base state immutably.\n *\n * Key benefits over Mutative/Immer:\n * - No proxy overhead - direct object access and copy-on-write cloning\n * - Structural sharing - unchanged subtrees keep their references\n * - Zero-copy on failure - if validation fails, returns original base unchanged\n *\n * @param base - The base state (never mutated)\n * @param tx - The transaction to apply\n * @param validateFn - Optional validation function\n * @returns The final state (if valid) or the original base (if invalid or empty)\n */\nexport function applyTxImmutable<T extends JSONObject>(\n  base: T,\n  tx: Pick<TxRecord, \"ops\">,\n  validateFn?: ValidateFn<T>\n): T {\n  if (tx.ops.length === 0) return base\n\n  const ctx = createDraft(base)\n\n  try {\n    for (const op of tx.ops) {\n      applyOpToDraft(ctx, op)\n    }\n\n    if (validateFn && !validateFn(ctx.root)) {\n      return base\n    }\n\n    return ctx.root\n  } catch {\n    return base\n  }\n}\n","import { failure } from \"./error\"\nimport { JSONRecord, JSONValue, Path } from \"./json\"\nimport { Op } from \"./operations\"\n\n/**\n * Reconciles the current state with the target state by computing and emitting\n * the minimal set of operations needed to transform currentState into targetState.\n */\nexport function computeReconcileOps(currentState: JSONValue, targetState: JSONValue): Op[] {\n  const ops: Op[] = []\n  diffValue(currentState, targetState, [], ops)\n  return ops\n}\n\nfunction diffValue(current: JSONValue, target: JSONValue, path: Path, ops: Op[]): void {\n  // 1. Reference equality (structural sharing)\n  if (current === target) return\n\n  // 2. Handle primitives and null quickly\n  const currentType = typeof current\n  const targetType = typeof target\n\n  if (current === null || target === null || currentType !== \"object\" || targetType !== \"object\") {\n    // At least one is primitive/null, or types don't match\n    emitReplace(path, target, ops)\n    return\n  }\n\n  // Both are objects (object or array)\n  const currentIsArray = Array.isArray(current)\n  const targetIsArray = Array.isArray(target)\n\n  if (currentIsArray !== targetIsArray) {\n    // Type mismatch (one array, one object)\n    emitReplace(path, target, ops)\n    return\n  }\n\n  if (currentIsArray) {\n    diffArray(current, target as JSONValue[], path, ops)\n  } else {\n    diffObject(current as JSONRecord, target as JSONRecord, path, ops)\n  }\n}\n\nfunction diffObject(current: JSONRecord, target: JSONRecord, path: Path, ops: Op[]): void {\n  // 1. Delete keys in current but not in target\n  for (const key in current) {\n    if (Object.hasOwn(current, key) && !Object.hasOwn(target, key)) {\n      ops.push({ kind: \"delete\", path, key })\n    }\n  }\n\n  // 2. Add/Update keys in target\n  for (const key in target) {\n    if (Object.hasOwn(target, key)) {\n      const targetVal = target[key]\n      if (!Object.hasOwn(current, key)) {\n        ops.push({ kind: \"set\", path, key, value: targetVal })\n      } else if (current[key] !== targetVal) {\n        // Only recurse if values differ (reference check first)\n        diffValue(current[key], targetVal, [...path, key], ops)\n      }\n    }\n  }\n}\n\nfunction diffArray(current: JSONValue[], target: JSONValue[], path: Path, ops: Op[]): void {\n  const currentLen = current.length\n  const targetLen = target.length\n  const minLen = currentLen < targetLen ? currentLen : targetLen\n\n  // Diff common elements\n  for (let i = 0; i < minLen; i++) {\n    if (current[i] !== target[i]) {\n      diffValue(current[i], target[i], [...path, i], ops)\n    }\n  }\n\n  // Handle length difference\n  if (targetLen > currentLen) {\n    ops.push({\n      kind: \"splice\",\n      path,\n      index: currentLen,\n      deleteCount: 0,\n      inserts: target.slice(currentLen),\n    })\n  } else if (currentLen > targetLen) {\n    ops.push({\n      kind: \"splice\",\n      path,\n      index: targetLen,\n      deleteCount: currentLen - targetLen,\n      inserts: [],\n    })\n  }\n}\n\nfunction emitReplace(path: Path, value: JSONValue, ops: Op[]): void {\n  if (path.length === 0) {\n    // Cannot replace root directly via Ops (unless we define a 'root' op, which we don't)\n    // We expect root to be handled by diffObject usually.\n    // If we land here, it means root types mismatched (e.g. Obj -> Array).\n    failure(\"StateSyncLog: Cannot replace root state directly via Ops.\")\n  }\n\n  const parentPath = path.slice(0, -1)\n  const keyToCheck = path[path.length - 1]\n\n  if (typeof keyToCheck === \"string\") {\n    // Parent is Object\n    ops.push({ kind: \"set\", path: parentPath, key: keyToCheck, value })\n  } else {\n    // Parent is Array\n    ops.push({\n      kind: \"splice\",\n      path: parentPath,\n      index: keyToCheck,\n      deleteCount: 1,\n      inserts: [value],\n    })\n  }\n}\n","import { failure } from \"./error\"\n\n/**\n * Parsed tx timestamp components.\n */\nexport type TxTimestamp = {\n  epoch: number\n  clock: number\n  clientId: string\n  wallClock: number\n}\n\n/**\n * Unique tx ID (Composite Key).\n */\nexport type TxTimestampKey = string\n\n/**\n * Converts a timestamp object to a TransactionTimestampKey string.\n */\nexport function txTimestampToKey(ts: TxTimestamp): TxTimestampKey {\n  return `${ts.epoch};${ts.clock};${ts.clientId};${ts.wallClock}`\n}\n\n/**\n * Helper to parse tx timestamp keys.\n * Throws if key is malformed.\n */\nexport function parseTxTimestampKey(key: TxTimestampKey): TxTimestamp {\n  const i1 = key.indexOf(\";\")\n  const i2 = key.indexOf(\";\", i1 + 1)\n  const i3 = key.indexOf(\";\", i2 + 1)\n\n  if (i1 === -1 || i2 === -1 || i3 === -1) {\n    failure(`Malformed timestamp key: ${key}`)\n  }\n\n  return {\n    epoch: Number.parseInt(key.substring(0, i1), 10),\n    clock: Number.parseInt(key.substring(i1 + 1, i2), 10),\n    clientId: key.substring(i2 + 1, i3),\n    wallClock: Number.parseInt(key.substring(i3 + 1), 10),\n  }\n}\n\n/**\n * Compares two tx timestamps for deterministic ordering.\n * Sort order: epoch (asc) → clock (asc) → clientId (asc)\n */\nexport function compareTxTimestamps(a: TxTimestamp, b: TxTimestamp): number {\n  if (a.epoch !== b.epoch) return a.epoch - b.epoch\n  if (a.clock !== b.clock) return a.clock - b.clock\n  if (a.clientId < b.clientId) return -1\n  if (a.clientId > b.clientId) return 1\n  return 0\n}\n","import type * as Y from \"yjs\"\nimport { failure } from \"./error\"\nimport { TxRecord } from \"./TxRecord\"\nimport { parseTxTimestampKey, type TxTimestamp, type TxTimestampKey } from \"./txTimestamp\"\n\n/**\n * A cached tx entry with lazy parsing and optional tx caching.\n * The timestamp is parsed on first access and cached.\n * The tx record can be fetched lazily and cached.\n */\nexport class SortedTxEntry {\n  private _txTimestamp?: TxTimestamp\n  private _originalTxTimestampKey?: TxTimestampKey | null\n  private _originalTxTimestamp?: TxTimestamp | null\n  private _txRecord?: TxRecord\n\n  constructor(\n    readonly txTimestampKey: TxTimestampKey,\n    private readonly _yTx: Y.Map<TxRecord>\n  ) {}\n\n  /**\n   * Gets the parsed timestamp, lazily parsing and caching on first access.\n   */\n  get txTimestamp(): TxTimestamp {\n    if (!this._txTimestamp) {\n      this._txTimestamp = parseTxTimestampKey(this.txTimestampKey)\n    }\n    return this._txTimestamp\n  }\n\n  /**\n   * Gets the original tx timestamp key, lazily and caching on first access.\n   */\n  get originalTxTimestampKey(): TxTimestampKey | null {\n    if (this._originalTxTimestampKey === undefined) {\n      const tx = this.txRecord\n      this._originalTxTimestampKey = tx.originalTxKey ?? null\n    }\n    return this._originalTxTimestampKey\n  }\n\n  /**\n   * Gets the parsed original tx timestamp, lazily parsing and caching on first access.\n   */\n  get originalTxTimestamp(): TxTimestamp | null {\n    if (this._originalTxTimestamp === undefined) {\n      const key = this.originalTxTimestampKey\n      this._originalTxTimestamp = key ? parseTxTimestampKey(key) : null\n    }\n    return this._originalTxTimestamp\n  }\n\n  /**\n   * Gets the logical (deduplicated) tx timestamp key.\n   * This is the original tx key if it exists, otherwise the physical key.\n   */\n  get dedupTxTimestampKey(): TxTimestampKey {\n    return this.originalTxTimestampKey ?? this.txTimestampKey\n  }\n\n  /**\n   * Gets the logical (deduplicated) parsed tx timestamp.\n   * This is the original tx timestamp if it exists, otherwise the physical timestamp.\n   */\n  get dedupTxTimestamp(): TxTimestamp {\n    return this.originalTxTimestamp ?? this.txTimestamp\n  }\n\n  /**\n   * Gets the tx record, lazily fetching and caching on first access.\n   * Returns undefined if the tx doesn't exist.\n   */\n  get txRecord(): TxRecord {\n    if (!this._txRecord) {\n      this._txRecord = this._yTx.get(this.txTimestampKey)\n      if (!this._txRecord) {\n        throw failure(`SortedTxEntry: TxRecord not found for key ${this.txTimestampKey}`)\n      }\n    }\n    return this._txRecord\n  }\n}\n","import type * as Y from \"yjs\"\nimport { type CheckpointRecord, type ClientWatermarks } from \"./checkpoints\"\nimport { applyTxImmutable } from \"./draft\"\nimport { JSONObject } from \"./json\"\nimport { Op, ValidateFn } from \"./operations\"\nimport { computeReconcileOps } from \"./reconcile\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { TxRecord } from \"./TxRecord\"\nimport { compareTxTimestamps, type TxTimestamp, type TxTimestampKey } from \"./txTimestamp\"\nimport { lazy } from \"./utils\"\n\n/**\n * Checks if a transaction is covered by the checkpoint watermarks.\n */\nexport function isTransactionInCheckpoint(ts: TxTimestamp, watermarks: ClientWatermarks): boolean {\n  const wm = watermarks[ts.clientId]\n  if (!wm) return false\n  return ts.clock <= wm.maxClock\n}\n\n/**\n * StateCalculator encapsulates the sorted transaction cache and state calculation logic.\n *\n * It maintains:\n * - A sorted array of transaction entries\n * - A map for O(1) lookup\n * - A tracking index indicating up to which tx the state has been calculated\n * - The cached calculated state\n * - The base checkpoint\n *\n * The tracking index is invalidated (set to null) when:\n * - A transaction is inserted before the already-calculated slice\n * - A transaction is deleted from the already-calculated slice\n * - The base checkpoint changes\n */\nexport class StateCalculator {\n  /** Sorted tx cache (ALL active/future txs, kept sorted by timestamp) */\n  private sortedTxs: SortedTxEntry[] = []\n\n  /** O(1) existence check and lookup */\n  private sortedTxsMap: Map<TxTimestampKey, SortedTxEntry> = new Map()\n\n  /**\n   * Index of the last transaction applied to cachedState.\n   * - null: state needs full recalculation from checkpoint\n   * - -1: no transactions have been applied yet (state === checkpoint state)\n   * - >= 0: transactions up to and including this index have been applied\n   */\n  private lastAppliedIndex: number | null = null\n\n  /** The cached calculated state */\n  private cachedState: JSONObject | null = null\n\n  /** The base checkpoint to calculate state from */\n  private baseCheckpoint: CheckpointRecord | null = null\n\n  /**\n   * Applied dedup keys - tracks which LOGICAL txs have been applied.\n   * This is the originalTxKey (or physical key if no original) for each applied tx.\n   * Used to properly deduplicate re-emits.\n   */\n  private appliedTxKeys: Set<TxTimestampKey> = new Set()\n\n  /** Max clock seen from any transaction (for Lamport clock updates) */\n  private maxSeenClock = 0\n\n  /** Validation function (optional) */\n  private validateFn?: ValidateFn<JSONObject>\n\n  constructor(validateFn?: ValidateFn<JSONObject>) {\n    this.validateFn = validateFn\n  }\n\n  /**\n   * Sets the base checkpoint. Invalidates cached state if checkpoint changed.\n   * @returns true if the checkpoint changed\n   */\n  setBaseCheckpoint(checkpoint: CheckpointRecord | null): boolean {\n    if (checkpoint === this.baseCheckpoint) {\n      return false\n    }\n\n    this.baseCheckpoint = checkpoint\n    this.invalidate()\n    return true\n  }\n\n  /**\n   * Gets the current base checkpoint.\n   */\n  getBaseCheckpoint(): CheckpointRecord | null {\n    return this.baseCheckpoint\n  }\n\n  /**\n   * Clears all transactions and rebuilds from yTx map.\n   * This is used when the checkpoint changes and we need a fresh start.\n   */\n  rebuildFromYjs(yTx: Y.Map<TxRecord>): void {\n    this.sortedTxs = []\n    this.sortedTxsMap.clear()\n\n    // Collect all entries, build the map and max clock\n    for (const key of yTx.keys()) {\n      const entry = new SortedTxEntry(key, yTx)\n      this.sortedTxs.push(entry)\n\n      this.sortedTxsMap.set(entry.txTimestampKey, entry)\n      if (entry.txTimestamp.clock > this.maxSeenClock) {\n        this.maxSeenClock = entry.txTimestamp.clock\n      }\n    }\n\n    // Sort once - O(n log n)\n    this.sortedTxs.sort((a, b) => compareTxTimestamps(a.txTimestamp, b.txTimestamp))\n\n    // Invalidate cached state since we rebuilt\n    this.invalidate()\n  }\n\n  /**\n   * Inserts a transaction into the sorted cache.\n   * Invalidates cached state if the transaction was inserted before the calculated slice.\n   *\n   * @returns true if this caused invalidation (out-of-order insert)\n   */\n  insertTx(key: TxTimestampKey, yTx: Y.Map<TxRecord>): boolean {\n    if (this.sortedTxsMap.has(key)) {\n      return false // Already exists\n    }\n\n    const entry = new SortedTxEntry(key, yTx)\n    const ts = entry.txTimestamp\n\n    // Update max seen clock for Lamport clock mechanism\n    if (ts.clock > this.maxSeenClock) {\n      this.maxSeenClock = ts.clock\n    }\n\n    const sortedTxs = this.sortedTxs\n\n    // Find insertion position (search from end since new txs typically have higher timestamps)\n    let insertIndex = sortedTxs.length // Default: append at end\n    for (let i = sortedTxs.length - 1; i >= 0; i--) {\n      const existingTs = sortedTxs[i].txTimestamp\n      if (compareTxTimestamps(ts, existingTs) >= 0) {\n        insertIndex = i + 1\n        break\n      }\n      if (i === 0) {\n        insertIndex = 0 // Insert at beginning\n      }\n    }\n\n    // Insert at the found position\n    sortedTxs.splice(insertIndex, 0, entry)\n    this.sortedTxsMap.set(key, entry)\n\n    // Check if this invalidates our cached state\n    // If we inserted before or at the last applied index, we need to recalculate\n    if (this.lastAppliedIndex !== null && insertIndex <= this.lastAppliedIndex) {\n      this.invalidate()\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Removes multiple transactions from the sorted cache.\n   * @returns the number of keys that were actually removed\n   */\n  removeTxs(keys: readonly TxTimestampKey[]): number {\n    if (keys.length === 0) return 0\n\n    let removedCount = 0\n    let minRemovedIndex = Number.POSITIVE_INFINITY\n\n    // Build set of keys to delete and track their indices\n    const toDelete = new Set<TxTimestampKey>()\n    for (const key of keys) {\n      const entry = this.sortedTxsMap.get(key)\n      if (entry) {\n        this.sortedTxsMap.delete(key)\n        toDelete.add(key)\n\n        // Find index for invalidation check\n        const index = this.sortedTxs.indexOf(entry)\n        if (index !== -1 && index < minRemovedIndex) {\n          minRemovedIndex = index\n        }\n      }\n    }\n\n    if (toDelete.size === 0) return 0\n\n    // Single forward pass through sortedTxs, removing matching entries\n    const sortedTxs = this.sortedTxs\n    let i = 0\n    while (i < sortedTxs.length && toDelete.size > 0) {\n      if (toDelete.has(sortedTxs[i].txTimestampKey)) {\n        toDelete.delete(sortedTxs[i].txTimestampKey)\n        sortedTxs.splice(i, 1)\n        removedCount++\n      } else {\n        i++\n      }\n    }\n\n    // Check if this invalidates our cached state\n    if (this.lastAppliedIndex !== null && minRemovedIndex <= this.lastAppliedIndex) {\n      this.invalidate()\n    }\n\n    return removedCount\n  }\n\n  /**\n   * Checks if a transaction key exists in the cache.\n   */\n  hasTx(key: TxTimestampKey): boolean {\n    return this.sortedTxsMap.has(key)\n  }\n\n  /**\n   * Gets a transaction entry by key.\n   */\n  getTx(key: TxTimestampKey): SortedTxEntry | undefined {\n    return this.sortedTxsMap.get(key)\n  }\n\n  /**\n   * Gets all sorted transaction entries.\n   */\n  getSortedTxs(): readonly SortedTxEntry[] {\n    return this.sortedTxs\n  }\n\n  /**\n   * Gets the number of transactions in the cache.\n   */\n  get txCount(): number {\n    return this.sortedTxs.length\n  }\n\n  /**\n   * Returns true if the state needs full recalculation.\n   */\n  needsFullRecalculation(): boolean {\n    return this.lastAppliedIndex === null\n  }\n\n  /**\n   * Invalidates the cached state, forcing a full recalculation on next calculateState().\n   * Note: cachedState is kept so computeReconcileOps can diff old vs new state.\n   */\n  invalidate(): void {\n    this.lastAppliedIndex = null\n  }\n\n  /**\n   * Calculates and returns the current state, along with a lazy getter for ops that changed from the previous state.\n   *\n   * - If lastAppliedIndex is null: full recalculation from checkpoint\n   * - If lastAppliedIndex >= -1: incremental apply from lastAppliedIndex + 1\n   */\n  calculateState(): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    const baseState: JSONObject = this.baseCheckpoint?.state ?? {}\n    const watermarks = this.baseCheckpoint?.watermarks ?? {}\n    const hasWatermarks = Object.keys(watermarks).length > 0\n\n    if (this.lastAppliedIndex === null) {\n      // SLOW PATH: Full recalculation\n      return this.fullRecalculation(baseState, watermarks, hasWatermarks)\n    }\n\n    // FAST PATH: Incremental apply\n    return this.incrementalApply(watermarks, hasWatermarks)\n  }\n\n  /**\n   * Full recalculation of state from the base checkpoint.\n   */\n  private fullRecalculation(\n    baseState: JSONObject,\n    watermarks: ClientWatermarks,\n    hasWatermarks: boolean\n  ): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    const oldState = this.cachedState ?? {}\n\n    // Reset tracking for full recompute\n    this.appliedTxKeys.clear()\n    this.lastAppliedIndex = -1\n    this.cachedState = baseState\n\n    // Delegate to incremental apply to replay all transactions\n    // We ignore the returned ops because they represent the operations applied from the base state,\n    // whereas we want the diff from the *previous cached state*.\n    // We pass returnOps=false to avoid collecting ops during replay.\n    const { state } = this.incrementalApply(watermarks, hasWatermarks, false)\n\n    // Lazy load the reconciliation ops (expensive diff)\n    const getAppliedOps = lazy(() => computeReconcileOps(oldState, state))\n\n    return { state, getAppliedOps }\n  }\n\n  /**\n   * Incremental apply of transactions from lastAppliedIndex + 1.\n   * @param returnOps If true, collects applied transactions (to lazy compute ops). If false, skips collection.\n   */\n  private incrementalApply(\n    watermarks: ClientWatermarks,\n    hasWatermarks: boolean,\n    returnOps = true\n  ): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    let state = this.cachedState as JSONObject\n    const appliedTxs: TxRecord[] = []\n    const sortedTxs = this.sortedTxs\n    const startIndex = this.lastAppliedIndex! + 1\n\n    for (let i = startIndex; i < sortedTxs.length; i++) {\n      const entry = sortedTxs[i]\n      const dedupKey = entry.dedupTxTimestampKey\n\n      // Skip if already applied (deduplication)\n      if (this.appliedTxKeys.has(dedupKey)) {\n        continue\n      }\n\n      // Skip if in checkpoint\n      if (hasWatermarks) {\n        const dedupTs = entry.dedupTxTimestamp\n        if (isTransactionInCheckpoint(dedupTs, watermarks)) {\n          this.appliedTxKeys.add(dedupKey)\n          continue\n        }\n      }\n\n      const tx = entry.txRecord\n\n      // Apply transaction 1-by-1 to avoid draft context pollution on validation failure\n      const newState = applyTxImmutable(state, tx, this.validateFn)\n\n      if (newState !== state) {\n        state = newState\n        if (returnOps) {\n          appliedTxs.push(tx)\n        }\n      }\n\n      this.appliedTxKeys.add(dedupKey)\n      this.lastAppliedIndex = i\n    }\n\n    // Update lastAppliedIndex to end even if all txs were skipped\n    // This ensures we don't re-process skipped txs on next incremental apply\n    if (sortedTxs.length > 0 && this.lastAppliedIndex! < sortedTxs.length - 1) {\n      this.lastAppliedIndex = sortedTxs.length - 1\n    }\n\n    this.cachedState = state\n\n    // Lazy getter for ops (flattens applied txs)\n    const getAppliedOps = lazy(() => {\n      const ops: Op[] = []\n      for (const tx of appliedTxs) {\n        ops.push(...tx.ops)\n      }\n      return ops\n    })\n\n    return { state, getAppliedOps }\n  }\n\n  /**\n   * Gets the max seen clock (for Lamport clock updates).\n   */\n  getMaxSeenClock(): number {\n    return this.maxSeenClock\n  }\n\n  /**\n   * Gets the current cached state without recalculating.\n   * Returns null if state has never been calculated.\n   */\n  getCachedState(): JSONObject | null {\n    return this.cachedState\n  }\n\n  /**\n   * Gets the last applied timestamp.\n   */\n  getLastAppliedTs(): TxTimestamp | null {\n    if (this.lastAppliedIndex === null || this.lastAppliedIndex < 0) {\n      return null\n    }\n    return this.sortedTxs[this.lastAppliedIndex]?.txTimestamp ?? null\n  }\n\n  /**\n   * Gets the last applied index (for debugging/tracking).\n   */\n  getLastAppliedIndex(): number | null {\n    return this.lastAppliedIndex\n  }\n}\n","import { JSONObject } from \"./json\"\nimport { ValidateFn } from \"./operations\"\nimport { StateCalculator } from \"./StateCalculator\"\n\n/**\n * Client-side state including clocks and calculator for state management\n */\nexport interface ClientState {\n  // Lamport clocks (monotonic, never reset)\n  localClock: number\n\n  // Cached finalized epoch (null = not yet initialized, recalculated only when checkpoint map changes)\n  cachedFinalizedEpoch: number | null\n\n  // State calculator (manages sorted tx cache, state calculation, and invalidation)\n  stateCalculator: StateCalculator\n\n  /**\n   * Timestamp retention window in milliseconds.\n   */\n  retentionWindowMs: number\n}\n\n/**\n * Factory to create an initial ClientState\n */\nexport function createClientState(\n  validateFn: ValidateFn<JSONObject> | undefined,\n  retentionWindowMs: number\n): ClientState {\n  return {\n    localClock: 0,\n    cachedFinalizedEpoch: null, // Will be recalculated on first run\n    stateCalculator: new StateCalculator(validateFn),\n    retentionWindowMs,\n  }\n}\n","import * as Y from \"yjs\"\nimport { type CheckpointRecord, pruneCheckpoints } from \"./checkpoints\"\nimport { getFinalizedEpochAndCheckpoint } from \"./checkpointUtils\"\nimport { ClientState } from \"./clientState\"\nimport { JSONObject } from \"./json\"\nimport { Op } from \"./operations\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { isTransactionInCheckpoint } from \"./StateCalculator\"\nimport { TxRecord } from \"./TxRecord\"\nimport { type TxTimestamp, type TxTimestampKey, txTimestampToKey } from \"./txTimestamp\"\n\n/**\n * Changes to transaction keys from a Y.YMapEvent.\n * - added: keys that were added\n * - deleted: keys that were deleted\n */\nexport type TxKeyChanges = {\n  added: readonly TxTimestampKey[]\n  deleted: readonly TxTimestampKey[]\n}\n\n/**\n * Appends a new transaction to the log.\n *\n * @param originalKey - Optional reference to the original transaction key for re-emits.\n *                      Used by syncLog to preserve transactions missed by checkpoints.\n */\nexport function appendTx(\n  ops: readonly Op[],\n  yTx: Y.Map<TxRecord>,\n  activeEpoch: number,\n  myClientId: string,\n  clientState: ClientState,\n  originalKey?: TxTimestampKey\n): TxTimestampKey {\n  const calc = clientState.stateCalculator\n\n  // 1. Advance logical clock (Lamport) based on all seen traffic\n  const clock = Math.max(clientState.localClock, calc.getMaxSeenClock()) + 1\n  clientState.localClock = clock\n\n  // 2. Generate Key with WallClock for future pruning safety\n  const ts: TxTimestamp = {\n    epoch: activeEpoch,\n    clock,\n    clientId: myClientId,\n    wallClock: Date.now(),\n  }\n  const key = txTimestampToKey(ts)\n\n  // 3. Write to Yjs (Atomic)\n  const record: TxRecord = { ops, originalTxKey: originalKey }\n  yTx.set(key, record)\n\n  return key\n}\n\n/**\n * Synchronizes the transaction log with the current checkpoint.\n * Re-emits missed transactions and prunes old ones.\n *\n * Should be called BEFORE updateState to ensure log is clean and complete.\n *\n * @returns true if any transactions were re-emitted or deleted, which may invalidate lastAppliedIndex\n */\nfunction syncLog(\n  yTx: Y.Map<TxRecord>,\n  myClientId: string,\n  clientState: ClientState,\n  finalizedEpoch: number,\n  baseCP: CheckpointRecord | null,\n  newKeys?: readonly TxTimestampKey[] // keys added in this update\n): void {\n  const calc = clientState.stateCalculator\n  const activeEpoch = finalizedEpoch + 1\n  const watermarks = baseCP?.watermarks ?? {}\n\n  // Deterministic Reference Time: Use stored minWallClock if available, otherwise 0 (nothing ancient).\n  const referenceTime = baseCP?.minWallClock ?? 0\n\n  // Helper to check if a transaction should be pruned\n  const shouldPrune = (ts: TxTimestamp, dedupTs: TxTimestamp): boolean => {\n    const isAncient = referenceTime - ts.wallClock > clientState.retentionWindowMs\n    if (isAncient) return true\n    return isTransactionInCheckpoint(dedupTs, watermarks)\n  }\n\n  const toDelete: TxTimestampKey[] = []\n  const toReEmit: Array<{ originalKey: TxTimestampKey; tx: TxRecord }> = []\n\n  // 1. Helper to decide what to do with each transaction\n  const processEntry = (entry: SortedTxEntry): boolean => {\n    if (shouldPrune(entry.txTimestamp, entry.dedupTxTimestamp)) {\n      toDelete.push(entry.txTimestampKey)\n      return false // deleted\n    }\n\n    if (entry.txTimestamp.epoch <= finalizedEpoch) {\n      // Not in checkpoint and still fresh - re-emit it to the active epoch\n      toReEmit.push({ originalKey: entry.dedupTxTimestampKey, tx: entry.txRecord })\n      toDelete.push(entry.txTimestampKey)\n      return false // re-emitted\n    }\n\n    return true // active/fresh\n  }\n\n  // 2. Scan local cache (sortedTxs) to identify missing/ancient transactions\n  for (const entry of calc.getSortedTxs()) {\n    if (processEntry(entry)) {\n      // Optimization: Physical keys are sorted. If we hit the active/fresh territory, we can stop.\n      break\n    }\n  }\n\n  const processKeyByTimestampKey = (txTimestampKey: TxTimestampKey): void => {\n    // Only process if it actually exists in Yjs Map\n    if (yTx.has(txTimestampKey)) {\n      processEntry(new SortedTxEntry(txTimestampKey, yTx))\n    }\n  }\n\n  // 3. Scan NEW keys from Yjs to handle incoming transactions (sync)\n  // Any client can re-emit - deduplication via originalTxKey handles duplicates.\n  if (newKeys) {\n    for (const key of newKeys) {\n      processKeyByTimestampKey(key)\n    }\n  }\n\n  // 4. Re-emit missed transactions BEFORE pruning\n  for (const { originalKey, tx } of toReEmit) {\n    const newKey = appendTx(tx.ops, yTx, activeEpoch, myClientId, clientState, originalKey)\n    calc.insertTx(newKey, yTx)\n  }\n\n  // 5. Prune old/finalized/redundant transactions from Yjs Map\n  for (const key of toDelete) {\n    yTx.delete(key)\n  }\n  calc.removeTxs(toDelete)\n}\n\n/**\n * The primary update function that maintains current state.\n *\n * @param txChanges - Changes from Y.YMapEvent. If undefined (first run), performs a full scan.\n */\nexport function updateState(\n  doc: Y.Doc,\n  yTx: Y.Map<TxRecord>,\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  myClientId: string,\n  clientState: ClientState,\n  txChanges: TxKeyChanges | undefined\n): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n  const calc = clientState.stateCalculator\n\n  // Always calculate fresh finalized epoch and checkpoint to handle sync race conditions\n  const { finalizedEpoch, checkpoint: baseCP } = getFinalizedEpochAndCheckpoint(yCheckpoint)\n\n  // Update read-cache\n  clientState.cachedFinalizedEpoch = finalizedEpoch\n\n  // Set base checkpoint (this handles invalidation if checkpoint changed)\n  calc.setBaseCheckpoint(baseCP)\n\n  // Track if we need to rebuild sorted cache (first run or missing delta)\n  // Optimization: We don't need to rebuild just because checkpoint changed,\n  // as long as we have txChanges to keep cache in sync.\n  const needsRebuildSortedCache = calc.getCachedState() === null || !txChanges\n\n  // Rebuild sorted cache before syncLog if needed\n  if (needsRebuildSortedCache) {\n    calc.rebuildFromYjs(yTx)\n  } else {\n    // If not rebuilding, immediately process deletions to avoid \"ghost\" transactions\n    // in syncLog (e.g. attempting to access a transaction that was just deleted).\n    calc.removeTxs(txChanges.deleted)\n  }\n\n  // Sync and prune within transaction\n  doc.transact(() => {\n    syncLog(yTx, myClientId, clientState, finalizedEpoch, baseCP, txChanges?.added)\n\n    // Safe to use local finalizedEpoch here\n    pruneCheckpoints(yCheckpoint, finalizedEpoch)\n  })\n\n  if (needsRebuildSortedCache) {\n    // Full recompute (calculator handles this)\n    return calc.calculateState()\n  }\n\n  // Incremental update using only changed keys (calculator handles this)\n  // txChanges is guaranteed to exist here since !txChanges implies needsRebuildSortedCache\n\n  // Update sorted cache with new keys from txChanges\n  // This must happen after syncLog which may have deleted some of these keys\n  for (const key of txChanges.added) {\n    // CRITICAL: Check yTx.has(key)! syncLog might have just pruned it.\n    if (yTx.has(key) && !calc.hasTx(key)) {\n      calc.insertTx(key, yTx)\n    }\n  }\n\n  return calc.calculateState()\n}\n","import * as Y from \"yjs\"\nimport { CheckpointRecord, createCheckpoint } from \"./checkpoints\"\nimport { createClientState } from \"./clientState\"\nimport { failure } from \"./error\"\nimport { JSONObject } from \"./json\"\n\nimport { Op, ValidateFn } from \"./operations\"\n\nimport { computeReconcileOps } from \"./reconcile\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { TxRecord } from \"./TxRecord\"\nimport { appendTx, TxKeyChanges, updateState } from \"./txLog\"\nimport { TxTimestampKey } from \"./txTimestamp\"\nimport { generateID } from \"./utils\"\n\nexport const getSortedTxsSymbol = Symbol(\"getSortedTxs\")\n\nexport interface StateSyncLogOptions<State extends JSONObject> {\n  /**\n   * The Y.js Document to bind to.\n   */\n  yDoc: Y.Doc\n\n  /**\n   * Name for the txs Y.Map.\n   * Default: \"state-sync-log-tx\"\n   */\n  yTxMapName?: string\n\n  /**\n   * Name for the checkpoint Y.Map.\n   * Default: \"state-sync-log-checkpoint\"\n   */\n  yCheckpointMapName?: string\n\n  /**\n   * Unique identifier for this client.\n   * If omitted, a random UUID (nanoid) will be generated.\n   * NOTE: If you need to resume a session (keep local clock/watermark), you MUST provide a stable ID.\n   * MUST NOT contain semicolons.\n   */\n  clientId?: string\n\n  /**\n   * Origin tag for Y.js txs created by this library.\n   */\n  yjsOrigin?: unknown\n\n  /**\n   * Optional validation function.\n   * Runs after each tx's ops are applied.\n   * If it returns false, the tx is rejected (state reverts).\n   * MUST be deterministic and consistent across all clients.\n   */\n  validate?: (state: State) => boolean\n\n  /**\n   * Timestamp retention window in milliseconds.\n   * Txs older than this window are considered \"Ancient\" and pruned.\n   *\n   * Default: Infinity (No pruning).\n   * Recommended: 14 days (1209600000 ms).\n   */\n  retentionWindowMs: number | undefined\n}\n\nexport interface StateSyncLogController<State extends JSONObject> {\n  /**\n   * Returns the current state.\n   */\n  getState(): State\n\n  /**\n   * Subscribes to state changes.\n   */\n  subscribe(callback: (newState: State, getAppliedOps: () => readonly Op[]) => void): () => void\n\n  /**\n   * Emits a new tx (list of operations) to the log.\n   */\n  emit(ops: Op[]): void\n\n  /**\n   * Reconciles the current state with the target state.\n   */\n  reconcileState(targetState: State): void\n\n  /**\n   * Manually triggers epoch compaction (Checkpointing).\n   */\n  compact(): void\n\n  /**\n   * Cleans up observers and releases memory.\n   */\n  dispose(): void\n\n  // --- Observability & Stats ---\n\n  /**\n   * Returns the current active epoch number.\n   */\n  getActiveEpoch(): number\n\n  /**\n   * Returns the number of txs currently in the active epoch.\n   */\n  getActiveEpochTxCount(): number\n\n  /**\n   * Returns the wallClock timestamp of the first tx in the active epoch.\n   */\n  getActiveEpochStartTime(): number | undefined\n\n  /**\n   * Returns true if the log is completely empty.\n   */\n  isLogEmpty(): boolean\n\n  /**\n   * Internal/Testing: Returns all txs currently in the log, sorted.\n   */\n  [getSortedTxsSymbol](): readonly SortedTxEntry[]\n}\n\n/**\n * Creates a StateSyncLog controller.\n */\nexport function createStateSyncLog<State extends JSONObject>(\n  options: StateSyncLogOptions<State>\n): StateSyncLogController<State> {\n  const {\n    yDoc,\n    yTxMapName = \"state-sync-log-tx\",\n    yCheckpointMapName = \"state-sync-log-checkpoint\",\n    clientId = generateID(),\n    yjsOrigin,\n    validate,\n    retentionWindowMs,\n  } = options\n\n  if (clientId.includes(\";\")) {\n    failure(`clientId MUST NOT contain semicolons: ${clientId}`)\n  }\n\n  const yTx = yDoc.getMap<TxRecord>(yTxMapName)\n  const yCheckpoint = yDoc.getMap<CheckpointRecord>(yCheckpointMapName)\n\n  // Cast validate to basic type to match internal ClientState\n  const clientState = createClientState(\n    validate as unknown as ValidateFn<JSONObject>,\n    retentionWindowMs ?? Number.POSITIVE_INFINITY\n  )\n\n  // Listeners\n  const subscribers = new Set<(state: State, getAppliedOps: () => readonly Op[]) => void>()\n\n  const notifySubscribers = (state: State, getAppliedOps: () => readonly Op[]) => {\n    for (const sub of subscribers) {\n      sub(state, getAppliedOps)\n    }\n  }\n\n  // Helper to extract key changes from YMapEvent\n  const extractTxChanges = (event: Y.YMapEvent<TxRecord>): TxKeyChanges => {\n    const added: TxTimestampKey[] = []\n    const deleted: TxTimestampKey[] = []\n\n    for (const [key, change] of event.changes.keys) {\n      if (change.action === \"add\") {\n        added.push(key)\n      } else if (change.action === \"delete\") {\n        deleted.push(key)\n      } else if (change.action === \"update\") {\n        deleted.push(key)\n        added.push(key)\n      }\n    }\n\n    return { added, deleted }\n  }\n\n  // Empty txChanges object for checkpoint observer (no tx keys changed)\n  const emptyTxChanges: TxKeyChanges = { added: [], deleted: [] }\n\n  // Update Logic with incremental changes\n  const runUpdate = (txChanges: TxKeyChanges | undefined) => {\n    const { state, getAppliedOps } = updateState(\n      yDoc,\n      yTx,\n      yCheckpoint,\n      clientId,\n      clientState,\n      txChanges\n    )\n    notifySubscribers(state as State, getAppliedOps)\n  }\n\n  // Tx observer\n  const txObserver = (event: Y.YMapEvent<TxRecord>, _transaction: Y.Transaction) => {\n    const txChanges = extractTxChanges(event)\n    runUpdate(txChanges)\n  }\n\n  // Checkpoint observer\n  const checkpointObserver = (\n    _event: Y.YMapEvent<CheckpointRecord>,\n    _transaction: Y.Transaction\n  ) => {\n    runUpdate(emptyTxChanges)\n  }\n\n  yCheckpoint.observe(checkpointObserver)\n  yTx.observe(txObserver)\n\n  // Initial run (full recompute, treat as checkpoint change to initialize epoch cache)\n  runUpdate(undefined)\n\n  // Track disposal state\n  let disposed = false\n\n  const assertNotDisposed = () => {\n    if (disposed) {\n      failure(\"StateSyncLog has been disposed and cannot be used\")\n    }\n  }\n\n  const getActiveEpochInternal = () => {\n    if (clientState.cachedFinalizedEpoch === null) {\n      failure(\"cachedFinalizedEpoch is null - this should not happen after initialization\")\n    }\n    return clientState.cachedFinalizedEpoch + 1\n  }\n\n  return {\n    getState(): State {\n      assertNotDisposed()\n      return (clientState.stateCalculator.getCachedState() ?? {}) as State\n    },\n\n    subscribe(callback: (newState: State, getAppliedOps: () => readonly Op[]) => void): () => void {\n      assertNotDisposed()\n      subscribers.add(callback)\n      return () => {\n        subscribers.delete(callback)\n      }\n    },\n\n    emit(ops: Op[]): void {\n      assertNotDisposed()\n      yDoc.transact(() => {\n        const activeEpoch = getActiveEpochInternal()\n        appendTx(ops, yTx, activeEpoch, clientId, clientState)\n      }, yjsOrigin)\n    },\n\n    reconcileState(targetState: State): void {\n      assertNotDisposed()\n      const currentState = (clientState.stateCalculator.getCachedState() ?? {}) as State\n      const ops = computeReconcileOps(currentState, targetState)\n      if (ops.length > 0) {\n        this.emit(ops)\n      }\n    },\n\n    compact(): void {\n      assertNotDisposed()\n      yDoc.transact(() => {\n        const activeEpoch = getActiveEpochInternal()\n        const currentState = clientState.stateCalculator.getCachedState() ?? {}\n        createCheckpoint(yTx, yCheckpoint, clientState, activeEpoch, currentState, clientId)\n      }, yjsOrigin)\n    },\n\n    dispose(): void {\n      if (disposed) return // Already disposed, no-op\n      disposed = true\n      yTx.unobserve(txObserver)\n      yCheckpoint.unobserve(checkpointObserver)\n      subscribers.clear()\n    },\n\n    getActiveEpoch(): number {\n      assertNotDisposed()\n      return getActiveEpochInternal()\n    },\n\n    getActiveEpochTxCount(): number {\n      assertNotDisposed()\n      const activeEpoch = getActiveEpochInternal()\n      let count = 0\n      // Only current or future epochs exist in sortedTxs (past epochs are pruned during updateState).\n      // Future epochs appear if we receive txs before the corresponding checkpoint.\n      for (const entry of clientState.stateCalculator.getSortedTxs()) {\n        const ts = entry.txTimestamp\n        if (ts.epoch === activeEpoch) {\n          count++\n        } else if (ts.epoch > activeEpoch) {\n          break // Optimization: sorted order means we can stop early\n        }\n      }\n      return count\n    },\n\n    getActiveEpochStartTime(): number | undefined {\n      assertNotDisposed()\n      const activeEpoch = getActiveEpochInternal()\n      // Only current or future epochs exist in sortedTxs (past epochs are pruned during updateState).\n      for (const entry of clientState.stateCalculator.getSortedTxs()) {\n        const ts = entry.txTimestamp\n        if (ts.epoch === activeEpoch) {\n          return ts.wallClock\n        } else if (ts.epoch > activeEpoch) {\n          break // Optimization: sorted order means we can stop early\n        }\n      }\n      return undefined\n    },\n\n    isLogEmpty(): boolean {\n      assertNotDisposed()\n      return yTx.size === 0 && yCheckpoint.size === 0\n    },\n\n    [getSortedTxsSymbol](): readonly SortedTxEntry[] {\n      assertNotDisposed()\n      return clientState.stateCalculator.getSortedTxs()\n    },\n  }\n}\n","import { failure } from \"./error\"\r\nimport { JSONObject, JSONValue, Path } from \"./json\"\r\nimport { deepClone, deepEqual, isObject } from \"./utils\"\r\n\r\n/**\r\n * Supported operations.\r\n * Applied sequentially within a tx.\r\n */\r\nexport type Op =\r\n  | { kind: \"set\"; path: Path; key: string; value: JSONValue }\r\n  | { kind: \"delete\"; path: Path; key: string }\r\n  | { kind: \"splice\"; path: Path; index: number; deleteCount: number; inserts: JSONValue[] }\r\n  | { kind: \"addToSet\"; path: Path; value: JSONValue }\r\n  | { kind: \"deleteFromSet\"; path: Path; value: JSONValue }\r\n\r\n/**\r\n * Validation function type.\r\n *\r\n * Rules:\r\n * - Validation MUST depend only on candidateState (and deterministic code).\r\n * - Validation runs once per tx, after all ops apply.\r\n * - If validation fails, the x is rejected (state reverts to previous).\r\n * - If no validator is provided, validation defaults to true.\r\n *\r\n * IMPORTANT: Validation outcome is **derived local state** and MUST NOT be replicated.\r\n * All clients MUST use the same validation logic to ensure consistency.\r\n */\r\nexport type ValidateFn<State extends JSONObject> = (candidateState: State) => boolean\r\n\r\n/**\r\n * Resolves a path within the state.\r\n * Throws if any segment is missing or has wrong type.\r\n */\r\nfunction resolvePath(state: JSONObject, path: Path): JSONValue {\r\n  let current: JSONValue = state\r\n  for (const segment of path) {\r\n    if (typeof segment === \"string\") {\r\n      if (!isObject(current) || Array.isArray(current)) {\r\n        failure(`Expected object at path segment \"${segment}\"`)\r\n      }\r\n      if (!(segment in current)) {\r\n        failure(`Property \"${segment}\" does not exist`)\r\n      }\r\n      current = current[segment]\r\n    } else {\r\n      if (!Array.isArray(current)) {\r\n        failure(`Expected array at path segment ${segment}`)\r\n      }\r\n      if (segment < 0 || segment >= current.length) {\r\n        failure(`Index ${segment} out of bounds`)\r\n      }\r\n      current = current[segment]\r\n    }\r\n  }\r\n  return current\r\n}\r\n\r\n/**\r\n * Applies a single operation.\r\n * (Reference implementation for standard JSON-patch behavior)\r\n */\r\nfunction applyOp(state: JSONObject, op: Op, cloneValues: boolean): void {\r\n  // Special case: if path is empty, we can't resolve \"container\".\r\n  // The caller must handle root-level replacement if necessary, but\r\n  // standard Ops usually act ON a container.\r\n  // Exception: if we act on root, handle explicitly or assume path length > 0.\r\n  // For this spec, Ops modify *fields* or *indices*.\r\n  // If path is empty, it means we are acting ON the root object itself?\r\n  // The spec's \"set\" example: container[op.key] = op.value.\r\n  // This implies we resolve path to get the PARENT container.\r\n\r\n  const container = resolvePath(state, op.path)\r\n\r\n  switch (op.kind) {\r\n    case \"set\":\r\n      if (!isObject(container) || Array.isArray(container)) {\r\n        failure(\"set requires object container\")\r\n      }\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      ;(container as any)[op.key] = cloneValues ? deepClone(op.value) : op.value\r\n      break\r\n\r\n    case \"delete\":\r\n      if (!isObject(container) || Array.isArray(container)) {\r\n        failure(\"delete requires object container\")\r\n      }\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      delete (container as any)[op.key]\r\n      break\r\n\r\n    case \"splice\": {\r\n      if (!Array.isArray(container)) {\r\n        failure(\"splice requires array container\")\r\n      }\r\n      const safeIndex = Math.min(op.index, container.length)\r\n      container.splice(\r\n        safeIndex,\r\n        op.deleteCount,\r\n        ...(cloneValues ? op.inserts.map((v) => deepClone(v)) : op.inserts)\r\n      )\r\n      break\r\n    }\r\n\r\n    case \"addToSet\":\r\n      if (!Array.isArray(container)) {\r\n        failure(\"addToSet requires array container\")\r\n      }\r\n      if (!container.some((item) => deepEqual(item, op.value))) {\r\n        container.push(cloneValues ? deepClone(op.value) : op.value)\r\n      }\r\n      break\r\n\r\n    case \"deleteFromSet\":\r\n      if (!Array.isArray(container)) {\r\n        failure(\"deleteFromSet requires array container\")\r\n      }\r\n      // Remove all matching items using splice (from end to avoid index shifting)\r\n      for (let i = container.length - 1; i >= 0; i--) {\r\n        if (deepEqual(container[i], op.value)) {\r\n          container.splice(i, 1)\r\n        }\r\n      }\r\n      break\r\n\r\n    default:\r\n      throw failure(`Unknown operation kind: ${(op as any).kind}`)\r\n  }\r\n}\r\n\r\n/**\r\n * Options for applyOps.\r\n */\r\nexport interface ApplyOpsOptions {\r\n  /**\r\n   * Whether to deep clone values before inserting them into the target.\r\n   * - `true` (default): Values are cloned to prevent aliasing between the ops and target.\r\n   * - `false`: Values are used directly for better performance. Only use this if you\r\n   *   guarantee the op values won't be mutated after application.\r\n   */\r\n  cloneValues?: boolean\r\n}\r\n\r\n/**\r\n * Applies a list of operations to a mutable target object.\r\n * Use this to synchronize an external mutable state (e.g., MobX store)\r\n * with the operations received via subscribe().\r\n *\r\n * @param ops - The list of operations to apply.\r\n * @param target - The mutable object to modify.\r\n * @param options - Optional settings for controlling cloning behavior.\r\n */\r\nexport function applyOps(ops: readonly Op[], target: JSONObject, options?: ApplyOpsOptions): void {\r\n  const cloneValues = options?.cloneValues ?? true\r\n  for (const op of ops) {\r\n    applyOp(target, op, cloneValues)\r\n  }\r\n}\r\n"],"names":["equal","scopedUrlAlphabet","rfdc","handler","clone"],"mappings":"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","x_google_ignoreList":[3,4,5,6]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"state-sync-log.esm.mjs","sources":["../src/error.ts","../src/createOps/constant.ts","../src/createOps/interface.ts","../src/createOps/utils.ts","../src/createOps/current.ts","../../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js","../../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js","../../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.browser.js","../../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js","../src/utils.ts","../src/createOps/pushOp.ts","../src/createOps/draft.ts","../src/createOps/draftify.ts","../src/createOps/createOps.ts","../src/createOps/original.ts","../src/createOps/setHelpers.ts","../src/checkpointUtils.ts","../src/checkpoints.ts","../src/draft.ts","../src/reconcile.ts","../src/txTimestamp.ts","../src/SortedTxEntry.ts","../src/StateCalculator.ts","../src/clientState.ts","../src/txLog.ts","../src/createStateSyncLog.ts","../src/operations.ts"],"sourcesContent":["export class StateSyncLogError extends Error {\n  constructor(msg: string) {\n    super(msg)\n\n    // Set the prototype explicitly for better instanceof support\n    Object.setPrototypeOf(this, StateSyncLogError.prototype)\n  }\n}\n\nexport function failure(message: string): never {\n  throw new StateSyncLogError(message)\n}\n","/**\r\n * Constants for createOps.\r\n * Simplified from original source - removed dataTypes (mark feature).\r\n */\r\n\r\n// Symbol to identify proxy drafts - accessible for 3rd party\r\nexport const PROXY_DRAFT = Symbol.for(\"__CREATEOPS_PROXY_DRAFT__\")\r\n\r\n// Symbol iterator\r\nexport const iteratorSymbol: typeof Symbol.iterator = Symbol.iterator\r\n","/**\r\n * createOps interface types.\r\n * Simplified from mutative - removed patches, autoFreeze, strict mode, mark, Map/Set support.\r\n */\r\n\r\nimport type { JSONPrimitive, JSONValue, Path } from \"../json\"\r\nimport type { Op } from \"../operations\"\r\n\r\nexport type { Op, Path, JSONValue }\r\n\r\nexport enum DraftType {\r\n  Object = 0,\r\n  Array = 1,\r\n}\r\n\r\n/**\r\n * Finalities - shared state for the draft tree\r\n */\r\nexport interface Finalities {\r\n  /** Finalization callbacks (for unwrapping child drafts) */\r\n  draft: (() => void)[]\r\n  /** Revoke functions for all proxies */\r\n  revoke: (() => void)[]\r\n  /** Set of handled objects (for cycle detection) */\r\n  handledSet: WeakSet<object>\r\n  /** Cache of created drafts */\r\n  draftsCache: WeakSet<object>\r\n  /** List of operations performed in this draft session (eager logging) */\r\n  ops: Op[]\r\n  /** Root draft of the tree (set when creating the root draft) */\r\n  rootDraft: ProxyDraft | null\r\n}\r\n\r\n/**\r\n * Internal proxy draft state\r\n */\r\nexport interface ProxyDraft<T = any> {\r\n  /** Type of the draft (Object or Array) */\r\n  type: DraftType\r\n  /** Whether this draft has been mutated */\r\n  operated?: boolean\r\n  /** Whether finalization has been completed */\r\n  finalized: boolean\r\n  /** The original (unmodified) value */\r\n  original: T\r\n  /** The shallow copy (created on first mutation) */\r\n  copy: T | null\r\n  /** The proxy instance */\r\n  proxy: T | null\r\n  /** Finalities container (shared across draft tree) */\r\n  finalities: Finalities\r\n  /** Parent draft (for path tracking) */\r\n  parent?: ProxyDraft | null\r\n  /** Key in parent */\r\n  key?: string | number\r\n  /** Track which keys have been assigned (key -> true=assigned, false=deleted) */\r\n  assignedMap?: Map<PropertyKey, boolean>\r\n  /** Count of positions this draft exists at (for aliasing optimization) */\r\n  aliasCount: number\r\n}\r\n\r\n/**\r\n * Result of createOps\r\n */\r\nexport interface CreateOpsResult<T> {\r\n  /** The new immutable state */\r\n  nextState: T\r\n  /** The operations that were performed */\r\n  ops: Op[]\r\n}\r\n\r\n// ============================================================================\r\n// Type Utilities\r\n// ============================================================================\r\n\r\n/** Primitive types that don't need drafting */\r\ntype Primitive = JSONPrimitive\r\n\r\n/**\r\n * Draft type - makes all properties mutable for editing\r\n */\r\nexport type Draft<T> = T extends Primitive\r\n  ? T\r\n  : T extends object\r\n    ? { -readonly [K in keyof T]: Draft<T[K]> }\r\n    : T\r\n\r\n/**\r\n * Immutable type - makes all properties readonly\r\n */\r\nexport type Immutable<T> = T extends Primitive\r\n  ? T\r\n  : T extends object\r\n    ? { readonly [K in keyof T]: Immutable<T[K]> }\r\n    : T\r\n","/**\r\n * Utility functions for proxy drafts.\r\n * Adapted from mutative - removed Map/Set support, mark, deepFreeze.\r\n */\r\n\r\nimport { failure } from \"../error\"\r\nimport { PROXY_DRAFT } from \"./constant\"\r\nimport { DraftType, type ProxyDraft } from \"./interface\"\r\n\r\n// ============================================================================\r\n// Core Draft Utilities\r\n// ============================================================================\r\n\r\n/**\r\n * Get the latest value (copy if exists, otherwise original)\r\n */\r\nexport function latest<T>(proxyDraft: ProxyDraft<T>): T {\r\n  return (proxyDraft.copy ?? proxyDraft.original) as T\r\n}\r\n\r\n/**\r\n * Check if the value is a draft\r\n */\r\nexport function isDraft(target: unknown): boolean {\r\n  return !!getProxyDraft(target)\r\n}\r\n\r\n/**\r\n * Get the ProxyDraft from a draft value\r\n */\r\nexport function getProxyDraft<T>(value: unknown): ProxyDraft<T> | null {\r\n  if (typeof value !== \"object\" || value === null) return null\r\n  return (value as { [PROXY_DRAFT]?: ProxyDraft<T> })[PROXY_DRAFT] ?? null\r\n}\r\n\r\n/**\r\n * Get the actual value from a draft (copy or original)\r\n */\r\nexport function getValue<T extends object>(value: T): T {\r\n  const proxyDraft = getProxyDraft(value)\r\n  return proxyDraft ? ((proxyDraft.copy ?? proxyDraft.original) as T) : value\r\n}\r\n\r\n/**\r\n * Check if a value is draftable (plain object or array)\r\n * We only support plain objects and arrays - no Map, Set, Date, etc.\r\n */\r\nexport function isDraftable(value: unknown): value is object {\r\n  if (value === null || typeof value !== \"object\") return false\r\n  return Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype\r\n}\r\n\r\n/**\r\n * Get the draft type\r\n */\r\nexport function getType(target: unknown): DraftType {\r\n  return Array.isArray(target) ? DraftType.Array : DraftType.Object\r\n}\r\n\r\n/**\r\n * Get a value by key\r\n */\r\nexport function get(target: object, key: PropertyKey): unknown {\r\n  return (target as Record<PropertyKey, unknown>)[key]\r\n}\r\n\r\n/**\r\n * Set a value by key\r\n */\r\nexport function set(target: object, key: PropertyKey, value: unknown): void {\r\n  ;(target as Record<PropertyKey, unknown>)[key] = value\r\n}\r\n\r\n/**\r\n * Check if a key exists (own property)\r\n */\r\nexport function has(target: object, key: PropertyKey): boolean {\r\n  return Object.hasOwn(target, key as string)\r\n}\r\n\r\n/**\r\n * Peek at a value (through drafts)\r\n */\r\nexport function peek(target: object, key: PropertyKey): unknown {\r\n  const state = getProxyDraft(target)\r\n  const source = state ? latest(state) : target\r\n  return (source as Record<PropertyKey, unknown>)[key]\r\n}\r\n\r\n/**\r\n * SameValue comparison (handles -0 and NaN)\r\n */\r\nexport function isEqual(x: unknown, y: unknown): boolean {\r\n  if (x === y) {\r\n    return x !== 0 || 1 / (x as number) === 1 / (y as number)\r\n  }\r\n  // biome-ignore lint/suspicious/noSelfCompare: NaN check pattern (NaN !== NaN)\r\n  return x !== x && y !== y\r\n}\r\n\r\n/**\r\n * Revoke all proxies in a draft tree\r\n */\r\nexport function revokeProxy(proxyDraft: ProxyDraft | null): void {\r\n  if (!proxyDraft) return\r\n  while (proxyDraft.finalities.revoke.length > 0) {\r\n    const revoke = proxyDraft.finalities.revoke.pop()!\r\n    revoke()\r\n  }\r\n}\r\n\r\n/**\r\n * Get the path from root to this draft\r\n */\r\nexport function getPath(\r\n  target: ProxyDraft,\r\n  path: (string | number)[] = []\r\n): (string | number)[] | null {\r\n  if (Object.hasOwn(target, \"key\") && target.key !== undefined) {\r\n    // Check if the parent still has this draft at this key\r\n    const parentCopy = target.parent?.copy\r\n    if (parentCopy) {\r\n      const proxyDraft = getProxyDraft(get(parentCopy as object, target.key))\r\n      if (proxyDraft !== null && proxyDraft.original !== target.original) {\r\n        return null\r\n      }\r\n    }\r\n    path.push(target.key)\r\n  }\r\n  if (target.parent) {\r\n    return getPath(target.parent, path)\r\n  }\r\n  // target is root draft\r\n  path.reverse()\r\n  return path\r\n}\r\n\r\n/**\r\n * Get the path from root to this draft, or throw if not available\r\n */\r\nexport function getPathOrThrow(target: ProxyDraft): (string | number)[] {\r\n  const path = getPath(target)\r\n  if (!path) {\r\n    throw failure(\"Cannot determine path for operation\")\r\n  }\r\n  return path\r\n}\r\n\r\n/**\r\n * Find all paths to a given draft by searching the tree.\r\n * This handles aliasing where the same draft exists at multiple positions.\r\n */\r\nexport function getAllPathsForDraft(\r\n  rootDraft: ProxyDraft,\r\n  targetDraft: ProxyDraft\r\n): (string | number)[][] {\r\n  const result: (string | number)[][] = []\r\n\r\n  function search(current: ProxyDraft, currentPath: (string | number)[]): void {\r\n    if (current === targetDraft) {\r\n      result.push([...currentPath])\r\n      // Don't return - the same draft could be nested inside itself (unlikely but possible)\r\n    }\r\n\r\n    const source = latest(current) as Record<string | number, unknown>\r\n    if (!source || typeof source !== \"object\") return\r\n\r\n    const keys: (string | number)[] = Array.isArray(source)\r\n      ? Array.from({ length: source.length }, (_, i) => i)\r\n      : Object.keys(source)\r\n\r\n    for (const key of keys) {\r\n      const value = source[key]\r\n      const childDraft = getProxyDraft(value)\r\n      if (childDraft) {\r\n        search(childDraft, [...currentPath, key])\r\n      }\r\n    }\r\n  }\r\n\r\n  search(rootDraft, [])\r\n  return result\r\n}\r\n\r\n/**\r\n * Get a property descriptor from the prototype chain\r\n */\r\nexport function getDescriptor(target: object, key: PropertyKey): PropertyDescriptor | undefined {\r\n  if (key in target) {\r\n    let prototype = Reflect.getPrototypeOf(target)\r\n    while (prototype) {\r\n      const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key)\r\n      if (descriptor) return descriptor\r\n      prototype = Reflect.getPrototypeOf(prototype)\r\n    }\r\n  }\r\n  return undefined\r\n}\r\n\r\n// ============================================================================\r\n// Copy Utilities\r\n// ============================================================================\r\n\r\nconst propIsEnum = Object.prototype.propertyIsEnumerable\r\n\r\n/**\r\n * Create a shallow copy of an object or array\r\n */\r\nexport function shallowCopy<T>(original: T): T {\r\n  if (Array.isArray(original)) {\r\n    return Array.prototype.concat.call(original) as T\r\n  }\r\n  // Plain object - use optimized copy\r\n  const copy: Record<string | symbol, unknown> = {}\r\n  for (const key of Object.keys(original as object)) {\r\n    copy[key] = (original as Record<string, unknown>)[key]\r\n  }\r\n  for (const key of Object.getOwnPropertySymbols(original as object)) {\r\n    if (propIsEnum.call(original, key)) {\r\n      copy[key] = (original as Record<symbol, unknown>)[key]\r\n    }\r\n  }\r\n  return copy as T\r\n}\r\n\r\n/**\r\n * Ensure a draft has a shallow copy\r\n */\r\nexport function ensureShallowCopy(target: ProxyDraft): void {\r\n  if (target.copy) return\r\n  target.copy = shallowCopy(target.original)\r\n  target.assignedMap = target.assignedMap ?? new Map()\r\n}\r\n\r\n/**\r\n * Deep clone a value, unwrapping any drafts\r\n */\r\nexport function deepClone<T>(target: T): T {\r\n  if (!isDraftable(target)) {\r\n    return isDraft(target) ? (getValue(target as object) as T) : target\r\n  }\r\n  if (Array.isArray(target)) {\r\n    return target.map(deepClone) as T\r\n  }\r\n  const copy: Record<string, unknown> = {}\r\n  for (const key in target) {\r\n    if (has(target, key)) {\r\n      copy[key] = deepClone((target as Record<string, unknown>)[key])\r\n    }\r\n  }\r\n  return copy as T\r\n}\r\n\r\n/**\r\n * Clone if the value is a draft, otherwise return as-is\r\n */\r\nexport function cloneIfNeeded<T>(target: T): T {\r\n  return isDraft(target) ? deepClone(target) : target\r\n}\r\n\r\n// ============================================================================\r\n// Draft State Utilities\r\n// ============================================================================\r\n\r\n/**\r\n * Mark a draft as changed (operated)\r\n */\r\nexport function markChanged(target: ProxyDraft): void {\r\n  if (!target.operated) {\r\n    target.operated = true\r\n    if (target.parent) {\r\n      markChanged(target.parent)\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Iterate over object/array entries\r\n */\r\nexport function forEach<T extends object>(\r\n  target: T,\r\n  callback: (key: PropertyKey, value: unknown, target: T) => void\r\n): void {\r\n  if (Array.isArray(target)) {\r\n    for (let i = 0; i < target.length; i++) {\r\n      callback(i, target[i], target)\r\n    }\r\n  } else {\r\n    for (const key of Reflect.ownKeys(target)) {\r\n      callback(key, (target as Record<PropertyKey, unknown>)[key], target)\r\n    }\r\n  }\r\n}\r\n\r\n// ============================================================================\r\n// Finalization Utilities\r\n// ============================================================================\r\n\r\n/**\r\n * Handle nested values during finalization\r\n */\r\nexport function handleValue(target: unknown, handledSet: WeakSet<object>): void {\r\n  if (\r\n    !isDraftable(target) ||\r\n    isDraft(target) ||\r\n    handledSet.has(target as object) ||\r\n    Object.isFrozen(target)\r\n  ) {\r\n    return\r\n  }\r\n\r\n  handledSet.add(target as object)\r\n\r\n  forEach(target as object, (key, value) => {\r\n    if (isDraft(value)) {\r\n      const proxyDraft = getProxyDraft(value)!\r\n      ensureShallowCopy(proxyDraft)\r\n      const updatedValue =\r\n        proxyDraft.assignedMap?.size || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original\r\n      set(target as object, key, updatedValue)\r\n    } else {\r\n      handleValue(value, handledSet)\r\n    }\r\n  })\r\n}\r\n","/**\r\n * Get the current value from a draft (snapshot).\r\n * Adapted from mutative - simplified for plain objects/arrays only.\r\n */\r\n\r\nimport type { Draft } from \"./interface\"\r\nimport {\r\n  forEach,\r\n  get,\r\n  getProxyDraft,\r\n  isDraft,\r\n  isDraftable,\r\n  isEqual,\r\n  set,\r\n  shallowCopy,\r\n} from \"./utils\"\r\n\r\n/**\r\n * Get current state from a value (handles nested drafts)\r\n */\r\nfunction getCurrent<T>(target: T): T {\r\n  const proxyDraft = getProxyDraft(target)\r\n\r\n  // Not draftable - return as-is\r\n  if (!isDraftable(target)) return target\r\n\r\n  // Draft that hasn't been modified - return original\r\n  if (proxyDraft && !proxyDraft.operated) {\r\n    return proxyDraft.original as T\r\n  }\r\n\r\n  let currentValue: T | undefined\r\n\r\n  function ensureShallowCopyLocal() {\r\n    currentValue = shallowCopy(target)\r\n  }\r\n\r\n  if (proxyDraft) {\r\n    // It's a draft - create a shallow copy eagerly\r\n    proxyDraft.finalized = true\r\n    try {\r\n      ensureShallowCopyLocal()\r\n    } finally {\r\n      proxyDraft.finalized = false\r\n    }\r\n  } else {\r\n    // Not a draft - use target directly, copy lazily if needed\r\n    currentValue = target\r\n  }\r\n\r\n  // Recursively process children\r\n  forEach(currentValue as object, (key, value) => {\r\n    if (proxyDraft && isEqual(get(proxyDraft.original as object, key), value)) {\r\n      return\r\n    }\r\n    const newValue = getCurrent(value)\r\n    if (newValue !== value) {\r\n      if (currentValue === target) {\r\n        ensureShallowCopyLocal()\r\n      }\r\n      set(currentValue as object, key, newValue)\r\n    }\r\n  })\r\n\r\n  return currentValue as T\r\n}\r\n\r\n/**\r\n * `current(draft)` to get current state in the draft mutation function.\r\n *\r\n * @example\r\n * ```ts\r\n * const { nextState, ops } = createOps(baseState, (draft) => {\r\n *   draft.foo.bar = 'new value';\r\n *   console.log(current(draft.foo)); // { bar: 'new value' }\r\n * });\r\n * ```\r\n */\r\nexport function current<T extends object>(target: Draft<T>): T\r\nexport function current<T extends object>(target: T | Draft<T>): T {\r\n  if (!isDraft(target)) {\r\n    throw new Error(`current() is only used for Draft, parameter: ${target}`)\r\n  }\r\n  return getCurrent(target) as T\r\n}\r\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","export const urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n","/* @ts-self-types=\"./index.d.ts\" */\nimport { urlAlphabet as scopedUrlAlphabet } from './url-alphabet/index.js'\nexport { urlAlphabet } from './url-alphabet/index.js'\nexport let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))\nexport let customRandom = (alphabet, defaultSize, getRandom) => {\n  let mask = (2 << Math.log2(alphabet.length - 1)) - 1\n  let step = -~((1.6 * mask * defaultSize) / alphabet.length)\n  return (size = defaultSize) => {\n    let id = ''\n    while (true) {\n      let bytes = getRandom(step)\n      let j = step | 0\n      while (j--) {\n        id += alphabet[bytes[j] & mask] || ''\n        if (id.length >= size) return id\n      }\n    }\n  }\n}\nexport let customAlphabet = (alphabet, size = 21) =>\n  customRandom(alphabet, size | 0, random)\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)))\n  while (size--) {\n    id += scopedUrlAlphabet[bytes[size] & 63]\n  }\n  return id\n}\n","'use strict'\nmodule.exports = rfdc\n\nfunction copyBuffer (cur) {\n  if (cur instanceof Buffer) {\n    return Buffer.from(cur)\n  }\n\n  return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length)\n}\n\nfunction rfdc (opts) {\n  opts = opts || {}\n  if (opts.circles) return rfdcCircles(opts)\n\n  const constructorHandlers = new Map()\n  constructorHandlers.set(Date, (o) => new Date(o))\n  constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)))\n  constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)))\n  if (opts.constructorHandlers) {\n    for (const handler of opts.constructorHandlers) {\n      constructorHandlers.set(handler[0], handler[1])\n    }\n  }\n\n  let handler = null\n\n  return opts.proto ? cloneProto : clone\n\n  function cloneArray (a, fn) {\n    const keys = Object.keys(a)\n    const a2 = new Array(keys.length)\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i]\n      const cur = a[k]\n      if (typeof cur !== 'object' || cur === null) {\n        a2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        a2[k] = handler(cur, fn)\n      } else if (ArrayBuffer.isView(cur)) {\n        a2[k] = copyBuffer(cur)\n      } else {\n        a2[k] = fn(cur)\n      }\n    }\n    return a2\n  }\n\n  function clone (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, clone)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, clone)\n    }\n    const o2 = {}\n    for (const k in o) {\n      if (Object.hasOwnProperty.call(o, k) === false) continue\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, clone)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        o2[k] = clone(cur)\n      }\n    }\n    return o2\n  }\n\n  function cloneProto (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, cloneProto)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, cloneProto)\n    }\n    const o2 = {}\n    for (const k in o) {\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, cloneProto)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        o2[k] = cloneProto(cur)\n      }\n    }\n    return o2\n  }\n}\n\nfunction rfdcCircles (opts) {\n  const refs = []\n  const refsNew = []\n\n  const constructorHandlers = new Map()\n  constructorHandlers.set(Date, (o) => new Date(o))\n  constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)))\n  constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)))\n  if (opts.constructorHandlers) {\n    for (const handler of opts.constructorHandlers) {\n      constructorHandlers.set(handler[0], handler[1])\n    }\n  }\n\n  let handler = null\n  return opts.proto ? cloneProto : clone\n\n  function cloneArray (a, fn) {\n    const keys = Object.keys(a)\n    const a2 = new Array(keys.length)\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i]\n      const cur = a[k]\n      if (typeof cur !== 'object' || cur === null) {\n        a2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        a2[k] = handler(cur, fn)\n      } else if (ArrayBuffer.isView(cur)) {\n        a2[k] = copyBuffer(cur)\n      } else {\n        const index = refs.indexOf(cur)\n        if (index !== -1) {\n          a2[k] = refsNew[index]\n        } else {\n          a2[k] = fn(cur)\n        }\n      }\n    }\n    return a2\n  }\n\n  function clone (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, clone)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, clone)\n    }\n    const o2 = {}\n    refs.push(o)\n    refsNew.push(o2)\n    for (const k in o) {\n      if (Object.hasOwnProperty.call(o, k) === false) continue\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, clone)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        const i = refs.indexOf(cur)\n        if (i !== -1) {\n          o2[k] = refsNew[i]\n        } else {\n          o2[k] = clone(cur)\n        }\n      }\n    }\n    refs.pop()\n    refsNew.pop()\n    return o2\n  }\n\n  function cloneProto (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, cloneProto)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, cloneProto)\n    }\n    const o2 = {}\n    refs.push(o)\n    refsNew.push(o2)\n    for (const k in o) {\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, cloneProto)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        const i = refs.indexOf(cur)\n        if (i !== -1) {\n          o2[k] = refsNew[i]\n        } else {\n          o2[k] = cloneProto(cur)\n        }\n      }\n    }\n    refs.pop()\n    refsNew.pop()\n    return o2\n  }\n}\n","import equal from \"fast-deep-equal\"\r\nimport { nanoid } from \"nanoid\"\r\nimport rfdc from \"rfdc\"\r\nimport type { JSONValue } from \"./json\"\r\n\r\nconst clone = rfdc({ proto: true })\r\n\r\n/**\r\n * Deep equality check for JSONValues.\r\n * Used for addToSet / deleteFromSet operations.\r\n */\r\nexport function deepEqual(a: JSONValue, b: JSONValue): boolean {\r\n  return equal(a, b)\r\n}\r\n\r\n/**\r\n * Generates a unique ID using nanoid.\r\n */\r\nexport function generateID(): string {\r\n  return nanoid()\r\n}\r\n\r\n/**\r\n * Checks if a value is an object (typeof === \"object\" && !== null).\r\n */\r\nexport function isObject(value: unknown): value is object {\r\n  return value !== null && typeof value === \"object\"\r\n}\r\n\r\n/**\r\n * Deep clones a JSON-serializable value.\r\n * Optimized: primitives are returned as-is.\r\n */\r\nexport function deepClone<T>(value: T): T {\r\n  // Primitives don't need cloning\r\n  if (value === null || typeof value !== \"object\") {\r\n    return value\r\n  }\r\n  return clone(value)\r\n}\r\n\r\n/**\r\n * Creates a lazy memoized getter.\r\n */\r\nexport function lazy<T>(fn: () => T): () => T {\r\n  let computed = false\r\n  let value: T\r\n  return () => {\r\n    if (!computed) {\r\n      value = fn()\r\n      computed = true\r\n    }\r\n    return value\r\n  }\r\n}\r\n\r\n/**\r\n * Checks if a string is a valid non-negative integer array index.\r\n * Returns the numeric value if valid, or null if invalid.\r\n */\r\nexport function parseArrayIndex(key: string): number | null {\r\n  const n = Number(key)\r\n  if (!Number.isInteger(n) || n < 0) {\r\n    return null\r\n  }\r\n  return n\r\n}\r\n","/**\r\n * Eager op generation - ops are pushed immediately when mutations happen.\r\n *\r\n * This module provides the pushOp function that records operations at mutation time,\r\n * rather than diffing at finalization time.\r\n *\r\n * When a draft exists at multiple positions (aliasing), ops are emitted for ALL positions\r\n * to ensure consistency when applied.\r\n */\r\n\r\nimport { failure } from \"../error\"\r\nimport type { Op, ProxyDraft } from \"./interface\"\r\nimport { getAllPathsForDraft } from \"./utils\"\r\n\r\n/**\r\n * Push an operation to the ops log.\r\n * Values should already be cloned by the caller to avoid aliasing issues.\r\n *\r\n * When the target draft exists at multiple positions (due to aliasing),\r\n * this function emits ops for all positions to maintain consistency.\r\n */\r\nexport function pushOp(proxyDraft: ProxyDraft, op: Op): void {\r\n  const rootDraft = proxyDraft.finalities.rootDraft\r\n  if (!rootDraft) {\r\n    throw failure(\"rootDraft is not set - cannot emit op\")\r\n  }\r\n\r\n  // Fast path: no aliasing, just emit the single op\r\n  if (proxyDraft.aliasCount <= 1) {\r\n    proxyDraft.finalities.ops.push(op)\r\n    return\r\n  }\r\n\r\n  // Slow path: draft exists at multiple positions, find all paths\r\n  const allPaths = getAllPathsForDraft(rootDraft, proxyDraft)\r\n\r\n  // Emit the op for each path where this draft exists\r\n  for (const path of allPaths) {\r\n    const adjustedOp = { ...op, path }\r\n    proxyDraft.finalities.ops.push(adjustedOp)\r\n  }\r\n}\r\n","/**\r\n * Proxy draft implementation.\r\n * Adapted from mutative - removed Map/Set/unsafe/mark support.\r\n * Modified to use eager op logging - ops are pushed immediately when mutations happen.\r\n */\r\n\r\nimport { parseArrayIndex } from \"../utils\"\r\nimport { PROXY_DRAFT } from \"./constant\"\r\nimport { DraftType, type Finalities, type JSONValue, type Op, type ProxyDraft } from \"./interface\"\r\nimport { pushOp } from \"./pushOp\"\r\nimport {\r\n  deepClone,\r\n  ensureShallowCopy,\r\n  get,\r\n  getDescriptor,\r\n  getPathOrThrow,\r\n  getProxyDraft,\r\n  getType,\r\n  getValue,\r\n  handleValue,\r\n  has,\r\n  isDraft,\r\n  isDraftable,\r\n  isEqual,\r\n  latest,\r\n  markChanged,\r\n  peek,\r\n  revokeProxy,\r\n  set,\r\n} from \"./utils\"\r\n\r\n// Note: getValue is used in finalizeDraft, deepClone uses it internally for drafts\r\n\r\n/**\r\n * Increment aliasCount for a draft (if the value is a draft).\r\n */\r\nfunction incAliasCount(value: unknown): void {\r\n  const draft = getProxyDraft(value)\r\n  if (draft) draft.aliasCount++\r\n}\r\n\r\n/**\r\n * Decrement aliasCount for a draft (if the value is a draft).\r\n */\r\nfunction decAliasCount(value: unknown): void {\r\n  const draft = getProxyDraft(value)\r\n  if (draft) draft.aliasCount--\r\n}\r\n\r\n/**\r\n * Normalize an array index like native array methods do.\r\n * Handles negative indices and clamps to [0, len].\r\n * @param index - The index to normalize (can be negative or undefined)\r\n * @param len - The array length\r\n * @param defaultValue - Value to use if index is undefined (typically 0 or len)\r\n */\r\nfunction normalizeIndex(index: number | undefined, len: number, defaultValue: number): number {\r\n  if (index === undefined) return defaultValue\r\n  return index < 0 ? Math.max(len + index, 0) : Math.min(index, len)\r\n}\r\n\r\n/**\r\n * Array methods that mutate the array and need to be intercepted for eager op logging.\r\n */\r\nconst MUTATING_ARRAY_METHODS = new Set([\r\n  \"push\",\r\n  \"pop\",\r\n  \"shift\",\r\n  \"unshift\",\r\n  \"splice\",\r\n  \"sort\",\r\n  \"reverse\",\r\n  \"fill\",\r\n  \"copyWithin\",\r\n])\r\n\r\n/**\r\n * Create a wrapped array method that logs ops eagerly.\r\n * @param proxyDraft - The ProxyDraft for the array (used for ops and state)\r\n * @param proxyRef - The actual proxy (used to access elements as drafts)\r\n * @param method - The method name being wrapped\r\n */\r\nfunction createArrayMethodWrapper(\r\n  proxyDraft: ProxyDraft,\r\n  proxyRef: unknown,\r\n  method: string\r\n): (...args: unknown[]) => unknown {\r\n  return function (this: unknown[], ...args: unknown[]): unknown {\r\n    ensureShallowCopy(proxyDraft)\r\n    markChanged(proxyDraft)\r\n\r\n    const arr = proxyDraft.copy as unknown[]\r\n    const originalLength = arr.length\r\n    const proxy = proxyRef as unknown[]\r\n\r\n    switch (method) {\r\n      case \"push\": {\r\n        // push(items...) -> splice at end\r\n        // Track aliasCount for drafts being inserted\r\n        for (const arg of args) {\r\n          incAliasCount(arg)\r\n        }\r\n        // Store raw values in array (preserving aliasing in the draft)\r\n        const result = arr.push(...args)\r\n        // Clone for the op (capture value at this moment)\r\n        pushOp(proxyDraft, {\r\n          kind: \"splice\",\r\n          path: getPathOrThrow(proxyDraft),\r\n          index: originalLength,\r\n          deleteCount: 0,\r\n          inserts: args.map(deepClone) as JSONValue[],\r\n        })\r\n        return result\r\n      }\r\n\r\n      case \"pop\": {\r\n        if (originalLength === 0) {\r\n          return arr.pop()\r\n        }\r\n        // Get the element through the proxy to ensure it's a draft if draftable\r\n        const returnValue = proxy[originalLength - 1]\r\n        // Track aliasCount for draft being removed\r\n        decAliasCount(arr[originalLength - 1])\r\n        // Now perform the actual mutation\r\n        arr.pop()\r\n        pushOp(proxyDraft, {\r\n          kind: \"splice\",\r\n          path: getPathOrThrow(proxyDraft),\r\n          index: originalLength - 1,\r\n          deleteCount: 1,\r\n          inserts: [],\r\n        })\r\n        return returnValue\r\n      }\r\n\r\n      case \"shift\": {\r\n        if (originalLength === 0) {\r\n          return arr.shift()\r\n        }\r\n        // Get the element through the proxy to ensure it's a draft if draftable\r\n        const returnValue = proxy[0]\r\n        // Track aliasCount for draft being removed\r\n        decAliasCount(arr[0])\r\n        // Now perform the actual mutation\r\n        arr.shift()\r\n        pushOp(proxyDraft, {\r\n          kind: \"splice\",\r\n          path: getPathOrThrow(proxyDraft),\r\n          index: 0,\r\n          deleteCount: 1,\r\n          inserts: [],\r\n        })\r\n        return returnValue\r\n      }\r\n\r\n      case \"unshift\": {\r\n        // Track aliasCount for drafts being inserted\r\n        for (const arg of args) {\r\n          incAliasCount(arg)\r\n        }\r\n        // Store raw values in array (preserving aliasing in the draft)\r\n        const result = arr.unshift(...args)\r\n        // Clone for the op (capture value at this moment)\r\n        pushOp(proxyDraft, {\r\n          kind: \"splice\",\r\n          path: getPathOrThrow(proxyDraft),\r\n          index: 0,\r\n          deleteCount: 0,\r\n          inserts: args.map(deepClone) as JSONValue[],\r\n        })\r\n        return result\r\n      }\r\n\r\n      case \"splice\": {\r\n        const start = args[0] as number | undefined\r\n        const deleteCountArg = args[1] as number | undefined\r\n        const inserts = args.slice(2)\r\n\r\n        // Normalize start index to get elements through proxy\r\n        const index =\r\n          start === undefined ? 0 : start < 0 ? Math.max(originalLength + start, 0) : start\r\n        const deleteCount = deleteCountArg ?? originalLength - index\r\n\r\n        // Get elements through proxy to ensure they're drafts if draftable\r\n        const returnValues: unknown[] = []\r\n        for (let i = 0; i < deleteCount && index + i < originalLength; i++) {\r\n          returnValues.push(proxy[index + i])\r\n          // Track aliasCount for drafts being removed\r\n          decAliasCount(arr[index + i])\r\n        }\r\n\r\n        // Track aliasCount for drafts being inserted\r\n        for (const insert of inserts) {\r\n          incAliasCount(insert)\r\n        }\r\n        // Store raw values in array (preserving aliasing in the draft)\r\n        ;(arr.splice as (...args: unknown[]) => unknown[])(...args)\r\n\r\n        // Clone for the op (capture value at this moment)\r\n        pushOp(proxyDraft, {\r\n          kind: \"splice\",\r\n          path: getPathOrThrow(proxyDraft),\r\n          index: start ?? 0,\r\n          deleteCount: deleteCountArg ?? originalLength,\r\n          inserts: inserts.map(deepClone) as JSONValue[],\r\n        })\r\n        return returnValues\r\n      }\r\n\r\n      case \"fill\": {\r\n        const fillValue = args[0]\r\n        const startArg = args[1] as number | undefined\r\n        const endArg = args[2] as number | undefined\r\n\r\n        const len = originalLength\r\n        const start = normalizeIndex(startArg, len, 0)\r\n        const end = normalizeIndex(endArg, len, len)\r\n\r\n        // Use proxy splice to replace the range (handles aliasCount and generates splice op)\r\n        const fillCount = end - start\r\n        if (fillCount > 0) {\r\n          const fillValues = Array(fillCount).fill(fillValue)\r\n          proxy.splice(start, fillCount, ...fillValues)\r\n        }\r\n\r\n        return proxy\r\n      }\r\n\r\n      case \"sort\": {\r\n        const compareFn = args[0] as ((a: unknown, b: unknown) => number) | undefined\r\n        // Sort a copy to get the sorted order, then use proxy splice\r\n        const sorted = [...arr].sort(compareFn)\r\n        if (originalLength > 0) {\r\n          proxy.splice(0, originalLength, ...sorted)\r\n        }\r\n        return proxy\r\n      }\r\n\r\n      case \"reverse\": {\r\n        // Reverse a copy to get the reversed order, then use proxy splice\r\n        const reversed = [...arr].reverse()\r\n        if (originalLength > 0) {\r\n          proxy.splice(0, originalLength, ...reversed)\r\n        }\r\n        return proxy\r\n      }\r\n\r\n      case \"copyWithin\": {\r\n        const targetArg = args[0] as number\r\n        const startArg = args[1] as number | undefined\r\n        const endArg = args[2] as number | undefined\r\n\r\n        const len = originalLength\r\n        const targetIdx = normalizeIndex(targetArg, len, 0)\r\n        const startIdx = normalizeIndex(startArg, len, 0)\r\n        const endIdx = normalizeIndex(endArg, len, len)\r\n\r\n        // Calculate how many elements will be copied\r\n        const copyCount = Math.min(endIdx - startIdx, len - targetIdx)\r\n\r\n        if (copyCount > 0) {\r\n          // Get the elements that will be copied (from the source range)\r\n          const elementsToCopy = arr.slice(startIdx, startIdx + copyCount)\r\n          // Use proxy splice to replace just the affected range\r\n          proxy.splice(targetIdx, copyCount, ...elementsToCopy)\r\n        }\r\n\r\n        return proxy\r\n      }\r\n\r\n      default:\r\n        return (arr as unknown as Record<string, (...args: unknown[]) => unknown>)[method](...args)\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Proxy handler for drafts\r\n */\r\nconst proxyHandler: ProxyHandler<ProxyDraft> = {\r\n  get(target: ProxyDraft, key: PropertyKey, receiver: unknown) {\r\n    // Return cached draft if available\r\n    const copy = target.copy?.[key as keyof typeof target.copy]\r\n    if (copy && target.finalities.draftsCache.has(copy as object)) {\r\n      return copy\r\n    }\r\n\r\n    // Return the ProxyDraft itself when accessing the symbol\r\n    if (key === PROXY_DRAFT) return target\r\n\r\n    const source = latest(target)\r\n\r\n    // Intercept mutating array methods for eager op logging\r\n    if (\r\n      target.type === DraftType.Array &&\r\n      typeof key === \"string\" &&\r\n      MUTATING_ARRAY_METHODS.has(key)\r\n    ) {\r\n      const originalMethod = (source as unknown[])[key as keyof unknown[]]\r\n      if (typeof originalMethod === \"function\") {\r\n        return createArrayMethodWrapper(target, receiver, key)\r\n      }\r\n    }\r\n\r\n    // Property doesn't exist - check prototype chain\r\n    if (!has(source, key)) {\r\n      const desc = getDescriptor(source, key)\r\n      return desc ? (\"value\" in desc ? desc.value : desc.get?.call(target.proxy)) : undefined\r\n    }\r\n\r\n    const value = (source as Record<PropertyKey, unknown>)[key]\r\n\r\n    // Already finalized or not draftable - return as-is\r\n    if (target.finalized || !isDraftable(value)) {\r\n      return value\r\n    }\r\n\r\n    // If value is same as original, create a nested draft\r\n    if (value === peek(target.original, key)) {\r\n      ensureShallowCopy(target)\r\n      const nestedKey = target.type === DraftType.Array ? Number(key) : key\r\n      ;(target.copy as Record<PropertyKey, unknown>)[key] = createDraft({\r\n        original: (target.original as Record<PropertyKey, unknown>)[key] as object,\r\n        parentDraft: target,\r\n        key: nestedKey as string | number,\r\n        finalities: target.finalities,\r\n      })\r\n      return (target.copy as Record<PropertyKey, unknown>)[key]\r\n    }\r\n\r\n    // Cache drafts that were assigned\r\n    if (isDraft(value)) {\r\n      target.finalities.draftsCache.add(value as object)\r\n    }\r\n\r\n    return value\r\n  },\r\n\r\n  set(target: ProxyDraft, key: PropertyKey, value: unknown) {\r\n    if (typeof key === \"symbol\") {\r\n      throw new Error(`Cannot set symbol properties on drafts`)\r\n    }\r\n\r\n    // For arrays, convert and validate the key\r\n    let opKey: string | number = key as string | number\r\n    if (target.type === DraftType.Array) {\r\n      if (key === \"length\") {\r\n        opKey = \"length\"\r\n      } else {\r\n        const numKey = typeof key === \"number\" ? key : parseArrayIndex(key as string)\r\n        if (numKey === null) {\r\n          throw new Error(`Only supports setting array indices and the 'length' property.`)\r\n        }\r\n        opKey = numKey\r\n\r\n        // Check for sparse array creation\r\n        const source = latest(target) as unknown[]\r\n        if (numKey > source.length) {\r\n          throw new Error(\r\n            `Cannot create sparse array. Index ${numKey} is out of bounds for array of length ${source.length}.`\r\n          )\r\n        }\r\n      }\r\n    }\r\n\r\n    // Handle setter from prototype\r\n    const desc = getDescriptor(latest(target), key)\r\n    if (desc?.set) {\r\n      desc.set.call(target.proxy, value)\r\n      return true\r\n    }\r\n\r\n    const current = peek(latest(target), key)\r\n    const currentProxyDraft = getProxyDraft(current)\r\n\r\n    // If assigning original draftable value back to its draft, just mark as not assigned\r\n    if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {\r\n      ;(target.copy as Record<PropertyKey, unknown>)[key] = value\r\n      target.assignedMap = target.assignedMap ?? new Map()\r\n      target.assignedMap.set(key, false)\r\n      return true\r\n    }\r\n\r\n    // No change - skip\r\n    if (isEqual(value, current) && (value !== undefined || has(target.original, key))) {\r\n      return true\r\n    }\r\n\r\n    ensureShallowCopy(target)\r\n    markChanged(target)\r\n\r\n    // Track assignment (still needed for finalization to know what changed)\r\n    if (\r\n      has(target.original, key) &&\r\n      isEqual(value, (target.original as Record<PropertyKey, unknown>)[key])\r\n    ) {\r\n      // Reverting to original value - still log the op since we're doing eager logging\r\n      target.assignedMap!.delete(key)\r\n    } else {\r\n      target.assignedMap!.set(key, true)\r\n    }\r\n\r\n    // Track aliasCount and update copy\r\n    const copy = target.copy as Record<PropertyKey, unknown>\r\n    decAliasCount(copy[key])\r\n    incAliasCount(value)\r\n    copy[key] = value\r\n\r\n    // Eager op logging for set operations\r\n    if (target.type === DraftType.Array && opKey === \"length\") {\r\n      const oldLength = (target.original as unknown[]).length\r\n      const newLength = value as number\r\n      if (newLength !== oldLength) {\r\n        // Length change - always use set op to capture intent\r\n        pushOp(target, {\r\n          kind: \"set\",\r\n          path: getPathOrThrow(target),\r\n          key: \"length\",\r\n          value: newLength,\r\n        })\r\n      }\r\n    } else {\r\n      // Regular property set - use opKey (numeric for arrays)\r\n      pushOp(target, {\r\n        kind: \"set\",\r\n        path: getPathOrThrow(target),\r\n        key: opKey,\r\n        value: deepClone(value) as JSONValue,\r\n      })\r\n    }\r\n\r\n    return true\r\n  },\r\n\r\n  has(target: ProxyDraft, key: PropertyKey) {\r\n    return key in latest(target)\r\n  },\r\n\r\n  ownKeys(target: ProxyDraft) {\r\n    return Reflect.ownKeys(latest(target))\r\n  },\r\n\r\n  getOwnPropertyDescriptor(target: ProxyDraft, key: PropertyKey) {\r\n    const source = latest(target)\r\n    const descriptor = Reflect.getOwnPropertyDescriptor(source, key)\r\n    if (!descriptor) return descriptor\r\n    return {\r\n      writable: true,\r\n      configurable: target.type !== DraftType.Array || key !== \"length\",\r\n      enumerable: descriptor.enumerable,\r\n      value: (source as Record<PropertyKey, unknown>)[key],\r\n    }\r\n  },\r\n\r\n  getPrototypeOf(target: ProxyDraft) {\r\n    return Reflect.getPrototypeOf(target.original as object)\r\n  },\r\n\r\n  setPrototypeOf() {\r\n    throw new Error(`Cannot call 'setPrototypeOf()' on drafts`)\r\n  },\r\n\r\n  defineProperty() {\r\n    throw new Error(`Cannot call 'defineProperty()' on drafts`)\r\n  },\r\n\r\n  deleteProperty(target: ProxyDraft, key: PropertyKey) {\r\n    if (typeof key === \"symbol\") {\r\n      throw new Error(`Cannot delete symbol properties from drafts`)\r\n    }\r\n\r\n    if (target.type === DraftType.Array) {\r\n      // For arrays, deleting a property sets it to undefined\r\n      return proxyHandler.set!.call(this, target, key as string | symbol, undefined, target.proxy)\r\n    }\r\n\r\n    // Check if property exists and get its current value\r\n    const current = peek(latest(target), key)\r\n    const existed = current !== undefined || key in (target.original as object)\r\n\r\n    // For objects, track deletion\r\n    if (existed) {\r\n      ensureShallowCopy(target)\r\n      markChanged(target)\r\n      target.assignedMap!.set(key, false)\r\n\r\n      // Eager op logging for delete\r\n      pushOp(target, {\r\n        kind: \"delete\",\r\n        path: getPathOrThrow(target),\r\n        key: key,\r\n      })\r\n\r\n      // Track aliasCount and delete from copy\r\n      const copy = target.copy as Record<PropertyKey, unknown>\r\n      decAliasCount(copy[key])\r\n      delete copy[key]\r\n    } else {\r\n      target.assignedMap = target.assignedMap ?? new Map()\r\n      target.assignedMap.delete(key)\r\n    }\r\n    return true\r\n  },\r\n}\r\n\r\n/**\r\n * Create a draft proxy for a value\r\n */\r\nexport function createDraft<T extends object>(options: {\r\n  original: T\r\n  parentDraft?: ProxyDraft | null\r\n  key?: string | number\r\n  finalities: Finalities\r\n}): T {\r\n  const { original, parentDraft, key, finalities } = options\r\n  const type = getType(original)\r\n\r\n  const proxyDraft: ProxyDraft<T> = {\r\n    type,\r\n    finalized: false,\r\n    parent: parentDraft ?? null,\r\n    original,\r\n    copy: null,\r\n    proxy: null,\r\n    finalities,\r\n    aliasCount: 1,\r\n  }\r\n\r\n  // Set key if provided\r\n  if (key !== undefined || \"key\" in options) {\r\n    proxyDraft.key = key\r\n  }\r\n\r\n  // Create revocable proxy\r\n  const { proxy, revoke } = Proxy.revocable<T>(\r\n    (type === DraftType.Array ? Object.assign([], proxyDraft) : proxyDraft) as T,\r\n    proxyHandler as ProxyHandler<T>\r\n  )\r\n\r\n  finalities.revoke.push(revoke)\r\n  proxyDraft.proxy = proxy\r\n\r\n  // Set up finalization callback to unwrap child drafts in parent copy\r\n  if (parentDraft) {\r\n    parentDraft.finalities.draft.push(() => {\r\n      const copy = parentDraft.copy\r\n      if (!copy) return\r\n\r\n      const draft = get(copy as object, key!)\r\n      const childProxyDraft = getProxyDraft(draft)\r\n\r\n      if (childProxyDraft) {\r\n        // Get the updated value\r\n        let updatedValue = childProxyDraft.original\r\n        if (childProxyDraft.operated) {\r\n          updatedValue = getValue(draft as object)\r\n        }\r\n        childProxyDraft.finalized = true\r\n        set(copy as object, key!, updatedValue)\r\n      }\r\n    })\r\n  }\r\n\r\n  return proxy\r\n}\r\n\r\n/**\r\n * Finalize a draft and return the result with ops\r\n */\r\nexport function finalizeDraft<T>(result: T, returnedValue: [T] | []): [T, Op[]] {\r\n  const proxyDraft = getProxyDraft<T>(result)\r\n  const hasReturnedValue = returnedValue.length > 0\r\n\r\n  // Run finalization callbacks to unwrap child drafts\r\n  if (proxyDraft?.operated) {\r\n    while (proxyDraft.finalities.draft.length > 0) {\r\n      const finalize = proxyDraft.finalities.draft.pop()!\r\n      finalize()\r\n    }\r\n    proxyDraft.finalized = true\r\n  }\r\n\r\n  // Determine final state\r\n  const state = hasReturnedValue\r\n    ? returnedValue[0]\r\n    : proxyDraft\r\n      ? proxyDraft.operated\r\n        ? (proxyDraft.copy as T)\r\n        : proxyDraft.original\r\n      : result\r\n\r\n  // Handle any remaining nested drafts in the state (e.g., from assignments like draft.a = draft.b)\r\n  if (proxyDraft && state && typeof state === \"object\") {\r\n    handleValue(state, proxyDraft.finalities.handledSet)\r\n  }\r\n\r\n  // Get ops from finalities (eager logging)\r\n  const ops = proxyDraft?.finalities.ops ?? []\r\n\r\n  // Revoke all proxies\r\n  if (proxyDraft) {\r\n    revokeProxy(proxyDraft)\r\n  }\r\n\r\n  return [state as T, ops]\r\n}\r\n","/**\r\n * Create a draft from a base state.\r\n * Simplified from mutative - removed patches/freeze/mark support.\r\n */\r\n\r\nimport { createDraft, finalizeDraft } from \"./draft\"\r\nimport type { Finalities, Op } from \"./interface\"\r\nimport { getProxyDraft, isDraftable } from \"./utils\"\r\n\r\n/**\r\n * Create a draft and return a finalize function\r\n */\r\nexport function draftify<T extends object>(\r\n  baseState: T\r\n): [T, (returnedValue: [T] | []) => [T, Op[]]] {\r\n  const finalities: Finalities = {\r\n    draft: [],\r\n    revoke: [],\r\n    handledSet: new WeakSet<object>(),\r\n    draftsCache: new WeakSet<object>(),\r\n    ops: [],\r\n    rootDraft: null, // Will be set by createDraft\r\n  }\r\n\r\n  // Check if state is draftable\r\n  if (!isDraftable(baseState)) {\r\n    throw new Error(`createOps() only supports plain objects and arrays.`)\r\n  }\r\n\r\n  const draft = createDraft({\r\n    original: baseState,\r\n    parentDraft: null,\r\n    finalities,\r\n  })\r\n\r\n  // Set the root draft for multi-path detection\r\n  finalities.rootDraft = getProxyDraft(draft)\r\n\r\n  return [\r\n    draft,\r\n    (returnedValue: [T] | [] = []) => {\r\n      return finalizeDraft(draft, returnedValue)\r\n    },\r\n  ]\r\n}\r\n","/**\r\n * createOps - Main API for generating operations from mutable-style mutations.\r\n *\r\n * Forked from mutative (https://github.com/unadlib/mutative)\r\n * MIT License\r\n */\r\n\r\nimport { current } from \"./current\"\r\nimport { draftify } from \"./draftify\"\r\nimport type { CreateOpsResult, Draft } from \"./interface\"\r\nimport { getProxyDraft, isDraft, isDraftable, isEqual, revokeProxy } from \"./utils\"\r\n\r\n/**\r\n * Create operations from mutable-style mutations.\r\n *\r\n * @param base - The base state (will not be mutated)\r\n * @param mutate - A function that mutates the draft\r\n * @returns An object containing the next state and the operations performed\r\n *\r\n * @example\r\n * ```ts\r\n * const state = { list: [{ text: 'Learn', done: false }] };\r\n *\r\n * const { nextState, ops } = createOps(state, (draft) => {\r\n *   draft.list[0].done = true;\r\n *   draft.list.push({ text: 'Practice', done: false });\r\n * });\r\n *\r\n * // ops contains the operations that were performed:\r\n * // [\r\n * //   { kind: 'set', path: ['list', 0], key: 'done', value: true },\r\n * //   { kind: 'splice', path: ['list'], index: 1, deleteCount: 0, inserts: [{ text: 'Practice', done: false }] }\r\n * // ]\r\n * ```\r\n */\r\nexport function createOps<T extends object>(\r\n  base: T,\r\n  mutate: (draft: Draft<T>) => void\r\n): CreateOpsResult<T> {\r\n  // Handle case where base is already a draft\r\n  const state = isDraft(base) ? current(base as Draft<T>) : base\r\n\r\n  // Validate that state is draftable\r\n  if (!isDraftable(state)) {\r\n    throw new Error(`createOps() only supports plain objects and arrays.`)\r\n  }\r\n\r\n  // Create draft\r\n  const [draft, finalize] = draftify(state)\r\n\r\n  // Run mutation\r\n  let result: unknown\r\n  try {\r\n    result = mutate(draft as Draft<T>)\r\n  } catch (error) {\r\n    revokeProxy(getProxyDraft(draft))\r\n    throw error\r\n  }\r\n\r\n  // Handle return value\r\n  const proxyDraft = getProxyDraft(draft)!\r\n\r\n  // Check for invalid return values\r\n  if (result !== undefined && !isDraft(result)) {\r\n    if (!isEqual(result, draft) && proxyDraft.operated) {\r\n      throw new Error(\r\n        `Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`\r\n      )\r\n    }\r\n    // User returned a new value - use it as the next state\r\n    // Note: We don't support rawReturn, so returning a non-draft value replaces the state\r\n    // but we can't generate meaningful ops for this case\r\n    if (result !== undefined) {\r\n      const [, ops] = finalize([])\r\n      return { nextState: result as T, ops }\r\n    }\r\n  }\r\n\r\n  // Standard flow - finalize the draft\r\n  if (result === draft || result === undefined) {\r\n    const [nextState, ops] = finalize([])\r\n    return { nextState, ops }\r\n  }\r\n\r\n  // Returned a different draft (child)\r\n  const returnedProxyDraft = getProxyDraft(result)\r\n  if (returnedProxyDraft) {\r\n    if (returnedProxyDraft.operated) {\r\n      throw new Error(`Cannot return a modified child draft.`)\r\n    }\r\n    const [, ops] = finalize([])\r\n    return { nextState: current(result as object) as T, ops }\r\n  }\r\n\r\n  const [nextState, ops] = finalize([])\r\n  return { nextState, ops }\r\n}\r\n","/**\r\n * Get the original value from a draft.\r\n */\r\n\r\nimport { getProxyDraft } from \"./utils\"\r\n\r\n/**\r\n * `original(draft)` to get original state in the draft mutation function.\r\n *\r\n * @example\r\n * ```ts\r\n * const { nextState, ops } = createOps(baseState, (draft) => {\r\n *   draft.foo.bar = 'new value';\r\n *   console.log(original(draft.foo)); // { bar: 'old value' }\r\n * });\r\n * ```\r\n */\r\nexport function original<T>(target: T): T {\r\n  const proxyDraft = getProxyDraft(target)\r\n  if (!proxyDraft) {\r\n    throw new Error(`original() is only used for a draft, parameter: ${target}`)\r\n  }\r\n  return proxyDraft.original as T\r\n}\r\n","/**\r\n * Helper functions for set-like array operations.\r\n * Uses eager op logging - ops are pushed immediately when mutations happen.\r\n */\r\n\r\nimport type { JSONValue } from \"../json\"\r\nimport { deepClone, deepEqual } from \"../utils\"\r\nimport { pushOp } from \"./pushOp\"\r\nimport { ensureShallowCopy, getPathOrThrow, getProxyDraft, markChanged } from \"./utils\"\r\n\r\n/**\r\n * Add a value to an array if it doesn't already exist (set semantics).\r\n * Generates an `addToSet` operation.\r\n *\r\n * @example\r\n * ```ts\r\n * createOps(state, (draft) => {\r\n *   addToSet(draft.tags, 'newTag'); // Only adds if not present\r\n * });\r\n * ```\r\n */\r\nexport function addToSet<T extends JSONValue>(draft: T[], value: T): void {\r\n  const proxyDraft = getProxyDraft(draft)\r\n  if (!proxyDraft) {\r\n    throw new Error(`addToSet() can only be used on draft arrays`)\r\n  }\r\n\r\n  // Mark as changed\r\n  ensureShallowCopy(proxyDraft)\r\n  markChanged(proxyDraft)\r\n\r\n  // Check if value already exists\r\n  const arr = proxyDraft.copy as T[]\r\n  if (arr.some((item) => item === value || deepEqual(item, value))) {\r\n    // Value already exists - no op needed\r\n    return\r\n  }\r\n\r\n  // Add the value\r\n  arr.push(value)\r\n\r\n  // Eager op logging\r\n  pushOp(proxyDraft, {\r\n    kind: \"addToSet\",\r\n    path: getPathOrThrow(proxyDraft),\r\n    value: deepClone(value) as JSONValue,\r\n  })\r\n}\r\n\r\n/**\r\n * Remove a value from an array (set semantics).\r\n * Generates a `deleteFromSet` operation.\r\n *\r\n * @example\r\n * ```ts\r\n * createOps(state, (draft) => {\r\n *   deleteFromSet(draft.tags, 'oldTag'); // Removes all matching items\r\n * });\r\n * ```\r\n */\r\nexport function deleteFromSet<T extends JSONValue>(draft: T[], value: T): void {\r\n  const proxyDraft = getProxyDraft(draft)\r\n  if (!proxyDraft) {\r\n    throw new Error(`deleteFromSet() can only be used on draft arrays`)\r\n  }\r\n\r\n  // Mark as changed\r\n  ensureShallowCopy(proxyDraft)\r\n  markChanged(proxyDraft)\r\n\r\n  // Check if value exists\r\n  const arr = proxyDraft.copy as T[]\r\n  const hasValue = arr.some((item) => item === value || deepEqual(item, value))\r\n\r\n  if (!hasValue) {\r\n    // Value doesn't exist - no op needed\r\n    return\r\n  }\r\n\r\n  // Remove all matching items (by value equality)\r\n  for (let i = arr.length - 1; i >= 0; i--) {\r\n    if (arr[i] === value || deepEqual(arr[i], value)) {\r\n      arr.splice(i, 1)\r\n    }\r\n  }\r\n\r\n  // Eager op logging\r\n  pushOp(proxyDraft, {\r\n    kind: \"deleteFromSet\",\r\n    path: getPathOrThrow(proxyDraft),\r\n    value: deepClone(value) as JSONValue,\r\n  })\r\n}\r\n","import * as Y from \"yjs\"\nimport { type CheckpointRecord, parseCheckpointKey } from \"./checkpoints\"\n\n/**\n * Determines the finalized epoch and its canonical checkpoint in a single pass.\n *\n * Policy A: The finalized epoch is the most recent epoch with a checkpoint.\n * Canonical checkpoint: The checkpoint with highest txCount for that epoch\n * (tie-break: lowest clientId alphabetically).\n *\n * Returns { finalizedEpoch: -1, checkpoint: null } if no checkpoints exist.\n */\nexport function getFinalizedEpochAndCheckpoint(yCheckpoint: Y.Map<CheckpointRecord>): {\n  finalizedEpoch: number\n  checkpoint: CheckpointRecord | null\n} {\n  let maxEpoch = -1\n  let best: CheckpointRecord | null = null\n  let bestTxCount = -1\n  let bestClientId = \"\"\n\n  for (const [key, cp] of yCheckpoint.entries()) {\n    const { epoch, clientId } = parseCheckpointKey(key)\n\n    if (epoch > maxEpoch) {\n      // New highest epoch - reset best checkpoint tracking\n      maxEpoch = epoch\n      best = cp\n      bestTxCount = cp.txCount\n      bestClientId = clientId\n    } else if (epoch === maxEpoch) {\n      // Same epoch - check if this is a better canonical checkpoint\n      // Primary: higher txCount wins\n      // Secondary (tie-break): lower clientId (alphabetically) wins\n      if (cp.txCount > bestTxCount || (cp.txCount === bestTxCount && clientId < bestClientId)) {\n        best = cp\n        bestTxCount = cp.txCount\n        bestClientId = clientId\n      }\n    }\n  }\n\n  return { finalizedEpoch: maxEpoch, checkpoint: best }\n}\n","import * as Y from \"yjs\"\nimport { ClientId } from \"./ClientId\"\nimport { getFinalizedEpochAndCheckpoint } from \"./checkpointUtils\"\nimport { ClientState } from \"./clientState\"\nimport { failure } from \"./error\"\nimport { JSONObject } from \"./json\"\nimport { TxRecord } from \"./TxRecord\"\nimport { TxTimestampKey } from \"./txTimestamp\"\n\n/**\n * Watermarking for deduplication and pruning.\n * - maxClock: All txs from this client with clock <= maxClock are FINALIZED.\n * - maxWallClock: The last time we saw this client active (for pruning).\n */\ntype ClientWatermark = Readonly<{\n  maxClock: number\n  maxWallClock: number\n}>\n\n/**\n * Watermarks for all clients.\n */\nexport type ClientWatermarks = Record<ClientId, ClientWatermark>\n\n/**\n * A snapshot of the state at the end of a specific epoch.\n */\nexport type CheckpointRecord = {\n  state: JSONObject // The document state\n  watermarks: ClientWatermarks // Dedup/Pruning info\n  txCount: number // Tie-breaker for canonical selection\n  minWallClock: number // Reference time for this epoch (deterministic pruning)\n}\n\n/**\n * Unique ID for a checkpoint.\n * Format: `${epoch};${txCount};${clientId}`\n */\nexport type CheckpointKey = string\n\n/**\n * Data extracted from a checkpoint key.\n */\nexport type CheckpointKeyData = {\n  epoch: number\n  txCount: number\n  clientId: ClientId\n}\n\n/**\n * Converts checkpoint key data components to a key string.\n */\nfunction checkpointKeyDataToKey(data: CheckpointKeyData): CheckpointKey {\n  return `${data.epoch};${data.txCount};${data.clientId}`\n}\n\n/**\n * Helper to parse checkpoint keys.\n * Checkpoint keys have format: `${epoch};${txCount};${clientId}`\n * Throws if key is malformed.\n */\nexport function parseCheckpointKey(key: CheckpointKey): CheckpointKeyData {\n  const i1 = key.indexOf(\";\")\n  const i2 = key.indexOf(\";\", i1 + 1)\n\n  if (i1 === -1 || i2 === -1) {\n    failure(`Malformed checkpoint key: ${key}`)\n  }\n\n  return {\n    epoch: Number.parseInt(key.substring(0, i1), 10),\n    txCount: Number.parseInt(key.substring(i1 + 1, i2), 10),\n    clientId: key.substring(i2 + 1),\n  }\n}\n\n/**\n * Called periodically (e.g. by a server or leader client) to finalize the epoch.\n */\nexport function createCheckpoint(\n  yTx: Y.Map<TxRecord>,\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  clientState: ClientState,\n  activeEpoch: number,\n  currentState: JSONObject,\n  myClientId: string\n): void {\n  // 1. Start with previous watermarks (from finalized epoch = activeEpoch - 1)\n  const { checkpoint: prevCP } = getFinalizedEpochAndCheckpoint(yCheckpoint)\n  const newWatermarks = prevCP ? { ...prevCP.watermarks } : {}\n\n  // Get active txs using cached sorted order (filter by epoch)\n  // FILTER IS REQUIRED:\n  // Although we are finalizing 'activeEpoch', other peers may have already\n  // advanced to the next epoch and started syncing those txs.\n  // We must ensure this checkpoint ONLY contains txs from 'activeEpoch'.\n  // Using stateCalculator.getSortedTxs avoids redundant key parsing (timestamps are cached).\n  //\n  // OPTIMIZATION: Since sortedTxs is sorted by epoch (primary key) and past epochs\n  // are pruned, we only need to find the right boundary. Future epochs are rare,\n  // so a simple linear search from the right is efficient (typically 0-1 iterations).\n  const sortedTxs = clientState.stateCalculator.getSortedTxs()\n\n  // Find end boundary by searching from right (skip any future epoch entries)\n  let endIndex = sortedTxs.length\n  while (endIndex > 0 && sortedTxs[endIndex - 1].txTimestamp.epoch > activeEpoch) {\n    endIndex--\n  }\n\n  // Slice from start to endIndex (past epochs are pruned, so these are all activeEpoch)\n  const activeTxs = sortedTxs.slice(0, endIndex)\n\n  if (activeTxs.length === 0) {\n    return // Do nothing if no txs (prevents empty epochs)\n  }\n\n  // 2. Update watermarks based on OBSERVED active txs and calculate minWallClock\n  // NOTE: We cannot use activeTxs[0].txTimestamp.wallClock for minWallClock because\n  // txs are sorted by Lamport clock (epoch → clock → clientId), not by wallClock.\n  // A client may have a high Lamport clock but early wallClock due to clock drift\n  // or receiving many messages before emitting.\n  let minWallClock = Number.POSITIVE_INFINITY\n  let txCount = 0\n  for (const entry of activeTxs) {\n    const ts = entry.txTimestamp\n\n    // Track min wallClock for deterministic pruning reference\n    if (ts.wallClock < minWallClock) {\n      minWallClock = ts.wallClock\n    }\n\n    const newWm = newWatermarks[ts.clientId]\n      ? { ...newWatermarks[ts.clientId] }\n      : { maxClock: -1, maxWallClock: 0 }\n\n    if (ts.clock > newWm.maxClock) {\n      newWm.maxClock = ts.clock\n      newWm.maxWallClock = ts.wallClock\n    }\n    newWatermarks[ts.clientId] = newWm\n    txCount++\n  }\n\n  // 3. Prune Inactive Watermarks (Deterministic)\n  // Uses minWallClock so all clients agree on exactly who to prune.\n  for (const clientId in newWatermarks) {\n    if (minWallClock - newWatermarks[clientId].maxWallClock > clientState.retentionWindowMs) {\n      delete newWatermarks[clientId]\n    }\n  }\n\n  // 4. Save Checkpoint\n  const cpKey = checkpointKeyDataToKey({\n    epoch: activeEpoch,\n    txCount,\n    clientId: myClientId,\n  })\n  yCheckpoint.set(cpKey, {\n    state: currentState, // Responsibility for cloning is moved to the caller if needed\n    watermarks: newWatermarks,\n    txCount,\n    minWallClock,\n  })\n\n  // 5. Early tx pruning (Optimization)\n  // Delete all txs from the now-finalized epoch\n  // This reduces memory pressure instead of waiting for cleanupLog\n  const keysToDelete: TxTimestampKey[] = []\n  for (const entry of activeTxs) {\n    yTx.delete(entry.txTimestampKey)\n    keysToDelete.push(entry.txTimestampKey)\n  }\n  clientState.stateCalculator.removeTxs(keysToDelete)\n}\n\n/**\n * Garbage collects old checkpoints.\n * Should be called periodically to prevent unbounded growth of yCheckpoint.\n *\n * Keeps only the canonical checkpoint for the finalized epoch.\n * Everything else is deleted (old epochs + non-canonical).\n *\n * Note: The active epoch never has checkpoints - creating a checkpoint\n * for an epoch immediately makes it finalized.\n */\nexport function pruneCheckpoints(\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  finalizedEpoch: number\n): void {\n  // Find the canonical checkpoint and its key in one pass\n  let canonicalKey: CheckpointKey | null = null\n  let bestTxCount = -1\n\n  for (const [key] of yCheckpoint.entries()) {\n    const { epoch, txCount } = parseCheckpointKey(key)\n    if (epoch === finalizedEpoch && txCount > bestTxCount) {\n      canonicalKey = key\n      bestTxCount = txCount\n    }\n  }\n\n  // Delete everything except the canonical checkpoint\n  for (const key of yCheckpoint.keys()) {\n    if (key !== canonicalKey) {\n      yCheckpoint.delete(key)\n    }\n  }\n}\n","import { failure } from \"./error\"\r\nimport type { JSONObject, JSONRecord, JSONValue, Path } from \"./json\"\r\nimport type { Op, ValidateFn } from \"./operations\"\r\nimport { TxRecord } from \"./TxRecord\"\r\nimport { deepEqual, isObject, parseArrayIndex } from \"./utils\"\r\n\r\n/**\r\n * A draft context for copy-on-write immutable updates.\r\n *\r\n * This provides Immer/Mutative-like semantics without the proxy overhead:\r\n * - The original base state is never mutated\r\n * - Objects are cloned lazily on first mutation (copy-on-write)\r\n * - Once an object is cloned (\"owned\"), it can be mutated directly\r\n * - If no changes are made, the original reference is preserved (structural sharing)\r\n */\r\nexport interface DraftContext<T extends JSONObject> {\r\n  /** The current root (may be the original base or a cloned version) */\r\n  root: T\r\n  /** The original base state (never mutated) */\r\n  base: T\r\n  /** Set of objects that have been cloned and are safe to mutate */\r\n  ownedObjects: WeakSet<object>\r\n  /** Optimization: fast check if root is already owned */\r\n  isRootOwned: boolean\r\n}\r\n\r\n/**\r\n * Creates a new draft context from a base state.\r\n * The base state will never be mutated.\r\n */\r\nexport function createDraft<T extends JSONObject>(base: T): DraftContext<T> {\r\n  return {\r\n    root: base,\r\n    base,\r\n    ownedObjects: new Set(),\r\n    isRootOwned: false,\r\n  }\r\n}\r\n\r\n/**\r\n * Checks if the draft was modified (root !== base).\r\n */\r\nexport function isDraftModified<T extends JSONObject>(ctx: DraftContext<T>): boolean {\r\n  return ctx.root !== ctx.base\r\n}\r\n\r\nfunction shallowClone<T extends object>(obj: T): T {\r\n  if (Array.isArray(obj)) {\r\n    return obj.slice() as unknown as T\r\n  }\r\n  const clone = {} as T\r\n  const keys = Object.keys(obj)\r\n  for (let i = 0; i < keys.length; i++) {\r\n    const key = keys[i]\r\n    ;(clone as any)[key] = (obj as any)[key]\r\n  }\r\n  return clone\r\n}\r\n\r\n/**\r\n * Ensures an object is owned (cloned if necessary) and returns the owned version.\r\n * Also updates the parent to point to the cloned child.\r\n */\r\nfunction ensureOwned<T extends JSONObject>(\r\n  ctx: DraftContext<T>,\r\n  parent: JSONObject,\r\n  key: string | number,\r\n  child: JSONRecord | JSONValue[]\r\n): JSONRecord | JSONValue[] {\r\n  if (ctx.ownedObjects.has(child)) {\r\n    return child\r\n  }\r\n  const cloned = shallowClone(child)\r\n  ;(parent as any)[key] = cloned\r\n  ctx.ownedObjects.add(cloned)\r\n  return cloned\r\n}\r\n\r\n/**\r\n * Ensures all objects along the path are owned (cloned if necessary).\r\n * Returns the container at the end of the path.\r\n * Throws if the path is invalid.\r\n */\r\nfunction ensureOwnedPath<T extends JSONObject>(\r\n  ctx: DraftContext<T>,\r\n  path: Path\r\n): JSONRecord | JSONValue[] {\r\n  // Ensure root is owned first\r\n  if (!ctx.isRootOwned) {\r\n    ctx.root = shallowClone(ctx.root as unknown as object) as T\r\n    ctx.ownedObjects.add(ctx.root)\r\n    ctx.isRootOwned = true\r\n  }\r\n\r\n  if (path.length === 0) {\r\n    return ctx.root\r\n  }\r\n\r\n  let current: JSONRecord | JSONValue[] = ctx.root\r\n\r\n  for (let i = 0; i < path.length; i++) {\r\n    const segment = path[i]\r\n    const isArrayIndex = typeof segment === \"number\"\r\n\r\n    // Validate container type\r\n    if (isArrayIndex) {\r\n      if (!Array.isArray(current)) {\r\n        failure(`Expected array at path segment ${segment}`)\r\n      }\r\n      if (segment < 0 || segment >= current.length) {\r\n        failure(`Index ${segment} out of bounds`)\r\n      }\r\n    } else {\r\n      if (!isObject(current) || Array.isArray(current)) {\r\n        failure(`Expected object at path segment \"${segment}\"`)\r\n      }\r\n      if (!(segment in current)) {\r\n        failure(`Property \"${segment}\" does not exist`)\r\n      }\r\n    }\r\n\r\n    const child: JSONValue = (current as any)[segment]\r\n\r\n    // Validate child is traversable\r\n    if (child === null || typeof child !== \"object\") {\r\n      failure(`Cannot traverse through primitive at path segment ${segment}`)\r\n    }\r\n\r\n    // Ensure child is owned and continue\r\n    current = ensureOwned(ctx, current, segment, child as JSONRecord | JSONValue[])\r\n  }\r\n\r\n  return current\r\n}\r\n\r\n/**\r\n * Applies a single \"set\" operation to the draft with copy-on-write.\r\n */\r\nexport function draftSet<T extends JSONObject>(\r\n  ctx: DraftContext<T>,\r\n  path: Path,\r\n  key: string | number,\r\n  value: JSONValue\r\n): void {\r\n  const container = ensureOwnedPath(ctx, path)\r\n  if (!isObject(container)) {\r\n    failure(\"set requires object or array container\")\r\n  }\r\n  let finalKey: string | number = key\r\n  // For arrays, convert string keys to numbers (except \"length\")\r\n  if (Array.isArray(container) && typeof key === \"string\" && key !== \"length\") {\r\n    const numKey = parseArrayIndex(key)\r\n    if (numKey === null) {\r\n      failure(`Cannot set non-numeric property \"${key}\" on array`)\r\n    }\r\n    finalKey = numKey\r\n  }\r\n  ;(container as Record<string | number, JSONValue>)[finalKey] = value\r\n}\r\n\r\n/**\r\n * Applies a single \"delete\" operation to the draft with copy-on-write.\r\n */\r\nexport function draftDelete<T extends JSONObject>(\r\n  ctx: DraftContext<T>,\r\n  path: Path,\r\n  key: string | number\r\n): void {\r\n  const container = ensureOwnedPath(ctx, path)\r\n  if (!isObject(container)) {\r\n    failure(\"delete requires object or array container\")\r\n  }\r\n  let finalKey: string | number = key\r\n  // For arrays, convert string keys to numbers\r\n  if (Array.isArray(container) && typeof key === \"string\") {\r\n    const numKey = parseArrayIndex(key)\r\n    if (numKey === null) {\r\n      failure(`Cannot delete non-numeric property \"${key}\" from array`)\r\n    }\r\n    finalKey = numKey\r\n  }\r\n  delete (container as Record<string | number, JSONValue>)[finalKey]\r\n}\r\n\r\n/**\r\n * Applies a single \"splice\" operation to the draft with copy-on-write.\r\n */\r\nexport function draftSplice<T extends JSONObject>(\r\n  ctx: DraftContext<T>,\r\n  path: Path,\r\n  index: number,\r\n  deleteCount: number,\r\n  inserts: readonly JSONValue[]\r\n): void {\r\n  const container = ensureOwnedPath(ctx, path)\r\n  if (!Array.isArray(container)) {\r\n    failure(\"splice requires array container\")\r\n  }\r\n  const safeIndex = Math.min(index, container.length)\r\n  if (inserts.length === 0) {\r\n    container.splice(safeIndex, deleteCount)\r\n  } else if (inserts.length === 1) {\r\n    container.splice(safeIndex, deleteCount, inserts[0])\r\n  } else {\r\n    container.splice(safeIndex, deleteCount, ...inserts)\r\n  }\r\n}\r\n\r\n/**\r\n * Applies a single \"addToSet\" operation to the draft with copy-on-write.\r\n */\r\nexport function draftAddToSet<T extends JSONObject>(\r\n  ctx: DraftContext<T>,\r\n  path: Path,\r\n  value: JSONValue\r\n): void {\r\n  const container = ensureOwnedPath(ctx, path)\r\n  if (!Array.isArray(container)) {\r\n    failure(\"addToSet requires array container\")\r\n  }\r\n  if (!container.some((item) => deepEqual(item, value))) {\r\n    container.push(value)\r\n  }\r\n}\r\n\r\n/**\r\n * Applies a single \"deleteFromSet\" operation to the draft with copy-on-write.\r\n */\r\nexport function draftDeleteFromSet<T extends JSONObject>(\r\n  ctx: DraftContext<T>,\r\n  path: Path,\r\n  value: JSONValue\r\n): void {\r\n  const container = ensureOwnedPath(ctx, path)\r\n  if (!Array.isArray(container)) {\r\n    failure(\"deleteFromSet requires array container\")\r\n  }\r\n  // Remove all matching items (iterate backwards to avoid index shifting)\r\n  for (let i = container.length - 1; i >= 0; i--) {\r\n    if (deepEqual(container[i], value)) {\r\n      container.splice(i, 1)\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Applies a single operation to the draft with copy-on-write.\r\n */\r\nexport function applyOpToDraft<T extends JSONObject>(ctx: DraftContext<T>, op: Op): void {\r\n  switch (op.kind) {\r\n    case \"set\":\r\n      draftSet(ctx, op.path, op.key, op.value)\r\n      break\r\n    case \"delete\":\r\n      draftDelete(ctx, op.path, op.key)\r\n      break\r\n    case \"splice\":\r\n      draftSplice(ctx, op.path, op.index, op.deleteCount, op.inserts)\r\n      break\r\n    case \"addToSet\":\r\n      draftAddToSet(ctx, op.path, op.value)\r\n      break\r\n    case \"deleteFromSet\":\r\n      draftDeleteFromSet(ctx, op.path, op.value)\r\n      break\r\n    default:\r\n      throw failure(`Unknown operation kind: ${(op as any).kind}`)\r\n  }\r\n}\r\n\r\n/**\r\n * Applies a single transaction to a base state immutably.\r\n *\r\n * Key benefits over Mutative/Immer:\r\n * - No proxy overhead - direct object access and copy-on-write cloning\r\n * - Structural sharing - unchanged subtrees keep their references\r\n * - Zero-copy on failure - if validation fails, returns original base unchanged\r\n *\r\n * @param base - The base state (never mutated)\r\n * @param tx - The transaction to apply\r\n * @param validateFn - Optional validation function\r\n * @returns The final state (if valid) or the original base (if invalid or empty)\r\n */\r\nexport function applyTxImmutable<T extends JSONObject>(\r\n  base: T,\r\n  tx: Pick<TxRecord, \"ops\">,\r\n  validateFn?: ValidateFn<T>\r\n): T {\r\n  if (tx.ops.length === 0) return base\r\n\r\n  const ctx = createDraft(base)\r\n\r\n  try {\r\n    for (const op of tx.ops) {\r\n      applyOpToDraft(ctx, op)\r\n    }\r\n\r\n    if (validateFn && !validateFn(ctx.root)) {\r\n      return base\r\n    }\r\n\r\n    return ctx.root\r\n  } catch {\r\n    return base\r\n  }\r\n}\r\n","import { failure } from \"./error\"\nimport { JSONRecord, JSONValue, Path } from \"./json\"\nimport { Op } from \"./operations\"\n\n/**\n * Reconciles the current state with the target state by computing and emitting\n * the minimal set of operations needed to transform currentState into targetState.\n */\nexport function computeReconcileOps(currentState: JSONValue, targetState: JSONValue): Op[] {\n  const ops: Op[] = []\n  diffValue(currentState, targetState, [], ops)\n  return ops\n}\n\nfunction diffValue(current: JSONValue, target: JSONValue, path: Path, ops: Op[]): void {\n  // 1. Reference equality (structural sharing)\n  if (current === target) return\n\n  // 2. Handle primitives and null quickly\n  const currentType = typeof current\n  const targetType = typeof target\n\n  if (current === null || target === null || currentType !== \"object\" || targetType !== \"object\") {\n    // At least one is primitive/null, or types don't match\n    emitReplace(path, target, ops)\n    return\n  }\n\n  // Both are objects (object or array)\n  const currentIsArray = Array.isArray(current)\n  const targetIsArray = Array.isArray(target)\n\n  if (currentIsArray !== targetIsArray) {\n    // Type mismatch (one array, one object)\n    emitReplace(path, target, ops)\n    return\n  }\n\n  if (currentIsArray) {\n    diffArray(current, target as JSONValue[], path, ops)\n  } else {\n    diffObject(current as JSONRecord, target as JSONRecord, path, ops)\n  }\n}\n\nfunction diffObject(current: JSONRecord, target: JSONRecord, path: Path, ops: Op[]): void {\n  // 1. Delete keys in current but not in target\n  for (const key in current) {\n    if (Object.hasOwn(current, key) && !Object.hasOwn(target, key)) {\n      ops.push({ kind: \"delete\", path, key })\n    }\n  }\n\n  // 2. Add/Update keys in target\n  for (const key in target) {\n    if (Object.hasOwn(target, key)) {\n      const targetVal = target[key]\n      if (!Object.hasOwn(current, key)) {\n        ops.push({ kind: \"set\", path, key, value: targetVal })\n      } else if (current[key] !== targetVal) {\n        // Only recurse if values differ (reference check first)\n        diffValue(current[key], targetVal, [...path, key], ops)\n      }\n    }\n  }\n}\n\nfunction diffArray(current: JSONValue[], target: JSONValue[], path: Path, ops: Op[]): void {\n  const currentLen = current.length\n  const targetLen = target.length\n  const minLen = currentLen < targetLen ? currentLen : targetLen\n\n  // Diff common elements\n  for (let i = 0; i < minLen; i++) {\n    if (current[i] !== target[i]) {\n      diffValue(current[i], target[i], [...path, i], ops)\n    }\n  }\n\n  // Handle length difference\n  if (targetLen > currentLen) {\n    ops.push({\n      kind: \"splice\",\n      path,\n      index: currentLen,\n      deleteCount: 0,\n      inserts: target.slice(currentLen),\n    })\n  } else if (currentLen > targetLen) {\n    ops.push({\n      kind: \"splice\",\n      path,\n      index: targetLen,\n      deleteCount: currentLen - targetLen,\n      inserts: [],\n    })\n  }\n}\n\nfunction emitReplace(path: Path, value: JSONValue, ops: Op[]): void {\n  if (path.length === 0) {\n    // Cannot replace root directly via Ops (unless we define a 'root' op, which we don't)\n    // We expect root to be handled by diffObject usually.\n    // If we land here, it means root types mismatched (e.g. Obj -> Array).\n    failure(\"StateSyncLog: Cannot replace root state directly via Ops.\")\n  }\n\n  const parentPath = path.slice(0, -1)\n  const keyToCheck = path[path.length - 1]\n\n  if (typeof keyToCheck === \"string\") {\n    // Parent is Object\n    ops.push({ kind: \"set\", path: parentPath, key: keyToCheck, value })\n  } else {\n    // Parent is Array\n    ops.push({\n      kind: \"splice\",\n      path: parentPath,\n      index: keyToCheck,\n      deleteCount: 1,\n      inserts: [value],\n    })\n  }\n}\n","import { failure } from \"./error\"\n\n/**\n * Parsed tx timestamp components.\n */\nexport type TxTimestamp = {\n  epoch: number\n  clock: number\n  clientId: string\n  wallClock: number\n}\n\n/**\n * Unique tx ID (Composite Key).\n */\nexport type TxTimestampKey = string\n\n/**\n * Converts a timestamp object to a TransactionTimestampKey string.\n */\nexport function txTimestampToKey(ts: TxTimestamp): TxTimestampKey {\n  return `${ts.epoch};${ts.clock};${ts.clientId};${ts.wallClock}`\n}\n\n/**\n * Helper to parse tx timestamp keys.\n * Throws if key is malformed.\n */\nexport function parseTxTimestampKey(key: TxTimestampKey): TxTimestamp {\n  const i1 = key.indexOf(\";\")\n  const i2 = key.indexOf(\";\", i1 + 1)\n  const i3 = key.indexOf(\";\", i2 + 1)\n\n  if (i1 === -1 || i2 === -1 || i3 === -1) {\n    failure(`Malformed timestamp key: ${key}`)\n  }\n\n  return {\n    epoch: Number.parseInt(key.substring(0, i1), 10),\n    clock: Number.parseInt(key.substring(i1 + 1, i2), 10),\n    clientId: key.substring(i2 + 1, i3),\n    wallClock: Number.parseInt(key.substring(i3 + 1), 10),\n  }\n}\n\n/**\n * Compares two tx timestamps for deterministic ordering.\n * Sort order: epoch (asc) → clock (asc) → clientId (asc)\n */\nexport function compareTxTimestamps(a: TxTimestamp, b: TxTimestamp): number {\n  if (a.epoch !== b.epoch) return a.epoch - b.epoch\n  if (a.clock !== b.clock) return a.clock - b.clock\n  if (a.clientId < b.clientId) return -1\n  if (a.clientId > b.clientId) return 1\n  return 0\n}\n","import type * as Y from \"yjs\"\nimport { failure } from \"./error\"\nimport { TxRecord } from \"./TxRecord\"\nimport { parseTxTimestampKey, type TxTimestamp, type TxTimestampKey } from \"./txTimestamp\"\n\n/**\n * A cached tx entry with lazy parsing and optional tx caching.\n * The timestamp is parsed on first access and cached.\n * The tx record can be fetched lazily and cached.\n */\nexport class SortedTxEntry {\n  private _txTimestamp?: TxTimestamp\n  private _originalTxTimestampKey?: TxTimestampKey | null\n  private _originalTxTimestamp?: TxTimestamp | null\n  private _txRecord?: TxRecord\n\n  constructor(\n    readonly txTimestampKey: TxTimestampKey,\n    private readonly _yTx: Y.Map<TxRecord>\n  ) {}\n\n  /**\n   * Gets the parsed timestamp, lazily parsing and caching on first access.\n   */\n  get txTimestamp(): TxTimestamp {\n    if (!this._txTimestamp) {\n      this._txTimestamp = parseTxTimestampKey(this.txTimestampKey)\n    }\n    return this._txTimestamp\n  }\n\n  /**\n   * Gets the original tx timestamp key, lazily and caching on first access.\n   */\n  get originalTxTimestampKey(): TxTimestampKey | null {\n    if (this._originalTxTimestampKey === undefined) {\n      const tx = this.txRecord\n      this._originalTxTimestampKey = tx.originalTxKey ?? null\n    }\n    return this._originalTxTimestampKey\n  }\n\n  /**\n   * Gets the parsed original tx timestamp, lazily parsing and caching on first access.\n   */\n  get originalTxTimestamp(): TxTimestamp | null {\n    if (this._originalTxTimestamp === undefined) {\n      const key = this.originalTxTimestampKey\n      this._originalTxTimestamp = key ? parseTxTimestampKey(key) : null\n    }\n    return this._originalTxTimestamp\n  }\n\n  /**\n   * Gets the logical (deduplicated) tx timestamp key.\n   * This is the original tx key if it exists, otherwise the physical key.\n   */\n  get dedupTxTimestampKey(): TxTimestampKey {\n    return this.originalTxTimestampKey ?? this.txTimestampKey\n  }\n\n  /**\n   * Gets the logical (deduplicated) parsed tx timestamp.\n   * This is the original tx timestamp if it exists, otherwise the physical timestamp.\n   */\n  get dedupTxTimestamp(): TxTimestamp {\n    return this.originalTxTimestamp ?? this.txTimestamp\n  }\n\n  /**\n   * Gets the tx record, lazily fetching and caching on first access.\n   * Returns undefined if the tx doesn't exist.\n   */\n  get txRecord(): TxRecord {\n    if (!this._txRecord) {\n      this._txRecord = this._yTx.get(this.txTimestampKey)\n      if (!this._txRecord) {\n        throw failure(`SortedTxEntry: TxRecord not found for key ${this.txTimestampKey}`)\n      }\n    }\n    return this._txRecord\n  }\n}\n","import type * as Y from \"yjs\"\nimport { type CheckpointRecord, type ClientWatermarks } from \"./checkpoints\"\nimport { applyTxImmutable } from \"./draft\"\nimport { JSONObject } from \"./json\"\nimport { Op, ValidateFn } from \"./operations\"\nimport { computeReconcileOps } from \"./reconcile\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { TxRecord } from \"./TxRecord\"\nimport { compareTxTimestamps, type TxTimestamp, type TxTimestampKey } from \"./txTimestamp\"\nimport { lazy } from \"./utils\"\n\n/**\n * Checks if a transaction is covered by the checkpoint watermarks.\n */\nexport function isTransactionInCheckpoint(ts: TxTimestamp, watermarks: ClientWatermarks): boolean {\n  const wm = watermarks[ts.clientId]\n  if (!wm) return false\n  return ts.clock <= wm.maxClock\n}\n\n/**\n * StateCalculator encapsulates the sorted transaction cache and state calculation logic.\n *\n * It maintains:\n * - A sorted array of transaction entries\n * - A map for O(1) lookup\n * - A tracking index indicating up to which tx the state has been calculated\n * - The cached calculated state\n * - The base checkpoint\n *\n * The tracking index is invalidated (set to null) when:\n * - A transaction is inserted before the already-calculated slice\n * - A transaction is deleted from the already-calculated slice\n * - The base checkpoint changes\n */\nexport class StateCalculator {\n  /** Sorted tx cache (ALL active/future txs, kept sorted by timestamp) */\n  private sortedTxs: SortedTxEntry[] = []\n\n  /** O(1) existence check and lookup */\n  private sortedTxsMap: Map<TxTimestampKey, SortedTxEntry> = new Map()\n\n  /**\n   * Index of the last transaction applied to cachedState.\n   * - null: state needs full recalculation from checkpoint\n   * - -1: no transactions have been applied yet (state === checkpoint state)\n   * - >= 0: transactions up to and including this index have been applied\n   */\n  private lastAppliedIndex: number | null = null\n\n  /** The cached calculated state */\n  private cachedState: JSONObject | null = null\n\n  /** The base checkpoint to calculate state from */\n  private baseCheckpoint: CheckpointRecord | null = null\n\n  /**\n   * Applied dedup keys - tracks which LOGICAL txs have been applied.\n   * This is the originalTxKey (or physical key if no original) for each applied tx.\n   * Used to properly deduplicate re-emits.\n   */\n  private appliedTxKeys: Set<TxTimestampKey> = new Set()\n\n  /** Max clock seen from any transaction (for Lamport clock updates) */\n  private maxSeenClock = 0\n\n  /** Validation function (optional) */\n  private validateFn?: ValidateFn<JSONObject>\n\n  constructor(validateFn?: ValidateFn<JSONObject>) {\n    this.validateFn = validateFn\n  }\n\n  /**\n   * Sets the base checkpoint. Invalidates cached state if checkpoint changed.\n   * @returns true if the checkpoint changed\n   */\n  setBaseCheckpoint(checkpoint: CheckpointRecord | null): boolean {\n    if (checkpoint === this.baseCheckpoint) {\n      return false\n    }\n\n    this.baseCheckpoint = checkpoint\n    this.invalidate()\n    return true\n  }\n\n  /**\n   * Gets the current base checkpoint.\n   */\n  getBaseCheckpoint(): CheckpointRecord | null {\n    return this.baseCheckpoint\n  }\n\n  /**\n   * Clears all transactions and rebuilds from yTx map.\n   * This is used when the checkpoint changes and we need a fresh start.\n   */\n  rebuildFromYjs(yTx: Y.Map<TxRecord>): void {\n    this.sortedTxs = []\n    this.sortedTxsMap.clear()\n\n    // Collect all entries, build the map and max clock\n    for (const key of yTx.keys()) {\n      const entry = new SortedTxEntry(key, yTx)\n      this.sortedTxs.push(entry)\n\n      this.sortedTxsMap.set(entry.txTimestampKey, entry)\n      if (entry.txTimestamp.clock > this.maxSeenClock) {\n        this.maxSeenClock = entry.txTimestamp.clock\n      }\n    }\n\n    // Sort once - O(n log n)\n    this.sortedTxs.sort((a, b) => compareTxTimestamps(a.txTimestamp, b.txTimestamp))\n\n    // Invalidate cached state since we rebuilt\n    this.invalidate()\n  }\n\n  /**\n   * Inserts a transaction into the sorted cache.\n   * Invalidates cached state if the transaction was inserted before the calculated slice.\n   *\n   * @returns true if this caused invalidation (out-of-order insert)\n   */\n  insertTx(key: TxTimestampKey, yTx: Y.Map<TxRecord>): boolean {\n    if (this.sortedTxsMap.has(key)) {\n      return false // Already exists\n    }\n\n    const entry = new SortedTxEntry(key, yTx)\n    const ts = entry.txTimestamp\n\n    // Update max seen clock for Lamport clock mechanism\n    if (ts.clock > this.maxSeenClock) {\n      this.maxSeenClock = ts.clock\n    }\n\n    const sortedTxs = this.sortedTxs\n\n    // Find insertion position (search from end since new txs typically have higher timestamps)\n    let insertIndex = sortedTxs.length // Default: append at end\n    for (let i = sortedTxs.length - 1; i >= 0; i--) {\n      const existingTs = sortedTxs[i].txTimestamp\n      if (compareTxTimestamps(ts, existingTs) >= 0) {\n        insertIndex = i + 1\n        break\n      }\n      if (i === 0) {\n        insertIndex = 0 // Insert at beginning\n      }\n    }\n\n    // Insert at the found position\n    sortedTxs.splice(insertIndex, 0, entry)\n    this.sortedTxsMap.set(key, entry)\n\n    // Check if this invalidates our cached state\n    // If we inserted before or at the last applied index, we need to recalculate\n    if (this.lastAppliedIndex !== null && insertIndex <= this.lastAppliedIndex) {\n      this.invalidate()\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Removes multiple transactions from the sorted cache.\n   * @returns the number of keys that were actually removed\n   */\n  removeTxs(keys: readonly TxTimestampKey[]): number {\n    if (keys.length === 0) return 0\n\n    let removedCount = 0\n    let minRemovedIndex = Number.POSITIVE_INFINITY\n\n    // Build set of keys to delete and track their indices\n    const toDelete = new Set<TxTimestampKey>()\n    for (const key of keys) {\n      const entry = this.sortedTxsMap.get(key)\n      if (entry) {\n        this.sortedTxsMap.delete(key)\n        toDelete.add(key)\n\n        // Find index for invalidation check\n        const index = this.sortedTxs.indexOf(entry)\n        if (index !== -1 && index < minRemovedIndex) {\n          minRemovedIndex = index\n        }\n      }\n    }\n\n    if (toDelete.size === 0) return 0\n\n    // Single forward pass through sortedTxs, removing matching entries\n    const sortedTxs = this.sortedTxs\n    let i = 0\n    while (i < sortedTxs.length && toDelete.size > 0) {\n      if (toDelete.has(sortedTxs[i].txTimestampKey)) {\n        toDelete.delete(sortedTxs[i].txTimestampKey)\n        sortedTxs.splice(i, 1)\n        removedCount++\n      } else {\n        i++\n      }\n    }\n\n    // Check if this invalidates our cached state\n    if (this.lastAppliedIndex !== null && minRemovedIndex <= this.lastAppliedIndex) {\n      this.invalidate()\n    }\n\n    return removedCount\n  }\n\n  /**\n   * Checks if a transaction key exists in the cache.\n   */\n  hasTx(key: TxTimestampKey): boolean {\n    return this.sortedTxsMap.has(key)\n  }\n\n  /**\n   * Gets a transaction entry by key.\n   */\n  getTx(key: TxTimestampKey): SortedTxEntry | undefined {\n    return this.sortedTxsMap.get(key)\n  }\n\n  /**\n   * Gets all sorted transaction entries.\n   */\n  getSortedTxs(): readonly SortedTxEntry[] {\n    return this.sortedTxs\n  }\n\n  /**\n   * Gets the number of transactions in the cache.\n   */\n  get txCount(): number {\n    return this.sortedTxs.length\n  }\n\n  /**\n   * Returns true if the state needs full recalculation.\n   */\n  needsFullRecalculation(): boolean {\n    return this.lastAppliedIndex === null\n  }\n\n  /**\n   * Invalidates the cached state, forcing a full recalculation on next calculateState().\n   * Note: cachedState is kept so computeReconcileOps can diff old vs new state.\n   */\n  invalidate(): void {\n    this.lastAppliedIndex = null\n  }\n\n  /**\n   * Calculates and returns the current state, along with a lazy getter for ops that changed from the previous state.\n   *\n   * - If lastAppliedIndex is null: full recalculation from checkpoint\n   * - If lastAppliedIndex >= -1: incremental apply from lastAppliedIndex + 1\n   */\n  calculateState(): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    const baseState: JSONObject = this.baseCheckpoint?.state ?? {}\n    const watermarks = this.baseCheckpoint?.watermarks ?? {}\n    const hasWatermarks = Object.keys(watermarks).length > 0\n\n    if (this.lastAppliedIndex === null) {\n      // SLOW PATH: Full recalculation\n      return this.fullRecalculation(baseState, watermarks, hasWatermarks)\n    }\n\n    // FAST PATH: Incremental apply\n    return this.incrementalApply(watermarks, hasWatermarks)\n  }\n\n  /**\n   * Full recalculation of state from the base checkpoint.\n   */\n  private fullRecalculation(\n    baseState: JSONObject,\n    watermarks: ClientWatermarks,\n    hasWatermarks: boolean\n  ): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    const oldState = this.cachedState ?? {}\n\n    // Reset tracking for full recompute\n    this.appliedTxKeys.clear()\n    this.lastAppliedIndex = -1\n    this.cachedState = baseState\n\n    // Delegate to incremental apply to replay all transactions\n    // We ignore the returned ops because they represent the operations applied from the base state,\n    // whereas we want the diff from the *previous cached state*.\n    // We pass returnOps=false to avoid collecting ops during replay.\n    const { state } = this.incrementalApply(watermarks, hasWatermarks, false)\n\n    // Lazy load the reconciliation ops (expensive diff)\n    const getAppliedOps = lazy(() => computeReconcileOps(oldState, state))\n\n    return { state, getAppliedOps }\n  }\n\n  /**\n   * Incremental apply of transactions from lastAppliedIndex + 1.\n   * @param returnOps If true, collects applied transactions (to lazy compute ops). If false, skips collection.\n   */\n  private incrementalApply(\n    watermarks: ClientWatermarks,\n    hasWatermarks: boolean,\n    returnOps = true\n  ): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    let state = this.cachedState as JSONObject\n    const appliedTxs: TxRecord[] = []\n    const sortedTxs = this.sortedTxs\n    const startIndex = this.lastAppliedIndex! + 1\n\n    for (let i = startIndex; i < sortedTxs.length; i++) {\n      const entry = sortedTxs[i]\n      const dedupKey = entry.dedupTxTimestampKey\n\n      // Skip if already applied (deduplication)\n      if (this.appliedTxKeys.has(dedupKey)) {\n        continue\n      }\n\n      // Skip if in checkpoint\n      if (hasWatermarks) {\n        const dedupTs = entry.dedupTxTimestamp\n        if (isTransactionInCheckpoint(dedupTs, watermarks)) {\n          this.appliedTxKeys.add(dedupKey)\n          continue\n        }\n      }\n\n      const tx = entry.txRecord\n\n      // Apply transaction 1-by-1 to avoid draft context pollution on validation failure\n      const newState = applyTxImmutable(state, tx, this.validateFn)\n\n      if (newState !== state) {\n        state = newState\n        if (returnOps) {\n          appliedTxs.push(tx)\n        }\n      }\n\n      this.appliedTxKeys.add(dedupKey)\n      this.lastAppliedIndex = i\n    }\n\n    // Update lastAppliedIndex to end even if all txs were skipped\n    // This ensures we don't re-process skipped txs on next incremental apply\n    if (sortedTxs.length > 0 && this.lastAppliedIndex! < sortedTxs.length - 1) {\n      this.lastAppliedIndex = sortedTxs.length - 1\n    }\n\n    this.cachedState = state\n\n    // Lazy getter for ops (flattens applied txs)\n    const getAppliedOps = lazy(() => {\n      const ops: Op[] = []\n      for (const tx of appliedTxs) {\n        ops.push(...tx.ops)\n      }\n      return ops\n    })\n\n    return { state, getAppliedOps }\n  }\n\n  /**\n   * Gets the max seen clock (for Lamport clock updates).\n   */\n  getMaxSeenClock(): number {\n    return this.maxSeenClock\n  }\n\n  /**\n   * Gets the current cached state without recalculating.\n   * Returns null if state has never been calculated.\n   */\n  getCachedState(): JSONObject | null {\n    return this.cachedState\n  }\n\n  /**\n   * Gets the last applied timestamp.\n   */\n  getLastAppliedTs(): TxTimestamp | null {\n    if (this.lastAppliedIndex === null || this.lastAppliedIndex < 0) {\n      return null\n    }\n    return this.sortedTxs[this.lastAppliedIndex]?.txTimestamp ?? null\n  }\n\n  /**\n   * Gets the last applied index (for debugging/tracking).\n   */\n  getLastAppliedIndex(): number | null {\n    return this.lastAppliedIndex\n  }\n}\n","import { JSONObject } from \"./json\"\nimport { ValidateFn } from \"./operations\"\nimport { StateCalculator } from \"./StateCalculator\"\n\n/**\n * Client-side state including clocks and calculator for state management\n */\nexport interface ClientState {\n  // Lamport clocks (monotonic, never reset)\n  localClock: number\n\n  // Cached finalized epoch (null = not yet initialized, recalculated only when checkpoint map changes)\n  cachedFinalizedEpoch: number | null\n\n  // State calculator (manages sorted tx cache, state calculation, and invalidation)\n  stateCalculator: StateCalculator\n\n  /**\n   * Timestamp retention window in milliseconds.\n   */\n  retentionWindowMs: number\n}\n\n/**\n * Factory to create an initial ClientState\n */\nexport function createClientState(\n  validateFn: ValidateFn<JSONObject> | undefined,\n  retentionWindowMs: number\n): ClientState {\n  return {\n    localClock: 0,\n    cachedFinalizedEpoch: null, // Will be recalculated on first run\n    stateCalculator: new StateCalculator(validateFn),\n    retentionWindowMs,\n  }\n}\n","import * as Y from \"yjs\"\nimport { type CheckpointRecord, pruneCheckpoints } from \"./checkpoints\"\nimport { getFinalizedEpochAndCheckpoint } from \"./checkpointUtils\"\nimport { ClientState } from \"./clientState\"\nimport { JSONObject } from \"./json\"\nimport { Op } from \"./operations\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { isTransactionInCheckpoint } from \"./StateCalculator\"\nimport { TxRecord } from \"./TxRecord\"\nimport { type TxTimestamp, type TxTimestampKey, txTimestampToKey } from \"./txTimestamp\"\n\n/**\n * Changes to transaction keys from a Y.YMapEvent.\n * - added: keys that were added\n * - deleted: keys that were deleted\n */\nexport type TxKeyChanges = {\n  added: readonly TxTimestampKey[]\n  deleted: readonly TxTimestampKey[]\n}\n\n/**\n * Appends a new transaction to the log.\n *\n * @param originalKey - Optional reference to the original transaction key for re-emits.\n *                      Used by syncLog to preserve transactions missed by checkpoints.\n */\nexport function appendTx(\n  ops: readonly Op[],\n  yTx: Y.Map<TxRecord>,\n  activeEpoch: number,\n  myClientId: string,\n  clientState: ClientState,\n  originalKey?: TxTimestampKey\n): TxTimestampKey {\n  const calc = clientState.stateCalculator\n\n  // 1. Advance logical clock (Lamport) based on all seen traffic\n  const clock = Math.max(clientState.localClock, calc.getMaxSeenClock()) + 1\n  clientState.localClock = clock\n\n  // 2. Generate Key with WallClock for future pruning safety\n  const ts: TxTimestamp = {\n    epoch: activeEpoch,\n    clock,\n    clientId: myClientId,\n    wallClock: Date.now(),\n  }\n  const key = txTimestampToKey(ts)\n\n  // 3. Write to Yjs (Atomic)\n  const record: TxRecord = { ops, originalTxKey: originalKey }\n  yTx.set(key, record)\n\n  return key\n}\n\n/**\n * Synchronizes the transaction log with the current checkpoint.\n * Re-emits missed transactions and prunes old ones.\n *\n * Should be called BEFORE updateState to ensure log is clean and complete.\n *\n * @returns true if any transactions were re-emitted or deleted, which may invalidate lastAppliedIndex\n */\nfunction syncLog(\n  yTx: Y.Map<TxRecord>,\n  myClientId: string,\n  clientState: ClientState,\n  finalizedEpoch: number,\n  baseCP: CheckpointRecord | null,\n  newKeys?: readonly TxTimestampKey[] // keys added in this update\n): void {\n  const calc = clientState.stateCalculator\n  const activeEpoch = finalizedEpoch + 1\n  const watermarks = baseCP?.watermarks ?? {}\n\n  // Deterministic Reference Time: Use stored minWallClock if available, otherwise 0 (nothing ancient).\n  const referenceTime = baseCP?.minWallClock ?? 0\n\n  // Helper to check if a transaction should be pruned\n  const shouldPrune = (ts: TxTimestamp, dedupTs: TxTimestamp): boolean => {\n    const isAncient = referenceTime - ts.wallClock > clientState.retentionWindowMs\n    if (isAncient) return true\n    return isTransactionInCheckpoint(dedupTs, watermarks)\n  }\n\n  const toDelete: TxTimestampKey[] = []\n  const toReEmit: Array<{ originalKey: TxTimestampKey; tx: TxRecord }> = []\n\n  // 1. Helper to decide what to do with each transaction\n  const processEntry = (entry: SortedTxEntry): boolean => {\n    if (shouldPrune(entry.txTimestamp, entry.dedupTxTimestamp)) {\n      toDelete.push(entry.txTimestampKey)\n      return false // deleted\n    }\n\n    if (entry.txTimestamp.epoch <= finalizedEpoch) {\n      // Not in checkpoint and still fresh - re-emit it to the active epoch\n      toReEmit.push({ originalKey: entry.dedupTxTimestampKey, tx: entry.txRecord })\n      toDelete.push(entry.txTimestampKey)\n      return false // re-emitted\n    }\n\n    return true // active/fresh\n  }\n\n  // 2. Scan local cache (sortedTxs) to identify missing/ancient transactions\n  for (const entry of calc.getSortedTxs()) {\n    if (processEntry(entry)) {\n      // Optimization: Physical keys are sorted. If we hit the active/fresh territory, we can stop.\n      break\n    }\n  }\n\n  const processKeyByTimestampKey = (txTimestampKey: TxTimestampKey): void => {\n    // Only process if it actually exists in Yjs Map\n    if (yTx.has(txTimestampKey)) {\n      processEntry(new SortedTxEntry(txTimestampKey, yTx))\n    }\n  }\n\n  // 3. Scan NEW keys from Yjs to handle incoming transactions (sync)\n  // Any client can re-emit - deduplication via originalTxKey handles duplicates.\n  if (newKeys) {\n    for (const key of newKeys) {\n      processKeyByTimestampKey(key)\n    }\n  }\n\n  // 4. Re-emit missed transactions BEFORE pruning\n  for (const { originalKey, tx } of toReEmit) {\n    const newKey = appendTx(tx.ops, yTx, activeEpoch, myClientId, clientState, originalKey)\n    calc.insertTx(newKey, yTx)\n  }\n\n  // 5. Prune old/finalized/redundant transactions from Yjs Map\n  for (const key of toDelete) {\n    yTx.delete(key)\n  }\n  calc.removeTxs(toDelete)\n}\n\n/**\n * The primary update function that maintains current state.\n *\n * @param txChanges - Changes from Y.YMapEvent. If undefined (first run), performs a full scan.\n */\nexport function updateState(\n  doc: Y.Doc,\n  yTx: Y.Map<TxRecord>,\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  myClientId: string,\n  clientState: ClientState,\n  txChanges: TxKeyChanges | undefined\n): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n  const calc = clientState.stateCalculator\n\n  // Always calculate fresh finalized epoch and checkpoint to handle sync race conditions\n  const { finalizedEpoch, checkpoint: baseCP } = getFinalizedEpochAndCheckpoint(yCheckpoint)\n\n  // Update read-cache\n  clientState.cachedFinalizedEpoch = finalizedEpoch\n\n  // Set base checkpoint (this handles invalidation if checkpoint changed)\n  calc.setBaseCheckpoint(baseCP)\n\n  // Track if we need to rebuild sorted cache (first run or missing delta)\n  // Optimization: We don't need to rebuild just because checkpoint changed,\n  // as long as we have txChanges to keep cache in sync.\n  const needsRebuildSortedCache = calc.getCachedState() === null || !txChanges\n\n  // Rebuild sorted cache before syncLog if needed\n  if (needsRebuildSortedCache) {\n    calc.rebuildFromYjs(yTx)\n  } else {\n    // If not rebuilding, immediately process deletions to avoid \"ghost\" transactions\n    // in syncLog (e.g. attempting to access a transaction that was just deleted).\n    calc.removeTxs(txChanges.deleted)\n  }\n\n  // Sync and prune within transaction\n  doc.transact(() => {\n    syncLog(yTx, myClientId, clientState, finalizedEpoch, baseCP, txChanges?.added)\n\n    // Safe to use local finalizedEpoch here\n    pruneCheckpoints(yCheckpoint, finalizedEpoch)\n  })\n\n  if (needsRebuildSortedCache) {\n    // Full recompute (calculator handles this)\n    return calc.calculateState()\n  }\n\n  // Incremental update using only changed keys (calculator handles this)\n  // txChanges is guaranteed to exist here since !txChanges implies needsRebuildSortedCache\n\n  // Update sorted cache with new keys from txChanges\n  // This must happen after syncLog which may have deleted some of these keys\n  for (const key of txChanges.added) {\n    // CRITICAL: Check yTx.has(key)! syncLog might have just pruned it.\n    if (yTx.has(key) && !calc.hasTx(key)) {\n      calc.insertTx(key, yTx)\n    }\n  }\n\n  return calc.calculateState()\n}\n","import * as Y from \"yjs\"\nimport { CheckpointRecord, createCheckpoint } from \"./checkpoints\"\nimport { createClientState } from \"./clientState\"\nimport { failure } from \"./error\"\nimport { JSONObject } from \"./json\"\n\nimport { Op, ValidateFn } from \"./operations\"\n\nimport { computeReconcileOps } from \"./reconcile\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { TxRecord } from \"./TxRecord\"\nimport { appendTx, TxKeyChanges, updateState } from \"./txLog\"\nimport { TxTimestampKey } from \"./txTimestamp\"\nimport { generateID } from \"./utils\"\n\nexport const getSortedTxsSymbol = Symbol(\"getSortedTxs\")\n\nexport interface StateSyncLogOptions<State extends JSONObject> {\n  /**\n   * The Y.js Document to bind to.\n   */\n  yDoc: Y.Doc\n\n  /**\n   * Name for the txs Y.Map.\n   * Default: \"state-sync-log-tx\"\n   */\n  yTxMapName?: string\n\n  /**\n   * Name for the checkpoint Y.Map.\n   * Default: \"state-sync-log-checkpoint\"\n   */\n  yCheckpointMapName?: string\n\n  /**\n   * Unique identifier for this client.\n   * If omitted, a random UUID (nanoid) will be generated.\n   * NOTE: If you need to resume a session (keep local clock/watermark), you MUST provide a stable ID.\n   * MUST NOT contain semicolons.\n   */\n  clientId?: string\n\n  /**\n   * Origin tag for Y.js txs created by this library.\n   */\n  yjsOrigin?: unknown\n\n  /**\n   * Optional validation function.\n   * Runs after each tx's ops are applied.\n   * If it returns false, the tx is rejected (state reverts).\n   * MUST be deterministic and consistent across all clients.\n   */\n  validate?: (state: State) => boolean\n\n  /**\n   * Timestamp retention window in milliseconds.\n   * Txs older than this window are considered \"Ancient\" and pruned.\n   *\n   * Default: Infinity (No pruning).\n   * Recommended: 14 days (1209600000 ms).\n   */\n  retentionWindowMs: number | undefined\n}\n\nexport interface StateSyncLogController<State extends JSONObject> {\n  /**\n   * Returns the current state.\n   */\n  getState(): State\n\n  /**\n   * Subscribes to state changes.\n   */\n  subscribe(callback: (newState: State, getAppliedOps: () => readonly Op[]) => void): () => void\n\n  /**\n   * Emits a new tx (list of operations) to the log.\n   */\n  emit(ops: Op[]): void\n\n  /**\n   * Reconciles the current state with the target state.\n   */\n  reconcileState(targetState: State): void\n\n  /**\n   * Manually triggers epoch compaction (Checkpointing).\n   */\n  compact(): void\n\n  /**\n   * Cleans up observers and releases memory.\n   */\n  dispose(): void\n\n  // --- Observability & Stats ---\n\n  /**\n   * Returns the current active epoch number.\n   */\n  getActiveEpoch(): number\n\n  /**\n   * Returns the number of txs currently in the active epoch.\n   */\n  getActiveEpochTxCount(): number\n\n  /**\n   * Returns the wallClock timestamp of the first tx in the active epoch.\n   */\n  getActiveEpochStartTime(): number | undefined\n\n  /**\n   * Returns true if the log is completely empty.\n   */\n  isLogEmpty(): boolean\n\n  /**\n   * Internal/Testing: Returns all txs currently in the log, sorted.\n   */\n  [getSortedTxsSymbol](): readonly SortedTxEntry[]\n}\n\n/**\n * Creates a StateSyncLog controller.\n */\nexport function createStateSyncLog<State extends JSONObject>(\n  options: StateSyncLogOptions<State>\n): StateSyncLogController<State> {\n  const {\n    yDoc,\n    yTxMapName = \"state-sync-log-tx\",\n    yCheckpointMapName = \"state-sync-log-checkpoint\",\n    clientId = generateID(),\n    yjsOrigin,\n    validate,\n    retentionWindowMs,\n  } = options\n\n  if (clientId.includes(\";\")) {\n    failure(`clientId MUST NOT contain semicolons: ${clientId}`)\n  }\n\n  const yTx = yDoc.getMap<TxRecord>(yTxMapName)\n  const yCheckpoint = yDoc.getMap<CheckpointRecord>(yCheckpointMapName)\n\n  // Cast validate to basic type to match internal ClientState\n  const clientState = createClientState(\n    validate as unknown as ValidateFn<JSONObject>,\n    retentionWindowMs ?? Number.POSITIVE_INFINITY\n  )\n\n  // Listeners\n  const subscribers = new Set<(state: State, getAppliedOps: () => readonly Op[]) => void>()\n\n  const notifySubscribers = (state: State, getAppliedOps: () => readonly Op[]) => {\n    for (const sub of subscribers) {\n      sub(state, getAppliedOps)\n    }\n  }\n\n  // Helper to extract key changes from YMapEvent\n  const extractTxChanges = (event: Y.YMapEvent<TxRecord>): TxKeyChanges => {\n    const added: TxTimestampKey[] = []\n    const deleted: TxTimestampKey[] = []\n\n    for (const [key, change] of event.changes.keys) {\n      if (change.action === \"add\") {\n        added.push(key)\n      } else if (change.action === \"delete\") {\n        deleted.push(key)\n      } else if (change.action === \"update\") {\n        deleted.push(key)\n        added.push(key)\n      }\n    }\n\n    return { added, deleted }\n  }\n\n  // Empty txChanges object for checkpoint observer (no tx keys changed)\n  const emptyTxChanges: TxKeyChanges = { added: [], deleted: [] }\n\n  // Update Logic with incremental changes\n  const runUpdate = (txChanges: TxKeyChanges | undefined) => {\n    const { state, getAppliedOps } = updateState(\n      yDoc,\n      yTx,\n      yCheckpoint,\n      clientId,\n      clientState,\n      txChanges\n    )\n    notifySubscribers(state as State, getAppliedOps)\n  }\n\n  // Tx observer\n  const txObserver = (event: Y.YMapEvent<TxRecord>, _transaction: Y.Transaction) => {\n    const txChanges = extractTxChanges(event)\n    runUpdate(txChanges)\n  }\n\n  // Checkpoint observer\n  const checkpointObserver = (\n    _event: Y.YMapEvent<CheckpointRecord>,\n    _transaction: Y.Transaction\n  ) => {\n    runUpdate(emptyTxChanges)\n  }\n\n  yCheckpoint.observe(checkpointObserver)\n  yTx.observe(txObserver)\n\n  // Initial run (full recompute, treat as checkpoint change to initialize epoch cache)\n  runUpdate(undefined)\n\n  // Track disposal state\n  let disposed = false\n\n  const assertNotDisposed = () => {\n    if (disposed) {\n      failure(\"StateSyncLog has been disposed and cannot be used\")\n    }\n  }\n\n  const getActiveEpochInternal = () => {\n    if (clientState.cachedFinalizedEpoch === null) {\n      failure(\"cachedFinalizedEpoch is null - this should not happen after initialization\")\n    }\n    return clientState.cachedFinalizedEpoch + 1\n  }\n\n  return {\n    getState(): State {\n      assertNotDisposed()\n      return (clientState.stateCalculator.getCachedState() ?? {}) as State\n    },\n\n    subscribe(callback: (newState: State, getAppliedOps: () => readonly Op[]) => void): () => void {\n      assertNotDisposed()\n      subscribers.add(callback)\n      return () => {\n        subscribers.delete(callback)\n      }\n    },\n\n    emit(ops: Op[]): void {\n      assertNotDisposed()\n      yDoc.transact(() => {\n        const activeEpoch = getActiveEpochInternal()\n        appendTx(ops, yTx, activeEpoch, clientId, clientState)\n      }, yjsOrigin)\n    },\n\n    reconcileState(targetState: State): void {\n      assertNotDisposed()\n      const currentState = (clientState.stateCalculator.getCachedState() ?? {}) as State\n      const ops = computeReconcileOps(currentState, targetState)\n      if (ops.length > 0) {\n        this.emit(ops)\n      }\n    },\n\n    compact(): void {\n      assertNotDisposed()\n      yDoc.transact(() => {\n        const activeEpoch = getActiveEpochInternal()\n        const currentState = clientState.stateCalculator.getCachedState() ?? {}\n        createCheckpoint(yTx, yCheckpoint, clientState, activeEpoch, currentState, clientId)\n      }, yjsOrigin)\n    },\n\n    dispose(): void {\n      if (disposed) return // Already disposed, no-op\n      disposed = true\n      yTx.unobserve(txObserver)\n      yCheckpoint.unobserve(checkpointObserver)\n      subscribers.clear()\n    },\n\n    getActiveEpoch(): number {\n      assertNotDisposed()\n      return getActiveEpochInternal()\n    },\n\n    getActiveEpochTxCount(): number {\n      assertNotDisposed()\n      const activeEpoch = getActiveEpochInternal()\n      let count = 0\n      // Only current or future epochs exist in sortedTxs (past epochs are pruned during updateState).\n      // Future epochs appear if we receive txs before the corresponding checkpoint.\n      for (const entry of clientState.stateCalculator.getSortedTxs()) {\n        const ts = entry.txTimestamp\n        if (ts.epoch === activeEpoch) {\n          count++\n        } else if (ts.epoch > activeEpoch) {\n          break // Optimization: sorted order means we can stop early\n        }\n      }\n      return count\n    },\n\n    getActiveEpochStartTime(): number | undefined {\n      assertNotDisposed()\n      const activeEpoch = getActiveEpochInternal()\n      // Only current or future epochs exist in sortedTxs (past epochs are pruned during updateState).\n      for (const entry of clientState.stateCalculator.getSortedTxs()) {\n        const ts = entry.txTimestamp\n        if (ts.epoch === activeEpoch) {\n          return ts.wallClock\n        } else if (ts.epoch > activeEpoch) {\n          break // Optimization: sorted order means we can stop early\n        }\n      }\n      return undefined\n    },\n\n    isLogEmpty(): boolean {\n      assertNotDisposed()\n      return yTx.size === 0 && yCheckpoint.size === 0\n    },\n\n    [getSortedTxsSymbol](): readonly SortedTxEntry[] {\n      assertNotDisposed()\n      return clientState.stateCalculator.getSortedTxs()\n    },\n  }\n}\n","import { failure } from \"./error\"\r\nimport { JSONObject, JSONValue, Path } from \"./json\"\r\nimport { deepClone, deepEqual, isObject, parseArrayIndex } from \"./utils\"\r\n\r\n/**\r\n * Supported operations.\r\n * Applied sequentially within a tx.\r\n */\r\nexport type Op =\r\n  | { kind: \"set\"; path: Path; key: string | number; value: JSONValue }\r\n  | { kind: \"delete\"; path: Path; key: string | number }\r\n  | { kind: \"splice\"; path: Path; index: number; deleteCount: number; inserts: JSONValue[] }\r\n  | { kind: \"addToSet\"; path: Path; value: JSONValue }\r\n  | { kind: \"deleteFromSet\"; path: Path; value: JSONValue }\r\n\r\n/**\r\n * Validation function type.\r\n *\r\n * Rules:\r\n * - Validation MUST depend only on candidateState (and deterministic code).\r\n * - Validation runs once per tx, after all ops apply.\r\n * - If validation fails, the x is rejected (state reverts to previous).\r\n * - If no validator is provided, validation defaults to true.\r\n *\r\n * IMPORTANT: Validation outcome is **derived local state** and MUST NOT be replicated.\r\n * All clients MUST use the same validation logic to ensure consistency.\r\n */\r\nexport type ValidateFn<State extends JSONObject> = (candidateState: State) => boolean\r\n\r\n/**\r\n * Resolves a path within the state.\r\n * Throws if any segment is missing or has wrong type.\r\n */\r\nfunction resolvePath(state: JSONObject, path: Path): JSONValue {\r\n  let current: JSONValue = state\r\n  for (const segment of path) {\r\n    if (typeof segment === \"string\") {\r\n      if (!isObject(current) || Array.isArray(current)) {\r\n        failure(`Expected object at path segment \"${segment}\"`)\r\n      }\r\n      if (!(segment in current)) {\r\n        failure(`Property \"${segment}\" does not exist`)\r\n      }\r\n      current = current[segment]\r\n    } else {\r\n      if (!Array.isArray(current)) {\r\n        failure(`Expected array at path segment ${segment}`)\r\n      }\r\n      if (segment < 0 || segment >= current.length) {\r\n        failure(`Index ${segment} out of bounds`)\r\n      }\r\n      current = current[segment]\r\n    }\r\n  }\r\n  return current\r\n}\r\n\r\n/**\r\n * Applies a single operation.\r\n * (Reference implementation for standard JSON-patch behavior)\r\n */\r\nfunction applyOp(state: JSONObject, op: Op, cloneValues: boolean): void {\r\n  // Special case: if path is empty, we can't resolve \"container\".\r\n  // The caller must handle root-level replacement if necessary, but\r\n  // standard Ops usually act ON a container.\r\n  // Exception: if we act on root, handle explicitly or assume path length > 0.\r\n  // For this spec, Ops modify *fields* or *indices*.\r\n  // If path is empty, it means we are acting ON the root object itself?\r\n  // The spec's \"set\" example: container[op.key] = op.value.\r\n  // This implies we resolve path to get the PARENT container.\r\n\r\n  const container = resolvePath(state, op.path)\r\n\r\n  switch (op.kind) {\r\n    case \"set\": {\r\n      // Allow object or array container\r\n      if (!isObject(container)) {\r\n        failure(\"set requires object or array container\")\r\n      }\r\n      let key: string | number = op.key\r\n      // For arrays, convert string keys to numbers (except \"length\")\r\n      if (Array.isArray(container) && typeof key === \"string\" && key !== \"length\") {\r\n        const numKey = parseArrayIndex(key)\r\n        if (numKey === null) {\r\n          failure(`Cannot set non-numeric property \"${key}\" on array`)\r\n        }\r\n        key = numKey\r\n      }\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      ;(container as any)[key] = cloneValues ? deepClone(op.value) : op.value\r\n      break\r\n    }\r\n\r\n    case \"delete\": {\r\n      // Allow object or array (sparse delete?)\r\n      if (!isObject(container)) {\r\n        failure(\"delete requires object or array container\")\r\n      }\r\n      let key: string | number = op.key\r\n      // For arrays, convert string keys to numbers\r\n      if (Array.isArray(container) && typeof key === \"string\") {\r\n        const numKey = parseArrayIndex(key)\r\n        if (numKey === null) {\r\n          failure(`Cannot delete non-numeric property \"${key}\" from array`)\r\n        }\r\n        key = numKey\r\n      }\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      delete (container as any)[key]\r\n      break\r\n    }\r\n\r\n    case \"splice\": {\r\n      if (!Array.isArray(container)) {\r\n        failure(\"splice requires array container\")\r\n      }\r\n      const safeIndex = Math.min(op.index, container.length)\r\n      container.splice(\r\n        safeIndex,\r\n        op.deleteCount,\r\n        ...(cloneValues ? op.inserts.map((v) => deepClone(v)) : op.inserts)\r\n      )\r\n      break\r\n    }\r\n\r\n    case \"addToSet\":\r\n      if (!Array.isArray(container)) {\r\n        failure(\"addToSet requires array container\")\r\n      }\r\n      if (!container.some((item) => deepEqual(item, op.value))) {\r\n        container.push(cloneValues ? deepClone(op.value) : op.value)\r\n      }\r\n      break\r\n\r\n    case \"deleteFromSet\":\r\n      if (!Array.isArray(container)) {\r\n        failure(\"deleteFromSet requires array container\")\r\n      }\r\n      // Remove all matching items using splice (from end to avoid index shifting)\r\n      for (let i = container.length - 1; i >= 0; i--) {\r\n        if (deepEqual(container[i], op.value)) {\r\n          container.splice(i, 1)\r\n        }\r\n      }\r\n      break\r\n\r\n    default:\r\n      throw failure(`Unknown operation kind: ${(op as any).kind}`)\r\n  }\r\n}\r\n\r\n/**\r\n * Options for applyOps.\r\n */\r\nexport interface ApplyOpsOptions {\r\n  /**\r\n   * Whether to deep clone values before inserting them into the target.\r\n   * - `true` (default): Values are cloned to prevent aliasing between the ops and target.\r\n   * - `false`: Values are used directly for better performance. Only use this if you\r\n   *   guarantee the op values won't be mutated after application.\r\n   */\r\n  cloneValues?: boolean\r\n}\r\n\r\n/**\r\n * Applies a list of operations to a mutable target object.\r\n * Use this to synchronize an external mutable state (e.g., MobX store)\r\n * with the operations received via subscribe().\r\n *\r\n * @param ops - The list of operations to apply.\r\n * @param target - The mutable object to modify.\r\n * @param options - Optional settings for controlling cloning behavior.\r\n */\r\nexport function applyOps(ops: readonly Op[], target: JSONObject, options?: ApplyOpsOptions): void {\r\n  const cloneValues = options?.cloneValues ?? true\r\n  for (const op of ops) {\r\n    applyOp(target, op, cloneValues)\r\n  }\r\n}\r\n"],"names":["DraftType","current","original","deepClone","equal","scopedUrlAlphabet","rfdc","handler","clone","createDraft","ops","nextState"],"mappings":"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","x_google_ignoreList":[5,6,7,8]}