state-sync-log 0.9.0

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

@@ -0,0 +1,1339 @@
+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);
+  }
+}
+export {
+  applyOps,
+  createStateSyncLog
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"state-sync-log.esm.mjs","sources":["../src/checkpointUtils.ts","../src/error.ts","../src/checkpoints.ts","../../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js","../../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js","../../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.browser.js","../../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js","../src/utils.ts","../src/draft.ts","../src/reconcile.ts","../src/txTimestamp.ts","../src/SortedTxEntry.ts","../src/StateCalculator.ts","../src/clientState.ts","../src/txLog.ts","../src/createStateSyncLog.ts","../src/operations.ts"],"sourcesContent":["import * as Y from \"yjs\"\nimport { type CheckpointRecord, parseCheckpointKey } from \"./checkpoints\"\n\n/**\n * Determines the finalized epoch and its canonical checkpoint in a single pass.\n *\n * Policy A: The finalized epoch is the most recent epoch with a checkpoint.\n * Canonical checkpoint: The checkpoint with highest txCount for that epoch\n * (tie-break: lowest clientId alphabetically).\n *\n * Returns { finalizedEpoch: -1, checkpoint: null } if no checkpoints exist.\n */\nexport function getFinalizedEpochAndCheckpoint(yCheckpoint: Y.Map<CheckpointRecord>): {\n  finalizedEpoch: number\n  checkpoint: CheckpointRecord | null\n} {\n  let maxEpoch = -1\n  let best: CheckpointRecord | null = null\n  let bestTxCount = -1\n  let bestClientId = \"\"\n\n  for (const [key, cp] of yCheckpoint.entries()) {\n    const { epoch, clientId } = parseCheckpointKey(key)\n\n    if (epoch > maxEpoch) {\n      // New highest epoch - reset best checkpoint tracking\n      maxEpoch = epoch\n      best = cp\n      bestTxCount = cp.txCount\n      bestClientId = clientId\n    } else if (epoch === maxEpoch) {\n      // Same epoch - check if this is a better canonical checkpoint\n      // Primary: higher txCount wins\n      // Secondary (tie-break): lower clientId (alphabetically) wins\n      if (cp.txCount > bestTxCount || (cp.txCount === bestTxCount && clientId < bestClientId)) {\n        best = cp\n        bestTxCount = cp.txCount\n        bestClientId = clientId\n      }\n    }\n  }\n\n  return { finalizedEpoch: maxEpoch, checkpoint: best }\n}\n","export class StateSyncLogError extends Error {\n  constructor(msg: string) {\n    super(msg)\n\n    // Set the prototype explicitly for better instanceof support\n    Object.setPrototypeOf(this, StateSyncLogError.prototype)\n  }\n}\n\nexport function failure(message: string): never {\n  throw new StateSyncLogError(message)\n}\n","import * as Y from \"yjs\"\nimport { ClientId } from \"./ClientId\"\nimport { getFinalizedEpochAndCheckpoint } from \"./checkpointUtils\"\nimport { ClientState } from \"./clientState\"\nimport { failure } from \"./error\"\nimport { JSONObject } from \"./json\"\nimport { TxRecord } from \"./TxRecord\"\nimport { TxTimestampKey } from \"./txTimestamp\"\n\n/**\n * Watermarking for deduplication and pruning.\n * - maxClock: All txs from this client with clock <= maxClock are FINALIZED.\n * - maxWallClock: The last time we saw this client active (for pruning).\n */\ntype ClientWatermark = Readonly<{\n  maxClock: number\n  maxWallClock: number\n}>\n\n/**\n * Watermarks for all clients.\n */\nexport type ClientWatermarks = Record<ClientId, ClientWatermark>\n\n/**\n * A snapshot of the state at the end of a specific epoch.\n */\nexport type CheckpointRecord = {\n  state: JSONObject // The document state\n  watermarks: ClientWatermarks // Dedup/Pruning info\n  txCount: number // Tie-breaker for canonical selection\n  minWallClock: number // Reference time for this epoch (deterministic pruning)\n}\n\n/**\n * Unique ID for a checkpoint.\n * Format: `${epoch};${txCount};${clientId}`\n */\nexport type CheckpointKey = string\n\n/**\n * Data extracted from a checkpoint key.\n */\nexport type CheckpointKeyData = {\n  epoch: number\n  txCount: number\n  clientId: ClientId\n}\n\n/**\n * Converts checkpoint key data components to a key string.\n */\nfunction checkpointKeyDataToKey(data: CheckpointKeyData): CheckpointKey {\n  return `${data.epoch};${data.txCount};${data.clientId}`\n}\n\n/**\n * Helper to parse checkpoint keys.\n * Checkpoint keys have format: `${epoch};${txCount};${clientId}`\n * Throws if key is malformed.\n */\nexport function parseCheckpointKey(key: CheckpointKey): CheckpointKeyData {\n  const i1 = key.indexOf(\";\")\n  const i2 = key.indexOf(\";\", i1 + 1)\n\n  if (i1 === -1 || i2 === -1) {\n    failure(`Malformed checkpoint key: ${key}`)\n  }\n\n  return {\n    epoch: Number.parseInt(key.substring(0, i1), 10),\n    txCount: Number.parseInt(key.substring(i1 + 1, i2), 10),\n    clientId: key.substring(i2 + 1),\n  }\n}\n\n/**\n * Called periodically (e.g. by a server or leader client) to finalize the epoch.\n */\nexport function createCheckpoint(\n  yTx: Y.Map<TxRecord>,\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  clientState: ClientState,\n  activeEpoch: number,\n  currentState: JSONObject,\n  myClientId: string\n): void {\n  // 1. Start with previous watermarks (from finalized epoch = activeEpoch - 1)\n  const { checkpoint: prevCP } = getFinalizedEpochAndCheckpoint(yCheckpoint)\n  const newWatermarks = prevCP ? { ...prevCP.watermarks } : {}\n\n  // Get active txs using cached sorted order (filter by epoch)\n  // FILTER IS REQUIRED:\n  // Although we are finalizing 'activeEpoch', other peers may have already\n  // advanced to the next epoch and started syncing those txs.\n  // We must ensure this checkpoint ONLY contains txs from 'activeEpoch'.\n  // Using stateCalculator.getSortedTxs avoids redundant key parsing (timestamps are cached).\n  //\n  // OPTIMIZATION: Since sortedTxs is sorted by epoch (primary key) and past epochs\n  // are pruned, we only need to find the right boundary. Future epochs are rare,\n  // so a simple linear search from the right is efficient (typically 0-1 iterations).\n  const sortedTxs = clientState.stateCalculator.getSortedTxs()\n\n  // Find end boundary by searching from right (skip any future epoch entries)\n  let endIndex = sortedTxs.length\n  while (endIndex > 0 && sortedTxs[endIndex - 1].txTimestamp.epoch > activeEpoch) {\n    endIndex--\n  }\n\n  // Slice from start to endIndex (past epochs are pruned, so these are all activeEpoch)\n  const activeTxs = sortedTxs.slice(0, endIndex)\n\n  if (activeTxs.length === 0) {\n    return // Do nothing if no txs (prevents empty epochs)\n  }\n\n  // 2. Update watermarks based on OBSERVED active txs and calculate minWallClock\n  // NOTE: We cannot use activeTxs[0].txTimestamp.wallClock for minWallClock because\n  // txs are sorted by Lamport clock (epoch → clock → clientId), not by wallClock.\n  // A client may have a high Lamport clock but early wallClock due to clock drift\n  // or receiving many messages before emitting.\n  let minWallClock = Number.POSITIVE_INFINITY\n  let txCount = 0\n  for (const entry of activeTxs) {\n    const ts = entry.txTimestamp\n\n    // Track min wallClock for deterministic pruning reference\n    if (ts.wallClock < minWallClock) {\n      minWallClock = ts.wallClock\n    }\n\n    const newWm = newWatermarks[ts.clientId]\n      ? { ...newWatermarks[ts.clientId] }\n      : { maxClock: -1, maxWallClock: 0 }\n\n    if (ts.clock > newWm.maxClock) {\n      newWm.maxClock = ts.clock\n      newWm.maxWallClock = ts.wallClock\n    }\n    newWatermarks[ts.clientId] = newWm\n    txCount++\n  }\n\n  // 3. Prune Inactive Watermarks (Deterministic)\n  // Uses minWallClock so all clients agree on exactly who to prune.\n  for (const clientId in newWatermarks) {\n    if (minWallClock - newWatermarks[clientId].maxWallClock > clientState.retentionWindowMs) {\n      delete newWatermarks[clientId]\n    }\n  }\n\n  // 4. Save Checkpoint\n  const cpKey = checkpointKeyDataToKey({\n    epoch: activeEpoch,\n    txCount,\n    clientId: myClientId,\n  })\n  yCheckpoint.set(cpKey, {\n    state: currentState, // Responsibility for cloning is moved to the caller if needed\n    watermarks: newWatermarks,\n    txCount,\n    minWallClock,\n  })\n\n  // 5. Early tx pruning (Optimization)\n  // Delete all txs from the now-finalized epoch\n  // This reduces memory pressure instead of waiting for cleanupLog\n  const keysToDelete: TxTimestampKey[] = []\n  for (const entry of activeTxs) {\n    yTx.delete(entry.txTimestampKey)\n    keysToDelete.push(entry.txTimestampKey)\n  }\n  clientState.stateCalculator.removeTxs(keysToDelete)\n}\n\n/**\n * Garbage collects old checkpoints.\n * Should be called periodically to prevent unbounded growth of yCheckpoint.\n *\n * Keeps only the canonical checkpoint for the finalized epoch.\n * Everything else is deleted (old epochs + non-canonical).\n *\n * Note: The active epoch never has checkpoints - creating a checkpoint\n * for an epoch immediately makes it finalized.\n */\nexport function pruneCheckpoints(\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  finalizedEpoch: number\n): void {\n  // Find the canonical checkpoint and its key in one pass\n  let canonicalKey: CheckpointKey | null = null\n  let bestTxCount = -1\n\n  for (const [key] of yCheckpoint.entries()) {\n    const { epoch, txCount } = parseCheckpointKey(key)\n    if (epoch === finalizedEpoch && txCount > bestTxCount) {\n      canonicalKey = key\n      bestTxCount = txCount\n    }\n  }\n\n  // Delete everything except the canonical checkpoint\n  for (const key of yCheckpoint.keys()) {\n    if (key !== canonicalKey) {\n      yCheckpoint.delete(key)\n    }\n  }\n}\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","export const urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n","/* @ts-self-types=\"./index.d.ts\" */\nimport { urlAlphabet as scopedUrlAlphabet } from './url-alphabet/index.js'\nexport { urlAlphabet } from './url-alphabet/index.js'\nexport let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))\nexport let customRandom = (alphabet, defaultSize, getRandom) => {\n  let mask = (2 << Math.log2(alphabet.length - 1)) - 1\n  let step = -~((1.6 * mask * defaultSize) / alphabet.length)\n  return (size = defaultSize) => {\n    let id = ''\n    while (true) {\n      let bytes = getRandom(step)\n      let j = step | 0\n      while (j--) {\n        id += alphabet[bytes[j] & mask] || ''\n        if (id.length >= size) return id\n      }\n    }\n  }\n}\nexport let customAlphabet = (alphabet, size = 21) =>\n  customRandom(alphabet, size | 0, random)\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)))\n  while (size--) {\n    id += scopedUrlAlphabet[bytes[size] & 63]\n  }\n  return id\n}\n","'use strict'\nmodule.exports = rfdc\n\nfunction copyBuffer (cur) {\n  if (cur instanceof Buffer) {\n    return Buffer.from(cur)\n  }\n\n  return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length)\n}\n\nfunction rfdc (opts) {\n  opts = opts || {}\n  if (opts.circles) return rfdcCircles(opts)\n\n  const constructorHandlers = new Map()\n  constructorHandlers.set(Date, (o) => new Date(o))\n  constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)))\n  constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)))\n  if (opts.constructorHandlers) {\n    for (const handler of opts.constructorHandlers) {\n      constructorHandlers.set(handler[0], handler[1])\n    }\n  }\n\n  let handler = null\n\n  return opts.proto ? cloneProto : clone\n\n  function cloneArray (a, fn) {\n    const keys = Object.keys(a)\n    const a2 = new Array(keys.length)\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i]\n      const cur = a[k]\n      if (typeof cur !== 'object' || cur === null) {\n        a2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        a2[k] = handler(cur, fn)\n      } else if (ArrayBuffer.isView(cur)) {\n        a2[k] = copyBuffer(cur)\n      } else {\n        a2[k] = fn(cur)\n      }\n    }\n    return a2\n  }\n\n  function clone (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, clone)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, clone)\n    }\n    const o2 = {}\n    for (const k in o) {\n      if (Object.hasOwnProperty.call(o, k) === false) continue\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, clone)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        o2[k] = clone(cur)\n      }\n    }\n    return o2\n  }\n\n  function cloneProto (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, cloneProto)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, cloneProto)\n    }\n    const o2 = {}\n    for (const k in o) {\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, cloneProto)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        o2[k] = cloneProto(cur)\n      }\n    }\n    return o2\n  }\n}\n\nfunction rfdcCircles (opts) {\n  const refs = []\n  const refsNew = []\n\n  const constructorHandlers = new Map()\n  constructorHandlers.set(Date, (o) => new Date(o))\n  constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)))\n  constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)))\n  if (opts.constructorHandlers) {\n    for (const handler of opts.constructorHandlers) {\n      constructorHandlers.set(handler[0], handler[1])\n    }\n  }\n\n  let handler = null\n  return opts.proto ? cloneProto : clone\n\n  function cloneArray (a, fn) {\n    const keys = Object.keys(a)\n    const a2 = new Array(keys.length)\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i]\n      const cur = a[k]\n      if (typeof cur !== 'object' || cur === null) {\n        a2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        a2[k] = handler(cur, fn)\n      } else if (ArrayBuffer.isView(cur)) {\n        a2[k] = copyBuffer(cur)\n      } else {\n        const index = refs.indexOf(cur)\n        if (index !== -1) {\n          a2[k] = refsNew[index]\n        } else {\n          a2[k] = fn(cur)\n        }\n      }\n    }\n    return a2\n  }\n\n  function clone (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, clone)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, clone)\n    }\n    const o2 = {}\n    refs.push(o)\n    refsNew.push(o2)\n    for (const k in o) {\n      if (Object.hasOwnProperty.call(o, k) === false) continue\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, clone)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        const i = refs.indexOf(cur)\n        if (i !== -1) {\n          o2[k] = refsNew[i]\n        } else {\n          o2[k] = clone(cur)\n        }\n      }\n    }\n    refs.pop()\n    refsNew.pop()\n    return o2\n  }\n\n  function cloneProto (o) {\n    if (typeof o !== 'object' || o === null) return o\n    if (Array.isArray(o)) return cloneArray(o, cloneProto)\n    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {\n      return handler(o, cloneProto)\n    }\n    const o2 = {}\n    refs.push(o)\n    refsNew.push(o2)\n    for (const k in o) {\n      const cur = o[k]\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur\n      } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {\n        o2[k] = handler(cur, cloneProto)\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur)\n      } else {\n        const i = refs.indexOf(cur)\n        if (i !== -1) {\n          o2[k] = refsNew[i]\n        } else {\n          o2[k] = cloneProto(cur)\n        }\n      }\n    }\n    refs.pop()\n    refsNew.pop()\n    return o2\n  }\n}\n","import equal from \"fast-deep-equal\"\nimport { nanoid } from \"nanoid\"\nimport rfdc from \"rfdc\"\nimport type { JSONValue } from \"./json\"\n\nconst clone = rfdc({ proto: true })\n\n/**\n * Deep equality check for JSONValues.\n * Used for addToSet / deleteFromSet operations.\n */\nexport function deepEqual(a: JSONValue, b: JSONValue): boolean {\n  return equal(a, b)\n}\n\n/**\n * Generates a unique ID using nanoid.\n */\nexport function generateID(): string {\n  return nanoid()\n}\n\n/**\n * Checks if a value is an object (typeof === \"object\" && !== null).\n */\nexport function isObject(value: unknown): value is object {\n  return value !== null && typeof value === \"object\"\n}\n\n/**\n * Deep clones a JSON-serializable value.\n * Optimized: primitives are returned as-is.\n */\nexport function deepClone<T>(value: T): T {\n  // Primitives don't need cloning\n  if (value === null || typeof value !== \"object\") {\n    return value\n  }\n  return clone(value)\n}\n\n/**\n * Creates a lazy memoized getter.\n */\nexport function lazy<T>(fn: () => T): () => T {\n  let computed = false\n  let value: T\n  return () => {\n    if (!computed) {\n      value = fn()\n      computed = true\n    }\n    return value\n  }\n}\n","import { failure } from \"./error\"\nimport type { JSONObject, JSONRecord, JSONValue, Path } from \"./json\"\nimport type { Op, ValidateFn } from \"./operations\"\nimport { TxRecord } from \"./TxRecord\"\nimport { deepEqual, isObject } from \"./utils\"\n\n/**\n * A draft context for copy-on-write immutable updates.\n *\n * This provides Immer/Mutative-like semantics without the proxy overhead:\n * - The original base state is never mutated\n * - Objects are cloned lazily on first mutation (copy-on-write)\n * - Once an object is cloned (\"owned\"), it can be mutated directly\n * - If no changes are made, the original reference is preserved (structural sharing)\n */\nexport interface DraftContext<T extends JSONObject> {\n  /** The current root (may be the original base or a cloned version) */\n  root: T\n  /** The original base state (never mutated) */\n  base: T\n  /** Set of objects that have been cloned and are safe to mutate */\n  ownedObjects: WeakSet<object>\n  /** Optimization: fast check if root is already owned */\n  isRootOwned: boolean\n}\n\n/**\n * Creates a new draft context from a base state.\n * The base state will never be mutated.\n */\nexport function createDraft<T extends JSONObject>(base: T): DraftContext<T> {\n  return {\n    root: base,\n    base,\n    ownedObjects: new Set(),\n    isRootOwned: false,\n  }\n}\n\n/**\n * Checks if the draft was modified (root !== base).\n */\nexport function isDraftModified<T extends JSONObject>(ctx: DraftContext<T>): boolean {\n  return ctx.root !== ctx.base\n}\n\nfunction shallowClone<T extends object>(obj: T): T {\n  if (Array.isArray(obj)) {\n    return obj.slice() as unknown as T\n  }\n  const clone = {} as T\n  const keys = Object.keys(obj)\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i]\n    ;(clone as any)[key] = (obj as any)[key]\n  }\n  return clone\n}\n\n/**\n * Ensures an object is owned (cloned if necessary) and returns the owned version.\n * Also updates the parent to point to the cloned child.\n */\nfunction ensureOwned<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  parent: JSONObject,\n  key: string | number,\n  child: JSONRecord | JSONValue[]\n): JSONRecord | JSONValue[] {\n  if (ctx.ownedObjects.has(child)) {\n    return child\n  }\n  const cloned = shallowClone(child)\n  ;(parent as any)[key] = cloned\n  ctx.ownedObjects.add(cloned)\n  return cloned\n}\n\n/**\n * Ensures all objects along the path are owned (cloned if necessary).\n * Returns the container at the end of the path.\n * Throws if the path is invalid.\n */\nfunction ensureOwnedPath<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path\n): JSONRecord | JSONValue[] {\n  // Ensure root is owned first\n  if (!ctx.isRootOwned) {\n    ctx.root = shallowClone(ctx.root as unknown as object) as T\n    ctx.ownedObjects.add(ctx.root)\n    ctx.isRootOwned = true\n  }\n\n  if (path.length === 0) {\n    return ctx.root\n  }\n\n  let current: JSONRecord | JSONValue[] = ctx.root\n\n  for (let i = 0; i < path.length; i++) {\n    const segment = path[i]\n    const isArrayIndex = typeof segment === \"number\"\n\n    // Validate container type\n    if (isArrayIndex) {\n      if (!Array.isArray(current)) {\n        failure(`Expected array at path segment ${segment}`)\n      }\n      if (segment < 0 || segment >= current.length) {\n        failure(`Index ${segment} out of bounds`)\n      }\n    } else {\n      if (!isObject(current) || Array.isArray(current)) {\n        failure(`Expected object at path segment \"${segment}\"`)\n      }\n      if (!(segment in current)) {\n        failure(`Property \"${segment}\" does not exist`)\n      }\n    }\n\n    const child: JSONValue = (current as any)[segment]\n\n    // Validate child is traversable\n    if (child === null || typeof child !== \"object\") {\n      failure(`Cannot traverse through primitive at path segment ${segment}`)\n    }\n\n    // Ensure child is owned and continue\n    current = ensureOwned(ctx, current, segment, child as JSONRecord | JSONValue[])\n  }\n\n  return current\n}\n\n/**\n * Applies a single \"set\" operation to the draft with copy-on-write.\n */\nexport function draftSet<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  key: string,\n  value: JSONValue\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (Array.isArray(container)) {\n    failure(\"set requires object container\")\n  }\n  ;(container as JSONRecord)[key] = value\n}\n\n/**\n * Applies a single \"delete\" operation to the draft with copy-on-write.\n */\nexport function draftDelete<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  key: string\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (Array.isArray(container)) {\n    failure(\"delete requires object container\")\n  }\n  delete (container as JSONRecord)[key]\n}\n\n/**\n * Applies a single \"splice\" operation to the draft with copy-on-write.\n */\nexport function draftSplice<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  index: number,\n  deleteCount: number,\n  inserts: readonly JSONValue[]\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (!Array.isArray(container)) {\n    failure(\"splice requires array container\")\n  }\n  const safeIndex = Math.min(index, container.length)\n  if (inserts.length === 0) {\n    container.splice(safeIndex, deleteCount)\n  } else if (inserts.length === 1) {\n    container.splice(safeIndex, deleteCount, inserts[0])\n  } else {\n    container.splice(safeIndex, deleteCount, ...inserts)\n  }\n}\n\n/**\n * Applies a single \"addToSet\" operation to the draft with copy-on-write.\n */\nexport function draftAddToSet<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  value: JSONValue\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (!Array.isArray(container)) {\n    failure(\"addToSet requires array container\")\n  }\n  if (!container.some((item) => deepEqual(item, value))) {\n    container.push(value)\n  }\n}\n\n/**\n * Applies a single \"deleteFromSet\" operation to the draft with copy-on-write.\n */\nexport function draftDeleteFromSet<T extends JSONObject>(\n  ctx: DraftContext<T>,\n  path: Path,\n  value: JSONValue\n): void {\n  const container = ensureOwnedPath(ctx, path)\n  if (!Array.isArray(container)) {\n    failure(\"deleteFromSet requires array container\")\n  }\n  // Remove all matching items (iterate backwards to avoid index shifting)\n  for (let i = container.length - 1; i >= 0; i--) {\n    if (deepEqual(container[i], value)) {\n      container.splice(i, 1)\n    }\n  }\n}\n\n/**\n * Applies a single operation to the draft with copy-on-write.\n */\nexport function applyOpToDraft<T extends JSONObject>(ctx: DraftContext<T>, op: Op): void {\n  switch (op.kind) {\n    case \"set\":\n      draftSet(ctx, op.path, op.key, op.value)\n      break\n    case \"delete\":\n      draftDelete(ctx, op.path, op.key)\n      break\n    case \"splice\":\n      draftSplice(ctx, op.path, op.index, op.deleteCount, op.inserts)\n      break\n    case \"addToSet\":\n      draftAddToSet(ctx, op.path, op.value)\n      break\n    case \"deleteFromSet\":\n      draftDeleteFromSet(ctx, op.path, op.value)\n      break\n    default:\n      throw failure(`Unknown operation kind: ${(op as any).kind}`)\n  }\n}\n\n/**\n * Applies a single transaction to a base state immutably.\n *\n * Key benefits over Mutative/Immer:\n * - No proxy overhead - direct object access and copy-on-write cloning\n * - Structural sharing - unchanged subtrees keep their references\n * - Zero-copy on failure - if validation fails, returns original base unchanged\n *\n * @param base - The base state (never mutated)\n * @param tx - The transaction to apply\n * @param validateFn - Optional validation function\n * @returns The final state (if valid) or the original base (if invalid or empty)\n */\nexport function applyTxImmutable<T extends JSONObject>(\n  base: T,\n  tx: Pick<TxRecord, \"ops\">,\n  validateFn?: ValidateFn<T>\n): T {\n  if (tx.ops.length === 0) return base\n\n  const ctx = createDraft(base)\n\n  try {\n    for (const op of tx.ops) {\n      applyOpToDraft(ctx, op)\n    }\n\n    if (validateFn && !validateFn(ctx.root)) {\n      return base\n    }\n\n    return ctx.root\n  } catch {\n    return base\n  }\n}\n","import { failure } from \"./error\"\nimport { JSONRecord, JSONValue, Path } from \"./json\"\nimport { Op } from \"./operations\"\n\n/**\n * Reconciles the current state with the target state by computing and emitting\n * the minimal set of operations needed to transform currentState into targetState.\n */\nexport function computeReconcileOps(currentState: JSONValue, targetState: JSONValue): Op[] {\n  const ops: Op[] = []\n  diffValue(currentState, targetState, [], ops)\n  return ops\n}\n\nfunction diffValue(current: JSONValue, target: JSONValue, path: Path, ops: Op[]): void {\n  // 1. Reference equality (structural sharing)\n  if (current === target) return\n\n  // 2. Handle primitives and null quickly\n  const currentType = typeof current\n  const targetType = typeof target\n\n  if (current === null || target === null || currentType !== \"object\" || targetType !== \"object\") {\n    // At least one is primitive/null, or types don't match\n    emitReplace(path, target, ops)\n    return\n  }\n\n  // Both are objects (object or array)\n  const currentIsArray = Array.isArray(current)\n  const targetIsArray = Array.isArray(target)\n\n  if (currentIsArray !== targetIsArray) {\n    // Type mismatch (one array, one object)\n    emitReplace(path, target, ops)\n    return\n  }\n\n  if (currentIsArray) {\n    diffArray(current, target as JSONValue[], path, ops)\n  } else {\n    diffObject(current as JSONRecord, target as JSONRecord, path, ops)\n  }\n}\n\nfunction diffObject(current: JSONRecord, target: JSONRecord, path: Path, ops: Op[]): void {\n  // 1. Delete keys in current but not in target\n  for (const key in current) {\n    if (Object.hasOwn(current, key) && !Object.hasOwn(target, key)) {\n      ops.push({ kind: \"delete\", path, key })\n    }\n  }\n\n  // 2. Add/Update keys in target\n  for (const key in target) {\n    if (Object.hasOwn(target, key)) {\n      const targetVal = target[key]\n      if (!Object.hasOwn(current, key)) {\n        ops.push({ kind: \"set\", path, key, value: targetVal })\n      } else if (current[key] !== targetVal) {\n        // Only recurse if values differ (reference check first)\n        diffValue(current[key], targetVal, [...path, key], ops)\n      }\n    }\n  }\n}\n\nfunction diffArray(current: JSONValue[], target: JSONValue[], path: Path, ops: Op[]): void {\n  const currentLen = current.length\n  const targetLen = target.length\n  const minLen = currentLen < targetLen ? currentLen : targetLen\n\n  // Diff common elements\n  for (let i = 0; i < minLen; i++) {\n    if (current[i] !== target[i]) {\n      diffValue(current[i], target[i], [...path, i], ops)\n    }\n  }\n\n  // Handle length difference\n  if (targetLen > currentLen) {\n    ops.push({\n      kind: \"splice\",\n      path,\n      index: currentLen,\n      deleteCount: 0,\n      inserts: target.slice(currentLen),\n    })\n  } else if (currentLen > targetLen) {\n    ops.push({\n      kind: \"splice\",\n      path,\n      index: targetLen,\n      deleteCount: currentLen - targetLen,\n      inserts: [],\n    })\n  }\n}\n\nfunction emitReplace(path: Path, value: JSONValue, ops: Op[]): void {\n  if (path.length === 0) {\n    // Cannot replace root directly via Ops (unless we define a 'root' op, which we don't)\n    // We expect root to be handled by diffObject usually.\n    // If we land here, it means root types mismatched (e.g. Obj -> Array).\n    failure(\"StateSyncLog: Cannot replace root state directly via Ops.\")\n  }\n\n  const parentPath = path.slice(0, -1)\n  const keyToCheck = path[path.length - 1]\n\n  if (typeof keyToCheck === \"string\") {\n    // Parent is Object\n    ops.push({ kind: \"set\", path: parentPath, key: keyToCheck, value })\n  } else {\n    // Parent is Array\n    ops.push({\n      kind: \"splice\",\n      path: parentPath,\n      index: keyToCheck,\n      deleteCount: 1,\n      inserts: [value],\n    })\n  }\n}\n","import { failure } from \"./error\"\n\n/**\n * Parsed tx timestamp components.\n */\nexport type TxTimestamp = {\n  epoch: number\n  clock: number\n  clientId: string\n  wallClock: number\n}\n\n/**\n * Unique tx ID (Composite Key).\n */\nexport type TxTimestampKey = string\n\n/**\n * Converts a timestamp object to a TransactionTimestampKey string.\n */\nexport function txTimestampToKey(ts: TxTimestamp): TxTimestampKey {\n  return `${ts.epoch};${ts.clock};${ts.clientId};${ts.wallClock}`\n}\n\n/**\n * Helper to parse tx timestamp keys.\n * Throws if key is malformed.\n */\nexport function parseTxTimestampKey(key: TxTimestampKey): TxTimestamp {\n  const i1 = key.indexOf(\";\")\n  const i2 = key.indexOf(\";\", i1 + 1)\n  const i3 = key.indexOf(\";\", i2 + 1)\n\n  if (i1 === -1 || i2 === -1 || i3 === -1) {\n    failure(`Malformed timestamp key: ${key}`)\n  }\n\n  return {\n    epoch: Number.parseInt(key.substring(0, i1), 10),\n    clock: Number.parseInt(key.substring(i1 + 1, i2), 10),\n    clientId: key.substring(i2 + 1, i3),\n    wallClock: Number.parseInt(key.substring(i3 + 1), 10),\n  }\n}\n\n/**\n * Compares two tx timestamps for deterministic ordering.\n * Sort order: epoch (asc) → clock (asc) → clientId (asc)\n */\nexport function compareTxTimestamps(a: TxTimestamp, b: TxTimestamp): number {\n  if (a.epoch !== b.epoch) return a.epoch - b.epoch\n  if (a.clock !== b.clock) return a.clock - b.clock\n  if (a.clientId < b.clientId) return -1\n  if (a.clientId > b.clientId) return 1\n  return 0\n}\n","import type * as Y from \"yjs\"\nimport { failure } from \"./error\"\nimport { TxRecord } from \"./TxRecord\"\nimport { parseTxTimestampKey, type TxTimestamp, type TxTimestampKey } from \"./txTimestamp\"\n\n/**\n * A cached tx entry with lazy parsing and optional tx caching.\n * The timestamp is parsed on first access and cached.\n * The tx record can be fetched lazily and cached.\n */\nexport class SortedTxEntry {\n  private _txTimestamp?: TxTimestamp\n  private _originalTxTimestampKey?: TxTimestampKey | null\n  private _originalTxTimestamp?: TxTimestamp | null\n  private _txRecord?: TxRecord\n\n  constructor(\n    readonly txTimestampKey: TxTimestampKey,\n    private readonly _yTx: Y.Map<TxRecord>\n  ) {}\n\n  /**\n   * Gets the parsed timestamp, lazily parsing and caching on first access.\n   */\n  get txTimestamp(): TxTimestamp {\n    if (!this._txTimestamp) {\n      this._txTimestamp = parseTxTimestampKey(this.txTimestampKey)\n    }\n    return this._txTimestamp\n  }\n\n  /**\n   * Gets the original tx timestamp key, lazily and caching on first access.\n   */\n  get originalTxTimestampKey(): TxTimestampKey | null {\n    if (this._originalTxTimestampKey === undefined) {\n      const tx = this.txRecord\n      this._originalTxTimestampKey = tx.originalTxKey ?? null\n    }\n    return this._originalTxTimestampKey\n  }\n\n  /**\n   * Gets the parsed original tx timestamp, lazily parsing and caching on first access.\n   */\n  get originalTxTimestamp(): TxTimestamp | null {\n    if (this._originalTxTimestamp === undefined) {\n      const key = this.originalTxTimestampKey\n      this._originalTxTimestamp = key ? parseTxTimestampKey(key) : null\n    }\n    return this._originalTxTimestamp\n  }\n\n  /**\n   * Gets the logical (deduplicated) tx timestamp key.\n   * This is the original tx key if it exists, otherwise the physical key.\n   */\n  get dedupTxTimestampKey(): TxTimestampKey {\n    return this.originalTxTimestampKey ?? this.txTimestampKey\n  }\n\n  /**\n   * Gets the logical (deduplicated) parsed tx timestamp.\n   * This is the original tx timestamp if it exists, otherwise the physical timestamp.\n   */\n  get dedupTxTimestamp(): TxTimestamp {\n    return this.originalTxTimestamp ?? this.txTimestamp\n  }\n\n  /**\n   * Gets the tx record, lazily fetching and caching on first access.\n   * Returns undefined if the tx doesn't exist.\n   */\n  get txRecord(): TxRecord {\n    if (!this._txRecord) {\n      this._txRecord = this._yTx.get(this.txTimestampKey)\n      if (!this._txRecord) {\n        throw failure(`SortedTxEntry: TxRecord not found for key ${this.txTimestampKey}`)\n      }\n    }\n    return this._txRecord\n  }\n}\n","import type * as Y from \"yjs\"\nimport { type CheckpointRecord, type ClientWatermarks } from \"./checkpoints\"\nimport { applyTxImmutable } from \"./draft\"\nimport { JSONObject } from \"./json\"\nimport { Op, ValidateFn } from \"./operations\"\nimport { computeReconcileOps } from \"./reconcile\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { TxRecord } from \"./TxRecord\"\nimport { compareTxTimestamps, type TxTimestamp, type TxTimestampKey } from \"./txTimestamp\"\nimport { lazy } from \"./utils\"\n\n/**\n * Checks if a transaction is covered by the checkpoint watermarks.\n */\nexport function isTransactionInCheckpoint(ts: TxTimestamp, watermarks: ClientWatermarks): boolean {\n  const wm = watermarks[ts.clientId]\n  if (!wm) return false\n  return ts.clock <= wm.maxClock\n}\n\n/**\n * StateCalculator encapsulates the sorted transaction cache and state calculation logic.\n *\n * It maintains:\n * - A sorted array of transaction entries\n * - A map for O(1) lookup\n * - A tracking index indicating up to which tx the state has been calculated\n * - The cached calculated state\n * - The base checkpoint\n *\n * The tracking index is invalidated (set to null) when:\n * - A transaction is inserted before the already-calculated slice\n * - A transaction is deleted from the already-calculated slice\n * - The base checkpoint changes\n */\nexport class StateCalculator {\n  /** Sorted tx cache (ALL active/future txs, kept sorted by timestamp) */\n  private sortedTxs: SortedTxEntry[] = []\n\n  /** O(1) existence check and lookup */\n  private sortedTxsMap: Map<TxTimestampKey, SortedTxEntry> = new Map()\n\n  /**\n   * Index of the last transaction applied to cachedState.\n   * - null: state needs full recalculation from checkpoint\n   * - -1: no transactions have been applied yet (state === checkpoint state)\n   * - >= 0: transactions up to and including this index have been applied\n   */\n  private lastAppliedIndex: number | null = null\n\n  /** The cached calculated state */\n  private cachedState: JSONObject | null = null\n\n  /** The base checkpoint to calculate state from */\n  private baseCheckpoint: CheckpointRecord | null = null\n\n  /**\n   * Applied dedup keys - tracks which LOGICAL txs have been applied.\n   * This is the originalTxKey (or physical key if no original) for each applied tx.\n   * Used to properly deduplicate re-emits.\n   */\n  private appliedTxKeys: Set<TxTimestampKey> = new Set()\n\n  /** Max clock seen from any transaction (for Lamport clock updates) */\n  private maxSeenClock = 0\n\n  /** Validation function (optional) */\n  private validateFn?: ValidateFn<JSONObject>\n\n  constructor(validateFn?: ValidateFn<JSONObject>) {\n    this.validateFn = validateFn\n  }\n\n  /**\n   * Sets the base checkpoint. Invalidates cached state if checkpoint changed.\n   * @returns true if the checkpoint changed\n   */\n  setBaseCheckpoint(checkpoint: CheckpointRecord | null): boolean {\n    if (checkpoint === this.baseCheckpoint) {\n      return false\n    }\n\n    this.baseCheckpoint = checkpoint\n    this.invalidate()\n    return true\n  }\n\n  /**\n   * Gets the current base checkpoint.\n   */\n  getBaseCheckpoint(): CheckpointRecord | null {\n    return this.baseCheckpoint\n  }\n\n  /**\n   * Clears all transactions and rebuilds from yTx map.\n   * This is used when the checkpoint changes and we need a fresh start.\n   */\n  rebuildFromYjs(yTx: Y.Map<TxRecord>): void {\n    this.sortedTxs = []\n    this.sortedTxsMap.clear()\n\n    // Collect all entries, build the map and max clock\n    for (const key of yTx.keys()) {\n      const entry = new SortedTxEntry(key, yTx)\n      this.sortedTxs.push(entry)\n\n      this.sortedTxsMap.set(entry.txTimestampKey, entry)\n      if (entry.txTimestamp.clock > this.maxSeenClock) {\n        this.maxSeenClock = entry.txTimestamp.clock\n      }\n    }\n\n    // Sort once - O(n log n)\n    this.sortedTxs.sort((a, b) => compareTxTimestamps(a.txTimestamp, b.txTimestamp))\n\n    // Invalidate cached state since we rebuilt\n    this.invalidate()\n  }\n\n  /**\n   * Inserts a transaction into the sorted cache.\n   * Invalidates cached state if the transaction was inserted before the calculated slice.\n   *\n   * @returns true if this caused invalidation (out-of-order insert)\n   */\n  insertTx(key: TxTimestampKey, yTx: Y.Map<TxRecord>): boolean {\n    if (this.sortedTxsMap.has(key)) {\n      return false // Already exists\n    }\n\n    const entry = new SortedTxEntry(key, yTx)\n    const ts = entry.txTimestamp\n\n    // Update max seen clock for Lamport clock mechanism\n    if (ts.clock > this.maxSeenClock) {\n      this.maxSeenClock = ts.clock\n    }\n\n    const sortedTxs = this.sortedTxs\n\n    // Find insertion position (search from end since new txs typically have higher timestamps)\n    let insertIndex = sortedTxs.length // Default: append at end\n    for (let i = sortedTxs.length - 1; i >= 0; i--) {\n      const existingTs = sortedTxs[i].txTimestamp\n      if (compareTxTimestamps(ts, existingTs) >= 0) {\n        insertIndex = i + 1\n        break\n      }\n      if (i === 0) {\n        insertIndex = 0 // Insert at beginning\n      }\n    }\n\n    // Insert at the found position\n    sortedTxs.splice(insertIndex, 0, entry)\n    this.sortedTxsMap.set(key, entry)\n\n    // Check if this invalidates our cached state\n    // If we inserted before or at the last applied index, we need to recalculate\n    if (this.lastAppliedIndex !== null && insertIndex <= this.lastAppliedIndex) {\n      this.invalidate()\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Removes multiple transactions from the sorted cache.\n   * @returns the number of keys that were actually removed\n   */\n  removeTxs(keys: readonly TxTimestampKey[]): number {\n    if (keys.length === 0) return 0\n\n    let removedCount = 0\n    let minRemovedIndex = Number.POSITIVE_INFINITY\n\n    // Build set of keys to delete and track their indices\n    const toDelete = new Set<TxTimestampKey>()\n    for (const key of keys) {\n      const entry = this.sortedTxsMap.get(key)\n      if (entry) {\n        this.sortedTxsMap.delete(key)\n        toDelete.add(key)\n\n        // Find index for invalidation check\n        const index = this.sortedTxs.indexOf(entry)\n        if (index !== -1 && index < minRemovedIndex) {\n          minRemovedIndex = index\n        }\n      }\n    }\n\n    if (toDelete.size === 0) return 0\n\n    // Single forward pass through sortedTxs, removing matching entries\n    const sortedTxs = this.sortedTxs\n    let i = 0\n    while (i < sortedTxs.length && toDelete.size > 0) {\n      if (toDelete.has(sortedTxs[i].txTimestampKey)) {\n        toDelete.delete(sortedTxs[i].txTimestampKey)\n        sortedTxs.splice(i, 1)\n        removedCount++\n      } else {\n        i++\n      }\n    }\n\n    // Check if this invalidates our cached state\n    if (this.lastAppliedIndex !== null && minRemovedIndex <= this.lastAppliedIndex) {\n      this.invalidate()\n    }\n\n    return removedCount\n  }\n\n  /**\n   * Checks if a transaction key exists in the cache.\n   */\n  hasTx(key: TxTimestampKey): boolean {\n    return this.sortedTxsMap.has(key)\n  }\n\n  /**\n   * Gets a transaction entry by key.\n   */\n  getTx(key: TxTimestampKey): SortedTxEntry | undefined {\n    return this.sortedTxsMap.get(key)\n  }\n\n  /**\n   * Gets all sorted transaction entries.\n   */\n  getSortedTxs(): readonly SortedTxEntry[] {\n    return this.sortedTxs\n  }\n\n  /**\n   * Gets the number of transactions in the cache.\n   */\n  get txCount(): number {\n    return this.sortedTxs.length\n  }\n\n  /**\n   * Returns true if the state needs full recalculation.\n   */\n  needsFullRecalculation(): boolean {\n    return this.lastAppliedIndex === null\n  }\n\n  /**\n   * Invalidates the cached state, forcing a full recalculation on next calculateState().\n   * Note: cachedState is kept so computeReconcileOps can diff old vs new state.\n   */\n  invalidate(): void {\n    this.lastAppliedIndex = null\n  }\n\n  /**\n   * Calculates and returns the current state, along with a lazy getter for ops that changed from the previous state.\n   *\n   * - If lastAppliedIndex is null: full recalculation from checkpoint\n   * - If lastAppliedIndex >= -1: incremental apply from lastAppliedIndex + 1\n   */\n  calculateState(): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    const baseState: JSONObject = this.baseCheckpoint?.state ?? {}\n    const watermarks = this.baseCheckpoint?.watermarks ?? {}\n    const hasWatermarks = Object.keys(watermarks).length > 0\n\n    if (this.lastAppliedIndex === null) {\n      // SLOW PATH: Full recalculation\n      return this.fullRecalculation(baseState, watermarks, hasWatermarks)\n    }\n\n    // FAST PATH: Incremental apply\n    return this.incrementalApply(watermarks, hasWatermarks)\n  }\n\n  /**\n   * Full recalculation of state from the base checkpoint.\n   */\n  private fullRecalculation(\n    baseState: JSONObject,\n    watermarks: ClientWatermarks,\n    hasWatermarks: boolean\n  ): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    const oldState = this.cachedState ?? {}\n\n    // Reset tracking for full recompute\n    this.appliedTxKeys.clear()\n    this.lastAppliedIndex = -1\n    this.cachedState = baseState\n\n    // Delegate to incremental apply to replay all transactions\n    // We ignore the returned ops because they represent the operations applied from the base state,\n    // whereas we want the diff from the *previous cached state*.\n    // We pass returnOps=false to avoid collecting ops during replay.\n    const { state } = this.incrementalApply(watermarks, hasWatermarks, false)\n\n    // Lazy load the reconciliation ops (expensive diff)\n    const getAppliedOps = lazy(() => computeReconcileOps(oldState, state))\n\n    return { state, getAppliedOps }\n  }\n\n  /**\n   * Incremental apply of transactions from lastAppliedIndex + 1.\n   * @param returnOps If true, collects applied transactions (to lazy compute ops). If false, skips collection.\n   */\n  private incrementalApply(\n    watermarks: ClientWatermarks,\n    hasWatermarks: boolean,\n    returnOps = true\n  ): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n    let state = this.cachedState as JSONObject\n    const appliedTxs: TxRecord[] = []\n    const sortedTxs = this.sortedTxs\n    const startIndex = this.lastAppliedIndex! + 1\n\n    for (let i = startIndex; i < sortedTxs.length; i++) {\n      const entry = sortedTxs[i]\n      const dedupKey = entry.dedupTxTimestampKey\n\n      // Skip if already applied (deduplication)\n      if (this.appliedTxKeys.has(dedupKey)) {\n        continue\n      }\n\n      // Skip if in checkpoint\n      if (hasWatermarks) {\n        const dedupTs = entry.dedupTxTimestamp\n        if (isTransactionInCheckpoint(dedupTs, watermarks)) {\n          this.appliedTxKeys.add(dedupKey)\n          continue\n        }\n      }\n\n      const tx = entry.txRecord\n\n      // Apply transaction 1-by-1 to avoid draft context pollution on validation failure\n      const newState = applyTxImmutable(state, tx, this.validateFn)\n\n      if (newState !== state) {\n        state = newState\n        if (returnOps) {\n          appliedTxs.push(tx)\n        }\n      }\n\n      this.appliedTxKeys.add(dedupKey)\n      this.lastAppliedIndex = i\n    }\n\n    // Update lastAppliedIndex to end even if all txs were skipped\n    // This ensures we don't re-process skipped txs on next incremental apply\n    if (sortedTxs.length > 0 && this.lastAppliedIndex! < sortedTxs.length - 1) {\n      this.lastAppliedIndex = sortedTxs.length - 1\n    }\n\n    this.cachedState = state\n\n    // Lazy getter for ops (flattens applied txs)\n    const getAppliedOps = lazy(() => {\n      const ops: Op[] = []\n      for (const tx of appliedTxs) {\n        ops.push(...tx.ops)\n      }\n      return ops\n    })\n\n    return { state, getAppliedOps }\n  }\n\n  /**\n   * Gets the max seen clock (for Lamport clock updates).\n   */\n  getMaxSeenClock(): number {\n    return this.maxSeenClock\n  }\n\n  /**\n   * Gets the current cached state without recalculating.\n   * Returns null if state has never been calculated.\n   */\n  getCachedState(): JSONObject | null {\n    return this.cachedState\n  }\n\n  /**\n   * Gets the last applied timestamp.\n   */\n  getLastAppliedTs(): TxTimestamp | null {\n    if (this.lastAppliedIndex === null || this.lastAppliedIndex < 0) {\n      return null\n    }\n    return this.sortedTxs[this.lastAppliedIndex]?.txTimestamp ?? null\n  }\n\n  /**\n   * Gets the last applied index (for debugging/tracking).\n   */\n  getLastAppliedIndex(): number | null {\n    return this.lastAppliedIndex\n  }\n}\n","import { JSONObject } from \"./json\"\nimport { ValidateFn } from \"./operations\"\nimport { StateCalculator } from \"./StateCalculator\"\n\n/**\n * Client-side state including clocks and calculator for state management\n */\nexport interface ClientState {\n  // Lamport clocks (monotonic, never reset)\n  localClock: number\n\n  // Cached finalized epoch (null = not yet initialized, recalculated only when checkpoint map changes)\n  cachedFinalizedEpoch: number | null\n\n  // State calculator (manages sorted tx cache, state calculation, and invalidation)\n  stateCalculator: StateCalculator\n\n  /**\n   * Timestamp retention window in milliseconds.\n   */\n  retentionWindowMs: number\n}\n\n/**\n * Factory to create an initial ClientState\n */\nexport function createClientState(\n  validateFn: ValidateFn<JSONObject> | undefined,\n  retentionWindowMs: number\n): ClientState {\n  return {\n    localClock: 0,\n    cachedFinalizedEpoch: null, // Will be recalculated on first run\n    stateCalculator: new StateCalculator(validateFn),\n    retentionWindowMs,\n  }\n}\n","import * as Y from \"yjs\"\nimport { type CheckpointRecord, pruneCheckpoints } from \"./checkpoints\"\nimport { getFinalizedEpochAndCheckpoint } from \"./checkpointUtils\"\nimport { ClientState } from \"./clientState\"\nimport { JSONObject } from \"./json\"\nimport { Op } from \"./operations\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { isTransactionInCheckpoint } from \"./StateCalculator\"\nimport { TxRecord } from \"./TxRecord\"\nimport { type TxTimestamp, type TxTimestampKey, txTimestampToKey } from \"./txTimestamp\"\n\n/**\n * Changes to transaction keys from a Y.YMapEvent.\n * - added: keys that were added\n * - deleted: keys that were deleted\n */\nexport type TxKeyChanges = {\n  added: readonly TxTimestampKey[]\n  deleted: readonly TxTimestampKey[]\n}\n\n/**\n * Appends a new transaction to the log.\n *\n * @param originalKey - Optional reference to the original transaction key for re-emits.\n *                      Used by syncLog to preserve transactions missed by checkpoints.\n */\nexport function appendTx(\n  ops: readonly Op[],\n  yTx: Y.Map<TxRecord>,\n  activeEpoch: number,\n  myClientId: string,\n  clientState: ClientState,\n  originalKey?: TxTimestampKey\n): TxTimestampKey {\n  const calc = clientState.stateCalculator\n\n  // 1. Advance logical clock (Lamport) based on all seen traffic\n  const clock = Math.max(clientState.localClock, calc.getMaxSeenClock()) + 1\n  clientState.localClock = clock\n\n  // 2. Generate Key with WallClock for future pruning safety\n  const ts: TxTimestamp = {\n    epoch: activeEpoch,\n    clock,\n    clientId: myClientId,\n    wallClock: Date.now(),\n  }\n  const key = txTimestampToKey(ts)\n\n  // 3. Write to Yjs (Atomic)\n  const record: TxRecord = { ops, originalTxKey: originalKey }\n  yTx.set(key, record)\n\n  return key\n}\n\n/**\n * Synchronizes the transaction log with the current checkpoint.\n * Re-emits missed transactions and prunes old ones.\n *\n * Should be called BEFORE updateState to ensure log is clean and complete.\n *\n * @returns true if any transactions were re-emitted or deleted, which may invalidate lastAppliedIndex\n */\nfunction syncLog(\n  yTx: Y.Map<TxRecord>,\n  myClientId: string,\n  clientState: ClientState,\n  finalizedEpoch: number,\n  baseCP: CheckpointRecord | null,\n  newKeys?: readonly TxTimestampKey[] // keys added in this update\n): void {\n  const calc = clientState.stateCalculator\n  const activeEpoch = finalizedEpoch + 1\n  const watermarks = baseCP?.watermarks ?? {}\n\n  // Deterministic Reference Time: Use stored minWallClock if available, otherwise 0 (nothing ancient).\n  const referenceTime = baseCP?.minWallClock ?? 0\n\n  // Helper to check if a transaction should be pruned\n  const shouldPrune = (ts: TxTimestamp, dedupTs: TxTimestamp): boolean => {\n    const isAncient = referenceTime - ts.wallClock > clientState.retentionWindowMs\n    if (isAncient) return true\n    return isTransactionInCheckpoint(dedupTs, watermarks)\n  }\n\n  const toDelete: TxTimestampKey[] = []\n  const toReEmit: Array<{ originalKey: TxTimestampKey; tx: TxRecord }> = []\n\n  // 1. Helper to decide what to do with each transaction\n  const processEntry = (entry: SortedTxEntry): boolean => {\n    if (shouldPrune(entry.txTimestamp, entry.dedupTxTimestamp)) {\n      toDelete.push(entry.txTimestampKey)\n      return false // deleted\n    }\n\n    if (entry.txTimestamp.epoch <= finalizedEpoch) {\n      // Not in checkpoint and still fresh - re-emit it to the active epoch\n      toReEmit.push({ originalKey: entry.dedupTxTimestampKey, tx: entry.txRecord })\n      toDelete.push(entry.txTimestampKey)\n      return false // re-emitted\n    }\n\n    return true // active/fresh\n  }\n\n  // 2. Scan local cache (sortedTxs) to identify missing/ancient transactions\n  for (const entry of calc.getSortedTxs()) {\n    if (processEntry(entry)) {\n      // Optimization: Physical keys are sorted. If we hit the active/fresh territory, we can stop.\n      break\n    }\n  }\n\n  const processKeyByTimestampKey = (txTimestampKey: TxTimestampKey): void => {\n    // Only process if it actually exists in Yjs Map\n    if (yTx.has(txTimestampKey)) {\n      processEntry(new SortedTxEntry(txTimestampKey, yTx))\n    }\n  }\n\n  // 3. Scan NEW keys from Yjs to handle incoming transactions (sync)\n  // Any client can re-emit - deduplication via originalTxKey handles duplicates.\n  if (newKeys) {\n    for (const key of newKeys) {\n      processKeyByTimestampKey(key)\n    }\n  }\n\n  // 4. Re-emit missed transactions BEFORE pruning\n  for (const { originalKey, tx } of toReEmit) {\n    const newKey = appendTx(tx.ops, yTx, activeEpoch, myClientId, clientState, originalKey)\n    calc.insertTx(newKey, yTx)\n  }\n\n  // 5. Prune old/finalized/redundant transactions from Yjs Map\n  for (const key of toDelete) {\n    yTx.delete(key)\n  }\n  calc.removeTxs(toDelete)\n}\n\n/**\n * The primary update function that maintains current state.\n *\n * @param txChanges - Changes from Y.YMapEvent. If undefined (first run), performs a full scan.\n */\nexport function updateState(\n  doc: Y.Doc,\n  yTx: Y.Map<TxRecord>,\n  yCheckpoint: Y.Map<CheckpointRecord>,\n  myClientId: string,\n  clientState: ClientState,\n  txChanges: TxKeyChanges | undefined\n): { state: JSONObject; getAppliedOps: () => readonly Op[] } {\n  const calc = clientState.stateCalculator\n\n  // Always calculate fresh finalized epoch and checkpoint to handle sync race conditions\n  const { finalizedEpoch, checkpoint: baseCP } = getFinalizedEpochAndCheckpoint(yCheckpoint)\n\n  // Update read-cache\n  clientState.cachedFinalizedEpoch = finalizedEpoch\n\n  // Set base checkpoint (this handles invalidation if checkpoint changed)\n  calc.setBaseCheckpoint(baseCP)\n\n  // Track if we need to rebuild sorted cache (first run or missing delta)\n  // Optimization: We don't need to rebuild just because checkpoint changed,\n  // as long as we have txChanges to keep cache in sync.\n  const needsRebuildSortedCache = calc.getCachedState() === null || !txChanges\n\n  // Rebuild sorted cache before syncLog if needed\n  if (needsRebuildSortedCache) {\n    calc.rebuildFromYjs(yTx)\n  } else {\n    // If not rebuilding, immediately process deletions to avoid \"ghost\" transactions\n    // in syncLog (e.g. attempting to access a transaction that was just deleted).\n    calc.removeTxs(txChanges.deleted)\n  }\n\n  // Sync and prune within transaction\n  doc.transact(() => {\n    syncLog(yTx, myClientId, clientState, finalizedEpoch, baseCP, txChanges?.added)\n\n    // Safe to use local finalizedEpoch here\n    pruneCheckpoints(yCheckpoint, finalizedEpoch)\n  })\n\n  if (needsRebuildSortedCache) {\n    // Full recompute (calculator handles this)\n    return calc.calculateState()\n  }\n\n  // Incremental update using only changed keys (calculator handles this)\n  // txChanges is guaranteed to exist here since !txChanges implies needsRebuildSortedCache\n\n  // Update sorted cache with new keys from txChanges\n  // This must happen after syncLog which may have deleted some of these keys\n  for (const key of txChanges.added) {\n    // CRITICAL: Check yTx.has(key)! syncLog might have just pruned it.\n    if (yTx.has(key) && !calc.hasTx(key)) {\n      calc.insertTx(key, yTx)\n    }\n  }\n\n  return calc.calculateState()\n}\n","import * as Y from \"yjs\"\nimport { CheckpointRecord, createCheckpoint } from \"./checkpoints\"\nimport { createClientState } from \"./clientState\"\nimport { failure } from \"./error\"\nimport { JSONObject } from \"./json\"\n\nimport { Op, ValidateFn } from \"./operations\"\n\nimport { computeReconcileOps } from \"./reconcile\"\nimport { SortedTxEntry } from \"./SortedTxEntry\"\nimport { TxRecord } from \"./TxRecord\"\nimport { appendTx, TxKeyChanges, updateState } from \"./txLog\"\nimport { TxTimestampKey } from \"./txTimestamp\"\nimport { generateID } from \"./utils\"\n\nexport const getSortedTxsSymbol = Symbol(\"getSortedTxs\")\n\nexport interface StateSyncLogOptions<State extends JSONObject> {\n  /**\n   * The Y.js Document to bind to.\n   */\n  yDoc: Y.Doc\n\n  /**\n   * Name for the txs Y.Map.\n   * Default: \"state-sync-log-tx\"\n   */\n  yTxMapName?: string\n\n  /**\n   * Name for the checkpoint Y.Map.\n   * Default: \"state-sync-log-checkpoint\"\n   */\n  yCheckpointMapName?: string\n\n  /**\n   * Unique identifier for this client.\n   * If omitted, a random UUID (nanoid) will be generated.\n   * NOTE: If you need to resume a session (keep local clock/watermark), you MUST provide a stable ID.\n   * MUST NOT contain semicolons.\n   */\n  clientId?: string\n\n  /**\n   * Origin tag for Y.js txs created by this library.\n   */\n  yjsOrigin?: unknown\n\n  /**\n   * Optional validation function.\n   * Runs after each tx's ops are applied.\n   * If it returns false, the tx is rejected (state reverts).\n   * MUST be deterministic and consistent across all clients.\n   */\n  validate?: (state: State) => boolean\n\n  /**\n   * Timestamp retention window in milliseconds.\n   * Txs older than this window are considered \"Ancient\" and pruned.\n   *\n   * Default: Infinity (No pruning).\n   * Recommended: 14 days (1209600000 ms).\n   */\n  retentionWindowMs: number | undefined\n}\n\nexport interface StateSyncLogController<State extends JSONObject> {\n  /**\n   * Returns the current state.\n   */\n  getState(): State\n\n  /**\n   * Subscribes to state changes.\n   */\n  subscribe(callback: (newState: State, getAppliedOps: () => readonly Op[]) => void): () => void\n\n  /**\n   * Emits a new tx (list of operations) to the log.\n   */\n  emit(ops: Op[]): void\n\n  /**\n   * Reconciles the current state with the target state.\n   */\n  reconcileState(targetState: State): void\n\n  /**\n   * Manually triggers epoch compaction (Checkpointing).\n   */\n  compact(): void\n\n  /**\n   * Cleans up observers and releases memory.\n   */\n  dispose(): void\n\n  // --- Observability & Stats ---\n\n  /**\n   * Returns the current active epoch number.\n   */\n  getActiveEpoch(): number\n\n  /**\n   * Returns the number of txs currently in the active epoch.\n   */\n  getActiveEpochTxCount(): number\n\n  /**\n   * Returns the wallClock timestamp of the first tx in the active epoch.\n   */\n  getActiveEpochStartTime(): number | undefined\n\n  /**\n   * Returns true if the log is completely empty.\n   */\n  isLogEmpty(): boolean\n\n  /**\n   * Internal/Testing: Returns all txs currently in the log, sorted.\n   */\n  [getSortedTxsSymbol](): readonly SortedTxEntry[]\n}\n\n/**\n * Creates a StateSyncLog controller.\n */\nexport function createStateSyncLog<State extends JSONObject>(\n  options: StateSyncLogOptions<State>\n): StateSyncLogController<State> {\n  const {\n    yDoc,\n    yTxMapName = \"state-sync-log-tx\",\n    yCheckpointMapName = \"state-sync-log-checkpoint\",\n    clientId = generateID(),\n    yjsOrigin,\n    validate,\n    retentionWindowMs,\n  } = options\n\n  if (clientId.includes(\";\")) {\n    failure(`clientId MUST NOT contain semicolons: ${clientId}`)\n  }\n\n  const yTx = yDoc.getMap<TxRecord>(yTxMapName)\n  const yCheckpoint = yDoc.getMap<CheckpointRecord>(yCheckpointMapName)\n\n  // Cast validate to basic type to match internal ClientState\n  const clientState = createClientState(\n    validate as unknown as ValidateFn<JSONObject>,\n    retentionWindowMs ?? Number.POSITIVE_INFINITY\n  )\n\n  // Listeners\n  const subscribers = new Set<(state: State, getAppliedOps: () => readonly Op[]) => void>()\n\n  const notifySubscribers = (state: State, getAppliedOps: () => readonly Op[]) => {\n    for (const sub of subscribers) {\n      sub(state, getAppliedOps)\n    }\n  }\n\n  // Helper to extract key changes from YMapEvent\n  const extractTxChanges = (event: Y.YMapEvent<TxRecord>): TxKeyChanges => {\n    const added: TxTimestampKey[] = []\n    const deleted: TxTimestampKey[] = []\n\n    for (const [key, change] of event.changes.keys) {\n      if (change.action === \"add\") {\n        added.push(key)\n      } else if (change.action === \"delete\") {\n        deleted.push(key)\n      } else if (change.action === \"update\") {\n        deleted.push(key)\n        added.push(key)\n      }\n    }\n\n    return { added, deleted }\n  }\n\n  // Empty txChanges object for checkpoint observer (no tx keys changed)\n  const emptyTxChanges: TxKeyChanges = { added: [], deleted: [] }\n\n  // Update Logic with incremental changes\n  const runUpdate = (txChanges: TxKeyChanges | undefined) => {\n    const { state, getAppliedOps } = updateState(\n      yDoc,\n      yTx,\n      yCheckpoint,\n      clientId,\n      clientState,\n      txChanges\n    )\n    notifySubscribers(state as State, getAppliedOps)\n  }\n\n  // Tx observer\n  const txObserver = (event: Y.YMapEvent<TxRecord>, _transaction: Y.Transaction) => {\n    const txChanges = extractTxChanges(event)\n    runUpdate(txChanges)\n  }\n\n  // Checkpoint observer\n  const checkpointObserver = (\n    _event: Y.YMapEvent<CheckpointRecord>,\n    _transaction: Y.Transaction\n  ) => {\n    runUpdate(emptyTxChanges)\n  }\n\n  yCheckpoint.observe(checkpointObserver)\n  yTx.observe(txObserver)\n\n  // Initial run (full recompute, treat as checkpoint change to initialize epoch cache)\n  runUpdate(undefined)\n\n  // Track disposal state\n  let disposed = false\n\n  const assertNotDisposed = () => {\n    if (disposed) {\n      failure(\"StateSyncLog has been disposed and cannot be used\")\n    }\n  }\n\n  const getActiveEpochInternal = () => {\n    if (clientState.cachedFinalizedEpoch === null) {\n      failure(\"cachedFinalizedEpoch is null - this should not happen after initialization\")\n    }\n    return clientState.cachedFinalizedEpoch + 1\n  }\n\n  return {\n    getState(): State {\n      assertNotDisposed()\n      return (clientState.stateCalculator.getCachedState() ?? {}) as State\n    },\n\n    subscribe(callback: (newState: State, getAppliedOps: () => readonly Op[]) => void): () => void {\n      assertNotDisposed()\n      subscribers.add(callback)\n      return () => {\n        subscribers.delete(callback)\n      }\n    },\n\n    emit(ops: Op[]): void {\n      assertNotDisposed()\n      yDoc.transact(() => {\n        const activeEpoch = getActiveEpochInternal()\n        appendTx(ops, yTx, activeEpoch, clientId, clientState)\n      }, yjsOrigin)\n    },\n\n    reconcileState(targetState: State): void {\n      assertNotDisposed()\n      const currentState = (clientState.stateCalculator.getCachedState() ?? {}) as State\n      const ops = computeReconcileOps(currentState, targetState)\n      if (ops.length > 0) {\n        this.emit(ops)\n      }\n    },\n\n    compact(): void {\n      assertNotDisposed()\n      yDoc.transact(() => {\n        const activeEpoch = getActiveEpochInternal()\n        const currentState = clientState.stateCalculator.getCachedState() ?? {}\n        createCheckpoint(yTx, yCheckpoint, clientState, activeEpoch, currentState, clientId)\n      }, yjsOrigin)\n    },\n\n    dispose(): void {\n      if (disposed) return // Already disposed, no-op\n      disposed = true\n      yTx.unobserve(txObserver)\n      yCheckpoint.unobserve(checkpointObserver)\n      subscribers.clear()\n    },\n\n    getActiveEpoch(): number {\n      assertNotDisposed()\n      return getActiveEpochInternal()\n    },\n\n    getActiveEpochTxCount(): number {\n      assertNotDisposed()\n      const activeEpoch = getActiveEpochInternal()\n      let count = 0\n      // Only current or future epochs exist in sortedTxs (past epochs are pruned during updateState).\n      // Future epochs appear if we receive txs before the corresponding checkpoint.\n      for (const entry of clientState.stateCalculator.getSortedTxs()) {\n        const ts = entry.txTimestamp\n        if (ts.epoch === activeEpoch) {\n          count++\n        } else if (ts.epoch > activeEpoch) {\n          break // Optimization: sorted order means we can stop early\n        }\n      }\n      return count\n    },\n\n    getActiveEpochStartTime(): number | undefined {\n      assertNotDisposed()\n      const activeEpoch = getActiveEpochInternal()\n      // Only current or future epochs exist in sortedTxs (past epochs are pruned during updateState).\n      for (const entry of clientState.stateCalculator.getSortedTxs()) {\n        const ts = entry.txTimestamp\n        if (ts.epoch === activeEpoch) {\n          return ts.wallClock\n        } else if (ts.epoch > activeEpoch) {\n          break // Optimization: sorted order means we can stop early\n        }\n      }\n      return undefined\n    },\n\n    isLogEmpty(): boolean {\n      assertNotDisposed()\n      return yTx.size === 0 && yCheckpoint.size === 0\n    },\n\n    [getSortedTxsSymbol](): readonly SortedTxEntry[] {\n      assertNotDisposed()\n      return clientState.stateCalculator.getSortedTxs()\n    },\n  }\n}\n","import { failure } from \"./error\"\r\nimport { JSONObject, JSONValue, Path } from \"./json\"\r\nimport { deepClone, deepEqual, isObject } from \"./utils\"\r\n\r\n/**\r\n * Supported operations.\r\n * Applied sequentially within a tx.\r\n */\r\nexport type Op =\r\n  | { kind: \"set\"; path: Path; key: string; value: JSONValue }\r\n  | { kind: \"delete\"; path: Path; key: string }\r\n  | { kind: \"splice\"; path: Path; index: number; deleteCount: number; inserts: JSONValue[] }\r\n  | { kind: \"addToSet\"; path: Path; value: JSONValue }\r\n  | { kind: \"deleteFromSet\"; path: Path; value: JSONValue }\r\n\r\n/**\r\n * Validation function type.\r\n *\r\n * Rules:\r\n * - Validation MUST depend only on candidateState (and deterministic code).\r\n * - Validation runs once per tx, after all ops apply.\r\n * - If validation fails, the x is rejected (state reverts to previous).\r\n * - If no validator is provided, validation defaults to true.\r\n *\r\n * IMPORTANT: Validation outcome is **derived local state** and MUST NOT be replicated.\r\n * All clients MUST use the same validation logic to ensure consistency.\r\n */\r\nexport type ValidateFn<State extends JSONObject> = (candidateState: State) => boolean\r\n\r\n/**\r\n * Resolves a path within the state.\r\n * Throws if any segment is missing or has wrong type.\r\n */\r\nfunction resolvePath(state: JSONObject, path: Path): JSONValue {\r\n  let current: JSONValue = state\r\n  for (const segment of path) {\r\n    if (typeof segment === \"string\") {\r\n      if (!isObject(current) || Array.isArray(current)) {\r\n        failure(`Expected object at path segment \"${segment}\"`)\r\n      }\r\n      if (!(segment in current)) {\r\n        failure(`Property \"${segment}\" does not exist`)\r\n      }\r\n      current = current[segment]\r\n    } else {\r\n      if (!Array.isArray(current)) {\r\n        failure(`Expected array at path segment ${segment}`)\r\n      }\r\n      if (segment < 0 || segment >= current.length) {\r\n        failure(`Index ${segment} out of bounds`)\r\n      }\r\n      current = current[segment]\r\n    }\r\n  }\r\n  return current\r\n}\r\n\r\n/**\r\n * Applies a single operation.\r\n * (Reference implementation for standard JSON-patch behavior)\r\n */\r\nfunction applyOp(state: JSONObject, op: Op, cloneValues: boolean): void {\r\n  // Special case: if path is empty, we can't resolve \"container\".\r\n  // The caller must handle root-level replacement if necessary, but\r\n  // standard Ops usually act ON a container.\r\n  // Exception: if we act on root, handle explicitly or assume path length > 0.\r\n  // For this spec, Ops modify *fields* or *indices*.\r\n  // If path is empty, it means we are acting ON the root object itself?\r\n  // The spec's \"set\" example: container[op.key] = op.value.\r\n  // This implies we resolve path to get the PARENT container.\r\n\r\n  const container = resolvePath(state, op.path)\r\n\r\n  switch (op.kind) {\r\n    case \"set\":\r\n      if (!isObject(container) || Array.isArray(container)) {\r\n        failure(\"set requires object container\")\r\n      }\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      ;(container as any)[op.key] = cloneValues ? deepClone(op.value) : op.value\r\n      break\r\n\r\n    case \"delete\":\r\n      if (!isObject(container) || Array.isArray(container)) {\r\n        failure(\"delete requires object container\")\r\n      }\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      delete (container as any)[op.key]\r\n      break\r\n\r\n    case \"splice\": {\r\n      if (!Array.isArray(container)) {\r\n        failure(\"splice requires array container\")\r\n      }\r\n      const safeIndex = Math.min(op.index, container.length)\r\n      container.splice(\r\n        safeIndex,\r\n        op.deleteCount,\r\n        ...(cloneValues ? op.inserts.map((v) => deepClone(v)) : op.inserts)\r\n      )\r\n      break\r\n    }\r\n\r\n    case \"addToSet\":\r\n      if (!Array.isArray(container)) {\r\n        failure(\"addToSet requires array container\")\r\n      }\r\n      if (!container.some((item) => deepEqual(item, op.value))) {\r\n        container.push(cloneValues ? deepClone(op.value) : op.value)\r\n      }\r\n      break\r\n\r\n    case \"deleteFromSet\":\r\n      if (!Array.isArray(container)) {\r\n        failure(\"deleteFromSet requires array container\")\r\n      }\r\n      // Remove all matching items using splice (from end to avoid index shifting)\r\n      for (let i = container.length - 1; i >= 0; i--) {\r\n        if (deepEqual(container[i], op.value)) {\r\n          container.splice(i, 1)\r\n        }\r\n      }\r\n      break\r\n\r\n    default:\r\n      throw failure(`Unknown operation kind: ${(op as any).kind}`)\r\n  }\r\n}\r\n\r\n/**\r\n * Options for applyOps.\r\n */\r\nexport interface ApplyOpsOptions {\r\n  /**\r\n   * Whether to deep clone values before inserting them into the target.\r\n   * - `true` (default): Values are cloned to prevent aliasing between the ops and target.\r\n   * - `false`: Values are used directly for better performance. Only use this if you\r\n   *   guarantee the op values won't be mutated after application.\r\n   */\r\n  cloneValues?: boolean\r\n}\r\n\r\n/**\r\n * Applies a list of operations to a mutable target object.\r\n * Use this to synchronize an external mutable state (e.g., MobX store)\r\n * with the operations received via subscribe().\r\n *\r\n * @param ops - The list of operations to apply.\r\n * @param target - The mutable object to modify.\r\n * @param options - Optional settings for controlling cloning behavior.\r\n */\r\nexport function applyOps(ops: readonly Op[], target: JSONObject, options?: ApplyOpsOptions): void {\r\n  const cloneValues = options?.cloneValues ?? true\r\n  for (const op of ops) {\r\n    applyOp(target, op, cloneValues)\r\n  }\r\n}\r\n"],"names":["equal","scopedUrlAlphabet","rfdc","handler","clone"],"mappings":"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","x_google_ignoreList":[3,4,5,6]}