state-sync-log 0.9.0

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

@@ -0,0 +1,1343 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["state-sync-log"] = {}));
+})(this, (function(exports2) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  function getFinalizedEpochAndCheckpoint(yCheckpoint) {
+    let maxEpoch = -1;
+    let best = null;
+    let bestTxCount = -1;
+    let bestClientId = "";
+    for (const [key, cp] of yCheckpoint.entries()) {
+      const { epoch, clientId } = parseCheckpointKey(key);
+      if (epoch > maxEpoch) {
+        maxEpoch = epoch;
+        best = cp;
+        bestTxCount = cp.txCount;
+        bestClientId = clientId;
+      } else if (epoch === maxEpoch) {
+        if (cp.txCount > bestTxCount || cp.txCount === bestTxCount && clientId < bestClientId) {
+          best = cp;
+          bestTxCount = cp.txCount;
+          bestClientId = clientId;
+        }
+      }
+    }
+    return { finalizedEpoch: maxEpoch, checkpoint: best };
+  }
+  class StateSyncLogError extends Error {
+    constructor(msg) {
+      super(msg);
+      Object.setPrototypeOf(this, StateSyncLogError.prototype);
+    }
+  }
+  function failure(message) {
+    throw new StateSyncLogError(message);
+  }
+  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 getDefaultExportFromCjs(x) {
+    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+  }
+  var fastDeepEqual;
+  var hasRequiredFastDeepEqual;
+  function requireFastDeepEqual() {
+    if (hasRequiredFastDeepEqual) return fastDeepEqual;
+    hasRequiredFastDeepEqual = 1;
+    fastDeepEqual = function equal2(a, b) {
+      if (a === b) return true;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor) return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          length = a.length;
+          if (length != b.length) return false;
+          for (i = length; i-- !== 0; )
+            if (!equal2(a[i], b[i])) return false;
+          return true;
+        }
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length) return false;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+        for (i = length; i-- !== 0; ) {
+          var key = keys[i];
+          if (!equal2(a[key], b[key])) return false;
+        }
+        return true;
+      }
+      return a !== a && b !== b;
+    };
+    return fastDeepEqual;
+  }
+  var fastDeepEqualExports = requireFastDeepEqual();
+  const equal = /* @__PURE__ */ getDefaultExportFromCjs(fastDeepEqualExports);
+  const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+  let nanoid = (size = 21) => {
+    let id = "";
+    let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63];
+    }
+    return id;
+  };
+  var rfdc_1;
+  var hasRequiredRfdc;
+  function requireRfdc() {
+    if (hasRequiredRfdc) return rfdc_1;
+    hasRequiredRfdc = 1;
+    rfdc_1 = rfdc2;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc2(opts) {
+      opts = opts || {};
+      if (opts.circles) return rfdcCircles(opts);
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            a2[k] = fn(cur);
+          }
+        }
+        return a2;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone2);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone2);
+        }
+        const o2 = {};
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone2);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = clone2(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      const refs = [];
+      const refsNew = [];
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            const index = refs.indexOf(cur);
+            if (index !== -1) {
+              a2[k] = refsNew[index];
+            } else {
+              a2[k] = fn(cur);
+            }
+          }
+        }
+        return a2;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone2);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone2);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone2);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = clone2(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+    return rfdc_1;
+  }
+  var rfdcExports = requireRfdc();
+  const rfdc = /* @__PURE__ */ getDefaultExportFromCjs(rfdcExports);
+  const clone = rfdc({ proto: true });
+  function deepEqual(a, b) {
+    return equal(a, b);
+  }
+  function generateID() {
+    return nanoid();
+  }
+  function isObject(value) {
+    return value !== null && typeof value === "object";
+  }
+  function deepClone(value) {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    return clone(value);
+  }
+  function lazy(fn) {
+    let computed = false;
+    let value;
+    return () => {
+      if (!computed) {
+        value = fn();
+        computed = true;
+      }
+      return value;
+    };
+  }
+  function createDraft(base) {
+    return {
+      root: base,
+      base,
+      ownedObjects: /* @__PURE__ */ new Set(),
+      isRootOwned: false
+    };
+  }
+  function shallowClone(obj) {
+    if (Array.isArray(obj)) {
+      return obj.slice();
+    }
+    const clone2 = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      clone2[key] = obj[key];
+    }
+    return clone2;
+  }
+  function ensureOwned(ctx, parent, key, child) {
+    if (ctx.ownedObjects.has(child)) {
+      return child;
+    }
+    const cloned = shallowClone(child);
+    parent[key] = cloned;
+    ctx.ownedObjects.add(cloned);
+    return cloned;
+  }
+  function ensureOwnedPath(ctx, path) {
+    if (!ctx.isRootOwned) {
+      ctx.root = shallowClone(ctx.root);
+      ctx.ownedObjects.add(ctx.root);
+      ctx.isRootOwned = true;
+    }
+    if (path.length === 0) {
+      return ctx.root;
+    }
+    let current = 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)) {
+          failure(`Expected array at path segment ${segment}`);
+        }
+        if (segment < 0 || segment >= current.length) {
+          failure(`Index ${segment} out of bounds`);
+        }
+      } else {
+        if (!isObject(current) || Array.isArray(current)) {
+          failure(`Expected object at path segment "${segment}"`);
+        }
+        if (!(segment in current)) {
+          failure(`Property "${segment}" does not exist`);
+        }
+      }
+      const child = current[segment];
+      if (child === null || typeof child !== "object") {
+        failure(`Cannot traverse through primitive at path segment ${segment}`);
+      }
+      current = ensureOwned(ctx, current, segment, child);
+    }
+    return current;
+  }
+  function draftSet(ctx, path, key, value) {
+    const container = ensureOwnedPath(ctx, path);
+    if (Array.isArray(container)) {
+      failure("set requires object container");
+    }
+    container[key] = value;
+  }
+  function draftDelete(ctx, path, key) {
+    const container = ensureOwnedPath(ctx, path);
+    if (Array.isArray(container)) {
+      failure("delete requires object container");
+    }
+    delete container[key];
+  }
+  function draftSplice(ctx, path, index, deleteCount, inserts) {
+    const container = ensureOwnedPath(ctx, path);
+    if (!Array.isArray(container)) {
+      failure("splice requires array container");
+    }
+    const safeIndex = Math.min(index, container.length);
+    if (inserts.length === 0) {
+      container.splice(safeIndex, deleteCount);
+    } else if (inserts.length === 1) {
+      container.splice(safeIndex, deleteCount, inserts[0]);
+    } else {
+      container.splice(safeIndex, deleteCount, ...inserts);
+    }
+  }
+  function draftAddToSet(ctx, path, value) {
+    const container = ensureOwnedPath(ctx, path);
+    if (!Array.isArray(container)) {
+      failure("addToSet requires array container");
+    }
+    if (!container.some((item) => deepEqual(item, value))) {
+      container.push(value);
+    }
+  }
+  function draftDeleteFromSet(ctx, path, value) {
+    const container = ensureOwnedPath(ctx, path);
+    if (!Array.isArray(container)) {
+      failure("deleteFromSet requires array container");
+    }
+    for (let i = container.length - 1; i >= 0; i--) {
+      if (deepEqual(container[i], value)) {
+        container.splice(i, 1);
+      }
+    }
+  }
+  function applyOpToDraft(ctx, op) {
+    switch (op.kind) {
+      case "set":
+        draftSet(ctx, op.path, op.key, op.value);
+        break;
+      case "delete":
+        draftDelete(ctx, op.path, op.key);
+        break;
+      case "splice":
+        draftSplice(ctx, op.path, op.index, op.deleteCount, op.inserts);
+        break;
+      case "addToSet":
+        draftAddToSet(ctx, op.path, op.value);
+        break;
+      case "deleteFromSet":
+        draftDeleteFromSet(ctx, op.path, op.value);
+        break;
+      default:
+        throw failure(`Unknown operation kind: ${op.kind}`);
+    }
+  }
+  function applyTxImmutable(base, tx, validateFn) {
+    if (tx.ops.length === 0) return base;
+    const ctx = createDraft(base);
+    try {
+      for (const op of tx.ops) {
+        applyOpToDraft(ctx, op);
+      }
+      if (validateFn && !validateFn(ctx.root)) {
+        return base;
+      }
+      return ctx.root;
+    } catch {
+      return base;
+    }
+  }
+  function computeReconcileOps(currentState, targetState) {
+    const ops = [];
+    diffValue(currentState, targetState, [], ops);
+    return ops;
+  }
+  function diffValue(current, target, path, ops) {
+    if (current === target) return;
+    const currentType = typeof current;
+    const targetType = typeof target;
+    if (current === null || target === null || currentType !== "object" || targetType !== "object") {
+      emitReplace(path, target, ops);
+      return;
+    }
+    const currentIsArray = Array.isArray(current);
+    const targetIsArray = Array.isArray(target);
+    if (currentIsArray !== targetIsArray) {
+      emitReplace(path, target, ops);
+      return;
+    }
+    if (currentIsArray) {
+      diffArray(current, target, path, ops);
+    } else {
+      diffObject(current, target, path, ops);
+    }
+  }
+  function diffObject(current, target, path, ops) {
+    for (const key in current) {
+      if (Object.hasOwn(current, 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)) {
+          ops.push({ kind: "set", path, key, value: targetVal });
+        } else if (current[key] !== targetVal) {
+          diffValue(current[key], targetVal, [...path, key], ops);
+        }
+      }
+    }
+  }
+  function diffArray(current, target, path, ops) {
+    const currentLen = current.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 (targetLen > currentLen) {
+      ops.push({
+        kind: "splice",
+        path,
+        index: currentLen,
+        deleteCount: 0,
+        inserts: target.slice(currentLen)
+      });
+    } else if (currentLen > targetLen) {
+      ops.push({
+        kind: "splice",
+        path,
+        index: targetLen,
+        deleteCount: currentLen - targetLen,
+        inserts: []
+      });
+    }
+  }
+  function emitReplace(path, value, ops) {
+    if (path.length === 0) {
+      failure("StateSyncLog: Cannot replace root state directly via Ops.");
+    }
+    const parentPath = path.slice(0, -1);
+    const keyToCheck = path[path.length - 1];
+    if (typeof keyToCheck === "string") {
+      ops.push({ kind: "set", path: parentPath, key: keyToCheck, value });
+    } else {
+      ops.push({
+        kind: "splice",
+        path: parentPath,
+        index: keyToCheck,
+        deleteCount: 1,
+        inserts: [value]
+      });
+    }
+  }
+  function txTimestampToKey(ts) {
+    return `${ts.epoch};${ts.clock};${ts.clientId};${ts.wallClock}`;
+  }
+  function parseTxTimestampKey(key) {
+    const i1 = key.indexOf(";");
+    const i2 = key.indexOf(";", i1 + 1);
+    const i3 = key.indexOf(";", i2 + 1);
+    if (i1 === -1 || i2 === -1 || i3 === -1) {
+      failure(`Malformed timestamp key: ${key}`);
+    }
+    return {
+      epoch: Number.parseInt(key.substring(0, i1), 10),
+      clock: Number.parseInt(key.substring(i1 + 1, i2), 10),
+      clientId: key.substring(i2 + 1, i3),
+      wallClock: Number.parseInt(key.substring(i3 + 1), 10)
+    };
+  }
+  function compareTxTimestamps(a, b) {
+    if (a.epoch !== b.epoch) return a.epoch - b.epoch;
+    if (a.clock !== b.clock) return a.clock - b.clock;
+    if (a.clientId < b.clientId) return -1;
+    if (a.clientId > b.clientId) return 1;
+    return 0;
+  }
+  class SortedTxEntry {
+    constructor(txTimestampKey, _yTx) {
+      __publicField(this, "_txTimestamp");
+      __publicField(this, "_originalTxTimestampKey");
+      __publicField(this, "_originalTxTimestamp");
+      __publicField(this, "_txRecord");
+      this.txTimestampKey = txTimestampKey;
+      this._yTx = _yTx;
+    }
+    /**
+     * Gets the parsed timestamp, lazily parsing and caching on first access.
+     */
+    get txTimestamp() {
+      if (!this._txTimestamp) {
+        this._txTimestamp = parseTxTimestampKey(this.txTimestampKey);
+      }
+      return this._txTimestamp;
+    }
+    /**
+     * Gets the original tx timestamp key, lazily and caching on first access.
+     */
+    get originalTxTimestampKey() {
+      var _a;
+      if (this._originalTxTimestampKey === void 0) {
+        const tx = this.txRecord;
+        this._originalTxTimestampKey = (_a = tx.originalTxKey) != null ? _a : null;
+      }
+      return this._originalTxTimestampKey;
+    }
+    /**
+     * Gets the parsed original tx timestamp, lazily parsing and caching on first access.
+     */
+    get originalTxTimestamp() {
+      if (this._originalTxTimestamp === void 0) {
+        const key = this.originalTxTimestampKey;
+        this._originalTxTimestamp = key ? parseTxTimestampKey(key) : null;
+      }
+      return this._originalTxTimestamp;
+    }
+    /**
+     * Gets the logical (deduplicated) tx timestamp key.
+     * This is the original tx key if it exists, otherwise the physical key.
+     */
+    get dedupTxTimestampKey() {
+      var _a;
+      return (_a = this.originalTxTimestampKey) != null ? _a : this.txTimestampKey;
+    }
+    /**
+     * Gets the logical (deduplicated) parsed tx timestamp.
+     * This is the original tx timestamp if it exists, otherwise the physical timestamp.
+     */
+    get dedupTxTimestamp() {
+      var _a;
+      return (_a = this.originalTxTimestamp) != null ? _a : this.txTimestamp;
+    }
+    /**
+     * Gets the tx record, lazily fetching and caching on first access.
+     * Returns undefined if the tx doesn't exist.
+     */
+    get txRecord() {
+      if (!this._txRecord) {
+        this._txRecord = this._yTx.get(this.txTimestampKey);
+        if (!this._txRecord) {
+          throw failure(`SortedTxEntry: TxRecord not found for key ${this.txTimestampKey}`);
+        }
+      }
+      return this._txRecord;
+    }
+  }
+  function isTransactionInCheckpoint(ts, watermarks) {
+    const wm = watermarks[ts.clientId];
+    if (!wm) return false;
+    return ts.clock <= wm.maxClock;
+  }
+  class StateCalculator {
+    constructor(validateFn) {
+      /** Sorted tx cache (ALL active/future txs, kept sorted by timestamp) */
+      __publicField(this, "sortedTxs", []);
+      /** O(1) existence check and lookup */
+      __publicField(this, "sortedTxsMap", /* @__PURE__ */ new Map());
+      /**
+       * Index of the last transaction applied to cachedState.
+       * - null: state needs full recalculation from checkpoint
+       * - -1: no transactions have been applied yet (state === checkpoint state)
+       * - >= 0: transactions up to and including this index have been applied
+       */
+      __publicField(this, "lastAppliedIndex", null);
+      /** The cached calculated state */
+      __publicField(this, "cachedState", null);
+      /** The base checkpoint to calculate state from */
+      __publicField(this, "baseCheckpoint", null);
+      /**
+       * Applied dedup keys - tracks which LOGICAL txs have been applied.
+       * This is the originalTxKey (or physical key if no original) for each applied tx.
+       * Used to properly deduplicate re-emits.
+       */
+      __publicField(this, "appliedTxKeys", /* @__PURE__ */ new Set());
+      /** Max clock seen from any transaction (for Lamport clock updates) */
+      __publicField(this, "maxSeenClock", 0);
+      /** Validation function (optional) */
+      __publicField(this, "validateFn");
+      this.validateFn = validateFn;
+    }
+    /**
+     * Sets the base checkpoint. Invalidates cached state if checkpoint changed.
+     * @returns true if the checkpoint changed
+     */
+    setBaseCheckpoint(checkpoint) {
+      if (checkpoint === this.baseCheckpoint) {
+        return false;
+      }
+      this.baseCheckpoint = checkpoint;
+      this.invalidate();
+      return true;
+    }
+    /**
+     * Gets the current base checkpoint.
+     */
+    getBaseCheckpoint() {
+      return this.baseCheckpoint;
+    }
+    /**
+     * Clears all transactions and rebuilds from yTx map.
+     * This is used when the checkpoint changes and we need a fresh start.
+     */
+    rebuildFromYjs(yTx) {
+      this.sortedTxs = [];
+      this.sortedTxsMap.clear();
+      for (const key of yTx.keys()) {
+        const entry = new SortedTxEntry(key, yTx);
+        this.sortedTxs.push(entry);
+        this.sortedTxsMap.set(entry.txTimestampKey, entry);
+        if (entry.txTimestamp.clock > this.maxSeenClock) {
+          this.maxSeenClock = entry.txTimestamp.clock;
+        }
+      }
+      this.sortedTxs.sort((a, b) => compareTxTimestamps(a.txTimestamp, b.txTimestamp));
+      this.invalidate();
+    }
+    /**
+     * Inserts a transaction into the sorted cache.
+     * Invalidates cached state if the transaction was inserted before the calculated slice.
+     *
+     * @returns true if this caused invalidation (out-of-order insert)
+     */
+    insertTx(key, yTx) {
+      if (this.sortedTxsMap.has(key)) {
+        return false;
+      }
+      const entry = new SortedTxEntry(key, yTx);
+      const ts = entry.txTimestamp;
+      if (ts.clock > this.maxSeenClock) {
+        this.maxSeenClock = ts.clock;
+      }
+      const sortedTxs = this.sortedTxs;
+      let insertIndex = sortedTxs.length;
+      for (let i = sortedTxs.length - 1; i >= 0; i--) {
+        const existingTs = sortedTxs[i].txTimestamp;
+        if (compareTxTimestamps(ts, existingTs) >= 0) {
+          insertIndex = i + 1;
+          break;
+        }
+        if (i === 0) {
+          insertIndex = 0;
+        }
+      }
+      sortedTxs.splice(insertIndex, 0, entry);
+      this.sortedTxsMap.set(key, entry);
+      if (this.lastAppliedIndex !== null && insertIndex <= this.lastAppliedIndex) {
+        this.invalidate();
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Removes multiple transactions from the sorted cache.
+     * @returns the number of keys that were actually removed
+     */
+    removeTxs(keys) {
+      if (keys.length === 0) return 0;
+      let removedCount = 0;
+      let minRemovedIndex = Number.POSITIVE_INFINITY;
+      const toDelete = /* @__PURE__ */ new Set();
+      for (const key of keys) {
+        const entry = this.sortedTxsMap.get(key);
+        if (entry) {
+          this.sortedTxsMap.delete(key);
+          toDelete.add(key);
+          const index = this.sortedTxs.indexOf(entry);
+          if (index !== -1 && index < minRemovedIndex) {
+            minRemovedIndex = index;
+          }
+        }
+      }
+      if (toDelete.size === 0) return 0;
+      const sortedTxs = this.sortedTxs;
+      let i = 0;
+      while (i < sortedTxs.length && toDelete.size > 0) {
+        if (toDelete.has(sortedTxs[i].txTimestampKey)) {
+          toDelete.delete(sortedTxs[i].txTimestampKey);
+          sortedTxs.splice(i, 1);
+          removedCount++;
+        } else {
+          i++;
+        }
+      }
+      if (this.lastAppliedIndex !== null && minRemovedIndex <= this.lastAppliedIndex) {
+        this.invalidate();
+      }
+      return removedCount;
+    }
+    /**
+     * Checks if a transaction key exists in the cache.
+     */
+    hasTx(key) {
+      return this.sortedTxsMap.has(key);
+    }
+    /**
+     * Gets a transaction entry by key.
+     */
+    getTx(key) {
+      return this.sortedTxsMap.get(key);
+    }
+    /**
+     * Gets all sorted transaction entries.
+     */
+    getSortedTxs() {
+      return this.sortedTxs;
+    }
+    /**
+     * Gets the number of transactions in the cache.
+     */
+    get txCount() {
+      return this.sortedTxs.length;
+    }
+    /**
+     * Returns true if the state needs full recalculation.
+     */
+    needsFullRecalculation() {
+      return this.lastAppliedIndex === null;
+    }
+    /**
+     * Invalidates the cached state, forcing a full recalculation on next calculateState().
+     * Note: cachedState is kept so computeReconcileOps can diff old vs new state.
+     */
+    invalidate() {
+      this.lastAppliedIndex = null;
+    }
+    /**
+     * Calculates and returns the current state, along with a lazy getter for ops that changed from the previous state.
+     *
+     * - If lastAppliedIndex is null: full recalculation from checkpoint
+     * - If lastAppliedIndex >= -1: incremental apply from lastAppliedIndex + 1
+     */
+    calculateState() {
+      var _a, _b, _c, _d;
+      const baseState = (_b = (_a = this.baseCheckpoint) == null ? void 0 : _a.state) != null ? _b : {};
+      const watermarks = (_d = (_c = this.baseCheckpoint) == null ? void 0 : _c.watermarks) != null ? _d : {};
+      const hasWatermarks = Object.keys(watermarks).length > 0;
+      if (this.lastAppliedIndex === null) {
+        return this.fullRecalculation(baseState, watermarks, hasWatermarks);
+      }
+      return this.incrementalApply(watermarks, hasWatermarks);
+    }
+    /**
+     * Full recalculation of state from the base checkpoint.
+     */
+    fullRecalculation(baseState, watermarks, hasWatermarks) {
+      var _a;
+      const oldState = (_a = this.cachedState) != null ? _a : {};
+      this.appliedTxKeys.clear();
+      this.lastAppliedIndex = -1;
+      this.cachedState = baseState;
+      const { state } = this.incrementalApply(watermarks, hasWatermarks, false);
+      const getAppliedOps = lazy(() => computeReconcileOps(oldState, state));
+      return { state, getAppliedOps };
+    }
+    /**
+     * Incremental apply of transactions from lastAppliedIndex + 1.
+     * @param returnOps If true, collects applied transactions (to lazy compute ops). If false, skips collection.
+     */
+    incrementalApply(watermarks, hasWatermarks, returnOps = true) {
+      let state = this.cachedState;
+      const appliedTxs = [];
+      const sortedTxs = this.sortedTxs;
+      const startIndex = this.lastAppliedIndex + 1;
+      for (let i = startIndex; i < sortedTxs.length; i++) {
+        const entry = sortedTxs[i];
+        const dedupKey = entry.dedupTxTimestampKey;
+        if (this.appliedTxKeys.has(dedupKey)) {
+          continue;
+        }
+        if (hasWatermarks) {
+          const dedupTs = entry.dedupTxTimestamp;
+          if (isTransactionInCheckpoint(dedupTs, watermarks)) {
+            this.appliedTxKeys.add(dedupKey);
+            continue;
+          }
+        }
+        const tx = entry.txRecord;
+        const newState = applyTxImmutable(state, tx, this.validateFn);
+        if (newState !== state) {
+          state = newState;
+          if (returnOps) {
+            appliedTxs.push(tx);
+          }
+        }
+        this.appliedTxKeys.add(dedupKey);
+        this.lastAppliedIndex = i;
+      }
+      if (sortedTxs.length > 0 && this.lastAppliedIndex < sortedTxs.length - 1) {
+        this.lastAppliedIndex = sortedTxs.length - 1;
+      }
+      this.cachedState = state;
+      const getAppliedOps = lazy(() => {
+        const ops = [];
+        for (const tx of appliedTxs) {
+          ops.push(...tx.ops);
+        }
+        return ops;
+      });
+      return { state, getAppliedOps };
+    }
+    /**
+     * Gets the max seen clock (for Lamport clock updates).
+     */
+    getMaxSeenClock() {
+      return this.maxSeenClock;
+    }
+    /**
+     * Gets the current cached state without recalculating.
+     * Returns null if state has never been calculated.
+     */
+    getCachedState() {
+      return this.cachedState;
+    }
+    /**
+     * Gets the last applied timestamp.
+     */
+    getLastAppliedTs() {
+      var _a, _b;
+      if (this.lastAppliedIndex === null || this.lastAppliedIndex < 0) {
+        return null;
+      }
+      return (_b = (_a = this.sortedTxs[this.lastAppliedIndex]) == null ? void 0 : _a.txTimestamp) != null ? _b : null;
+    }
+    /**
+     * Gets the last applied index (for debugging/tracking).
+     */
+    getLastAppliedIndex() {
+      return this.lastAppliedIndex;
+    }
+  }
+  function createClientState(validateFn, retentionWindowMs) {
+    return {
+      localClock: 0,
+      cachedFinalizedEpoch: null,
+      // Will be recalculated on first run
+      stateCalculator: new StateCalculator(validateFn),
+      retentionWindowMs
+    };
+  }
+  function appendTx(ops, yTx, activeEpoch, myClientId, clientState, originalKey) {
+    const calc = clientState.stateCalculator;
+    const clock = Math.max(clientState.localClock, calc.getMaxSeenClock()) + 1;
+    clientState.localClock = clock;
+    const ts = {
+      epoch: activeEpoch,
+      clock,
+      clientId: myClientId,
+      wallClock: Date.now()
+    };
+    const key = txTimestampToKey(ts);
+    const record = { ops, originalTxKey: originalKey };
+    yTx.set(key, record);
+    return key;
+  }
+  function syncLog(yTx, myClientId, clientState, finalizedEpoch, baseCP, newKeys) {
+    var _a, _b;
+    const calc = clientState.stateCalculator;
+    const activeEpoch = finalizedEpoch + 1;
+    const watermarks = (_a = baseCP == null ? void 0 : baseCP.watermarks) != null ? _a : {};
+    const referenceTime = (_b = baseCP == null ? void 0 : baseCP.minWallClock) != null ? _b : 0;
+    const shouldPrune = (ts, dedupTs) => {
+      const isAncient = referenceTime - ts.wallClock > clientState.retentionWindowMs;
+      if (isAncient) return true;
+      return isTransactionInCheckpoint(dedupTs, watermarks);
+    };
+    const toDelete = [];
+    const toReEmit = [];
+    const processEntry = (entry) => {
+      if (shouldPrune(entry.txTimestamp, entry.dedupTxTimestamp)) {
+        toDelete.push(entry.txTimestampKey);
+        return false;
+      }
+      if (entry.txTimestamp.epoch <= finalizedEpoch) {
+        toReEmit.push({ originalKey: entry.dedupTxTimestampKey, tx: entry.txRecord });
+        toDelete.push(entry.txTimestampKey);
+        return false;
+      }
+      return true;
+    };
+    for (const entry of calc.getSortedTxs()) {
+      if (processEntry(entry)) {
+        break;
+      }
+    }
+    const processKeyByTimestampKey = (txTimestampKey) => {
+      if (yTx.has(txTimestampKey)) {
+        processEntry(new SortedTxEntry(txTimestampKey, yTx));
+      }
+    };
+    if (newKeys) {
+      for (const key of newKeys) {
+        processKeyByTimestampKey(key);
+      }
+    }
+    for (const { originalKey, tx } of toReEmit) {
+      const newKey = appendTx(tx.ops, yTx, activeEpoch, myClientId, clientState, originalKey);
+      calc.insertTx(newKey, yTx);
+    }
+    for (const key of toDelete) {
+      yTx.delete(key);
+    }
+    calc.removeTxs(toDelete);
+  }
+  function updateState(doc, yTx, yCheckpoint, myClientId, clientState, txChanges) {
+    const calc = clientState.stateCalculator;
+    const { finalizedEpoch, checkpoint: baseCP } = getFinalizedEpochAndCheckpoint(yCheckpoint);
+    clientState.cachedFinalizedEpoch = finalizedEpoch;
+    calc.setBaseCheckpoint(baseCP);
+    const needsRebuildSortedCache = calc.getCachedState() === null || !txChanges;
+    if (needsRebuildSortedCache) {
+      calc.rebuildFromYjs(yTx);
+    } else {
+      calc.removeTxs(txChanges.deleted);
+    }
+    doc.transact(() => {
+      syncLog(yTx, myClientId, clientState, finalizedEpoch, baseCP, txChanges == null ? void 0 : txChanges.added);
+      pruneCheckpoints(yCheckpoint, finalizedEpoch);
+    });
+    if (needsRebuildSortedCache) {
+      return calc.calculateState();
+    }
+    for (const key of txChanges.added) {
+      if (yTx.has(key) && !calc.hasTx(key)) {
+        calc.insertTx(key, yTx);
+      }
+    }
+    return calc.calculateState();
+  }
+  const getSortedTxsSymbol = /* @__PURE__ */ Symbol("getSortedTxs");
+  function createStateSyncLog(options) {
+    const {
+      yDoc,
+      yTxMapName = "state-sync-log-tx",
+      yCheckpointMapName = "state-sync-log-checkpoint",
+      clientId = generateID(),
+      yjsOrigin,
+      validate,
+      retentionWindowMs
+    } = options;
+    if (clientId.includes(";")) {
+      failure(`clientId MUST NOT contain semicolons: ${clientId}`);
+    }
+    const yTx = yDoc.getMap(yTxMapName);
+    const yCheckpoint = yDoc.getMap(yCheckpointMapName);
+    const clientState = createClientState(
+      validate,
+      retentionWindowMs != null ? retentionWindowMs : Number.POSITIVE_INFINITY
+    );
+    const subscribers = /* @__PURE__ */ new Set();
+    const notifySubscribers = (state, getAppliedOps) => {
+      for (const sub of subscribers) {
+        sub(state, getAppliedOps);
+      }
+    };
+    const extractTxChanges = (event) => {
+      const added = [];
+      const deleted = [];
+      for (const [key, change] of event.changes.keys) {
+        if (change.action === "add") {
+          added.push(key);
+        } else if (change.action === "delete") {
+          deleted.push(key);
+        } else if (change.action === "update") {
+          deleted.push(key);
+          added.push(key);
+        }
+      }
+      return { added, deleted };
+    };
+    const emptyTxChanges = { added: [], deleted: [] };
+    const runUpdate = (txChanges) => {
+      const { state, getAppliedOps } = updateState(
+        yDoc,
+        yTx,
+        yCheckpoint,
+        clientId,
+        clientState,
+        txChanges
+      );
+      notifySubscribers(state, getAppliedOps);
+    };
+    const txObserver = (event, _transaction) => {
+      const txChanges = extractTxChanges(event);
+      runUpdate(txChanges);
+    };
+    const checkpointObserver = (_event, _transaction) => {
+      runUpdate(emptyTxChanges);
+    };
+    yCheckpoint.observe(checkpointObserver);
+    yTx.observe(txObserver);
+    runUpdate(void 0);
+    let disposed = false;
+    const assertNotDisposed = () => {
+      if (disposed) {
+        failure("StateSyncLog has been disposed and cannot be used");
+      }
+    };
+    const getActiveEpochInternal = () => {
+      if (clientState.cachedFinalizedEpoch === null) {
+        failure("cachedFinalizedEpoch is null - this should not happen after initialization");
+      }
+      return clientState.cachedFinalizedEpoch + 1;
+    };
+    return {
+      getState() {
+        var _a;
+        assertNotDisposed();
+        return (_a = clientState.stateCalculator.getCachedState()) != null ? _a : {};
+      },
+      subscribe(callback) {
+        assertNotDisposed();
+        subscribers.add(callback);
+        return () => {
+          subscribers.delete(callback);
+        };
+      },
+      emit(ops) {
+        assertNotDisposed();
+        yDoc.transact(() => {
+          const activeEpoch = getActiveEpochInternal();
+          appendTx(ops, yTx, activeEpoch, clientId, clientState);
+        }, yjsOrigin);
+      },
+      reconcileState(targetState) {
+        var _a;
+        assertNotDisposed();
+        const currentState = (_a = clientState.stateCalculator.getCachedState()) != null ? _a : {};
+        const ops = computeReconcileOps(currentState, targetState);
+        if (ops.length > 0) {
+          this.emit(ops);
+        }
+      },
+      compact() {
+        assertNotDisposed();
+        yDoc.transact(() => {
+          var _a;
+          const activeEpoch = getActiveEpochInternal();
+          const currentState = (_a = clientState.stateCalculator.getCachedState()) != null ? _a : {};
+          createCheckpoint(yTx, yCheckpoint, clientState, activeEpoch, currentState, clientId);
+        }, yjsOrigin);
+      },
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        yTx.unobserve(txObserver);
+        yCheckpoint.unobserve(checkpointObserver);
+        subscribers.clear();
+      },
+      getActiveEpoch() {
+        assertNotDisposed();
+        return getActiveEpochInternal();
+      },
+      getActiveEpochTxCount() {
+        assertNotDisposed();
+        const activeEpoch = getActiveEpochInternal();
+        let count = 0;
+        for (const entry of clientState.stateCalculator.getSortedTxs()) {
+          const ts = entry.txTimestamp;
+          if (ts.epoch === activeEpoch) {
+            count++;
+          } else if (ts.epoch > activeEpoch) {
+            break;
+          }
+        }
+        return count;
+      },
+      getActiveEpochStartTime() {
+        assertNotDisposed();
+        const activeEpoch = getActiveEpochInternal();
+        for (const entry of clientState.stateCalculator.getSortedTxs()) {
+          const ts = entry.txTimestamp;
+          if (ts.epoch === activeEpoch) {
+            return ts.wallClock;
+          } else if (ts.epoch > activeEpoch) {
+            break;
+          }
+        }
+        return void 0;
+      },
+      isLogEmpty() {
+        assertNotDisposed();
+        return yTx.size === 0 && yCheckpoint.size === 0;
+      },
+      [getSortedTxsSymbol]() {
+        assertNotDisposed();
+        return clientState.stateCalculator.getSortedTxs();
+      }
+    };
+  }
+  function resolvePath(state, path) {
+    let current = state;
+    for (const segment of path) {
+      if (typeof segment === "string") {
+        if (!isObject(current) || Array.isArray(current)) {
+          failure(`Expected object at path segment "${segment}"`);
+        }
+        if (!(segment in current)) {
+          failure(`Property "${segment}" does not exist`);
+        }
+        current = current[segment];
+      } else {
+        if (!Array.isArray(current)) {
+          failure(`Expected array at path segment ${segment}`);
+        }
+        if (segment < 0 || segment >= current.length) {
+          failure(`Index ${segment} out of bounds`);
+        }
+        current = current[segment];
+      }
+    }
+    return current;
+  }
+  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");
+        }
+        container[op.key] = cloneValues ? deepClone(op.value) : op.value;
+        break;
+      case "delete":
+        if (!isObject(container) || Array.isArray(container)) {
+          failure("delete requires object container");
+        }
+        delete container[op.key];
+        break;
+      case "splice": {
+        if (!Array.isArray(container)) {
+          failure("splice requires array container");
+        }
+        const safeIndex = Math.min(op.index, container.length);
+        container.splice(
+          safeIndex,
+          op.deleteCount,
+          ...cloneValues ? op.inserts.map((v) => deepClone(v)) : op.inserts
+        );
+        break;
+      }
+      case "addToSet":
+        if (!Array.isArray(container)) {
+          failure("addToSet requires array container");
+        }
+        if (!container.some((item) => deepEqual(item, op.value))) {
+          container.push(cloneValues ? deepClone(op.value) : op.value);
+        }
+        break;
+      case "deleteFromSet":
+        if (!Array.isArray(container)) {
+          failure("deleteFromSet requires array container");
+        }
+        for (let i = container.length - 1; i >= 0; i--) {
+          if (deepEqual(container[i], op.value)) {
+            container.splice(i, 1);
+          }
+        }
+        break;
+      default:
+        throw failure(`Unknown operation kind: ${op.kind}`);
+    }
+  }
+  function applyOps(ops, target, options) {
+    var _a;
+    const cloneValues = (_a = options == null ? void 0 : options.cloneValues) != null ? _a : true;
+    for (const op of ops) {
+      applyOp(target, op, cloneValues);
+    }
+  }
+  exports2.applyOps = applyOps;
+  exports2.createStateSyncLog = createStateSyncLog;
+  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":";;;;;;;AAYO,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;AAAA,EC3CO,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;ACyCA,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;;;;;;;;;ACzMA,oBAAiB,SAASA,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;ACxBO,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,UAAMA,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,QAAI,UAAoC,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,QAAQ,OAAO,GAAG;AAC3B,kBAAQ,kCAAkC,OAAO,EAAE;AAAA,QACrD;AACA,YAAI,UAAU,KAAK,WAAW,QAAQ,QAAQ;AAC5C,kBAAQ,SAAS,OAAO,gBAAgB;AAAA,QAC1C;AAAA,MACF,OAAO;AACL,YAAI,CAAC,SAAS,OAAO,KAAK,MAAM,QAAQ,OAAO,GAAG;AAChD,kBAAQ,oCAAoC,OAAO,GAAG;AAAA,QACxD;AACA,YAAI,EAAE,WAAW,UAAU;AACzB,kBAAQ,aAAa,OAAO,kBAAkB;AAAA,QAChD;AAAA,MACF;AAEA,YAAM,QAAoB,QAAgB,OAAO;AAGjD,UAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAC/C,gBAAQ,qDAAqD,OAAO,EAAE;AAAA,MACxE;AAGA,gBAAU,YAAY,KAAK,SAAS,SAAS,KAAiC;AAAA,IAChF;AAEA,WAAO;AAAA,EACT;AAKO,WAAS,SACd,KACA,MACA,KACA,OACM;AACN,UAAM,YAAY,gBAAgB,KAAK,IAAI;AAC3C,QAAI,MAAM,QAAQ,SAAS,GAAG;AAC5B,cAAQ,+BAA+B;AAAA,IACzC;AACE,cAAyB,GAAG,IAAI;AAAA,EACpC;AAKO,WAAS,YACd,KACA,MACA,KACM;AACN,UAAM,YAAY,gBAAgB,KAAK,IAAI;AAC3C,QAAI,MAAM,QAAQ,SAAS,GAAG;AAC5B,cAAQ,kCAAkC;AAAA,IAC5C;AACA,WAAQ,UAAyB,GAAG;AAAA,EACtC;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;ACvRO,WAAS,oBAAoB,cAAyB,aAA8B;AACzF,UAAM,MAAY,CAAA;AAClB,cAAU,cAAc,aAAa,CAAA,GAAI,GAAG;AAC5C,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,SAAoB,QAAmB,MAAY,KAAiB;AAErF,QAAI,YAAY,OAAQ;AAGxB,UAAM,cAAc,OAAO;AAC3B,UAAM,aAAa,OAAO;AAE1B,QAAI,YAAY,QAAQ,WAAW,QAAQ,gBAAgB,YAAY,eAAe,UAAU;AAE9F,kBAAY,MAAM,QAAQ,GAAG;AAC7B;AAAA,IACF;AAGA,UAAM,iBAAiB,MAAM,QAAQ,OAAO;AAC5C,UAAM,gBAAgB,MAAM,QAAQ,MAAM;AAE1C,QAAI,mBAAmB,eAAe;AAEpC,kBAAY,MAAM,QAAQ,GAAG;AAC7B;AAAA,IACF;AAEA,QAAI,gBAAgB;AAClB,gBAAU,SAAS,QAAuB,MAAM,GAAG;AAAA,IACrD,OAAO;AACL,iBAAW,SAAuB,QAAsB,MAAM,GAAG;AAAA,IACnE;AAAA,EACF;AAEA,WAAS,WAAW,SAAqB,QAAoB,MAAY,KAAiB;AAExF,eAAW,OAAO,SAAS;AACzB,UAAI,OAAO,OAAO,SAAS,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,OAAO,SAAS,GAAG,GAAG;AAChC,cAAI,KAAK,EAAE,MAAM,OAAO,MAAM,KAAK,OAAO,WAAW;AAAA,QACvD,WAAW,QAAQ,GAAG,MAAM,WAAW;AAErC,oBAAU,QAAQ,GAAG,GAAG,WAAW,CAAC,GAAG,MAAM,GAAG,GAAG,GAAG;AAAA,QACxD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,WAAS,UAAU,SAAsB,QAAqB,MAAY,KAAiB;AACzF,UAAM,aAAa,QAAQ;AAC3B,UAAM,YAAY,OAAO;AACzB,UAAM,SAAS,aAAa,YAAY,aAAa;AAGrD,aAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,UAAI,QAAQ,CAAC,MAAM,OAAO,CAAC,GAAG;AAC5B,kBAAU,QAAQ,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,QAAI,UAAqB;AACzB,eAAW,WAAW,MAAM;AAC1B,UAAI,OAAO,YAAY,UAAU;AAC/B,YAAI,CAAC,SAAS,OAAO,KAAK,MAAM,QAAQ,OAAO,GAAG;AAChD,kBAAQ,oCAAoC,OAAO,GAAG;AAAA,QACxD;AACA,YAAI,EAAE,WAAW,UAAU;AACzB,kBAAQ,aAAa,OAAO,kBAAkB;AAAA,QAChD;AACA,kBAAU,QAAQ,OAAO;AAAA,MAC3B,OAAO;AACL,YAAI,CAAC,MAAM,QAAQ,OAAO,GAAG;AAC3B,kBAAQ,kCAAkC,OAAO,EAAE;AAAA,QACrD;AACA,YAAI,UAAU,KAAK,WAAW,QAAQ,QAAQ;AAC5C,kBAAQ,SAAS,OAAO,gBAAgB;AAAA,QAC1C;AACA,kBAAU,QAAQ,OAAO;AAAA,MAC3B;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAMA,WAAS,QAAQ,OAAmB,IAAQ,aAA4B;AAUtE,UAAM,YAAY,YAAY,OAAO,GAAG,IAAI;AAE5C,YAAQ,GAAG,MAAA;AAAA,MACT,KAAK;AACH,YAAI,CAAC,SAAS,SAAS,KAAK,MAAM,QAAQ,SAAS,GAAG;AACpD,kBAAQ,+BAA+B;AAAA,QACzC;AAEE,kBAAkB,GAAG,GAAG,IAAI,cAAc,UAAU,GAAG,KAAK,IAAI,GAAG;AACrE;AAAA,MAEF,KAAK;AACH,YAAI,CAAC,SAAS,SAAS,KAAK,MAAM,QAAQ,SAAS,GAAG;AACpD,kBAAQ,kCAAkC;AAAA,QAC5C;AAEA,eAAQ,UAAkB,GAAG,GAAG;AAChC;AAAA,MAEF,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":[3,4,5,6]}