@getlimelight/sdk 0.5.5 → 0.7.4

package/dist/index.js

@@ -66,6 +66,7 @@ var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
   NetworkType2["FETCH"] = "fetch";
   NetworkType2["XHR"] = "xhr";
   NetworkType2["GRAPHQL"] = "graphql";
+  NetworkType2["INCOMING"] = "incoming";
   return NetworkType2;
 })(NetworkType || {});
 var NetworkPhase = /* @__PURE__ */ ((NetworkPhase2) => {
@@ -86,17 +87,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__ */ ((HttpMethod6) => {
+  HttpMethod6["GET"] = "GET";
+  HttpMethod6["POST"] = "POST";
+  HttpMethod6["PUT"] = "PUT";
+  HttpMethod6["PATCH"] = "PATCH";
+  HttpMethod6["DELETE"] = "DELETE";
+  HttpMethod6["HEAD"] = "HEAD";
+  HttpMethod6["OPTIONS"] = "OPTIONS";
+  HttpMethod6["TRACE"] = "TRACE";
+  HttpMethod6["CONNECT"] = "CONNECT";
+  return HttpMethod6;
 })(HttpMethod || {});
 var HttpStatusClass = /* @__PURE__ */ ((HttpStatusClass2) => {
   HttpStatusClass2[HttpStatusClass2["INFORMATIONAL"] = 100] = "INFORMATIONAL";
@@ -284,8 +285,9 @@ var SENSITIVE_HEADERS = [
 ];
 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.5.5" : "test-version";
+var SDK_VERSION = true ? "0.7.4" : "test-version";
 var RENDER_THRESHOLDS = {
   HOT_VELOCITY: 5,
   HIGH_RENDER_COUNT: 50,
@@ -539,6 +541,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 = () => {
@@ -704,13 +709,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;
@@ -730,9 +753,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();
@@ -750,6 +782,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) {
@@ -783,6 +821,7 @@ var NetworkInterceptor = class {
       }
       let requestEvent = {
         id: requestId,
+        traceId,
         sessionId: self2.getSessionId(),
         timestamp: startTime,
         phase: "REQUEST" /* REQUEST */,
@@ -799,17 +838,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;
@@ -829,6 +868,7 @@ var NetworkInterceptor = class {
         );
         let responseEvent = {
           id: requestId,
+          traceId,
           sessionId: self2.getSessionId(),
           timestamp: endTime,
           phase: "RESPONSE" /* RESPONSE */,
@@ -861,6 +901,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 */,
@@ -891,7 +932,9 @@ var NetworkInterceptor = class {
       return;
     }
     this.isSetup = false;
-    this.globalObject.fetch = this.originalFetch;
+    if (this.originalFetch) {
+      this.globalObject.fetch = this.originalFetch;
+    }
   }
 };
 
@@ -900,9 +943,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;
@@ -917,6 +962,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");
@@ -955,12 +1003,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 */,
@@ -1020,6 +1080,7 @@ var XHRInterceptor = class {
           );
           let responseEvent = {
             id: data.id,
+            traceId: data.traceId,
             sessionId: self2.getSessionId(),
             timestamp: endTime,
             phase: "RESPONSE" /* RESPONSE */,
@@ -1054,6 +1115,7 @@ var XHRInterceptor = class {
           responseSent = true;
           let errorEvent = {
             id: data.id,
+            traceId: data.traceId,
             sessionId: self2.getSessionId(),
             timestamp: Date.now(),
             phase,
@@ -1132,15 +1194,14 @@ var XHRInterceptor = class {
    */
   cleanup() {
     if (!this.isSetup) {
-      if (this.config?.enableInternalLogging) {
-        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;
+    if (typeof XMLHttpRequest !== "undefined") {
+      XMLHttpRequest.prototype.open = this.originalXHROpen;
+      XMLHttpRequest.prototype.send = this.originalXHRSend;
+      XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
+    }
   }
 };
 
@@ -1793,6 +1854,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;
@@ -2276,6 +2414,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;
@@ -2292,6 +2577,7 @@ var LimelightClient = class {
   consoleInterceptor;
   renderInterceptor;
   stateInterceptor;
+  errorInterceptor;
   requestBridge;
   commandHandler = null;
   constructor() {
@@ -2315,6 +2601,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
@@ -2335,7 +2625,7 @@ var LimelightClient = class {
    */
   configure(config) {
     const isEnabled = config?.enabled ?? isDevelopment();
-    const configServerUrl = config?.serverUrl ? config.serverUrl : config?.projectKey ? `${LIMELIGHT_WEB_WSS_URL}${WS_PATH}` : `${LIMELIGHT_DESKTOP_WSS_URL}${WS_PATH}`;
+    const configServerUrl = config?.serverUrl ? config.serverUrl : config?.target === "mcp" ? LIMELIGHT_MCP_WS_URL : config?.projectKey ? `${LIMELIGHT_WEB_WSS_URL}${WS_PATH}` : `${LIMELIGHT_DESKTOP_WSS_URL}${WS_PATH}`;
     this.config = {
       ...config,
       appName: config?.appName ?? "Limelight App",
@@ -2356,12 +2646,17 @@ 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 (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) {
@@ -2389,7 +2684,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.");
       }
@@ -2412,15 +2707,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
         }
@@ -2487,10 +2791,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) {
@@ -2508,9 +2815,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) {
@@ -2568,6 +2875,7 @@ var LimelightClient = class {
     this.networkInterceptor.cleanup();
     this.xhrInterceptor.cleanup();
     this.consoleInterceptor.cleanup();
+    this.errorInterceptor.cleanup();
     this.renderInterceptor.cleanup();
     this.stateInterceptor.cleanup();
     this.requestBridge.cleanup();
@@ -2614,6 +2922,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();
 // Annotate the CommonJS export names for ESM import in node: