@getlimelight/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,1244 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BodyFormat: () => BodyFormat,
+  ConsoleLevel: () => ConsoleLevel,
+  ConsoleSource: () => ConsoleSource,
+  ConsoleType: () => ConsoleType,
+  EventType: () => EventType,
+  GraphqlOprtation: () => GraphqlOprtation,
+  HttpMethod: () => HttpMethod,
+  HttpStatusClass: () => HttpStatusClass,
+  Limelight: () => Limelight,
+  NetworkPhase: () => NetworkPhase,
+  NetworkType: () => NetworkType
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/console.ts
+var ConsoleLevel = /* @__PURE__ */ ((ConsoleLevel2) => {
+  ConsoleLevel2["LOG"] = "log";
+  ConsoleLevel2["WARN"] = "warn";
+  ConsoleLevel2["ERROR"] = "error";
+  ConsoleLevel2["INFO"] = "info";
+  ConsoleLevel2["DEBUG"] = "debug";
+  ConsoleLevel2["TRACE"] = "trace";
+  return ConsoleLevel2;
+})(ConsoleLevel || {});
+var ConsoleSource = /* @__PURE__ */ ((ConsoleSource2) => {
+  ConsoleSource2["APP"] = "app";
+  ConsoleSource2["LIBRARY"] = "library";
+  ConsoleSource2["REACT_NATIVE"] = "react-native";
+  ConsoleSource2["NATIVE"] = "native";
+  return ConsoleSource2;
+})(ConsoleSource || {});
+var ConsoleType = /* @__PURE__ */ ((ConsoleType2) => {
+  ConsoleType2["EXCEPTION"] = "exception";
+  ConsoleType2["WARNING"] = "warning";
+  ConsoleType2["NETWORK"] = "network";
+  ConsoleType2["PERFORMANCE"] = "performance";
+  ConsoleType2["GENERAL"] = "general";
+  return ConsoleType2;
+})(ConsoleType || {});
+
+// src/types/core.ts
+var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
+  NetworkType2["FETCH"] = "fetch";
+  NetworkType2["XHR"] = "xhr";
+  NetworkType2["GRAPHQL"] = "graphql";
+  return NetworkType2;
+})(NetworkType || {});
+var NetworkPhase = /* @__PURE__ */ ((NetworkPhase2) => {
+  NetworkPhase2["CONNECT"] = "CONNECT";
+  NetworkPhase2["REQUEST"] = "REQUEST";
+  NetworkPhase2["RESPONSE"] = "RESPONSE";
+  NetworkPhase2["ERROR"] = "ERROR";
+  return NetworkPhase2;
+})(NetworkPhase || {});
+var BodyFormat = /* @__PURE__ */ ((BodyFormat2) => {
+  BodyFormat2["TEXT"] = "TEXT";
+  BodyFormat2["JSON"] = "JSON";
+  BodyFormat2["FORM_DATA"] = "FORM_DATA";
+  BodyFormat2["BLOB"] = "BLOB";
+  BodyFormat2["ARRAY_BUFFER"] = "ARRAY_BUFFER";
+  BodyFormat2["NONE"] = "NONE";
+  BodyFormat2["UNSERIALIZABLE"] = "UNSERIALIZABLE";
+  return BodyFormat2;
+})(BodyFormat || {});
+var HttpMethod = /* @__PURE__ */ ((HttpMethod4) => {
+  HttpMethod4["GET"] = "GET";
+  HttpMethod4["POST"] = "POST";
+  HttpMethod4["PUT"] = "PUT";
+  HttpMethod4["PATCH"] = "PATCH";
+  HttpMethod4["DELETE"] = "DELETE";
+  HttpMethod4["HEAD"] = "HEAD";
+  HttpMethod4["OPTIONS"] = "OPTIONS";
+  HttpMethod4["TRACE"] = "TRACE";
+  HttpMethod4["CONNECT"] = "CONNECT";
+  return HttpMethod4;
+})(HttpMethod || {});
+var HttpStatusClass = /* @__PURE__ */ ((HttpStatusClass2) => {
+  HttpStatusClass2[HttpStatusClass2["INFORMATIONAL"] = 100] = "INFORMATIONAL";
+  HttpStatusClass2[HttpStatusClass2["SUCCESS"] = 200] = "SUCCESS";
+  HttpStatusClass2[HttpStatusClass2["REDIRECTION"] = 300] = "REDIRECTION";
+  HttpStatusClass2[HttpStatusClass2["CLIENT_ERROR"] = 400] = "CLIENT_ERROR";
+  HttpStatusClass2[HttpStatusClass2["SERVER_ERROR"] = 500] = "SERVER_ERROR";
+  return HttpStatusClass2;
+})(HttpStatusClass || {});
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["NETWORK"] = "NETWORK";
+  EventType2["CONSOLE"] = "CONSOLE";
+  return EventType2;
+})(EventType || {});
+
+// src/types/graphql.ts
+var GraphqlOprtation = /* @__PURE__ */ ((GraphqlOprtation2) => {
+  GraphqlOprtation2["QUERY"] = "QUERY";
+  GraphqlOprtation2["MUTATION"] = "MUTATION";
+  GraphqlOprtation2["SUB"] = "SUBSCRIPTION";
+  return GraphqlOprtation2;
+})(GraphqlOprtation || {});
+
+// src/helpers/detection/detectConsoleType.ts
+var detectConsoleType = (level, args) => {
+  const messageStr = args.map((arg) => {
+    try {
+      return typeof arg === "object" ? JSON.stringify(arg) : String(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ").toLowerCase();
+  if (level === "error") {
+    if (messageStr.includes("error:") || messageStr.includes("exception") || messageStr.includes("uncaught") || messageStr.includes("unhandled") || args.some((arg) => arg instanceof Error)) {
+      return "exception" /* EXCEPTION */;
+    }
+  }
+  if (level === "warn") {
+    return "warning" /* WARNING */;
+  }
+  if (messageStr.includes("network") || messageStr.includes("fetch") || messageStr.includes("request") || messageStr.includes("response") || messageStr.includes("http") || messageStr.includes("api") || messageStr.includes("graphql") || messageStr.includes("xhr")) {
+    return "network" /* NETWORK */;
+  }
+  if (messageStr.includes("performance") || messageStr.includes("slow") || messageStr.includes("render") || messageStr.includes("fps") || messageStr.includes("memory") || messageStr.includes("optimization") || messageStr.includes("bottleneck")) {
+    return "performance" /* PERFORMANCE */;
+  }
+  return "general" /* GENERAL */;
+};
+
+// src/helpers/detection/detectSource.ts
+var detectLogSource = () => {
+  try {
+    const stack = new Error().stack;
+    if (!stack) return "app" /* APP */;
+    const stackLines = stack.split("\n");
+    for (let i = 3; i < stackLines.length; i++) {
+      const line = stackLines[i];
+      if (line === void 0) return "app" /* APP */;
+      if (line.includes("node_modules/react-native/") || line.includes("react-native/Libraries/") || line.includes("MessageQueue.js") || line.includes("BatchedBridge")) {
+        return "react-native" /* REACT_NATIVE */;
+      }
+      if (line.includes("[native code]") || line.includes("NativeModules")) {
+        return "native" /* NATIVE */;
+      }
+      if (!line.includes("node_modules/")) {
+        return "app" /* APP */;
+      }
+      if (!line.includes("node_modules/")) {
+        return "app" /* APP */;
+      }
+    }
+    return "app" /* APP */;
+  } catch {
+    return "app" /* APP */;
+  }
+};
+
+// src/helpers/detection/getInitiator.ts
+var getInitiator = () => {
+  try {
+    const stack = new Error().stack;
+    if (!stack) return "unknown";
+    const lines = stack.split("\n");
+    const callerLine = lines[4] || lines[3];
+    if (!callerLine) return "unknown";
+    const match = callerLine.match(/at (.+) \((.+):(\d+):(\d+)\)/);
+    if (match) {
+      const [, functionName, filePath, line] = match;
+      const fileName = filePath?.split("/").pop();
+      return `${functionName} (${fileName}:${line})`;
+    }
+    return callerLine.trim();
+  } catch {
+    return "unknown";
+  }
+};
+
+// src/helpers/graphql/detectGraphQlOperationType.ts
+var detectGraphQlOperationType = (query) => {
+  if (!query) return null;
+  if (query.trim().startsWith("mutation")) return "MUTATION" /* MUTATION */;
+  if (query.trim().startsWith("subscription")) return "SUBSCRIPTION" /* SUB */;
+  return "QUERY" /* QUERY */;
+};
+
+// src/helpers/graphql/isGraphQLRequest.ts
+var isGraphQLRequest = (url, body) => {
+  const isGraphqlUrl = url.toLowerCase().includes("graphql");
+  const rawBody = typeof body === "object" && body !== null ? body.raw : body;
+  if (typeof rawBody !== "string") return isGraphqlUrl;
+  try {
+    if (rawBody.includes('"query"') || rawBody.includes('"operationName"')) {
+      return true;
+    }
+  } catch {
+  }
+  return isGraphqlUrl;
+};
+
+// src/helpers/graphql/parseGraphQL.ts
+var parseGraphQL = (body) => {
+  try {
+    const parsed = typeof body === "string" ? JSON.parse(body) : body;
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    if (!parsed.query && !parsed.operationName) {
+      return null;
+    }
+    return {
+      operationName: parsed.operationName || void 0,
+      operationType: detectGraphQlOperationType(parsed.query),
+      variables: parsed.variables || void 0,
+      query: parsed.query || void 0
+    };
+  } catch {
+    return null;
+  }
+};
+
+// src/constants/index.ts
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "x-access-token",
+  "api-key",
+  "apikey",
+  "proxy-authorization",
+  "x-csrf-token",
+  "x-xsrf-token",
+  "x-auth",
+  "auth-token",
+  "access-token",
+  "secret",
+  "x-secret",
+  "bearer"
+];
+var DEFAULT_PORT = 9090;
+var WS_PATH = "/limelight";
+
+// src/helpers/safety/redactSensitiveHeaders.ts
+var redactSensitiveHeaders = (headers) => {
+  const redacted = { ...headers };
+  Object.keys(redacted).forEach((key) => {
+    if (SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+      redacted[key] = "[REDACTED]";
+    }
+  });
+  return redacted;
+};
+
+// src/helpers/safety/safeStringify.ts
+var safeStringify = (value, maxDepth = 10, pretty = false) => {
+  const seen = /* @__PURE__ */ new WeakMap();
+  const process2 = (val, currentDepth) => {
+    if (val === null) return null;
+    if (val === void 0) return "[undefined]";
+    if (typeof val === "bigint") return `${val}n`;
+    if (typeof val === "symbol") return val.toString();
+    if (typeof val === "function") {
+      return `[Function: ${val.name || "anonymous"}]`;
+    }
+    if (typeof val !== "object") return val;
+    if (currentDepth >= maxDepth) {
+      return "[Max Depth]";
+    }
+    if (seen.has(val)) {
+      return "[Circular]";
+    }
+    seen.set(val, true);
+    if (val instanceof Error) {
+      return {
+        __type: "Error",
+        name: val.name,
+        message: val.message,
+        stack: val.stack
+      };
+    }
+    if (val instanceof Date) {
+      return val.toISOString();
+    }
+    if (val instanceof RegExp) {
+      return val.toString();
+    }
+    if (val instanceof Map) {
+      const obj = {};
+      val.forEach((v, k) => {
+        const key = typeof k === "string" ? k : String(k);
+        obj[key] = process2(v, currentDepth + 1);
+      });
+      return obj;
+    }
+    if (val instanceof Set) {
+      return Array.from(val).map((v) => process2(v, currentDepth + 1));
+    }
+    if (ArrayBuffer.isView(val)) {
+      return `[${val.constructor.name}(${val.length})]`;
+    }
+    if (Array.isArray(val)) {
+      return val.map((item) => process2(item, currentDepth + 1));
+    }
+    const result = {};
+    for (const key in val) {
+      if (Object.prototype.hasOwnProperty.call(val, key)) {
+        result[key] = process2(val[key], currentDepth + 1);
+      }
+    }
+    return result;
+  };
+  try {
+    const processed = process2(value, 0);
+    return JSON.stringify(processed, null, pretty ? 2 : 0);
+  } catch (error) {
+    return JSON.stringify({
+      __error: "Stringification failed",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+
+// src/helpers/utils/serializeBody.ts
+var serializeBody = (input, disableBodyCapture) => {
+  if (disableBodyCapture) {
+    return { format: "NONE" /* NONE */, size: 0, preview: "" };
+  }
+  if (!input) {
+    return {
+      format: "NONE" /* NONE */,
+      size: 0,
+      preview: ""
+    };
+  }
+  try {
+    if (typeof input === "object") {
+      const json = JSON.stringify(input);
+      return {
+        format: "JSON" /* JSON */,
+        size: json.length,
+        preview: json.slice(0, 200),
+        raw: json
+      };
+    }
+    if (typeof input === "string") {
+      return {
+        format: "TEXT" /* TEXT */,
+        size: input.length,
+        preview: input.slice(0, 200),
+        raw: input
+      };
+    }
+    if (typeof FormData !== "undefined" && input instanceof FormData) {
+      return {
+        format: "FORM_DATA" /* FORM_DATA */,
+        size: 0,
+        preview: "[FormData]"
+      };
+    }
+    if (typeof Blob !== "undefined" && input instanceof Blob) {
+      return {
+        format: "BLOB" /* BLOB */,
+        size: input.size,
+        preview: "[Blob]"
+      };
+    }
+    if (input instanceof ArrayBuffer) {
+      return {
+        format: "ARRAY_BUFFER" /* ARRAY_BUFFER */,
+        size: input.byteLength,
+        preview: "[ArrayBuffer]"
+      };
+    }
+    return {
+      format: "UNSERIALIZABLE" /* UNSERIALIZABLE */,
+      size: 0,
+      preview: String(input)
+    };
+  } catch {
+    return {
+      format: "UNSERIALIZABLE" /* UNSERIALIZABLE */,
+      size: 0,
+      preview: "[Unserializable]"
+    };
+  }
+};
+
+// src/helpers/utils/isDevelopment.ts
+var isDevelopment = () => {
+  try {
+    const g = globalThis;
+    if (typeof g.__DEV__ !== "undefined") return !!g.__DEV__;
+    if (typeof process !== "undefined" && process.env?.NODE_ENV) {
+      return process.env.NODE_ENV !== "production";
+    }
+    const importMeta = g.import?.meta;
+    if (importMeta?.env?.DEV) {
+      return true;
+    }
+    if (typeof g.import !== "undefined" && g.import.meta?.env?.DEV) {
+      return true;
+    }
+  } catch (e) {
+    return true;
+  }
+  return true;
+};
+
+// src/helpers/utils/formatRequestName.ts
+var formatRequestName = (url) => {
+  try {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const segments = path.split("/").filter(Boolean);
+    return segments[segments.length - 1] || path || url;
+  } catch {
+    return url;
+  }
+};
+
+// src/limelight/interceptors/ConsoleInterceptor.ts
+var ConsoleInterceptor = class {
+  constructor(sendMessage, getSessionId) {
+    this.sendMessage = sendMessage;
+    this.getSessionId = getSessionId;
+  }
+  originalConsole = {};
+  counter = 0;
+  isSetup = false;
+  isInternalLog = false;
+  config = null;
+  /**
+   * Sets up console interception by wrapping console methods.
+   * Intercepts log, warn, error, info, debug, trace methods to capture console output.
+   * Prevents double setup and infinite loops from internal logging.
+   * @param {LimelightConfig} config - Configuration object for Limelight
+   * @returns {void}
+   */
+  setup(config) {
+    if (this.isSetup) {
+      console.warn("[Limelight] Console interceptor already set up");
+      return;
+    }
+    this.isSetup = true;
+    this.config = config;
+    const self = this;
+    const methods = [
+      "log" /* LOG */,
+      "warn" /* WARN */,
+      "error" /* ERROR */,
+      "info" /* INFO */,
+      "debug" /* DEBUG */,
+      "trace" /* TRACE */
+    ];
+    methods.forEach((level) => {
+      const original = console[level];
+      this.originalConsole[level] = original;
+      console[level] = function(...args) {
+        if (self.isInternalLog) {
+          return original.apply(console, args);
+        }
+        self.isInternalLog = true;
+        try {
+          const source = detectLogSource();
+          const consoleType = detectConsoleType(level, args);
+          const stackTrace = self.captureStackTrace();
+          let consoleEvent = {
+            id: `${self.getSessionId()}-${Date.now()}-${self.counter++}`,
+            phase: "CONSOLE",
+            type: "CONSOLE" /* CONSOLE */,
+            level,
+            timestamp: Date.now(),
+            sessionId: self.getSessionId(),
+            source,
+            consoleType,
+            args: args.map((arg) => safeStringify(arg)),
+            stackTrace
+          };
+          if (self.config?.beforeSend) {
+            const modifiedEvent = self.config.beforeSend(consoleEvent);
+            if (!modifiedEvent) {
+              return original.apply(console, args);
+            }
+            if (modifiedEvent.phase !== "CONSOLE") {
+              console.error(
+                "[Limelight] beforeSend must return same event type"
+              );
+              return original.apply(console, args);
+            }
+            consoleEvent = modifiedEvent;
+          }
+          self.sendMessage(consoleEvent);
+        } catch (error) {
+        } finally {
+          self.isInternalLog = false;
+        }
+        return original.apply(console, args);
+      };
+    });
+  }
+  /**
+   * Captures the current stack trace, filtering out internal frames.
+   * @private
+   * @returns {string | undefined} Formatted stack trace or undefined if unavailable
+   */
+  captureStackTrace() {
+    try {
+      const error = new Error();
+      const stack = error.stack;
+      if (!stack) return void 0;
+      const relevantLines = stack.split("\n").slice(3).filter(
+        (line) => !line.includes("ConsoleInterceptor") && !line.includes("limelight")
+      );
+      return relevantLines.length > 0 ? relevantLines.join("\n") : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Restores original console methods and removes all interception.
+   * @returns {void}
+   */
+  cleanup() {
+    if (!this.isSetup) {
+      console.warn("[Limelight] Console interceptor not set up");
+      return;
+    }
+    this.isSetup = false;
+    Object.entries(this.originalConsole).forEach(([method, fn]) => {
+      if (fn) {
+        console[method] = fn;
+      }
+    });
+    this.originalConsole = {};
+  }
+};
+
+// src/protocol/protocol.ts
+var createSessionId = () => {
+  return `${Date.now()}-${Math.random().toString(36).substring(7)}`;
+};
+var generateRequestId = () => {
+  return `req-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+};
+
+// src/limelight/interceptors/NetworkInterceptor.ts
+var NetworkInterceptor = class {
+  constructor(sendMessage, getSessionId) {
+    this.sendMessage = sendMessage;
+    this.getSessionId = getSessionId;
+    this.originalFetch = global.fetch;
+  }
+  originalFetch;
+  config = null;
+  isSetup = false;
+  /**
+   * Sets up fetch interception by wrapping the global fetch function.
+   * Intercepts all fetch requests to capture network events.
+   * Prevents double setup to avoid losing original fetch reference.
+   * @param {LimelightConfig} config - Configuration object for Limelight
+   * @returns {void}
+   */
+  setup(config) {
+    if (this.isSetup) {
+      console.warn("[Limelight] Network interceptor already set up");
+      return;
+    }
+    this.isSetup = true;
+    this.config = config;
+    const self = this;
+    global.fetch = async function(input, init = {}) {
+      const requestId = generateRequestId();
+      const startTime = Date.now();
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      const method = init.method || "GET";
+      const modifiedInit = { ...init };
+      const headers = {};
+      if (modifiedInit.headers instanceof Headers) {
+        modifiedInit.headers.forEach((value, key) => {
+          headers[key.toLowerCase()] = value;
+        });
+      } else if (modifiedInit.headers) {
+        Object.entries(modifiedInit.headers).forEach(([key, value]) => {
+          headers[key.toLowerCase()] = value;
+        });
+      }
+      headers["x-limelight-intercepted"] = "fetch";
+      modifiedInit.headers = new Headers(headers);
+      let requestBodyToSerialize = init.body;
+      if (input instanceof Request && !requestBodyToSerialize) {
+        try {
+          const clonedRequest = input.clone();
+          const contentType = clonedRequest.headers.get("content-type") || "";
+          if (contentType.includes("application/json") || contentType.includes("text/")) {
+            requestBodyToSerialize = await clonedRequest.text();
+          } else {
+            requestBodyToSerialize = await clonedRequest.blob();
+          }
+        } catch {
+          requestBodyToSerialize = void 0;
+          console.warn(
+            "[Limelight] Failed to read request body from Request object"
+          );
+        }
+      }
+      const requestBody = serializeBody(
+        requestBodyToSerialize,
+        self.config?.disableBodyCapture
+      );
+      let graphqlData = void 0;
+      if (self.config?.enableGraphQL && isGraphQLRequest(url, requestBody)) {
+        const rawBody = requestBody?.raw;
+        if (rawBody) {
+          graphqlData = parseGraphQL(rawBody) ?? void 0;
+        }
+      }
+      let requestEvent = {
+        id: requestId,
+        sessionId: self.getSessionId(),
+        timestamp: startTime,
+        phase: "REQUEST" /* REQUEST */,
+        networkType: "fetch" /* FETCH */,
+        url,
+        method,
+        headers: redactSensitiveHeaders(headers),
+        body: requestBody,
+        name: formatRequestName(url),
+        initiator: getInitiator(),
+        requestSize: requestBody?.size ?? 0,
+        graphql: graphqlData
+      };
+      if (self.config?.beforeSend) {
+        const modifiedEvent = self.config.beforeSend(requestEvent);
+        if (!modifiedEvent) {
+          return self.originalFetch(input, modifiedInit);
+        }
+        if (modifiedEvent.phase !== "REQUEST" /* REQUEST */) {
+          console.error("[Limelight] beforeSend must return same event type");
+          return self.originalFetch(input, modifiedInit);
+        }
+        requestEvent = modifiedEvent;
+      }
+      self.sendMessage(requestEvent);
+      try {
+        const response = await self.originalFetch(input, modifiedInit);
+        const clone = response.clone();
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        let responseText;
+        try {
+          responseText = await clone.text();
+        } catch (cloneError) {
+          responseText = void 0;
+        }
+        const responseBody = serializeBody(
+          responseText,
+          self.config?.disableBodyCapture
+        );
+        let responseEvent = {
+          id: requestId,
+          sessionId: self.getSessionId(),
+          timestamp: endTime,
+          phase: "RESPONSE" /* RESPONSE */,
+          networkType: "fetch" /* FETCH */,
+          status: response.status,
+          statusText: response.statusText,
+          headers: redactSensitiveHeaders(responseHeaders),
+          body: responseBody,
+          duration,
+          responseSize: responseBody?.size ?? 0,
+          redirected: response.redirected,
+          ok: response.ok
+        };
+        if (self.config?.beforeSend) {
+          const modifiedEvent = self.config.beforeSend(responseEvent);
+          if (!modifiedEvent) {
+            return response;
+          }
+          if (modifiedEvent.phase !== "RESPONSE" /* RESPONSE */) {
+            console.error("[Limelight] beforeSend must return same event type");
+            return response;
+          }
+          responseEvent = modifiedEvent;
+        }
+        self.sendMessage(responseEvent);
+        return response;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const errorStack = err instanceof Error ? err.stack : void 0;
+        let errorEvent = {
+          id: requestId,
+          sessionId: self.getSessionId(),
+          timestamp: Date.now(),
+          phase: "ERROR" /* ERROR */,
+          networkType: "fetch" /* FETCH */,
+          errorMessage,
+          stack: errorStack
+        };
+        if (self.config?.beforeSend) {
+          const modifiedEvent = self.config.beforeSend(errorEvent);
+          if (modifiedEvent && modifiedEvent.phase === "ERROR" /* ERROR */) {
+            errorEvent = modifiedEvent;
+          }
+        }
+        self.sendMessage(errorEvent);
+        throw err;
+      }
+    };
+  }
+  /**
+   * Restores the original fetch function and removes all interception.
+   * @returns {void}
+   */
+  cleanup() {
+    if (!this.isSetup) {
+      console.warn("[Limelight] Network interceptor not set up");
+      return;
+    }
+    this.isSetup = false;
+    global.fetch = this.originalFetch;
+  }
+};
+
+// src/limelight/interceptors/XHRInterceptor.ts
+var XHRInterceptor = class {
+  constructor(sendMessage, getSessionId) {
+    this.sendMessage = sendMessage;
+    this.getSessionId = getSessionId;
+    this.originalXHROpen = XMLHttpRequest.prototype.open;
+    this.originalXHRSend = XMLHttpRequest.prototype.send;
+    this.originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+  }
+  originalXHROpen;
+  originalXHRSend;
+  originalXHRSetRequestHeader;
+  isSetup = false;
+  config = null;
+  /**
+   * Sets up XHR interception by wrapping XMLHttpRequest methods.
+   * Intercepts open, setRequestHeader, and send to capture network events.
+   * Prevents double setup to avoid losing original method references.
+   * @param {LimelightConfig} config - Configuration object for Limelight
+   * @returns {void}
+   */
+  setup(config) {
+    if (this.isSetup) {
+      console.warn("[Limelight] XHR interceptor already set up");
+      return;
+    }
+    this.isSetup = true;
+    this.config = config;
+    const self = this;
+    XMLHttpRequest.prototype.open = function(method, url) {
+      this._limelightData = {
+        id: generateRequestId(),
+        method,
+        url,
+        headers: {},
+        startTime: Date.now(),
+        listeners: /* @__PURE__ */ new Map()
+      };
+      return self.originalXHROpen.apply(
+        this,
+        arguments
+      );
+    };
+    XMLHttpRequest.prototype.setRequestHeader = function(header, value) {
+      if (this._limelightData) {
+        this._limelightData.headers[header] = value;
+        if (header.toLowerCase() === "x-limelight-intercepted" && value === "fetch") {
+          this._limelightData.skipIntercept = true;
+        }
+      }
+      return self.originalXHRSetRequestHeader.apply(this, arguments);
+    };
+    XMLHttpRequest.prototype.send = function(body) {
+      const data = this._limelightData;
+      if (data?.skipIntercept) {
+        return self.originalXHRSend.apply(this, arguments);
+      }
+      if (data) {
+        const requestBody = serializeBody(
+          body,
+          self.config?.disableBodyCapture
+        );
+        let requestEvent = {
+          id: data.id,
+          sessionId: self.getSessionId(),
+          timestamp: data.startTime,
+          phase: "REQUEST" /* REQUEST */,
+          networkType: "xhr" /* XHR */,
+          url: data.url,
+          method: data.method,
+          headers: redactSensitiveHeaders(data.headers),
+          body: requestBody,
+          name: formatRequestName(data.url),
+          initiator: getInitiator(),
+          requestSize: requestBody?.size ?? 0
+        };
+        if (self.config?.beforeSend) {
+          const modifiedEvent = self.config.beforeSend(requestEvent);
+          if (!modifiedEvent) {
+            return self.originalXHRSend.apply(this, arguments);
+          }
+          if (modifiedEvent.phase !== "REQUEST" /* REQUEST */) {
+            console.error("[Limelight] beforeSend must return same event type");
+            return self.originalXHRSend.apply(this, arguments);
+          }
+          requestEvent = modifiedEvent;
+        }
+        self.sendMessage(requestEvent);
+        let responseSent = false;
+        const cleanup = () => {
+          if (data.listeners) {
+            data.listeners.forEach((listener, event) => {
+              this.removeEventListener(event, listener);
+            });
+            data.listeners.clear();
+          }
+          delete this._limelightData;
+        };
+        const sendResponse = () => {
+          if (responseSent) return;
+          responseSent = true;
+          const endTime = Date.now();
+          const duration = endTime - data.startTime;
+          const responseHeaders = self.parseResponseHeaders(
+            this.getAllResponseHeaders()
+          );
+          const responseBody = serializeBody(
+            this.responseText || this.response,
+            self.config?.disableBodyCapture
+          );
+          let responseEvent = {
+            id: data.id,
+            sessionId: self.getSessionId(),
+            timestamp: endTime,
+            phase: "RESPONSE" /* RESPONSE */,
+            networkType: "xhr" /* XHR */,
+            status: this.status,
+            statusText: this.statusText,
+            headers: redactSensitiveHeaders(responseHeaders),
+            body: responseBody,
+            duration,
+            responseSize: responseBody?.size ?? 0,
+            redirected: false,
+            ok: this.status >= 200 && this.status < 300
+          };
+          if (self.config?.beforeSend) {
+            const modifiedEvent = self.config.beforeSend(responseEvent);
+            if (!modifiedEvent) {
+              return;
+            }
+            if (modifiedEvent.phase !== "RESPONSE" /* RESPONSE */) {
+              console.error(
+                "[Limelight] beforeSend must return same event type"
+              );
+              return;
+            }
+            responseEvent = modifiedEvent;
+          }
+          self.sendMessage(responseEvent);
+          cleanup.call(this);
+        };
+        const sendError = (errorMessage) => {
+          if (responseSent) return;
+          responseSent = true;
+          let errorEvent = {
+            id: data.id,
+            sessionId: self.getSessionId(),
+            timestamp: Date.now(),
+            phase: "ERROR" /* ERROR */,
+            networkType: "xhr" /* XHR */,
+            errorMessage
+          };
+          if (self.config?.beforeSend) {
+            const modifiedEvent = self.config.beforeSend(errorEvent);
+            if (modifiedEvent && modifiedEvent.phase === "ERROR" /* ERROR */) {
+              errorEvent = modifiedEvent;
+            }
+          }
+          self.sendMessage(errorEvent);
+          cleanup.call(this);
+        };
+        const readyStateChangeHandler = function() {
+          if ((this.readyState === 3 || this.readyState === 4) && this.status !== 0) {
+            sendResponse.call(this);
+          }
+        };
+        const loadHandler = function() {
+          sendResponse.call(this);
+        };
+        const errorHandler = function() {
+          sendError("Network request failed");
+          cleanup.call(this);
+        };
+        const abortHandler = function() {
+          sendError("Request aborted");
+          cleanup.call(this);
+        };
+        const timeoutHandler = function() {
+          sendError("Request timeout");
+          cleanup.call(this);
+        };
+        const loadEndHandler = function() {
+          cleanup.call(this);
+        };
+        this.addEventListener("readystatechange", readyStateChangeHandler);
+        this.addEventListener("load", loadHandler);
+        this.addEventListener("error", errorHandler);
+        this.addEventListener("abort", abortHandler);
+        this.addEventListener("timeout", timeoutHandler);
+        this.addEventListener("loadend", loadEndHandler);
+        data.listeners.set("readystatechange", readyStateChangeHandler);
+        data.listeners.set("load", loadHandler);
+        data.listeners.set("error", errorHandler);
+        data.listeners.set("abort", abortHandler);
+        data.listeners.set("timeout", timeoutHandler);
+        data.listeners.set("loadend", loadEndHandler);
+      }
+      return self.originalXHRSend.apply(this, arguments);
+    };
+  }
+  /**
+   * Parses raw HTTP header string into a key-value object.
+   * @private
+   * @param {string} headerString - Raw header string from getAllResponseHeaders()
+   * @returns {Record<string, string>} Parsed headers object
+   */
+  parseResponseHeaders(headerString) {
+    const headers = {};
+    headerString.split("\r\n").forEach((line) => {
+      const colonIndex = line.indexOf(": ");
+      if (colonIndex > 0) {
+        const key = line.substring(0, colonIndex);
+        const value = line.substring(colonIndex + 2);
+        headers[key] = value;
+      }
+    });
+    return headers;
+  }
+  /**
+   * Restores original XMLHttpRequest methods and removes all interception.
+   * @returns {void}
+   */
+  cleanup() {
+    if (!this.isSetup) {
+      console.warn("[Limelight] XHR interceptor not set up");
+      return;
+    }
+    this.isSetup = false;
+    XMLHttpRequest.prototype.open = this.originalXHROpen;
+    XMLHttpRequest.prototype.send = this.originalXHRSend;
+    XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
+  }
+};
+
+// src/limelight/LimelightClient.ts
+var LimelightClient = class {
+  ws = null;
+  config = null;
+  sessionId = "";
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  reconnectDelay = 1e3;
+  reconnectTimer = null;
+  messageQueue = [];
+  maxQueueSize = 100;
+  networkInterceptor;
+  xhrInterceptor;
+  consoleInterceptor;
+  constructor() {
+    this.networkInterceptor = new NetworkInterceptor(
+      this.sendMessage.bind(this),
+      () => this.sessionId
+    );
+    this.xhrInterceptor = new XHRInterceptor(
+      this.sendMessage.bind(this),
+      () => this.sessionId
+    );
+    this.consoleInterceptor = new ConsoleInterceptor(
+      this.sendMessage.bind(this),
+      () => this.sessionId
+    );
+  }
+  /**
+   * Configures the Limelight client with the provided settings.
+   * Sets up network, XHR, and console interceptors based on the configuration.
+   * @internal
+   * @private
+   * @param {LimelightConfig} config - Configuration object for Limelight
+   * @returns {void}
+   */
+  configure(config) {
+    const isEnabled = config.enabled ?? isDevelopment();
+    this.config = {
+      appName: "Limelight App",
+      serverUrl: `ws://localhost:${DEFAULT_PORT}${WS_PATH}`,
+      enabled: isEnabled,
+      enableNetworkInspector: true,
+      enableConsole: true,
+      enableGraphQL: true,
+      ...config
+    };
+    if (!this.config.enabled) {
+      return;
+    }
+    this.sessionId = createSessionId();
+    try {
+      if (this.config.enableNetworkInspector) {
+        this.networkInterceptor.setup(this.config);
+        this.xhrInterceptor.setup(this.config);
+      }
+      if (this.config.enableConsole) {
+        this.consoleInterceptor.setup(this.config);
+      }
+    } catch (error) {
+      console.error("[Limelight] Failed to setup interceptors:", error);
+    }
+  }
+  /**
+   * Establishes a WebSocket connection to the Limelight server.
+   * If a config object is provided, it will configure the client before connecting.
+   *
+   * If no config is provided and the client hasn't been configured, it will use default settings.
+   *
+   * Prevents multiple simultaneous connections and handles reconnection logic.
+   *
+   * @param {LimelightConfig} [config] - Optional configuration object.
+   * @returns {void}
+   */
+  connect(config) {
+    if (config) {
+      this.configure(config);
+    } else if (!this.config) {
+      this.configure({});
+    }
+    if (!this.config?.enabled) {
+      return;
+    }
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      console.warn("[Limelight] Already connected. Call disconnect() first.");
+      return;
+    }
+    if (this.ws) {
+      const oldWs = this.ws;
+      oldWs.onclose = null;
+      oldWs.onerror = null;
+      oldWs.onopen = null;
+      if (oldWs.readyState === 1) {
+        oldWs.close();
+      }
+      this.ws = null;
+    }
+    const { serverUrl, appName, platform } = this.config;
+    if (!serverUrl) {
+      console.error("[Limelight] serverUrl missing in configuration.");
+      return;
+    }
+    try {
+      this.ws = new WebSocket(serverUrl);
+      const message = {
+        phase: "CONNECT",
+        sessionId: this.sessionId,
+        timestamp: Date.now(),
+        data: {
+          appName,
+          platform: platform || "react-native"
+        }
+      };
+      this.ws.onopen = () => {
+        this.reconnectAttempts = 0;
+        this.flushMessageQueue();
+        this.sendMessage(message);
+      };
+      this.ws.onerror = (error) => {
+        console.error("[Limelight] WebSocket error:", error);
+      };
+      this.ws.onclose = () => {
+        this.attemptReconnect();
+      };
+    } catch (error) {
+      console.error("[Limelight] Failed to connect:", error);
+      this.attemptReconnect();
+    }
+  }
+  /**
+   * Attempts to reconnect to the Limelight server using exponential backoff.
+   * Will retry up to maxReconnectAttempts times with increasing delays.
+   * Maximum delay is capped at 30 seconds.
+   * @private
+   * @returns {void}
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      return;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
+      3e4
+    );
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Sends all queued messages to the server.
+   * Only executes if the WebSocket connection is open.
+   * @private
+   * @returns {void}
+   */
+  flushMessageQueue() {
+    if (this.ws?.readyState !== WebSocket.OPEN) return;
+    while (this.messageQueue.length > 0) {
+      const message = this.messageQueue.shift();
+      try {
+        this.ws.send(safeStringify(message));
+      } catch (error) {
+        console.error("[Limelight] Failed to send queued message:", error);
+      }
+    }
+  }
+  /**
+   * Sends a message to the Limelight server or queues it if not connected.
+   * Messages are automatically queued when the connection is not open.
+   * If the queue is full, the oldest message will be dropped.
+   * @private
+   * @param {LimelightMessage} message - The message to send
+   * @returns {void}
+   */
+  sendMessage(message) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.flushMessageQueue();
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        try {
+          this.ws.send(safeStringify(message));
+        } catch (error) {
+          console.error("[Limelight] Failed to send message:", error);
+          this.messageQueue.push(message);
+        }
+      } else {
+        this.messageQueue.push(message);
+      }
+    } else {
+      if (this.messageQueue.length >= this.maxQueueSize) {
+        console.warn("[Limelight] Message queue full, dropping oldest message");
+        this.messageQueue.shift();
+      }
+      this.messageQueue.push(message);
+    }
+  }
+  /**
+   * Disconnects from the Limelight server and cleans up resources.
+   * Closes the WebSocket connection, removes all interceptors, and resets connection state.
+   * Preserves configuration and session ID for potential reconnection.
+   * @returns {void}
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onerror = null;
+      this.ws.onclose = null;
+      try {
+        if (this.ws.readyState === 0 || this.ws.readyState === 1) {
+          if ("terminate" in this.ws && typeof this.ws.terminate === "function") {
+            if (this.ws._socket) {
+              this.ws.terminate();
+            } else {
+              this.ws.readyState = 3;
+            }
+          } else {
+            this.ws.close();
+          }
+        }
+      } catch (e) {
+      }
+      this.ws = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.networkInterceptor.cleanup();
+    this.xhrInterceptor.cleanup();
+    this.consoleInterceptor.cleanup();
+    this.reconnectAttempts = 0;
+    this.messageQueue = [];
+  }
+  /**
+   * Performs a complete reset of the Limelight client.
+   * Disconnects from the server and clears all configuration and session data.
+   * After calling reset(), connect() must be called again.
+   * @returns {void}
+   */
+  reset() {
+    this.disconnect();
+    this.config = null;
+    this.sessionId = "";
+  }
+};
+var Limelight = new LimelightClient();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BodyFormat,
+  ConsoleLevel,
+  ConsoleSource,
+  ConsoleType,
+  EventType,
+  GraphqlOprtation,
+  HttpMethod,
+  HttpStatusClass,
+  Limelight,
+  NetworkPhase,
+  NetworkType
+});
+//# sourceMappingURL=index.js.map