elit 3.6.6 → 3.6.8

package/dist/http.js

@@ -7,23 +7,88 @@
     throw Error('Dynamic require of "' + x + '" is not supported');
   });
 
-  // src/http.ts
-  var import_node_events = __require("events");
+  // src/server/http/agent.ts
+  var Agent = class {
+    constructor(options) {
+      this.options = options;
+    }
+  };
 
-  // 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/client-request.ts
+  var import_node_events = __require("events");
 
-  // src/http.ts
+  // 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) {
@@ -48,17 +113,73 @@
     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",
@@ -126,13 +247,23 @@
     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;
@@ -143,14 +274,13 @@
         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));
@@ -161,14 +291,80 @@
       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;
@@ -301,7 +497,6 @@
     _setResolver(resolve) {
       this._resolve = resolve;
     }
-    // Express.js-like methods
     json(data, statusCode = 200) {
       if (!this.headersSent) {
         this.setHeader("Content-Type", "application/json");
@@ -325,7 +520,15 @@
       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();
@@ -338,9 +541,28 @@
     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") {
@@ -355,8 +577,10 @@
       } 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) => {
@@ -371,11 +595,19 @@
         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;
@@ -400,6 +632,8 @@
             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) => {
@@ -436,9 +670,9 @@
             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()
@@ -492,57 +726,148 @@
                   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;
     }
@@ -571,9 +896,11 @@
           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);
       }
@@ -583,70 +910,12 @@
       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,