@rozenite/network-activity-plugin 1.5.1 → 1.6.0

package/dist/boot-recording.js

@@ -1,1086 +1,5 @@
-import { createNanoEvents } from "nanoevents";
-import { g as getEventSource } from "./event-source.js";
-import { Platform } from "react-native";
-import WebSocketInterceptor from "react-native/Libraries/WebSocket/WebSocketInterceptor";
-const REQUEST_TTL = 1e3 * 60 * 5;
-const getNetworkRequestsRegistry = () => {
-  const registry = /* @__PURE__ */ new Map();
-  const trimRegistry = () => {
-    const now = Date.now();
-    registry.forEach((entry) => {
-      if (now - entry.sentAt < REQUEST_TTL) {
-        return;
-      }
-      registry.delete(entry.id);
-    });
-  };
-  const addEntry = (id, request) => {
-    trimRegistry();
-    registry.set(id, {
-      id,
-      request,
-      sentAt: Date.now()
-    });
-  };
-  const getEntry = (id) => {
-    return registry.get(id)?.request ?? null;
-  };
-  const clear = () => {
-    registry.clear();
-  };
-  return {
-    addEntry,
-    getEntry,
-    clear
-  };
-};
-const XMLHttpRequest = global.XMLHttpRequest || window.XMLHttpRequest;
-const originalXHROpen = XMLHttpRequest.prototype.open;
-const originalXHRSend = XMLHttpRequest.prototype.send;
-const originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
-let openCallback;
-let sendCallback;
-let requestHeaderCallback;
-let headerReceivedCallback;
-let responseCallback;
-let overrideCallback;
-let isInterceptorEnabled$1 = false;
-const XHRInterceptor = {
-  /**
-   * Invoked before XMLHttpRequest.open(...) is called.
-   */
-  setOpenCallback(callback) {
-    openCallback = callback;
-  },
-  /**
-   * Invoked before XMLHttpRequest.send(...) is called.
-   */
-  setSendCallback(callback) {
-    sendCallback = callback;
-  },
-  /**
-   * Invoked after xhr's readyState becomes xhr.HEADERS_RECEIVED.
-   */
-  setHeaderReceivedCallback(callback) {
-    headerReceivedCallback = callback;
-  },
-  /**
-   * Invoked after xhr's readyState becomes xhr.DONE.
-   */
-  setResponseCallback(callback) {
-    responseCallback = callback;
-  },
-  /**
-   * Invoked before XMLHttpRequest.setRequestHeader(...) is called.
-   */
-  setRequestHeaderCallback(callback) {
-    requestHeaderCallback = callback;
-  },
-  /**
-   * Invoked before XMLHttpRequest.send(...) is called.
-   */
-  setOverrideCallback(callback) {
-    overrideCallback = callback;
-  },
-  isInterceptorEnabled() {
-    return isInterceptorEnabled$1;
-  },
-  enableInterception() {
-    if (isInterceptorEnabled$1) {
-      return;
-    }
-    XMLHttpRequest.prototype.open = function(method, url) {
-      if (openCallback) {
-        openCallback(method, url, this);
-      }
-      originalXHROpen.apply(this, arguments);
-    };
-    XMLHttpRequest.prototype.setRequestHeader = function(header, value) {
-      if (requestHeaderCallback) {
-        requestHeaderCallback(header, value, this);
-      }
-      originalXHRSetRequestHeader.apply(this, arguments);
-    };
-    XMLHttpRequest.prototype.send = function(data) {
-      if (sendCallback) {
-        sendCallback(data, this);
-      }
-      if (overrideCallback) {
-        overrideCallback(this);
-      }
-      if (this.addEventListener) {
-        this.addEventListener(
-          "readystatechange",
-          () => {
-            if (!isInterceptorEnabled$1) {
-              return;
-            }
-            if (this.readyState === this.HEADERS_RECEIVED) {
-              const contentTypeString = this.getResponseHeader("Content-Type");
-              const contentLengthString = this.getResponseHeader("Content-Length");
-              let responseContentType, responseSize;
-              if (contentTypeString) {
-                responseContentType = contentTypeString.split(";")[0];
-              }
-              if (contentLengthString) {
-                responseSize = parseInt(contentLengthString, 10);
-              }
-              if (headerReceivedCallback) {
-                headerReceivedCallback(
-                  responseContentType,
-                  responseSize,
-                  this.getAllResponseHeaders(),
-                  this
-                );
-              }
-            }
-            if (this.readyState === this.DONE) {
-              if (responseCallback) {
-                responseCallback(
-                  this.status,
-                  this.timeout,
-                  this.response,
-                  this.responseURL,
-                  this.responseType,
-                  this
-                );
-              }
-            }
-          },
-          false
-        );
-      }
-      originalXHRSend.apply(this, arguments);
-    };
-    isInterceptorEnabled$1 = true;
-  },
-  // Unpatch XMLHttpRequest methods and remove the callbacks.
-  disableInterception() {
-    if (!isInterceptorEnabled$1) {
-      return;
-    }
-    isInterceptorEnabled$1 = false;
-    XMLHttpRequest.prototype.send = originalXHRSend;
-    XMLHttpRequest.prototype.open = originalXHROpen;
-    XMLHttpRequest.prototype.setRequestHeader = originalXHRSetRequestHeader;
-    responseCallback = null;
-    openCallback = null;
-    sendCallback = null;
-    headerReceivedCallback = null;
-    requestHeaderCallback = null;
-    overrideCallback = null;
-  }
-};
-function safeStringify(data) {
-  try {
-    return typeof data === "string" ? data : JSON.stringify(data);
-  } catch {
-    return String(data);
-  }
-}
-const getStringSizeInBytes = (value) => {
-  return new TextEncoder().encode(value).length;
-};
-const isBlob = (value) => value instanceof Blob;
-const isArrayBuffer = (value) => value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-const isFormData = (value) => value instanceof FormData;
-const isNullOrUndefined = (value) => value === null || value === void 0;
-function getHttpHeader(headers, name) {
-  const lowerName = name.toLowerCase();
-  for (const key in headers) {
-    if (key.toLowerCase() === lowerName) {
-      return { value: headers[key], originalKey: key };
-    }
-  }
-  return void 0;
-}
-function getContentTypeMime(headers) {
-  const contentType = getHttpHeader(headers, "content-type");
-  if (!contentType) {
-    return void 0;
-  }
-  const { value } = contentType;
-  const actualValue = Array.isArray(value) ? value[0] : value;
-  return actualValue.split(";")[0].trim();
-}
-const getContentType = (request) => {
-  const responseHeaders = request.responseHeaders;
-  const responseType = request.responseType;
-  const contentType = getContentTypeMime(responseHeaders || {});
-  if (contentType) {
-    return contentType;
-  }
-  switch (responseType) {
-    case "arraybuffer":
-    case "blob":
-      return "application/octet-stream";
-    case "text":
-    case "":
-      return "text/plain";
-    case "json":
-      return "application/json";
-    case "document":
-      return "text/html";
-  }
-};
-function getBlobName(blob) {
-  if (typeof blob?.name === "string") {
-    return blob.name;
-  }
-  if (blob?.data && typeof blob.data.name === "string") {
-    return blob.data.name;
-  }
-  return void 0;
-}
-function getFormDataEntries(formData) {
-  if (!formData || typeof formData !== "object") {
-    return [];
-  }
-  if (typeof formData.entries === "function") {
-    return formData.entries();
-  }
-  if (Array.isArray(formData._parts)) {
-    return formData._parts;
-  }
-  return [];
-}
-const getBinaryPostData = (body) => ({
-  type: "binary",
-  value: {
-    size: body.size,
-    type: body.type,
-    name: getBlobName(body)
-  }
-});
-const getArrayBufferPostData = (body) => ({
-  type: "binary",
-  value: {
-    size: body.byteLength
-  }
-});
-const getTextPostData = (body) => ({
-  type: "text",
-  value: safeStringify(body)
-});
-const getFormDataPostData = (body) => ({
-  type: "form-data",
-  value: Array.from(getFormDataEntries(body)).reduce((acc, [key, value]) => {
-    if (isBlob(value)) {
-      acc[key] = getBinaryPostData(value);
-    } else if (isArrayBuffer(value)) {
-      acc[key] = getArrayBufferPostData(value);
-    } else {
-      acc[key] = getTextPostData(value);
-    }
-    return acc;
-  }, {})
-});
-const getRequestBody = (body) => {
-  if (isNullOrUndefined(body)) {
-    return body;
-  }
-  if (isBlob(body)) {
-    return getBinaryPostData(body);
-  }
-  if (isArrayBuffer(body)) {
-    return getArrayBufferPostData(body);
-  }
-  if (isFormData(body)) {
-    return getFormDataPostData(body);
-  }
-  return getTextPostData(body);
-};
-const getResponseSize = (request) => {
-  try {
-    const { responseType, response } = request;
-    if (response === null) {
-      return 0;
-    }
-    if (responseType === "" || responseType === "text") {
-      return getStringSizeInBytes(request.responseText);
-    }
-    if (responseType === "json") {
-      return getStringSizeInBytes(safeStringify(response));
-    }
-    if (responseType === "blob") {
-      return response.size;
-    }
-    if (responseType === "arraybuffer") {
-      return response.byteLength;
-    }
-    return 0;
-  } catch {
-    return null;
-  }
-};
-const getResponseBody = async (request) => {
-  const responseType = request.responseType;
-  if (responseType === "" || responseType === "text") {
-    return request.responseText;
-  }
-  if (responseType === "blob") {
-    const contentType = request.getResponseHeader("Content-Type") || "";
-    if (contentType.startsWith("text/") || contentType.startsWith("application/json")) {
-      return new Promise((resolve) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-          resolve(reader.result);
-        };
-        reader.readAsText(request.response);
-      });
-    }
-  }
-  if (responseType === "json") {
-    return safeStringify(request.response);
-  }
-  return null;
-};
-const getInitiatorFromStack = () => {
-  try {
-    const stack = new Error().stack;
-    if (!stack) {
-      return { type: "other" };
-    }
-    const line = stack.split("\n")[9];
-    const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
-    if (match) {
-      return {
-        type: "script",
-        url: match[2],
-        lineNumber: parseInt(match[3]),
-        columnNumber: parseInt(match[4])
-      };
-    }
-  } catch {
-  }
-  return { type: "other" };
-};
-const setupRequestOverride = (overridesRegistry, request) => {
-  const override = overridesRegistry.getOverrideForUrl(request._url);
-  if (!override) return;
-  request.addEventListener("readystatechange", () => {
-    if (override.body !== void 0) {
-      Object.defineProperty(request, "responseType", { writable: true });
-      Object.defineProperty(request, "response", { writable: true });
-      Object.defineProperty(request, "responseText", { writable: true });
-      const contentType = getContentType(request);
-      if (contentType === "application/json") {
-        request.responseType = "json";
-      } else if (contentType === "text/plain") {
-        request.responseType = "text";
-      }
-      request.response = override.body;
-      request.responseText = override.body;
-    }
-    if (override.status !== void 0) {
-      Object.defineProperty(request, "status", { writable: true });
-      request.status = override.status;
-    }
-  });
-};
-const splitSetCookieHeaderByComma = (header) => {
-  const regex = /(?:^|,\s)([^=;,]+=[^;]+(?:;[^,]*)*)/g;
-  const matches = [];
-  let match;
-  while ((match = regex.exec(header)) !== null) {
-    matches.push(match[1].trim());
-  }
-  return matches;
-};
-const applyReactNativeResponseHeadersLogic = (headers) => {
-  const parsedHeaders = { ...headers };
-  const setCookieHeader = getHttpHeader(headers, "set-cookie");
-  if (setCookieHeader) {
-    const { value, originalKey } = setCookieHeader;
-    const cookies = splitSetCookieHeaderByComma(value);
-    parsedHeaders[originalKey] = cookies.length > 0 ? cookies : value;
-  }
-  return parsedHeaders;
-};
-const createOverridesRegistry = () => {
-  let overrides = /* @__PURE__ */ new Map();
-  const setOverrides = (newOverrides) => {
-    overrides = new Map(newOverrides);
-  };
-  const getOverrideForUrl = (url) => {
-    return overrides.get(url);
-  };
-  return {
-    setOverrides,
-    getOverrideForUrl
-  };
-};
-let registryInstance = null;
-const getOverridesRegistry = () => {
-  if (!registryInstance) {
-    registryInstance = createOverridesRegistry();
-  }
-  return registryInstance;
-};
-const HTTP_EVENTS = [
-  "request-sent",
-  "response-received",
-  "request-completed",
-  "request-failed",
-  "request-progress"
-];
-const isHttpEvent = (type) => {
-  return HTTP_EVENTS.includes(type);
-};
-const READY_STATE_HEADERS_RECEIVED = 2;
-const getHTTPInspector = () => {
-  const eventEmitter = createNanoEvents();
-  const networkRequestsRegistry = getNetworkRequestsRegistry();
-  const overridesRegistry = getOverridesRegistry();
-  XHRInterceptor.setOverrideCallback(
-    (request) => setupRequestOverride(overridesRegistry, request)
-  );
-  return {
-    enable: () => {
-      if (XHRInterceptor.isInterceptorEnabled()) return;
-      XHRInterceptor.disableInterception();
-      XHRInterceptor.setSendCallback((data, request) => {
-        const initiator = getInitiatorFromStack();
-        const sendTime = Date.now();
-        const requestId = `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-        request._rozeniteRequestId = requestId;
-        networkRequestsRegistry.addEntry(requestId, request);
-        let ttfb = 0;
-        eventEmitter.emit("request-sent", {
-          requestId,
-          timestamp: sendTime,
-          request: {
-            url: request._url,
-            method: request._method,
-            headers: request._headers,
-            postData: getRequestBody(data)
-          },
-          type: "XHR",
-          initiator
-        });
-        request.addEventListener("readystatechange", () => {
-          if (request.readyState === READY_STATE_HEADERS_RECEIVED) {
-            ttfb = Date.now() - sendTime;
-          }
-        });
-        request.addEventListener("progress", (event) => {
-          eventEmitter.emit("request-progress", {
-            requestId,
-            timestamp: Date.now(),
-            loaded: event.loaded,
-            total: event.total,
-            lengthComputable: event.lengthComputable
-          });
-        });
-        request.addEventListener("load", () => {
-          eventEmitter.emit("response-received", {
-            requestId,
-            timestamp: Date.now(),
-            type: "XHR",
-            response: {
-              url: request._url,
-              status: request.status,
-              statusText: request.statusText,
-              headers: applyReactNativeResponseHeadersLogic(
-                request.responseHeaders || {}
-              ),
-              contentType: getContentType(request),
-              size: getResponseSize(request),
-              responseTime: Date.now()
-            }
-          });
-        });
-        request.addEventListener("loadend", () => {
-          eventEmitter.emit("request-completed", {
-            requestId,
-            timestamp: Date.now(),
-            duration: Date.now() - sendTime,
-            size: getResponseSize(request),
-            ttfb
-          });
-        });
-        request.addEventListener("error", () => {
-          eventEmitter.emit("request-failed", {
-            requestId,
-            timestamp: Date.now(),
-            type: "XHR",
-            error: "Failed",
-            canceled: false
-          });
-        });
-        request.addEventListener("abort", () => {
-          eventEmitter.emit("request-failed", {
-            requestId,
-            timestamp: Date.now(),
-            type: "XHR",
-            error: "Aborted",
-            canceled: true
-          });
-        });
-        request.addEventListener("timeout", () => {
-          eventEmitter.emit("request-failed", {
-            requestId,
-            timestamp: Date.now(),
-            type: "XHR",
-            error: "Timeout",
-            canceled: false
-          });
-        });
-      });
-      XHRInterceptor.enableInterception();
-    },
-    disable: () => {
-      XHRInterceptor.disableInterception();
-      networkRequestsRegistry.clear();
-    },
-    isEnabled: () => {
-      return XHRInterceptor.isInterceptorEnabled();
-    },
-    dispose: () => {
-      XHRInterceptor.disableInterception();
-      networkRequestsRegistry.clear();
-    },
-    getNetworkRequestsRegistry: () => networkRequestsRegistry,
-    on: (event, callback) => eventEmitter.on(event, callback)
-  };
-};
-const getWebSocketInterceptor = () => {
-  if (Platform.constants.reactNativeVersion.minor >= 79) {
-    return WebSocketInterceptor;
-  } else {
-    const WebSocketInterceptorPreRN079 = WebSocketInterceptor;
-    return {
-      ...WebSocketInterceptorPreRN079,
-      setOnMessageCallback: (callback) => {
-        WebSocketInterceptorPreRN079.setOnMessageCallback((socketId, data) => {
-          callback(data, socketId);
-        });
-      },
-      setOnCloseCallback: (callback) => {
-        WebSocketInterceptorPreRN079.setOnCloseCallback((error, socketId) => {
-          callback(socketId, error);
-        });
-      },
-      setOnErrorCallback: (callback) => {
-        WebSocketInterceptorPreRN079.setOnErrorCallback((error, socketId) => {
-          callback(socketId, error);
-        });
-      }
-    };
-  }
-};
-const WEBSOCKET_EVENTS = [
-  "websocket-connect",
-  "websocket-open",
-  "websocket-close",
-  "websocket-message-sent",
-  "websocket-message-received",
-  "websocket-error",
-  "websocket-connection-status-changed"
-];
-const isWebSocketEvent = (type) => {
-  return WEBSOCKET_EVENTS.includes(type);
-};
-const getWebSocketInspector = () => {
-  const eventEmitter = createNanoEvents();
-  const socketUrlMap = /* @__PURE__ */ new Map();
-  const webSocketInterceptor = getWebSocketInterceptor();
-  return {
-    enable: () => {
-      webSocketInterceptor.setConnectCallback(
-        (url, protocols, options, socketId) => {
-          socketUrlMap.set(socketId, url);
-          const event = {
-            type: "websocket-connect",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            protocols,
-            options
-          };
-          eventEmitter.emit("websocket-connect", event);
-        }
-      );
-      webSocketInterceptor.setCloseCallback(
-        (code, reason, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-close",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            code: code || 0,
-            reason: reason || void 0
-          };
-          eventEmitter.emit("websocket-close", event);
-          socketUrlMap.delete(socketId);
-        }
-      );
-      webSocketInterceptor.setOnMessageCallback(
-        (data, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-message-received",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            data,
-            messageType: typeof data === "string" ? "text" : "binary"
-          };
-          eventEmitter.emit("websocket-message-received", event);
-        }
-      );
-      webSocketInterceptor.setOnErrorCallback(
-        (error, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-error",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            error
-          };
-          eventEmitter.emit("websocket-error", event);
-        }
-      );
-      webSocketInterceptor.setSendCallback((data, socketId) => {
-        const url = socketUrlMap.get(socketId);
-        if (!url) {
-          return;
-        }
-        const event = {
-          type: "websocket-message-sent",
-          url,
-          socketId,
-          timestamp: Date.now(),
-          data,
-          messageType: typeof data === "string" ? "text" : "binary"
-        };
-        eventEmitter.emit("websocket-message-sent", event);
-      });
-      webSocketInterceptor.setOnOpenCallback((socketId) => {
-        const url = socketUrlMap.get(socketId);
-        if (!url) {
-          return;
-        }
-        const event = {
-          type: "websocket-open",
-          url,
-          socketId,
-          timestamp: Date.now()
-        };
-        eventEmitter.emit("websocket-open", event);
-      });
-      webSocketInterceptor.setOnCloseCallback(
-        (error, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-close",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            code: error.code,
-            reason: error.reason
-          };
-          eventEmitter.emit("websocket-close", event);
-          socketUrlMap.delete(socketId);
-        }
-      );
-      webSocketInterceptor.enableInterception();
-    },
-    disable: () => {
-      webSocketInterceptor.disableInterception();
-    },
-    isEnabled: () => webSocketInterceptor.isInterceptorEnabled(),
-    dispose: () => {
-      webSocketInterceptor.disableInterception();
-      socketUrlMap.clear();
-    },
-    on: (event, callback) => eventEmitter.on(event, callback)
-  };
-};
-let connectCallback;
-let messageCallback;
-let errorCallback;
-let openEventCallback;
-let closeCallback;
-let isInterceptorEnabled = false;
-const eventSourceClass = getEventSource();
-const originalOpen = eventSourceClass.prototype.open;
-const originalDispatch = eventSourceClass.prototype.dispatch;
-const BUILT_IN_EVENT_TYPES = /* @__PURE__ */ new Set(["open", "error", "close", "done"]);
-const SSEInterceptor = {
-  /**
-   * Invoked when EventSource.open() is called (connection attempt starting).
-   */
-  setConnectCallback(callback) {
-    connectCallback = callback;
-  },
-  /**
-   * Invoked when a message event is received.
-   */
-  setMessageCallback(callback) {
-    messageCallback = callback;
-  },
-  /**
-   * Invoked when an error event occurs.
-   */
-  setErrorCallback(callback) {
-    errorCallback = callback;
-  },
-  /**
-   * Invoked when the connection is successfully opened (open event fired).
-   */
-  setOpenEventCallback(callback) {
-    openEventCallback = callback;
-  },
-  /**
-   * Invoked when the connection is closed.
-   */
-  setCloseCallback(callback) {
-    closeCallback = callback;
-  },
-  isInterceptorEnabled() {
-    return isInterceptorEnabled;
-  },
-  enableInterception() {
-    if (isInterceptorEnabled) {
-      return;
-    }
-    eventSourceClass.prototype.open = function() {
-      if (connectCallback) {
-        connectCallback(this.url, this);
-      }
-      this.addEventListener("open", (event) => {
-        if (openEventCallback) {
-          openEventCallback(event, this);
-        }
-      });
-      this.addEventListener(
-        "error",
-        (event) => {
-          if (errorCallback) {
-            errorCallback(event, this);
-          }
-        }
-      );
-      this.addEventListener("close", (event) => {
-        if (closeCallback) {
-          closeCallback(event, this);
-        }
-      });
-      return originalOpen.call(this);
-    };
-    eventSourceClass.prototype.dispatch = function(eventType, data) {
-      if (!BUILT_IN_EVENT_TYPES.has(eventType)) {
-        if (messageCallback) {
-          messageCallback(data, this);
-        }
-      }
-      return originalDispatch.call(this, eventType, data);
-    };
-    isInterceptorEnabled = true;
-  },
-  // Unpatch EventSource open method and remove the callbacks.
-  disableInterception() {
-    if (!isInterceptorEnabled) {
-      return;
-    }
-    isInterceptorEnabled = false;
-    eventSourceClass.prototype.open = originalOpen;
-    eventSourceClass.prototype.dispatch = originalDispatch;
-    connectCallback = null;
-    messageCallback = null;
-    errorCallback = null;
-    openEventCallback = null;
-    closeCallback = null;
-  }
-};
-const SSE_EVENTS = [
-  "sse-open",
-  "sse-message",
-  "sse-error",
-  "sse-close"
-];
-const isSSEEvent = (type) => {
-  return SSE_EVENTS.includes(type);
-};
-const getSSEInspector = () => {
-  const eventEmitter = createNanoEvents();
-  const getRequestId = (eventSource) => {
-    const requestId = eventSource._xhr?._rozeniteRequestId;
-    if (!requestId) {
-      return null;
-    }
-    return requestId;
-  };
-  return {
-    enable: () => {
-      SSEInterceptor.setOpenEventCallback((_, eventSource) => {
-        const sseEventSource = eventSource;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const sseXhr = sseEventSource._xhr;
-        const event = {
-          type: "sse-open",
-          requestId,
-          timestamp: Date.now(),
-          response: {
-            url: sseXhr._url,
-            status: sseXhr.status,
-            statusText: sseXhr.statusText,
-            headers: sseXhr.responseHeaders || {},
-            contentType: getContentType(sseXhr),
-            size: 0,
-            responseTime: Date.now()
-          }
-        };
-        eventEmitter.emit("sse-open", event);
-      });
-      SSEInterceptor.setMessageCallback((messageEvent, eventSource) => {
-        const sseEventSource = eventSource;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const event = {
-          type: "sse-message",
-          requestId,
-          timestamp: Date.now(),
-          payload: {
-            type: messageEvent.type,
-            data: messageEvent.data || ""
-          }
-        };
-        eventEmitter.emit("sse-message", event);
-      });
-      SSEInterceptor.setErrorCallback((errorEvent, eventSource) => {
-        const sseEventSource = eventSource;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const event = {
-          type: "sse-error",
-          requestId,
-          timestamp: Date.now(),
-          error: {
-            type: errorEvent.type,
-            message: errorEvent.type === "timeout" ? "Timeout" : errorEvent.message
-          }
-        };
-        eventEmitter.emit("sse-error", event);
-      });
-      SSEInterceptor.setCloseCallback((_, eventSource) => {
-        const sseEventSource = eventSource;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const event = {
-          type: "sse-close",
-          requestId,
-          timestamp: Date.now()
-        };
-        eventEmitter.emit("sse-close", event);
-      });
-      SSEInterceptor.enableInterception();
-    },
-    disable: () => {
-      SSEInterceptor.disableInterception();
-    },
-    isEnabled: () => SSEInterceptor.isInterceptorEnabled(),
-    dispose: () => {
-      SSEInterceptor.disableInterception();
-    },
-    on: (event, callback) => eventEmitter.on(event, callback)
-  };
-};
-const DEFAULT_CONFIG = {
-  inspectors: {
-    http: true,
-    websocket: true,
-    sse: true
-  },
-  clientUISettings: {
-    showUrlAsName: false
-  }
-};
-const validateConfig = (config) => {
-  const inspectors = config.inspectors;
-  if (!inspectors) {
-    return;
-  }
-  if (inspectors.sse && !inspectors.http) {
-    throw new Error("SSE inspector requires HTTP inspector to be enabled.");
-  }
-};
-class EventsListener {
-  constructor() {
-    this.messageQueue = [];
-    this.sendFunction = null;
-    this.maxQueueSize = 200;
-    this.isQueuing = false;
-  }
-  setMaxQueueSize(size) {
-    this.maxQueueSize = size;
-  }
-  /**
-   * Enable queuing mode to capture events before client is connected
-   */
-  enableQueuing() {
-    this.isQueuing = true;
-  }
-  /**
-   * Connect the actual send function and automatically flush queued messages
-   */
-  connect(sendFn, filterFn) {
-    this.sendFunction = sendFn;
-    this.isQueuing = false;
-    this.flushQueue(filterFn);
-  }
-  isInQueueMode() {
-    return this.isQueuing;
-  }
-  /**
-   * Send a message (queued if not connected, sent directly if connected)
-   */
-  send(type, data) {
-    if (this.isQueuing) {
-      this.enqueueMessage({ type, data });
-    } else if (this.sendFunction) {
-      this.sendFunction(type, data);
-    }
-  }
-  enqueueMessage(message) {
-    if (this.messageQueue.length >= this.maxQueueSize) {
-      this.messageQueue.shift();
-    }
-    this.messageQueue.push(message);
-  }
-  flushQueue(filterFn) {
-    if (!this.sendFunction) {
-      return;
-    }
-    while (this.messageQueue.length > 0) {
-      const message = this.messageQueue.shift();
-      if (message) {
-        if (filterFn && !filterFn(message)) {
-          continue;
-        }
-        this.sendFunction(message.type, message.data);
-      }
-    }
-  }
-}
-const createEventsListener = () => {
-  return new EventsListener();
-};
-const createNetworkInspectorInstance = () => {
-  const http = getHTTPInspector();
-  const sse = getSSEInspector();
-  const websocket = getWebSocketInspector();
-  return {
-    http,
-    sse,
-    websocket,
-    setup(eventsListener) {
-      HTTP_EVENTS.forEach((event) => {
-        http.on(event, (data) => {
-          eventsListener.send(event, data);
-        });
-      });
-      SSE_EVENTS.forEach((event) => {
-        sse.on(event, (data) => {
-          eventsListener.send(data.type, data);
-        });
-      });
-      WEBSOCKET_EVENTS.forEach((event) => {
-        websocket.on(event, (data) => {
-          eventsListener.send(data.type, data);
-        });
-      });
-    },
-    enable(config = { http: true, sse: true, websocket: true }) {
-      if (config.http) http.enable();
-      if (config.sse) sse.enable();
-      if (config.websocket) websocket.enable();
-    },
-    disable() {
-      http.disable();
-      sse.disable();
-      websocket.disable();
-    },
-    dispose() {
-      http.dispose();
-      sse.dispose();
-      websocket.dispose();
-    }
-  };
-};
-const getNetworkInspector = /* @__PURE__ */ (() => {
-  let instance = null;
-  return () => {
-    if (!instance) {
-      instance = createNetworkInspectorInstance();
-    }
-    return instance;
-  };
-})();
-let inspectorsConfig;
-let bootRecordingEnabled = false;
-const createNetworkInspectorsConfiguration = (options) => {
-  if (inspectorsConfig) {
-    return inspectorsConfig;
-  }
-  bootRecordingEnabled = options?.enableBootRecording ?? true;
-  const maxQueueSize = options?.maxQueueSize ?? 200;
-  const inspectors = {
-    http: true,
-    websocket: true,
-    sse: true,
-    ...options?.inspectors
-  };
-  validateConfig({ inspectors });
-  const eventsListener = createEventsListener();
-  eventsListener.setMaxQueueSize(maxQueueSize);
-  const networkInspector = getNetworkInspector();
-  networkInspector.setup(eventsListener);
-  if (bootRecordingEnabled) {
-    eventsListener.enableQueuing();
-    networkInspector.enable(inspectors);
-  }
-  inspectorsConfig = {
-    eventsListener,
-    networkInspector
-  };
-  return inspectorsConfig;
-};
-const withOnBootNetworkActivityRecording = (options) => {
-  createNetworkInspectorsConfiguration(options);
-};
+import { c, w } from "./boot-recording.js";
 export {
-  DEFAULT_CONFIG as D,
-  getResponseBody as a,
-  isWebSocketEvent as b,
-  createNetworkInspectorsConfiguration as c,
-  isSSEEvent as d,
-  getOverridesRegistry as g,
-  isHttpEvent as i,
-  validateConfig as v,
-  withOnBootNetworkActivityRecording as w
+  c as createNetworkInspectorsConfiguration,
+  w as withOnBootNetworkActivityRecording
 };