@flotrace/runtime 0.1.2 → 2.0.0

package/dist/index.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -30,1887 +31,147 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   FloTraceProvider: () => FloTraceProvider,
-  FloTraceWebSocketClient: () => FloTraceWebSocketClient,
-  disposeWebSocketClient: () => disposeWebSocketClient,
-  getDetailedRenderReason: () => getDetailedRenderReason,
-  getFiberRefMap: () => getFiberRefMap,
-  getNodeEffects: () => getNodeEffects,
-  getNodeHooks: () => getNodeHooks,
-  getTimeline: () => getTimeline,
-  getWebSocketClient: () => getWebSocketClient,
-  inspectEffects: () => inspectEffects,
-  inspectHooks: () => inspectHooks,
-  installFiberTreeWalker: () => installFiberTreeWalker,
   installNetworkTracker: () => installNetworkTracker,
-  installReduxTracker: () => installReduxTracker,
   installRouterTracker: () => installRouterTracker,
-  installTanStackQueryTracker: () => installTanStackQueryTracker,
-  installTimelineTracker: () => installTimelineTracker,
-  installZustandTracker: () => installZustandTracker,
-  isReduxStore: () => isReduxStore,
-  isTanStackQueryClient: () => isTanStackQueryClient,
-  recordTimelineEvent: () => recordTimelineEvent,
-  requestTreeSnapshot: () => requestTreeSnapshot,
-  serializeProps: () => serializeProps,
-  serializeValue: () => serializeValue,
-  uninstallFiberTreeWalker: () => uninstallFiberTreeWalker,
   uninstallNetworkTracker: () => uninstallNetworkTracker,
-  uninstallReduxTracker: () => uninstallReduxTracker,
   uninstallRouterTracker: () => uninstallRouterTracker,
-  uninstallTanStackQueryTracker: () => uninstallTanStackQueryTracker,
-  uninstallTimelineTracker: () => uninstallTimelineTracker,
-  uninstallZustandTracker: () => uninstallZustandTracker,
   useFloTrace: () => useFloTrace,
   useTrackProps: () => useTrackProps,
   withFloTrace: () => withFloTrace
 });
 module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("@flotrace/runtime-core"), module.exports);
 
 // src/FloTraceProvider.tsx
 var import_react = __toESM(require("react"));
+var import_runtime_core3 = require("@flotrace/runtime-core");
 
-// src/types.ts
-var DEFAULT_CONFIG = {
-  host: "127.0.0.1",
-  port: 3457,
-  appName: "React App",
-  enabled: process.env.NODE_ENV === "development",
-  autoReconnect: true,
-  reconnectInterval: 2e3,
-  trackAllRenders: true,
-  includeProps: true,
-  trackZustand: true,
-  trackRedux: true,
-  trackRouter: true,
-  trackContext: true,
-  trackTanstackQuery: true
-};
-
-// src/websocketClient.ts
-var _FloTraceWebSocketClient = class _FloTraceWebSocketClient {
-  constructor(config = {}) {
-    this.ws = null;
-    this.messageQueue = [];
-    this.flushTimeout = null;
-    this.reconnectTimeout = null;
-    this.isConnecting = false;
-    this.reconnectAttempts = 0;
-    // Prevent unbounded queue growth when disconnected
-    this.messageHandlers = /* @__PURE__ */ new Set();
-    this.connectionHandlers = /* @__PURE__ */ new Set();
-    this.config = { ...DEFAULT_CONFIG, ...config };
+// src/routerTracker.ts
+var isInstalled = false;
+var debounceTimer = null;
+var client = null;
+var originalPushState = null;
+var originalReplaceState = null;
+var popstateHandler = null;
+var DEBOUNCE_MS = 200;
+function installRouterTracker(wsClient) {
+  if (isInstalled) {
+    console.warn("[FloTrace] Router tracker already installed, reinstalling");
+    uninstallRouterTracker();
   }
-  /**
-   * Connect to the FloTrace WebSocket server
-   */
-  connect() {
-    if (this.ws || this.isConnecting) {
-      return;
-    }
-    if (!this.config.enabled) {
-      console.log("[FloTrace] Runtime disabled, skipping connection");
-      return;
-    }
-    if (typeof WebSocket === "undefined") {
-      console.log("[FloTrace] WebSocket not available, skipping connection");
-      return;
-    }
-    this.isConnecting = true;
-    try {
-      const url = `ws://${this.config.host}:${this.config.port}`;
-      console.log(`[FloTrace] Connecting to ${url}...`);
-      this.ws = new WebSocket(url);
-      this.ws.onopen = () => {
-        this.isConnecting = false;
-        this.reconnectAttempts = 0;
-        console.log("[FloTrace] Connected to FloTrace desktop");
-        this.notifyConnectionChange(true);
-        let appUrl;
-        try {
-          appUrl = typeof window !== "undefined" && window.location ? window.location.href : void 0;
-        } catch {
-          appUrl = void 0;
-        }
-        this.send({
-          type: "runtime:ready",
-          appName: this.config.appName,
-          reactVersion: this.getReactVersion(),
-          appUrl
-        });
-        this.flush();
-      };
-      this.ws.onmessage = (event) => {
-        try {
-          const message = JSON.parse(event.data);
-          this.handleMessage(message);
-        } catch (error) {
-          console.error("[FloTrace] Failed to parse message:", error);
-        }
-      };
-      this.ws.onclose = () => {
-        this.isConnecting = false;
-        this.ws = null;
-        console.log("[FloTrace] Disconnected from VS Code extension");
-        this.notifyConnectionChange(false);
-        if (this.config.autoReconnect) {
-          this.scheduleReconnect();
-        }
-      };
-      this.ws.onerror = (error) => {
-        this.isConnecting = false;
-        console.error("[FloTrace] WebSocket error:", error);
-      };
-    } catch (error) {
-      this.isConnecting = false;
-      console.error("[FloTrace] Failed to connect:", error);
-      if (this.config.autoReconnect) {
-        this.scheduleReconnect();
-      }
-    }
+  if (typeof window === "undefined" || typeof history === "undefined") {
+    console.warn("[FloTrace] Router tracker requires a browser environment");
+    return;
   }
-  /**
-   * Disconnect from the server
-   */
-  disconnect() {
-    if (this.reconnectTimeout) {
-      clearTimeout(this.reconnectTimeout);
-      this.reconnectTimeout = null;
-    }
-    if (this.flushTimeout) {
-      clearTimeout(this.flushTimeout);
-      this.flushTimeout = null;
-    }
-    if (this.ws) {
+  console.log("[FloTrace] Installing router tracker");
+  try {
+    isInstalled = true;
+    client = wsClient;
+    originalPushState = history.pushState.bind(history);
+    originalReplaceState = history.replaceState.bind(history);
+    history.pushState = function(data, unused, url) {
+      originalPushState(data, unused, url);
       try {
-        this.send({ type: "runtime:disconnect", reason: "Client disconnect" });
+        scheduleRouterUpdate();
       } catch (error) {
-        console.error("[FloTrace] Error sending disconnect message:", error);
-      }
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  /**
-   * Send a message to the extension (queued and batched)
-   */
-  send(message) {
-    if (!this.config.enabled) {
-      return;
-    }
-    this.messageQueue.push(message);
-    if (this.messageQueue.length > _FloTraceWebSocketClient.MAX_QUEUE_SIZE) {
-      this.messageQueue = this.messageQueue.slice(-_FloTraceWebSocketClient.MAX_QUEUE_SIZE);
-    }
-    if (!this.flushTimeout) {
-      this.flushTimeout = setTimeout(() => {
-        this.flush();
-      }, _FloTraceWebSocketClient.BATCH_FLUSH_MS);
-    }
-    if (this.messageQueue.length >= (this.config.trackAllRenders ? 50 : 10)) {
-      this.flush();
-    }
-  }
-  /**
-   * Send a message immediately (not batched)
-   */
-  sendImmediate(message) {
-    if (!this.config.enabled || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      return;
-    }
-    try {
-      this.ws.send(JSON.stringify(message));
-    } catch (error) {
-      console.error("[FloTrace] Failed to send message:", error);
-    }
-  }
-  /**
-   * Flush the message queue
-   */
-  flush() {
-    if (this.flushTimeout) {
-      clearTimeout(this.flushTimeout);
-      this.flushTimeout = null;
-    }
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || this.messageQueue.length === 0) {
-      return;
-    }
-    try {
-      for (const message of this.messageQueue) {
-        this.ws.send(JSON.stringify(message));
+        console.error("[FloTrace] Error in pushState handler:", error);
       }
-      this.messageQueue = [];
-    } catch (error) {
-      console.error("[FloTrace] Failed to flush messages:", error);
-    }
-  }
-  /**
-   * Schedule a reconnection attempt
-   */
-  scheduleReconnect() {
-    if (this.reconnectTimeout) {
-      return;
-    }
-    if (this.reconnectAttempts >= _FloTraceWebSocketClient.MAX_RECONNECT_ATTEMPTS) {
-      console.warn(
-        `[FloTrace] Reconnection budget exhausted (${_FloTraceWebSocketClient.MAX_RECONNECT_ATTEMPTS} attempts). Reload the page or restart the extension to retry.`
-      );
-      return;
-    }
-    const baseDelay = this.config.reconnectInterval || 2e3;
-    const delay = Math.min(
-      baseDelay * Math.pow(2, this.reconnectAttempts),
-      _FloTraceWebSocketClient.MAX_RECONNECT_INTERVAL
-    );
-    this.reconnectAttempts++;
-    console.log(
-      `[FloTrace] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${_FloTraceWebSocketClient.MAX_RECONNECT_ATTEMPTS})`
-    );
-    this.reconnectTimeout = setTimeout(() => {
-      this.reconnectTimeout = null;
-      this.connect();
-    }, delay);
-  }
-  /**
-   * Handle incoming message from extension
-   */
-  handleMessage(message) {
-    for (const handler of this.messageHandlers) {
+    };
+    history.replaceState = function(data, unused, url) {
+      originalReplaceState(data, unused, url);
       try {
-        handler(message);
+        scheduleRouterUpdate();
       } catch (error) {
-        console.error("[FloTrace] Message handler error:", error);
+        console.error("[FloTrace] Error in replaceState handler:", error);
       }
-    }
-  }
-  /**
-   * Notify connection state change
-   */
-  notifyConnectionChange(connected) {
-    for (const handler of this.connectionHandlers) {
+    };
+    popstateHandler = () => {
       try {
-        handler(connected);
+        scheduleRouterUpdate();
       } catch (error) {
-        console.error("[FloTrace] Connection handler error:", error);
-      }
-    }
-  }
-  /**
-   * Add a message handler
-   */
-  onMessage(handler) {
-    this.messageHandlers.add(handler);
-    return () => this.messageHandlers.delete(handler);
-  }
-  /**
-   * Add a connection state handler
-   */
-  onConnectionChange(handler) {
-    this.connectionHandlers.add(handler);
-    return () => this.connectionHandlers.delete(handler);
-  }
-  /**
-   * Check if connected
-   */
-  get connected() {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
-  }
-  /**
-   * Get React version if available
-   */
-  getReactVersion() {
-    try {
-      if (typeof window !== "undefined") {
-        const React2 = window.React;
-        return React2?.version;
+        console.error("[FloTrace] Error in popstate handler:", error);
       }
-    } catch {
-    }
-    return void 0;
-  }
-};
-_FloTraceWebSocketClient.MAX_RECONNECT_ATTEMPTS = 10;
-_FloTraceWebSocketClient.MAX_RECONNECT_INTERVAL = 3e4;
-// 30s cap
-_FloTraceWebSocketClient.BATCH_FLUSH_MS = 100;
-// Flush batched messages every 100ms
-_FloTraceWebSocketClient.MAX_QUEUE_SIZE = 500;
-var FloTraceWebSocketClient = _FloTraceWebSocketClient;
-var clientInstance = null;
-function getWebSocketClient(config) {
-  if (!clientInstance) {
-    clientInstance = new FloTraceWebSocketClient(config);
-  }
-  return clientInstance;
-}
-function disposeWebSocketClient() {
-  if (clientInstance) {
-    clientInstance.disconnect();
-    clientInstance = null;
-  }
-}
-
-// src/serializer.ts
-var MAX_DEPTH = 5;
-var MAX_STRING_LENGTH = 500;
-var MAX_ARRAY_LENGTH = 50;
-var MAX_OBJECT_KEYS = 30;
-function serializeValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) {
-    return null;
-  }
-  if (value === void 0) {
-    return { __type: "undefined" };
-  }
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (Number.isNaN(value)) return "NaN";
-    if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
-    return value;
-  }
-  if (typeof value === "string") {
-    if (value.length > MAX_STRING_LENGTH) {
-      return {
-        __type: "truncated",
-        originalType: "string",
-        length: value.length
-      };
-    }
-    return value;
-  }
-  if (typeof value === "symbol") {
-    return {
-      __type: "symbol",
-      description: value.description
-    };
-  }
-  if (typeof value === "function") {
-    return {
-      __type: "function",
-      name: value.name || "anonymous"
     };
-  }
-  if (typeof value === "object") {
-    if (seen.has(value)) {
-      return { __type: "circular" };
-    }
-    if (depth >= MAX_DEPTH) {
-      return {
-        __type: "truncated",
-        originalType: Array.isArray(value) ? "array" : "object"
-      };
-    }
-    seen.add(value);
-    if (Array.isArray(value)) {
-      if (value.length > MAX_ARRAY_LENGTH) {
-        const truncated = value.slice(0, MAX_ARRAY_LENGTH).map((item) => serializeValue(item, depth + 1, seen));
-        return [
-          ...truncated,
-          {
-            __type: "truncated",
-            originalType: "array",
-            length: value.length
-          }
-        ];
-      }
-      return value.map((item) => serializeValue(item, depth + 1, seen));
-    }
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (value instanceof Error) {
-      return {
-        name: value.name,
-        message: value.message
-      };
-    }
-    if (value instanceof Map) {
-      const obj = {};
-      let count = 0;
-      for (const [k, v] of value.entries()) {
-        if (count >= MAX_OBJECT_KEYS) {
-          obj.__truncated = { __type: "truncated", originalType: "Map", length: value.size };
-          break;
-        }
-        obj[String(k)] = serializeValue(v, depth + 1, seen);
-        count++;
-      }
-      return obj;
-    }
-    if (value instanceof Set) {
-      const arr = Array.from(value);
-      if (arr.length > MAX_ARRAY_LENGTH) {
-        return {
-          __type: "truncated",
-          originalType: "Set",
-          length: arr.length
-        };
-      }
-      return arr.map((item) => serializeValue(item, depth + 1, seen));
-    }
-    if (value instanceof RegExp) {
-      return value.toString();
-    }
-    const keys = Object.keys(value);
-    const result = {};
-    for (let i = 0; i < Math.min(keys.length, MAX_OBJECT_KEYS); i++) {
-      const key = keys[i];
-      try {
-        result[key] = serializeValue(
-          value[key],
-          depth + 1,
-          seen
-        );
-      } catch {
-        result[key] = { __type: "truncated", originalType: "error" };
-      }
-    }
-    if (keys.length > MAX_OBJECT_KEYS) {
-      result.__truncated = {
-        __type: "truncated",
-        originalType: "object",
-        length: keys.length
-      };
-    }
-    return result;
-  }
-  return { __type: "truncated", originalType: typeof value };
-}
-function serializeProps(props) {
-  const result = {};
-  for (const [key, value] of Object.entries(props)) {
-    if (key === "children" || key === "key" || key === "ref") {
-      continue;
-    }
-    if (key.startsWith("__")) {
-      continue;
-    }
-    try {
-      result[key] = serializeValue(value);
-    } catch (error) {
-      console.error(`[FloTrace] Error serializing prop "${key}":`, error);
-      result[key] = { __type: "truncated", originalType: "error" };
-    }
-  }
-  return result;
-}
-function getChangedKeys(prev, next) {
-  if (!prev) {
-    return Object.keys(next);
-  }
-  const changed = [];
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
-  for (const key of allKeys) {
-    if (!Object.is(prev[key], next[key])) {
-      changed.push(key);
-    }
-  }
-  return changed;
-}
-
-// src/fiberConstants.ts
-var HOOK_HAS_EFFECT = 1;
-var HOOK_INSERTION = 2;
-var HOOK_LAYOUT = 4;
-var HOOK_PASSIVE = 8;
-function collectCircularList(lastEffect) {
-  const list = [];
-  let effect = lastEffect.next;
-  if (!effect) return list;
-  do {
-    list.push(effect);
-    effect = effect.next;
-  } while (effect && effect !== lastEffect.next);
-  return list;
-}
-
-// src/hookInspector.ts
-function inspectHooks(fiber) {
-  const hooks = [];
-  let hookState = fiber.memoizedState;
-  const effects = fiber.updateQueue?.lastEffect ? collectCircularList(fiber.updateQueue.lastEffect) : [];
-  let effectIndex = 0;
-  const debugTypes = fiber._debugHookTypes ?? null;
-  let index = 0;
-  while (hookState) {
+    window.addEventListener("popstate", popstateHandler);
+    sendRouterUpdate();
+  } catch (error) {
+    console.error("[FloTrace] Failed to install router tracker:", error);
     try {
-      const debugLabel = debugTypes?.[index] ?? void 0;
-      const hookInfo = classifyHook(hookState, index, effects, effectIndex, debugLabel);
-      hooks.push(hookInfo);
-      if (hookInfo.type === "useEffect" || hookInfo.type === "useLayoutEffect" || hookInfo.type === "useInsertionEffect") {
-        effectIndex++;
-      }
-    } catch (error) {
-      hooks.push({ index, type: "unknown", value: { __type: "truncated", originalType: "error" } });
-    }
-    hookState = hookState.next;
-    index++;
-  }
-  return hooks;
-}
-function classifyHook(state, index, effects, effectIdx, debugLabel) {
-  const ms = state.memoizedState;
-  if (debugLabel) {
-    return classifyFromDebugLabel(state, index, effects, effectIdx, debugLabel);
-  }
-  if (state.queue !== null) {
-    const queue = state.queue;
-    const isReducer = queue.lastRenderedReducer && typeof queue.lastRenderedReducer === "function" && queue.lastRenderedReducer.name !== "" && queue.lastRenderedReducer.name !== "basicStateReducer";
-    return {
-      index,
-      type: isReducer ? "useReducer" : "useState",
-      value: serializeValue(ms, 0, /* @__PURE__ */ new WeakSet())
-    };
-  }
-  if (ms !== null && typeof ms === "object" && !Array.isArray(ms) && "current" in ms) {
-    const keys = Object.keys(ms);
-    if (keys.length === 1 && keys[0] === "current") {
-      return {
-        index,
-        type: "useRef",
-        value: serializeValue(ms.current, 0, /* @__PURE__ */ new WeakSet())
-      };
-    }
-  }
-  if (Array.isArray(ms) && ms.length === 2 && Array.isArray(ms[1])) {
-    const isCallback = typeof ms[0] === "function";
-    return {
-      index,
-      type: isCallback ? "useCallback" : "useMemo",
-      value: serializeValue(ms[0], 0, /* @__PURE__ */ new WeakSet()),
-      deps: ms[1].map((d) => serializeValue(d, 0, /* @__PURE__ */ new WeakSet()))
-    };
-  }
-  if (effectIdx < effects.length) {
-    const effect = effects[effectIdx];
-    if (typeof ms === "number" || isEffectShape(ms)) {
-      const type = (effect.tag & HOOK_PASSIVE) !== 0 ? "useEffect" : (effect.tag & HOOK_LAYOUT) !== 0 ? "useLayoutEffect" : (effect.tag & HOOK_INSERTION) !== 0 ? "useInsertionEffect" : "useEffect";
-      return {
-        index,
-        type,
-        value: { __type: "function", name: "effect" },
-        deps: effect.deps ? effect.deps.map((d) => serializeValue(d, 0, /* @__PURE__ */ new WeakSet())) : void 0
-      };
-    }
-  }
-  if (Array.isArray(ms) && ms.length === 2 && typeof ms[0] === "boolean" && typeof ms[1] === "function") {
-    return {
-      index,
-      type: "useTransition",
-      value: serializeValue(ms[0], 0, /* @__PURE__ */ new WeakSet())
-    };
-  }
-  if (typeof ms === "string" && ms.startsWith(":")) {
-    return {
-      index,
-      type: "useId",
-      value: ms
-    };
-  }
-  return { index, type: "unknown", value: serializeValue(ms, 0, /* @__PURE__ */ new WeakSet()) };
-}
-function classifyFromDebugLabel(state, index, effects, effectIdx, debugLabel) {
-  const ms = state.memoizedState;
-  const normalizedLabel = debugLabel.toLowerCase().replace(/\s/g, "");
-  const labelMap = {
-    "usestate": "useState",
-    "usereducer": "useReducer",
-    "useref": "useRef",
-    "usememo": "useMemo",
-    "usecallback": "useCallback",
-    "useeffect": "useEffect",
-    "uselayouteffect": "useLayoutEffect",
-    "useinsertioneffect": "useInsertionEffect",
-    "usecontext": "useContext",
-    "useimperativehandle": "useImperativeHandle",
-    "usedebugvalue": "useDebugValue",
-    "usetransition": "useTransition",
-    "usedeferredvalue": "useDeferredValue",
-    "useid": "useId",
-    "usesyncexternalstore": "useSyncExternalStore",
-    "useoptimistic": "useOptimistic",
-    "useformstatus": "useFormStatus"
-  };
-  const hookType = labelMap[normalizedLabel] ?? "unknown";
-  const base = { index, type: hookType, value: serializeValue(ms, 0, /* @__PURE__ */ new WeakSet()), debugLabel };
-  if (hookType === "useEffect" || hookType === "useLayoutEffect" || hookType === "useInsertionEffect") {
-    if (effectIdx < effects.length) {
-      const effect = effects[effectIdx];
-      base.value = { __type: "function", name: "effect" };
-      base.deps = effect.deps ? effect.deps.map((d) => serializeValue(d, 0, /* @__PURE__ */ new WeakSet())) : void 0;
+      uninstallRouterTracker();
+    } catch (_) {
     }
   }
-  if ((hookType === "useMemo" || hookType === "useCallback") && Array.isArray(ms) && ms.length === 2 && Array.isArray(ms[1])) {
-    base.value = serializeValue(ms[0], 0, /* @__PURE__ */ new WeakSet());
-    base.deps = ms[1].map((d) => serializeValue(d, 0, /* @__PURE__ */ new WeakSet()));
-  }
-  if (hookType === "useRef" && ms !== null && typeof ms === "object" && "current" in ms) {
-    base.value = serializeValue(ms.current, 0, /* @__PURE__ */ new WeakSet());
-  }
-  return base;
 }
-function isEffectShape(ms) {
-  if (ms === null || ms === void 0) return false;
-  if (typeof ms === "object" && ms !== null) {
-    const obj = ms;
-    return "tag" in obj && "create" in obj && "deps" in obj;
+function uninstallRouterTracker() {
+  if (!isInstalled) return;
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
   }
-  return false;
-}
-
-// src/effectInspector.ts
-function inspectEffects(fiber) {
-  const results = [];
-  const lastEffect = fiber.updateQueue?.lastEffect;
-  if (!lastEffect) return results;
-  const currEffects = collectCircularList(lastEffect);
-  const prevEffects = fiber.alternate?.updateQueue?.lastEffect ? collectCircularList(fiber.alternate.updateQueue.lastEffect) : [];
-  const hookIndexMap = buildEffectToHookIndexMap(fiber, currEffects);
-  for (let i = 0; i < currEffects.length; i++) {
-    try {
-      const curr = currEffects[i];
-      const prev = prevEffects[i] ?? null;
-      const type = (curr.tag & HOOK_PASSIVE) !== 0 ? "useEffect" : (curr.tag & HOOK_LAYOUT) !== 0 ? "useLayoutEffect" : (curr.tag & HOOK_INSERTION) !== 0 ? "useInsertionEffect" : "useEffect";
-      const willRun = (curr.tag & HOOK_HAS_EFFECT) !== 0;
-      const changedDepIndices = diffDeps(prev?.deps ?? null, curr.deps);
-      const hasCleanup = typeof curr.destroy === "function";
-      results.push({
-        index: i,
-        hookIndex: hookIndexMap.get(i) ?? -1,
-        type,
-        deps: serializeDeps(curr.deps),
-        prevDeps: prev ? serializeDeps(prev.deps) : null,
-        changedDepIndices,
-        willRun,
-        hasCleanup
-      });
-    } catch (error) {
-      results.push({
-        index: i,
-        hookIndex: -1,
-        type: "useEffect",
-        deps: null,
-        prevDeps: null,
-        changedDepIndices: [],
-        willRun: false,
-        hasCleanup: false
-      });
+  try {
+    if (originalPushState) {
+      history.pushState = originalPushState;
+      originalPushState = null;
     }
+  } catch (error) {
+    console.error("[FloTrace] Error restoring pushState:", error);
   }
-  return results;
-}
-function buildEffectToHookIndexMap(fiber, effects) {
-  const map = /* @__PURE__ */ new Map();
-  let hookState = fiber.memoizedState;
-  let hookIndex = 0;
-  let effectIndex = 0;
-  while (hookState && effectIndex < effects.length) {
-    const ms = hookState.memoizedState;
-    if (isLikelyEffectHook(ms, hookState)) {
-      map.set(effectIndex, hookIndex);
-      effectIndex++;
+  try {
+    if (originalReplaceState) {
+      history.replaceState = originalReplaceState;
+      originalReplaceState = null;
     }
-    hookState = hookState.next;
-    hookIndex++;
-  }
-  return map;
-}
-function isLikelyEffectHook(ms, state) {
-  if (state.queue !== null) return false;
-  if (ms !== null && typeof ms === "object") {
-    const obj = ms;
-    if ("tag" in obj && "create" in obj && "deps" in obj) return true;
+  } catch (error) {
+    console.error("[FloTrace] Error restoring replaceState:", error);
   }
-  return false;
-}
-function diffDeps(prev, curr) {
-  if (!prev || !curr) return [];
-  const changed = [];
-  const len = Math.max(prev.length, curr.length);
-  for (let i = 0; i < len; i++) {
-    if (!Object.is(prev[i], curr[i])) {
-      changed.push(i);
+  try {
+    if (popstateHandler) {
+      window.removeEventListener("popstate", popstateHandler);
+      popstateHandler = null;
     }
+  } catch (error) {
+    console.error("[FloTrace] Error removing popstate listener:", error);
   }
-  return changed;
-}
-function serializeDeps(deps) {
-  if (deps === null) return null;
-  return deps.map((d) => serializeValue(d, 0, /* @__PURE__ */ new WeakSet()));
-}
-
-// src/timelineTracker.ts
-var MAX_EVENTS_PER_COMPONENT = 100;
-var FLUSH_INTERVAL_MS = 500;
-var MAX_PENDING_EVENTS = 200;
-var timelines = /* @__PURE__ */ new Map();
-var pendingEvents = [];
-var client = null;
-var flushTimer = null;
-var isInstalled = false;
-function installTimelineTracker(wsClient) {
-  if (isInstalled) return;
-  client = wsClient;
-  isInstalled = true;
-  flushTimer = setInterval(flushPendingEvents, FLUSH_INTERVAL_MS);
-}
-function uninstallTimelineTracker() {
-  if (!isInstalled) return;
-  if (flushTimer) {
-    clearInterval(flushTimer);
-    flushTimer = null;
-  }
-  flushPendingEvents();
-  timelines.clear();
-  pendingEvents = [];
   client = null;
   isInstalled = false;
+  console.log("[FloTrace] Router tracker uninstalled");
 }
-function recordTimelineEvent(nodeId, componentName, eventType, detail, duration) {
-  if (!isInstalled) return;
-  const event = {
-    type: eventType,
-    timestamp: Date.now(),
-    duration,
-    detail: detail !== void 0 ? serializeValue(detail, 0, /* @__PURE__ */ new WeakSet()) : void 0
-  };
-  let events = timelines.get(nodeId);
-  if (!events) {
-    events = [];
-    timelines.set(nodeId, events);
-  }
-  events.push(event);
-  if (events.length > MAX_EVENTS_PER_COMPONENT) {
-    events.shift();
-  }
-  if (pendingEvents.length < MAX_PENDING_EVENTS) {
-    pendingEvents.push({ nodeId, componentName, event });
-  }
-}
-function getTimeline(nodeId) {
-  return timelines.get(nodeId) ?? [];
+function scheduleRouterUpdate() {
+  if (debounceTimer) clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(() => {
+    debounceTimer = null;
+    sendRouterUpdate();
+  }, DEBOUNCE_MS);
 }
-function flushPendingEvents() {
-  if (!client?.connected || pendingEvents.length === 0) return;
-  for (const { nodeId, componentName, event } of pendingEvents) {
-    client.send({
-      type: "runtime:timelineEvent",
-      nodeId,
-      componentName,
-      event
+function sendRouterUpdate() {
+  try {
+    if (!client?.connected) return;
+    const pathname = window.location.pathname;
+    const searchParams = {};
+    const urlSearchParams = new URLSearchParams(window.location.search);
+    for (const [key, value] of urlSearchParams.entries()) {
+      searchParams[key] = value;
+    }
+    client.sendImmediate({
+      type: "runtime:router",
+      pathname,
+      // Matched route params (e.g., :id) are not available from the History API.
+      // Future enhancement: extract from React Router's fiber context.
+      params: {},
+      searchParams,
+      timestamp: Date.now()
     });
+  } catch (error) {
+    console.error("[FloTrace] Error sending router update:", error);
   }
-  pendingEvents = [];
-}
-
-// src/fiberUtils.ts
-function getFiberDisplayName(type) {
-  if (!type) return "Unknown";
-  if (typeof type === "function") {
-    return type.displayName || type.name || "Anonymous";
-  }
-  if (typeof type === "object") {
-    const t = type;
-    return t.type?.displayName || t.type?.name || t.render?.name || t.displayName || t.name || "Unknown";
-  }
-  return "Unknown";
-}
-
-// src/dispatchWrapper.ts
-var MAX_TRIGGERS = 200;
-var triggerBuffer = [];
-var triggerSeq = 0;
-var wrappedDispatchers = /* @__PURE__ */ new WeakSet();
-var currentBatchId = null;
-function nextBatchId() {
-  if (!currentBatchId) {
-    currentBatchId = String(Date.now()) + "-" + (Math.random() * 65535 | 0).toString(16);
-    queueMicrotask(() => {
-      currentBatchId = null;
-    });
-  }
-  return currentBatchId;
-}
-function nextTriggerId() {
-  return "tr-" + (++triggerSeq).toString(36);
-}
-var STACK_DEPTH_LIMIT = 15;
-var NOISE_PATTERNS = [
-  "node_modules",
-  "react-dom",
-  "react-reconciler",
-  "@flotrace/runtime",
-  "flotrace/runtime",
-  "/runtime/src/",
-  "webpack-internal",
-  "webpack/bootstrap",
-  "<anonymous>"
-];
-function isUserCodeFrame(fileName) {
-  if (!fileName) return false;
-  for (const pattern of NOISE_PATTERNS) {
-    if (fileName.includes(pattern)) return false;
-  }
-  return true;
-}
-function captureStack() {
-  const frames = [];
-  try {
-    const originalPrepare = Error.prepareStackTrace;
-    Error.prepareStackTrace = (_err, callSites) => {
-      for (const site of callSites) {
-        if (frames.length >= STACK_DEPTH_LIMIT) break;
-        const fileName = site.getFileName();
-        frames.push({
-          functionName: site.getFunctionName() ?? site.getMethodName(),
-          fileName,
-          lineNumber: site.getLineNumber(),
-          columnNumber: site.getColumnNumber(),
-          isUserCode: isUserCodeFrame(fileName)
-        });
-      }
-      return "";
-    };
-    const err = new Error();
-    void err.stack;
-    Error.prepareStackTrace = originalPrepare;
-  } catch {
-    try {
-      const raw = new Error().stack ?? "";
-      const lines = raw.split("\n").slice(1);
-      for (const line of lines) {
-        if (frames.length >= STACK_DEPTH_LIMIT) break;
-        const match = line.match(/^\s+at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?$/);
-        if (match) {
-          const fileName = match[2] ?? null;
-          frames.push({
-            functionName: match[1] ?? null,
-            fileName,
-            lineNumber: match[3] ? parseInt(match[3], 10) : null,
-            columnNumber: match[4] ? parseInt(match[4], 10) : null,
-            isUserCode: isUserCodeFrame(fileName)
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  return frames;
-}
-var FIBER_TAG_FUNCTION = 0;
-var FIBER_TAG_CLASS = 1;
-var FIBER_TAG_FORWARD = 11;
-var FIBER_TAG_MEMO = 14;
-var FIBER_TAG_SIMPLEMEMO = 15;
-function getComponentName(fiber) {
-  return getFiberDisplayName(fiber.type);
-}
-function wrapFunctionComponentDispatchers(fiber) {
-  let hookNode = fiber.memoizedState;
-  let hookIndex = 0;
-  while (hookNode && hookIndex < 100) {
-    try {
-      const queue = hookNode.queue;
-      if (queue && typeof queue.dispatch === "function") {
-        const original = queue.dispatch;
-        if (!wrappedDispatchers.has(original)) {
-          const componentName = getComponentName(fiber);
-          const fiberId = getFiberId(fiber);
-          const capturedHookIndex = hookIndex;
-          const hookType = typeof queue.lastRenderedReducer === "function" && queue.lastRenderedReducer?.toString().includes("action") ? "reducer" : "state";
-          const wrapped = function dispatchWithCapture(action) {
-            try {
-              const stack = captureStack();
-              const record = {
-                triggerId: nextTriggerId(),
-                fiberId,
-                componentName,
-                hookIndex: capturedHookIndex,
-                hookType,
-                stack,
-                timestamp: performance.now(),
-                action: serializeValue(action, 2),
-                batchId: nextBatchId()
-              };
-              addTrigger(record);
-            } catch {
-            }
-            return original(action);
-          };
-          wrappedDispatchers.add(wrapped);
-          queue.dispatch = wrapped;
-        }
-      }
-    } catch {
-    }
-    hookNode = hookNode.next;
-    hookIndex++;
-  }
-}
-function wrapClassComponentInstance(fiber) {
-  const instance = fiber.stateNode;
-  if (!instance || instance.__ftWrapped) return;
-  const componentName = getComponentName(fiber);
-  const fiberId = getFiberId(fiber);
-  if (typeof instance.setState === "function") {
-    const origSetState = instance.setState;
-    instance.setState = function wrappedSetState(updater, callback) {
-      try {
-        const stack = captureStack();
-        addTrigger({
-          triggerId: nextTriggerId(),
-          fiberId,
-          componentName,
-          hookIndex: 0,
-          hookType: "setState",
-          stack,
-          timestamp: performance.now(),
-          action: serializeValue(updater, 2),
-          batchId: nextBatchId()
-        });
-      } catch {
-      }
-      return origSetState.call(this, updater, callback);
-    };
-  }
-  if (typeof instance.forceUpdate === "function") {
-    const origForceUpdate = instance.forceUpdate;
-    instance.forceUpdate = function wrappedForceUpdate(callback) {
-      try {
-        const stack = captureStack();
-        addTrigger({
-          triggerId: nextTriggerId(),
-          fiberId,
-          componentName,
-          hookIndex: 0,
-          hookType: "forceUpdate",
-          stack,
-          timestamp: performance.now(),
-          action: null,
-          batchId: nextBatchId()
-        });
-      } catch {
-      }
-      return origForceUpdate.call(this, callback);
-    };
-  }
-  instance.__ftWrapped = true;
-}
-var fiberIds = /* @__PURE__ */ new WeakMap();
-var fiberIdSeq = 0;
-function getFiberId(fiber) {
-  let id = fiberIds.get(fiber);
-  if (!id) {
-    id = getComponentName(fiber) + "-" + (++fiberIdSeq).toString(36);
-    fiberIds.set(fiber, id);
-  }
-  return id;
-}
-function addTrigger(record) {
-  if (triggerBuffer.length >= MAX_TRIGGERS) {
-    triggerBuffer.shift();
-  }
-  triggerBuffer.push(record);
-}
-function wrapFiberDispatchers(root) {
-  try {
-    walkAndWrap(root.current);
-  } catch {
-  }
-}
-function walkAndWrap(rootFiber) {
-  if (!rootFiber) return;
-  const stack = [rootFiber];
-  while (stack.length > 0) {
-    const fiber = stack.pop();
-    try {
-      const tag = fiber.tag;
-      if (tag === FIBER_TAG_FUNCTION || tag === FIBER_TAG_FORWARD || tag === FIBER_TAG_MEMO || tag === FIBER_TAG_SIMPLEMEMO) {
-        wrapFunctionComponentDispatchers(fiber);
-      } else if (tag === FIBER_TAG_CLASS) {
-        wrapClassComponentInstance(fiber);
-      }
-    } catch {
-    }
-    if (fiber.sibling) stack.push(fiber.sibling);
-    if (fiber.child) stack.push(fiber.child);
-  }
-}
-function peekTriggers() {
-  return triggerBuffer;
-}
-function clearTriggers() {
-  triggerBuffer.length = 0;
-}
-
-// src/laneDetector.ts
-var SyncHydrationLane = 1;
-var SyncLane = 2;
-var InputContinuousHydrationLane = 4;
-var InputContinuousLane = 8;
-var DefaultHydrationLane = 16;
-var DefaultLane = 32;
-var TransitionLanes = 4194240;
-var RetryLanes = 62914560;
-var SelectiveHydrationLane = 67108864;
-var IdleHydrationLane = 134217728;
-var IdleLane = 268435456;
-var OffscreenLane = 536870912;
-function classifyLanes(lanes) {
-  try {
-    if (lanes & SyncHydrationLane || lanes & SyncLane) {
-      return { priority: "sync", lanes, isTransition: false, isBlocking: true };
-    }
-    if (lanes & InputContinuousHydrationLane || lanes & InputContinuousLane) {
-      return { priority: "discrete", lanes, isTransition: false, isBlocking: true };
-    }
-    if (lanes & DefaultHydrationLane || lanes & DefaultLane) {
-      return { priority: "default", lanes, isTransition: false, isBlocking: false };
-    }
-    if (lanes & TransitionLanes) {
-      return { priority: "transition", lanes, isTransition: true, isBlocking: false };
-    }
-    if (lanes & RetryLanes || lanes & SelectiveHydrationLane) {
-      return { priority: "deferred", lanes, isTransition: false, isBlocking: false };
-    }
-    if (lanes & IdleHydrationLane || lanes & IdleLane) {
-      return { priority: "idle", lanes, isTransition: false, isBlocking: false };
-    }
-    if (lanes & OffscreenLane) {
-      return { priority: "offscreen", lanes, isTransition: false, isBlocking: false };
-    }
-  } catch {
-  }
-  return { priority: "default", lanes, isTransition: false, isBlocking: false };
-}
-function getFinishedLanes(root) {
-  try {
-    return root.finishedLanes ?? root.pendingLanes ?? 0;
-  } catch {
-    return 0;
-  }
-}
-
-// src/cascadeAnalyzer.ts
-var PerformedWork = 1;
-var ForceUpdateFlag = 256;
-var FunctionComponent = 0;
-var ClassComponent = 1;
-var ForwardRef = 11;
-var MemoComponent = 14;
-var SimpleMemoComponent = 15;
-var USER_TAGS = /* @__PURE__ */ new Set([FunctionComponent, ClassComponent, ForwardRef, MemoComponent, SimpleMemoComponent]);
-function isMemoizedFiber(fiber) {
-  return fiber.tag === MemoComponent || fiber.tag === SimpleMemoComponent;
-}
-function propsChanged(prev, next) {
-  if (prev === next) return false;
-  if (!prev || !next) return true;
-  const prevKeys = Object.keys(prev);
-  const nextKeys = Object.keys(next);
-  if (prevKeys.length !== nextKeys.length) return true;
-  for (const key of nextKeys) {
-    if (key === "children") continue;
-    if (prev[key] !== next[key]) return true;
-  }
-  return false;
-}
-function getChangedPropKeys(prev, next) {
-  if (!prev || !next) return [];
-  const changed = [];
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
-  for (const key of allKeys) {
-    if (key === "children") continue;
-    if (prev[key] !== next[key]) changed.push(key);
-  }
-  return changed;
-}
-function hadOwnUpdate(fiber) {
-  try {
-    const uq = fiber.updateQueue;
-    if (!uq) return false;
-    if (uq.shared && uq.shared.pending != null) return true;
-    if (fiber.lanes !== 0) return true;
-    return false;
-  } catch {
-    return false;
-  }
-}
-function hadContextUpdate(fiber) {
-  try {
-    return !!fiber.dependencies?.firstContext;
-  } catch {
-    return false;
-  }
-}
-function classifyFiber(fiber, didRender, parentRerendered) {
-  if (!didRender) {
-    if (fiber.alternate && isMemoizedFiber(fiber)) return "bailed-out";
-    return null;
-  }
-  if (fiber.flags & ForceUpdateFlag) return "force-update";
-  if (hadContextUpdate(fiber)) return "context-update";
-  if (hadOwnUpdate(fiber)) return "state-update";
-  if (parentRerendered) {
-    const alt = fiber.alternate;
-    if (alt && propsChanged(alt.memoizedProps, fiber.memoizedProps)) {
-      return "props-changed";
-    }
-    return "parent-cascade";
-  }
-  return "state-update";
-}
-function computeSubtreeDuration(node) {
-  let total = node.renderDuration;
-  for (const child of node.children) {
-    total += computeSubtreeDuration(child);
-  }
-  node.subtreeDuration = total;
-  return total;
-}
-var commitIdSeq = 0;
-function nextCommitId() {
-  return "c-" + (++commitIdSeq).toString(36) + "-" + (Date.now() % 1e5).toString(36);
-}
-function buildCascadeTree(rootFiber, triggers) {
-  const rootCauses = [];
-  let totalComponents = 0;
-  let avoidableCount = 0;
-  let avoidableDuration = 0;
-  const triggerByName = /* @__PURE__ */ new Map();
-  for (const t of triggers) {
-    if (!triggerByName.has(t.componentName)) {
-      triggerByName.set(t.componentName, t);
-    }
-  }
-  const stack = [{
-    fiber: rootFiber,
-    depth: 0,
-    parentRerendered: false,
-    parentNode: null,
-    isRoot: true
-  }];
-  while (stack.length > 0) {
-    const entry = stack.pop();
-    const { fiber, depth, parentRerendered, parentNode, isRoot } = entry;
-    if (!fiber) continue;
-    if (depth > 150) continue;
-    const didRender = !!(fiber.flags & PerformedWork);
-    const isNewMount = !fiber.alternate;
-    if (isNewMount && !didRender) {
-      let child2 = fiber.child;
-      while (child2) {
-        stack.push({ fiber: child2, depth: depth + 1, parentRerendered: false, parentNode, isRoot: false });
-        child2 = child2.sibling;
-      }
-      continue;
-    }
-    if (!USER_TAGS.has(fiber.tag)) {
-      let child2 = fiber.child;
-      while (child2) {
-        stack.push({ fiber: child2, depth: depth + 1, parentRerendered: didRender || parentRerendered, parentNode, isRoot: false });
-        child2 = child2.sibling;
-      }
-      continue;
-    }
-    const reason = classifyFiber(fiber, didRender, parentRerendered);
-    if (reason === null) {
-      let child2 = fiber.child;
-      while (child2) {
-        stack.push({ fiber: child2, depth: depth + 1, parentRerendered: false, parentNode, isRoot: false });
-        child2 = child2.sibling;
-      }
-      continue;
-    }
-    const componentName = getFiberDisplayName(fiber.type);
-    const renderDuration = fiber.actualDuration ?? 0;
-    let changedProps;
-    if (reason === "props-changed" && fiber.alternate) {
-      changedProps = getChangedPropKeys(fiber.alternate.memoizedProps, fiber.memoizedProps);
-    }
-    let triggerId;
-    if (reason === "state-update" || reason === "context-update" || reason === "force-update") {
-      triggerId = triggerByName.get(componentName)?.triggerId;
-    }
-    const node = {
-      nodeId: componentName + "-" + depth + "-" + totalComponents,
-      componentName,
-      reason,
-      renderDuration,
-      subtreeDuration: renderDuration,
-      // will be updated from children
-      changedProps,
-      triggerId,
-      children: [],
-      depth,
-      isMemoized: isMemoizedFiber(fiber)
-    };
-    totalComponents++;
-    if (reason === "parent-cascade") {
-      avoidableCount++;
-      avoidableDuration += renderDuration;
-    }
-    if (parentNode) {
-      parentNode.children.push(node);
-    } else if (reason === "state-update" || reason === "context-update" || reason === "force-update" || isRoot) {
-      rootCauses.push(node);
-    } else if (parentRerendered) {
-      rootCauses.push(node);
-    }
-    let child = fiber.child;
-    while (child) {
-      stack.push({
-        fiber: child,
-        depth: depth + 1,
-        parentRerendered: didRender,
-        parentNode: reason !== "bailed-out" ? node : parentNode,
-        isRoot: false
-      });
-      child = child.sibling;
-    }
-  }
-  for (const root of rootCauses) computeSubtreeDuration(root);
-  return { rootCauses, totalComponents, avoidableCount, avoidableDuration };
-}
-function analyzeCascade(root, triggers) {
-  try {
-    const finishedLanes = getFinishedLanes(root);
-    const lane = classifyLanes(finishedLanes);
-    const { rootCauses, totalComponents, avoidableCount, avoidableDuration } = buildCascadeTree(root.current, triggers);
-    if (totalComponents === 0) return null;
-    const totalDuration = rootCauses.reduce((sum, n) => sum + n.subtreeDuration, 0);
-    const triggerIds = triggers.map((t) => t.triggerId);
-    return {
-      commitId: nextCommitId(),
-      timestamp: performance.now(),
-      totalDuration,
-      totalComponents,
-      avoidableCount,
-      avoidableDuration,
-      rootCauses,
-      lane,
-      triggerIds
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/propDrillingAnalyzer.ts
-var ANALYZE_INTERVAL_MS = 2e3;
-var DRILLING_THRESHOLD = 3;
-var EXCLUDED_PROP_NAMES = /* @__PURE__ */ new Set([
-  // React internals
-  "children",
-  "key",
-  "ref",
-  // Common HTML attributes
-  "className",
-  "style",
-  "id",
-  "name",
-  "type",
-  "value",
-  "placeholder",
-  "disabled",
-  "readOnly",
-  "required",
-  "autoFocus",
-  "tabIndex",
-  "role",
-  "aria-label",
-  "aria-describedby",
-  "aria-hidden",
-  "title",
-  "lang",
-  "dir",
-  "hidden",
-  // Common layout props
-  "width",
-  "height",
-  "size",
-  "variant",
-  "color",
-  "theme",
-  // Test IDs
-  "data-testid",
-  "testID"
-]);
-function isExcluded(propName) {
-  return EXCLUDED_PROP_NAMES.has(propName) || propName.startsWith("on");
-}
-var analyzeTimer = null;
-var lastAnalysisTime = 0;
-function valueFingerprint(value, depth = 0) {
-  if (depth > 3) return "__deep__";
-  if (value === null || value === void 0) return "null";
-  if (typeof value === "function") return `fn:${value.name || "anon"}`;
-  if (typeof value !== "object") return `${typeof value}:${String(value)}`;
-  if (Array.isArray(value)) {
-    const arr = value;
-    return `arr:${arr.length}:${arr.slice(0, 5).map((v) => valueFingerprint(v, depth + 1)).join(",")}`;
-  }
-  const obj = value;
-  const keys = Object.keys(obj).sort();
-  return `obj:${keys.slice(0, 10).map((k) => `${k}=${valueFingerprint(obj[k], depth + 1)}`).join(",")}`;
-}
-function shouldFlagRename(value) {
-  if (value === null || value === void 0) return false;
-  if (typeof value !== "object") return false;
-  if (Array.isArray(value) && value.length === 0) return false;
-  if (!Array.isArray(value) && Object.keys(value).length === 0) return false;
-  return true;
-}
-function computePropIntersectionRatio(nodeProps, childrenProps) {
-  const nodeKeys = Object.keys(nodeProps).filter((k) => !isExcluded(k));
-  if (nodeKeys.length === 0) return 0;
-  let forwarded = 0;
-  for (const key of nodeKeys) {
-    const fp = valueFingerprint(nodeProps[key]);
-    const isForwarded = childrenProps.some(
-      (cp) => Object.values(cp).some((v) => valueFingerprint(v) === fp)
-    );
-    if (isForwarded) forwarded++;
-  }
-  return forwarded / nodeKeys.length;
-}
-function classifyNode(nodeId, drilledPropFp, parentNodeId, childNodeIds, getProps, hookCounts, contextFlags) {
-  if (!parentNodeId) return "source";
-  const parentProps = getProps(parentNodeId);
-  const parentHasProp = Object.values(parentProps).some(
-    (v) => valueFingerprint(v) === drilledPropFp
-  );
-  if (!parentHasProp) return "source";
-  const forwardsToChild = childNodeIds.some((cid) => {
-    const childProps = getProps(cid);
-    return Object.values(childProps).some((v) => valueFingerprint(v) === drilledPropFp);
-  });
-  if (!forwardsToChild) return "consumer";
-  const hookCount = hookCounts.get(nodeId) ?? 0;
-  const hasContext = contextFlags.get(nodeId) ?? false;
-  if (hookCount === 0) return "passthrough";
-  if (hasContext) return "consumer";
-  const nodeProps = getProps(nodeId);
-  const childrenProps = childNodeIds.map(getProps);
-  const intersectionRatio = computePropIntersectionRatio(nodeProps, childrenProps);
-  if (intersectionRatio > 0.7 && hookCount <= 1) return "passthrough";
-  return "consumer";
-}
-function calculateSeverity(depth, passthroughCount, consumerCount) {
-  if (depth >= 5) return "critical";
-  if (passthroughCount >= 3) return "critical";
-  if (consumerCount >= 3 && depth >= 4) return "critical";
-  if (depth >= 4) return "warning";
-  if (passthroughCount >= 2) return "warning";
-  if (consumerCount >= 2) return "warning";
-  return "info";
-}
-function makeChainId(sourceNodeId, fp, consumerNodeId) {
-  return `${sourceNodeId}::${fp.slice(0, 20)}::${consumerNodeId}`;
-}
-function flattenTree(node, parentId, parentMap, childrenMap, nodeMap) {
-  if (node.isFramework) {
-    for (const child of node.children) {
-      flattenTree(child, parentId, parentMap, childrenMap, nodeMap);
-    }
-    return;
-  }
-  nodeMap.set(node.id, node);
-  if (parentId) {
-    parentMap.set(node.id, parentId);
-    const siblings = childrenMap.get(parentId) ?? [];
-    siblings.push(node.id);
-    childrenMap.set(parentId, siblings);
-  }
-  if (!childrenMap.has(node.id)) {
-    childrenMap.set(node.id, []);
-  }
-  for (const child of node.children) {
-    flattenTree(child, node.id, parentMap, childrenMap, nodeMap);
-  }
-}
-function runAnalysis(tree, fiberRefMap2) {
-  const parentMap = /* @__PURE__ */ new Map();
-  const childrenMap = /* @__PURE__ */ new Map();
-  const nodeMap = /* @__PURE__ */ new Map();
-  flattenTree(tree, void 0, parentMap, childrenMap, nodeMap);
-  const allNodeIds = Array.from(nodeMap.keys());
-  function getProps(nodeId) {
-    try {
-      return fiberRefMap2.get(nodeId)?.memoizedProps ?? {};
-    } catch {
-      return {};
-    }
-  }
-  const hookCounts = /* @__PURE__ */ new Map();
-  const contextFlags = /* @__PURE__ */ new Map();
-  for (const nodeId of allNodeIds) {
-    const node = nodeMap.get(nodeId);
-    hookCounts.set(nodeId, node.hookCount ?? 0);
-    contextFlags.set(nodeId, node.hasContextHook ?? false);
-  }
-  const edges = [];
-  for (const nodeId of allNodeIds) {
-    const parentId = parentMap.get(nodeId);
-    if (!parentId) continue;
-    const parentProps = getProps(parentId);
-    const childProps = getProps(nodeId);
-    const childKeys = Object.keys(childProps).filter((k) => !isExcluded(k));
-    const parentKeys = Object.keys(parentProps).filter((k) => !isExcluded(k));
-    for (const childKey of childKeys) {
-      const childVal = childProps[childKey];
-      if (typeof childVal === "function") continue;
-      const childFp = valueFingerprint(childVal);
-      if (childFp === "null") continue;
-      for (const parentKey of parentKeys) {
-        const parentVal = parentProps[parentKey];
-        if (typeof parentVal === "function") continue;
-        const parentFp = valueFingerprint(parentVal);
-        if (parentFp === childFp) {
-          const isRename = parentKey !== childKey;
-          if (!isRename || shouldFlagRename(parentVal)) {
-            edges.push({
-              parentNodeId: parentId,
-              childNodeId: nodeId,
-              propKey: parentKey,
-              childPropKey: childKey,
-              fp: childFp
-            });
-            break;
-          }
-        }
-      }
-    }
-  }
-  const edgesByFp = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    const group = edgesByFp.get(edge.fp) ?? [];
-    group.push(edge);
-    edgesByFp.set(edge.fp, group);
-  }
-  const chains = [];
-  const passthroughNodeIdSet = /* @__PURE__ */ new Set();
-  for (const [fp, fpEdges] of edgesByFp) {
-    const outEdges = /* @__PURE__ */ new Map();
-    const inNodes = /* @__PURE__ */ new Set();
-    for (const edge of fpEdges) {
-      const out = outEdges.get(edge.parentNodeId) ?? [];
-      out.push(edge);
-      outEdges.set(edge.parentNodeId, out);
-      inNodes.add(edge.childNodeId);
-    }
-    const sourceNodeIds = /* @__PURE__ */ new Set();
-    for (const edge of fpEdges) {
-      if (!inNodes.has(edge.parentNodeId)) {
-        sourceNodeIds.add(edge.parentNodeId);
-      }
-    }
-    for (const sourceId of sourceNodeIds) {
-      let dfs2 = function(currentId, currentPropKey, currentPath, visited) {
-        if (visited.has(currentId)) return;
-        visited.add(currentId);
-        const outgoing = outEdges.get(currentId);
-        if (!outgoing || outgoing.length === 0) {
-          if (currentPath.length >= DRILLING_THRESHOLD) {
-            allPaths.push([...currentPath]);
-          }
-          visited.delete(currentId);
-          return;
-        }
-        for (const edge of outgoing) {
-          const isRename = edge.propKey !== edge.childPropKey;
-          dfs2(
-            edge.childNodeId,
-            edge.childPropKey,
-            [...currentPath, { nodeId: edge.childNodeId, propKey: edge.childPropKey, isRename }],
-            new Set(visited)
-          );
-        }
-        visited.delete(currentId);
-      };
-      var dfs = dfs2;
-      const firstEdge = outEdges.get(sourceId)?.[0];
-      if (!firstEdge) continue;
-      const sourcePropName = firstEdge.propKey;
-      const allPaths = [];
-      dfs2(
-        sourceId,
-        sourcePropName,
-        [{ nodeId: sourceId, propKey: sourcePropName, isRename: false }],
-        /* @__PURE__ */ new Set()
-      );
-      if (allPaths.length === 0) continue;
-      for (const path of allPaths) {
-        if (path.length < DRILLING_THRESHOLD) continue;
-        const consumerNodeId = path[path.length - 1].nodeId;
-        const consumerNode = nodeMap.get(consumerNodeId);
-        if (!consumerNode) continue;
-        const chainNodes = path.map((p, i) => {
-          const parentIdForNode = i === 0 ? void 0 : path[i - 1].nodeId;
-          const childNodeIds = i < path.length - 1 ? [path[i + 1].nodeId] : [];
-          const role = classifyNode(
-            p.nodeId,
-            fp,
-            parentIdForNode,
-            childNodeIds,
-            getProps,
-            hookCounts,
-            contextFlags
-          );
-          if (role === "passthrough") {
-            passthroughNodeIdSet.add(p.nodeId);
-          }
-          const n = nodeMap.get(p.nodeId);
-          return {
-            nodeId: p.nodeId,
-            componentName: n?.name ?? p.nodeId,
-            propKey: p.propKey,
-            role,
-            hookCount: hookCounts.get(p.nodeId) ?? 0,
-            hasContextHook: contextFlags.get(p.nodeId) ?? false
-          };
-        });
-        const passthroughCount = chainNodes.filter((n) => n.role === "passthrough").length;
-        const sourceNode = nodeMap.get(sourceId);
-        const renames = path.flatMap(
-          (p, idx) => p.isRename ? [{ atNodeId: p.nodeId, fromKey: idx > 0 ? path[idx - 1].propKey : sourcePropName, toKey: p.propKey }] : []
-        );
-        chains.push({
-          chainId: makeChainId(sourceId, fp, consumerNodeId),
-          propName: sourcePropName,
-          sourceNodeId: sourceId,
-          sourceComponentName: sourceNode?.name ?? sourceId,
-          consumerNodeIds: [consumerNodeId],
-          consumerComponentNames: [consumerNode.name],
-          path: chainNodes,
-          depth: path.length,
-          passthroughCount,
-          severity: calculateSeverity(path.length, passthroughCount, 1),
-          renames
-        });
-      }
-    }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const dedupedChains = chains.filter((c) => {
-    if (seen.has(c.chainId)) return false;
-    seen.add(c.chainId);
-    return true;
-  });
-  const severityOrder = { critical: 0, warning: 1, info: 2 };
-  dedupedChains.sort((a, b) => {
-    const s = severityOrder[a.severity] - severityOrder[b.severity];
-    if (s !== 0) return s;
-    return b.depth - a.depth;
-  });
-  return {
-    chains: dedupedChains.slice(0, 50),
-    // cap at 50 chains
-    passthroughNodeIds: Array.from(passthroughNodeIdSet)
-  };
-}
-function schedulePropDrillingAnalysis(tree, fiberRefMap2, client4) {
-  if (analyzeTimer) clearTimeout(analyzeTimer);
-  const now = Date.now();
-  const elapsed = now - lastAnalysisTime;
-  const delay = elapsed >= ANALYZE_INTERVAL_MS ? 0 : ANALYZE_INTERVAL_MS - elapsed;
-  analyzeTimer = setTimeout(() => {
-    analyzeTimer = null;
-    if (!client4.connected) return;
-    try {
-      lastAnalysisTime = Date.now();
-      const { chains, passthroughNodeIds } = runAnalysis(tree, fiberRefMap2);
-      client4.sendImmediate({
-        type: "runtime:propDrilling",
-        payload: {
-          chains,
-          passthroughNodeIds,
-          analysisTimestamp: lastAnalysisTime,
-          treeSize: fiberRefMap2.size
-        }
-      });
-    } catch (err) {
-      if (typeof console !== "undefined") {
-        console.warn("[FloTrace] Prop drilling analysis error:", err);
-      }
-    }
-  }, delay);
-}
-
-// src/compilerAnalyzer.ts
-var MEMO_CACHE_SENTINEL = /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel");
-var FUNCTION_COMPONENT = 0;
-var SIMPLE_MEMO = 15;
-function detectCompilerStatus(fiber) {
-  if (fiber.tag === SIMPLE_MEMO) return "manual";
-  if (fiber.tag !== FUNCTION_COMPONENT) return void 0;
-  const firstHook = fiber.memoizedState;
-  if (!firstHook) return "unoptimized";
-  const cache = firstHook.memoizedState;
-  if (!Array.isArray(cache) || cache.length === 0) return "unoptimized";
-  const hasSentinel = cache.some((v) => v === MEMO_CACHE_SENTINEL);
-  if (!hasSentinel) return "unoptimized";
-  const allSentinel = cache.every((v) => v === MEMO_CACHE_SENTINEL);
-  if (allSentinel && fiber.alternate != null) return "de-opted";
-  return "compiled";
-}
-
-// src/nextjsDetector.ts
-var SERVER_COMPONENT_PATTERNS = [
-  /\.server\.[jt]sx?$/,
-  // explicit .server.tsx convention
-  /[\\/]app[\\/].+[\\/]page\.[jt]sx?$/,
-  // Next.js app router page
-  /[\\/]app[\\/].+[\\/]layout\.[jt]sx?$/,
-  // Next.js app router layout
-  /[\\/]app[\\/].+[\\/]loading\.[jt]sx?$/,
-  // Next.js loading UI
-  /[\\/]app[\\/].+[\\/]error\.[jt]sx?$/
-  // Next.js error UI
-];
-var SERVER_REFERENCE_PATTERNS = [
-  /_ServerReference$/,
-  /^RSC_/
-];
-var detectionEmitted = false;
-function maybeEmitNextjsContext(client4) {
-  if (detectionEmitted) return;
-  try {
-    const win = globalThis;
-    const hasNextData = "__NEXT_DATA__" in win;
-    const hasNextRouter = "__next_router_state_tree__" in win;
-    const hasNext = "next" in win && win.next !== null;
-    if (!hasNextData && !hasNextRouter && !hasNext) return;
-    detectionEmitted = true;
-    let version;
-    let isAppRouter = false;
-    let initialRoute;
-    try {
-      const nextData = win.__NEXT_DATA__;
-      if (nextData) {
-        version = typeof nextData.buildId === "string" ? nextData.buildId : void 0;
-        initialRoute = typeof nextData.page === "string" ? nextData.page : void 0;
-      }
-      isAppRouter = hasNextRouter || !!win.__next_router_state_tree__;
-    } catch {
-    }
-    client4.sendImmediate({
-      type: "runtime:nextjsContext",
-      detected: true,
-      version,
-      isAppRouter,
-      initialRoute,
-      timestamp: Date.now()
-    });
-  } catch {
-  }
-}
-function detectServerComponent(fiber) {
-  const type = fiber.type;
-  if (type) {
-    const name = type.displayName || type.name || "";
-    if (SERVER_REFERENCE_PATTERNS.some((p) => p.test(name))) return true;
-  }
-  const fileName = fiber._debugSource?.fileName;
-  if (fileName) {
-    if (SERVER_COMPONENT_PATTERNS.some((p) => p.test(fileName))) return true;
-  }
-  return false;
-}
-function resetNextjsDetection() {
-  detectionEmitted = false;
-}
-
-// src/actionStateTracker.ts
-var prevActionStateMap = /* @__PURE__ */ new Map();
-var ACTION_STATE_HOOK_NAMES = /* @__PURE__ */ new Set(["useActionState"]);
-var OPTIMISTIC_HOOK_NAMES = /* @__PURE__ */ new Set(["useOptimistic"]);
-function extractActionEntries(fiber) {
-  const hookTypes = fiber._debugHookTypes;
-  if (!hookTypes) return null;
-  const entries = [];
-  let hookState = fiber.memoizedState;
-  let hookIdx = 0;
-  for (const hookType of hookTypes) {
-    if (!hookState) break;
-    if (ACTION_STATE_HOOK_NAMES.has(hookType)) {
-      const ms = hookState.memoizedState;
-      if (Array.isArray(ms) && ms.length >= 3) {
-        entries.push({
-          hookIndex: hookIdx,
-          hookKind: "action",
-          isPending: ms[2] === true,
-          state: serializeValue(ms[0])
-        });
-      }
-    } else if (OPTIMISTIC_HOOK_NAMES.has(hookType)) {
-      const ms = hookState.memoizedState;
-      if (Array.isArray(ms)) {
-        entries.push({
-          hookIndex: hookIdx,
-          hookKind: "optimistic",
-          isPending: false,
-          // optimistic values are "immediately applied"
-          state: serializeValue(ms[0])
-        });
-      }
-    }
-    hookState = hookState.next;
-    hookIdx++;
-  }
-  return entries.length > 0 ? entries : null;
-}
-function scanActionStateChanges(fiberRefMap2, client4) {
-  try {
-    for (const [nodeId, fiber] of fiberRefMap2) {
-      const entries = extractActionEntries(fiber);
-      if (!entries) continue;
-      const snapshot = JSON.stringify(entries.map((e) => ({ i: e.hookIndex, p: e.isPending, s: e.state })));
-      if (prevActionStateMap.get(nodeId) === snapshot) continue;
-      prevActionStateMap.set(nodeId, snapshot);
-      const componentName = nodeId.split("/").pop()?.replace(/-\d+$/, "") ?? "Unknown";
-      client4.send({
-        type: "runtime:actionState",
-        nodeId,
-        componentName,
-        actions: entries,
-        timestamp: Date.now()
-      });
-    }
-  } catch {
-  }
-}
-function clearActionStateCache() {
-  prevActionStateMap.clear();
-}
-
-// src/rscPayloadInterceptor.ts
-var RSC_URL_PATTERNS = [
-  /\?_rsc=/,
-  // App Router RSC param
-  /\?__RSC__=/,
-  // Older Next.js RSC param
-  /\/_next\/data\//,
-  // Pages Router getServerSideProps / getStaticProps
-  /\/__nextjs_original-stack-frame/
-];
-function parseCacheStatus(headers) {
-  const raw = headers.get("x-nextjs-cache") || headers.get("x-vercel-cache") || "";
-  switch (raw.toUpperCase()) {
-    case "HIT":
-      return "HIT";
-    case "MISS":
-      return "MISS";
-    case "STALE":
-      return "STALE";
-    default:
-      return "unknown";
-  }
-}
-function extractRoute(url) {
-  try {
-    const u = new URL(url, globalThis.location?.href ?? "http://localhost");
-    return u.pathname;
-  } catch {
-    return url.split("?")[0] ?? url;
-  }
-}
-var originalFetch = null;
-var interceptorClient = null;
-var isInstalled2 = false;
-function installRscPayloadInterceptor(client4) {
-  if (isInstalled2 || typeof globalThis.fetch !== "function") return;
-  isInstalled2 = true;
-  interceptorClient = client4;
-  originalFetch = globalThis.fetch;
-  globalThis.fetch = async function patchedFetch(input, init) {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    const isRscRequest = RSC_URL_PATTERNS.some((p) => p.test(url));
-    const response = await originalFetch.call(globalThis, input, init);
-    if (isRscRequest && interceptorClient?.connected) {
-      try {
-        const sizeHeader = response.headers.get("content-length");
-        const payloadSizeBytes = sizeHeader ? parseInt(sizeHeader, 10) : 0;
-        interceptorClient.send({
-          type: "runtime:rscPayload",
-          route: extractRoute(url),
-          payloadSizeBytes: isNaN(payloadSizeBytes) ? 0 : payloadSizeBytes,
-          cacheStatus: parseCacheStatus(response.headers),
-          timestamp: Date.now()
-        });
-      } catch {
-      }
-    }
-    return response;
-  };
-}
-function uninstallRscPayloadInterceptor() {
-  if (!isInstalled2 || !originalFetch) return;
-  globalThis.fetch = originalFetch;
-  originalFetch = null;
-  interceptorClient = null;
-  isInstalled2 = false;
-}
-
-// src/fiberAttribution.ts
-function isFiberLike(val) {
-  if (!val || typeof val !== "object") return false;
-  const obj = val;
-  return typeof obj.tag === "number" && "type" in obj && "return" in obj && ("memoizedState" in obj || "stateNode" in obj);
-}
-function getCurrentRenderingFiber() {
-  try {
-    const win = window;
-    const secret = win.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-    if (secret?.ReactCurrentOwner?.current) return secret.ReactCurrentOwner.current;
-    const client4 = win.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
-    if (client4) {
-      for (const val of Object.values(client4)) {
-        if (isFiberLike(val)) return val;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function getComponentNameFromFiber(fiber) {
-  const type = fiber.type;
-  if (!type) return null;
-  if (typeof type === "function") {
-    return type.displayName || type.name || null;
-  }
-  if (typeof type === "object" && type !== null) {
-    if (type.type) {
-      return type.type.displayName || type.type.name || null;
-    }
-    if (type.render) {
-      return type.render.displayName || type.render.name || null;
-    }
-    return type.displayName || type.name || null;
-  }
-  return null;
-}
-function buildAncestorChain(fiber) {
-  const chain = [];
-  let current = fiber;
-  const maxDepth = 10;
-  while (current && chain.length < maxDepth) {
-    const name = getComponentNameFromFiber(current);
-    if (name) {
-      chain.unshift(name);
-    }
-    current = current.return;
-  }
-  return chain;
 }
 
 // src/networkTracker.ts
+var import_runtime_core = require("@flotrace/runtime-core");
+var import_runtime_core2 = require("@flotrace/runtime-core");
 var MAX_BATCH_SIZE = 50;
-var FLUSH_INTERVAL_MS2 = 500;
+var FLUSH_INTERVAL_MS = 500;
 var MAX_BUFFER_SIZE = 300;
 var DEDUPE_WINDOW_MS = 5e3;
 var MAX_ANCESTOR_CHAIN = 3;
@@ -1954,11 +215,11 @@ var NOISE_URL_PATTERNS = [
   /moz-extension:/i
 ];
 var client2 = null;
-var isInstalled3 = false;
+var isInstalled2 = false;
 var isPrewarmed = false;
 var buffer = [];
 var earlyBuffer = [];
-var flushTimer2 = null;
+var flushTimer = null;
 var requestCounter = 0;
 var requestIndexMap = /* @__PURE__ */ new Map();
 var earlyRequestIndexMap = /* @__PURE__ */ new Map();
@@ -1971,43 +232,6 @@ var responseToRequestId = /* @__PURE__ */ new WeakMap();
 var activeXhrRequestId = null;
 var activeXhrResponseText = null;
 var dedupeWindow = /* @__PURE__ */ new Map();
-var fetchDataOrigin = /* @__PURE__ */ new WeakMap();
-var requestTagTimestamps = /* @__PURE__ */ new Map();
-var FETCH_ORIGIN_TTL_MS = 3e3;
-function tagFetchData(obj, requestId, depth = 0) {
-  if (depth > 2 || obj === null || typeof obj !== "object") return;
-  fetchDataOrigin.set(obj, requestId);
-  if (depth === 0) requestTagTimestamps.set(requestId, Date.now());
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < Math.min(obj.length, 50); i++) tagFetchData(obj[i], requestId, depth + 1);
-  } else {
-    for (const val of Object.values(obj)) tagFetchData(val, requestId, depth + 1);
-  }
-}
-function hasActiveTags() {
-  return requestTagTimestamps.size > 0;
-}
-function findFetchOrigin(obj, depth = 0) {
-  if (depth > 2 || obj === null || typeof obj !== "object") return void 0;
-  const rid = fetchDataOrigin.get(obj);
-  if (rid) {
-    const tagTime = requestTagTimestamps.get(rid);
-    if (tagTime && Date.now() - tagTime <= FETCH_ORIGIN_TTL_MS) return rid;
-    requestTagTimestamps.delete(rid);
-  }
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < Math.min(obj.length, 20); i++) {
-      const found = findFetchOrigin(obj[i], depth + 1);
-      if (found) return found;
-    }
-  } else {
-    for (const val of Object.values(obj)) {
-      const found = findFetchOrigin(val, depth + 1);
-      if (found) return found;
-    }
-  }
-  return void 0;
-}
 function installPatches() {
   patchFetch();
   patchXhr();
@@ -2015,14 +239,14 @@ function installPatches() {
   patchJsonParse();
 }
 function prewarmNetworkTracker() {
-  if (isInstalled3 || isPrewarmed) return;
+  if (isInstalled2 || isPrewarmed) return;
   isPrewarmed = true;
   installPatches();
 }
 function installNetworkTracker(wsClient) {
-  if (isInstalled3) return;
+  if (isInstalled2) return;
   client2 = wsClient;
-  isInstalled3 = true;
+  isInstalled2 = true;
   if (!isPrewarmed) {
     requestCounter = 0;
     installPatches();
@@ -2035,11 +259,11 @@ function installNetworkTracker(wsClient) {
       earlyRequestIndexMap.clear();
     }
   }
-  flushTimer2 = setInterval(flushBuffer, FLUSH_INTERVAL_MS2);
+  flushTimer = setInterval(flushBuffer, FLUSH_INTERVAL_MS);
   flushBuffer();
 }
 function uninstallNetworkTracker() {
-  if (!isInstalled3 && !isPrewarmed) return;
+  if (!isInstalled2 && !isPrewarmed) return;
   if (previousFetch) {
     globalThis.fetch = previousFetch;
     previousFetch = null;
@@ -2060,21 +284,21 @@ function uninstallNetworkTracker() {
     JSON.parse = originalJsonParse;
     originalJsonParse = null;
   }
-  if (flushTimer2) {
-    clearInterval(flushTimer2);
-    flushTimer2 = null;
+  if (flushTimer) {
+    clearInterval(flushTimer);
+    flushTimer = null;
   }
-  if (isInstalled3) flushBuffer();
+  if (isInstalled2) flushBuffer();
   buffer = [];
   earlyBuffer = [];
   requestIndexMap.clear();
   earlyRequestIndexMap.clear();
   dedupeWindow.clear();
-  requestTagTimestamps.clear();
+  (0, import_runtime_core.clearFetchOriginTags)();
   activeXhrRequestId = null;
   activeXhrResponseText = null;
   client2 = null;
-  isInstalled3 = false;
+  isInstalled2 = false;
   isPrewarmed = false;
 }
 function patchFetch() {
@@ -2135,7 +359,7 @@ function patchXhr() {
       if (!requestId) return;
       if (self.responseType === "json" && self.response !== null && typeof self.response === "object") {
         try {
-          tagFetchData(self.response, requestId, 0);
+          (0, import_runtime_core.tagFetchData)(self.response, requestId, 0);
         } catch {
         }
         return;
@@ -2192,1874 +416,158 @@ function patchResponseJson() {
     const requestId = responseToRequestId.get(this);
     if (requestId && data !== null && typeof data === "object") {
       try {
-        tagFetchData(data, requestId, 0);
+        (0, import_runtime_core.tagFetchData)(data, requestId, 0);
       } catch {
       }
     }
     return data;
   };
-}
-function patchJsonParse() {
-  originalJsonParse = JSON.parse;
-  JSON.parse = function(text, reviver) {
-    const result = originalJsonParse.call(JSON, text, reviver);
-    if (activeXhrRequestId !== null && activeXhrResponseText !== null && text === activeXhrResponseText && result !== null && typeof result === "object") {
-      try {
-        tagFetchData(result, activeXhrRequestId, 0);
-      } catch {
-      }
-      activeXhrRequestId = null;
-      activeXhrResponseText = null;
-    }
-    return result;
-  };
-}
-function createEntry(method, parsedUrl, init) {
-  const requestId = String(++requestCounter);
-  const dedupeKey = `${method}:${parsedUrl.path}`;
-  const attribution = getAttribution();
-  const isServerAction = hasHeader(init, "Next-Action");
-  const isPrefetch = hasHeader(init, "Next-Router-Prefetch");
-  const now = Date.now();
-  const isDuplicate = checkDuplicate(dedupeKey, now);
-  return {
-    requestId,
-    method,
-    urlPath: parsedUrl.path,
-    urlHost: parsedUrl.host,
-    status: 0,
-    durationMs: null,
-    responseSizeBytes: null,
-    componentName: attribution.componentName,
-    ancestorChain: attribution.ancestorChain,
-    initiatedDuringRender: attribution.duringRender,
-    initiatedInEffect: attribution.inEffect,
-    state: "pending",
-    dedupeKey,
-    isDuplicate: isDuplicate || void 0,
-    isServerAction: isServerAction || void 0,
-    isPrefetch: isPrefetch || void 0,
-    timestamp: now
-  };
-}
-function getAttribution() {
-  const fiber = getCurrentRenderingFiber();
-  if (fiber) {
-    const name = getComponentNameFromFiber(fiber);
-    const ancestors = buildAncestorChain(fiber).slice(-MAX_ANCESTOR_CHAIN);
-    return {
-      componentName: name || void 0,
-      ancestorChain: ancestors.length > 0 ? ancestors : void 0,
-      duringRender: true,
-      inEffect: false
-    };
-  }
-  return { duringRender: false, inEffect: false };
-}
-function extractUrl(input) {
-  if (typeof input === "string") return input;
-  if (input instanceof URL) return input.href;
-  return input.url;
-}
-function parseUrl(url) {
-  try {
-    const u = new URL(url, globalThis.location?.href ?? "http://localhost");
-    return { path: u.pathname, host: u.host };
-  } catch {
-    return { path: url.split("?")[0] ?? url, host: "" };
-  }
-}
-var COMBINED_NOISE_PATTERN = new RegExp(
-  NOISE_URL_PATTERNS.map((r) => r.source).join("|"),
-  "i"
-);
-function isNoiseUrl(url) {
-  return COMBINED_NOISE_PATTERN.test(url);
-}
-function parseIntOrNull(value) {
-  if (!value) return null;
-  const n = parseInt(value, 10);
-  return isNaN(n) ? null : n;
-}
-function parseContentLength(headers) {
-  return parseIntOrNull(headers.get("content-length"));
-}
-function parseXhrContentLength(xhr) {
-  return parseIntOrNull(xhr.getResponseHeader("content-length"));
-}
-function hasHeader(init, name) {
-  if (!init?.headers) return false;
-  if (init.headers instanceof Headers) return init.headers.has(name);
-  if (Array.isArray(init.headers)) return init.headers.some(([k]) => k.toLowerCase() === name.toLowerCase());
-  if (typeof init.headers === "object") {
-    return Object.keys(init.headers).some((k) => k.toLowerCase() === name.toLowerCase());
-  }
-  return false;
-}
-function checkDuplicate(dedupeKey, now) {
-  for (const [key, ts] of dedupeWindow) {
-    if (now - ts > DEDUPE_WINDOW_MS) dedupeWindow.delete(key);
-  }
-  const isDup = dedupeWindow.has(dedupeKey);
-  dedupeWindow.set(dedupeKey, now);
-  return isDup;
-}
-function upsertAndPrune(entry, buf, idxMap, maxSize) {
-  const existingIdx = idxMap.get(entry.requestId);
-  if (existingIdx !== void 0 && existingIdx < buf.length && buf[existingIdx]?.requestId === entry.requestId) {
-    buf[existingIdx] = entry;
-    return buf;
-  }
-  idxMap.set(entry.requestId, buf.length);
-  buf.push(entry);
-  if (buf.length > maxSize) {
-    const pruned = buf.slice(-maxSize);
-    idxMap.clear();
-    for (let i = 0; i < pruned.length; i++) idxMap.set(pruned[i].requestId, i);
-    return pruned;
-  }
-  return buf;
-}
-function pushEntry(entry) {
-  if (client2 === null && isPrewarmed) {
-    earlyBuffer = upsertAndPrune(entry, earlyBuffer, earlyRequestIndexMap, MAX_BUFFER_SIZE);
-    return;
-  }
-  buffer = upsertAndPrune(entry, buffer, requestIndexMap, MAX_BUFFER_SIZE);
-  if (buffer.length >= MAX_BATCH_SIZE) flushBuffer();
-}
-function rebuildRequestIndex() {
-  requestIndexMap.clear();
-  for (let i = 0; i < buffer.length; i++) {
-    requestIndexMap.set(buffer[i].requestId, i);
-  }
-}
-function flushBuffer() {
-  if (buffer.length === 0 || !client2?.connected) return;
-  client2.send({
-    type: "runtime:networkRequest",
-    requests: [...buffer],
-    timestamp: Date.now()
-  });
-  buffer = [];
-  requestIndexMap.clear();
-}
-
-// src/fiberTreeWalker.ts
-var FIBER_TAGS = {
-  FunctionComponent: 0,
-  ClassComponent: 1,
-  HostRoot: 3,
-  // Root of a host tree (e.g., #root DOM node)
-  HostComponent: 5,
-  // DOM elements (div, span, etc.) - SKIP these
-  HostText: 6,
-  // Text nodes - SKIP these
-  Fragment: 7,
-  // React.Fragment - SKIP but traverse children
-  Mode: 8,
-  // React.StrictMode, ConcurrentMode - SKIP but traverse children
-  ContextConsumer: 9,
-  ContextProvider: 10,
-  ForwardRef: 11,
-  Profiler: 12,
-  // React.Profiler - SKIP but traverse children
-  SuspenseComponent: 13,
-  MemoComponent: 14,
-  SimpleMemoComponent: 15,
-  LazyComponent: 16,
-  OffscreenComponent: 22
-  // React 18 concurrent features - SKIP but traverse children
-};
-var USER_COMPONENT_TAGS = /* @__PURE__ */ new Set([
-  FIBER_TAGS.FunctionComponent,
-  FIBER_TAGS.ClassComponent,
-  FIBER_TAGS.ForwardRef,
-  FIBER_TAGS.MemoComponent,
-  FIBER_TAGS.SimpleMemoComponent
-]);
-function isLikelyQueryObserver(obj) {
-  if (obj === null || typeof obj !== "object") return false;
-  const candidate = obj;
-  return typeof candidate.getCurrentResult === "function" && typeof candidate.subscribe === "function";
-}
-function getQueryHashFromObserver(observer) {
-  if (observer.options && typeof observer.options === "object") {
-    const opts = observer.options;
-    if (typeof opts.queryHash === "string") return opts.queryHash;
-  }
-  if (observer.currentQuery && typeof observer.currentQuery === "object") {
-    const q = observer.currentQuery;
-    if (typeof q.queryHash === "string") return q.queryHash;
-  }
-  if (typeof observer.queryHash === "string") return observer.queryHash;
-  return null;
-}
-function detectQueryObserverHashes(fiber) {
-  let hookState = fiber.memoizedState;
-  if (!hookState) return void 0;
-  const seen = /* @__PURE__ */ new Set();
-  let iterations = 0;
-  while (hookState && iterations < 100) {
-    iterations++;
-    try {
-      const ms = hookState.memoizedState;
-      if (isLikelyQueryObserver(ms)) {
-        const hash = getQueryHashFromObserver(ms);
-        if (hash) seen.add(hash);
-      } else if (ms !== null && typeof ms === "object" && !Array.isArray(ms)) {
-        const ref = ms.current;
-        if (isLikelyQueryObserver(ref)) {
-          const hash = getQueryHashFromObserver(ref);
-          if (hash) seen.add(hash);
-        }
-      }
-    } catch {
-    }
-    hookState = hookState.next;
-  }
-  return seen.size > 0 ? Array.from(seen) : void 0;
-}
-function countFiberHooks(fiber) {
-  if (fiber._debugHookTypes) return fiber._debugHookTypes.length;
-  let count = 0;
-  let state = fiber.memoizedState;
-  while (state && count < 100) {
-    count++;
-    state = state.next;
-  }
-  return count;
-}
-function hasFiberContextHook(fiber) {
-  if (fiber.dependencies?.firstContext) return true;
-  if (fiber._debugHookTypes?.includes("useContext")) return true;
-  return false;
-}
-function detectTransitionPending(fiber) {
-  let state = fiber.memoizedState;
-  let iterations = 0;
-  while (state && iterations < 100) {
-    iterations++;
-    const ms = state.memoizedState;
-    if (Array.isArray(ms) && ms.length === 2 && typeof ms[0] === "boolean" && typeof ms[1] === "function") {
-      if (ms[0] === true) return true;
-    }
-    state = state.next;
-  }
-  return false;
-}
-var MAX_TREE_DEPTH = 100;
-var MAX_CHILDREN_PER_NODE = 300;
-var throttleTimer = null;
-var maxWaitTimer = null;
-var INTERVAL_MS_SMALL = 200;
-var INTERVAL_MS_MEDIUM = 500;
-var INTERVAL_MS_LARGE = 1e3;
-var snapshotIntervalMs = INTERVAL_MS_SMALL;
-var cachedFiberRoot = null;
-var isWalking = false;
-var pendingLocalStateCorrelations = [];
-var originalOnCommitFiberRoot = null;
-var isInstalled4 = false;
-var hookedRendererID = null;
-var activeStrategy = null;
-var lastSnapshotSentTime = 0;
-var DEVTOOLS_STALE_THRESHOLD_MS = 2e3;
-var debugEnabled = false;
-try {
-  debugEnabled = !!globalThis.__FLOTRACE_DEBUG__;
-} catch {
-}
-function debugLog(...args) {
-  if (debugEnabled) console.log(...args);
-}
-var fiberRefMap = /* @__PURE__ */ new Map();
-function getComponentName2(fiber) {
-  const type = fiber.type;
-  if (!type) return "Unknown";
-  if (typeof type === "function") {
-    return type.displayName || type.name || "Anonymous";
-  }
-  if (typeof type === "object" && type !== null) {
-    const t = type;
-    if (t.type) {
-      return t.type.displayName || t.type.name || "Memo";
-    }
-    if (t.render) {
-      return t.render.displayName || t.render.name || "ForwardRef";
-    }
-    return t.displayName || t.name || "Unknown";
-  }
-  if (typeof type === "string") {
-    return type;
-  }
-  return "Unknown";
-}
-function isUserComponent(fiber) {
-  if (!USER_COMPONENT_TAGS.has(fiber.tag)) return false;
-  const name = getComponentName2(fiber);
-  if (name === "Anonymous" || name === "Unknown" || name === "ForwardRef" || name === "Memo")
-    return false;
-  if (name.startsWith("FloTrace")) return false;
-  if (name.startsWith("@") || name.includes("/")) return false;
-  if (/^[$_][A-Za-z0-9]{0,3}$/.test(name)) return false;
-  if (fiber._debugSource?.fileName?.includes("node_modules")) return false;
-  return true;
-}
-var FRAMEWORK_COMPONENT_NAMES = /* @__PURE__ */ new Set([
-  // Next.js App Router internals (Next.js 13–14)
-  "InnerLayoutRouter",
-  "OuterLayoutRouter",
-  "HotReload",
-  "RedirectBoundary",
-  "NotFoundBoundary",
-  "RenderFromTemplateContext",
-  "ScrollAndFocusHandler",
-  "AppRouter",
-  "ServerRoot",
-  "ReactDevOverlay",
-  "PathnameContextProviderAdapter",
-  "MetadataBoundary",
-  "ViewportBoundary",
-  "NotFoundErrorBoundary",
-  "RedirectErrorBoundary",
-  "InnerScrollAndFocusHandler",
-  "GlobalError",
-  // Next.js 15 / React 19 new internals
-  "ViewTransition",
-  // Next.js 15 shared-element transition wrapper
-  "ActionStateContext",
-  // Next.js 15 server action state context provider
-  "RequestCookiesProvider",
-  "DraftModeProvider",
-  // React Router v6 / v7
-  "Routes",
-  "Route",
-  "Router",
-  "BrowserRouter",
-  "HashRouter",
-  "MemoryRouter",
-  "Outlet",
-  "Navigate",
-  "RenderedRoute",
-  "RouterProvider",
-  // React 19 built-in primitives
-  "Activity",
-  // React 19: show/hide subtrees while preserving state (was <Offscreen>)
-  // Common library wrappers
-  "Suspense",
-  "ErrorBoundary",
-  "QueryClientProvider",
-  "PersistGate"
-]);
-var FRAMEWORK_PATH_PATTERNS = [
-  // React core / Next.js
-  /next[\\/]dist/,
-  /react-dom/,
-  /[\\/]scheduler[\\/]/,
-  // React internal scheduler package
-  // Routing
-  /react-router/,
-  // React Router v6
-  /@react-router[\\/]/,
-  // React Router v7 (scoped package)
-  // State management
-  /@tanstack[\\/]/,
-  // TanStack Query / Table / Router / Form / Virtual
-  /react-redux/,
-  /zustand/,
-  /jotai/,
-  /recoil/,
-  // UI component libraries (for when source maps are available)
-  /@fortawesome[\\/]/,
-  // Font Awesome icons
-  /framer-motion/,
-  // Framer Motion (PresenceChild, AnimatePresence, etc.)
-  /sonner/,
-  // Sonner toast
-  /@radix-ui[\\/]/,
-  // Radix UI primitives
-  /@headlessui[\\/]/,
-  // Headless UI
-  /@mui[\\/]/,
-  // Material UI
-  /@chakra-ui[\\/]/,
-  // Chakra UI
-  /react-spring/,
-  // React Spring
-  /react-transition-group/,
-  // React Transition Group
-  /react-aria/,
-  // Adobe React Aria
-  /react-hook-form/,
-  /formik/
-];
-function isFrameworkComponent(fiber, name) {
-  if (FRAMEWORK_COMPONENT_NAMES.has(name)) return true;
-  const filePath = fiber._debugSource?.fileName;
-  if (filePath) {
-    for (const pattern of FRAMEWORK_PATH_PATTERNS) {
-      if (pattern.test(filePath)) return true;
-    }
-  }
-  return false;
-}
-var KNOWN_LIBRARY_NAMES = /* @__PURE__ */ new Map([
-  // Font Awesome
-  ["FontAwesomeIcon", "fontawesome"],
-  ["FontAwesomeLayers", "fontawesome"],
-  ["FontAwesomeLayersText", "fontawesome"],
-  // Framer Motion
-  ["AnimatePresence", "framer"],
-  ["LazyMotion", "framer"],
-  ["MotionConfig", "framer"],
-  ["PresenceChild", "framer"],
-  ["LayoutGroupContext", "framer"],
-  // Lottie
-  ["Lottie", "lottie"],
-  ["LottiePlayer", "lottie"],
-  // Heroicons / Lucide exported icons sometimes appear as named functions
-  ["HeroIcon", "heroicons"]
-]);
-function detectLibraryName(fiber, name) {
-  if (name.includes(".")) {
-    return name.split(".")[0].toLowerCase();
-  }
-  if (name.startsWith("__")) {
-    return "internal";
-  }
-  const known = KNOWN_LIBRARY_NAMES.get(name);
-  return known;
-}
-function buildNodeId(name, sameNameIndex, parentId) {
-  const segment = `${name}-${sameNameIndex}`;
-  return parentId ? `${parentId}/${segment}` : segment;
-}
-function shallowPropsChanged(prev, next) {
-  if (prev === next) return false;
-  if (!prev || !next) return true;
-  const prevKeys = Object.keys(prev);
-  const nextKeys = Object.keys(next);
-  if (prevKeys.length !== nextKeys.length) return true;
-  for (const key of nextKeys) {
-    if (key === "children") continue;
-    if (prev[key] !== next[key]) return true;
-  }
-  return false;
-}
-function detectRenderReason(fiber, renderPhase) {
-  if (renderPhase === "mount") return "mount";
-  const prev = fiber.alternate;
-  if (!prev) return "mount";
-  if (shallowPropsChanged(prev.memoizedProps, fiber.memoizedProps)) {
-    return "props-changed";
-  }
-  return "state-or-context";
-}
-function scanFiberStateForOrigin(fiber, componentName) {
-  let hook = fiber.memoizedState;
-  let hookIndex = 0;
-  while (hook !== null) {
-    try {
-      const ms = hook.memoizedState;
-      if (ms !== null && typeof ms === "object") {
-        const isEffect = "tag" in ms && "create" in ms;
-        if (!isEffect) {
-          const rid = findFetchOrigin(ms);
-          if (rid) {
-            pendingLocalStateCorrelations.push({ requestId: rid, componentName, hookIndex });
-          } else if (hook.queue !== null) {
-            const lastRendered = hook.queue.lastRenderedState;
-            if (lastRendered !== null && typeof lastRendered === "object") {
-              const rid2 = findFetchOrigin(lastRendered);
-              if (rid2) {
-                pendingLocalStateCorrelations.push({ requestId: rid2, componentName, hookIndex });
-              }
-            }
-          }
-        }
-      }
-    } catch {
-    }
-    hook = hook.next;
-    hookIndex++;
-  }
-}
-function walkFiber(fiber, parentId, sharedNameCountMap, depth = 0, inSuspenseFallback = false) {
-  if (!fiber) return [];
-  if (depth >= MAX_TREE_DEPTH) return [];
-  const nodes = [];
-  let current = fiber;
-  const nameCountMap = sharedNameCountMap || /* @__PURE__ */ new Map();
-  while (current) {
-    try {
-      const tag = current.tag;
-      if (isUserComponent(current)) {
-        const name = getComponentName2(current);
-        const nameCount = nameCountMap.get(name) || 0;
-        nameCountMap.set(name, nameCount + 1);
-        const nodeId = buildNodeId(name, nameCount, parentId);
-        fiberRefMap.set(nodeId, current);
-        const renderPhase = current.alternate ? "update" : "mount";
-        const renderReason = detectRenderReason(current, renderPhase);
-        recordTimelineEvent(
-          nodeId,
-          name,
-          renderPhase === "mount" ? "mount" : "render",
-          { reason: renderReason },
-          current.actualDuration
-        );
-        const children = walkFiber(
-          current.child,
-          nodeId,
-          void 0,
-          depth + 1,
-          inSuspenseFallback
-        );
-        const truncatedChildren = children.length > MAX_CHILDREN_PER_NODE ? children.slice(0, MAX_CHILDREN_PER_NODE) : children;
-        const framework = isFrameworkComponent(current, name) || void 0;
-        const queryHashes = detectQueryObserverHashes(current);
-        const isTransitionPending = detectTransitionPending(current) || void 0;
-        const compilerStatus = detectCompilerStatus(current);
-        const isServerComponent = detectServerComponent(current) || void 0;
-        const libraryName = framework ? void 0 : detectLibraryName(current, name);
-        nodes.push({
-          id: nodeId,
-          name,
-          children: truncatedChildren,
-          fiberTag: tag,
-          renderPhase,
-          renderReason,
-          renderDuration: current.actualDuration,
-          filePath: current._debugSource?.fileName,
-          lineNumber: current._debugSource?.lineNumber,
-          isFramework: framework,
-          reactKey: typeof current.key === "string" ? current.key : void 0,
-          queryHashes,
-          hookCount: countFiberHooks(current),
-          hasContextHook: hasFiberContextHook(current) || void 0,
-          isTransitionPending,
-          isSuspenseFallback: inSuspenseFallback || void 0,
-          compilerStatus,
-          isServerComponent,
-          isLibrary: libraryName !== void 0 ? true : void 0,
-          libraryName
-        });
-        if (hasActiveTags() && current.memoizedState !== null) {
-          scanFiberStateForOrigin(current, name);
-        }
-      } else if (tag === FIBER_TAGS.HostText) {
-      } else if (tag === FIBER_TAGS.SuspenseComponent) {
-        const primary = current.child;
-        if (current.memoizedState === null && primary) {
-          const childNodes = walkFiber(
-            primary.child,
-            parentId,
-            nameCountMap,
-            depth,
-            inSuspenseFallback
-          );
-          nodes.push(...childNodes);
-        } else if (primary?.sibling) {
-          const childNodes = walkFiber(
-            primary.sibling,
-            parentId,
-            nameCountMap,
-            depth,
-            true
-            // all nodes in the fallback branch get isSuspenseFallback
-          );
-          nodes.push(...childNodes);
-        } else {
-          debugLog("[FloTrace] SuspenseComponent has no walkable children");
-        }
-      } else if (tag === FIBER_TAGS.OffscreenComponent) {
-        if (current.memoizedState === null) {
-          const childNodes = walkFiber(
-            current.child,
-            parentId,
-            nameCountMap,
-            depth,
-            inSuspenseFallback
-          );
-          nodes.push(...childNodes);
-        } else {
-          debugLog("[FloTrace] Skipping hidden OffscreenComponent subtree");
-        }
-      } else {
-        const childNodes = walkFiber(
-          current.child,
-          parentId,
-          nameCountMap,
-          depth,
-          inSuspenseFallback
-        );
-        nodes.push(...childNodes);
-      }
-    } catch (error) {
-      console.error("[FloTrace] Error processing fiber node, skipping:", error);
-    }
-    current = current.sibling;
-  }
-  return nodes;
-}
-function buildTreeFromFiberRoot(root) {
-  const rootFiber = root.current;
-  if (!rootFiber || !rootFiber.child) {
-    console.warn("[FloTrace] No root fiber or no child:", {
-      hasRoot: !!rootFiber,
-      hasChild: !!rootFiber?.child
-    });
-    return null;
-  }
-  fiberRefMap.clear();
-  const topLevelNodes = walkFiber(rootFiber.child, "");
-  debugLog(
-    "[FloTrace] walkFiber found",
-    topLevelNodes.length,
-    "top-level nodes"
-  );
-  if (topLevelNodes.length === 1) {
-    return topLevelNodes[0];
-  }
-  if (topLevelNodes.length > 0) {
-    return {
-      id: "Root",
-      name: "Root",
-      children: topLevelNodes,
-      fiberTag: FIBER_TAGS.HostRoot
-    };
-  }
-  return null;
-}
-function findFiberRootFromDOM() {
-  try {
-    if (typeof document === "undefined") return null;
-    const selectors = ["#root", "#__next", "#app", "#__nuxt", "[data-reactroot]"];
-    for (const selector of selectors) {
-      const element = document.querySelector(selector);
-      if (!element) continue;
-      debugLog(
-        `[FloTrace] Trying selector "${selector}" \u2192 found element`,
-        element.tagName,
-        element.id
-      );
-      const reactKeys = Object.keys(element).filter(
-        (k) => k.startsWith("__react") || k.startsWith("_react")
-      );
-      debugLog(`[FloTrace] React keys on element:`, reactKeys);
-      const fiberRoot = getFiberRootFromElement(element);
-      if (fiberRoot) {
-        debugLog("[FloTrace] Found fiber root from selector:", selector);
-        return fiberRoot;
-      }
-    }
-    const allBodyChildren = document.body?.children;
-    if (allBodyChildren) {
-      debugLog(
-        "[FloTrace] Scanning all",
-        allBodyChildren.length,
-        "body children for React root..."
-      );
-      for (const child of Array.from(allBodyChildren)) {
-        const reactKeys = Object.keys(child).filter(
-          (k) => k.startsWith("__react") || k.startsWith("_react")
-        );
-        if (reactKeys.length > 0) {
-          debugLog(
-            "[FloTrace] React keys on",
-            child.tagName,
-            child.id || "(no id)",
-            ":",
-            reactKeys
-          );
-        }
-        const fiberRoot = getFiberRootFromElement(child);
-        if (fiberRoot) {
-          debugLog(
-            "[FloTrace] Found fiber root from body child scan:",
-            child.tagName,
-            child.id || "(no id)"
-          );
-          return fiberRoot;
-        }
-      }
-    }
-    console.warn(
-      "[FloTrace] Could not find React fiber root from any DOM element"
-    );
-    return null;
-  } catch (error) {
-    console.error("[FloTrace] Error finding fiber root from DOM:", error);
-    return null;
-  }
-}
-function getFiberRootFromElement(element) {
-  const keys = Object.keys(element);
-  const containerKey = keys.find((k) => k.startsWith("__reactContainer$"));
-  if (containerKey) {
-    const hostRootFiber = element[containerKey];
-    if (hostRootFiber?.stateNode) {
-      return hostRootFiber.stateNode;
-    }
-  }
-  const fiberKey = keys.find(
-    (k) => k.startsWith("__reactFiber$") || k.startsWith("__reactInternalInstance$")
-  );
-  if (fiberKey) {
-    const fiber = element[fiberKey];
-    if (fiber) {
-      let current = fiber;
-      while (current?.return) {
-        current = current.return;
-      }
-      if (current && current.tag === FIBER_TAGS.HostRoot && current.stateNode) {
-        return current.stateNode;
-      }
-    }
-  }
-  const el = element;
-  if (el._reactRootContainer?._internalRoot) {
-    return el._reactRootContainer._internalRoot;
-  }
-  return null;
-}
-function adaptSnapshotInterval(nodeCount) {
-  if (nodeCount >= 200) {
-    snapshotIntervalMs = INTERVAL_MS_LARGE;
-  } else if (nodeCount >= 50) {
-    snapshotIntervalMs = INTERVAL_MS_MEDIUM;
-  } else {
-    snapshotIntervalMs = INTERVAL_MS_SMALL;
-  }
-}
-function executeSnapshot(root) {
-  if (isWalking) {
-    debugLog("[FloTrace] Skipped snapshot: already walking");
-    return;
-  }
-  isWalking = true;
-  try {
-    const tree = buildTreeFromFiberRoot(root);
-    if (!tree) {
-      console.warn("[FloTrace] buildTreeFromFiberRoot returned null");
-      return;
-    }
-    const nodeCount = fiberRefMap.size;
-    adaptSnapshotInterval(nodeCount);
-    const client4 = getWebSocketClient();
-    if (!client4.connected) {
-      console.warn(
-        "[FloTrace] WebSocket not connected, cannot send tree snapshot"
-      );
-      return;
-    }
-    const currentFlatTree = flattenTree2(tree);
-    const sendFull = previousFlatTree === null || snapshotCounter % FULL_SNAPSHOT_INTERVAL === 0;
-    if (sendFull) {
-      debugLog(
-        "[FloTrace] Sending FULL tree snapshot, root:",
-        tree.name,
-        "nodes:",
-        nodeCount,
-        "seq:",
-        snapshotCounter,
-        "nextInterval:",
-        snapshotIntervalMs + "ms"
-      );
-      client4.sendImmediate({
-        type: "runtime:treeSnapshot",
-        tree,
-        timestamp: Date.now()
-      });
-      lastSnapshotSentTime = Date.now();
-      diffSeq = 0;
-    } else {
-      const diff = computeTreeDiff(previousFlatTree, currentFlatTree);
-      if (diff) {
-        debugLog(
-          "[FloTrace] Sending tree diff, seq:",
-          diffSeq,
-          "added:",
-          diff.added.length,
-          "removed:",
-          diff.removed.length,
-          "updated:",
-          diff.updated.length
-        );
-        client4.sendImmediate({
-          type: "runtime:treeDiff",
-          seq: diffSeq,
-          added: diff.added,
-          removed: diff.removed,
-          updated: diff.updated,
-          timestamp: Date.now()
-        });
-        lastSnapshotSentTime = Date.now();
-        diffSeq++;
-      } else {
-        debugLog("[FloTrace] Tree unchanged, skipping diff");
-      }
-    }
-    previousFlatTree = currentFlatTree;
-    if (pendingLocalStateCorrelations.length > 0) {
-      const now = Date.now();
-      const toSend = pendingLocalStateCorrelations.splice(0);
-      for (const corr of toSend) {
-        try {
-          client4.sendImmediate({
-            type: "runtime:localStateCorrelation",
-            requestId: corr.requestId,
-            componentName: corr.componentName,
-            hookIndex: corr.hookIndex,
-            timestamp: now
-          });
-        } catch {
-        }
-      }
-    }
-    schedulePropDrillingAnalysis(tree, fiberRefMap, client4);
-    scanActionStateChanges(fiberRefMap, client4);
-    maybeEmitNextjsContext(client4);
-    snapshotCounter++;
-  } catch (error) {
-    console.error("[FloTrace] Error walking fiber tree:", error);
-  } finally {
-    isWalking = false;
-  }
-}
-function scheduleSnapshot(root) {
-  cachedFiberRoot = root;
-  if (throttleTimer) {
-    clearTimeout(throttleTimer);
-  }
-  throttleTimer = setTimeout(() => {
-    throttleTimer = null;
-    if (maxWaitTimer) {
-      clearTimeout(maxWaitTimer);
-      maxWaitTimer = null;
-    }
-    executeSnapshot(cachedFiberRoot);
-  }, snapshotIntervalMs);
-  if (!maxWaitTimer) {
-    maxWaitTimer = setTimeout(() => {
-      maxWaitTimer = null;
-      if (throttleTimer) {
-        clearTimeout(throttleTimer);
-        throttleTimer = null;
-      }
-      debugLog("[FloTrace] MaxWait forced snapshot (rapid commits detected)");
-      if (cachedFiberRoot) {
-        executeSnapshot(cachedFiberRoot);
-      }
-    }, snapshotIntervalMs * 2);
-  }
-}
-var previousFlatTree = null;
-var diffSeq = 0;
-var snapshotCounter = 0;
-var FULL_SNAPSHOT_INTERVAL = 10;
-function flattenTree2(root, out = /* @__PURE__ */ new Map()) {
-  out.set(root.id, root);
-  for (const child of root.children) {
-    flattenTree2(child, out);
-  }
-  return out;
-}
-function getParentId(nodeId) {
-  const lastSlash = nodeId.lastIndexOf("/");
-  return lastSlash === -1 ? "" : nodeId.substring(0, lastSlash);
-}
-function computeTreeDiff(prev, curr) {
-  const added = [];
-  const removed = [];
-  const updated = [];
-  for (const [id, currNode] of curr) {
-    const prevNode = prev.get(id);
-    if (!prevNode) {
-      added.push({ ...currNode, children: [], parentId: getParentId(id) });
-    } else {
-      if (prevNode.renderDuration !== currNode.renderDuration || prevNode.renderPhase !== currNode.renderPhase || prevNode.renderReason !== currNode.renderReason) {
-        updated.push({
-          id,
-          renderDuration: currNode.renderDuration,
-          renderPhase: currNode.renderPhase,
-          renderReason: currNode.renderReason
-        });
-      }
-    }
-  }
-  for (const id of prev.keys()) {
-    if (!curr.has(id)) {
-      removed.push(id);
-    }
-  }
-  if (added.length === 0 && removed.length === 0 && updated.length === 0) {
-    return null;
-  }
-  return { added, removed, updated };
-}
-function requestTreeSnapshot() {
-  if (!isInstalled4) {
-    return;
-  }
-  if (activeStrategy === "devtools") {
-    const elapsed = Date.now() - lastSnapshotSentTime;
-    if (elapsed < DEVTOOLS_STALE_THRESHOLD_MS) return;
-    debugLog("[FloTrace] DevTools hook stale (" + elapsed + "ms), falling back to DOM snapshot");
-  }
-  const root = findFiberRootFromDOM();
-  if (root) {
-    scheduleSnapshot(root);
-  }
-}
-function requestFullSnapshot() {
-  previousFlatTree = null;
-  snapshotCounter = 0;
-  diffSeq = 0;
-  if (cachedFiberRoot) {
-    scheduleSnapshot(cachedFiberRoot);
-  }
-}
-function installFiberTreeWalker() {
-  if (isInstalled4) {
-    console.warn("[FloTrace] Fiber tree walker already installed");
-    return () => uninstallFiberTreeWalker();
-  }
-  if (typeof window === "undefined") {
-    console.warn(
-      "[FloTrace] Not in browser environment, cannot install fiber tree walker"
-    );
-    return () => {
-    };
-  }
-  isInstalled4 = true;
-  try {
-    const client4 = getWebSocketClient();
-    installRscPayloadInterceptor(client4);
-  } catch {
-  }
-  const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook && typeof hook.onCommitFiberRoot === "function") {
-    originalOnCommitFiberRoot = hook.onCommitFiberRoot;
-    hook.onCommitFiberRoot = (rendererID, root, priority) => {
-      if (originalOnCommitFiberRoot) {
-        try {
-          originalOnCommitFiberRoot(rendererID, root, priority);
-        } catch (error) {
-          console.error(
-            "[FloTrace] Error in original onCommitFiberRoot:",
-            error
-          );
-        }
-      }
-      if (hookedRendererID === null) {
-        hookedRendererID = rendererID;
-      }
-      if (rendererID !== hookedRendererID) return;
-      try {
-        const client4 = getWebSocketClient();
-        if (client4.connected) {
-          const triggers = peekTriggers();
-          for (const trigger of triggers) {
-            client4.sendImmediate({ type: "runtime:renderTrigger", trigger });
-          }
-          const cascade = analyzeCascade(root, triggers);
-          if (cascade) {
-            client4.sendImmediate({ type: "runtime:renderCascade", cascade });
-          }
-          wrapFiberDispatchers(root);
-          clearTriggers();
-        }
-      } catch {
-      }
-      scheduleSnapshot(root);
-    };
-    activeStrategy = "devtools";
-    console.log(
-      "[FloTrace] Fiber tree walker installed (DevTools hook strategy)"
-    );
-    setTimeout(() => {
-      try {
-        const root = findFiberRootFromDOM();
-        if (root) {
-          scheduleSnapshot(root);
-        }
-      } catch (error) {
-        console.error("[FloTrace] Error sending initial DevTools snapshot:", error);
-      }
-    }, 100);
-  } else {
-    activeStrategy = "dom";
-    console.log(
-      "[FloTrace] Fiber tree walker installed (DOM fallback strategy)"
-    );
-    setTimeout(() => {
-      try {
-        const root = findFiberRootFromDOM();
-        if (root) {
-          scheduleSnapshot(root);
-        }
-      } catch (error) {
-        console.error("[FloTrace] Error sending initial DOM fallback snapshot:", error);
-      }
-    }, 100);
-  }
-  return () => uninstallFiberTreeWalker();
-}
-function getNodeProps(nodeId) {
-  const fiber = fiberRefMap.get(nodeId);
-  if (!fiber || !fiber.memoizedProps) {
-    return null;
-  }
-  try {
-    return serializeProps(fiber.memoizedProps);
-  } catch (error) {
-    console.error(`[FloTrace] Error serializing props for node "${nodeId}":`, error);
-    return null;
-  }
-}
-function detectDetailedRenderReason(fiber) {
-  if (!fiber.alternate) return { type: "mount" };
-  const prev = fiber.alternate;
-  if (shallowPropsChanged(prev.memoizedProps, fiber.memoizedProps)) {
-    const changedProps = diffProps(prev.memoizedProps, fiber.memoizedProps);
-    return { type: "props-changed", changedProps };
-  }
-  const changedHookIndices = diffHookStates(prev.memoizedState, fiber.memoizedState);
-  if (changedHookIndices.length > 0) {
-    return { type: "state-changed", changedHookIndices };
-  }
-  const changedContexts = detectContextChanges(fiber);
-  if (changedContexts.length > 0) {
-    return { type: "context-changed", contextNames: changedContexts };
-  }
-  const parentName = fiber.return ? getComponentName2(fiber.return) : void 0;
-  return { type: "parent-render", parentName };
-}
-function diffProps(prev, next) {
-  const changes = [];
-  if (!prev || !next) return changes;
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
-  for (const key of allKeys) {
-    if (key === "children") continue;
-    if (!Object.is(prev[key], next[key])) {
-      changes.push({
-        key,
-        prev: serializeValue(prev[key], 0, /* @__PURE__ */ new WeakSet()),
-        next: serializeValue(next[key], 0, /* @__PURE__ */ new WeakSet())
-      });
-    }
-  }
-  return changes;
-}
-function diffHookStates(prev, next) {
-  const changed = [];
-  let prevHook = prev;
-  let nextHook = next;
-  let index = 0;
-  while (prevHook && nextHook) {
-    if (prevHook.queue !== null || nextHook.queue !== null) {
-      if (!Object.is(prevHook.memoizedState, nextHook.memoizedState)) {
-        changed.push(index);
-      }
-    }
-    prevHook = prevHook.next;
-    nextHook = nextHook.next;
-    index++;
-  }
-  return changed;
-}
-function detectContextChanges(fiber) {
-  const changed = [];
-  if (!fiber.dependencies?.firstContext) return changed;
-  let ctx = fiber.dependencies.firstContext;
-  while (ctx) {
-    try {
-      if (!Object.is(ctx.memoizedValue, ctx.context._currentValue)) {
-        const name = ctx.context.displayName || "UnknownContext";
-        changed.push(name);
-      }
-    } catch {
-    }
-    ctx = ctx.next;
-  }
-  return changed;
-}
-function getDetailedRenderReason(nodeId) {
-  const fiber = fiberRefMap.get(nodeId);
-  if (!fiber) return null;
-  try {
-    return detectDetailedRenderReason(fiber);
-  } catch (error) {
-    console.error(`[FloTrace] Error detecting render reason for "${nodeId}":`, error);
-    return null;
-  }
-}
-function getNodeHooks(nodeId) {
-  const fiber = fiberRefMap.get(nodeId);
-  if (!fiber) return null;
-  try {
-    return inspectHooks(fiber);
-  } catch (error) {
-    console.error(`[FloTrace] Error inspecting hooks for node "${nodeId}":`, error);
-    return null;
-  }
-}
-function getNodeEffects(nodeId) {
-  const fiber = fiberRefMap.get(nodeId);
-  if (!fiber) return null;
-  try {
-    return inspectEffects(fiber);
-  } catch (error) {
-    console.error(`[FloTrace] Error inspecting effects for node "${nodeId}":`, error);
-    return null;
-  }
-}
-function getFiberRefMap() {
-  return fiberRefMap;
-}
-function uninstallFiberTreeWalker() {
-  if (!isInstalled4) return;
-  if (throttleTimer) {
-    clearTimeout(throttleTimer);
-    throttleTimer = null;
-  }
-  if (maxWaitTimer) {
-    clearTimeout(maxWaitTimer);
-    maxWaitTimer = null;
-  }
-  cachedFiberRoot = null;
-  if (activeStrategy === "devtools" && typeof window !== "undefined") {
-    const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) {
-      if (originalOnCommitFiberRoot) {
-        hook.onCommitFiberRoot = originalOnCommitFiberRoot;
-      } else {
-        delete hook.onCommitFiberRoot;
-      }
-    }
-  }
-  originalOnCommitFiberRoot = null;
-  hookedRendererID = null;
-  activeStrategy = null;
-  fiberRefMap = /* @__PURE__ */ new Map();
-  previousFlatTree = null;
-  snapshotCounter = 0;
-  diffSeq = 0;
-  lastSnapshotSentTime = 0;
-  isInstalled4 = false;
-  try {
-    uninstallRscPayloadInterceptor();
-  } catch {
-  }
-  clearActionStateCache();
-  resetNextjsDetection();
-  console.log("[FloTrace] Fiber tree walker uninstalled");
-}
-
-// src/storeUtils.ts
-function serializeStoreState(state, logPrefix) {
-  const serialized = {};
-  for (const [key, value] of Object.entries(state)) {
-    try {
-      serialized[key] = serializeValue(value);
-    } catch (error) {
-      console.error(`[FloTrace] Error serializing ${logPrefix} key "${key}":`, error);
-      serialized[key] = { __type: "error", value: "Serialization failed" };
-    }
-  }
-  return serialized;
-}
-function buildCorrelatedRequests(state, changedKeys) {
-  const byRequestId = /* @__PURE__ */ new Map();
-  for (const key of changedKeys) {
-    try {
-      const rid = findFetchOrigin(state[key]);
-      if (rid) {
-        const keys = byRequestId.get(rid) ?? [];
-        keys.push(key);
-        byRequestId.set(rid, keys);
-      }
-    } catch {
-    }
-  }
-  if (byRequestId.size === 0) return void 0;
-  return Array.from(byRequestId, ([requestId, storeKeys]) => ({ requestId, storeKeys }));
-}
-
-// src/zustandTracker.ts
-var activeUnsubscribers = [];
-var isInstalled5 = false;
-var debounceTimers = /* @__PURE__ */ new Map();
-var DEBOUNCE_MS = 200;
-function installZustandTracker(stores, client4) {
-  if (isInstalled5) {
-    console.warn("[FloTrace] Zustand tracker already installed, reinstalling");
-    uninstallZustandTracker();
-  }
-  isInstalled5 = true;
-  console.log("[FloTrace] Installing Zustand tracker for stores:", Object.keys(stores));
-  for (const [storeName, store] of Object.entries(stores)) {
-    if (!store || typeof store !== "object" && typeof store !== "function" || typeof store.getState !== "function" || typeof store.subscribe !== "function") {
-      console.warn(
-        `[FloTrace] Skipping "${storeName}" \u2014 not a valid Zustand store (missing getState/subscribe). Ensure you pass Zustand stores like: stores={{ myStore: useMyStore }}`
-      );
-      continue;
-    }
-    try {
-      const initialState = store.getState();
-      sendStoreUpdate(storeName, initialState, Object.keys(initialState), client4);
-      const unsubscribe = store.subscribe((newState, prevState) => {
-        try {
-          scheduleStoreUpdate(storeName, prevState, newState, client4);
-        } catch (error) {
-          console.error(`[FloTrace] Error in Zustand subscribe callback for "${storeName}":`, error);
-        }
-      });
-      activeUnsubscribers.push(unsubscribe);
-    } catch (error) {
-      console.error(`[FloTrace] Failed to install tracker for Zustand store "${storeName}":`, error);
-    }
-  }
-}
-function uninstallZustandTracker() {
-  if (!isInstalled5) return;
-  for (const timer of debounceTimers.values()) {
-    clearTimeout(timer);
-  }
-  debounceTimers.clear();
-  for (const unsubscribe of activeUnsubscribers) {
-    try {
-      unsubscribe();
-    } catch (error) {
-      console.error("[FloTrace] Error unsubscribing from Zustand store:", error);
-    }
-  }
-  activeUnsubscribers = [];
-  isInstalled5 = false;
-  console.log("[FloTrace] Zustand tracker uninstalled");
-}
-function scheduleStoreUpdate(storeName, prevState, newState, client4) {
-  let changedKeys;
-  try {
-    changedKeys = getChangedKeys(prevState, newState);
-  } catch (error) {
-    console.error(`[FloTrace] Error diffing Zustand state for "${storeName}":`, error);
-    return;
-  }
-  if (changedKeys.length === 0) return;
-  const existing = debounceTimers.get(storeName);
-  if (existing) clearTimeout(existing);
-  debounceTimers.set(storeName, setTimeout(() => {
-    debounceTimers.delete(storeName);
-    sendStoreUpdate(storeName, newState, changedKeys, client4);
-  }, DEBOUNCE_MS));
-}
-function sendStoreUpdate(storeName, state, changedKeys, client4) {
-  try {
-    if (!client4.connected) return;
-    client4.sendImmediate({
-      type: "runtime:zustand",
-      storeName,
-      state: serializeStoreState(state, `Zustand "${storeName}"`),
-      changedKeys,
-      correlatedRequests: buildCorrelatedRequests(state, changedKeys),
-      timestamp: Date.now()
-    });
-  } catch (error) {
-    console.error(`[FloTrace] Error sending Zustand update for "${storeName}":`, error);
-  }
-}
-
-// src/reduxTracker.ts
-var activeUnsubscribe = null;
-var isInstalled6 = false;
-var debounceTimer = null;
-var previousState = null;
-var DEBOUNCE_MS2 = 200;
-function isReduxStore(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.getState === "function" && typeof obj.subscribe === "function" && typeof obj.dispatch === "function";
-}
-function installReduxTracker(store, client4) {
-  if (isInstalled6) {
-    console.warn("[FloTrace] Redux tracker already installed, reinstalling");
-    uninstallReduxTracker();
-  }
-  isInstalled6 = true;
-  console.log("[FloTrace] Installing Redux tracker");
-  try {
-    const initialState = store.getState();
-    previousState = initialState;
-    sendReduxUpdate(initialState, Object.keys(initialState), client4);
-    activeUnsubscribe = store.subscribe(() => {
-      try {
-        const newState = store.getState();
-        scheduleReduxUpdate(newState, client4);
-      } catch (error) {
-        console.error("[FloTrace] Error in Redux subscribe callback:", error);
-      }
-    });
-  } catch (error) {
-    console.error("[FloTrace] Failed to install Redux tracker:", error);
-    isInstalled6 = false;
-  }
-}
-function uninstallReduxTracker() {
-  if (!isInstalled6) return;
-  if (debounceTimer) {
-    clearTimeout(debounceTimer);
-    debounceTimer = null;
-  }
-  if (activeUnsubscribe) {
-    try {
-      activeUnsubscribe();
-    } catch (error) {
-      console.error("[FloTrace] Error unsubscribing from Redux store:", error);
-    }
-    activeUnsubscribe = null;
-  }
-  previousState = null;
-  isInstalled6 = false;
-  console.log("[FloTrace] Redux tracker uninstalled");
-}
-function scheduleReduxUpdate(newState, client4) {
-  let changedKeys;
-  try {
-    changedKeys = getChangedKeys(previousState ?? {}, newState);
-  } catch (error) {
-    console.error("[FloTrace] Error diffing Redux state:", error);
-    return;
-  }
-  if (changedKeys.length === 0) return;
-  previousState = newState;
-  if (debounceTimer) clearTimeout(debounceTimer);
-  debounceTimer = setTimeout(() => {
-    debounceTimer = null;
-    sendReduxUpdate(newState, changedKeys, client4);
-  }, DEBOUNCE_MS2);
-}
-function sendReduxUpdate(state, changedKeys, client4) {
-  try {
-    if (!client4.connected) return;
-    client4.sendImmediate({
-      type: "runtime:redux",
-      state: serializeStoreState(state, "Redux"),
-      changedKeys,
-      correlatedRequests: buildCorrelatedRequests(state, changedKeys),
-      timestamp: Date.now()
-    });
-  } catch (error) {
-    console.error("[FloTrace] Error sending Redux update:", error);
-  }
-}
-
-// src/tanstackQueryTracker.ts
-var isInstalled7 = false;
-var queryUnsubscribe = null;
-var mutationUnsubscribe = null;
-var debounceTimer2 = null;
-var DEBOUNCE_MS3 = 300;
-var MAX_EVENTS_PER_QUERY = 50;
-var queryTracking = /* @__PURE__ */ new Map();
-var CORRELATION_WINDOW_MS = 500;
-var MAX_COMPLETED_CORRELATIONS = 20;
-var correlationCounter = 0;
-var pendingCorrelations = /* @__PURE__ */ new Map();
-var completedCorrelations = [];
-var mutationPrevStatus = /* @__PURE__ */ new Map();
-var mutationCorrelationMap = /* @__PURE__ */ new Map();
-function isTanStackQueryClient(obj) {
-  if (!obj || typeof obj !== "object") return false;
-  const candidate = obj;
-  return typeof candidate.getQueryCache === "function" && typeof candidate.getMutationCache === "function";
-}
-function installTanStackQueryTracker(queryClient, client4) {
-  if (isInstalled7) {
-    console.warn("[FloTrace] TanStack Query tracker already installed, reinstalling");
-    uninstallTanStackQueryTracker();
-  }
-  isInstalled7 = true;
-  console.log("[FloTrace] Installing TanStack Query tracker");
-  try {
-    const queryCache = queryClient.getQueryCache();
-    const mutationCache = queryClient.getMutationCache();
-    for (const query of queryCache.getAll()) {
-      if (!queryTracking.has(query.queryHash)) {
-        initQueryTracking(query);
-      }
-    }
-    for (const mutation of mutationCache.getAll()) {
-      mutationPrevStatus.set(mutation.mutationId, mutation.state.status);
-    }
-    sendSnapshot(queryCache, mutationCache, client4);
-    queryUnsubscribe = queryCache.subscribe((event) => {
-      try {
-        if (event.type === "added" || event.type === "removed" || event.type === "updated") {
-          if (event.query) {
-            updateQueryTracking(event.query, event.type);
-          }
-          scheduleSnapshot2(queryCache, mutationCache, client4);
-        }
-      } catch (error) {
-        console.error("[FloTrace] Error in TanStack Query cache subscribe callback:", error);
-      }
-    });
-    mutationUnsubscribe = mutationCache.subscribe((event) => {
-      try {
-        if (event.mutation) {
-          updateMutationTracking(event.mutation, queryCache, mutationCache, client4);
-        }
-        scheduleSnapshot2(queryCache, mutationCache, client4);
-      } catch (error) {
-        console.error("[FloTrace] Error in TanStack Mutation cache subscribe callback:", error);
-      }
-    });
-  } catch (error) {
-    console.error("[FloTrace] Failed to install TanStack Query tracker:", error);
-    isInstalled7 = false;
-  }
-}
-function uninstallTanStackQueryTracker() {
-  if (!isInstalled7) return;
-  if (debounceTimer2) {
-    clearTimeout(debounceTimer2);
-    debounceTimer2 = null;
-  }
-  if (queryUnsubscribe) {
-    try {
-      queryUnsubscribe();
-    } catch (e) {
-      console.error("[FloTrace] Error unsubscribing from QueryCache:", e);
-    }
-    queryUnsubscribe = null;
-  }
-  if (mutationUnsubscribe) {
-    try {
-      mutationUnsubscribe();
-    } catch (e) {
-      console.error("[FloTrace] Error unsubscribing from MutationCache:", e);
-    }
-    mutationUnsubscribe = null;
-  }
-  for (const pending of pendingCorrelations.values()) {
-    clearTimeout(pending.timeoutId);
-  }
-  pendingCorrelations.clear();
-  isInstalled7 = false;
-  console.log("[FloTrace] TanStack Query tracker uninstalled");
-}
-function computeDataHash(data) {
-  if (data === null || data === void 0) return "__null__";
-  try {
-    return JSON.stringify(data);
-  } catch {
-    return "__unhashable__";
-  }
-}
-function initQueryTracking(query) {
-  const state = {
-    lastDataHash: computeDataHash(query.state.data),
-    lastDataUpdatedAt: query.state.dataUpdatedAt,
-    prevStatus: query.state.status,
-    prevFetchStatus: query.state.fetchStatus,
-    totalFetchCount: 0,
-    wastedRefetchCount: 0,
-    events: []
-  };
-  queryTracking.set(query.queryHash, state);
-  return state;
-}
-function updateQueryTracking(query, eventType) {
-  let tracking = queryTracking.get(query.queryHash);
-  if (eventType === "removed") {
-    queryTracking.delete(query.queryHash);
-    return;
-  }
-  if (!tracking) {
-    tracking = initQueryTracking(query);
-  }
-  const currentStatus = query.state.status;
-  const currentFetchStatus = query.state.fetchStatus;
-  const statusChanged = tracking.prevStatus !== currentStatus;
-  const fetchStatusChanged = tracking.prevFetchStatus !== currentFetchStatus;
-  if (statusChanged || fetchStatusChanged) {
-    const currentDataHash = computeDataHash(query.state.data);
-    const dataChanged = currentDataHash !== tracking.lastDataHash;
-    const event = {
-      timestamp: Date.now(),
-      fromStatus: tracking.prevStatus,
-      toStatus: currentStatus,
-      fromFetchStatus: tracking.prevFetchStatus,
-      toFetchStatus: currentFetchStatus,
-      dataChanged
-    };
-    tracking.events.push(event);
-    if (tracking.events.length > MAX_EVENTS_PER_QUERY) {
-      tracking.events.shift();
-    }
-    if (tracking.prevFetchStatus === "fetching" && currentFetchStatus === "idle" && currentStatus === "success") {
-      tracking.totalFetchCount++;
-      if (!dataChanged) {
-        tracking.wastedRefetchCount++;
-      }
-      tracking.lastDataHash = currentDataHash;
-      tracking.lastDataUpdatedAt = query.state.dataUpdatedAt;
-      if (query.state.data !== null && query.state.data !== void 0) {
-        const rid = findFetchOrigin(query.state.data);
-        if (rid) tracking.pendingCorrelationId = rid;
-      }
-    }
-    if (tracking.prevFetchStatus === "idle" && currentFetchStatus === "fetching") {
-      const now = Date.now();
-      for (const pending of pendingCorrelations.values()) {
-        if (pending.idleQueryHashes.has(query.queryHash)) {
-          pending.affectedQueries.set(query.queryHash, {
-            fetchStartedAt: now,
-            queryKey: query.queryKey
-          });
-        }
+}
+function patchJsonParse() {
+  originalJsonParse = JSON.parse;
+  JSON.parse = function(text, reviver) {
+    const result = originalJsonParse.call(JSON, text, reviver);
+    if (activeXhrRequestId !== null && activeXhrResponseText !== null && text === activeXhrResponseText && result !== null && typeof result === "object") {
+      try {
+        (0, import_runtime_core.tagFetchData)(result, activeXhrRequestId, 0);
+      } catch {
       }
+      activeXhrRequestId = null;
+      activeXhrResponseText = null;
     }
-    tracking.prevStatus = currentStatus;
-    tracking.prevFetchStatus = currentFetchStatus;
-  }
+    return result;
+  };
 }
-function openCorrelationWindow(mutation, queryCache, mutationCache, client4) {
-  const correlationId = `corr-${++correlationCounter}`;
+function createEntry(method, parsedUrl, init) {
+  const requestId = String(++requestCounter);
+  const dedupeKey = `${method}:${parsedUrl.path}`;
+  const attribution = getAttribution();
+  const isServerAction = hasHeader(init, "Next-Action");
+  const isPrefetch = hasHeader(init, "Next-Router-Prefetch");
   const now = Date.now();
-  const idleQueryHashes = /* @__PURE__ */ new Set();
-  for (const query of queryCache.getAll()) {
-    if (query.state.fetchStatus === "idle") {
-      idleQueryHashes.add(query.queryHash);
-    }
-  }
-  const timeoutId = setTimeout(() => {
-    resolveCorrelation(correlationId, queryCache, mutationCache, client4);
-  }, CORRELATION_WINDOW_MS);
-  pendingCorrelations.set(correlationId, {
-    correlationId,
-    mutationId: mutation.mutationId,
-    mutationKey: mutation.options.mutationKey,
-    completedAt: now,
-    idleQueryHashes,
-    affectedQueries: /* @__PURE__ */ new Map(),
-    timeoutId
-  });
-  mutationCorrelationMap.set(mutation.mutationId, correlationId);
-}
-function resolveCorrelation(correlationId, queryCache, mutationCache, client4) {
-  const pending = pendingCorrelations.get(correlationId);
-  if (!pending) return;
-  pendingCorrelations.delete(correlationId);
-  if (pending.affectedQueries.size === 0) return;
-  const affectedQueries = [];
-  for (const [queryHash, info] of pending.affectedQueries) {
-    const tracking = queryTracking.get(queryHash);
-    let queryKeySerialized;
-    try {
-      queryKeySerialized = serializeValue(info.queryKey);
-    } catch {
-      queryKeySerialized = "[serialization failed]";
-    }
-    affectedQueries.push({
-      queryHash,
-      queryKey: queryKeySerialized,
-      fetchStartedAt: info.fetchStartedAt,
-      latencyMs: info.fetchStartedAt - pending.completedAt,
-      // dataChanged is resolved from the latest tracking state if the fetch completed
-      dataChanged: tracking?.events.length ? tracking.events[tracking.events.length - 1].dataChanged : void 0
-    });
-  }
-  let mutationKeySerialized;
-  if (pending.mutationKey) {
-    try {
-      mutationKeySerialized = serializeValue(pending.mutationKey);
-    } catch {
-      mutationKeySerialized = "[serialization failed]";
-    }
-  }
-  const correlation = {
-    correlationId,
-    mutationId: pending.mutationId,
-    mutationKey: mutationKeySerialized,
-    mutationCompletedAt: pending.completedAt,
-    affectedQueries,
-    resolvedAt: Date.now()
+  const isDuplicate = checkDuplicate(dedupeKey, now);
+  return {
+    requestId,
+    method,
+    urlPath: parsedUrl.path,
+    urlHost: parsedUrl.host,
+    status: 0,
+    durationMs: null,
+    responseSizeBytes: null,
+    componentName: attribution.componentName,
+    ancestorChain: attribution.ancestorChain,
+    initiatedDuringRender: attribution.duringRender,
+    initiatedInEffect: attribution.inEffect,
+    state: "pending",
+    dedupeKey,
+    isDuplicate: isDuplicate || void 0,
+    isServerAction: isServerAction || void 0,
+    isPrefetch: isPrefetch || void 0,
+    timestamp: now
   };
-  completedCorrelations.push(correlation);
-  if (completedCorrelations.length > MAX_COMPLETED_CORRELATIONS) {
-    completedCorrelations = completedCorrelations.slice(-MAX_COMPLETED_CORRELATIONS);
-  }
-  scheduleSnapshot2(queryCache, mutationCache, client4);
 }
-function updateMutationTracking(mutation, queryCache, mutationCache, client4) {
-  const currentStatus = mutation.state.status;
-  const prevStatus = mutationPrevStatus.get(mutation.mutationId);
-  mutationPrevStatus.set(mutation.mutationId, currentStatus);
-  if (prevStatus && prevStatus !== "success" && currentStatus === "success") {
-    openCorrelationWindow(mutation, queryCache, mutationCache, client4);
+function getAttribution() {
+  const fiber = (0, import_runtime_core.getCurrentRenderingFiber)();
+  if (fiber) {
+    const name = (0, import_runtime_core.getComponentNameFromFiber)(fiber);
+    const ancestors = (0, import_runtime_core.buildAncestorChain)(fiber).slice(-MAX_ANCESTOR_CHAIN);
+    return {
+      componentName: name || void 0,
+      ancestorChain: ancestors.length > 0 ? ancestors : void 0,
+      duringRender: true,
+      inEffect: false
+    };
   }
+  return { duringRender: false, inEffect: false };
 }
-function scheduleSnapshot2(queryCache, mutationCache, client4) {
-  if (debounceTimer2) clearTimeout(debounceTimer2);
-  debounceTimer2 = setTimeout(() => {
-    debounceTimer2 = null;
-    sendSnapshot(queryCache, mutationCache, client4);
-  }, DEBOUNCE_MS3);
+function extractUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
 }
-function serializeQueryData(data) {
-  if (data === null || data === void 0) return null;
+function parseUrl(url) {
   try {
-    return serializeValue(data);
+    const u = new URL(url, globalThis.location?.href ?? "http://localhost");
+    return { path: u.pathname, host: u.host };
   } catch {
-    return { __type: "truncated", originalType: typeof data };
+    return { path: url.split("?")[0] ?? url, host: "" };
   }
 }
-function extractErrorMessage(error) {
-  try {
-    return error instanceof Error ? error.message : String(error);
-  } catch {
-    return "Unknown error";
-  }
+var COMBINED_NOISE_PATTERN = new RegExp(
+  NOISE_URL_PATTERNS.map((r) => r.source).join("|"),
+  "i"
+);
+function isNoiseUrl(url) {
+  return COMBINED_NOISE_PATTERN.test(url);
 }
-function serializeQuery(query) {
-  let queryKeySerialized;
-  try {
-    queryKeySerialized = serializeValue(query.queryKey);
-  } catch {
-    queryKeySerialized = "[serialization failed]";
-  }
-  const errorMessage = query.state.error ? extractErrorMessage(query.state.error) : void 0;
-  const tracking = queryTracking.get(query.queryHash);
-  const correlatedRequestId = tracking?.pendingCorrelationId;
-  if (correlatedRequestId && tracking) {
-    tracking.pendingCorrelationId = void 0;
-  }
-  return {
-    queryKey: queryKeySerialized,
-    queryHash: query.queryHash,
-    status: query.state.status,
-    fetchStatus: query.state.fetchStatus,
-    dataUpdatedAt: query.state.dataUpdatedAt,
-    errorUpdatedAt: query.state.errorUpdatedAt,
-    isInvalidated: query.state.isInvalidated,
-    isStale: safeCall(() => query.isStale(), false),
-    isActive: safeCall(() => query.isActive(), false),
-    isDisabled: safeCall(() => query.isDisabled(), false),
-    failureCount: query.state.fetchFailureCount,
-    errorMessage,
-    observerCount: safeCall(() => query.getObserversCount(), 0),
-    staleTime: query.options.staleTime,
-    gcTime: query.options.gcTime,
-    // Phase 1: additional config for health analysis
-    refetchInterval: query.options.refetchInterval,
-    refetchOnWindowFocus: query.options.refetchOnWindowFocus,
-    refetchOnMount: query.options.refetchOnMount,
-    refetchOnReconnect: query.options.refetchOnReconnect,
-    networkMode: query.options.networkMode,
-    enabled: query.options.enabled,
-    retry: query.options.retry,
-    dataShape: serializeQueryData(query.state.data),
-    // Phase 2: wasted refetch tracking
-    wastedRefetchCount: tracking?.wastedRefetchCount,
-    totalFetchCount: tracking?.totalFetchCount,
-    // Phase 3: query timeline
-    events: tracking?.events.length ? [...tracking.events] : void 0,
-    correlatedRequestId
-  };
+function parseIntOrNull(value) {
+  if (!value) return null;
+  const n = parseInt(value, 10);
+  return isNaN(n) ? null : n;
 }
-function serializeMutation(mutation) {
-  const errorMessage = mutation.state.error ? extractErrorMessage(mutation.state.error) : void 0;
-  let mutationKey;
-  if (mutation.options.mutationKey) {
-    try {
-      mutationKey = serializeValue(mutation.options.mutationKey);
-    } catch {
-      mutationKey = "[serialization failed]";
-    }
-  }
-  return {
-    mutationId: mutation.mutationId,
-    status: mutation.state.status,
-    isPaused: mutation.state.isPaused,
-    submittedAt: mutation.state.submittedAt,
-    failureCount: mutation.state.failureCount,
-    errorMessage,
-    mutationKey,
-    scope: mutation.options.scope?.id,
-    lastCorrelationId: mutationCorrelationMap.get(mutation.mutationId)
-  };
+function parseContentLength(headers) {
+  return parseIntOrNull(headers.get("content-length"));
 }
-function sendSnapshot(queryCache, mutationCache, client4) {
-  try {
-    if (!client4.connected) return;
-    const queries = [];
-    for (const query of queryCache.getAll()) {
-      try {
-        queries.push(serializeQuery(query));
-      } catch (error) {
-        console.error(`[FloTrace] Error serializing query "${query.queryHash}":`, error);
-      }
-    }
-    const mutations = [];
-    const activeMutationIds = /* @__PURE__ */ new Set();
-    for (const mutation of mutationCache.getAll()) {
-      try {
-        activeMutationIds.add(mutation.mutationId);
-        mutations.push(serializeMutation(mutation));
-      } catch (error) {
-        console.error(`[FloTrace] Error serializing mutation ${mutation.mutationId}:`, error);
-      }
-    }
-    for (const id of mutationPrevStatus.keys()) {
-      if (!activeMutationIds.has(id)) {
-        mutationPrevStatus.delete(id);
-        mutationCorrelationMap.delete(id);
-      }
-    }
-    const correlations = completedCorrelations.length > 0 ? [...completedCorrelations] : void 0;
-    if (correlations) {
-      completedCorrelations = [];
-    }
-    client4.sendImmediate({
-      type: "runtime:tanstackQuery",
-      queries,
-      mutations,
-      correlations,
-      timestamp: Date.now()
-    });
-  } catch (error) {
-    console.error("[FloTrace] Error sending TanStack Query snapshot:", error);
-  }
+function parseXhrContentLength(xhr) {
+  return parseIntOrNull(xhr.getResponseHeader("content-length"));
 }
-function safeCall(fn, fallback) {
-  try {
-    return fn();
-  } catch {
-    return fallback;
+function hasHeader(init, name) {
+  if (!init?.headers) return false;
+  if (init.headers instanceof Headers) return init.headers.has(name);
+  if (Array.isArray(init.headers)) return init.headers.some(([k]) => k.toLowerCase() === name.toLowerCase());
+  if (typeof init.headers === "object") {
+    return Object.keys(init.headers).some((k) => k.toLowerCase() === name.toLowerCase());
   }
+  return false;
 }
-
-// src/routerTracker.ts
-var isInstalled8 = false;
-var debounceTimer3 = null;
-var client3 = null;
-var originalPushState = null;
-var originalReplaceState = null;
-var popstateHandler = null;
-var DEBOUNCE_MS4 = 200;
-function installRouterTracker(wsClient) {
-  if (isInstalled8) {
-    console.warn("[FloTrace] Router tracker already installed, reinstalling");
-    uninstallRouterTracker();
-  }
-  if (typeof window === "undefined" || typeof history === "undefined") {
-    console.warn("[FloTrace] Router tracker requires a browser environment");
-    return;
-  }
-  console.log("[FloTrace] Installing router tracker");
-  try {
-    isInstalled8 = true;
-    client3 = wsClient;
-    originalPushState = history.pushState.bind(history);
-    originalReplaceState = history.replaceState.bind(history);
-    history.pushState = function(data, unused, url) {
-      originalPushState(data, unused, url);
-      try {
-        scheduleRouterUpdate();
-      } catch (error) {
-        console.error("[FloTrace] Error in pushState handler:", error);
-      }
-    };
-    history.replaceState = function(data, unused, url) {
-      originalReplaceState(data, unused, url);
-      try {
-        scheduleRouterUpdate();
-      } catch (error) {
-        console.error("[FloTrace] Error in replaceState handler:", error);
-      }
-    };
-    popstateHandler = () => {
-      try {
-        scheduleRouterUpdate();
-      } catch (error) {
-        console.error("[FloTrace] Error in popstate handler:", error);
-      }
-    };
-    window.addEventListener("popstate", popstateHandler);
-    sendRouterUpdate();
-  } catch (error) {
-    console.error("[FloTrace] Failed to install router tracker:", error);
-    try {
-      uninstallRouterTracker();
-    } catch (_) {
-    }
+function checkDuplicate(dedupeKey, now) {
+  for (const [key, ts] of dedupeWindow) {
+    if (now - ts > DEDUPE_WINDOW_MS) dedupeWindow.delete(key);
   }
+  const isDup = dedupeWindow.has(dedupeKey);
+  dedupeWindow.set(dedupeKey, now);
+  return isDup;
 }
-function uninstallRouterTracker() {
-  if (!isInstalled8) return;
-  if (debounceTimer3) {
-    clearTimeout(debounceTimer3);
-    debounceTimer3 = null;
-  }
-  try {
-    if (originalPushState) {
-      history.pushState = originalPushState;
-      originalPushState = null;
-    }
-  } catch (error) {
-    console.error("[FloTrace] Error restoring pushState:", error);
-  }
-  try {
-    if (originalReplaceState) {
-      history.replaceState = originalReplaceState;
-      originalReplaceState = null;
-    }
-  } catch (error) {
-    console.error("[FloTrace] Error restoring replaceState:", error);
+function upsertAndPrune(entry, buf, idxMap, maxSize) {
+  const existingIdx = idxMap.get(entry.requestId);
+  if (existingIdx !== void 0 && existingIdx < buf.length && buf[existingIdx]?.requestId === entry.requestId) {
+    buf[existingIdx] = entry;
+    return buf;
   }
-  try {
-    if (popstateHandler) {
-      window.removeEventListener("popstate", popstateHandler);
-      popstateHandler = null;
-    }
-  } catch (error) {
-    console.error("[FloTrace] Error removing popstate listener:", error);
+  idxMap.set(entry.requestId, buf.length);
+  buf.push(entry);
+  if (buf.length > maxSize) {
+    const pruned = buf.slice(-maxSize);
+    idxMap.clear();
+    for (let i = 0; i < pruned.length; i++) idxMap.set(pruned[i].requestId, i);
+    return pruned;
   }
-  client3 = null;
-  isInstalled8 = false;
-  console.log("[FloTrace] Router tracker uninstalled");
+  return buf;
 }
-function scheduleRouterUpdate() {
-  if (debounceTimer3) clearTimeout(debounceTimer3);
-  debounceTimer3 = setTimeout(() => {
-    debounceTimer3 = null;
-    sendRouterUpdate();
-  }, DEBOUNCE_MS4);
+function pushEntry(entry) {
+  if (client2 === null && isPrewarmed) {
+    earlyBuffer = upsertAndPrune(entry, earlyBuffer, earlyRequestIndexMap, MAX_BUFFER_SIZE);
+    return;
+  }
+  buffer = upsertAndPrune(entry, buffer, requestIndexMap, MAX_BUFFER_SIZE);
+  if (buffer.length >= MAX_BATCH_SIZE) flushBuffer();
 }
-function sendRouterUpdate() {
-  try {
-    if (!client3?.connected) return;
-    const pathname = window.location.pathname;
-    const searchParams = {};
-    const urlSearchParams = new URLSearchParams(window.location.search);
-    for (const [key, value] of urlSearchParams.entries()) {
-      searchParams[key] = value;
-    }
-    client3.sendImmediate({
-      type: "runtime:router",
-      pathname,
-      // Matched route params (e.g., :id) are not available from the History API.
-      // Future enhancement: extract from React Router's fiber context.
-      params: {},
-      searchParams,
-      timestamp: Date.now()
-    });
-  } catch (error) {
-    console.error("[FloTrace] Error sending router update:", error);
+function rebuildRequestIndex() {
+  requestIndexMap.clear();
+  for (let i = 0; i < buffer.length; i++) {
+    requestIndexMap.set(buffer[i].requestId, i);
   }
 }
+function flushBuffer() {
+  if (buffer.length === 0 || !client2?.connected) return;
+  client2.send({
+    type: "runtime:networkRequest",
+    requests: [...buffer],
+    timestamp: Date.now()
+  });
+  buffer = [];
+  requestIndexMap.clear();
+}
 
 // src/FloTraceProvider.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -4076,7 +584,20 @@ function useFloTrace() {
   return (0, import_react.useContext)(FloTraceContext);
 }
 function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClient }) {
-  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    console.warn(
+      "[FloTrace] FloTraceProvider (from @flotrace/runtime) detected a React Native environment. Install @flotrace/runtime-native and use FloTraceProviderNative instead. Skipping attach."
+    );
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+  }
+  const mergedConfig = {
+    ...import_runtime_core3.DEFAULT_CONFIG,
+    // Web default: expose the current page URL as the `appUrl` in runtime:ready.
+    // Runtime-core defaults this to undefined so it stays platform-agnostic.
+    getAppUrl: () => typeof window !== "undefined" ? window.location.href : void 0,
+    platform: "web",
+    ...config
+  };
   const [connected, setConnected] = import_react.default.useState(false);
   const trackingOptionsRef = (0, import_react.useRef)({});
   const storesRef = (0, import_react.useRef)(stores);
@@ -4087,9 +608,9 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
   queryClientRef.current = queryClient;
   const enabledRef = (0, import_react.useRef)(mergedConfig.enabled);
   enabledRef.current = mergedConfig.enabled;
-  if (mergedConfig.enabled && typeof WebSocket !== "undefined") {
-    getWebSocketClient(mergedConfig);
-    installFiberTreeWalker();
+  if (mergedConfig.enabled && typeof window !== "undefined") {
+    (0, import_runtime_core3.getWebSocketClient)(mergedConfig);
+    (0, import_runtime_core3.installFiberTreeWalker)();
     prewarmNetworkTracker();
   }
   (0, import_react.useEffect)(() => {
@@ -4100,59 +621,59 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
       clearTimeout(pendingCleanupTimer);
       pendingCleanupTimer = null;
     }
-    const client4 = getWebSocketClient();
-    const unsubConnection = client4.onConnectionChange((isConnected) => {
+    const client3 = (0, import_runtime_core3.getWebSocketClient)();
+    const unsubConnection = client3.onConnectionChange((isConnected) => {
       setConnected(isConnected);
       if (isConnected) {
-        requestFullSnapshot();
+        (0, import_runtime_core3.requestFullSnapshot)();
       }
     });
-    const unsubMessage = client4.onMessage((message) => {
+    const unsubMessage = client3.onMessage((message) => {
       try {
         switch (message.type) {
           case "ext:ping":
-            client4.sendImmediate({ type: "runtime:ready", appName: mergedConfig.appName });
+            client3.sendImmediate({ type: "runtime:ready", appName: mergedConfig.appName });
             break;
           case "ext:startTracking":
             trackingOptionsRef.current = message.options || {};
             if (message.options?.trackZustand && storesRef.current && Object.keys(storesRef.current).length > 0) {
-              safeTrackerOp("Zustand install", () => installZustandTracker(storesRef.current, client4));
+              safeTrackerOp("Zustand install", () => (0, import_runtime_core3.installZustandTracker)(storesRef.current, client3));
             }
             if (message.options?.trackRedux && reduxStoreRef.current) {
-              safeTrackerOp("Redux install", () => installReduxTracker(reduxStoreRef.current, client4));
+              safeTrackerOp("Redux install", () => (0, import_runtime_core3.installReduxTracker)(reduxStoreRef.current, client3));
             }
             if (message.options?.trackTanstackQuery && queryClientRef.current) {
-              safeTrackerOp("TanStack Query install", () => installTanStackQueryTracker(queryClientRef.current, client4));
+              safeTrackerOp("TanStack Query install", () => (0, import_runtime_core3.installTanStackQueryTracker)(queryClientRef.current, client3));
             }
             if (message.options?.trackRouter) {
-              safeTrackerOp("Router install", () => installRouterTracker(client4));
+              safeTrackerOp("Router install", () => installRouterTracker(client3));
             }
             if (message.options?.trackNetwork) {
-              safeTrackerOp("Network install", () => installNetworkTracker(client4));
+              safeTrackerOp("Network install", () => installNetworkTracker(client3));
             }
-            safeTrackerOp("Timeline install", () => installTimelineTracker(client4));
+            safeTrackerOp("Timeline install", () => (0, import_runtime_core3.installTimelineTracker)(client3));
             console.log("[FloTrace] Tracking started with options:", message.options);
             break;
           case "ext:stopTracking":
             trackingOptionsRef.current = {};
-            safeTrackerOp("Zustand uninstall", uninstallZustandTracker);
-            safeTrackerOp("Redux uninstall", uninstallReduxTracker);
-            safeTrackerOp("TanStack Query uninstall", uninstallTanStackQueryTracker);
+            safeTrackerOp("Zustand uninstall", import_runtime_core3.uninstallZustandTracker);
+            safeTrackerOp("Redux uninstall", import_runtime_core3.uninstallReduxTracker);
+            safeTrackerOp("TanStack Query uninstall", import_runtime_core3.uninstallTanStackQueryTracker);
             safeTrackerOp("Router uninstall", uninstallRouterTracker);
-            safeTrackerOp("Timeline uninstall", uninstallTimelineTracker);
+            safeTrackerOp("Timeline uninstall", import_runtime_core3.uninstallTimelineTracker);
             safeTrackerOp("Network uninstall", uninstallNetworkTracker);
             console.log("[FloTrace] Tracking stopped");
             break;
           case "ext:startTreeTracking":
-            installFiberTreeWalker();
+            (0, import_runtime_core3.installFiberTreeWalker)();
             break;
           case "ext:stopTreeTracking":
-            uninstallFiberTreeWalker();
+            (0, import_runtime_core3.uninstallFiberTreeWalker)();
             console.log("[FloTrace] Tree tracking stopped");
             break;
           case "ext:requestNodeProps": {
-            const props = getNodeProps(message.nodeId);
-            client4.sendImmediate({
+            const props = (0, import_runtime_core3.getNodeProps)(message.nodeId);
+            client3.sendImmediate({
               type: "runtime:nodeProps",
               nodeId: message.nodeId,
               props: props || {},
@@ -4161,8 +682,8 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
             break;
           }
           case "ext:requestNodeHooks": {
-            const hooks = getNodeHooks(message.nodeId);
-            client4.sendImmediate({
+            const hooks = (0, import_runtime_core3.getNodeHooks)(message.nodeId);
+            client3.sendImmediate({
               type: "runtime:nodeHooks",
               nodeId: message.nodeId,
               hooks: hooks || [],
@@ -4171,8 +692,8 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
             break;
           }
           case "ext:requestNodeEffects": {
-            const effects = getNodeEffects(message.nodeId);
-            client4.sendImmediate({
+            const effects = (0, import_runtime_core3.getNodeEffects)(message.nodeId);
+            client3.sendImmediate({
               type: "runtime:nodeEffects",
               nodeId: message.nodeId,
               effects: effects || [],
@@ -4181,9 +702,9 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
             break;
           }
           case "ext:requestDetailedRenderReason": {
-            const reason = getDetailedRenderReason(message.nodeId);
+            const reason = (0, import_runtime_core3.getDetailedRenderReason)(message.nodeId);
             if (reason) {
-              client4.sendImmediate({
+              client3.sendImmediate({
                 type: "runtime:detailedRenderReason",
                 nodeId: message.nodeId,
                 reason,
@@ -4193,14 +714,14 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
             break;
           }
           case "ext:requestFullSnapshot":
-            requestFullSnapshot();
+            (0, import_runtime_core3.requestFullSnapshot)();
             console.log("[FloTrace] Full snapshot requested by extension");
             break;
           case "ext:requestTimeline": {
-            const events = getTimeline(message.nodeId);
+            const events = (0, import_runtime_core3.getTimeline)(message.nodeId);
             const componentName = message.nodeId.split("/").pop()?.replace(/-\d+$/, "") ?? "Unknown";
             for (const event of events) {
-              client4.sendImmediate({
+              client3.sendImmediate({
                 type: "runtime:timelineEvent",
                 nodeId: message.nodeId,
                 componentName,
@@ -4210,37 +731,37 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
             break;
           }
           case "ext:startNetworkCapture":
-            safeTrackerOp("Network capture start", () => installNetworkTracker(client4));
+            safeTrackerOp("Network capture start", () => installNetworkTracker(client3));
             break;
           case "ext:stopNetworkCapture":
             safeTrackerOp("Network capture stop", uninstallNetworkTracker);
             break;
           // --- Individual tracker start/stop (sidebar panel show/hide) ---
           case "ext:startReduxTracking":
-            if (reduxStoreRef.current) safeTrackerOp("Redux install", () => installReduxTracker(reduxStoreRef.current, client4));
+            if (reduxStoreRef.current) safeTrackerOp("Redux install", () => (0, import_runtime_core3.installReduxTracker)(reduxStoreRef.current, client3));
             break;
           case "ext:stopReduxTracking":
-            safeTrackerOp("Redux uninstall", uninstallReduxTracker);
+            safeTrackerOp("Redux uninstall", import_runtime_core3.uninstallReduxTracker);
             break;
           case "ext:startRouterTracking":
-            safeTrackerOp("Router install", () => installRouterTracker(client4));
+            safeTrackerOp("Router install", () => installRouterTracker(client3));
             break;
           case "ext:stopRouterTracking":
             safeTrackerOp("Router uninstall", uninstallRouterTracker);
             break;
           case "ext:startZustandTracking":
             if (storesRef.current && Object.keys(storesRef.current).length > 0) {
-              safeTrackerOp("Zustand install", () => installZustandTracker(storesRef.current, client4));
+              safeTrackerOp("Zustand install", () => (0, import_runtime_core3.installZustandTracker)(storesRef.current, client3));
             }
             break;
           case "ext:stopZustandTracking":
-            safeTrackerOp("Zustand uninstall", uninstallZustandTracker);
+            safeTrackerOp("Zustand uninstall", import_runtime_core3.uninstallZustandTracker);
             break;
           case "ext:startTanstackTracking":
-            if (queryClientRef.current) safeTrackerOp("TanStack Query install", () => installTanStackQueryTracker(queryClientRef.current, client4));
+            if (queryClientRef.current) safeTrackerOp("TanStack Query install", () => (0, import_runtime_core3.installTanStackQueryTracker)(queryClientRef.current, client3));
             break;
           case "ext:stopTanstackTracking":
-            safeTrackerOp("TanStack Query uninstall", uninstallTanStackQueryTracker);
+            safeTrackerOp("TanStack Query uninstall", import_runtime_core3.uninstallTanStackQueryTracker);
             break;
           case "ext:requestState":
             break;
@@ -4249,30 +770,30 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
         console.error(`[FloTrace] Error handling message type "${message.type}":`, error);
       }
     });
-    client4.connect();
+    client3.connect();
     return () => {
       unsubConnection();
       unsubMessage();
       pendingCleanupTimer = setTimeout(() => {
         pendingCleanupTimer = null;
-        safeTrackerOp("cleanup fiberTreeWalker", uninstallFiberTreeWalker);
-        safeTrackerOp("cleanup zustandTracker", uninstallZustandTracker);
-        safeTrackerOp("cleanup reduxTracker", uninstallReduxTracker);
-        safeTrackerOp("cleanup tanstackQueryTracker", uninstallTanStackQueryTracker);
+        safeTrackerOp("cleanup fiberTreeWalker", import_runtime_core3.uninstallFiberTreeWalker);
+        safeTrackerOp("cleanup zustandTracker", import_runtime_core3.uninstallZustandTracker);
+        safeTrackerOp("cleanup reduxTracker", import_runtime_core3.uninstallReduxTracker);
+        safeTrackerOp("cleanup tanstackQueryTracker", import_runtime_core3.uninstallTanStackQueryTracker);
         safeTrackerOp("cleanup routerTracker", uninstallRouterTracker);
-        safeTrackerOp("cleanup timelineTracker", uninstallTimelineTracker);
+        safeTrackerOp("cleanup timelineTracker", import_runtime_core3.uninstallTimelineTracker);
         safeTrackerOp("cleanup networkTracker", uninstallNetworkTracker);
-        safeTrackerOp("cleanup websocketClient", disposeWebSocketClient);
+        safeTrackerOp("cleanup websocketClient", import_runtime_core3.disposeWebSocketClient);
       }, 100);
     };
   }, [mergedConfig.enabled, mergedConfig.port, mergedConfig.appName]);
   const onRenderCallback = (0, import_react.useCallback)((id, phase, actualDuration, baseDuration, _startTime, commitTime) => {
     try {
       if (!enabledRef.current) return;
-      const client4 = getWebSocketClient();
-      if (!client4.connected) return;
+      const client3 = (0, import_runtime_core3.getWebSocketClient)();
+      if (!client3.connected) return;
       const normalizedPhase = phase === "nested-update" ? "update" : phase;
-      client4.send({
+      client3.send({
         type: "runtime:render",
         componentName: id,
         phase: normalizedPhase,
@@ -4280,7 +801,7 @@ function FloTraceProvider({ children, config = {}, stores, reduxStore, queryClie
         baseDuration,
         timestamp: commitTime
       });
-      requestTreeSnapshot();
+      (0, import_runtime_core3.requestTreeSnapshot)();
     } catch (error) {
       console.error("[FloTrace] Error in Profiler callback:", error);
     }
@@ -4301,12 +822,12 @@ function withFloTrace(Component, displayName) {
         if (!floTrace?.enabled) {
           return;
         }
-        const client4 = getWebSocketClient();
-        if (!client4.connected) {
+        const client3 = (0, import_runtime_core3.getWebSocketClient)();
+        if (!client3.connected) {
           return;
         }
         const normalizedPhase = phase === "nested-update" ? "update" : phase;
-        client4.send({
+        client3.send({
           type: "runtime:render",
           componentName: id,
           phase: normalizedPhase,
@@ -4315,10 +836,10 @@ function withFloTrace(Component, displayName) {
           timestamp: commitTime
         });
         if (floTrace.config.includeProps) {
-          client4.send({
+          client3.send({
             type: "runtime:props",
             componentName: id,
-            props: serializeProps(props),
+            props: (0, import_runtime_core3.serializeProps)(props),
             timestamp: commitTime
           });
         }
@@ -4339,16 +860,16 @@ function useTrackProps(componentName, props) {
       if (!floTrace?.enabled || !floTrace.config.includeProps) {
         return;
       }
-      const client4 = getWebSocketClient();
-      if (!client4.connected) {
+      const client3 = (0, import_runtime_core3.getWebSocketClient)();
+      if (!client3.connected) {
         return;
       }
-      const changedKeys = getChangedKeys(prevPropsRef.current, props);
+      const changedKeys = (0, import_runtime_core3.getChangedKeys)(prevPropsRef.current, props);
       if (changedKeys.length > 0) {
-        client4.send({
+        client3.send({
           type: "runtime:props",
           componentName,
-          props: serializeProps(props),
+          props: (0, import_runtime_core3.serializeProps)(props),
           changedKeys,
           timestamp: Date.now()
         });
@@ -4362,39 +883,13 @@ function useTrackProps(componentName, props) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DEFAULT_CONFIG,
   FloTraceProvider,
-  FloTraceWebSocketClient,
-  disposeWebSocketClient,
-  getDetailedRenderReason,
-  getFiberRefMap,
-  getNodeEffects,
-  getNodeHooks,
-  getTimeline,
-  getWebSocketClient,
-  inspectEffects,
-  inspectHooks,
-  installFiberTreeWalker,
   installNetworkTracker,
-  installReduxTracker,
   installRouterTracker,
-  installTanStackQueryTracker,
-  installTimelineTracker,
-  installZustandTracker,
-  isReduxStore,
-  isTanStackQueryClient,
-  recordTimelineEvent,
-  requestTreeSnapshot,
-  serializeProps,
-  serializeValue,
-  uninstallFiberTreeWalker,
   uninstallNetworkTracker,
-  uninstallReduxTracker,
   uninstallRouterTracker,
-  uninstallTanStackQueryTracker,
-  uninstallTimelineTracker,
-  uninstallZustandTracker,
   useFloTrace,
   useTrackProps,
-  withFloTrace
+  withFloTrace,
+  ...require("@flotrace/runtime-core")
 });