state-sync-log 0.9.0 → 0.10.0

package/dist/state-sync-log.umd.js

@@ -5,28 +5,6 @@
 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);
@@ -36,88 +14,232 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   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;
   }
@@ -385,6 +507,636 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       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,
@@ -423,46 +1175,62 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     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);
@@ -539,50 +1307,50 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     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) {
@@ -1258,43 +2026,61 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     };
   }
   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");
@@ -1336,8 +2122,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       applyOp(target, op, cloneValues);
     }
   }
+  exports2.addToSet = addToSet;
   exports2.applyOps = applyOps;
+  exports2.createOps = createOps;
   exports2.createStateSyncLog = createStateSyncLog;
+  exports2.current = current;
+  exports2.deleteFromSet = deleteFromSet;
+  exports2.isDraft = isDraft;
+  exports2.isDraftable = isDraftable;
+  exports2.original = original;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"state-sync-log.umd.js","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.umd.js","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":";;;;;;;EAAO,MAAM,0BAA0B,MAAM;AAAA,IAC3C,YAAY,KAAa;AACvB,YAAM,GAAG;AAGT,aAAO,eAAe,MAAM,kBAAkB,SAAS;AAAA,IACzD;AAAA,EACF;AAEO,WAAS,QAAQ,SAAwB;AAC9C,UAAM,IAAI,kBAAkB,OAAO;AAAA,EACrC;ACLO,QAAM,cAAc,uBAAO,IAAI,2BAA2B;ACI1D,MAAK,8BAAAA,eAAL;AACLA,eAAAA,WAAA,YAAS,CAAA,IAAT;AACAA,eAAAA,WAAA,WAAQ,CAAA,IAAR;AAFU,WAAAA;AAAAA,EAAA,GAAA,aAAA,CAAA,CAAA;ACML,WAAS,OAAU,YAA8B;;AACtD,YAAQ,gBAAW,SAAX,YAAmB,WAAW;AAAA,EACxC;AAKO,WAAS,QAAQ,QAA0B;AAChD,WAAO,CAAC,CAAC,cAAc,MAAM;AAAA,EAC/B;AAKO,WAAS,cAAiB,OAAsC;;AACrE,QAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,YAAQ,WAA4C,WAAW,MAAvD,YAA4D;AAAA,EACtE;AAKO,WAAS,SAA2B,OAAa;;AACtD,UAAM,aAAa,cAAc,KAAK;AACtC,WAAO,cAAe,gBAAW,SAAX,YAAmB,WAAW,WAAkB;AAAA,EACxE;AAMO,WAAS,YAAY,OAAiC;AAC3D,QAAI,UAAU,QAAQ,OAAO,UAAU,SAAU,QAAO;AACxD,WAAO,MAAM,QAAQ,KAAK,KAAK,OAAO,eAAe,KAAK,MAAM,OAAO;AAAA,EACzE;AAKO,WAAS,QAAQ,QAA4B;AAClD,WAAO,MAAM,QAAQ,MAAM,IAAI,UAAU,QAAQ,UAAU;AAAA,EAC7D;AAKO,WAAS,IAAI,QAAgB,KAA2B;AAC7D,WAAQ,OAAwC,GAAG;AAAA,EACrD;AAKO,WAAS,IAAI,QAAgB,KAAkB,OAAsB;AACxE,WAAwC,GAAG,IAAI;AAAA,EACnD;AAKO,WAAS,IAAI,QAAgB,KAA2B;AAC7D,WAAO,OAAO,OAAO,QAAQ,GAAa;AAAA,EAC5C;AAKO,WAAS,KAAK,QAAgB,KAA2B;AAC9D,UAAM,QAAQ,cAAc,MAAM;AAClC,UAAM,SAAS,QAAQ,OAAO,KAAK,IAAI;AACvC,WAAQ,OAAwC,GAAG;AAAA,EACrD;AAKO,WAAS,QAAQ,GAAY,GAAqB;AACvD,QAAI,MAAM,GAAG;AACX,aAAO,MAAM,KAAK,IAAK,MAAiB,IAAK;AAAA,IAC/C;AAEA,WAAO,MAAM,KAAK,MAAM;AAAA,EAC1B;AAKO,WAAS,YAAY,YAAqC;AAC/D,QAAI,CAAC,WAAY;AACjB,WAAO,WAAW,WAAW,OAAO,SAAS,GAAG;AAC9C,YAAM,SAAS,WAAW,WAAW,OAAO,IAAA;AAC5C,aAAA;AAAA,IACF;AAAA,EACF;AAKO,WAAS,QACd,QACA,OAA4B,IACA;;AAC5B,QAAI,OAAO,OAAO,QAAQ,KAAK,KAAK,OAAO,QAAQ,QAAW;AAE5D,YAAM,cAAa,YAAO,WAAP,mBAAe;AAClC,UAAI,YAAY;AACd,cAAM,aAAa,cAAc,IAAI,YAAsB,OAAO,GAAG,CAAC;AACtE,YAAI,eAAe,QAAQ,WAAW,aAAa,OAAO,UAAU;AAClE,iBAAO;AAAA,QACT;AAAA,MACF;AACA,WAAK,KAAK,OAAO,GAAG;AAAA,IACtB;AACA,QAAI,OAAO,QAAQ;AACjB,aAAO,QAAQ,OAAO,QAAQ,IAAI;AAAA,IACpC;AAEA,SAAK,QAAA;AACL,WAAO;AAAA,EACT;AAKO,WAAS,eAAe,QAAyC;AACtE,UAAM,OAAO,QAAQ,MAAM;AAC3B,QAAI,CAAC,MAAM;AACT,YAAM,QAAQ,qCAAqC;AAAA,IACrD;AACA,WAAO;AAAA,EACT;AAMO,WAAS,oBACd,WACA,aACuB;AACvB,UAAM,SAAgC,CAAA;AAEtC,aAAS,OAAOC,UAAqB,aAAwC;AAC3E,UAAIA,aAAY,aAAa;AAC3B,eAAO,KAAK,CAAC,GAAG,WAAW,CAAC;AAAA,MAE9B;AAEA,YAAM,SAAS,OAAOA,QAAO;AAC7B,UAAI,CAAC,UAAU,OAAO,WAAW,SAAU;AAE3C,YAAM,OAA4B,MAAM,QAAQ,MAAM,IAClD,MAAM,KAAK,EAAE,QAAQ,OAAO,OAAA,GAAU,CAAC,GAAG,MAAM,CAAC,IACjD,OAAO,KAAK,MAAM;AAEtB,iBAAW,OAAO,MAAM;AACtB,cAAM,QAAQ,OAAO,GAAG;AACxB,cAAM,aAAa,cAAc,KAAK;AACtC,YAAI,YAAY;AACd,iBAAO,YAAY,CAAC,GAAG,aAAa,GAAG,CAAC;AAAA,QAC1C;AAAA,MACF;AAAA,IACF;AAEA,WAAO,WAAW,EAAE;AACpB,WAAO;AAAA,EACT;AAKO,WAAS,cAAc,QAAgB,KAAkD;AAC9F,QAAI,OAAO,QAAQ;AACjB,UAAI,YAAY,QAAQ,eAAe,MAAM;AAC7C,aAAO,WAAW;AAChB,cAAM,aAAa,QAAQ,yBAAyB,WAAW,GAAG;AAClE,YAAI,WAAY,QAAO;AACvB,oBAAY,QAAQ,eAAe,SAAS;AAAA,MAC9C;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAMA,QAAM,aAAa,OAAO,UAAU;AAK7B,WAAS,YAAeC,WAAgB;AAC7C,QAAI,MAAM,QAAQA,SAAQ,GAAG;AAC3B,aAAO,MAAM,UAAU,OAAO,KAAKA,SAAQ;AAAA,IAC7C;AAEA,UAAM,OAAyC,CAAA;AAC/C,eAAW,OAAO,OAAO,KAAKA,SAAkB,GAAG;AACjD,WAAK,GAAG,IAAKA,UAAqC,GAAG;AAAA,IACvD;AACA,eAAW,OAAO,OAAO,sBAAsBA,SAAkB,GAAG;AAClE,UAAI,WAAW,KAAKA,WAAU,GAAG,GAAG;AAClC,aAAK,GAAG,IAAKA,UAAqC,GAAG;AAAA,MACvD;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAKO,WAAS,kBAAkB,QAA0B;;AAC1D,QAAI,OAAO,KAAM;AACjB,WAAO,OAAO,YAAY,OAAO,QAAQ;AACzC,WAAO,eAAc,YAAO,gBAAP,YAAsB,oBAAI,IAAA;AAAA,EACjD;AAKO,WAASC,YAAa,QAAc;AACzC,QAAI,CAAC,YAAY,MAAM,GAAG;AACxB,aAAO,QAAQ,MAAM,IAAK,SAAS,MAAgB,IAAU;AAAA,IAC/D;AACA,QAAI,MAAM,QAAQ,MAAM,GAAG;AACzB,aAAO,OAAO,IAAIA,WAAS;AAAA,IAC7B;AACA,UAAM,OAAgC,CAAA;AACtC,eAAW,OAAO,QAAQ;AACxB,UAAI,IAAI,QAAQ,GAAG,GAAG;AACpB,aAAK,GAAG,IAAIA,YAAW,OAAmC,GAAG,CAAC;AAAA,MAChE;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAgBO,WAAS,YAAY,QAA0B;AACpD,QAAI,CAAC,OAAO,UAAU;AACpB,aAAO,WAAW;AAClB,UAAI,OAAO,QAAQ;AACjB,oBAAY,OAAO,MAAM;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AAKO,WAAS,QACd,QACA,UACM;AACN,QAAI,MAAM,QAAQ,MAAM,GAAG;AACzB,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,iBAAS,GAAG,OAAO,CAAC,GAAG,MAAM;AAAA,MAC/B;AAAA,IACF,OAAO;AACL,iBAAW,OAAO,QAAQ,QAAQ,MAAM,GAAG;AACzC,iBAAS,KAAM,OAAwC,GAAG,GAAG,MAAM;AAAA,MACrE;AAAA,IACF;AAAA,EACF;AASO,WAAS,YAAY,QAAiB,YAAmC;AAC9E,QACE,CAAC,YAAY,MAAM,KACnB,QAAQ,MAAM,KACd,WAAW,IAAI,MAAgB,KAC/B,OAAO,SAAS,MAAM,GACtB;AACA;AAAA,IACF;AAEA,eAAW,IAAI,MAAgB;AAE/B,YAAQ,QAAkB,CAAC,KAAK,UAAU;;AACxC,UAAI,QAAQ,KAAK,GAAG;AAClB,cAAM,aAAa,cAAc,KAAK;AACtC,0BAAkB,UAAU;AAC5B,cAAM,iBACJ,gBAAW,gBAAX,mBAAwB,SAAQ,WAAW,WAAW,WAAW,OAAO,WAAW;AACrF,YAAI,QAAkB,KAAK,YAAY;AAAA,MACzC,OAAO;AACL,oBAAY,OAAO,UAAU;AAAA,MAC/B;AAAA,IACF,CAAC;AAAA,EACH;AChTA,WAAS,WAAc,QAAc;AACnC,UAAM,aAAa,cAAc,MAAM;AAGvC,QAAI,CAAC,YAAY,MAAM,EAAG,QAAO;AAGjC,QAAI,cAAc,CAAC,WAAW,UAAU;AACtC,aAAO,WAAW;AAAA,IACpB;AAEA,QAAI;AAEJ,aAAS,yBAAyB;AAChC,qBAAe,YAAY,MAAM;AAAA,IACnC;AAEA,QAAI,YAAY;AAEd,iBAAW,YAAY;AACvB,UAAI;AACF,+BAAA;AAAA,MACF,UAAA;AACE,mBAAW,YAAY;AAAA,MACzB;AAAA,IACF,OAAO;AAEL,qBAAe;AAAA,IACjB;AAGA,YAAQ,cAAwB,CAAC,KAAK,UAAU;AAC9C,UAAI,cAAc,QAAQ,IAAI,WAAW,UAAoB,GAAG,GAAG,KAAK,GAAG;AACzE;AAAA,MACF;AACA,YAAM,WAAW,WAAW,KAAK;AACjC,UAAI,aAAa,OAAO;AACtB,YAAI,iBAAiB,QAAQ;AAC3B,iCAAA;AAAA,QACF;AACA,YAAI,cAAwB,KAAK,QAAQ;AAAA,MAC3C;AAAA,IACF,CAAC;AAED,WAAO;AAAA,EACT;AAcO,WAAS,QAA0B,QAAyB;AACjE,QAAI,CAAC,QAAQ,MAAM,GAAG;AACpB,YAAM,IAAI,MAAM,gDAAgD,MAAM,EAAE;AAAA,IAC1E;AACA,WAAO,WAAW,MAAM;AAAA,EAC1B;;;;;;;;;AC9EA,oBAAiB,SAASC,OAAM,GAAG,GAAG;AACpC,UAAI,MAAM,EAAG,QAAO;AAEpB,UAAI,KAAK,KAAK,OAAO,KAAK,YAAY,OAAO,KAAK,UAAU;AAC1D,YAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;AAE5C,YAAI,QAAQ,GAAG;AACf,YAAI,MAAM,QAAQ,CAAC,GAAG;AACpB,mBAAS,EAAE;AACX,cAAI,UAAU,EAAE,OAAQ,QAAO;AAC/B,eAAK,IAAI,QAAQ,QAAQ;AACvB,gBAAI,CAACA,OAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAG,QAAO;AACjC,iBAAO;AAAA,QACb;AAII,YAAI,EAAE,gBAAgB,OAAQ,QAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE;AAC5E,YAAI,EAAE,YAAY,OAAO,UAAU,QAAS,QAAO,EAAE,QAAO,MAAO,EAAE,QAAO;AAC5E,YAAI,EAAE,aAAa,OAAO,UAAU,SAAU,QAAO,EAAE,SAAQ,MAAO,EAAE,SAAQ;AAEhF,eAAO,OAAO,KAAK,CAAC;AACpB,iBAAS,KAAK;AACd,YAAI,WAAW,OAAO,KAAK,CAAC,EAAE,OAAQ,QAAO;AAE7C,aAAK,IAAI,QAAQ,QAAQ;AACvB,cAAI,CAAC,OAAO,UAAU,eAAe,KAAK,GAAG,KAAK,CAAC,CAAC,EAAG,QAAO;AAEhE,aAAK,IAAI,QAAQ,QAAQ,KAAI;AAC3B,cAAI,MAAM,KAAK,CAAC;AAEhB,cAAI,CAACA,OAAM,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,EAAG,QAAO;AAAA,QACzC;AAEI,eAAO;AAAA,MACX;AAGE,aAAO,MAAI,KAAK,MAAI;AAAA,IACtB;;;;;AC7CO,QAAM,cACX;ACoBK,MAAI,SAAS,CAAC,OAAO,OAAO;AACjC,QAAI,KAAK;AACT,QAAI,QAAQ,OAAO,gBAAgB,IAAI,WAAY,QAAQ,CAAC,CAAE;AAC9D,WAAO,QAAQ;AACb,YAAMC,YAAkB,MAAM,IAAI,IAAI,EAAE;AAAA,IAC1C;AACA,WAAO;AAAA,EACT;;;;;;AC3BA,aAAiBC;AAEjB,aAAS,WAAY,KAAK;AACxB,UAAI,eAAe,QAAQ;AACzB,eAAO,OAAO,KAAK,GAAG;AAAA,MAC1B;AAEE,aAAO,IAAI,IAAI,YAAY,IAAI,OAAO,MAAK,GAAI,IAAI,YAAY,IAAI,MAAM;AAAA,IAC3E;AAEA,aAASA,MAAM,MAAM;AACnB,aAAO,QAAQ,CAAA;AACf,UAAI,KAAK,QAAS,QAAO,YAAY,IAAI;AAEzC,YAAM,sBAAsB,oBAAI,IAAG;AACnC,0BAAoB,IAAI,MAAM,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC;AAChD,0BAAoB,IAAI,KAAK,CAAC,GAAG,OAAO,IAAI,IAAI,WAAW,MAAM,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;AAC9E,0BAAoB,IAAI,KAAK,CAAC,GAAG,OAAO,IAAI,IAAI,WAAW,MAAM,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;AAC9E,UAAI,KAAK,qBAAqB;AAC5B,mBAAWC,YAAW,KAAK,qBAAqB;AAC9C,8BAAoB,IAAIA,SAAQ,CAAC,GAAGA,SAAQ,CAAC,CAAC;AAAA,QACpD;AAAA,MACA;AAEE,UAAI,UAAU;AAEd,aAAO,KAAK,QAAQ,aAAaC;AAEjC,eAAS,WAAY,GAAG,IAAI;AAC1B,cAAM,OAAO,OAAO,KAAK,CAAC;AAC1B,cAAM,KAAK,IAAI,MAAM,KAAK,MAAM;AAChC,iBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,gBAAM,IAAI,KAAK,CAAC;AAChB,gBAAM,MAAM,EAAE,CAAC;AACf,cAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,eAAG,CAAC,IAAI;AAAA,UAChB,WAAiB,IAAI,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,IAAI,WAAW,IAAI;AAC7F,eAAG,CAAC,IAAI,QAAQ,KAAK,EAAE;AAAA,UAC/B,WAAiB,YAAY,OAAO,GAAG,GAAG;AAClC,eAAG,CAAC,IAAI,WAAW,GAAG;AAAA,UAC9B,OAAa;AACL,eAAG,CAAC,IAAI,GAAG,GAAG;AAAA,UACtB;AAAA,QACA;AACI,eAAO;AAAA,MACX;AAEE,eAASA,OAAO,GAAG;AACjB,YAAI,OAAO,MAAM,YAAY,MAAM,KAAM,QAAO;AAChD,YAAI,MAAM,QAAQ,CAAC,EAAG,QAAO,WAAW,GAAGA,MAAK;AAChD,YAAI,EAAE,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,EAAE,WAAW,IAAI;AAClF,iBAAO,QAAQ,GAAGA,MAAK;AAAA,QAC7B;AACI,cAAM,KAAK,CAAA;AACX,mBAAW,KAAK,GAAG;AACjB,cAAI,OAAO,eAAe,KAAK,GAAG,CAAC,MAAM,MAAO;AAChD,gBAAM,MAAM,EAAE,CAAC;AACf,cAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,eAAG,CAAC,IAAI;AAAA,UAChB,WAAiB,IAAI,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,IAAI,WAAW,IAAI;AAC7F,eAAG,CAAC,IAAI,QAAQ,KAAKA,MAAK;AAAA,UAClC,WAAiB,YAAY,OAAO,GAAG,GAAG;AAClC,eAAG,CAAC,IAAI,WAAW,GAAG;AAAA,UAC9B,OAAa;AACL,eAAG,CAAC,IAAIA,OAAM,GAAG;AAAA,UACzB;AAAA,QACA;AACI,eAAO;AAAA,MACX;AAEE,eAAS,WAAY,GAAG;AACtB,YAAI,OAAO,MAAM,YAAY,MAAM,KAAM,QAAO;AAChD,YAAI,MAAM,QAAQ,CAAC,EAAG,QAAO,WAAW,GAAG,UAAU;AACrD,YAAI,EAAE,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,EAAE,WAAW,IAAI;AAClF,iBAAO,QAAQ,GAAG,UAAU;AAAA,QAClC;AACI,cAAM,KAAK,CAAA;AACX,mBAAW,KAAK,GAAG;AACjB,gBAAM,MAAM,EAAE,CAAC;AACf,cAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,eAAG,CAAC,IAAI;AAAA,UAChB,WAAiB,IAAI,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,IAAI,WAAW,IAAI;AAC7F,eAAG,CAAC,IAAI,QAAQ,KAAK,UAAU;AAAA,UACvC,WAAiB,YAAY,OAAO,GAAG,GAAG;AAClC,eAAG,CAAC,IAAI,WAAW,GAAG;AAAA,UAC9B,OAAa;AACL,eAAG,CAAC,IAAI,WAAW,GAAG;AAAA,UAC9B;AAAA,QACA;AACI,eAAO;AAAA,MACX;AAAA,IACA;AAEA,aAAS,YAAa,MAAM;AAC1B,YAAM,OAAO,CAAA;AACb,YAAM,UAAU,CAAA;AAEhB,YAAM,sBAAsB,oBAAI,IAAG;AACnC,0BAAoB,IAAI,MAAM,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC;AAChD,0BAAoB,IAAI,KAAK,CAAC,GAAG,OAAO,IAAI,IAAI,WAAW,MAAM,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;AAC9E,0BAAoB,IAAI,KAAK,CAAC,GAAG,OAAO,IAAI,IAAI,WAAW,MAAM,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;AAC9E,UAAI,KAAK,qBAAqB;AAC5B,mBAAWD,YAAW,KAAK,qBAAqB;AAC9C,8BAAoB,IAAIA,SAAQ,CAAC,GAAGA,SAAQ,CAAC,CAAC;AAAA,QACpD;AAAA,MACA;AAEE,UAAI,UAAU;AACd,aAAO,KAAK,QAAQ,aAAaC;AAEjC,eAAS,WAAY,GAAG,IAAI;AAC1B,cAAM,OAAO,OAAO,KAAK,CAAC;AAC1B,cAAM,KAAK,IAAI,MAAM,KAAK,MAAM;AAChC,iBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,gBAAM,IAAI,KAAK,CAAC;AAChB,gBAAM,MAAM,EAAE,CAAC;AACf,cAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,eAAG,CAAC,IAAI;AAAA,UAChB,WAAiB,IAAI,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,IAAI,WAAW,IAAI;AAC7F,eAAG,CAAC,IAAI,QAAQ,KAAK,EAAE;AAAA,UAC/B,WAAiB,YAAY,OAAO,GAAG,GAAG;AAClC,eAAG,CAAC,IAAI,WAAW,GAAG;AAAA,UAC9B,OAAa;AACL,kBAAM,QAAQ,KAAK,QAAQ,GAAG;AAC9B,gBAAI,UAAU,IAAI;AAChB,iBAAG,CAAC,IAAI,QAAQ,KAAK;AAAA,YAC/B,OAAe;AACL,iBAAG,CAAC,IAAI,GAAG,GAAG;AAAA,YACxB;AAAA,UACA;AAAA,QACA;AACI,eAAO;AAAA,MACX;AAEE,eAASA,OAAO,GAAG;AACjB,YAAI,OAAO,MAAM,YAAY,MAAM,KAAM,QAAO;AAChD,YAAI,MAAM,QAAQ,CAAC,EAAG,QAAO,WAAW,GAAGA,MAAK;AAChD,YAAI,EAAE,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,EAAE,WAAW,IAAI;AAClF,iBAAO,QAAQ,GAAGA,MAAK;AAAA,QAC7B;AACI,cAAM,KAAK,CAAA;AACX,aAAK,KAAK,CAAC;AACX,gBAAQ,KAAK,EAAE;AACf,mBAAW,KAAK,GAAG;AACjB,cAAI,OAAO,eAAe,KAAK,GAAG,CAAC,MAAM,MAAO;AAChD,gBAAM,MAAM,EAAE,CAAC;AACf,cAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,eAAG,CAAC,IAAI;AAAA,UAChB,WAAiB,IAAI,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,IAAI,WAAW,IAAI;AAC7F,eAAG,CAAC,IAAI,QAAQ,KAAKA,MAAK;AAAA,UAClC,WAAiB,YAAY,OAAO,GAAG,GAAG;AAClC,eAAG,CAAC,IAAI,WAAW,GAAG;AAAA,UAC9B,OAAa;AACL,kBAAM,IAAI,KAAK,QAAQ,GAAG;AAC1B,gBAAI,MAAM,IAAI;AACZ,iBAAG,CAAC,IAAI,QAAQ,CAAC;AAAA,YAC3B,OAAe;AACL,iBAAG,CAAC,IAAIA,OAAM,GAAG;AAAA,YAC3B;AAAA,UACA;AAAA,QACA;AACI,aAAK,IAAG;AACR,gBAAQ,IAAG;AACX,eAAO;AAAA,MACX;AAEE,eAAS,WAAY,GAAG;AACtB,YAAI,OAAO,MAAM,YAAY,MAAM,KAAM,QAAO;AAChD,YAAI,MAAM,QAAQ,CAAC,EAAG,QAAO,WAAW,GAAG,UAAU;AACrD,YAAI,EAAE,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,EAAE,WAAW,IAAI;AAClF,iBAAO,QAAQ,GAAG,UAAU;AAAA,QAClC;AACI,cAAM,KAAK,CAAA;AACX,aAAK,KAAK,CAAC;AACX,gBAAQ,KAAK,EAAE;AACf,mBAAW,KAAK,GAAG;AACjB,gBAAM,MAAM,EAAE,CAAC;AACf,cAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,eAAG,CAAC,IAAI;AAAA,UAChB,WAAiB,IAAI,gBAAgB,WAAW,UAAU,oBAAoB,IAAI,IAAI,WAAW,IAAI;AAC7F,eAAG,CAAC,IAAI,QAAQ,KAAK,UAAU;AAAA,UACvC,WAAiB,YAAY,OAAO,GAAG,GAAG;AAClC,eAAG,CAAC,IAAI,WAAW,GAAG;AAAA,UAC9B,OAAa;AACL,kBAAM,IAAI,KAAK,QAAQ,GAAG;AAC1B,gBAAI,MAAM,IAAI;AACZ,iBAAG,CAAC,IAAI,QAAQ,CAAC;AAAA,YAC3B,OAAe;AACL,iBAAG,CAAC,IAAI,WAAW,GAAG;AAAA,YAChC;AAAA,UACA;AAAA,QACA;AACI,aAAK,IAAG;AACR,gBAAQ,IAAG;AACX,eAAO;AAAA,MACX;AAAA,IACA;;;;;AChMA,QAAM,QAAQ,KAAK,EAAE,OAAO,MAAM;AAM3B,WAAS,UAAU,GAAc,GAAuB;AAC7D,WAAO,MAAM,GAAG,CAAC;AAAA,EACnB;AAKO,WAAS,aAAqB;AACnC,WAAO,OAAA;AAAA,EACT;AAKO,WAAS,SAAS,OAAiC;AACxD,WAAO,UAAU,QAAQ,OAAO,UAAU;AAAA,EAC5C;AAMO,WAAS,UAAa,OAAa;AAExC,QAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAC/C,aAAO;AAAA,IACT;AACA,WAAO,MAAM,KAAK;AAAA,EACpB;AAKO,WAAS,KAAQ,IAAsB;AAC5C,QAAI,WAAW;AACf,QAAI;AACJ,WAAO,MAAM;AACX,UAAI,CAAC,UAAU;AACb,gBAAQ,GAAA;AACR,mBAAW;AAAA,MACb;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAMO,WAAS,gBAAgB,KAA4B;AAC1D,UAAM,IAAI,OAAO,GAAG;AACpB,QAAI,CAAC,OAAO,UAAU,CAAC,KAAK,IAAI,GAAG;AACjC,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AC7CO,WAAS,OAAO,YAAwB,IAAc;AAC3D,UAAM,YAAY,WAAW,WAAW;AACxC,QAAI,CAAC,WAAW;AACd,YAAM,QAAQ,uCAAuC;AAAA,IACvD;AAGA,QAAI,WAAW,cAAc,GAAG;AAC9B,iBAAW,WAAW,IAAI,KAAK,EAAE;AACjC;AAAA,IACF;AAGA,UAAM,WAAW,oBAAoB,WAAW,UAAU;AAG1D,eAAW,QAAQ,UAAU;AAC3B,YAAM,aAAa,EAAE,GAAG,IAAI,KAAA;AAC5B,iBAAW,WAAW,IAAI,KAAK,UAAU;AAAA,IAC3C;AAAA,EACF;ACLA,WAAS,cAAc,OAAsB;AAC3C,UAAM,QAAQ,cAAc,KAAK;AACjC,QAAI,MAAO,OAAM;AAAA,EACnB;AAKA,WAAS,cAAc,OAAsB;AAC3C,UAAM,QAAQ,cAAc,KAAK;AACjC,QAAI,MAAO,OAAM;AAAA,EACnB;AASA,WAAS,eAAe,OAA2B,KAAa,cAA8B;AAC5F,QAAI,UAAU,OAAW,QAAO;AAChC,WAAO,QAAQ,IAAI,KAAK,IAAI,MAAM,OAAO,CAAC,IAAI,KAAK,IAAI,OAAO,GAAG;AAAA,EACnE;AAKA,QAAM,6CAA6B,IAAI;AAAA,IACrC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAQD,WAAS,yBACP,YACA,UACA,QACiC;AACjC,WAAO,YAA8B,MAA0B;AAC7D,wBAAkB,UAAU;AAC5B,kBAAY,UAAU;AAEtB,YAAM,MAAM,WAAW;AACvB,YAAM,iBAAiB,IAAI;AAC3B,YAAM,QAAQ;AAEd,cAAQ,QAAA;AAAA,QACN,KAAK,QAAQ;AAGX,qBAAW,OAAO,MAAM;AACtB,0BAAc,GAAG;AAAA,UACnB;AAEA,gBAAM,SAAS,IAAI,KAAK,GAAG,IAAI;AAE/B,iBAAO,YAAY;AAAA,YACjB,MAAM;AAAA,YACN,MAAM,eAAe,UAAU;AAAA,YAC/B,OAAO;AAAA,YACP,aAAa;AAAA,YACb,SAAS,KAAK,IAAIL,WAAS;AAAA,UAAA,CAC5B;AACD,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,OAAO;AACV,cAAI,mBAAmB,GAAG;AACxB,mBAAO,IAAI,IAAA;AAAA,UACb;AAEA,gBAAM,cAAc,MAAM,iBAAiB,CAAC;AAE5C,wBAAc,IAAI,iBAAiB,CAAC,CAAC;AAErC,cAAI,IAAA;AACJ,iBAAO,YAAY;AAAA,YACjB,MAAM;AAAA,YACN,MAAM,eAAe,UAAU;AAAA,YAC/B,OAAO,iBAAiB;AAAA,YACxB,aAAa;AAAA,YACb,SAAS,CAAA;AAAA,UAAC,CACX;AACD,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,SAAS;AACZ,cAAI,mBAAmB,GAAG;AACxB,mBAAO,IAAI,MAAA;AAAA,UACb;AAEA,gBAAM,cAAc,MAAM,CAAC;AAE3B,wBAAc,IAAI,CAAC,CAAC;AAEpB,cAAI,MAAA;AACJ,iBAAO,YAAY;AAAA,YACjB,MAAM;AAAA,YACN,MAAM,eAAe,UAAU;AAAA,YAC/B,OAAO;AAAA,YACP,aAAa;AAAA,YACb,SAAS,CAAA;AAAA,UAAC,CACX;AACD,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,WAAW;AAEd,qBAAW,OAAO,MAAM;AACtB,0BAAc,GAAG;AAAA,UACnB;AAEA,gBAAM,SAAS,IAAI,QAAQ,GAAG,IAAI;AAElC,iBAAO,YAAY;AAAA,YACjB,MAAM;AAAA,YACN,MAAM,eAAe,UAAU;AAAA,YAC/B,OAAO;AAAA,YACP,aAAa;AAAA,YACb,SAAS,KAAK,IAAIA,WAAS;AAAA,UAAA,CAC5B;AACD,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,UAAU;AACb,gBAAM,QAAQ,KAAK,CAAC;AACpB,gBAAM,iBAAiB,KAAK,CAAC;AAC7B,gBAAM,UAAU,KAAK,MAAM,CAAC;AAG5B,gBAAM,QACJ,UAAU,SAAY,IAAI,QAAQ,IAAI,KAAK,IAAI,iBAAiB,OAAO,CAAC,IAAI;AAC9E,gBAAM,cAAc,0CAAkB,iBAAiB;AAGvD,gBAAM,eAA0B,CAAA;AAChC,mBAAS,IAAI,GAAG,IAAI,eAAe,QAAQ,IAAI,gBAAgB,KAAK;AAClE,yBAAa,KAAK,MAAM,QAAQ,CAAC,CAAC;AAElC,0BAAc,IAAI,QAAQ,CAAC,CAAC;AAAA,UAC9B;AAGA,qBAAW,UAAU,SAAS;AAC5B,0BAAc,MAAM;AAAA,UACtB;AAEE,cAAI,OAA6C,GAAG,IAAI;AAG1D,iBAAO,YAAY;AAAA,YACjB,MAAM;AAAA,YACN,MAAM,eAAe,UAAU;AAAA,YAC/B,OAAO,wBAAS;AAAA,YAChB,aAAa,0CAAkB;AAAA,YAC/B,SAAS,QAAQ,IAAIA,WAAS;AAAA,UAAA,CAC/B;AACD,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,QAAQ;AACX,gBAAM,YAAY,KAAK,CAAC;AACxB,gBAAM,WAAW,KAAK,CAAC;AACvB,gBAAM,SAAS,KAAK,CAAC;AAErB,gBAAM,MAAM;AACZ,gBAAM,QAAQ,eAAe,UAAU,KAAK,CAAC;AAC7C,gBAAM,MAAM,eAAe,QAAQ,KAAK,GAAG;AAG3C,gBAAM,YAAY,MAAM;AACxB,cAAI,YAAY,GAAG;AACjB,kBAAM,aAAa,MAAM,SAAS,EAAE,KAAK,SAAS;AAClD,kBAAM,OAAO,OAAO,WAAW,GAAG,UAAU;AAAA,UAC9C;AAEA,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,QAAQ;AACX,gBAAM,YAAY,KAAK,CAAC;AAExB,gBAAM,SAAS,CAAC,GAAG,GAAG,EAAE,KAAK,SAAS;AACtC,cAAI,iBAAiB,GAAG;AACtB,kBAAM,OAAO,GAAG,gBAAgB,GAAG,MAAM;AAAA,UAC3C;AACA,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,WAAW;AAEd,gBAAM,WAAW,CAAC,GAAG,GAAG,EAAE,QAAA;AAC1B,cAAI,iBAAiB,GAAG;AACtB,kBAAM,OAAO,GAAG,gBAAgB,GAAG,QAAQ;AAAA,UAC7C;AACA,iBAAO;AAAA,QACT;AAAA,QAEA,KAAK,cAAc;AACjB,gBAAM,YAAY,KAAK,CAAC;AACxB,gBAAM,WAAW,KAAK,CAAC;AACvB,gBAAM,SAAS,KAAK,CAAC;AAErB,gBAAM,MAAM;AACZ,gBAAM,YAAY,eAAe,WAAW,KAAK,CAAC;AAClD,gBAAM,WAAW,eAAe,UAAU,KAAK,CAAC;AAChD,gBAAM,SAAS,eAAe,QAAQ,KAAK,GAAG;AAG9C,gBAAM,YAAY,KAAK,IAAI,SAAS,UAAU,MAAM,SAAS;AAE7D,cAAI,YAAY,GAAG;AAEjB,kBAAM,iBAAiB,IAAI,MAAM,UAAU,WAAW,SAAS;AAE/D,kBAAM,OAAO,WAAW,WAAW,GAAG,cAAc;AAAA,UACtD;AAEA,iBAAO;AAAA,QACT;AAAA,QAEA;AACE,iBAAQ,IAAmE,MAAM,EAAE,GAAG,IAAI;AAAA,MAAA;AAAA,IAEhG;AAAA,EACF;AAKA,QAAM,eAAyC;AAAA,IAC7C,IAAI,QAAoB,KAAkB,UAAmB;;AAE3D,YAAM,QAAO,YAAO,SAAP,mBAAc;AAC3B,UAAI,QAAQ,OAAO,WAAW,YAAY,IAAI,IAAc,GAAG;AAC7D,eAAO;AAAA,MACT;AAGA,UAAI,QAAQ,YAAa,QAAO;AAEhC,YAAM,SAAS,OAAO,MAAM;AAG5B,UACE,OAAO,SAAS,UAAU,SAC1B,OAAO,QAAQ,YACf,uBAAuB,IAAI,GAAG,GAC9B;AACA,cAAM,iBAAkB,OAAqB,GAAsB;AACnE,YAAI,OAAO,mBAAmB,YAAY;AACxC,iBAAO,yBAAyB,QAAQ,UAAU,GAAG;AAAA,QACvD;AAAA,MACF;AAGA,UAAI,CAAC,IAAI,QAAQ,GAAG,GAAG;AACrB,cAAM,OAAO,cAAc,QAAQ,GAAG;AACtC,eAAO,OAAQ,WAAW,OAAO,KAAK,SAAQ,UAAK,QAAL,mBAAU,KAAK,OAAO,SAAU;AAAA,MAChF;AAEA,YAAM,QAAS,OAAwC,GAAG;AAG1D,UAAI,OAAO,aAAa,CAAC,YAAY,KAAK,GAAG;AAC3C,eAAO;AAAA,MACT;AAGA,UAAI,UAAU,KAAK,OAAO,UAAU,GAAG,GAAG;AACxC,0BAAkB,MAAM;AACxB,cAAM,YAAY,OAAO,SAAS,UAAU,QAAQ,OAAO,GAAG,IAAI;AAChE,eAAO,KAAsC,GAAG,IAAIM,cAAY;AAAA,UAChE,UAAW,OAAO,SAA0C,GAAG;AAAA,UAC/D,aAAa;AAAA,UACb,KAAK;AAAA,UACL,YAAY,OAAO;AAAA,QAAA,CACpB;AACD,eAAQ,OAAO,KAAsC,GAAG;AAAA,MAC1D;AAGA,UAAI,QAAQ,KAAK,GAAG;AAClB,eAAO,WAAW,YAAY,IAAI,KAAe;AAAA,MACnD;AAEA,aAAO;AAAA,IACT;AAAA,IAEA,IAAI,QAAoB,KAAkB,OAAgB;;AACxD,UAAI,OAAO,QAAQ,UAAU;AAC3B,cAAM,IAAI,MAAM,wCAAwC;AAAA,MAC1D;AAGA,UAAI,QAAyB;AAC7B,UAAI,OAAO,SAAS,UAAU,OAAO;AACnC,YAAI,QAAQ,UAAU;AACpB,kBAAQ;AAAA,QACV,OAAO;AACL,gBAAM,SAAS,OAAO,QAAQ,WAAW,MAAM,gBAAgB,GAAa;AAC5E,cAAI,WAAW,MAAM;AACnB,kBAAM,IAAI,MAAM,gEAAgE;AAAA,UAClF;AACA,kBAAQ;AAGR,gBAAM,SAAS,OAAO,MAAM;AAC5B,cAAI,SAAS,OAAO,QAAQ;AAC1B,kBAAM,IAAI;AAAA,cACR,qCAAqC,MAAM,yCAAyC,OAAO,MAAM;AAAA,YAAA;AAAA,UAErG;AAAA,QACF;AAAA,MACF;AAGA,YAAM,OAAO,cAAc,OAAO,MAAM,GAAG,GAAG;AAC9C,UAAI,6BAAM,KAAK;AACb,aAAK,IAAI,KAAK,OAAO,OAAO,KAAK;AACjC,eAAO;AAAA,MACT;AAEA,YAAMR,WAAU,KAAK,OAAO,MAAM,GAAG,GAAG;AACxC,YAAM,oBAAoB,cAAcA,QAAO;AAG/C,UAAI,qBAAqB,QAAQ,kBAAkB,UAAU,KAAK,GAAG;AACjE,eAAO,KAAsC,GAAG,IAAI;AACtD,eAAO,eAAc,YAAO,gBAAP,YAAsB,oBAAI,IAAA;AAC/C,eAAO,YAAY,IAAI,KAAK,KAAK;AACjC,eAAO;AAAA,MACT;AAGA,UAAI,QAAQ,OAAOA,QAAO,MAAM,UAAU,UAAa,IAAI,OAAO,UAAU,GAAG,IAAI;AACjF,eAAO;AAAA,MACT;AAEA,wBAAkB,MAAM;AACxB,kBAAY,MAAM;AAGlB,UACE,IAAI,OAAO,UAAU,GAAG,KACxB,QAAQ,OAAQ,OAAO,SAA0C,GAAG,CAAC,GACrE;AAEA,eAAO,YAAa,OAAO,GAAG;AAAA,MAChC,OAAO;AACL,eAAO,YAAa,IAAI,KAAK,IAAI;AAAA,MACnC;AAGA,YAAM,OAAO,OAAO;AACpB,oBAAc,KAAK,GAAG,CAAC;AACvB,oBAAc,KAAK;AACnB,WAAK,GAAG,IAAI;AAGZ,UAAI,OAAO,SAAS,UAAU,SAAS,UAAU,UAAU;AACzD,cAAM,YAAa,OAAO,SAAuB;AACjD,cAAM,YAAY;AAClB,YAAI,cAAc,WAAW;AAE3B,iBAAO,QAAQ;AAAA,YACb,MAAM;AAAA,YACN,MAAM,eAAe,MAAM;AAAA,YAC3B,KAAK;AAAA,YACL,OAAO;AAAA,UAAA,CACR;AAAA,QACH;AAAA,MACF,OAAO;AAEL,eAAO,QAAQ;AAAA,UACb,MAAM;AAAA,UACN,MAAM,eAAe,MAAM;AAAA,UAC3B,KAAK;AAAA,UACL,OAAOE,YAAU,KAAK;AAAA,QAAA,CACvB;AAAA,MACH;AAEA,aAAO;AAAA,IACT;AAAA,IAEA,IAAI,QAAoB,KAAkB;AACxC,aAAO,OAAO,OAAO,MAAM;AAAA,IAC7B;AAAA,IAEA,QAAQ,QAAoB;AAC1B,aAAO,QAAQ,QAAQ,OAAO,MAAM,CAAC;AAAA,IACvC;AAAA,IAEA,yBAAyB,QAAoB,KAAkB;AAC7D,YAAM,SAAS,OAAO,MAAM;AAC5B,YAAM,aAAa,QAAQ,yBAAyB,QAAQ,GAAG;AAC/D,UAAI,CAAC,WAAY,QAAO;AACxB,aAAO;AAAA,QACL,UAAU;AAAA,QACV,cAAc,OAAO,SAAS,UAAU,SAAS,QAAQ;AAAA,QACzD,YAAY,WAAW;AAAA,QACvB,OAAQ,OAAwC,GAAG;AAAA,MAAA;AAAA,IAEvD;AAAA,IAEA,eAAe,QAAoB;AACjC,aAAO,QAAQ,eAAe,OAAO,QAAkB;AAAA,IACzD;AAAA,IAEA,iBAAiB;AACf,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC5D;AAAA,IAEA,iBAAiB;AACf,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC5D;AAAA,IAEA,eAAe,QAAoB,KAAkB;;AACnD,UAAI,OAAO,QAAQ,UAAU;AAC3B,cAAM,IAAI,MAAM,6CAA6C;AAAA,MAC/D;AAEA,UAAI,OAAO,SAAS,UAAU,OAAO;AAEnC,eAAO,aAAa,IAAK,KAAK,MAAM,QAAQ,KAAwB,QAAW,OAAO,KAAK;AAAA,MAC7F;AAGA,YAAMF,WAAU,KAAK,OAAO,MAAM,GAAG,GAAG;AACxC,YAAM,UAAUA,aAAY,UAAa,OAAQ,OAAO;AAGxD,UAAI,SAAS;AACX,0BAAkB,MAAM;AACxB,oBAAY,MAAM;AAClB,eAAO,YAAa,IAAI,KAAK,KAAK;AAGlC,eAAO,QAAQ;AAAA,UACb,MAAM;AAAA,UACN,MAAM,eAAe,MAAM;AAAA,UAC3B;AAAA,QAAA,CACD;AAGD,cAAM,OAAO,OAAO;AACpB,sBAAc,KAAK,GAAG,CAAC;AACvB,eAAO,KAAK,GAAG;AAAA,MACjB,OAAO;AACL,eAAO,eAAc,YAAO,gBAAP,YAAsB,oBAAI,IAAA;AAC/C,eAAO,YAAY,OAAO,GAAG;AAAA,MAC/B;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAKO,WAASQ,cAA8B,SAKxC;AACJ,UAAM,EAAE,UAAAP,WAAU,aAAa,KAAK,eAAe;AACnD,UAAM,OAAO,QAAQA,SAAQ;AAE7B,UAAM,aAA4B;AAAA,MAChC;AAAA,MACA,WAAW;AAAA,MACX,QAAQ,oCAAe;AAAA,MACvB,UAAAA;AAAA,MACA,MAAM;AAAA,MACN,OAAO;AAAA,MACP;AAAA,MACA,YAAY;AAAA,IAAA;AAId,QAAI,QAAQ,UAAa,SAAS,SAAS;AACzC,iBAAW,MAAM;AAAA,IACnB;AAGA,UAAM,EAAE,OAAO,OAAA,IAAW,MAAM;AAAA,MAC7B,SAAS,UAAU,QAAQ,OAAO,OAAO,CAAA,GAAI,UAAU,IAAI;AAAA,MAC5D;AAAA,IAAA;AAGF,eAAW,OAAO,KAAK,MAAM;AAC7B,eAAW,QAAQ;AAGnB,QAAI,aAAa;AACf,kBAAY,WAAW,MAAM,KAAK,MAAM;AACtC,cAAM,OAAO,YAAY;AACzB,YAAI,CAAC,KAAM;AAEX,cAAM,QAAQ,IAAI,MAAgB,GAAI;AACtC,cAAM,kBAAkB,cAAc,KAAK;AAE3C,YAAI,iBAAiB;AAEnB,cAAI,eAAe,gBAAgB;AACnC,cAAI,gBAAgB,UAAU;AAC5B,2BAAe,SAAS,KAAe;AAAA,UACzC;AACA,0BAAgB,YAAY;AAC5B,cAAI,MAAgB,KAAM,YAAY;AAAA,QACxC;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AAKO,WAAS,cAAiB,QAAW,eAAoC;;AAC9E,UAAM,aAAa,cAAiB,MAAM;AAC1C,UAAM,mBAAmB,cAAc,SAAS;AAGhD,QAAI,yCAAY,UAAU;AACxB,aAAO,WAAW,WAAW,MAAM,SAAS,GAAG;AAC7C,cAAM,WAAW,WAAW,WAAW,MAAM,IAAA;AAC7C,iBAAA;AAAA,MACF;AACA,iBAAW,YAAY;AAAA,IACzB;AAGA,UAAM,QAAQ,mBACV,cAAc,CAAC,IACf,aACE,WAAW,WACR,WAAW,OACZ,WAAW,WACb;AAGN,QAAI,cAAc,SAAS,OAAO,UAAU,UAAU;AACpD,kBAAY,OAAO,WAAW,WAAW,UAAU;AAAA,IACrD;AAGA,UAAM,OAAM,8CAAY,WAAW,QAAvB,YAA8B,CAAA;AAG1C,QAAI,YAAY;AACd,kBAAY,UAAU;AAAA,IACxB;AAEA,WAAO,CAAC,OAAY,GAAG;AAAA,EACzB;ACjlBO,WAAS,SACd,WAC6C;AAC7C,UAAM,aAAyB;AAAA,MAC7B,OAAO,CAAA;AAAA,MACP,QAAQ,CAAA;AAAA,MACR,gCAAgB,QAAA;AAAA,MAChB,iCAAiB,QAAA;AAAA,MACjB,KAAK,CAAA;AAAA,MACL,WAAW;AAAA;AAAA,IAAA;AAIb,QAAI,CAAC,YAAY,SAAS,GAAG;AAC3B,YAAM,IAAI,MAAM,qDAAqD;AAAA,IACvE;AAEA,UAAM,QAAQO,cAAY;AAAA,MACxB,UAAU;AAAA,MACV,aAAa;AAAA,MACb;AAAA,IAAA,CACD;AAGD,eAAW,YAAY,cAAc,KAAK;AAE1C,WAAO;AAAA,MACL;AAAA,MACA,CAAC,gBAA0B,CAAA,MAAO;AAChC,eAAO,cAAc,OAAO,aAAa;AAAA,MAC3C;AAAA,IAAA;AAAA,EAEJ;ACTO,WAAS,UACd,MACA,QACoB;AAEpB,UAAM,QAAQ,QAAQ,IAAI,IAAI,QAAQ,IAAgB,IAAI;AAG1D,QAAI,CAAC,YAAY,KAAK,GAAG;AACvB,YAAM,IAAI,MAAM,qDAAqD;AAAA,IACvE;AAGA,UAAM,CAAC,OAAO,QAAQ,IAAI,SAAS,KAAK;AAGxC,QAAI;AACJ,QAAI;AACF,eAAS,OAAO,KAAiB;AAAA,IACnC,SAAS,OAAO;AACd,kBAAY,cAAc,KAAK,CAAC;AAChC,YAAM;AAAA,IACR;AAGA,UAAM,aAAa,cAAc,KAAK;AAGtC,QAAI,WAAW,UAAa,CAAC,QAAQ,MAAM,GAAG;AAC5C,UAAI,CAAC,QAAQ,QAAQ,KAAK,KAAK,WAAW,UAAU;AAClD,cAAM,IAAI;AAAA,UACR;AAAA,QAAA;AAAA,MAEJ;AAIA,UAAI,WAAW,QAAW;AACxB,cAAM,GAAGC,IAAG,IAAI,SAAS,EAAE;AAC3B,eAAO,EAAE,WAAW,QAAa,KAAAA,KAAAA;AAAAA,MACnC;AAAA,IACF;AAGA,QAAI,WAAW,SAAS,WAAW,QAAW;AAC5C,YAAM,CAACC,YAAWD,IAAG,IAAI,SAAS,CAAA,CAAE;AACpC,aAAO,EAAE,WAAAC,YAAW,KAAAD,KAAAA;AAAAA,IACtB;AAGA,UAAM,qBAAqB,cAAc,MAAM;AAC/C,QAAI,oBAAoB;AACtB,UAAI,mBAAmB,UAAU;AAC/B,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AACA,YAAM,GAAGA,IAAG,IAAI,SAAS,EAAE;AAC3B,aAAO,EAAE,WAAW,QAAQ,MAAgB,GAAQ,KAAAA,KAAAA;AAAAA,IACtD;AAEA,UAAM,CAAC,WAAW,GAAG,IAAI,SAAS,CAAA,CAAE;AACpC,WAAO,EAAE,WAAW,IAAA;AAAA,EACtB;AC/EO,WAAS,SAAY,QAAc;AACxC,UAAM,aAAa,cAAc,MAAM;AACvC,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,mDAAmD,MAAM,EAAE;AAAA,IAC7E;AACA,WAAO,WAAW;AAAA,EACpB;ACFO,WAAS,SAA8B,OAAY,OAAgB;AACxE,UAAM,aAAa,cAAc,KAAK;AACtC,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,6CAA6C;AAAA,IAC/D;AAGA,sBAAkB,UAAU;AAC5B,gBAAY,UAAU;AAGtB,UAAM,MAAM,WAAW;AACvB,QAAI,IAAI,KAAK,CAAC,SAAS,SAAS,SAAS,UAAU,MAAM,KAAK,CAAC,GAAG;AAEhE;AAAA,IACF;AAGA,QAAI,KAAK,KAAK;AAGd,WAAO,YAAY;AAAA,MACjB,MAAM;AAAA,MACN,MAAM,eAAe,UAAU;AAAA,MAC/B,OAAO,UAAU,KAAK;AAAA,IAAA,CACvB;AAAA,EACH;AAaO,WAAS,cAAmC,OAAY,OAAgB;AAC7E,UAAM,aAAa,cAAc,KAAK;AACtC,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,kDAAkD;AAAA,IACpE;AAGA,sBAAkB,UAAU;AAC5B,gBAAY,UAAU;AAGtB,UAAM,MAAM,WAAW;AACvB,UAAM,WAAW,IAAI,KAAK,CAAC,SAAS,SAAS,SAAS,UAAU,MAAM,KAAK,CAAC;AAE5E,QAAI,CAAC,UAAU;AAEb;AAAA,IACF;AAGA,aAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,UAAI,IAAI,CAAC,MAAM,SAAS,UAAU,IAAI,CAAC,GAAG,KAAK,GAAG;AAChD,YAAI,OAAO,GAAG,CAAC;AAAA,MACjB;AAAA,IACF;AAGA,WAAO,YAAY;AAAA,MACjB,MAAM;AAAA,MACN,MAAM,eAAe,UAAU;AAAA,MAC/B,OAAO,UAAU,KAAK;AAAA,IAAA,CACvB;AAAA,EACH;AChFO,WAAS,+BAA+B,aAG7C;AACA,QAAI,WAAW;AACf,QAAI,OAAgC;AACpC,QAAI,cAAc;AAClB,QAAI,eAAe;AAEnB,eAAW,CAAC,KAAK,EAAE,KAAK,YAAY,WAAW;AAC7C,YAAM,EAAE,OAAO,aAAa,mBAAmB,GAAG;AAElD,UAAI,QAAQ,UAAU;AAEpB,mBAAW;AACX,eAAO;AACP,sBAAc,GAAG;AACjB,uBAAe;AAAA,MACjB,WAAW,UAAU,UAAU;AAI7B,YAAI,GAAG,UAAU,eAAgB,GAAG,YAAY,eAAe,WAAW,cAAe;AACvF,iBAAO;AACP,wBAAc,GAAG;AACjB,yBAAe;AAAA,QACjB;AAAA,MACF;AAAA,IACF;AAEA,WAAO,EAAE,gBAAgB,UAAU,YAAY,KAAA;AAAA,EACjD;ACSA,WAAS,uBAAuB,MAAwC;AACtE,WAAO,GAAG,KAAK,KAAK,IAAI,KAAK,OAAO,IAAI,KAAK,QAAQ;AAAA,EACvD;AAOO,WAAS,mBAAmB,KAAuC;AACxE,UAAM,KAAK,IAAI,QAAQ,GAAG;AAC1B,UAAM,KAAK,IAAI,QAAQ,KAAK,KAAK,CAAC;AAElC,QAAI,OAAO,MAAM,OAAO,IAAI;AAC1B,cAAQ,6BAA6B,GAAG,EAAE;AAAA,IAC5C;AAEA,WAAO;AAAA,MACL,OAAO,OAAO,SAAS,IAAI,UAAU,GAAG,EAAE,GAAG,EAAE;AAAA,MAC/C,SAAS,OAAO,SAAS,IAAI,UAAU,KAAK,GAAG,EAAE,GAAG,EAAE;AAAA,MACtD,UAAU,IAAI,UAAU,KAAK,CAAC;AAAA,IAAA;AAAA,EAElC;AAKO,WAAS,iBACd,KACA,aACA,aACA,aACA,cACA,YACM;AAEN,UAAM,EAAE,YAAY,WAAW,+BAA+B,WAAW;AACzE,UAAM,gBAAgB,SAAS,EAAE,GAAG,OAAO,WAAA,IAAe,CAAA;AAY1D,UAAM,YAAY,YAAY,gBAAgB,aAAA;AAG9C,QAAI,WAAW,UAAU;AACzB,WAAO,WAAW,KAAK,UAAU,WAAW,CAAC,EAAE,YAAY,QAAQ,aAAa;AAC9E;AAAA,IACF;AAGA,UAAM,YAAY,UAAU,MAAM,GAAG,QAAQ;AAE7C,QAAI,UAAU,WAAW,GAAG;AAC1B;AAAA,IACF;AAOA,QAAI,eAAe,OAAO;AAC1B,QAAI,UAAU;AACd,eAAW,SAAS,WAAW;AAC7B,YAAM,KAAK,MAAM;AAGjB,UAAI,GAAG,YAAY,cAAc;AAC/B,uBAAe,GAAG;AAAA,MACpB;AAEA,YAAM,QAAQ,cAAc,GAAG,QAAQ,IACnC,EAAE,GAAG,cAAc,GAAG,QAAQ,MAC9B,EAAE,UAAU,IAAI,cAAc,EAAA;AAElC,UAAI,GAAG,QAAQ,MAAM,UAAU;AAC7B,cAAM,WAAW,GAAG;AACpB,cAAM,eAAe,GAAG;AAAA,MAC1B;AACA,oBAAc,GAAG,QAAQ,IAAI;AAC7B;AAAA,IACF;AAIA,eAAW,YAAY,eAAe;AACpC,UAAI,eAAe,cAAc,QAAQ,EAAE,eAAe,YAAY,mBAAmB;AACvF,eAAO,cAAc,QAAQ;AAAA,MAC/B;AAAA,IACF;AAGA,UAAM,QAAQ,uBAAuB;AAAA,MACnC,OAAO;AAAA,MACP;AAAA,MACA,UAAU;AAAA,IAAA,CACX;AACD,gBAAY,IAAI,OAAO;AAAA,MACrB,OAAO;AAAA;AAAA,MACP,YAAY;AAAA,MACZ;AAAA,MACA;AAAA,IAAA,CACD;AAKD,UAAM,eAAiC,CAAA;AACvC,eAAW,SAAS,WAAW;AAC7B,UAAI,OAAO,MAAM,cAAc;AAC/B,mBAAa,KAAK,MAAM,cAAc;AAAA,IACxC;AACA,gBAAY,gBAAgB,UAAU,YAAY;AAAA,EACpD;AAYO,WAAS,iBACd,aACA,gBACM;AAEN,QAAI,eAAqC;AACzC,QAAI,cAAc;AAElB,eAAW,CAAC,GAAG,KAAK,YAAY,WAAW;AACzC,YAAM,EAAE,OAAO,YAAY,mBAAmB,GAAG;AACjD,UAAI,UAAU,kBAAkB,UAAU,aAAa;AACrD,uBAAe;AACf,sBAAc;AAAA,MAChB;AAAA,IACF;AAGA,eAAW,OAAO,YAAY,QAAQ;AACpC,UAAI,QAAQ,cAAc;AACxB,oBAAY,OAAO,GAAG;AAAA,MACxB;AAAA,IACF;AAAA,EACF;ACjLO,WAAS,YAAkC,MAA0B;AAC1E,WAAO;AAAA,MACL,MAAM;AAAA,MACN;AAAA,MACA,kCAAkB,IAAA;AAAA,MAClB,aAAa;AAAA,IAAA;AAAA,EAEjB;AASA,WAAS,aAA+B,KAAW;AACjD,QAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,aAAO,IAAI,MAAA;AAAA,IACb;AACA,UAAMF,SAAQ,CAAA;AACd,UAAM,OAAO,OAAO,KAAK,GAAG;AAC5B,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAChB,MAAAA,OAAc,GAAG,IAAK,IAAY,GAAG;AAAA,IACzC;AACA,WAAOA;AAAA,EACT;AAMA,WAAS,YACP,KACA,QACA,KACA,OAC0B;AAC1B,QAAI,IAAI,aAAa,IAAI,KAAK,GAAG;AAC/B,aAAO;AAAA,IACT;AACA,UAAM,SAAS,aAAa,KAAK;AAC/B,WAAe,GAAG,IAAI;AACxB,QAAI,aAAa,IAAI,MAAM;AAC3B,WAAO;AAAA,EACT;AAOA,WAAS,gBACP,KACA,MAC0B;AAE1B,QAAI,CAAC,IAAI,aAAa;AACpB,UAAI,OAAO,aAAa,IAAI,IAAyB;AACrD,UAAI,aAAa,IAAI,IAAI,IAAI;AAC7B,UAAI,cAAc;AAAA,IACpB;AAEA,QAAI,KAAK,WAAW,GAAG;AACrB,aAAO,IAAI;AAAA,IACb;AAEA,QAAIP,WAAoC,IAAI;AAE5C,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,UAAU,KAAK,CAAC;AACtB,YAAM,eAAe,OAAO,YAAY;AAGxC,UAAI,cAAc;AAChB,YAAI,CAAC,MAAM,QAAQA,QAAO,GAAG;AAC3B,kBAAQ,kCAAkC,OAAO,EAAE;AAAA,QACrD;AACA,YAAI,UAAU,KAAK,WAAWA,SAAQ,QAAQ;AAC5C,kBAAQ,SAAS,OAAO,gBAAgB;AAAA,QAC1C;AAAA,MACF,OAAO;AACL,YAAI,CAAC,SAASA,QAAO,KAAK,MAAM,QAAQA,QAAO,GAAG;AAChD,kBAAQ,oCAAoC,OAAO,GAAG;AAAA,QACxD;AACA,YAAI,EAAE,WAAWA,WAAU;AACzB,kBAAQ,aAAa,OAAO,kBAAkB;AAAA,QAChD;AAAA,MACF;AAEA,YAAM,QAAoBA,SAAgB,OAAO;AAGjD,UAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAC/C,gBAAQ,qDAAqD,OAAO,EAAE;AAAA,MACxE;AAGA,MAAAA,WAAU,YAAY,KAAKA,UAAS,SAAS,KAAiC;AAAA,IAChF;AAEA,WAAOA;AAAA,EACT;AAKO,WAAS,SACd,KACA,MACA,KACA,OACM;AACN,UAAM,YAAY,gBAAgB,KAAK,IAAI;AAC3C,QAAI,CAAC,SAAS,SAAS,GAAG;AACxB,cAAQ,wCAAwC;AAAA,IAClD;AACA,QAAI,WAA4B;AAEhC,QAAI,MAAM,QAAQ,SAAS,KAAK,OAAO,QAAQ,YAAY,QAAQ,UAAU;AAC3E,YAAM,SAAS,gBAAgB,GAAG;AAClC,UAAI,WAAW,MAAM;AACnB,gBAAQ,oCAAoC,GAAG,YAAY;AAAA,MAC7D;AACA,iBAAW;AAAA,IACb;AACE,cAAiD,QAAQ,IAAI;AAAA,EACjE;AAKO,WAAS,YACd,KACA,MACA,KACM;AACN,UAAM,YAAY,gBAAgB,KAAK,IAAI;AAC3C,QAAI,CAAC,SAAS,SAAS,GAAG;AACxB,cAAQ,2CAA2C;AAAA,IACrD;AACA,QAAI,WAA4B;AAEhC,QAAI,MAAM,QAAQ,SAAS,KAAK,OAAO,QAAQ,UAAU;AACvD,YAAM,SAAS,gBAAgB,GAAG;AAClC,UAAI,WAAW,MAAM;AACnB,gBAAQ,uCAAuC,GAAG,cAAc;AAAA,MAClE;AACA,iBAAW;AAAA,IACb;AACA,WAAQ,UAAiD,QAAQ;AAAA,EACnE;AAKO,WAAS,YACd,KACA,MACA,OACA,aACA,SACM;AACN,UAAM,YAAY,gBAAgB,KAAK,IAAI;AAC3C,QAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC7B,cAAQ,iCAAiC;AAAA,IAC3C;AACA,UAAM,YAAY,KAAK,IAAI,OAAO,UAAU,MAAM;AAClD,QAAI,QAAQ,WAAW,GAAG;AACxB,gBAAU,OAAO,WAAW,WAAW;AAAA,IACzC,WAAW,QAAQ,WAAW,GAAG;AAC/B,gBAAU,OAAO,WAAW,aAAa,QAAQ,CAAC,CAAC;AAAA,IACrD,OAAO;AACL,gBAAU,OAAO,WAAW,aAAa,GAAG,OAAO;AAAA,IACrD;AAAA,EACF;AAKO,WAAS,cACd,KACA,MACA,OACM;AACN,UAAM,YAAY,gBAAgB,KAAK,IAAI;AAC3C,QAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC7B,cAAQ,mCAAmC;AAAA,IAC7C;AACA,QAAI,CAAC,UAAU,KAAK,CAAC,SAAS,UAAU,MAAM,KAAK,CAAC,GAAG;AACrD,gBAAU,KAAK,KAAK;AAAA,IACtB;AAAA,EACF;AAKO,WAAS,mBACd,KACA,MACA,OACM;AACN,UAAM,YAAY,gBAAgB,KAAK,IAAI;AAC3C,QAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC7B,cAAQ,wCAAwC;AAAA,IAClD;AAEA,aAAS,IAAI,UAAU,SAAS,GAAG,KAAK,GAAG,KAAK;AAC9C,UAAI,UAAU,UAAU,CAAC,GAAG,KAAK,GAAG;AAClC,kBAAU,OAAO,GAAG,CAAC;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AAKO,WAAS,eAAqC,KAAsB,IAAc;AACvF,YAAQ,GAAG,MAAA;AAAA,MACT,KAAK;AACH,iBAAS,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK;AACvC;AAAA,MACF,KAAK;AACH,oBAAY,KAAK,GAAG,MAAM,GAAG,GAAG;AAChC;AAAA,MACF,KAAK;AACH,oBAAY,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,OAAO;AAC9D;AAAA,MACF,KAAK;AACH,sBAAc,KAAK,GAAG,MAAM,GAAG,KAAK;AACpC;AAAA,MACF,KAAK;AACH,2BAAmB,KAAK,GAAG,MAAM,GAAG,KAAK;AACzC;AAAA,MACF;AACE,cAAM,QAAQ,2BAA4B,GAAW,IAAI,EAAE;AAAA,IAAA;AAAA,EAEjE;AAeO,WAAS,iBACd,MACA,IACA,YACG;AACH,QAAI,GAAG,IAAI,WAAW,EAAG,QAAO;AAEhC,UAAM,MAAM,YAAY,IAAI;AAE5B,QAAI;AACF,iBAAW,MAAM,GAAG,KAAK;AACvB,uBAAe,KAAK,EAAE;AAAA,MACxB;AAEA,UAAI,cAAc,CAAC,WAAW,IAAI,IAAI,GAAG;AACvC,eAAO;AAAA,MACT;AAEA,aAAO,IAAI;AAAA,IACb,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;ACzSO,WAAS,oBAAoB,cAAyB,aAA8B;AACzF,UAAM,MAAY,CAAA;AAClB,cAAU,cAAc,aAAa,CAAA,GAAI,GAAG;AAC5C,WAAO;AAAA,EACT;AAEA,WAAS,UAAUA,UAAoB,QAAmB,MAAY,KAAiB;AAErF,QAAIA,aAAY,OAAQ;AAGxB,UAAM,cAAc,OAAOA;AAC3B,UAAM,aAAa,OAAO;AAE1B,QAAIA,aAAY,QAAQ,WAAW,QAAQ,gBAAgB,YAAY,eAAe,UAAU;AAE9F,kBAAY,MAAM,QAAQ,GAAG;AAC7B;AAAA,IACF;AAGA,UAAM,iBAAiB,MAAM,QAAQA,QAAO;AAC5C,UAAM,gBAAgB,MAAM,QAAQ,MAAM;AAE1C,QAAI,mBAAmB,eAAe;AAEpC,kBAAY,MAAM,QAAQ,GAAG;AAC7B;AAAA,IACF;AAEA,QAAI,gBAAgB;AAClB,gBAAUA,UAAS,QAAuB,MAAM,GAAG;AAAA,IACrD,OAAO;AACL,iBAAWA,UAAuB,QAAsB,MAAM,GAAG;AAAA,IACnE;AAAA,EACF;AAEA,WAAS,WAAWA,UAAqB,QAAoB,MAAY,KAAiB;AAExF,eAAW,OAAOA,UAAS;AACzB,UAAI,OAAO,OAAOA,UAAS,GAAG,KAAK,CAAC,OAAO,OAAO,QAAQ,GAAG,GAAG;AAC9D,YAAI,KAAK,EAAE,MAAM,UAAU,MAAM,KAAK;AAAA,MACxC;AAAA,IACF;AAGA,eAAW,OAAO,QAAQ;AACxB,UAAI,OAAO,OAAO,QAAQ,GAAG,GAAG;AAC9B,cAAM,YAAY,OAAO,GAAG;AAC5B,YAAI,CAAC,OAAO,OAAOA,UAAS,GAAG,GAAG;AAChC,cAAI,KAAK,EAAE,MAAM,OAAO,MAAM,KAAK,OAAO,WAAW;AAAA,QACvD,WAAWA,SAAQ,GAAG,MAAM,WAAW;AAErC,oBAAUA,SAAQ,GAAG,GAAG,WAAW,CAAC,GAAG,MAAM,GAAG,GAAG,GAAG;AAAA,QACxD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,WAAS,UAAUA,UAAsB,QAAqB,MAAY,KAAiB;AACzF,UAAM,aAAaA,SAAQ;AAC3B,UAAM,YAAY,OAAO;AACzB,UAAM,SAAS,aAAa,YAAY,aAAa;AAGrD,aAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,UAAIA,SAAQ,CAAC,MAAM,OAAO,CAAC,GAAG;AAC5B,kBAAUA,SAAQ,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,GAAG;AAAA,MACpD;AAAA,IACF;AAGA,QAAI,YAAY,YAAY;AAC1B,UAAI,KAAK;AAAA,QACP,MAAM;AAAA,QACN;AAAA,QACA,OAAO;AAAA,QACP,aAAa;AAAA,QACb,SAAS,OAAO,MAAM,UAAU;AAAA,MAAA,CACjC;AAAA,IACH,WAAW,aAAa,WAAW;AACjC,UAAI,KAAK;AAAA,QACP,MAAM;AAAA,QACN;AAAA,QACA,OAAO;AAAA,QACP,aAAa,aAAa;AAAA,QAC1B,SAAS,CAAA;AAAA,MAAC,CACX;AAAA,IACH;AAAA,EACF;AAEA,WAAS,YAAY,MAAY,OAAkB,KAAiB;AAClE,QAAI,KAAK,WAAW,GAAG;AAIrB,cAAQ,2DAA2D;AAAA,IACrE;AAEA,UAAM,aAAa,KAAK,MAAM,GAAG,EAAE;AACnC,UAAM,aAAa,KAAK,KAAK,SAAS,CAAC;AAEvC,QAAI,OAAO,eAAe,UAAU;AAElC,UAAI,KAAK,EAAE,MAAM,OAAO,MAAM,YAAY,KAAK,YAAY,OAAO;AAAA,IACpE,OAAO;AAEL,UAAI,KAAK;AAAA,QACP,MAAM;AAAA,QACN,MAAM;AAAA,QACN,OAAO;AAAA,QACP,aAAa;AAAA,QACb,SAAS,CAAC,KAAK;AAAA,MAAA,CAChB;AAAA,IACH;AAAA,EACF;ACvGO,WAAS,iBAAiB,IAAiC;AAChE,WAAO,GAAG,GAAG,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,QAAQ,IAAI,GAAG,SAAS;AAAA,EAC/D;AAMO,WAAS,oBAAoB,KAAkC;AACpE,UAAM,KAAK,IAAI,QAAQ,GAAG;AAC1B,UAAM,KAAK,IAAI,QAAQ,KAAK,KAAK,CAAC;AAClC,UAAM,KAAK,IAAI,QAAQ,KAAK,KAAK,CAAC;AAElC,QAAI,OAAO,MAAM,OAAO,MAAM,OAAO,IAAI;AACvC,cAAQ,4BAA4B,GAAG,EAAE;AAAA,IAC3C;AAEA,WAAO;AAAA,MACL,OAAO,OAAO,SAAS,IAAI,UAAU,GAAG,EAAE,GAAG,EAAE;AAAA,MAC/C,OAAO,OAAO,SAAS,IAAI,UAAU,KAAK,GAAG,EAAE,GAAG,EAAE;AAAA,MACpD,UAAU,IAAI,UAAU,KAAK,GAAG,EAAE;AAAA,MAClC,WAAW,OAAO,SAAS,IAAI,UAAU,KAAK,CAAC,GAAG,EAAE;AAAA,IAAA;AAAA,EAExD;AAMO,WAAS,oBAAoB,GAAgB,GAAwB;AAC1E,QAAI,EAAE,UAAU,EAAE,MAAO,QAAO,EAAE,QAAQ,EAAE;AAC5C,QAAI,EAAE,UAAU,EAAE,MAAO,QAAO,EAAE,QAAQ,EAAE;AAC5C,QAAI,EAAE,WAAW,EAAE,SAAU,QAAO;AACpC,QAAI,EAAE,WAAW,EAAE,SAAU,QAAO;AACpC,WAAO;AAAA,EACT;AAAA,EC7CO,MAAM,cAAc;AAAA,IAMzB,YACW,gBACQ,MACjB;AARM;AACA;AACA;AACA;AAGG,WAAA,iBAAA;AACQ,WAAA,OAAA;AAAA,IAChB;AAAA;AAAA;AAAA;AAAA,IAKH,IAAI,cAA2B;AAC7B,UAAI,CAAC,KAAK,cAAc;AACtB,aAAK,eAAe,oBAAoB,KAAK,cAAc;AAAA,MAC7D;AACA,aAAO,KAAK;AAAA,IACd;AAAA;AAAA;AAAA;AAAA,IAKA,IAAI,yBAAgD;;AAClD,UAAI,KAAK,4BAA4B,QAAW;AAC9C,cAAM,KAAK,KAAK;AAChB,aAAK,2BAA0B,QAAG,kBAAH,YAAoB;AAAA,MACrD;AACA,aAAO,KAAK;AAAA,IACd;AAAA;AAAA;AAAA;AAAA,IAKA,IAAI,sBAA0C;AAC5C,UAAI,KAAK,yBAAyB,QAAW;AAC3C,cAAM,MAAM,KAAK;AACjB,aAAK,uBAAuB,MAAM,oBAAoB,GAAG,IAAI;AAAA,MAC/D;AACA,aAAO,KAAK;AAAA,IACd;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,IAAI,sBAAsC;;AACxC,cAAO,UAAK,2BAAL,YAA+B,KAAK;AAAA,IAC7C;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,IAAI,mBAAgC;;AAClC,cAAO,UAAK,wBAAL,YAA4B,KAAK;AAAA,IAC1C;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,IAAI,WAAqB;AACvB,UAAI,CAAC,KAAK,WAAW;AACnB,aAAK,YAAY,KAAK,KAAK,IAAI,KAAK,cAAc;AAClD,YAAI,CAAC,KAAK,WAAW;AACnB,gBAAM,QAAQ,6CAA6C,KAAK,cAAc,EAAE;AAAA,QAClF;AAAA,MACF;AACA,aAAO,KAAK;AAAA,IACd;AAAA,EACF;ACpEO,WAAS,0BAA0B,IAAiB,YAAuC;AAChG,UAAM,KAAK,WAAW,GAAG,QAAQ;AACjC,QAAI,CAAC,GAAI,QAAO;AAChB,WAAO,GAAG,SAAS,GAAG;AAAA,EACxB;AAAA,EAiBO,MAAM,gBAAgB;AAAA,IAkC3B,YAAY,YAAqC;AAhCzC;AAAA,uCAA6B,CAAA;AAG7B;AAAA,8DAAuD,IAAA;AAQvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,8CAAkC;AAGlC;AAAA,yCAAiC;AAGjC;AAAA,4CAA0C;AAO1C;AAAA;AAAA;AAAA;AAAA;AAAA,+DAAyC,IAAA;AAGzC;AAAA,0CAAe;AAGf;AAAA;AAGN,WAAK,aAAa;AAAA,IACpB;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,kBAAkB,YAA8C;AAC9D,UAAI,eAAe,KAAK,gBAAgB;AACtC,eAAO;AAAA,MACT;AAEA,WAAK,iBAAiB;AACtB,WAAK,WAAA;AACL,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,oBAA6C;AAC3C,aAAO,KAAK;AAAA,IACd;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,eAAe,KAA4B;AACzC,WAAK,YAAY,CAAA;AACjB,WAAK,aAAa,MAAA;AAGlB,iBAAW,OAAO,IAAI,QAAQ;AAC5B,cAAM,QAAQ,IAAI,cAAc,KAAK,GAAG;AACxC,aAAK,UAAU,KAAK,KAAK;AAEzB,aAAK,aAAa,IAAI,MAAM,gBAAgB,KAAK;AACjD,YAAI,MAAM,YAAY,QAAQ,KAAK,cAAc;AAC/C,eAAK,eAAe,MAAM,YAAY;AAAA,QACxC;AAAA,MACF;AAGA,WAAK,UAAU,KAAK,CAAC,GAAG,MAAM,oBAAoB,EAAE,aAAa,EAAE,WAAW,CAAC;AAG/E,WAAK,WAAA;AAAA,IACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQA,SAAS,KAAqB,KAA+B;AAC3D,UAAI,KAAK,aAAa,IAAI,GAAG,GAAG;AAC9B,eAAO;AAAA,MACT;AAEA,YAAM,QAAQ,IAAI,cAAc,KAAK,GAAG;AACxC,YAAM,KAAK,MAAM;AAGjB,UAAI,GAAG,QAAQ,KAAK,cAAc;AAChC,aAAK,eAAe,GAAG;AAAA,MACzB;AAEA,YAAM,YAAY,KAAK;AAGvB,UAAI,cAAc,UAAU;AAC5B,eAAS,IAAI,UAAU,SAAS,GAAG,KAAK,GAAG,KAAK;AAC9C,cAAM,aAAa,UAAU,CAAC,EAAE;AAChC,YAAI,oBAAoB,IAAI,UAAU,KAAK,GAAG;AAC5C,wBAAc,IAAI;AAClB;AAAA,QACF;AACA,YAAI,MAAM,GAAG;AACX,wBAAc;AAAA,QAChB;AAAA,MACF;AAGA,gBAAU,OAAO,aAAa,GAAG,KAAK;AACtC,WAAK,aAAa,IAAI,KAAK,KAAK;AAIhC,UAAI,KAAK,qBAAqB,QAAQ,eAAe,KAAK,kBAAkB;AAC1E,aAAK,WAAA;AACL,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,UAAU,MAAyC;AACjD,UAAI,KAAK,WAAW,EAAG,QAAO;AAE9B,UAAI,eAAe;AACnB,UAAI,kBAAkB,OAAO;AAG7B,YAAM,+BAAe,IAAA;AACrB,iBAAW,OAAO,MAAM;AACtB,cAAM,QAAQ,KAAK,aAAa,IAAI,GAAG;AACvC,YAAI,OAAO;AACT,eAAK,aAAa,OAAO,GAAG;AAC5B,mBAAS,IAAI,GAAG;AAGhB,gBAAM,QAAQ,KAAK,UAAU,QAAQ,KAAK;AAC1C,cAAI,UAAU,MAAM,QAAQ,iBAAiB;AAC3C,8BAAkB;AAAA,UACpB;AAAA,QACF;AAAA,MACF;AAEA,UAAI,SAAS,SAAS,EAAG,QAAO;AAGhC,YAAM,YAAY,KAAK;AACvB,UAAI,IAAI;AACR,aAAO,IAAI,UAAU,UAAU,SAAS,OAAO,GAAG;AAChD,YAAI,SAAS,IAAI,UAAU,CAAC,EAAE,cAAc,GAAG;AAC7C,mBAAS,OAAO,UAAU,CAAC,EAAE,cAAc;AAC3C,oBAAU,OAAO,GAAG,CAAC;AACrB;AAAA,QACF,OAAO;AACL;AAAA,QACF;AAAA,MACF;AAGA,UAAI,KAAK,qBAAqB,QAAQ,mBAAmB,KAAK,kBAAkB;AAC9E,aAAK,WAAA;AAAA,MACP;AAEA,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,KAA8B;AAClC,aAAO,KAAK,aAAa,IAAI,GAAG;AAAA,IAClC;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,KAAgD;AACpD,aAAO,KAAK,aAAa,IAAI,GAAG;AAAA,IAClC;AAAA;AAAA;AAAA;AAAA,IAKA,eAAyC;AACvC,aAAO,KAAK;AAAA,IACd;AAAA;AAAA;AAAA;AAAA,IAKA,IAAI,UAAkB;AACpB,aAAO,KAAK,UAAU;AAAA,IACxB;AAAA;AAAA;AAAA;AAAA,IAKA,yBAAkC;AAChC,aAAO,KAAK,qBAAqB;AAAA,IACnC;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,aAAmB;AACjB,WAAK,mBAAmB;AAAA,IAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQA,iBAA4E;;AAC1E,YAAM,aAAwB,gBAAK,mBAAL,mBAAqB,UAArB,YAA8B,CAAA;AAC5D,YAAM,cAAa,gBAAK,mBAAL,mBAAqB,eAArB,YAAmC,CAAA;AACtD,YAAM,gBAAgB,OAAO,KAAK,UAAU,EAAE,SAAS;AAEvD,UAAI,KAAK,qBAAqB,MAAM;AAElC,eAAO,KAAK,kBAAkB,WAAW,YAAY,aAAa;AAAA,MACpE;AAGA,aAAO,KAAK,iBAAiB,YAAY,aAAa;AAAA,IACxD;AAAA;AAAA;AAAA;AAAA,IAKQ,kBACN,WACA,YACA,eAC2D;;AAC3D,YAAM,YAAW,UAAK,gBAAL,YAAoB,CAAA;AAGrC,WAAK,cAAc,MAAA;AACnB,WAAK,mBAAmB;AACxB,WAAK,cAAc;AAMnB,YAAM,EAAE,MAAA,IAAU,KAAK,iBAAiB,YAAY,eAAe,KAAK;AAGxE,YAAM,gBAAgB,KAAK,MAAM,oBAAoB,UAAU,KAAK,CAAC;AAErE,aAAO,EAAE,OAAO,cAAA;AAAA,IAClB;AAAA;AAAA;AAAA;AAAA;AAAA,IAMQ,iBACN,YACA,eACA,YAAY,MAC+C;AAC3D,UAAI,QAAQ,KAAK;AACjB,YAAM,aAAyB,CAAA;AAC/B,YAAM,YAAY,KAAK;AACvB,YAAM,aAAa,KAAK,mBAAoB;AAE5C,eAAS,IAAI,YAAY,IAAI,UAAU,QAAQ,KAAK;AAClD,cAAM,QAAQ,UAAU,CAAC;AACzB,cAAM,WAAW,MAAM;AAGvB,YAAI,KAAK,cAAc,IAAI,QAAQ,GAAG;AACpC;AAAA,QACF;AAGA,YAAI,eAAe;AACjB,gBAAM,UAAU,MAAM;AACtB,cAAI,0BAA0B,SAAS,UAAU,GAAG;AAClD,iBAAK,cAAc,IAAI,QAAQ;AAC/B;AAAA,UACF;AAAA,QACF;AAEA,cAAM,KAAK,MAAM;AAGjB,cAAM,WAAW,iBAAiB,OAAO,IAAI,KAAK,UAAU;AAE5D,YAAI,aAAa,OAAO;AACtB,kBAAQ;AACR,cAAI,WAAW;AACb,uBAAW,KAAK,EAAE;AAAA,UACpB;AAAA,QACF;AAEA,aAAK,cAAc,IAAI,QAAQ;AAC/B,aAAK,mBAAmB;AAAA,MAC1B;AAIA,UAAI,UAAU,SAAS,KAAK,KAAK,mBAAoB,UAAU,SAAS,GAAG;AACzE,aAAK,mBAAmB,UAAU,SAAS;AAAA,MAC7C;AAEA,WAAK,cAAc;AAGnB,YAAM,gBAAgB,KAAK,MAAM;AAC/B,cAAM,MAAY,CAAA;AAClB,mBAAW,MAAM,YAAY;AAC3B,cAAI,KAAK,GAAG,GAAG,GAAG;AAAA,QACpB;AACA,eAAO;AAAA,MACT,CAAC;AAED,aAAO,EAAE,OAAO,cAAA;AAAA,IAClB;AAAA;AAAA;AAAA;AAAA,IAKA,kBAA0B;AACxB,aAAO,KAAK;AAAA,IACd;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,iBAAoC;AAClC,aAAO,KAAK;AAAA,IACd;AAAA;AAAA;AAAA;AAAA,IAKA,mBAAuC;;AACrC,UAAI,KAAK,qBAAqB,QAAQ,KAAK,mBAAmB,GAAG;AAC/D,eAAO;AAAA,MACT;AACA,cAAO,gBAAK,UAAU,KAAK,gBAAgB,MAApC,mBAAuC,gBAAvC,YAAsD;AAAA,IAC/D;AAAA;AAAA;AAAA;AAAA,IAKA,sBAAqC;AACnC,aAAO,KAAK;AAAA,IACd;AAAA,EACF;AC5XO,WAAS,kBACd,YACA,mBACa;AACb,WAAO;AAAA,MACL,YAAY;AAAA,MACZ,sBAAsB;AAAA;AAAA,MACtB,iBAAiB,IAAI,gBAAgB,UAAU;AAAA,MAC/C;AAAA,IAAA;AAAA,EAEJ;ACTO,WAAS,SACd,KACA,KACA,aACA,YACA,aACA,aACgB;AAChB,UAAM,OAAO,YAAY;AAGzB,UAAM,QAAQ,KAAK,IAAI,YAAY,YAAY,KAAK,gBAAA,CAAiB,IAAI;AACzE,gBAAY,aAAa;AAGzB,UAAM,KAAkB;AAAA,MACtB,OAAO;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,WAAW,KAAK,IAAA;AAAA,IAAI;AAEtB,UAAM,MAAM,iBAAiB,EAAE;AAG/B,UAAM,SAAmB,EAAE,KAAK,eAAe,YAAA;AAC/C,QAAI,IAAI,KAAK,MAAM;AAEnB,WAAO;AAAA,EACT;AAUA,WAAS,QACP,KACA,YACA,aACA,gBACA,QACA,SACM;;AACN,UAAM,OAAO,YAAY;AACzB,UAAM,cAAc,iBAAiB;AACrC,UAAM,cAAa,sCAAQ,eAAR,YAAsB,CAAA;AAGzC,UAAM,iBAAgB,sCAAQ,iBAAR,YAAwB;AAG9C,UAAM,cAAc,CAAC,IAAiB,YAAkC;AACtE,YAAM,YAAY,gBAAgB,GAAG,YAAY,YAAY;AAC7D,UAAI,UAAW,QAAO;AACtB,aAAO,0BAA0B,SAAS,UAAU;AAAA,IACtD;AAEA,UAAM,WAA6B,CAAA;AACnC,UAAM,WAAiE,CAAA;AAGvE,UAAM,eAAe,CAAC,UAAkC;AACtD,UAAI,YAAY,MAAM,aAAa,MAAM,gBAAgB,GAAG;AAC1D,iBAAS,KAAK,MAAM,cAAc;AAClC,eAAO;AAAA,MACT;AAEA,UAAI,MAAM,YAAY,SAAS,gBAAgB;AAE7C,iBAAS,KAAK,EAAE,aAAa,MAAM,qBAAqB,IAAI,MAAM,UAAU;AAC5E,iBAAS,KAAK,MAAM,cAAc;AAClC,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT;AAGA,eAAW,SAAS,KAAK,gBAAgB;AACvC,UAAI,aAAa,KAAK,GAAG;AAEvB;AAAA,MACF;AAAA,IACF;AAEA,UAAM,2BAA2B,CAAC,mBAAyC;AAEzE,UAAI,IAAI,IAAI,cAAc,GAAG;AAC3B,qBAAa,IAAI,cAAc,gBAAgB,GAAG,CAAC;AAAA,MACrD;AAAA,IACF;AAIA,QAAI,SAAS;AACX,iBAAW,OAAO,SAAS;AACzB,iCAAyB,GAAG;AAAA,MAC9B;AAAA,IACF;AAGA,eAAW,EAAE,aAAa,GAAA,KAAQ,UAAU;AAC1C,YAAM,SAAS,SAAS,GAAG,KAAK,KAAK,aAAa,YAAY,aAAa,WAAW;AACtF,WAAK,SAAS,QAAQ,GAAG;AAAA,IAC3B;AAGA,eAAW,OAAO,UAAU;AAC1B,UAAI,OAAO,GAAG;AAAA,IAChB;AACA,SAAK,UAAU,QAAQ;AAAA,EACzB;AAOO,WAAS,YACd,KACA,KACA,aACA,YACA,aACA,WAC2D;AAC3D,UAAM,OAAO,YAAY;AAGzB,UAAM,EAAE,gBAAgB,YAAY,OAAA,IAAW,+BAA+B,WAAW;AAGzF,gBAAY,uBAAuB;AAGnC,SAAK,kBAAkB,MAAM;AAK7B,UAAM,0BAA0B,KAAK,eAAA,MAAqB,QAAQ,CAAC;AAGnE,QAAI,yBAAyB;AAC3B,WAAK,eAAe,GAAG;AAAA,IACzB,OAAO;AAGL,WAAK,UAAU,UAAU,OAAO;AAAA,IAClC;AAGA,QAAI,SAAS,MAAM;AACjB,cAAQ,KAAK,YAAY,aAAa,gBAAgB,QAAQ,uCAAW,KAAK;AAG9E,uBAAiB,aAAa,cAAc;AAAA,IAC9C,CAAC;AAED,QAAI,yBAAyB;AAE3B,aAAO,KAAK,eAAA;AAAA,IACd;AAOA,eAAW,OAAO,UAAU,OAAO;AAEjC,UAAI,IAAI,IAAI,GAAG,KAAK,CAAC,KAAK,MAAM,GAAG,GAAG;AACpC,aAAK,SAAS,KAAK,GAAG;AAAA,MACxB;AAAA,IACF;AAEA,WAAO,KAAK,eAAA;AAAA,EACd;AChMO,QAAM,4CAA4B,cAAc;AAiHhD,WAAS,mBACd,SAC+B;AAC/B,UAAM;AAAA,MACJ;AAAA,MACA,aAAa;AAAA,MACb,qBAAqB;AAAA,MACrB,WAAW,WAAA;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,IAAA,IACE;AAEJ,QAAI,SAAS,SAAS,GAAG,GAAG;AAC1B,cAAQ,yCAAyC,QAAQ,EAAE;AAAA,IAC7D;AAEA,UAAM,MAAM,KAAK,OAAiB,UAAU;AAC5C,UAAM,cAAc,KAAK,OAAyB,kBAAkB;AAGpE,UAAM,cAAc;AAAA,MAClB;AAAA,MACA,gDAAqB,OAAO;AAAA,IAAA;AAI9B,UAAM,kCAAkB,IAAA;AAExB,UAAM,oBAAoB,CAAC,OAAc,kBAAuC;AAC9E,iBAAW,OAAO,aAAa;AAC7B,YAAI,OAAO,aAAa;AAAA,MAC1B;AAAA,IACF;AAGA,UAAM,mBAAmB,CAAC,UAA+C;AACvE,YAAM,QAA0B,CAAA;AAChC,YAAM,UAA4B,CAAA;AAElC,iBAAW,CAAC,KAAK,MAAM,KAAK,MAAM,QAAQ,MAAM;AAC9C,YAAI,OAAO,WAAW,OAAO;AAC3B,gBAAM,KAAK,GAAG;AAAA,QAChB,WAAW,OAAO,WAAW,UAAU;AACrC,kBAAQ,KAAK,GAAG;AAAA,QAClB,WAAW,OAAO,WAAW,UAAU;AACrC,kBAAQ,KAAK,GAAG;AAChB,gBAAM,KAAK,GAAG;AAAA,QAChB;AAAA,MACF;AAEA,aAAO,EAAE,OAAO,QAAA;AAAA,IAClB;AAGA,UAAM,iBAA+B,EAAE,OAAO,CAAA,GAAI,SAAS,CAAA,EAAC;AAG5D,UAAM,YAAY,CAAC,cAAwC;AACzD,YAAM,EAAE,OAAO,cAAA,IAAkB;AAAA,QAC/B;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAEF,wBAAkB,OAAgB,aAAa;AAAA,IACjD;AAGA,UAAM,aAAa,CAAC,OAA8B,iBAAgC;AAChF,YAAM,YAAY,iBAAiB,KAAK;AACxC,gBAAU,SAAS;AAAA,IACrB;AAGA,UAAM,qBAAqB,CACzB,QACA,iBACG;AACH,gBAAU,cAAc;AAAA,IAC1B;AAEA,gBAAY,QAAQ,kBAAkB;AACtC,QAAI,QAAQ,UAAU;AAGtB,cAAU,MAAS;AAGnB,QAAI,WAAW;AAEf,UAAM,oBAAoB,MAAM;AAC9B,UAAI,UAAU;AACZ,gBAAQ,mDAAmD;AAAA,MAC7D;AAAA,IACF;AAEA,UAAM,yBAAyB,MAAM;AACnC,UAAI,YAAY,yBAAyB,MAAM;AAC7C,gBAAQ,4EAA4E;AAAA,MACtF;AACA,aAAO,YAAY,uBAAuB;AAAA,IAC5C;AAEA,WAAO;AAAA,MACL,WAAkB;;AAChB,0BAAA;AACA,gBAAQ,iBAAY,gBAAgB,eAAA,MAA5B,YAAgD,CAAA;AAAA,MAC1D;AAAA,MAEA,UAAU,UAAqF;AAC7F,0BAAA;AACA,oBAAY,IAAI,QAAQ;AACxB,eAAO,MAAM;AACX,sBAAY,OAAO,QAAQ;AAAA,QAC7B;AAAA,MACF;AAAA,MAEA,KAAK,KAAiB;AACpB,0BAAA;AACA,aAAK,SAAS,MAAM;AAClB,gBAAM,cAAc,uBAAA;AACpB,mBAAS,KAAK,KAAK,aAAa,UAAU,WAAW;AAAA,QACvD,GAAG,SAAS;AAAA,MACd;AAAA,MAEA,eAAe,aAA0B;;AACvC,0BAAA;AACA,cAAM,gBAAgB,iBAAY,gBAAgB,eAAA,MAA5B,YAAgD,CAAA;AACtE,cAAM,MAAM,oBAAoB,cAAc,WAAW;AACzD,YAAI,IAAI,SAAS,GAAG;AAClB,eAAK,KAAK,GAAG;AAAA,QACf;AAAA,MACF;AAAA,MAEA,UAAgB;AACd,0BAAA;AACA,aAAK,SAAS,MAAM;;AAClB,gBAAM,cAAc,uBAAA;AACpB,gBAAM,gBAAe,iBAAY,gBAAgB,eAAA,MAA5B,YAAgD,CAAA;AACrE,2BAAiB,KAAK,aAAa,aAAa,aAAa,cAAc,QAAQ;AAAA,QACrF,GAAG,SAAS;AAAA,MACd;AAAA,MAEA,UAAgB;AACd,YAAI,SAAU;AACd,mBAAW;AACX,YAAI,UAAU,UAAU;AACxB,oBAAY,UAAU,kBAAkB;AACxC,oBAAY,MAAA;AAAA,MACd;AAAA,MAEA,iBAAyB;AACvB,0BAAA;AACA,eAAO,uBAAA;AAAA,MACT;AAAA,MAEA,wBAAgC;AAC9B,0BAAA;AACA,cAAM,cAAc,uBAAA;AACpB,YAAI,QAAQ;AAGZ,mBAAW,SAAS,YAAY,gBAAgB,aAAA,GAAgB;AAC9D,gBAAM,KAAK,MAAM;AACjB,cAAI,GAAG,UAAU,aAAa;AAC5B;AAAA,UACF,WAAW,GAAG,QAAQ,aAAa;AACjC;AAAA,UACF;AAAA,QACF;AACA,eAAO;AAAA,MACT;AAAA,MAEA,0BAA8C;AAC5C,0BAAA;AACA,cAAM,cAAc,uBAAA;AAEpB,mBAAW,SAAS,YAAY,gBAAgB,aAAA,GAAgB;AAC9D,gBAAM,KAAK,MAAM;AACjB,cAAI,GAAG,UAAU,aAAa;AAC5B,mBAAO,GAAG;AAAA,UACZ,WAAW,GAAG,QAAQ,aAAa;AACjC;AAAA,UACF;AAAA,QACF;AACA,eAAO;AAAA,MACT;AAAA,MAEA,aAAsB;AACpB,0BAAA;AACA,eAAO,IAAI,SAAS,KAAK,YAAY,SAAS;AAAA,MAChD;AAAA,MAEA,CAAC,kBAAkB,IAA8B;AAC/C,0BAAA;AACA,eAAO,YAAY,gBAAgB,aAAA;AAAA,MACrC;AAAA,IAAA;AAAA,EAEJ;ACxSA,WAAS,YAAY,OAAmB,MAAuB;AAC7D,QAAIA,WAAqB;AACzB,eAAW,WAAW,MAAM;AAC1B,UAAI,OAAO,YAAY,UAAU;AAC/B,YAAI,CAAC,SAASA,QAAO,KAAK,MAAM,QAAQA,QAAO,GAAG;AAChD,kBAAQ,oCAAoC,OAAO,GAAG;AAAA,QACxD;AACA,YAAI,EAAE,WAAWA,WAAU;AACzB,kBAAQ,aAAa,OAAO,kBAAkB;AAAA,QAChD;AACA,QAAAA,WAAUA,SAAQ,OAAO;AAAA,MAC3B,OAAO;AACL,YAAI,CAAC,MAAM,QAAQA,QAAO,GAAG;AAC3B,kBAAQ,kCAAkC,OAAO,EAAE;AAAA,QACrD;AACA,YAAI,UAAU,KAAK,WAAWA,SAAQ,QAAQ;AAC5C,kBAAQ,SAAS,OAAO,gBAAgB;AAAA,QAC1C;AACA,QAAAA,WAAUA,SAAQ,OAAO;AAAA,MAC3B;AAAA,IACF;AACA,WAAOA;AAAA,EACT;AAMA,WAAS,QAAQ,OAAmB,IAAQ,aAA4B;AAUtE,UAAM,YAAY,YAAY,OAAO,GAAG,IAAI;AAE5C,YAAQ,GAAG,MAAA;AAAA,MACT,KAAK,OAAO;AAEV,YAAI,CAAC,SAAS,SAAS,GAAG;AACxB,kBAAQ,wCAAwC;AAAA,QAClD;AACA,YAAI,MAAuB,GAAG;AAE9B,YAAI,MAAM,QAAQ,SAAS,KAAK,OAAO,QAAQ,YAAY,QAAQ,UAAU;AAC3E,gBAAM,SAAS,gBAAgB,GAAG;AAClC,cAAI,WAAW,MAAM;AACnB,oBAAQ,oCAAoC,GAAG,YAAY;AAAA,UAC7D;AACA,gBAAM;AAAA,QACR;AAEE,kBAAkB,GAAG,IAAI,cAAc,UAAU,GAAG,KAAK,IAAI,GAAG;AAClE;AAAA,MACF;AAAA,MAEA,KAAK,UAAU;AAEb,YAAI,CAAC,SAAS,SAAS,GAAG;AACxB,kBAAQ,2CAA2C;AAAA,QACrD;AACA,YAAI,MAAuB,GAAG;AAE9B,YAAI,MAAM,QAAQ,SAAS,KAAK,OAAO,QAAQ,UAAU;AACvD,gBAAM,SAAS,gBAAgB,GAAG;AAClC,cAAI,WAAW,MAAM;AACnB,oBAAQ,uCAAuC,GAAG,cAAc;AAAA,UAClE;AACA,gBAAM;AAAA,QACR;AAEA,eAAQ,UAAkB,GAAG;AAC7B;AAAA,MACF;AAAA,MAEA,KAAK,UAAU;AACb,YAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC7B,kBAAQ,iCAAiC;AAAA,QAC3C;AACA,cAAM,YAAY,KAAK,IAAI,GAAG,OAAO,UAAU,MAAM;AACrD,kBAAU;AAAA,UACR;AAAA,UACA,GAAG;AAAA,UACH,GAAI,cAAc,GAAG,QAAQ,IAAI,CAAC,MAAM,UAAU,CAAC,CAAC,IAAI,GAAG;AAAA,QAAA;AAE7D;AAAA,MACF;AAAA,MAEA,KAAK;AACH,YAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC7B,kBAAQ,mCAAmC;AAAA,QAC7C;AACA,YAAI,CAAC,UAAU,KAAK,CAAC,SAAS,UAAU,MAAM,GAAG,KAAK,CAAC,GAAG;AACxD,oBAAU,KAAK,cAAc,UAAU,GAAG,KAAK,IAAI,GAAG,KAAK;AAAA,QAC7D;AACA;AAAA,MAEF,KAAK;AACH,YAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC7B,kBAAQ,wCAAwC;AAAA,QAClD;AAEA,iBAAS,IAAI,UAAU,SAAS,GAAG,KAAK,GAAG,KAAK;AAC9C,cAAI,UAAU,UAAU,CAAC,GAAG,GAAG,KAAK,GAAG;AACrC,sBAAU,OAAO,GAAG,CAAC;AAAA,UACvB;AAAA,QACF;AACA;AAAA,MAEF;AACE,cAAM,QAAQ,2BAA4B,GAAW,IAAI,EAAE;AAAA,IAAA;AAAA,EAEjE;AAwBO,WAAS,SAAS,KAAoB,QAAoB,SAAiC;;AAChG,UAAM,eAAc,wCAAS,gBAAT,YAAwB;AAC5C,eAAW,MAAM,KAAK;AACpB,cAAQ,QAAQ,IAAI,WAAW;AAAA,IACjC;AAAA,EACF;;;;;;;;;;;;","x_google_ignoreList":[5,6,7,8]}