state-surgeon 1.0.0

package/dist/instrument/index.mjs

@@ -0,0 +1,819 @@
+import { v4 } from 'uuid';
+
+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');
+});
+
+// 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;
+}
+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()}_${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 generateSessionId() {
+  return `session_${Date.now()}_${v4().slice(0, 8)}`;
+}
+
+// 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);
+  };
+}
+
+export { MutationTransport, StateSurgeonClient, createReduxMiddleware, instrumentFetch, instrumentReact, instrumentReduxStore, instrumentXHR, instrumentZustand };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map