elit 3.6.6 → 3.6.8

package/dist/http.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/http.ts
+// src/server/http/index.ts
 var http_exports = {};
 __export(http_exports, {
   Agent: () => Agent,
@@ -34,22 +34,89 @@ __export(http_exports, {
   request: () => request
 });
 module.exports = __toCommonJS(http_exports);
-var import_node_events = require("events");
 
-// src/runtime.ts
-var runtime = (() => {
-  if (typeof Deno !== "undefined") return "deno";
-  if (typeof Bun !== "undefined") return "bun";
-  return "node";
-})();
-var isNode = runtime === "node";
-var isBun = runtime === "bun";
-var isDeno = runtime === "deno";
+// src/server/http/agent.ts
+var Agent = class {
+  constructor(options) {
+    this.options = options;
+  }
+};
 
-// src/http.ts
+// src/server/http/client-request.ts
+var import_node_events = require("events");
+
+// src/server/http/utils.ts
 function queueCallback(callback) {
   if (callback) queueMicrotask(callback);
 }
+function getRequestPath(url) {
+  if (!url) return "";
+  try {
+    const urlObj = new URL(url);
+    return urlObj.pathname + urlObj.search;
+  } catch {
+    return url;
+  }
+}
+function headersToRecord(headers) {
+  const result = /* @__PURE__ */ Object.create(null);
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function headersToRawHeaders(headers) {
+  const rawHeaders = [];
+  headers.forEach((value, key) => {
+    rawHeaders.push(key, value);
+  });
+  return rawHeaders;
+}
+function normalizeRequestBodyChunk(chunk, encoding = "utf8") {
+  if (typeof chunk === "string") {
+    if (encoding !== "utf8" && typeof Buffer !== "undefined") {
+      return Buffer.from(chunk, encoding);
+    }
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return chunk;
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+  return new TextEncoder().encode(String(chunk));
+}
+function buildRequestBody(chunks) {
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  if (chunks.every((chunk) => typeof chunk === "string")) {
+    return chunks.join("");
+  }
+  const encoder = new TextEncoder();
+  const bodyParts = chunks.map((chunk) => typeof chunk === "string" ? encoder.encode(chunk) : chunk);
+  const totalLength = bodyParts.reduce((sum, part) => sum + part.byteLength, 0);
+  const body = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of bodyParts) {
+    body.set(part, offset);
+    offset += part.byteLength;
+  }
+  return body;
+}
+function isFetchResponse(value) {
+  return typeof value?.status === "number" && typeof value?.statusText === "string" && typeof value?.headers?.forEach === "function";
+}
+function isNodeIncomingMessage(value) {
+  return typeof value?.on === "function" && typeof value?.headers === "object" && (typeof value?.httpVersion === "string" || value?.socket !== void 0);
+}
 function headersToInit(headers) {
   const result = {};
   for (const key in headers) {
@@ -74,17 +141,73 @@ function closeAndEmit(server, callback) {
   server.emit("close");
   if (callback) queueMicrotask(() => callback());
 }
-var http;
-var https;
-if (isNode && typeof process !== "undefined") {
-  try {
-    http = require("http");
-    https = require("https");
-  } catch (e) {
-    http = require("http");
-    https = require("https");
+
+// src/server/http/client-request.ts
+var ClientRequest = class extends import_node_events.EventEmitter {
+  constructor(_url, _options = {}) {
+    super();
+    this._bodyChunks = [];
+    this._ended = false;
   }
-}
+  _setNativeRequest(nativeRequest) {
+    this._nativeRequest = nativeRequest;
+  }
+  _setExecutor(executor) {
+    this._executor = executor;
+  }
+  write(chunk, encoding, callback) {
+    if (this._ended) {
+      throw new Error("Cannot write after end");
+    }
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (this._nativeRequest) {
+      const actualEncoding2 = typeof encoding === "string" ? encoding : void 0;
+      return this._nativeRequest.write(chunk, actualEncoding2, callback);
+    }
+    const actualEncoding = typeof encoding === "string" ? encoding : "utf8";
+    this._bodyChunks.push(normalizeRequestBodyChunk(chunk, actualEncoding));
+    queueCallback(callback);
+    return true;
+  }
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = void 0;
+      encoding = void 0;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (this._ended) {
+      queueCallback(callback);
+      return;
+    }
+    this._ended = true;
+    if (this._nativeRequest) {
+      const actualEncoding = typeof encoding === "string" ? encoding : void 0;
+      if (chunk !== void 0) {
+        this._nativeRequest.end(chunk, actualEncoding, callback);
+      } else {
+        this._nativeRequest.end(callback);
+      }
+      return;
+    }
+    if (chunk !== void 0) {
+      this._bodyChunks.push(normalizeRequestBodyChunk(chunk, typeof encoding === "string" ? encoding : "utf8"));
+    }
+    const executor = this._executor;
+    const body = buildRequestBody(this._bodyChunks);
+    if (executor) {
+      Promise.resolve().then(() => executor(body)).catch((error) => this.emit("error", error));
+    }
+    queueCallback(callback);
+  }
+};
+
+// src/server/http/constants.ts
 var METHODS = [
   "GET",
   "POST",
@@ -152,13 +275,23 @@ var STATUS_CODES = {
   510: "Not Extended",
   511: "Network Authentication Required"
 };
-var IncomingMessage = class extends import_node_events.EventEmitter {
-  constructor(req) {
+
+// src/server/http/incoming-message.ts
+var import_node_events2 = require("events");
+var IncomingMessage = class extends import_node_events2.EventEmitter {
+  constructor(req, requestMethod) {
     super();
     this.httpVersion = "1.1";
     this.rawHeaders = [];
     this._req = req;
-    if (isNode) {
+    if (isFetchResponse(req)) {
+      this.method = requestMethod || "GET";
+      this.url = getRequestPath(req.url);
+      this.headers = headersToRecord(req.headers);
+      this.statusCode = req.status;
+      this.statusMessage = req.statusText;
+      this.rawHeaders = headersToRawHeaders(req.headers);
+    } else if (isNodeIncomingMessage(req)) {
       this.method = req.method;
       this.url = req.url;
       this.headers = req.headers;
@@ -169,14 +302,13 @@ var IncomingMessage = class extends import_node_events.EventEmitter {
       this.socket = req.socket;
     } else {
       this.method = req.method;
-      const urlObj = new URL(req.url);
-      this.url = urlObj.pathname + urlObj.search;
-      this.headers = req.headers;
-      this.rawHeaders = [];
+      this.url = getRequestPath(req.url);
+      this.headers = headersToRecord(req.headers);
+      this.rawHeaders = headersToRawHeaders(req.headers);
     }
   }
   async text() {
-    if (isNode) {
+    if (isNodeIncomingMessage(this._req)) {
       return new Promise((resolve, reject) => {
         const chunks = [];
         this._req.on("data", (chunk) => chunks.push(chunk));
@@ -187,14 +319,80 @@ var IncomingMessage = class extends import_node_events.EventEmitter {
     return this._req.text();
   }
   async json() {
-    if (isNode) {
+    if (isNodeIncomingMessage(this._req)) {
       const text = await this.text();
       return JSON.parse(text);
     }
     return this._req.json();
   }
 };
-var ServerResponse = class extends import_node_events.EventEmitter {
+
+// src/shares/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/server/http/node-modules.ts
+var http;
+var https;
+if (isNode && typeof process !== "undefined") {
+  try {
+    http = require("http");
+    https = require("https");
+  } catch {
+    http = require("http");
+    https = require("https");
+  }
+}
+
+// src/server/http/request-api.ts
+function request(url, options, callback) {
+  const urlString = typeof url === "string" ? url : url.toString();
+  const req = new ClientRequest(urlString, options);
+  if (isNode) {
+    const urlObj = new URL(urlString);
+    const client = urlObj.protocol === "https:" ? https : http;
+    const nodeReq = client.request(urlString, {
+      method: options?.method || "GET",
+      headers: options?.headers,
+      timeout: options?.timeout,
+      signal: options?.signal
+    }, (res) => {
+      const incomingMessage = new IncomingMessage(res);
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+    req._setNativeRequest(nodeReq);
+    nodeReq.on("error", (error) => req.emit("error", error));
+  } else {
+    req._setExecutor(async (body) => {
+      const response = await fetch(urlString, {
+        method: options?.method || "GET",
+        headers: options?.headers,
+        body,
+        signal: options?.signal
+      });
+      const incomingMessage = new IncomingMessage(response, options?.method || "GET");
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+  }
+  return req;
+}
+function get(url, options, callback) {
+  const req = request(url, { ...options, method: "GET" }, callback);
+  req.end();
+  return req;
+}
+
+// src/server/http/response.ts
+var import_node_events3 = require("events");
+var ServerResponse = class extends import_node_events3.EventEmitter {
   constructor(_req, nodeRes) {
     super();
     this.statusCode = 200;
@@ -327,7 +525,6 @@ var ServerResponse = class extends import_node_events.EventEmitter {
   _setResolver(resolve) {
     this._resolve = resolve;
   }
-  // Express.js-like methods
   json(data, statusCode = 200) {
     if (!this.headersSent) {
       this.setHeader("Content-Type", "application/json");
@@ -351,7 +548,15 @@ var ServerResponse = class extends import_node_events.EventEmitter {
     return this;
   }
 };
-var Server = class extends import_node_events.EventEmitter {
+
+// src/server/http/runtime.ts
+function getRuntime() {
+  return runtime;
+}
+
+// src/server/http/server-runtime.ts
+var import_node_events4 = require("events");
+var Server = class extends import_node_events4.EventEmitter {
   constructor(requestListener) {
     super();
     this._bunWebSocketServers = /* @__PURE__ */ new Set();
@@ -364,9 +569,28 @@ var Server = class extends import_node_events.EventEmitter {
   unregisterWebSocketServer(wsServer) {
     this._bunWebSocketServers.delete(wsServer);
   }
+  resolvePmInheritedFd(explicitPort, explicitFd) {
+    if (typeof explicitFd === "number" && Number.isInteger(explicitFd) && explicitFd >= 0) {
+      return explicitFd;
+    }
+    const fdValue = process.env.ELIT_PM_LISTEN_FD;
+    if (!fdValue) {
+      return void 0;
+    }
+    const parsedFd = Number.parseInt(fdValue, 10);
+    if (!Number.isInteger(parsedFd) || parsedFd < 0) {
+      return void 0;
+    }
+    const publicPort = Number.parseInt(process.env.ELIT_PM_PUBLIC_PORT ?? process.env.ELIT_PM_PORT ?? "", 10);
+    if (Number.isInteger(explicitPort) && Number.isInteger(publicPort) && explicitPort !== publicPort) {
+      return void 0;
+    }
+    return parsedFd;
+  }
   listen(...args) {
     let port = 3e3;
     let hostname = "0.0.0.0";
+    let fd;
     let callback;
     const firstArg = args[0];
     if (typeof firstArg === "number") {
@@ -381,8 +605,10 @@ var Server = class extends import_node_events.EventEmitter {
     } else if (firstArg && typeof firstArg === "object") {
       port = firstArg.port || 3e3;
       hostname = firstArg.hostname || "0.0.0.0";
+      fd = typeof firstArg.fd === "number" ? firstArg.fd : void 0;
       callback = args[1];
     }
+    fd = this.resolvePmInheritedFd(firstArg && typeof firstArg === "object" ? firstArg.port : port, fd);
     const self = this;
     if (isNode) {
       this.nativeServer = http.createServer((req, res) => {
@@ -397,11 +623,19 @@ var Server = class extends import_node_events.EventEmitter {
       this.nativeServer.on("upgrade", (req, socket, head) => {
         self.emit("upgrade", req, socket, head);
       });
-      this.nativeServer.listen(port, hostname, () => {
-        this._listening = true;
-        this.emit("listening");
-        if (callback) callback();
-      });
+      if (fd !== void 0) {
+        this.nativeServer.listen({ fd, exclusive: false }, () => {
+          this._listening = true;
+          this.emit("listening");
+          if (callback) callback();
+        });
+      } else {
+        this.nativeServer.listen(port, hostname, () => {
+          this._listening = true;
+          this.emit("listening");
+          if (callback) callback();
+        });
+      }
       this.nativeServer.on("error", (err) => this.emit("error", err));
       this.nativeServer.on("close", () => {
         this._listening = false;
@@ -426,6 +660,8 @@ var Server = class extends import_node_events.EventEmitter {
           const urlObj = new URL(req.url);
           const pathname = urlObj.pathname;
           const requestUrl = urlObj.pathname + urlObj.search;
+          const incomingHeaders = headersToRecord(req.headers);
+          const rawHeaders = headersToRawHeaders(req.headers);
           const upgradeHeader = req.headers.get("upgrade");
           if (upgradeHeader && upgradeHeader.toLowerCase() === "websocket") {
             const matchingWebSocketServer = Array.from(this._bunWebSocketServers).find((wsServer) => {
@@ -462,9 +698,9 @@ var Server = class extends import_node_events.EventEmitter {
           const incomingMessage = {
             method: req.method,
             url: requestUrl,
-            headers: req.headers,
+            headers: incomingHeaders,
             httpVersion: "1.1",
-            rawHeaders: [],
+            rawHeaders,
             _req: req,
             text: () => req.text(),
             json: () => req.json()
@@ -518,57 +754,148 @@ var Server = class extends import_node_events.EventEmitter {
                 this.writeHead(statusCode);
               }
               responseReady = true;
-              return this;
             }
           };
           if (self.requestListener) {
             self.requestListener(incomingMessage, serverResponse);
+          } else {
+            self.emit("request", incomingMessage, serverResponse);
           }
-          if (responseReady) {
-            return new Response(body, {
-              status: statusCode,
-              statusText: statusMessage,
-              headers
-            });
+          if (!responseReady) {
+            serverResponse.end();
           }
-          return new Promise((resolve) => {
-            serverResponse.end = (chunk) => {
-              if (chunk !== void 0) {
-                body += chunk;
-              }
-              resolve(new Response(body, {
-                status: statusCode,
-                statusText: statusMessage,
-                headers
-              }));
-            };
+          return new Response(body, {
+            status: statusCode,
+            statusText: statusMessage,
+            headers
           });
         },
-        error: createErrorResponse
+        error: (err) => {
+          this.emit("error", err);
+          return createErrorResponse();
+        }
       });
+      this._listening = true;
       emitListeningWithCallback(this, callback);
+      this.nativeServer.stop = this.nativeServer.stop || this.nativeServer.close;
+      this.nativeServer.close = this.nativeServer.close || this.nativeServer.stop;
+      this.nativeServer.on?.("close", () => {
+        this._listening = false;
+        this.emit("close");
+      });
     } else if (isDeno) {
+      const server = this;
       this.nativeServer = Deno.serve({
         port,
-        hostname,
-        handler: (req) => {
-          return new Promise((resolve) => {
-            const incomingMessage = new IncomingMessage(req);
-            const serverResponse = new ServerResponse();
-            serverResponse._setResolver(resolve);
-            if (self.requestListener) {
-              self.requestListener(incomingMessage, serverResponse);
-            } else {
-              self.emit("request", incomingMessage, serverResponse);
+        hostname
+      }, async (req) => {
+        const urlObj = new URL(req.url);
+        const requestUrl = urlObj.pathname + urlObj.search;
+        const incomingHeaders = headersToRecord(req.headers);
+        const rawHeaders = headersToRawHeaders(req.headers);
+        const bodyChunks = [];
+        const responseHeaders = new Headers();
+        let statusCode = 200;
+        let statusText = "OK";
+        let responseClosed = false;
+        const incomingMessage = {
+          method: req.method,
+          url: requestUrl,
+          headers: incomingHeaders,
+          httpVersion: "1.1",
+          rawHeaders,
+          _req: req,
+          text: () => req.text(),
+          json: () => req.json()
+        };
+        const serverResponse = {
+          statusCode: 200,
+          statusMessage: "OK",
+          headersSent: false,
+          setHeader(name, value) {
+            responseHeaders.set(name, Array.isArray(value) ? value.join(", ") : String(value));
+            return this;
+          },
+          getHeader(name) {
+            return responseHeaders.get(name) ?? void 0;
+          },
+          getHeaders() {
+            const headers = {};
+            responseHeaders.forEach((value, key) => {
+              headers[key] = value;
+            });
+            return headers;
+          },
+          writeHead(status, arg2, arg3) {
+            statusCode = status;
+            this.statusCode = status;
+            this.headersSent = true;
+            if (typeof arg2 === "string") {
+              statusText = arg2;
+              this.statusMessage = arg2;
+              if (arg3) {
+                Object.entries(arg3).forEach(([key, value]) => {
+                  responseHeaders.set(key, Array.isArray(value) ? value.join(", ") : String(value));
+                });
+              }
+            } else if (arg2) {
+              Object.entries(arg2).forEach(([key, value]) => {
+                responseHeaders.set(key, Array.isArray(value) ? value.join(", ") : String(value));
+              });
             }
-          });
-        },
-        onError: (error) => {
-          this.emit("error", error);
-          return createErrorResponse();
+            return this;
+          },
+          write(chunk) {
+            if (!this.headersSent) {
+              this.writeHead(statusCode);
+            }
+            if (typeof chunk === "string") {
+              bodyChunks.push(new TextEncoder().encode(chunk));
+            } else if (chunk instanceof Uint8Array) {
+              bodyChunks.push(chunk);
+            } else if (chunk !== void 0 && chunk !== null) {
+              bodyChunks.push(new TextEncoder().encode(String(chunk)));
+            }
+            return true;
+          },
+          end(chunk) {
+            if (chunk !== void 0) {
+              this.write(chunk);
+            }
+            if (!this.headersSent) {
+              this.writeHead(statusCode);
+            }
+            responseClosed = true;
+          }
+        };
+        if (server.requestListener) {
+          server.requestListener(incomingMessage, serverResponse);
+        } else {
+          server.emit("request", incomingMessage, serverResponse);
         }
+        if (!responseClosed) {
+          serverResponse.end();
+        }
+        const body = bodyChunks.length === 0 ? void 0 : (() => {
+          const totalLength = bodyChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+          const output = new ArrayBuffer(totalLength);
+          const combined = new Uint8Array(output);
+          let offset = 0;
+          for (const chunk of bodyChunks) {
+            combined.set(chunk, offset);
+            offset += chunk.length;
+          }
+          return output;
+        })();
+        return new Response(body, {
+          status: statusCode,
+          statusText,
+          headers: responseHeaders
+        });
       });
+      this._listening = true;
       emitListeningWithCallback(this, callback);
+      this.nativeServer.finished.then(() => closeAndEmit(this)).catch((err) => this.emit("error", err));
     }
     return this;
   }
@@ -597,9 +924,11 @@ var Server = class extends import_node_events.EventEmitter {
         return createAddress(0, addr, "unix");
       }
       return addr;
-    } else if (isBun) {
+    }
+    if (isBun) {
       return createAddress(this.nativeServer.port, this.nativeServer.hostname);
-    } else if (isDeno) {
+    }
+    if (isDeno) {
       const addr = this.nativeServer.addr;
       return createAddress(addr.port, addr.hostname);
     }
@@ -609,70 +938,12 @@ var Server = class extends import_node_events.EventEmitter {
     return this._listening;
   }
 };
-var ClientRequest = class extends import_node_events.EventEmitter {
-  constructor(_url, _options = {}) {
-    super();
-  }
-  write(_chunk) {
-    return true;
-  }
-  end(callback) {
-    queueCallback(callback);
-  }
-};
-var Agent = class {
-  constructor(options) {
-    this.options = options;
-  }
-};
-function createServer(optionsOrListener, requestListener) {
-  return new Server(typeof optionsOrListener === "function" ? optionsOrListener : requestListener);
-}
-function request(url, options, callback) {
-  const urlString = typeof url === "string" ? url : url.toString();
-  const req = new ClientRequest(urlString, options);
-  if (isNode) {
-    const urlObj = new URL(urlString);
-    const client = urlObj.protocol === "https:" ? https : http;
-    const nodeReq = client.request(urlString, {
-      method: options?.method || "GET",
-      headers: options?.headers,
-      timeout: options?.timeout,
-      signal: options?.signal
-    }, (res) => {
-      const incomingMessage = new IncomingMessage(res);
-      if (callback) callback(incomingMessage);
-      req.emit("response", incomingMessage);
-    });
-    nodeReq.on("error", (error) => req.emit("error", error));
-    nodeReq.end();
-  } else {
-    queueMicrotask(async () => {
-      try {
-        const response = await fetch(urlString, {
-          method: options?.method || "GET",
-          headers: options?.headers,
-          signal: options?.signal
-        });
-        const fetchRequest = new Request(urlString);
-        const incomingMessage = new IncomingMessage(fetchRequest);
-        incomingMessage.statusCode = response.status;
-        incomingMessage.statusMessage = response.statusText;
-        if (callback) callback(incomingMessage);
-        req.emit("response", incomingMessage);
-      } catch (error) {
-        req.emit("error", error);
-      }
-    });
-  }
-  return req;
-}
-function get(url, options, callback) {
-  return request(url, { ...options, method: "GET" }, callback);
-}
-function getRuntime() {
-  return runtime;
+function createServer(arg1, arg2) {
+  const requestListener = typeof arg1 === "function" ? arg1 : arg2;
+  return new Server(requestListener);
 }
+
+// src/server/http/index.ts
 var http_default = {
   createServer,
   request,