state-surgeon 1.0.0

package/dist/index.js

@@ -0,0 +1,1828 @@
+'use strict';
+
+var uuid = require('uuid');
+var express = require('express');
+var ws = require('ws');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var express__default = /*#__PURE__*/_interopDefault(express);
+
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/diff.ts
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+function calculateDiff(before, after, path = "") {
+  const diffs = [];
+  if (before === after) {
+    return diffs;
+  }
+  if (before === null || before === void 0 || typeof before !== "object") {
+    if (after === null || after === void 0 || typeof after !== "object") {
+      if (before !== after) {
+        if (before === void 0) {
+          diffs.push({ path: path || "root", operation: "ADD", newValue: after });
+        } else if (after === void 0) {
+          diffs.push({ path: path || "root", operation: "REMOVE", oldValue: before });
+        } else {
+          diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+        }
+      }
+      return diffs;
+    }
+    diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+    return diffs;
+  }
+  if (after === null || after === void 0 || typeof after !== "object") {
+    diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+    return diffs;
+  }
+  if (Array.isArray(before) || Array.isArray(after)) {
+    if (!Array.isArray(before) || !Array.isArray(after)) {
+      diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+      return diffs;
+    }
+    const maxLength = Math.max(before.length, after.length);
+    for (let i = 0; i < maxLength; i++) {
+      const itemPath = path ? `${path}[${i}]` : `[${i}]`;
+      if (i >= before.length) {
+        diffs.push({ path: itemPath, operation: "ADD", newValue: after[i] });
+      } else if (i >= after.length) {
+        diffs.push({ path: itemPath, operation: "REMOVE", oldValue: before[i] });
+      } else {
+        diffs.push(...calculateDiff(before[i], after[i], itemPath));
+      }
+    }
+    return diffs;
+  }
+  const beforeObj = before;
+  const afterObj = after;
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(beforeObj), ...Object.keys(afterObj)]);
+  for (const key of allKeys) {
+    const keyPath = path ? `${path}.${key}` : key;
+    const beforeValue = beforeObj[key];
+    const afterValue = afterObj[key];
+    if (!(key in beforeObj)) {
+      diffs.push({ path: keyPath, operation: "ADD", newValue: afterValue });
+    } else if (!(key in afterObj)) {
+      diffs.push({ path: keyPath, operation: "REMOVE", oldValue: beforeValue });
+    } else {
+      diffs.push(...calculateDiff(beforeValue, afterValue, keyPath));
+    }
+  }
+  return diffs;
+}
+function applyDiff(state, diffs) {
+  const result = deepClone(state);
+  for (const diff of diffs) {
+    setValueAtPath(result, diff.path, diff.operation === "REMOVE" ? void 0 : diff.newValue);
+  }
+  return result;
+}
+function getValueAtPath(obj, path) {
+  if (!path || path === "root") return obj;
+  const parts = parsePath(path);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setValueAtPath(obj, path, value) {
+  if (!path || path === "root") return;
+  const parts = parsePath(path);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) {
+      const nextPart = parts[i + 1];
+      current[part] = /^\d+$/.test(nextPart) ? [] : {};
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  if (value === void 0) {
+    delete current[lastPart];
+  } else {
+    current[lastPart] = value;
+  }
+}
+function parsePath(path) {
+  const parts = [];
+  let current = "";
+  let inBracket = false;
+  for (const char of path) {
+    if (char === "." && !inBracket) {
+      if (current) parts.push(current);
+      current = "";
+    } else if (char === "[") {
+      if (current) parts.push(current);
+      current = "";
+      inBracket = true;
+    } else if (char === "]") {
+      if (current) parts.push(current);
+      current = "";
+      inBracket = false;
+    } else {
+      current += char;
+    }
+  }
+  if (current) parts.push(current);
+  return parts;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== "object") return a === b;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+}
+var logicalClock = 0;
+function createMutation(options) {
+  const {
+    source,
+    sessionId,
+    previousState,
+    nextState,
+    actionType = "CUSTOM",
+    actionPayload,
+    component,
+    function: funcName,
+    captureStack = true,
+    metadata
+  } = options;
+  logicalClock++;
+  const mutation = {
+    id: `mut_${Date.now()}_${uuid.v4().slice(0, 8)}`,
+    timestamp: typeof performance !== "undefined" ? performance.now() : Date.now(),
+    logicalClock,
+    sessionId,
+    source,
+    component,
+    function: funcName,
+    actionType,
+    actionPayload,
+    previousState,
+    nextState,
+    metadata
+  };
+  if (captureStack) {
+    mutation.callStack = parseCallStack(new Error().stack);
+  }
+  return mutation;
+}
+function parseCallStack(stack) {
+  if (!stack) return [];
+  return stack.split("\n").slice(2).map((line) => line.trim()).filter((line) => line.startsWith("at ")).map((line) => {
+    const match = line.match(/at\s+(.+?)\s+\((.+):(\d+):(\d+)\)/);
+    if (match) {
+      return `${match[1]} (${match[2].split("/").pop()}:${match[3]})`;
+    }
+    const simpleMatch = line.match(/at\s+(.+):(\d+):(\d+)/);
+    if (simpleMatch) {
+      return `anonymous (${simpleMatch[1].split("/").pop()}:${simpleMatch[2]})`;
+    }
+    return line.replace("at ", "");
+  }).slice(0, 10);
+}
+function getLogicalClock() {
+  return logicalClock;
+}
+function resetLogicalClock() {
+  logicalClock = 0;
+}
+function generateSessionId() {
+  return `session_${Date.now()}_${uuid.v4().slice(0, 8)}`;
+}
+
+// src/core/utils.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+function debounce(fn, ms) {
+  let timeoutId;
+  return function(...args) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn.apply(this, args);
+    }, ms);
+  };
+}
+function throttle(fn, ms) {
+  let lastCall = 0;
+  let timeoutId;
+  return function(...args) {
+    const now = Date.now();
+    const remaining = ms - (now - lastCall);
+    if (remaining <= 0) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      lastCall = now;
+      fn.apply(this, args);
+    } else if (!timeoutId) {
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        timeoutId = void 0;
+        fn.apply(this, args);
+      }, remaining);
+    }
+  };
+}
+function compress(data) {
+  return data;
+}
+function decompress(data) {
+  return data;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function formatDuration(ms) {
+  if (ms < 1) return `${(ms * 1e3).toFixed(2)}\u03BCs`;
+  if (ms < 1e3) return `${ms.toFixed(2)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isNode() {
+  return typeof process !== "undefined" && process.versions?.node !== void 0;
+}
+function safeStringify(obj, space) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(obj, (_, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    if (typeof value === "function") {
+      return `[Function: ${value.name || "anonymous"}]`;
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack
+      };
+    }
+    if (value instanceof Map) {
+      return { __type: "Map", entries: Array.from(value.entries()) };
+    }
+    if (value instanceof Set) {
+      return { __type: "Set", values: Array.from(value.values()) };
+    }
+    return value;
+  }, space);
+}
+function safeParse(json) {
+  return JSON.parse(json, (_, value) => {
+    if (value && typeof value === "object") {
+      if (value.__type === "Map") {
+        return new Map(value.entries);
+      }
+      if (value.__type === "Set") {
+        return new Set(value.values);
+      }
+    }
+    return value;
+  });
+}
+
+// src/instrument/index.ts
+var instrument_exports = {};
+__export(instrument_exports, {
+  MutationTransport: () => MutationTransport,
+  StateSurgeonClient: () => StateSurgeonClient,
+  createReduxMiddleware: () => createReduxMiddleware,
+  instrumentFetch: () => instrumentFetch,
+  instrumentReact: () => instrumentReact,
+  instrumentReduxStore: () => instrumentReduxStore,
+  instrumentXHR: () => instrumentXHR,
+  instrumentZustand: () => instrumentZustand
+});
+
+// src/instrument/transport.ts
+var MutationTransport = class {
+  constructor(url, options = {}) {
+    this.ws = null;
+    this.buffer = [];
+    this.flushTimer = null;
+    this.reconnectAttempts = 0;
+    this.isConnecting = false;
+    this.shouldReconnect = true;
+    this.url = url;
+    this.options = {
+      batchSize: options.batchSize ?? 50,
+      flushInterval: options.flushInterval ?? 100,
+      reconnectDelay: options.reconnectDelay ?? 1e3,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
+      onConnect: options.onConnect ?? (() => {
+      }),
+      onDisconnect: options.onDisconnect ?? (() => {
+      }),
+      onError: options.onError ?? (() => {
+      }),
+      onMessage: options.onMessage ?? (() => {
+      })
+    };
+  }
+  /**
+   * Establishes WebSocket connection
+   */
+  connect() {
+    if (this.ws || this.isConnecting) {
+      return;
+    }
+    this.isConnecting = true;
+    this.shouldReconnect = true;
+    try {
+      const WebSocketImpl = typeof WebSocket !== "undefined" ? WebSocket : __require("ws");
+      this.ws = new WebSocketImpl(this.url);
+      this.ws.onopen = () => {
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        this.startFlushTimer();
+        this.options.onConnect();
+      };
+      this.ws.onclose = () => {
+        this.isConnecting = false;
+        this.stopFlushTimer();
+        this.ws = null;
+        this.options.onDisconnect();
+        this.attemptReconnect();
+      };
+      this.ws.onerror = (event) => {
+        this.isConnecting = false;
+        const error = new Error("WebSocket error");
+        this.options.onError(error);
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.options.onMessage(message);
+        } catch (e) {
+        }
+      };
+    } catch (error) {
+      this.isConnecting = false;
+      this.options.onError(error instanceof Error ? error : new Error(String(error)));
+      this.attemptReconnect();
+    }
+  }
+  /**
+   * Closes the WebSocket connection
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    this.stopFlushTimer();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Sends a message (adds to buffer)
+   */
+  send(message) {
+    this.buffer.push(message);
+    if (this.buffer.length >= this.options.batchSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Flushes the buffer immediately
+   */
+  flush() {
+    if (this.buffer.length === 0) {
+      return;
+    }
+    if (this.ws && this.ws.readyState === 1) {
+      try {
+        const batch = {
+          type: "MUTATION_BATCH",
+          payload: {
+            mutations: this.buffer.map((m) => m.payload),
+            timestamp: Date.now()
+          }
+        };
+        this.ws.send(JSON.stringify(batch));
+        this.buffer = [];
+      } catch (error) {
+        this.options.onError(
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    }
+  }
+  /**
+   * Checks if transport is connected
+   */
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === 1;
+  }
+  /**
+   * Gets the current buffer size
+   */
+  getBufferSize() {
+    return this.buffer.length;
+  }
+  startFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.options.flushInterval);
+  }
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  attemptReconnect() {
+    if (!this.shouldReconnect) {
+      return;
+    }
+    if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+      this.options.onError(new Error("Max reconnection attempts reached"));
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.options.reconnectDelay * Math.pow(1.5, this.reconnectAttempts - 1);
+    setTimeout(() => {
+      if (this.shouldReconnect) {
+        this.connect();
+      }
+    }, Math.min(delay, 3e4));
+  }
+};
+
+// src/instrument/client.ts
+var StateSurgeonClient = class {
+  constructor(options = {}) {
+    this.transport = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.isConnected = false;
+    // Track mutations locally for offline support
+    this.localMutations = [];
+    this.maxLocalMutations = 1e4;
+    this.sessionId = options.sessionId || generateSessionId();
+    this.appId = options.appId || "default";
+    this.debug = options.debug || false;
+    this.serverUrl = options.serverUrl || "ws://localhost:8081";
+    this.transportOptions = {
+      batchSize: options.batchSize || 50,
+      flushInterval: options.flushInterval || 100,
+      ...options.transport
+    };
+    if (options.autoConnect !== false) {
+      this.connect();
+    }
+    this.log("State Surgeon Client initialized", { sessionId: this.sessionId, appId: this.appId });
+  }
+  /**
+   * Connects to the recorder server
+   */
+  connect() {
+    if (this.transport) {
+      return;
+    }
+    this.transport = new MutationTransport(this.serverUrl, {
+      ...this.transportOptions,
+      onConnect: () => {
+        this.isConnected = true;
+        this.log("Connected to State Surgeon recorder");
+        this.sendHandshake();
+      },
+      onDisconnect: () => {
+        this.isConnected = false;
+        this.log("Disconnected from State Surgeon recorder");
+      },
+      onError: (error) => {
+        this.log("Transport error:", error);
+      }
+    });
+    this.transport.connect();
+  }
+  /**
+   * Disconnects from the recorder server
+   */
+  disconnect() {
+    if (this.transport) {
+      this.transport.disconnect();
+      this.transport = null;
+    }
+    this.isConnected = false;
+  }
+  /**
+   * Sends the initial handshake to register the session
+   */
+  sendHandshake() {
+    if (this.transport) {
+      this.transport.send({
+        type: "REGISTER_SESSION",
+        payload: {
+          appId: this.appId,
+          sessionId: this.sessionId,
+          timestamp: Date.now(),
+          userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "node",
+          url: typeof window !== "undefined" ? window.location.href : void 0
+        }
+      });
+    }
+  }
+  /**
+   * Records a mutation
+   */
+  recordMutation(mutation) {
+    this.localMutations.push(mutation);
+    if (this.localMutations.length > this.maxLocalMutations) {
+      this.localMutations.shift();
+    }
+    for (const listener of this.listeners) {
+      try {
+        listener(mutation);
+      } catch (error) {
+        this.log("Listener error:", error);
+      }
+    }
+    if (this.transport && this.isConnected) {
+      this.transport.send({
+        type: "MUTATION_RECORDED",
+        payload: mutation
+      });
+    }
+    this.log("Mutation recorded:", mutation.id, mutation.source);
+  }
+  /**
+   * Creates and records a mutation from state change
+   */
+  captureStateChange(source, previousState, nextState, options = {}) {
+    const mutation = createMutation({
+      source,
+      sessionId: this.sessionId,
+      previousState: deepClone(previousState),
+      nextState: deepClone(nextState),
+      actionType: options.actionType || "CUSTOM",
+      actionPayload: options.actionPayload,
+      component: options.component,
+      function: options.function,
+      captureStack: true
+    });
+    mutation.diff = calculateDiff(mutation.previousState, mutation.nextState);
+    this.recordMutation(mutation);
+    return mutation;
+  }
+  /**
+   * Adds a mutation listener
+   */
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Gets the current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Gets all local mutations
+   */
+  getMutations() {
+    return [...this.localMutations];
+  }
+  /**
+   * Clears local mutations
+   */
+  clearMutations() {
+    this.localMutations = [];
+  }
+  /**
+   * Checks if connected to server
+   */
+  isServerConnected() {
+    return this.isConnected;
+  }
+  /**
+   * Flushes any pending mutations
+   */
+  flush() {
+    if (this.transport) {
+      this.transport.flush();
+    }
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[State Surgeon]", ...args);
+    }
+  }
+};
+var globalClient = null;
+function getClient(options) {
+  if (!globalClient) {
+    globalClient = new StateSurgeonClient(options);
+  }
+  return globalClient;
+}
+
+// src/instrument/api.ts
+var originalFetch = null;
+var fetchInstrumented = false;
+var originalXHROpen = null;
+var originalXHRSend = null;
+var xhrInstrumented = false;
+function instrumentFetch(options = {}) {
+  if (fetchInstrumented) {
+    console.warn("[State Surgeon] Fetch already instrumented");
+    return () => {
+    };
+  }
+  if (typeof fetch === "undefined") {
+    console.warn("[State Surgeon] Fetch not available in this environment");
+    return () => {
+    };
+  }
+  const client = options.client || getClient();
+  const ignoreUrls = options.ignoreUrls || [];
+  const captureRequestBody = options.captureRequestBody !== false;
+  const captureResponseBody = options.captureResponseBody !== false;
+  const maxBodySize = options.maxBodySize || 1e4;
+  originalFetch = fetch;
+  globalThis.fetch = async function instrumentedFetch(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (ignoreUrls.some((ignore) => url.includes(ignore))) {
+      return originalFetch(input, init);
+    }
+    const startTime = Date.now();
+    const requestId = `req_${startTime}_${Math.random().toString(36).slice(2, 8)}`;
+    const requestInfo = {
+      url,
+      method: init?.method || "GET",
+      headers: init?.headers
+    };
+    if (captureRequestBody && init?.body) {
+      requestInfo.body = truncateBody(init.body, maxBodySize);
+    }
+    try {
+      const response = await originalFetch(input, init);
+      const duration = Date.now() - startTime;
+      const clonedResponse = response.clone();
+      const responseInfo = {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries())
+      };
+      if (captureResponseBody) {
+        try {
+          const text = await clonedResponse.text();
+          responseInfo.body = truncateBody(text, maxBodySize);
+        } catch {
+          responseInfo.body = "[Unable to read response body]";
+        }
+      }
+      client.captureStateChange("api", requestInfo, responseInfo, {
+        actionType: "API_RESPONSE",
+        actionPayload: {
+          requestId,
+          url,
+          method: requestInfo.method,
+          status: response.status,
+          duration
+        },
+        function: "fetch"
+      });
+      return response;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      client.captureStateChange("api", requestInfo, {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      }, {
+        actionType: "API_RESPONSE",
+        actionPayload: {
+          requestId,
+          url,
+          method: requestInfo.method,
+          status: 0,
+          error: true,
+          duration
+        },
+        function: "fetch"
+      });
+      throw error;
+    }
+  };
+  fetchInstrumented = true;
+  return () => {
+    if (originalFetch) {
+      globalThis.fetch = originalFetch;
+      originalFetch = null;
+    }
+    fetchInstrumented = false;
+  };
+}
+function instrumentXHR(options = {}) {
+  if (xhrInstrumented) {
+    console.warn("[State Surgeon] XHR already instrumented");
+    return () => {
+    };
+  }
+  if (typeof XMLHttpRequest === "undefined") {
+    console.warn("[State Surgeon] XMLHttpRequest not available in this environment");
+    return () => {
+    };
+  }
+  const client = options.client || getClient();
+  const ignoreUrls = options.ignoreUrls || [];
+  const captureResponseBody = options.captureResponseBody !== false;
+  const maxBodySize = options.maxBodySize || 1e4;
+  originalXHROpen = XMLHttpRequest.prototype.open;
+  originalXHRSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function(method, url, async = true, username, password) {
+    this._stateSurgeon = {
+      method,
+      url: url.toString(),
+      startTime: 0
+    };
+    return originalXHROpen.call(this, method, url, async, username, password);
+  };
+  XMLHttpRequest.prototype.send = function(body) {
+    const info = this._stateSurgeon;
+    if (!info || ignoreUrls.some((ignore) => info.url.includes(ignore))) {
+      return originalXHRSend.call(this, body);
+    }
+    info.startTime = Date.now();
+    const requestId = `xhr_${info.startTime}_${Math.random().toString(36).slice(2, 8)}`;
+    const requestInfo = {
+      url: info.url,
+      method: info.method
+    };
+    this.addEventListener("loadend", () => {
+      const duration = Date.now() - info.startTime;
+      const responseInfo = {
+        status: this.status,
+        statusText: this.statusText
+      };
+      if (captureResponseBody && this.responseText) {
+        responseInfo.body = truncateBody(this.responseText, maxBodySize);
+      }
+      client.captureStateChange("api", requestInfo, responseInfo, {
+        actionType: "API_RESPONSE",
+        actionPayload: {
+          requestId,
+          url: info.url,
+          method: info.method,
+          status: this.status,
+          duration
+        },
+        function: "XMLHttpRequest"
+      });
+    });
+    return originalXHRSend.call(this, body);
+  };
+  xhrInstrumented = true;
+  return () => {
+    if (originalXHROpen) {
+      XMLHttpRequest.prototype.open = originalXHROpen;
+      originalXHROpen = null;
+    }
+    if (originalXHRSend) {
+      XMLHttpRequest.prototype.send = originalXHRSend;
+      originalXHRSend = null;
+    }
+    xhrInstrumented = false;
+  };
+}
+function truncateBody(body, maxSize) {
+  let str;
+  if (typeof body === "string") {
+    str = body;
+  } else if (body instanceof FormData) {
+    str = "[FormData]";
+  } else if (body instanceof Blob) {
+    str = `[Blob: ${body.size} bytes]`;
+  } else if (body instanceof ArrayBuffer) {
+    str = `[ArrayBuffer: ${body.byteLength} bytes]`;
+  } else {
+    try {
+      str = JSON.stringify(body);
+    } catch {
+      str = String(body);
+    }
+  }
+  if (str.length > maxSize) {
+    return str.slice(0, maxSize) + "... [truncated]";
+  }
+  return str;
+}
+
+// src/instrument/react.ts
+var originalUseState = null;
+var originalUseReducer = null;
+var isInstrumented = false;
+function instrumentReact(React, options = {}) {
+  if (isInstrumented) {
+    console.warn("[State Surgeon] React already instrumented");
+    return () => {
+    };
+  }
+  const client = options.client || getClient();
+  const captureComponentName = options.captureComponentName !== false;
+  originalUseState = React.useState;
+  originalUseReducer = React.useReducer;
+  React.useState = function(initialState) {
+    const [state, originalSetState] = originalUseState(initialState);
+    const instrumentedSetState = (newStateOrUpdater) => {
+      const previousState = deepClone(state);
+      const newState = typeof newStateOrUpdater === "function" ? newStateOrUpdater(state) : newStateOrUpdater;
+      client.captureStateChange("react", previousState, newState, {
+        actionType: "SET_STATE",
+        component: captureComponentName ? getComponentName() : void 0,
+        function: "useState"
+      });
+      return originalSetState(newStateOrUpdater);
+    };
+    return [state, instrumentedSetState];
+  };
+  React.useReducer = function(reducer, initialArg, init) {
+    const instrumentedReducer = ((state, action) => {
+      const previousState = deepClone(state);
+      const newState = reducer(state, action);
+      client.captureStateChange("react", previousState, newState, {
+        actionType: "DISPATCH",
+        actionPayload: action,
+        component: captureComponentName ? getComponentName() : void 0,
+        function: "useReducer"
+      });
+      return newState;
+    });
+    return originalUseReducer(instrumentedReducer, initialArg, init);
+  };
+  isInstrumented = true;
+  return () => {
+    if (originalUseState) {
+      React.useState = originalUseState;
+    }
+    if (originalUseReducer) {
+      React.useReducer = originalUseReducer;
+    }
+    isInstrumented = false;
+    originalUseState = null;
+    originalUseReducer = null;
+  };
+}
+function getComponentName() {
+  const stack = new Error().stack;
+  if (!stack) return void 0;
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    if (line.includes("instrumentedSetState") || line.includes("instrumentedReducer") || line.includes("useState") || line.includes("useReducer") || line.includes("react-dom") || line.includes("react.development")) {
+      continue;
+    }
+    const match = line.match(/at\s+([A-Z][A-Za-z0-9_]*)/);
+    if (match) {
+      return match[1];
+    }
+  }
+  return void 0;
+}
+
+// src/instrument/redux.ts
+function createReduxMiddleware(options = {}) {
+  const client = options.client || getClient();
+  const ignoreActions = new Set(options.ignoreActions || []);
+  const storeName = options.storeName || "redux";
+  return (storeAPI) => (next) => (action) => {
+    const actionType = action?.type;
+    if (actionType && ignoreActions.has(actionType)) {
+      return next(action);
+    }
+    const previousState = deepClone(storeAPI.getState());
+    const startTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const result = next(action);
+    const nextState = deepClone(storeAPI.getState());
+    const duration = (typeof performance !== "undefined" ? performance.now() : Date.now()) - startTime;
+    const mutation = client.captureStateChange("redux", previousState, nextState, {
+      actionType: "DISPATCH",
+      actionPayload: action,
+      component: storeName,
+      function: actionType || "dispatch"
+    });
+    mutation.duration = duration;
+    return result;
+  };
+}
+function instrumentReduxStore(store, options = {}) {
+  const client = options.client || getClient();
+  const ignoreActions = new Set(options.ignoreActions || []);
+  const storeName = options.storeName || "redux";
+  const originalDispatch = store.dispatch;
+  store.dispatch = function instrumentedDispatch(action) {
+    const actionType = action?.type;
+    if (actionType && ignoreActions.has(actionType)) {
+      return originalDispatch(action);
+    }
+    const previousState = deepClone(store.getState());
+    const startTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const result = originalDispatch(action);
+    const nextState = deepClone(store.getState());
+    const duration = (typeof performance !== "undefined" ? performance.now() : Date.now()) - startTime;
+    const mutation = client.captureStateChange("redux", previousState, nextState, {
+      actionType: "DISPATCH",
+      actionPayload: action,
+      component: storeName,
+      function: actionType || "dispatch"
+    });
+    mutation.duration = duration;
+    return result;
+  };
+  return () => {
+    store.dispatch = originalDispatch;
+  };
+}
+
+// src/instrument/zustand.ts
+function instrumentZustand(stateCreator, options = {}) {
+  const client = options.client || getClient();
+  const storeName = options.storeName || "zustand";
+  return (set, get, api) => {
+    const instrumentedSet = (partial, replace) => {
+      const previousState = deepClone(get());
+      set(partial, replace);
+      const nextState = deepClone(get());
+      client.captureStateChange("zustand", previousState, nextState, {
+        actionType: "SET_STATE",
+        actionPayload: typeof partial === "function" ? "updater function" : partial,
+        component: storeName,
+        function: "set"
+      });
+    };
+    return stateCreator(instrumentedSet, get, api);
+  };
+}
+
+// src/recorder/index.ts
+var recorder_exports = {};
+__export(recorder_exports, {
+  MutationStore: () => MutationStore,
+  TimelineReconstructor: () => TimelineReconstructor,
+  createAPIRoutes: () => createAPIRoutes,
+  createRecorderServer: () => createRecorderServer
+});
+function createAPIRoutes(store, reconstructor) {
+  const router = express.Router();
+  router.get("/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: Date.now() });
+  });
+  router.get("/sessions", (req, res) => {
+    try {
+      const appId = req.query.appId;
+      const sessions = store.getSessions(appId);
+      res.json({ sessions });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId", (req, res) => {
+    try {
+      const session = store.getSession(req.params.sessionId);
+      if (!session) {
+        return res.status(404).json({ error: "Session not found" });
+      }
+      res.json({ session });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.delete("/sessions/:sessionId", (req, res) => {
+    try {
+      const deleted = store.deleteSession(req.params.sessionId);
+      res.json({ deleted });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId/timeline", (req, res) => {
+    try {
+      const timeline = store.getTimeline(req.params.sessionId);
+      res.json({ timeline, count: timeline.length });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations", (req, res) => {
+    try {
+      const options = {
+        sessionId: req.query.sessionId,
+        startTime: req.query.startTime ? Number(req.query.startTime) : void 0,
+        endTime: req.query.endTime ? Number(req.query.endTime) : void 0,
+        source: req.query.source,
+        component: req.query.component,
+        limit: req.query.limit ? Number(req.query.limit) : 100,
+        offset: req.query.offset ? Number(req.query.offset) : 0,
+        sortOrder: req.query.sortOrder || "asc"
+      };
+      const mutations = store.queryMutations(options);
+      res.json({ mutations, count: mutations.length });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations/:mutationId", (req, res) => {
+    try {
+      const mutation = store.getMutation(req.params.mutationId);
+      if (!mutation) {
+        return res.status(404).json({ error: "Mutation not found" });
+      }
+      res.json({ mutation });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations/:mutationId/state", async (req, res) => {
+    try {
+      const state = await reconstructor.getStateAtMutation(req.params.mutationId);
+      res.json({ state });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations/:mutationId/chain", async (req, res) => {
+    try {
+      const maxDepth = req.query.maxDepth ? Number(req.query.maxDepth) : 100;
+      const chain = await reconstructor.findCausalChain(req.params.mutationId, maxDepth);
+      res.json({ chain });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId/path", async (req, res) => {
+    try {
+      const path = req.query.path;
+      if (!path) {
+        return res.status(400).json({ error: "Path is required" });
+      }
+      const mutations = await reconstructor.findMutationsForPath(req.params.sessionId, path);
+      res.json({ mutations, count: mutations.length });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId/summary", async (req, res) => {
+    try {
+      const startTime = Number(req.query.startTime);
+      const endTime = Number(req.query.endTime);
+      if (isNaN(startTime) || isNaN(endTime)) {
+        return res.status(400).json({ error: "startTime and endTime are required" });
+      }
+      const summary = await reconstructor.summarizeTimeRange(
+        req.params.sessionId,
+        startTime,
+        endTime
+      );
+      res.json({ summary });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/stats", (_req, res) => {
+    try {
+      const stats = store.getStats();
+      res.json({ stats });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.delete("/clear", (_req, res) => {
+    try {
+      store.clear();
+      reconstructor.clearCache();
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  return router;
+}
+
+// src/recorder/reconstructor.ts
+var TimelineReconstructor = class {
+  constructor(store) {
+    this.stateCache = /* @__PURE__ */ new Map();
+    this.maxCacheSize = 1e3;
+    this.store = store;
+  }
+  /**
+   * Reconstructs the state at a specific mutation
+   */
+  async getStateAtMutation(mutationId) {
+    const cached = this.stateCache.get(mutationId);
+    if (cached !== void 0) {
+      return deepClone(cached);
+    }
+    const targetMutation = this.store.getMutation(mutationId);
+    if (!targetMutation) {
+      throw new Error(`Mutation not found: ${mutationId}`);
+    }
+    const timeline = this.store.getTimeline(targetMutation.sessionId);
+    const targetIndex = timeline.findIndex((m) => m.id === mutationId);
+    if (targetIndex === -1) {
+      throw new Error(`Mutation not in timeline: ${mutationId}`);
+    }
+    let state = {};
+    for (let i = 0; i <= targetIndex; i++) {
+      const mutation = timeline[i];
+      state = mutation.nextState;
+      this.cacheState(mutation.id, state);
+    }
+    return deepClone(state);
+  }
+  /**
+   * Reconstructs the state at a specific timestamp
+   */
+  async getStateAtTime(sessionId, timestamp) {
+    const timeline = this.store.getTimeline(sessionId);
+    let lastMutation = null;
+    for (const mutation of timeline) {
+      if (mutation.timestamp <= timestamp) {
+        lastMutation = mutation;
+      } else {
+        break;
+      }
+    }
+    if (!lastMutation) {
+      return {};
+    }
+    return this.getStateAtMutation(lastMutation.id);
+  }
+  /**
+   * Finds the causal chain leading to a mutation
+   */
+  async findCausalChain(mutationId, maxDepth = 100) {
+    const chain = [];
+    let currentId = mutationId;
+    let depth = 0;
+    while (currentId && depth < maxDepth) {
+      const mutation = this.store.getMutation(currentId);
+      if (!mutation) break;
+      chain.push(mutation);
+      if (mutation.parentMutationId) {
+        currentId = mutation.parentMutationId;
+      } else if (mutation.causes && mutation.causes.length > 0) {
+        currentId = mutation.causes[0];
+      } else {
+        break;
+      }
+      depth++;
+    }
+    return {
+      mutations: chain.reverse(),
+      rootCause: chain[0]
+    };
+  }
+  /**
+   * Binary search to find when state became invalid
+   */
+  async findStateCorruption(sessionId, validator) {
+    const timeline = this.store.getTimeline(sessionId);
+    if (timeline.length === 0) {
+      return null;
+    }
+    let left = 0;
+    let right = timeline.length - 1;
+    let firstBad = null;
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const state = await this.getStateAtMutation(timeline[mid].id);
+      const isValid = validator(state);
+      if (isValid) {
+        left = mid + 1;
+      } else {
+        firstBad = mid;
+        right = mid - 1;
+      }
+    }
+    return firstBad !== null ? timeline[firstBad] : null;
+  }
+  /**
+   * Finds all mutations that touched a specific path
+   */
+  async findMutationsForPath(sessionId, path) {
+    const timeline = this.store.getTimeline(sessionId);
+    const result = [];
+    for (const mutation of timeline) {
+      if (mutation.diff) {
+        for (const diff of mutation.diff) {
+          if (diff.path === path || diff.path.startsWith(path + ".") || diff.path.startsWith(path + "[")) {
+            result.push(mutation);
+            break;
+          }
+        }
+      } else {
+        const prevValue = getValueAtPath(mutation.previousState, path);
+        const nextValue = getValueAtPath(mutation.nextState, path);
+        if (prevValue !== nextValue) {
+          result.push(mutation);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Compares two sessions to find divergence points
+   */
+  async compareSessions(sessionId1, sessionId2) {
+    const timeline1 = this.store.getTimeline(sessionId1);
+    const timeline2 = this.store.getTimeline(sessionId2);
+    let divergencePoint;
+    const minLength = Math.min(timeline1.length, timeline2.length);
+    for (let i = 0; i < minLength; i++) {
+      const state1 = await this.getStateAtMutation(timeline1[i].id);
+      const state2 = await this.getStateAtMutation(timeline2[i].id);
+      if (JSON.stringify(state1) !== JSON.stringify(state2)) {
+        divergencePoint = i;
+        break;
+      }
+    }
+    const actions1 = new Set(timeline1.map((m) => `${m.actionType}:${JSON.stringify(m.actionPayload)}`));
+    const actions2 = new Set(timeline2.map((m) => `${m.actionType}:${JSON.stringify(m.actionPayload)}`));
+    const session1Only = timeline1.filter(
+      (m) => !actions2.has(`${m.actionType}:${JSON.stringify(m.actionPayload)}`)
+    );
+    const session2Only = timeline2.filter(
+      (m) => !actions1.has(`${m.actionType}:${JSON.stringify(m.actionPayload)}`)
+    );
+    return {
+      divergencePoint,
+      session1Only,
+      session2Only
+    };
+  }
+  /**
+   * Generates a summary of what happened in a time range
+   */
+  async summarizeTimeRange(sessionId, startTime, endTime) {
+    const mutations = this.store.queryMutations({
+      sessionId,
+      startTime,
+      endTime
+    });
+    const componentBreakdown = {};
+    const sourceBreakdown = {};
+    const pathsSet = /* @__PURE__ */ new Set();
+    for (const mutation of mutations) {
+      const component = mutation.component || "unknown";
+      componentBreakdown[component] = (componentBreakdown[component] || 0) + 1;
+      sourceBreakdown[mutation.source] = (sourceBreakdown[mutation.source] || 0) + 1;
+      if (mutation.diff) {
+        for (const diff of mutation.diff) {
+          pathsSet.add(diff.path);
+        }
+      }
+    }
+    return {
+      mutationCount: mutations.length,
+      componentBreakdown,
+      sourceBreakdown,
+      pathsChanged: Array.from(pathsSet)
+    };
+  }
+  /**
+   * Clears the state cache
+   */
+  clearCache() {
+    this.stateCache.clear();
+  }
+  cacheState(mutationId, state) {
+    if (this.stateCache.size >= this.maxCacheSize) {
+      const firstKey = this.stateCache.keys().next().value;
+      if (firstKey) {
+        this.stateCache.delete(firstKey);
+      }
+    }
+    this.stateCache.set(mutationId, deepClone(state));
+  }
+};
+
+// src/recorder/store.ts
+var MutationStore = class {
+  constructor(options = {}) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.mutations = /* @__PURE__ */ new Map();
+    this.totalMutationCount = 0;
+    this.options = {
+      maxMutationsPerSession: options.maxMutationsPerSession ?? 1e4,
+      maxTotalMutations: options.maxTotalMutations ?? 1e5,
+      sessionTimeout: options.sessionTimeout ?? 30 * 60 * 1e3,
+      // 30 minutes
+      debug: options.debug ?? false
+    };
+  }
+  /**
+   * Creates or updates a session
+   */
+  registerSession(sessionId, appId, metadata) {
+    let session = this.sessions.get(sessionId);
+    if (!session) {
+      session = {
+        id: sessionId,
+        appId,
+        startTime: /* @__PURE__ */ new Date(),
+        metadata,
+        mutationCount: 0
+      };
+      this.sessions.set(sessionId, session);
+      this.mutations.set(sessionId, []);
+      this.log("Session registered:", sessionId);
+    }
+    return session;
+  }
+  /**
+   * Ends a session
+   */
+  endSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.endTime = /* @__PURE__ */ new Date();
+      this.log("Session ended:", sessionId);
+    }
+  }
+  /**
+   * Stores a mutation
+   */
+  storeMutation(mutation) {
+    const sessionId = mutation.sessionId;
+    if (!this.sessions.has(sessionId)) {
+      this.registerSession(sessionId, "unknown");
+    }
+    let sessionMutations = this.mutations.get(sessionId);
+    if (!sessionMutations) {
+      sessionMutations = [];
+      this.mutations.set(sessionId, sessionMutations);
+    }
+    if (!mutation.diff && mutation.previousState !== void 0 && mutation.nextState !== void 0) {
+      mutation.diff = calculateDiff(mutation.previousState, mutation.nextState);
+    }
+    if (sessionMutations.length >= this.options.maxMutationsPerSession) {
+      sessionMutations.shift();
+      this.totalMutationCount--;
+    }
+    if (this.totalMutationCount >= this.options.maxTotalMutations) {
+      this.evictOldestMutations();
+    }
+    sessionMutations.push(mutation);
+    this.totalMutationCount++;
+    const session = this.sessions.get(sessionId);
+    session.mutationCount++;
+    this.log("Mutation stored:", mutation.id);
+  }
+  /**
+   * Stores multiple mutations at once
+   */
+  storeMutations(mutations) {
+    for (const mutation of mutations) {
+      this.storeMutation(mutation);
+    }
+  }
+  /**
+   * Gets a session by ID
+   */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  /**
+   * Gets all sessions
+   */
+  getSessions(appId) {
+    const sessions = Array.from(this.sessions.values());
+    if (appId) {
+      return sessions.filter((s) => s.appId === appId);
+    }
+    return sessions;
+  }
+  /**
+   * Gets a specific mutation by ID
+   */
+  getMutation(mutationId) {
+    for (const sessionMutations of this.mutations.values()) {
+      const mutation = sessionMutations.find((m) => m.id === mutationId);
+      if (mutation) return mutation;
+    }
+    return void 0;
+  }
+  /**
+   * Queries mutations with filters
+   */
+  queryMutations(options = {}) {
+    let results = [];
+    if (options.sessionId) {
+      const sessionMutations = this.mutations.get(options.sessionId);
+      if (sessionMutations) {
+        results = [...sessionMutations];
+      }
+    } else {
+      for (const sessionMutations of this.mutations.values()) {
+        results.push(...sessionMutations);
+      }
+    }
+    if (options.startTime !== void 0) {
+      results = results.filter((m) => m.timestamp >= options.startTime);
+    }
+    if (options.endTime !== void 0) {
+      results = results.filter((m) => m.timestamp <= options.endTime);
+    }
+    if (options.source) {
+      results = results.filter((m) => m.source === options.source);
+    }
+    if (options.component) {
+      results = results.filter((m) => m.component === options.component);
+    }
+    results.sort((a, b) => {
+      const order = options.sortOrder === "desc" ? -1 : 1;
+      return (a.logicalClock - b.logicalClock) * order;
+    });
+    if (options.offset !== void 0) {
+      results = results.slice(options.offset);
+    }
+    if (options.limit !== void 0) {
+      results = results.slice(0, options.limit);
+    }
+    return results;
+  }
+  /**
+   * Gets the timeline for a session
+   */
+  getTimeline(sessionId) {
+    const mutations = this.mutations.get(sessionId) || [];
+    return [...mutations].sort((a, b) => a.logicalClock - b.logicalClock);
+  }
+  /**
+   * Deletes a session and its mutations
+   */
+  deleteSession(sessionId) {
+    const sessionMutations = this.mutations.get(sessionId);
+    if (sessionMutations) {
+      this.totalMutationCount -= sessionMutations.length;
+    }
+    this.mutations.delete(sessionId);
+    return this.sessions.delete(sessionId);
+  }
+  /**
+   * Clears all data
+   */
+  clear() {
+    this.sessions.clear();
+    this.mutations.clear();
+    this.totalMutationCount = 0;
+    this.log("Store cleared");
+  }
+  /**
+   * Gets store statistics
+   */
+  getStats() {
+    const mutationsPerSession = {};
+    for (const [sessionId, mutations] of this.mutations.entries()) {
+      mutationsPerSession[sessionId] = mutations.length;
+    }
+    return {
+      sessionCount: this.sessions.size,
+      totalMutations: this.totalMutationCount,
+      mutationsPerSession
+    };
+  }
+  /**
+   * Evicts oldest mutations when capacity is exceeded
+   */
+  evictOldestMutations() {
+    let oldestSession = null;
+    let oldestTime = Infinity;
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (session.startTime.getTime() < oldestTime) {
+        oldestTime = session.startTime.getTime();
+        oldestSession = sessionId;
+      }
+    }
+    if (oldestSession) {
+      const mutations = this.mutations.get(oldestSession);
+      if (mutations && mutations.length > 0) {
+        mutations.shift();
+        this.totalMutationCount--;
+        this.log("Evicted oldest mutation from:", oldestSession);
+      }
+    }
+  }
+  log(...args) {
+    if (this.options.debug) {
+      console.log("[MutationStore]", ...args);
+    }
+  }
+};
+
+// src/recorder/server.ts
+function createRecorderServer(options = {}) {
+  const port = options.port ?? 8080;
+  const wsPort = options.wsPort ?? 8081;
+  const apiPath = options.apiPath ?? "/api";
+  const debug = options.debug ?? false;
+  const store = new MutationStore(options.storeOptions);
+  const reconstructor = new TimelineReconstructor(store);
+  const app = express__default.default();
+  app.use(express__default.default.json({ limit: "10mb" }));
+  if (options.cors !== false) {
+    app.use((_req, res, next) => {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+      next();
+    });
+  }
+  app.use(apiPath, createAPIRoutes(store, reconstructor));
+  app.get("/_surgeon", (_req, res) => {
+    res.send(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>State Surgeon Dashboard</title>
+          <style>
+            body { font-family: system-ui, sans-serif; padding: 2rem; background: #1a1a2e; color: #eee; }
+            h1 { color: #00d9ff; }
+            .stats { background: #16213e; padding: 1rem; border-radius: 8px; margin: 1rem 0; }
+            pre { background: #0f0f23; padding: 1rem; border-radius: 4px; overflow: auto; }
+          </style>
+        </head>
+        <body>
+          <h1>\u{1F52C} State Surgeon Dashboard</h1>
+          <p>Recorder is running. Connect your application to start capturing mutations.</p>
+          <div class="stats">
+            <h3>Quick Stats</h3>
+            <div id="stats">Loading...</div>
+          </div>
+          <h3>Recent Sessions</h3>
+          <pre id="sessions">Loading...</pre>
+          <script>
+            async function loadData() {
+              try {
+                const statsRes = await fetch('${apiPath}/stats');
+                const stats = await statsRes.json();
+                document.getElementById('stats').innerHTML =
+                  '<pre>' + JSON.stringify(stats, null, 2) + '</pre>';
+
+                const sessionsRes = await fetch('${apiPath}/sessions');
+                const sessions = await sessionsRes.json();
+                document.getElementById('sessions').textContent =
+                  JSON.stringify(sessions, null, 2);
+              } catch (e) {
+                document.getElementById('stats').textContent = 'Error loading stats';
+              }
+            }
+            loadData();
+            setInterval(loadData, 5000);
+          </script>
+        </body>
+      </html>
+    `);
+  });
+  const httpServer = app.listen(0);
+  httpServer.close();
+  let wss;
+  const clients = /* @__PURE__ */ new Map();
+  function log(...args) {
+    if (debug) {
+      console.log("[State Surgeon Recorder]", ...args);
+    }
+  }
+  function handleMessage(ws, message) {
+    log("Received message:", message.type);
+    switch (message.type) {
+      case "REGISTER_SESSION": {
+        const payload = message.payload;
+        store.registerSession(payload.sessionId, payload.appId, {
+          userAgent: payload.userAgent,
+          url: payload.url
+        });
+        clients.set(ws, { sessionId: payload.sessionId });
+        ws.send(JSON.stringify({
+          type: "SESSION_CONFIRMED",
+          payload: { sessionId: payload.sessionId }
+        }));
+        log("Session registered:", payload.sessionId);
+        break;
+      }
+      case "MUTATION_RECORDED": {
+        const mutation = message.payload;
+        store.storeMutation(mutation);
+        ws.send(JSON.stringify({
+          type: "MUTATION_ACKNOWLEDGED",
+          payload: { mutationId: mutation.id, receivedAt: Date.now() }
+        }));
+        break;
+      }
+      case "MUTATION_BATCH": {
+        const payload = message.payload;
+        store.storeMutations(payload.mutations);
+        ws.send(JSON.stringify({
+          type: "BATCH_ACKNOWLEDGED",
+          payload: { count: payload.mutations.length, receivedAt: Date.now() }
+        }));
+        log("Batch received:", payload.mutations.length, "mutations");
+        break;
+      }
+      case "END_SESSION": {
+        const clientInfo = clients.get(ws);
+        if (clientInfo?.sessionId) {
+          store.endSession(clientInfo.sessionId);
+          log("Session ended:", clientInfo.sessionId);
+        }
+        break;
+      }
+      default:
+        log("Unknown message type:", message.type);
+    }
+  }
+  const server = {
+    app,
+    httpServer: null,
+    wss: null,
+    store,
+    reconstructor,
+    async start() {
+      return new Promise((resolve) => {
+        server.httpServer = app.listen(port, () => {
+          log(`HTTP server listening on port ${port}`);
+        });
+        wss = new ws.WebSocketServer({ port: wsPort });
+        server.wss = wss;
+        wss.on("connection", (ws) => {
+          log("Client connected");
+          clients.set(ws, {});
+          ws.on("message", (data) => {
+            try {
+              const message = JSON.parse(data.toString());
+              handleMessage(ws, message);
+            } catch (error) {
+              log("Error parsing message:", error);
+            }
+          });
+          ws.on("close", () => {
+            const clientInfo = clients.get(ws);
+            if (clientInfo?.sessionId) {
+              store.endSession(clientInfo.sessionId);
+            }
+            clients.delete(ws);
+            log("Client disconnected");
+          });
+          ws.on("error", (error) => {
+            log("WebSocket error:", error);
+          });
+        });
+        wss.on("listening", () => {
+          log(`WebSocket server listening on port ${wsPort}`);
+          resolve();
+        });
+      });
+    },
+    async stop() {
+      return new Promise((resolve) => {
+        for (const ws of clients.keys()) {
+          ws.close();
+        }
+        clients.clear();
+        if (wss) {
+          wss.close(() => {
+            log("WebSocket server closed");
+          });
+        }
+        if (server.httpServer) {
+          server.httpServer.close(() => {
+            log("HTTP server closed");
+            resolve();
+          });
+        } else {
+          resolve();
+        }
+      });
+    }
+  };
+  return server;
+}
+
+exports.applyDiff = applyDiff;
+exports.calculateDiff = calculateDiff;
+exports.compress = compress;
+exports.createMutation = createMutation;
+exports.debounce = debounce;
+exports.decompress = decompress;
+exports.deepClone = deepClone;
+exports.deepEqual = deepEqual;
+exports.deepMerge = deepMerge;
+exports.formatBytes = formatBytes;
+exports.formatDuration = formatDuration;
+exports.generateSessionId = generateSessionId;
+exports.getLogicalClock = getLogicalClock;
+exports.getValueAtPath = getValueAtPath;
+exports.instrument = instrument_exports;
+exports.isBrowser = isBrowser;
+exports.isNode = isNode;
+exports.parseCallStack = parseCallStack;
+exports.recorder = recorder_exports;
+exports.resetLogicalClock = resetLogicalClock;
+exports.safeParse = safeParse;
+exports.safeStringify = safeStringify;
+exports.setValueAtPath = setValueAtPath;
+exports.simpleHash = simpleHash;
+exports.throttle = throttle;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map