@getlimelight/sdk 0.6.1 → 0.7.8

package/dist/index.mjs

@@ -1,3 +1,8 @@
+// Bridge Node CJS require to globalThis so runtime dynamic requires work
+// in environments like ts-node where require is module-scoped only.
+// In ESM or browser contexts typeof require is 'undefined', so this is a no-op.
+if (typeof require === "function" && typeof globalThis !== "undefined" && typeof globalThis.require === "undefined" && typeof process !== "undefined" && process.versions && process.versions.node) { Object.defineProperty(globalThis, "require", { value: require, configurable: true, writable: true, enumerable: false }); }
+
 // src/types/console.ts
 var ConsoleLevel = /* @__PURE__ */ ((ConsoleLevel2) => {
   ConsoleLevel2["LOG"] = "log";
@@ -29,6 +34,8 @@ var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
   NetworkType2["FETCH"] = "fetch";
   NetworkType2["XHR"] = "xhr";
   NetworkType2["GRAPHQL"] = "graphql";
+  NetworkType2["INCOMING"] = "incoming";
+  NetworkType2["HTTP"] = "http";
   return NetworkType2;
 })(NetworkType || {});
 var NetworkPhase = /* @__PURE__ */ ((NetworkPhase2) => {
@@ -49,17 +56,17 @@ var BodyFormat = /* @__PURE__ */ ((BodyFormat2) => {
   BodyFormat2["UNSERIALIZABLE"] = "UNSERIALIZABLE";
   return BodyFormat2;
 })(BodyFormat || {});
-var HttpMethod = /* @__PURE__ */ ((HttpMethod5) => {
-  HttpMethod5["GET"] = "GET";
-  HttpMethod5["POST"] = "POST";
-  HttpMethod5["PUT"] = "PUT";
-  HttpMethod5["PATCH"] = "PATCH";
-  HttpMethod5["DELETE"] = "DELETE";
-  HttpMethod5["HEAD"] = "HEAD";
-  HttpMethod5["OPTIONS"] = "OPTIONS";
-  HttpMethod5["TRACE"] = "TRACE";
-  HttpMethod5["CONNECT"] = "CONNECT";
-  return HttpMethod5;
+var HttpMethod = /* @__PURE__ */ ((HttpMethod7) => {
+  HttpMethod7["GET"] = "GET";
+  HttpMethod7["POST"] = "POST";
+  HttpMethod7["PUT"] = "PUT";
+  HttpMethod7["PATCH"] = "PATCH";
+  HttpMethod7["DELETE"] = "DELETE";
+  HttpMethod7["HEAD"] = "HEAD";
+  HttpMethod7["OPTIONS"] = "OPTIONS";
+  HttpMethod7["TRACE"] = "TRACE";
+  HttpMethod7["CONNECT"] = "CONNECT";
+  return HttpMethod7;
 })(HttpMethod || {});
 var HttpStatusClass = /* @__PURE__ */ ((HttpStatusClass2) => {
   HttpStatusClass2[HttpStatusClass2["INFORMATIONAL"] = 100] = "INFORMATIONAL";
@@ -249,7 +256,7 @@ var LIMELIGHT_WEB_WSS_URL = "wss://api.getlimelight.io";
 var LIMELIGHT_DESKTOP_WSS_URL = "ws://localhost:8484";
 var LIMELIGHT_MCP_WS_URL = "ws://localhost:9229";
 var WS_PATH = "/limelight";
-var SDK_VERSION = true ? "0.6.1" : "test-version";
+var SDK_VERSION = true ? "0.7.8" : "test-version";
 var RENDER_THRESHOLDS = {
   HOT_VELOCITY: 5,
   HIGH_RENDER_COUNT: 50,
@@ -263,6 +270,16 @@ var RENDER_THRESHOLDS = {
   TOP_PROPS_TO_REPORT: 5
   // Only report top N changed props
 };
+var BINARY_CONTENT_TYPES = [
+  "image/",
+  "audio/",
+  "video/",
+  "application/octet-stream",
+  "application/pdf",
+  "application/zip",
+  "application/gzip"
+];
+var MAX_BODY_SIZE = 1024 * 1024;
 
 // src/helpers/safety/redactSensitiveHeaders.ts
 var redactSensitiveHeaders = (headers) => {
@@ -503,6 +520,9 @@ var formatRequestName = (url) => {
   }
 };
 
+// src/helpers/utils/environment.ts
+var hasDOM = () => typeof window !== "undefined" && typeof document !== "undefined";
+
 // src/helpers/render/generateRenderId.ts
 var counter = 0;
 var generateRenderId = () => {
@@ -539,6 +559,21 @@ var getCurrentTransactionId = () => {
   return globalGetTransactionId?.() ?? null;
 };
 
+// src/helpers/http/resolveUrl.ts
+var resolveUrl = (protocol, options) => {
+  const host = options.hostname || options.host || "localhost";
+  const port = options.port ? `:${options.port}` : "";
+  const path = options.path || "/";
+  return `${protocol}//${host}${port}${path}`;
+};
+
+// src/helpers/http/isBinaryContentType.ts
+var isBinaryContentType = (contentType) => {
+  return BINARY_CONTENT_TYPES.some(
+    (type) => contentType.toLowerCase().includes(type)
+  );
+};
+
 // src/limelight/interceptors/ConsoleInterceptor.ts
 var ConsoleInterceptor = class {
   constructor(sendMessage, getSessionId) {
@@ -668,13 +703,31 @@ var generateRequestId = () => {
   return `req-${Date.now()}-${Math.random().toString(36).substring(7)}`;
 };
 
+// src/limelight/context/traceContext.ts
+var _resolved = false;
+var _traceContext;
+var getTraceContext = () => {
+  if (!_resolved) {
+    _resolved = true;
+    try {
+      const _require = globalThis["require"];
+      const { AsyncLocalStorage } = _require("node:async_hooks");
+      _traceContext = new AsyncLocalStorage();
+    } catch {
+    }
+  }
+  return _traceContext;
+};
+
 // src/limelight/interceptors/NetworkInterceptor.ts
 var NetworkInterceptor = class {
   constructor(sendMessage, getSessionId) {
     this.sendMessage = sendMessage;
     this.getSessionId = getSessionId;
     this.globalObject = detectGlobalObject();
-    this.originalFetch = this.globalObject.fetch.bind(this.globalObject);
+    if (typeof this.globalObject.fetch === "function") {
+      this.originalFetch = this.globalObject.fetch.bind(this.globalObject);
+    }
   }
   originalFetch;
   config = null;
@@ -694,9 +747,18 @@ var NetworkInterceptor = class {
       }
       return;
     }
+    if (!this.originalFetch) {
+      if (config?.enableInternalLogging) {
+        console.warn(
+          "[Limelight] fetch is not available in this environment, skipping network interception"
+        );
+      }
+      return;
+    }
     this.isSetup = true;
     this.config = config;
     const self2 = this;
+    const originalFetch = this.originalFetch;
     this.globalObject.fetch = async function(input, init = {}) {
       const requestId = generateRequestId();
       const startTime = Date.now();
@@ -714,6 +776,12 @@ var NetworkInterceptor = class {
         });
       }
       headers["x-limelight-intercepted"] = "fetch";
+      const traceHeaderName = self2.config?.traceHeaderName ?? "x-limelight-trace-id";
+      if (!headers[traceHeaderName]) {
+        const existingTraceId = getTraceContext()?.getStore()?.traceId;
+        headers[traceHeaderName] = existingTraceId || generateRequestId();
+      }
+      const traceId = headers[traceHeaderName];
       modifiedInit.headers = new Headers(headers);
       let requestBodyToSerialize = init.body;
       if (input instanceof Request && !requestBodyToSerialize) {
@@ -747,6 +815,7 @@ var NetworkInterceptor = class {
       }
       let requestEvent = {
         id: requestId,
+        traceId,
         sessionId: self2.getSessionId(),
         timestamp: startTime,
         phase: "REQUEST" /* REQUEST */,
@@ -763,17 +832,17 @@ var NetworkInterceptor = class {
       if (self2.config?.beforeSend) {
         const modifiedEvent = self2.config.beforeSend(requestEvent);
         if (!modifiedEvent) {
-          return self2.originalFetch(input, modifiedInit);
+          return originalFetch(input, modifiedInit);
         }
         if (modifiedEvent.phase !== "REQUEST" /* REQUEST */) {
           console.error("[Limelight] beforeSend must return same event type");
-          return self2.originalFetch(input, modifiedInit);
+          return originalFetch(input, modifiedInit);
         }
         requestEvent = modifiedEvent;
       }
       self2.sendMessage(requestEvent);
       try {
-        const response = await self2.originalFetch(input, modifiedInit);
+        const response = await originalFetch(input, modifiedInit);
         const clone = response.clone();
         const endTime = Date.now();
         const duration = endTime - startTime;
@@ -793,6 +862,7 @@ var NetworkInterceptor = class {
         );
         let responseEvent = {
           id: requestId,
+          traceId,
           sessionId: self2.getSessionId(),
           timestamp: endTime,
           phase: "RESPONSE" /* RESPONSE */,
@@ -825,6 +895,7 @@ var NetworkInterceptor = class {
         const errorStack = err instanceof Error ? err.stack : void 0;
         let errorEvent = {
           id: requestId,
+          traceId,
           sessionId: self2.getSessionId(),
           timestamp: Date.now(),
           phase: isAbort ? "ABORT" /* ABORT */ : "ERROR" /* ERROR */,
@@ -855,7 +926,9 @@ var NetworkInterceptor = class {
       return;
     }
     this.isSetup = false;
-    this.globalObject.fetch = this.originalFetch;
+    if (this.originalFetch) {
+      this.globalObject.fetch = this.originalFetch;
+    }
   }
 };
 
@@ -864,9 +937,11 @@ 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;
+    if (typeof XMLHttpRequest !== "undefined") {
+      this.originalXHROpen = XMLHttpRequest.prototype.open;
+      this.originalXHRSend = XMLHttpRequest.prototype.send;
+      this.originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+    }
   }
   originalXHROpen;
   originalXHRSend;
@@ -881,6 +956,9 @@ var XHRInterceptor = class {
    * @returns {void}
    */
   setup(config) {
+    if (typeof XMLHttpRequest === "undefined") {
+      return;
+    }
     if (this.isSetup) {
       if (this.config?.enableInternalLogging) {
         console.warn("[Limelight] XHR interceptor already set up");
@@ -919,12 +997,24 @@ var XHRInterceptor = class {
         return self2.originalXHRSend.apply(this, arguments);
       }
       if (data) {
+        const traceHeaderName = self2.config?.traceHeaderName ?? "x-limelight-trace-id";
+        if (!data.headers[traceHeaderName]) {
+          data.traceId = generateRequestId();
+          self2.originalXHRSetRequestHeader.call(
+            this,
+            traceHeaderName,
+            data.traceId
+          );
+        } else {
+          data.traceId = data.headers[traceHeaderName];
+        }
         const requestBody = serializeBody(
           body,
           self2.config?.disableBodyCapture
         );
         let requestEvent = {
           id: data.id,
+          traceId: data.traceId,
           sessionId: self2.getSessionId(),
           timestamp: data.startTime,
           phase: "REQUEST" /* REQUEST */,
@@ -984,6 +1074,7 @@ var XHRInterceptor = class {
           );
           let responseEvent = {
             id: data.id,
+            traceId: data.traceId,
             sessionId: self2.getSessionId(),
             timestamp: endTime,
             phase: "RESPONSE" /* RESPONSE */,
@@ -1018,6 +1109,7 @@ var XHRInterceptor = class {
           responseSent = true;
           let errorEvent = {
             id: data.id,
+            traceId: data.traceId,
             sessionId: self2.getSessionId(),
             timestamp: Date.now(),
             phase,
@@ -1094,17 +1186,370 @@ var XHRInterceptor = class {
    * Restores original XMLHttpRequest methods and removes all interception.
    * @returns {void}
    */
+  cleanup() {
+    if (!this.isSetup) {
+      return;
+    }
+    this.isSetup = false;
+    if (typeof XMLHttpRequest !== "undefined") {
+      XMLHttpRequest.prototype.open = this.originalXHROpen;
+      XMLHttpRequest.prototype.send = this.originalXHRSend;
+      XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
+    }
+  }
+};
+
+// src/limelight/interceptors/HttpInterceptor.ts
+var HttpInterceptor = class {
+  constructor(sendMessage, getSessionId) {
+    this.sendMessage = sendMessage;
+    this.getSessionId = getSessionId;
+    try {
+      const _require = globalThis["require"];
+      this.httpModule = _require("http");
+      this.httpsModule = _require("https");
+      this.originalHttpRequest = this.httpModule.request;
+      this.originalHttpGet = this.httpModule.get;
+      this.originalHttpsRequest = this.httpsModule.request;
+      this.originalHttpsGet = this.httpsModule.get;
+    } catch {
+    }
+  }
+  originalHttpRequest = null;
+  originalHttpGet = null;
+  originalHttpsRequest = null;
+  originalHttpsGet = null;
+  httpModule = null;
+  httpsModule = null;
+  config = null;
+  isSetup = false;
+  setup(config) {
+    if (this.isSetup) {
+      if (this.config?.enableInternalLogging) {
+        console.warn("[Limelight] HTTP interceptor already set up");
+      }
+      return;
+    }
+    if (!this.httpModule || !this.httpsModule) {
+      if (config?.enableInternalLogging) {
+        console.warn(
+          "[Limelight] Node http module not available, skipping HTTP interception"
+        );
+      }
+      return;
+    }
+    this.isSetup = true;
+    this.config = config;
+    const self2 = this;
+    const httpMod = this.httpModule;
+    const httpsMod = this.httpsModule;
+    httpMod.request = (...args) => {
+      return self2.interceptRequest(
+        "http:",
+        self2.originalHttpRequest,
+        httpMod,
+        args
+      );
+    };
+    httpMod.get = (...args) => {
+      const req = self2.interceptRequest(
+        "http:",
+        self2.originalHttpRequest,
+        httpMod,
+        args
+      );
+      req.end();
+      return req;
+    };
+    httpsMod.request = (...args) => {
+      return self2.interceptRequest(
+        "https:",
+        self2.originalHttpsRequest,
+        httpsMod,
+        args
+      );
+    };
+    httpsMod.get = (...args) => {
+      const req = self2.interceptRequest(
+        "https:",
+        self2.originalHttpsRequest,
+        httpsMod,
+        args
+      );
+      req.end();
+      return req;
+    };
+  }
+  interceptRequest(protocol, originalMethod, module, args) {
+    let url;
+    let options;
+    let callback;
+    if (typeof args[0] === "string" || args[0] instanceof URL) {
+      url = args[0];
+      if (typeof args[1] === "function") {
+        options = {};
+        callback = args[1];
+      } else {
+        options = args[1] || {};
+        callback = args[2];
+      }
+    } else {
+      options = args[0] || {};
+      callback = args[1];
+    }
+    let resolvedUrl;
+    if (url) {
+      resolvedUrl = url.toString();
+    } else {
+      resolvedUrl = resolveUrl(protocol, options);
+    }
+    const limelightServerUrl = this.config?.serverUrl || "";
+    if (limelightServerUrl && resolvedUrl.includes(limelightServerUrl)) {
+      return originalMethod.apply(module, args);
+    }
+    const self2 = this;
+    const requestId = generateRequestId();
+    const startTime = Date.now();
+    const initiator = getInitiator();
+    const traceHeaderName = this.config?.traceHeaderName ?? "x-limelight-trace-id";
+    const existingTraceId = getTraceContext()?.getStore()?.traceId;
+    const traceId = existingTraceId || generateRequestId();
+    if (!options.headers) {
+      options.headers = {};
+    }
+    options.headers[traceHeaderName] = traceId;
+    const method = (options.method || "GET").toUpperCase();
+    let patchedArgs;
+    if (url) {
+      patchedArgs = callback ? [url, options, callback] : [url, options];
+    } else {
+      patchedArgs = callback ? [options, callback] : [options];
+    }
+    const req = originalMethod.apply(
+      module,
+      patchedArgs
+    );
+    const bodyChunks = [];
+    let totalBodySize = 0;
+    let requestEventSent = false;
+    const originalWrite = req.write.bind(req);
+    const originalEnd = req.end.bind(req);
+    req.write = (chunk, encodingOrCallback, callback2) => {
+      if (chunk && totalBodySize < MAX_BODY_SIZE) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bodyChunks.push(buf);
+        totalBodySize += buf.length;
+      }
+      return originalWrite(chunk, encodingOrCallback, callback2);
+    };
+    req.end = (chunk, encodingOrCallback, callback2) => {
+      if (chunk && typeof chunk !== "function" && totalBodySize < MAX_BODY_SIZE) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bodyChunks.push(buf);
+        totalBodySize += buf.length;
+      }
+      if (!requestEventSent) {
+        requestEventSent = true;
+        const fullBody = bodyChunks.length > 0 ? Buffer.concat(bodyChunks).toString("utf-8") : void 0;
+        const headers = {};
+        const rawHeaders = req.getHeaders();
+        for (const [key, value] of Object.entries(rawHeaders)) {
+          if (value !== void 0) {
+            headers[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+          }
+        }
+        const requestBody = serializeBody(
+          fullBody,
+          self2.config?.disableBodyCapture
+        );
+        let requestEvent = {
+          id: requestId,
+          traceId,
+          sessionId: self2.getSessionId(),
+          timestamp: startTime,
+          phase: "REQUEST" /* REQUEST */,
+          networkType: "http" /* HTTP */,
+          url: resolvedUrl,
+          method,
+          headers: redactSensitiveHeaders(headers),
+          body: requestBody,
+          name: formatRequestName(resolvedUrl),
+          initiator,
+          requestSize: requestBody?.size ?? 0
+        };
+        if (self2.config?.beforeSend) {
+          const modifiedEvent = self2.config.beforeSend(requestEvent);
+          if (!modifiedEvent) {
+            return originalEnd(
+              chunk,
+              encodingOrCallback,
+              callback2
+            );
+          }
+          if (modifiedEvent.phase !== "REQUEST" /* REQUEST */) {
+            console.error("[Limelight] beforeSend must return same event type");
+            return originalEnd(
+              chunk,
+              encodingOrCallback,
+              callback2
+            );
+          }
+          requestEvent = modifiedEvent;
+        }
+        self2.sendMessage(requestEvent);
+      }
+      return originalEnd(chunk, encodingOrCallback, callback2);
+    };
+    let responseSent = false;
+    req.on("response", (res) => {
+      const responseChunks = [];
+      let responseSize = 0;
+      res.on("data", (chunk) => {
+        if (responseSize < MAX_BODY_SIZE) {
+          responseChunks.push(chunk);
+          responseSize += chunk.length;
+        }
+      });
+      res.on("end", () => {
+        if (responseSent) return;
+        responseSent = true;
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        const responseHeaders = {};
+        if (res.headers) {
+          for (const [key, value] of Object.entries(res.headers)) {
+            if (value) {
+              responseHeaders[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+            }
+          }
+        }
+        const contentType = responseHeaders["content-type"] || "";
+        let responseBodyStr;
+        if (responseChunks.length > 0) {
+          if (isBinaryContentType(contentType)) {
+            responseBodyStr = `[Binary Data: ${contentType}]`;
+          } else {
+            const full = Buffer.concat(responseChunks);
+            responseBodyStr = full.length > MAX_BODY_SIZE ? full.toString("utf-8", 0, MAX_BODY_SIZE) + "...[truncated]" : full.toString("utf-8");
+          }
+        }
+        const responseBody = serializeBody(
+          responseBodyStr,
+          self2.config?.disableBodyCapture
+        );
+        const statusCode = res.statusCode ?? 0;
+        let responseEvent = {
+          id: requestId,
+          traceId,
+          sessionId: self2.getSessionId(),
+          timestamp: endTime,
+          phase: "RESPONSE" /* RESPONSE */,
+          networkType: "http" /* HTTP */,
+          status: statusCode,
+          statusText: res.statusMessage || "",
+          headers: redactSensitiveHeaders(responseHeaders),
+          body: responseBody,
+          duration,
+          responseSize: responseBody?.size ?? 0,
+          redirected: false,
+          ok: statusCode >= 200 && statusCode < 300
+        };
+        if (self2.config?.beforeSend) {
+          const modifiedEvent = self2.config.beforeSend(responseEvent);
+          if (!modifiedEvent) return;
+          if (modifiedEvent.phase !== "RESPONSE" /* RESPONSE */) {
+            console.error("[Limelight] beforeSend must return same event type");
+            return;
+          }
+          responseEvent = modifiedEvent;
+        }
+        self2.sendMessage(responseEvent);
+      });
+    });
+    req.on("error", (err) => {
+      if (responseSent) return;
+      responseSent = true;
+      let errorEvent = {
+        id: requestId,
+        traceId,
+        sessionId: self2.getSessionId(),
+        timestamp: Date.now(),
+        phase: "ERROR" /* ERROR */,
+        networkType: "http" /* HTTP */,
+        errorMessage: err.message || "Network request failed",
+        stack: err.stack
+      };
+      if (self2.config?.beforeSend) {
+        const modifiedEvent = self2.config.beforeSend(errorEvent);
+        if (modifiedEvent && (modifiedEvent.phase === "ERROR" /* ERROR */ || modifiedEvent.phase === "ABORT" /* ABORT */)) {
+          errorEvent = modifiedEvent;
+        }
+      }
+      self2.sendMessage(errorEvent);
+    });
+    req.on("timeout", () => {
+      if (responseSent) return;
+      responseSent = true;
+      let errorEvent = {
+        id: requestId,
+        traceId,
+        sessionId: self2.getSessionId(),
+        timestamp: Date.now(),
+        phase: "ERROR" /* ERROR */,
+        networkType: "http" /* HTTP */,
+        errorMessage: "Request timeout"
+      };
+      if (self2.config?.beforeSend) {
+        const modifiedEvent = self2.config.beforeSend(errorEvent);
+        if (modifiedEvent && (modifiedEvent.phase === "ERROR" /* ERROR */ || modifiedEvent.phase === "ABORT" /* ABORT */)) {
+          errorEvent = modifiedEvent;
+        }
+      }
+      self2.sendMessage(errorEvent);
+    });
+    req.on("close", () => {
+      if (responseSent) return;
+      if (!req.destroyed) return;
+      responseSent = true;
+      let errorEvent = {
+        id: requestId,
+        traceId,
+        sessionId: self2.getSessionId(),
+        timestamp: Date.now(),
+        phase: "ABORT" /* ABORT */,
+        networkType: "http" /* HTTP */,
+        errorMessage: "Request aborted"
+      };
+      if (self2.config?.beforeSend) {
+        const modifiedEvent = self2.config.beforeSend(errorEvent);
+        if (modifiedEvent && (modifiedEvent.phase === "ERROR" /* ERROR */ || modifiedEvent.phase === "ABORT" /* ABORT */)) {
+          errorEvent = modifiedEvent;
+        }
+      }
+      self2.sendMessage(errorEvent);
+    });
+    return req;
+  }
   cleanup() {
     if (!this.isSetup) {
       if (this.config?.enableInternalLogging) {
-        console.warn("[Limelight] XHR interceptor not set up");
+        console.warn("[Limelight] HTTP interceptor not set up");
       }
       return;
     }
     this.isSetup = false;
-    XMLHttpRequest.prototype.open = this.originalXHROpen;
-    XMLHttpRequest.prototype.send = this.originalXHRSend;
-    XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
+    if (this.httpModule && this.originalHttpRequest) {
+      this.httpModule.request = this.originalHttpRequest;
+    }
+    if (this.httpModule && this.originalHttpGet) {
+      this.httpModule.get = this.originalHttpGet;
+    }
+    if (this.httpsModule && this.originalHttpsRequest) {
+      this.httpsModule.request = this.originalHttpsRequest;
+    }
+    if (this.httpsModule && this.originalHttpsGet) {
+      this.httpsModule.get = this.originalHttpsGet;
+    }
   }
 };
 
@@ -1757,6 +2202,83 @@ var RenderInterceptor = class {
   }
 };
 
+// src/limelight/interceptors/ErrorInterceptor.ts
+var ErrorInterceptor = class {
+  constructor(sendMessage, getSessionId) {
+    this.sendMessage = sendMessage;
+    this.getSessionId = getSessionId;
+  }
+  isSetup = false;
+  config = null;
+  counter = 0;
+  uncaughtExceptionHandler = null;
+  unhandledRejectionHandler = null;
+  setup(config) {
+    if (this.isSetup) {
+      if (this.config?.enableInternalLogging) {
+        console.warn("[Limelight] Error interceptor already set up");
+      }
+      return;
+    }
+    if (typeof process === "undefined" || !process.on) {
+      return;
+    }
+    this.isSetup = true;
+    this.config = config;
+    this.uncaughtExceptionHandler = (error) => {
+      this.sendErrorEvent(error, "uncaughtException");
+      setTimeout(() => {
+        process.exit(1);
+      }, 200);
+    };
+    this.unhandledRejectionHandler = (reason) => {
+      const error = reason instanceof Error ? reason : new Error(String(reason));
+      this.sendErrorEvent(error, "unhandledRejection");
+    };
+    process.on("uncaughtException", this.uncaughtExceptionHandler);
+    process.on("unhandledRejection", this.unhandledRejectionHandler);
+  }
+  cleanup() {
+    if (!this.isSetup) return;
+    this.isSetup = false;
+    if (this.uncaughtExceptionHandler) {
+      process.removeListener(
+        "uncaughtException",
+        this.uncaughtExceptionHandler
+      );
+      this.uncaughtExceptionHandler = null;
+    }
+    if (this.unhandledRejectionHandler) {
+      process.removeListener(
+        "unhandledRejection",
+        this.unhandledRejectionHandler
+      );
+      this.unhandledRejectionHandler = null;
+    }
+    this.config = null;
+  }
+  sendErrorEvent(error, source) {
+    const sessionId = this.getSessionId();
+    const event = {
+      id: `${sessionId}-${Date.now()}-${this.counter++}`,
+      phase: "CONSOLE",
+      type: "CONSOLE" /* CONSOLE */,
+      level: "error" /* ERROR */,
+      timestamp: Date.now(),
+      sessionId,
+      source: "app" /* APP */,
+      consoleType: "exception" /* EXCEPTION */,
+      args: [safeStringify(`[${source}] ${error.message}`)],
+      stackTrace: error.stack
+    };
+    if (this.config?.beforeSend) {
+      const modified = this.config.beforeSend(event);
+      if (!modified) return;
+    }
+    this.sendMessage(event);
+  }
+};
+
 // src/limelight/interceptors/StateInterceptor.ts
 var StateInterceptor = class {
   sendMessage;
@@ -2240,6 +2762,153 @@ var CommandHandler = class {
   }
 };
 
+// src/limelight/middleware/httpMiddleware.ts
+var DEFAULT_MAX_BODY_SIZE = 64 * 1024;
+var captureRequest = (req, res, sendMessage, getSessionId, config, options) => {
+  const requestId = generateRequestId();
+  const startTime = Date.now();
+  const maxBodySize = options?.maxBodySize ?? DEFAULT_MAX_BODY_SIZE;
+  const traceHeaderName = config?.traceHeaderName ?? "x-limelight-trace-id";
+  const incomingTraceId = req.headers[traceHeaderName];
+  const traceId = incomingTraceId || generateRequestId();
+  req.limelightTraceId = traceId;
+  const url = req.url || "/";
+  const method = (req.method || "GET").toUpperCase();
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) {
+      headers[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  let requestBody = serializeBody(req.body, config?.disableBodyCapture);
+  if (requestBody?.raw && requestBody.raw.length > maxBodySize) {
+    requestBody = {
+      ...requestBody,
+      raw: requestBody.raw.slice(0, maxBodySize) + "...[truncated]",
+      size: requestBody.size
+    };
+  }
+  let requestEvent = {
+    id: requestId,
+    traceId,
+    sessionId: getSessionId(),
+    timestamp: startTime,
+    phase: "REQUEST" /* REQUEST */,
+    networkType: "incoming" /* INCOMING */,
+    url,
+    method,
+    headers: redactSensitiveHeaders(headers),
+    body: requestBody,
+    name: url.split("?")[0]?.split("/").filter(Boolean).pop() ?? "/",
+    initiator: "incoming",
+    requestSize: requestBody?.size ?? 0
+  };
+  if (config?.beforeSend) {
+    const modified = config.beforeSend(requestEvent);
+    if (!modified) return;
+    if (modified.phase !== "REQUEST" /* REQUEST */) {
+      console.error("[Limelight] beforeSend must return same event type");
+      return;
+    }
+    requestEvent = modified;
+  }
+  sendMessage(requestEvent);
+  const chunks = [];
+  let totalSize = 0;
+  const originalWrite = res.write;
+  const originalEnd = res.end;
+  res.write = (chunk, ...args) => {
+    if (chunk && typeof chunk !== "function" && totalSize < maxBodySize) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      chunks.push(buf);
+      totalSize += buf.length;
+    }
+    return originalWrite.apply(res, [chunk, ...args]);
+  };
+  res.end = (chunk, ...args) => {
+    if (chunk && typeof chunk !== "function" && totalSize < maxBodySize) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      chunks.push(buf);
+      totalSize += buf.length;
+    }
+    return originalEnd.apply(res, [chunk, ...args]);
+  };
+  res.on("finish", () => {
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+    const responseHeaders = {};
+    const rawHeaders = res.getHeaders();
+    for (const [key, value] of Object.entries(rawHeaders)) {
+      if (value) {
+        responseHeaders[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+      }
+    }
+    let responseBodyStr;
+    if (chunks.length > 0 && !config?.disableBodyCapture) {
+      const full = Buffer.concat(chunks);
+      const fullStr = full.toString("utf-8");
+      responseBodyStr = fullStr.length > maxBodySize ? fullStr.slice(0, maxBodySize) + "...[truncated]" : fullStr;
+    }
+    const responseBody = serializeBody(
+      responseBodyStr,
+      config?.disableBodyCapture
+    );
+    let responseEvent = {
+      id: requestId,
+      traceId,
+      sessionId: getSessionId(),
+      timestamp: endTime,
+      phase: "RESPONSE" /* RESPONSE */,
+      networkType: "incoming" /* INCOMING */,
+      status: res.statusCode,
+      statusText: res.statusMessage || "",
+      headers: redactSensitiveHeaders(responseHeaders),
+      body: responseBody,
+      duration,
+      responseSize: responseBody?.size ?? 0,
+      redirected: false,
+      ok: res.statusCode >= 200 && res.statusCode < 300
+    };
+    if (config?.beforeSend) {
+      const modified = config.beforeSend(responseEvent);
+      if (!modified) return;
+      if (modified.phase !== "RESPONSE" /* RESPONSE */) {
+        console.error("[Limelight] beforeSend must return same event type");
+        return;
+      }
+      responseEvent = modified;
+    }
+    sendMessage(responseEvent);
+  });
+};
+var createHttpMiddleware = (sendMessage, getSessionId, getConfig, options) => {
+  return (req, res, next) => {
+    captureRequest(req, res, sendMessage, getSessionId, getConfig(), options);
+    const traceId = req.limelightTraceId;
+    const ctx = getTraceContext();
+    if (ctx && traceId) {
+      ctx.run({ traceId }, next);
+    } else {
+      next();
+    }
+  };
+};
+
+// src/limelight/middleware/withLimelight.ts
+var createWithLimelight = (sendMessage, getSessionId, getConfig, options) => {
+  return (handler) => {
+    return (req, res) => {
+      captureRequest(req, res, sendMessage, getSessionId, getConfig(), options);
+      const traceId = req.limelightTraceId;
+      const ctx = getTraceContext();
+      if (ctx && traceId) {
+        return ctx.run({ traceId }, () => handler(req, res));
+      }
+      return handler(req, res);
+    };
+  };
+};
+
 // src/limelight/LimelightClient.ts
 var LimelightClient = class {
   ws = null;
@@ -2253,9 +2922,11 @@ var LimelightClient = class {
   maxQueueSize = 100;
   networkInterceptor;
   xhrInterceptor;
+  httpInterceptor;
   consoleInterceptor;
   renderInterceptor;
   stateInterceptor;
+  errorInterceptor;
   requestBridge;
   commandHandler = null;
   constructor() {
@@ -2267,6 +2938,10 @@ var LimelightClient = class {
       this.sendMessage.bind(this),
       () => this.sessionId
     );
+    this.httpInterceptor = new HttpInterceptor(
+      this.sendMessage.bind(this),
+      () => this.sessionId
+    );
     this.consoleInterceptor = new ConsoleInterceptor(
       this.sendMessage.bind(this),
       () => this.sessionId
@@ -2279,6 +2954,10 @@ var LimelightClient = class {
       this.sendMessage.bind(this),
       () => this.sessionId
     );
+    this.errorInterceptor = new ErrorInterceptor(
+      this.sendMessage.bind(this),
+      () => this.sessionId
+    );
     this.requestBridge = new RequestBridge(
       this.sendMessage.bind(this),
       () => this.sessionId
@@ -2320,12 +2999,20 @@ var LimelightClient = class {
     try {
       if (this.config.enableNetworkInspector) {
         this.networkInterceptor.setup(this.config);
-        this.xhrInterceptor.setup(this.config);
+        if (typeof XMLHttpRequest !== "undefined") {
+          this.xhrInterceptor.setup(this.config);
+        }
+        if (!hasDOM()) {
+          this.httpInterceptor.setup(this.config);
+        }
       }
       if (this.config.enableConsole) {
         this.consoleInterceptor.setup(this.config);
+        if (!hasDOM()) {
+          this.errorInterceptor.setup(this.config);
+        }
       }
-      if (this.config.enableRenderInspector) {
+      if (this.config.enableRenderInspector && hasDOM()) {
         this.renderInterceptor.setup(this.config);
       }
       if (this.config.stores && this.config.enableStateInspector) {
@@ -2353,7 +3040,7 @@ var LimelightClient = class {
     if (!this.config?.enabled) {
       return;
     }
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+    if (this.ws && this.ws.readyState === 1) {
       if (this.config?.enableInternalLogging) {
         console.warn("[Limelight] Already connected. Call disconnect() first.");
       }
@@ -2376,15 +3063,24 @@ var LimelightClient = class {
       }
       return;
     }
+    const WsConstructor = this.config.webSocketImpl ?? (typeof WebSocket !== "undefined" ? WebSocket : void 0);
+    if (!WsConstructor) {
+      if (this.config?.enableInternalLogging) {
+        console.error(
+          "[Limelight] WebSocket is not available. Pass webSocketImpl in config (e.g. ws package)."
+        );
+      }
+      return;
+    }
     try {
-      this.ws = new WebSocket(serverUrl);
+      this.ws = new WsConstructor(serverUrl);
       const message = {
         phase: "CONNECT",
         sessionId: this.sessionId,
         timestamp: Date.now(),
         data: {
           appName,
-          platform: platform || (typeof window !== "undefined" ? "web" : "react-native"),
+          platform: platform || (hasDOM() ? "web" : typeof process !== "undefined" ? "node" : "react-native"),
           projectKey: this.config.projectKey || "",
           sdkVersion: SDK_VERSION
         }
@@ -2451,10 +3147,13 @@ var LimelightClient = class {
    * @returns {void}
    */
   flushMessageQueue() {
-    if (this.ws?.readyState !== WebSocket.OPEN) return;
+    if (this.ws?.readyState !== 1) return;
     while (this.messageQueue.length > 0) {
       const message = this.messageQueue.shift();
       try {
+        if (message && "sessionId" in message && !message.sessionId) {
+          message.sessionId = this.sessionId;
+        }
         this.ws.send(safeStringify(message));
       } catch (error) {
         if (this.config?.enableInternalLogging) {
@@ -2472,9 +3171,9 @@ var LimelightClient = class {
    * @returns {void}
    */
   sendMessage(message) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
+    if (this.ws?.readyState === 1) {
       this.flushMessageQueue();
-      if (this.ws?.readyState === WebSocket.OPEN) {
+      if (this.ws?.readyState === 1) {
         try {
           this.ws.send(safeStringify(message));
         } catch (error) {
@@ -2531,7 +3230,9 @@ var LimelightClient = class {
     }
     this.networkInterceptor.cleanup();
     this.xhrInterceptor.cleanup();
+    this.httpInterceptor.cleanup();
     this.consoleInterceptor.cleanup();
+    this.errorInterceptor.cleanup();
     this.renderInterceptor.cleanup();
     this.stateInterceptor.cleanup();
     this.requestBridge.cleanup();
@@ -2578,6 +3279,46 @@ var LimelightClient = class {
   failRequest(requestId, error) {
     this.requestBridge.failRequest(requestId, error);
   }
+  /**
+   * Returns an Express/Connect-compatible middleware that captures incoming
+   * HTTP requests and responses.
+   *
+   * Place after body-parser middleware (express.json(), etc.) for request body capture.
+   *
+   * @example
+   * ```ts
+   * app.use(express.json());
+   * app.use(Limelight.middleware());
+   * ```
+   */
+  middleware(options) {
+    return createHttpMiddleware(
+      this.sendMessage.bind(this),
+      () => this.sessionId,
+      () => this.config,
+      options
+    );
+  }
+  /**
+   * Wraps a Next.js Pages API route handler with request/response capture.
+   * Works with Pages Router (`pages/api/`), not App Router (`app/api/`).
+   *
+   * @example
+   * ```ts
+   * // pages/api/users.ts
+   * export default Limelight.withLimelight((req, res) => {
+   *   res.json({ ok: true });
+   * });
+   * ```
+   */
+  withLimelight(handler) {
+    const wrapper = createWithLimelight(
+      this.sendMessage.bind(this),
+      () => this.sessionId,
+      () => this.config
+    );
+    return wrapper(handler);
+  }
 };
 var Limelight = new LimelightClient();
 export {