@tonyclaw/agent-inspector 3.0.18 → 3.0.20

package/.output/server/_libs/srvx.mjs

@@ -3,7 +3,7 @@ import { Readable, PassThrough } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import nodeHTTPS from "node:https";
 import nodeHTTP2 from "node:http2";
-function lazyInherit$1(target, source, sourceKey) {
+function lazyInherit$2(target, source, sourceKey) {
   for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
     if (key === "constructor") continue;
     const targetDesc = Object.getOwnPropertyDescriptor(target, key);
@@ -30,8 +30,9 @@ function lazyInherit$1(target, source, sourceKey) {
     if (modified) Object.defineProperty(target, key, desc);
   }
 }
-const _needsNormRE$1 = /(?:(?:^|\/)(?:\.|\.\.|%2e|%2e\.|\.%2e|%2e%2e)(?:\/|$))|[\\^\x80-\uffff]/i;
-const FastURL$1 = /* @__PURE__ */ (() => {
+const _needsNormRE$2 = /(?:(?:^|\/)(?:\.|\.\.|%2e|%2e\.|\.%2e|%2e%2e)(?:\/|$))|[\\^#"<>{}`\x80-\uffff]/i;
+const _searchNeedsNormRE = /[#"'<>]/;
+const FastURL$2 = /* @__PURE__ */ (() => {
   const NativeURL = globalThis.URL;
   const FastURL2 = class URL {
     #url;
@@ -43,9 +44,11 @@ const FastURL$1 = /* @__PURE__ */ (() => {
     #searchParams;
     #pos;
     constructor(url) {
-      if (typeof url === "string") if (url[0] === "/") this.#href = url;
-      else this.#url = new NativeURL(url);
-      else if (_needsNormRE$1.test(url.pathname)) this.#url = new NativeURL(`${url.protocol || "http:"}//${url.host || "localhost"}${url.pathname}${url.search || ""}`);
+      if (typeof url === "string") {
+        const isOriginForm = url[0] === "/";
+        if (isOriginForm && !_searchNeedsNormRE.test(url)) this.#href = url;
+        else this.#url = new NativeURL(isOriginForm ? `http://localhost${url}` : url);
+      } else if (_needsNormRE$2.test(url.pathname) || url.search && _searchNeedsNormRE.test(url.search)) this.#url = new NativeURL(`${url.protocol || "http:"}//${url.host || "localhost"}${url.pathname}${url.search || ""}`);
       else {
         this.#protocol = url.protocol;
         this.#host = url.host;
@@ -128,7 +131,7 @@ const FastURL$1 = /* @__PURE__ */ (() => {
       return this.href;
     }
   };
-  lazyInherit$1(FastURL2.prototype, NativeURL.prototype, "_url");
+  lazyInherit$2(FastURL2.prototype, NativeURL.prototype, "_url");
   Object.setPrototypeOf(FastURL2.prototype, NativeURL.prototype);
   Object.setPrototypeOf(FastURL2, NativeURL);
   return FastURL2;
@@ -267,10 +270,56 @@ const gracefulShutdownPlugin = (server) => {
   };
   for (const sig of ["SIGINT", "SIGTERM"]) globalThis.process.on(sig, shutdown);
 };
-async function sendNodeResponse(nodeRes, webRes) {
+function createBodyTooLargeError(maxRequestBodySize) {
+  return Object.assign(/* @__PURE__ */ new Error(`Request body exceeds the maximum allowed size of ${maxRequestBodySize} bytes.`), {
+    code: "ERR_BODY_TOO_LARGE",
+    statusCode: 413,
+    status: 413
+  });
+}
+function limitBodyStream(stream, maxRequestBodySize) {
+  const reader = stream.getReader();
+  let size = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await reader.read();
+      if (done) {
+        controller.close();
+        return;
+      }
+      size += value.byteLength;
+      if (size > maxRequestBodySize) {
+        const error = createBodyTooLargeError(maxRequestBodySize);
+        reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+        return;
+      }
+      controller.enqueue(value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+function sendNodeResponseDetached(nodeRes, webRes) {
+  try {
+    return _sendNodeResponse(nodeRes, webRes, true);
+  } catch (error) {
+    handleSendError(nodeRes);
+  }
+}
+function handleSendError(nodeRes, _error) {
+  if (nodeRes.headersSent) nodeRes.destroy();
+  else {
+    nodeRes.statusCode = 500;
+    nodeRes.end();
+  }
+}
+function _sendNodeResponse(nodeRes, webRes, detached) {
   if (!webRes) {
     nodeRes.statusCode = 500;
-    return endNodeResponse(nodeRes);
+    return endNodeResponse(nodeRes, detached);
   }
   if (webRes._toNodeResponse) {
     const res = webRes._toNodeResponse();
@@ -282,18 +331,22 @@ async function sendNodeResponse(nodeRes, webRes) {
       writeHead(nodeRes, res.status, res.statusText, res.headers);
       nodeRes.write(res.body);
     } else writeHead(nodeRes, res.status, res.statusText, res.headers);
-    return endNodeResponse(nodeRes);
+    return endNodeResponse(nodeRes, detached);
   }
-  const rawHeaders = [...webRes.headers];
+  const rawHeaders = [];
+  for (const [key, value] of webRes.headers) rawHeaders.push(key, value);
   writeHead(nodeRes, webRes.status, webRes.statusText, rawHeaders);
-  return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes);
+  return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes, detached);
 }
 function writeHead(nodeRes, status, statusText, rawHeaders) {
-  const writeHeaders = rawHeaders.flat();
-  if (!nodeRes.headersSent) if (nodeRes.req?.httpVersion === "2.0") nodeRes.writeHead(status, writeHeaders);
-  else nodeRes.writeHead(status, statusText, writeHeaders);
+  if (!nodeRes.headersSent) if (nodeRes.req?.httpVersion === "2.0") nodeRes.writeHead(status, rawHeaders);
+  else nodeRes.writeHead(status, statusText, rawHeaders);
 }
-function endNodeResponse(nodeRes) {
+function endNodeResponse(nodeRes, detached) {
+  if (detached) {
+    nodeRes.end();
+    return;
+  }
   return new Promise((resolve) => nodeRes.end(resolve));
 }
 function pipeBody(stream, nodeRes, status, statusText, headers) {
@@ -360,8 +413,7 @@ function streamBody(stream, nodeRes) {
   });
 }
 const HOST_RE = /^(\[(?:[A-Fa-f0-9:.]+)\]|(?:[A-Za-z0-9_-]+\.)*[A-Za-z0-9_-]+|(?:\d{1,3}\.){3}\d{1,3})(:\d{1,5})?$/;
-var NodeRequestURL = class extends FastURL$1 {
-  #req;
+var NodeRequestURL = class extends FastURL$2 {
   constructor({ req }) {
     const path = req.url || "/";
     let host = req.headers.host || req.headers[":authority"];
@@ -384,16 +436,40 @@ var NodeRequestURL = class extends FastURL$1 {
       search: ""
     });
     else super(path);
-    this.#req = req;
-  }
-  get pathname() {
-    return super.pathname;
-  }
-  set pathname(value) {
-    this._url.pathname = value;
-    this.#req.url = this._url.pathname + this._url.search;
   }
 };
+const _nonJoinedHeaders = /* @__PURE__ */ new Set([
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "server",
+  "user-agent"
+]);
+const _validHeaderNameRE = /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/;
+function _isRepeated(rawHeaders, lowerName) {
+  let seen = false;
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const key = rawHeaders[i];
+    if (key.length === lowerName.length && key.toLowerCase() === lowerName) {
+      if (seen) return true;
+      seen = true;
+    }
+  }
+  return false;
+}
 const NodeRequestHeaders = /* @__PURE__ */ (() => {
   const NativeHeaders = globalThis.Headers;
   class Headers2 {
@@ -422,17 +498,24 @@ const NodeRequestHeaders = /* @__PURE__ */ (() => {
     }
     get(name) {
       if (this.#headers) return this.#headers.get(name);
-      const value = this.#req.headers[name.toLowerCase()];
-      return Array.isArray(value) ? value.join(", ") : value || null;
+      const lower = name.toLowerCase();
+      if (lower.charCodeAt(0) === 58) return this._headers.get(name);
+      const value = this.#req.headers[lower];
+      if (typeof value === "string") return _nonJoinedHeaders.has(lower) && _isRepeated(this.#req.rawHeaders, lower) ? this._headers.get(name) : value;
+      if (Array.isArray(value)) return value.join(", ");
+      return lower !== "__proto__" && _validHeaderNameRE.test(name) ? null : this._headers.get(name);
     }
     has(name) {
       if (this.#headers) return this.#headers.has(name);
-      return name.toLowerCase() in this.#req.headers;
+      const lower = name.toLowerCase();
+      if (lower.charCodeAt(0) === 58) return this._headers.has(name);
+      if (Object.hasOwn(this.#req.headers, lower)) return true;
+      return lower !== "__proto__" && _validHeaderNameRE.test(name) ? false : this._headers.has(name);
     }
     getSetCookie() {
       if (this.#headers) return this.#headers.getSetCookie();
       const value = this.#req.headers["set-cookie"];
-      return Array.isArray(value) ? value : value ? [value] : [];
+      return Array.isArray(value) ? value.slice() : value ? [value] : [];
     }
     entries() {
       return this._headers.entries();
@@ -441,23 +524,27 @@ const NodeRequestHeaders = /* @__PURE__ */ (() => {
       return this.entries();
     }
   }
-  lazyInherit$1(Headers2.prototype, NativeHeaders.prototype, "_headers");
+  lazyInherit$2(Headers2.prototype, NativeHeaders.prototype, "_headers");
   Object.setPrototypeOf(Headers2, NativeHeaders);
   Object.setPrototypeOf(Headers2.prototype, NativeHeaders.prototype);
   return Headers2;
 })();
+const kNativeRequest = /* @__PURE__ */ Symbol.for("srvx.nativeRequest");
 const NodeRequest = /* @__PURE__ */ (() => {
-  const NativeRequest = globalThis.Request;
+  const NativeRequest = getNativeRequest();
   class Request {
     runtime;
+    waitUntil;
     #req;
     #url;
     #bodyStream;
     #request;
     #headers;
     #abortController;
+    #maxRequestBodySize;
     constructor(ctx) {
       this.#req = ctx.req;
+      this.#maxRequestBodySize = ctx.maxRequestBodySize;
       this.runtime = {
         name: "node",
         node: ctx
@@ -511,19 +598,24 @@ const NodeRequest = /* @__PURE__ */ (() => {
       if (this.#request) return this.#request.body;
       if (this.#bodyStream === void 0) {
         const method = this.method;
-        const hasBody = !(method === "GET" || method === "HEAD");
-        this.#bodyStream = hasBody ? Readable.toWeb(this.#req) : null;
+        let stream = !(method === "GET" || method === "HEAD") ? Readable.toWeb(this.#req) : null;
+        if (stream && this.#maxRequestBodySize !== void 0) stream = limitBodyStream(stream, this.#maxRequestBodySize);
+        this.#bodyStream = stream;
       }
       return this.#bodyStream;
     }
+    #readBuffered() {
+      return readBody(this.#req, this.#maxRequestBodySize);
+    }
     text() {
       if (this.#request) return this.#request.text();
       if (this.#bodyStream !== void 0) return this.#bodyStream ? new Response(this.#bodyStream).text() : Promise.resolve("");
-      return readBody(this.#req).then((buf) => buf.toString());
+      return this.#readBuffered().then((buf) => buf.toString());
     }
     json() {
       if (this.#request) return this.#request.json();
-      return this.text().then((text) => JSON.parse(text));
+      if (this.#bodyStream !== void 0) return this.text().then((text) => JSON.parse(text));
+      return this.#readBuffered().then((buf) => JSON.parse(buf.toString()));
     }
     get _request() {
       if (!this.#request) {
@@ -541,29 +633,52 @@ const NodeRequest = /* @__PURE__ */ (() => {
       return this.#request;
     }
   }
-  lazyInherit$1(Request.prototype, NativeRequest.prototype, "_request");
+  lazyInherit$2(Request.prototype, NativeRequest.prototype, "_request");
   Object.setPrototypeOf(Request.prototype, NativeRequest.prototype);
   return Request;
 })();
-function readBody(req) {
-  if ("rawBody" in req && Buffer.isBuffer(req.rawBody)) return Promise.resolve(req.rawBody);
+function readBody(req, maxRequestBodySize) {
+  if ("rawBody" in req && Buffer.isBuffer(req.rawBody)) {
+    if (maxRequestBodySize !== void 0 && req.rawBody.length > maxRequestBodySize) return Promise.reject(createBodyTooLargeError(maxRequestBodySize));
+    return Promise.resolve(req.rawBody);
+  }
   return new Promise((resolve, reject) => {
     const chunks = [];
+    let size = 0;
+    const cleanup = () => {
+      req.off("data", onData);
+      req.off("end", onEnd);
+      req.off("error", onError);
+    };
     const onData = (chunk) => {
+      if (maxRequestBodySize !== void 0) {
+        size += chunk.length;
+        if (size > maxRequestBodySize) {
+          cleanup();
+          req.pause?.();
+          reject(createBodyTooLargeError(maxRequestBodySize));
+          return;
+        }
+      }
       chunks.push(chunk);
     };
     const onError = (err) => {
+      cleanup();
       reject(err);
     };
     const onEnd = () => {
-      req.off("error", onError);
-      req.off("data", onData);
-      resolve(Buffer.concat(chunks));
+      cleanup();
+      resolve(chunks.length === 1 ? chunks[0] : Buffer.concat(chunks));
     };
     req.on("data", onData).once("end", onEnd).once("error", onError);
   });
 }
-const NodeResponse$1 = /* @__PURE__ */ (() => {
+function getNativeRequest() {
+  let R = globalThis[kNativeRequest] || globalThis.Request;
+  while (R?._srvx) R = Object.getPrototypeOf(R);
+  return globalThis[kNativeRequest] ??= R;
+}
+const NodeResponse$2 = /* @__PURE__ */ (() => {
   const NativeResponse = globalThis.Response;
   const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
   class NodeResponse2 {
@@ -643,17 +758,18 @@ const NodeResponse$1 = /* @__PURE__ */ (() => {
       else body = this._response.body;
       const headers = [];
       const initHeaders = this.#init?.headers;
-      const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k, v]) => [k.toLowerCase(), v]) : void 0);
+      const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders) : void 0);
       let hasContentTypeHeader;
       let hasContentLength;
       if (headerEntries) for (const [key, value] of headerEntries) {
-        if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
-        else headers.push([key, value]);
-        if (key === "content-type") hasContentTypeHeader = true;
-        else if (key === "content-length") hasContentLength = true;
+        const lowerKey = typeof key === "string" ? key.toLowerCase() : String(key);
+        if (Array.isArray(value)) for (const v of value) headers.push(lowerKey, v);
+        else headers.push(lowerKey, value);
+        if (lowerKey === "content-type") hasContentTypeHeader = true;
+        else if (lowerKey === "content-length") hasContentLength = true;
       }
-      if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
-      if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+      if (contentType && !hasContentTypeHeader) headers.push("content-type", contentType);
+      if (contentLength && !hasContentLength) headers.push("content-length", String(contentLength));
       this.#init = void 0;
       this.#headers = void 0;
       this.#response = void 0;
@@ -666,7 +782,7 @@ const NodeResponse$1 = /* @__PURE__ */ (() => {
       };
     }
   }
-  lazyInherit$1(NodeResponse2.prototype, NativeResponse.prototype, "_response");
+  lazyInherit$2(NodeResponse2.prototype, NativeResponse.prototype, "_response");
   Object.setPrototypeOf(NodeResponse2, NativeResponse);
   Object.setPrototypeOf(NodeResponse2.prototype, NativeResponse.prototype);
   return NodeResponse2;
@@ -702,11 +818,12 @@ var NodeServer = class {
       }
       const request = new NodeRequest({
         req: nodeReq,
-        res: nodeRes
+        res: nodeRes,
+        maxRequestBodySize: this.options.maxRequestBodySize
       });
       request.waitUntil = this.#wait?.waitUntil;
       const res = fetchHandler(request);
-      return res instanceof Promise ? res.then((resolvedRes) => sendNodeResponse(nodeRes, resolvedRes)) : sendNodeResponse(nodeRes, res);
+      return res instanceof Promise ? res.then((resolvedRes) => sendNodeResponseDetached(nodeRes, resolvedRes)) : sendNodeResponseDetached(nodeRes, res);
     };
     this.node = {
       handler,
@@ -787,6 +904,244 @@ var NodeServer = class {
     })]);
   }
 };
+function lazyInherit$1(target, source, sourceKey) {
+  for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
+    if (key === "constructor") continue;
+    const targetDesc = Object.getOwnPropertyDescriptor(target, key);
+    const desc = Object.getOwnPropertyDescriptor(source, key);
+    let modified = false;
+    if (desc.get) {
+      modified = true;
+      desc.get = targetDesc?.get || function() {
+        return this[sourceKey][key];
+      };
+    }
+    if (desc.set) {
+      modified = true;
+      desc.set = targetDesc?.set || function(value) {
+        this[sourceKey][key] = value;
+      };
+    }
+    if (!targetDesc?.value && typeof desc.value === "function") {
+      modified = true;
+      desc.value = function(...args) {
+        return this[sourceKey][key](...args);
+      };
+    }
+    if (modified) Object.defineProperty(target, key, desc);
+  }
+}
+const _needsNormRE$1 = /(?:(?:^|\/)(?:\.|\.\.|%2e|%2e\.|\.%2e|%2e%2e)(?:\/|$))|[\\^\x80-\uffff]/i;
+const FastURL$1 = /* @__PURE__ */ (() => {
+  const NativeURL = globalThis.URL;
+  const FastURL2 = class URL {
+    #url;
+    #href;
+    #protocol;
+    #host;
+    #pathname;
+    #search;
+    #searchParams;
+    #pos;
+    constructor(url) {
+      if (typeof url === "string") if (url[0] === "/") this.#href = url;
+      else this.#url = new NativeURL(url);
+      else if (_needsNormRE$1.test(url.pathname)) this.#url = new NativeURL(`${url.protocol || "http:"}//${url.host || "localhost"}${url.pathname}${url.search || ""}`);
+      else {
+        this.#protocol = url.protocol;
+        this.#host = url.host;
+        this.#pathname = url.pathname;
+        this.#search = url.search;
+      }
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeURL;
+    }
+    get _url() {
+      if (this.#url) return this.#url;
+      this.#url = new NativeURL(this.href);
+      this.#href = void 0;
+      this.#protocol = void 0;
+      this.#host = void 0;
+      this.#pathname = void 0;
+      this.#search = void 0;
+      this.#searchParams = void 0;
+      this.#pos = void 0;
+      return this.#url;
+    }
+    get href() {
+      if (this.#url) return this.#url.href;
+      if (!this.#href) this.#href = `${this.#protocol || "http:"}//${this.#host || "localhost"}${this.#pathname || "/"}${this.#search || ""}`;
+      return this.#href;
+    }
+    #getPos() {
+      if (!this.#pos) {
+        const url = this.href;
+        const protoIndex = url.indexOf("://");
+        const pathnameIndex = protoIndex === -1 ? -1 : url.indexOf("/", protoIndex + 4);
+        const qIndex = pathnameIndex === -1 ? -1 : url.indexOf("?", pathnameIndex);
+        this.#pos = [
+          protoIndex,
+          pathnameIndex,
+          qIndex
+        ];
+      }
+      return this.#pos;
+    }
+    get pathname() {
+      if (this.#url) return this.#url.pathname;
+      if (this.#pathname === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.pathname;
+        this.#pathname = this.href.slice(pathnameIndex, queryIndex === -1 ? void 0 : queryIndex);
+      }
+      return this.#pathname;
+    }
+    get search() {
+      if (this.#url) return this.#url.search;
+      if (this.#search === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.search;
+        const url = this.href;
+        this.#search = queryIndex === -1 || queryIndex === url.length - 1 ? "" : url.slice(queryIndex);
+      }
+      return this.#search;
+    }
+    get searchParams() {
+      if (this.#url) return this.#url.searchParams;
+      if (!this.#searchParams) this.#searchParams = new URLSearchParams(this.search);
+      return this.#searchParams;
+    }
+    get protocol() {
+      if (this.#url) return this.#url.protocol;
+      if (this.#protocol === void 0) {
+        const [protocolIndex] = this.#getPos();
+        if (protocolIndex === -1) return this._url.protocol;
+        const url = this.href;
+        this.#protocol = url.slice(0, protocolIndex + 1);
+      }
+      return this.#protocol;
+    }
+    toString() {
+      return this.href;
+    }
+    toJSON() {
+      return this.href;
+    }
+  };
+  lazyInherit$1(FastURL2.prototype, NativeURL.prototype, "_url");
+  Object.setPrototypeOf(FastURL2.prototype, NativeURL.prototype);
+  Object.setPrototypeOf(FastURL2, NativeURL);
+  return FastURL2;
+})();
+const NodeResponse$1 = /* @__PURE__ */ (() => {
+  const NativeResponse = globalThis.Response;
+  const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+  class NodeResponse2 {
+    #body;
+    #init;
+    #headers;
+    #response;
+    constructor(body, init) {
+      this.#body = body;
+      this.#init = init;
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeResponse;
+    }
+    get status() {
+      return this.#response?.status || this.#init?.status || 200;
+    }
+    get statusText() {
+      return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
+    }
+    get headers() {
+      if (this.#response) return this.#response.headers;
+      if (this.#headers) return this.#headers;
+      const initHeaders = this.#init?.headers;
+      return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
+    }
+    get ok() {
+      if (this.#response) return this.#response.ok;
+      const status = this.status;
+      return status >= 200 && status < 300;
+    }
+    get _response() {
+      if (this.#response) return this.#response;
+      let body = this.#body;
+      if (body && typeof body.pipe === "function" && !(body instanceof Readable)) {
+        const stream = new PassThrough();
+        body.pipe(stream);
+        const abort = body.abort;
+        if (abort) stream.once("close", () => abort());
+        body = stream;
+      }
+      this.#response = new NativeResponse(body, this.#headers ? {
+        ...this.#init,
+        headers: this.#headers
+      } : this.#init);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#body = void 0;
+      return this.#response;
+    }
+    _toNodeResponse() {
+      const status = this.status;
+      const statusText = this.statusText;
+      let body;
+      let contentType;
+      let contentLength;
+      if (this.#response) body = this.#response.body;
+      else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
+      else if (typeof this.#body === "string") {
+        body = this.#body;
+        contentType = "text/plain; charset=UTF-8";
+        contentLength = Buffer.byteLength(this.#body);
+      } else if (this.#body instanceof ArrayBuffer) {
+        body = Buffer.from(this.#body);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Uint8Array) {
+        body = this.#body;
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof DataView) {
+        body = Buffer.from(this.#body.buffer);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Blob) {
+        body = this.#body.stream();
+        contentType = this.#body.type;
+        contentLength = this.#body.size;
+      } else if (typeof this.#body.pipe === "function") body = this.#body;
+      else body = this._response.body;
+      const headers = [];
+      const initHeaders = this.#init?.headers;
+      const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k, v]) => [k.toLowerCase(), v]) : void 0);
+      let hasContentTypeHeader;
+      let hasContentLength;
+      if (headerEntries) for (const [key, value] of headerEntries) {
+        if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
+        else headers.push([key, value]);
+        if (key === "content-type") hasContentTypeHeader = true;
+        else if (key === "content-length") hasContentLength = true;
+      }
+      if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
+      if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#response = void 0;
+      this.#body = void 0;
+      return {
+        status,
+        statusText,
+        headers,
+        body
+      };
+    }
+  }
+  lazyInherit$1(NodeResponse2.prototype, NativeResponse.prototype, "_response");
+  Object.setPrototypeOf(NodeResponse2, NativeResponse);
+  Object.setPrototypeOf(NodeResponse2.prototype, NativeResponse.prototype);
+  return NodeResponse2;
+})();
 function lazyInherit(target, source, sourceKey) {
   for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
     if (key === "constructor") continue;
@@ -1030,5 +1385,6 @@ export {
   NodeResponse$1 as N,
   FastURL as a,
   NodeResponse as b,
+  NodeResponse$2 as c,
   serve as s
 };

package/.output/server/_libs/swr.mjs

@@ -1,4 +1,4 @@
-import { r as reactExports, a as React } from "./react.mjs";
+import { r as reactExports, R as React } from "./react.mjs";
 import { s as shimExports } from "./use-sync-external-store.mjs";
 import { d as dequal } from "./dequal.mjs";
 const FOCUS_EVENT = 0;
@@ -307,7 +307,13 @@ const initCache = (provider, options) => {
       const subs = subscriptions[key] || [];
       subscriptions[key] = subs;
       subs.push(callback);
-      return () => subs.splice(subs.indexOf(callback), 1);
+      return () => {
+        const index = subs.indexOf(callback);
+        if (index >= 0) {
+          subs[index] = subs[subs.length - 1];
+          subs.pop();
+        }
+      };
     };
     const setter = (key, value, prev) => {
       provider.set(key, value);
@@ -536,6 +542,8 @@ const WITH_DEDUPE = {
   dedupe: true
 };
 const resolvedUndef = Promise.resolve(UNDEFINED);
+resolvedUndef.status = "fulfilled";
+resolvedUndef.value = UNDEFINED;
 const sub = () => noop;
 const useSWRHandler = (_key, fetcher, config) => {
   const { cache: cache2, compare: compare2, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData, strictServerPrefetchWarning } = config;