elit 3.6.6 → 3.6.8

package/dist/https.js

@@ -27,41 +27,78 @@
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/runtime.ts
-  var runtime, isNode, isBun, isDeno;
-  var init_runtime = __esm({
-    "src/runtime.ts"() {
-      "use strict";
-      runtime = (() => {
-        if (typeof Deno !== "undefined") return "deno";
-        if (typeof Bun !== "undefined") return "bun";
-        return "node";
-      })();
-      isNode = runtime === "node";
-      isBun = runtime === "bun";
-      isDeno = runtime === "deno";
-    }
-  });
-
-  // src/http.ts
-  var http_exports = {};
-  __export(http_exports, {
-    Agent: () => Agent,
-    ClientRequest: () => ClientRequest,
-    IncomingMessage: () => IncomingMessage,
-    METHODS: () => METHODS,
-    STATUS_CODES: () => STATUS_CODES,
-    Server: () => Server,
-    ServerResponse: () => ServerResponse,
-    createServer: () => createServer,
-    default: () => http_default,
-    get: () => get,
-    getRuntime: () => getRuntime,
-    request: () => request
-  });
+  // 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) {
@@ -86,69 +123,119 @@
     server.emit("close");
     if (callback) queueMicrotask(() => callback());
   }
-  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);
+  var init_utils = __esm({
+    "src/server/http/utils.ts"() {
+      "use strict";
+    }
+  });
+
+  // src/shares/runtime.ts
+  var runtime, isNode, isBun, isDeno;
+  var init_runtime = __esm({
+    "src/shares/runtime.ts"() {
+      "use strict";
+      runtime = (() => {
+        if (typeof Deno !== "undefined") return "deno";
+        if (typeof Bun !== "undefined") return "bun";
+        return "node";
+      })();
+      isNode = runtime === "node";
+      isBun = runtime === "bun";
+      isDeno = runtime === "deno";
+    }
+  });
+
+  // src/server/http/agent.ts
+  var Agent2;
+  var init_agent = __esm({
+    "src/server/http/agent.ts"() {
+      "use strict";
+      Agent2 = class {
+        constructor(options) {
+          this.options = options;
         }
-      });
+      };
     }
-    return req;
-  }
-  function get(url, options, callback) {
-    return request(url, { ...options, method: "GET" }, callback);
-  }
-  function getRuntime() {
-    return runtime;
-  }
-  var import_node_events, http, https, METHODS, STATUS_CODES, IncomingMessage, ServerResponse, Server, ClientRequest, Agent, http_default;
-  var init_http = __esm({
-    "src/http.ts"() {
+  });
+
+  // src/server/http/client-request.ts
+  var import_node_events2, ClientRequest2;
+  var init_client_request = __esm({
+    "src/server/http/client-request.ts"() {
       "use strict";
-      import_node_events = __require("events");
-      init_runtime();
-      if (isNode && typeof process !== "undefined") {
-        try {
-          http = __require("http");
-          https = __require("https");
-        } catch (e) {
-          http = __require("http");
-          https = __require("https");
+      import_node_events2 = __require("events");
+      init_utils();
+      ClientRequest2 = class extends import_node_events2.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, STATUS_CODES;
+  var init_constants = __esm({
+    "src/server/http/constants.ts"() {
+      "use strict";
       METHODS = [
         "GET",
         "POST",
@@ -216,13 +303,30 @@
         510: "Not Extended",
         511: "Network Authentication Required"
       };
-      IncomingMessage = class extends import_node_events.EventEmitter {
-        constructor(req) {
+    }
+  });
+
+  // src/server/http/incoming-message.ts
+  var import_node_events3, IncomingMessage;
+  var init_incoming_message = __esm({
+    "src/server/http/incoming-message.ts"() {
+      "use strict";
+      import_node_events3 = __require("events");
+      init_utils();
+      IncomingMessage = class extends import_node_events3.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;
@@ -233,14 +337,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));
@@ -251,14 +354,92 @@
           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();
         }
       };
-      ServerResponse = class extends import_node_events.EventEmitter {
+    }
+  });
+
+  // src/server/http/node-modules.ts
+  var http, https;
+  var init_node_modules = __esm({
+    "src/server/http/node-modules.ts"() {
+      "use strict";
+      init_runtime();
+      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 ClientRequest2(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;
+  }
+  var init_request_api = __esm({
+    "src/server/http/request-api.ts"() {
+      "use strict";
+      init_runtime();
+      init_client_request();
+      init_incoming_message();
+      init_node_modules();
+    }
+  });
+
+  // src/server/http/response.ts
+  var import_node_events4, ServerResponse;
+  var init_response = __esm({
+    "src/server/http/response.ts"() {
+      "use strict";
+      import_node_events4 = __require("events");
+      init_runtime();
+      init_utils();
+      ServerResponse = class extends import_node_events4.EventEmitter {
         constructor(_req, nodeRes) {
           super();
           this.statusCode = 200;
@@ -391,7 +572,6 @@
         _setResolver(resolve) {
           this._resolve = resolve;
         }
-        // Express.js-like methods
         json(data, statusCode = 200) {
           if (!this.headersSent) {
             this.setHeader("Content-Type", "application/json");
@@ -415,7 +595,36 @@
           return this;
         }
       };
-      Server = class extends import_node_events.EventEmitter {
+    }
+  });
+
+  // src/server/http/runtime.ts
+  function getRuntime() {
+    return runtime;
+  }
+  var init_runtime2 = __esm({
+    "src/server/http/runtime.ts"() {
+      "use strict";
+      init_runtime();
+    }
+  });
+
+  // src/server/http/server-runtime.ts
+  function createServer(arg1, arg2) {
+    const requestListener = typeof arg1 === "function" ? arg1 : arg2;
+    return new Server(requestListener);
+  }
+  var import_node_events5, Server;
+  var init_server_runtime = __esm({
+    "src/server/http/server-runtime.ts"() {
+      "use strict";
+      import_node_events5 = __require("events");
+      init_runtime();
+      init_node_modules();
+      init_incoming_message();
+      init_response();
+      init_utils();
+      Server = class extends import_node_events5.EventEmitter {
         constructor(requestListener) {
           super();
           this._bunWebSocketServers = /* @__PURE__ */ new Set();
@@ -428,9 +637,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") {
@@ -445,8 +673,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) => {
@@ -461,11 +691,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;
@@ -490,6 +728,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) => {
@@ -526,9 +766,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()
@@ -582,57 +822,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;
         }
@@ -661,9 +992,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);
           }
@@ -673,22 +1006,45 @@
           return this._listening;
         }
       };
-      ClientRequest = class extends import_node_events.EventEmitter {
-        constructor(_url, _options = {}) {
-          super();
-        }
-        write(_chunk) {
-          return true;
-        }
-        end(callback) {
-          queueCallback(callback);
-        }
-      };
-      Agent = class {
-        constructor(options) {
-          this.options = options;
-        }
-      };
+    }
+  });
+
+  // src/server/http/index.ts
+  var http_exports = {};
+  __export(http_exports, {
+    Agent: () => Agent2,
+    ClientRequest: () => ClientRequest2,
+    IncomingMessage: () => IncomingMessage,
+    METHODS: () => METHODS,
+    STATUS_CODES: () => STATUS_CODES,
+    Server: () => Server,
+    ServerResponse: () => ServerResponse,
+    createServer: () => createServer,
+    default: () => http_default,
+    get: () => get,
+    getRuntime: () => getRuntime,
+    request: () => request
+  });
+  var http_default;
+  var init_http = __esm({
+    "src/server/http/index.ts"() {
+      "use strict";
+      init_agent();
+      init_client_request();
+      init_constants();
+      init_incoming_message();
+      init_request_api();
+      init_response();
+      init_runtime2();
+      init_server_runtime();
+      init_agent();
+      init_client_request();
+      init_constants();
+      init_incoming_message();
+      init_request_api();
+      init_response();
+      init_runtime2();
+      init_server_runtime();
       http_default = {
         createServer,
         request,
@@ -696,8 +1052,8 @@
         Server,
         IncomingMessage,
         ServerResponse,
-        Agent,
-        ClientRequest,
+        Agent: Agent2,
+        ClientRequest: ClientRequest2,
         METHODS,
         STATUS_CODES,
         getRuntime
@@ -705,28 +1061,83 @@
     }
   });
 
-  // src/https.ts
-  var import_events = __require("events");
+  // src/server/https/agent.ts
+  var Agent = class {
+    constructor(options) {
+      this.options = options;
+    }
+  };
+
+  // src/server/https/client-request.ts
+  var import_node_events = __require("events");
+  init_utils();
+  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 actualEncoding = typeof encoding === "string" ? encoding : void 0;
+        return this._nativeRequest.write(chunk, actualEncoding, callback);
+      }
+      this._bodyChunks.push(normalizeRequestBodyChunk(chunk, typeof encoding === "string" ? encoding : "utf8"));
+      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/https/request-api.ts
   init_runtime();
-  function queueCallback2(callback) {
-    if (callback) queueMicrotask(callback);
-  }
-  function createErrorResponse2() {
-    return new Response("Internal Server Error", { status: 500 });
-  }
-  function createAddress2(port, address, family = "IPv4") {
-    return { port, family, address };
-  }
-  function emitListeningWithCallback2(server, callback) {
-    server._listening = true;
-    server.emit("listening");
-    queueCallback2(callback);
-  }
-  function closeAndEmit2(server, callback) {
-    server._listening = false;
-    server.emit("close");
-    if (callback) queueMicrotask(() => callback());
-  }
+
+  // src/server/https/http-classes.ts
   function loadHttpClasses() {
     const httpModule = (init_http(), __toCommonJS(http_exports));
     return {
@@ -734,17 +1145,97 @@
       ServerResponse: httpModule.ServerResponse
     };
   }
+
+  // src/server/https/node-modules.ts
+  init_runtime();
   var https2;
-  var Server2 = class extends import_events.EventEmitter {
-    constructor(options, requestListener) {
+  if (isNode && typeof process !== "undefined") {
+    try {
+      https2 = __require("https");
+    } catch {
+      https2 = __require("https");
+    }
+  }
+
+  // src/server/https/request-api.ts
+  function request2(url, options, callback) {
+    const urlString = typeof url === "string" ? url : url.toString();
+    const req = new ClientRequest(urlString, options);
+    if (isNode) {
+      const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
+      const nodeReq = https2.request(urlString, {
+        method: options?.method || "GET",
+        headers: options?.headers,
+        timeout: options?.timeout,
+        signal: options?.signal
+      }, (res) => {
+        const incomingMessage = new IncomingMessage2(res);
+        if (callback) callback(incomingMessage);
+        req.emit("response", incomingMessage);
+      });
+      req._setNativeRequest(nodeReq);
+      nodeReq.on("error", (error) => req.emit("error", error));
+    } else {
+      const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
+      req._setExecutor(async (body) => {
+        const response = await fetch(urlString, {
+          method: options?.method || "GET",
+          headers: options?.headers,
+          body,
+          signal: options?.signal
+        });
+        const incomingMessage = new IncomingMessage2(response, options?.method || "GET");
+        if (callback) callback(incomingMessage);
+        req.emit("response", incomingMessage);
+      });
+    }
+    return req;
+  }
+  function get2(url, options, callback) {
+    const req = request2(url, { ...options, method: "GET" }, callback);
+    req.end();
+    return req;
+  }
+
+  // src/server/https/runtime.ts
+  init_runtime();
+  function getRuntime2() {
+    return runtime;
+  }
+
+  // src/server/https/server-runtime.ts
+  var import_node_events6 = __require("events");
+  init_runtime();
+  init_utils();
+  var Server2 = class extends import_node_events6.EventEmitter {
+    constructor(options = {}, requestListener) {
       super();
       this._listening = false;
       this.options = options;
       this.requestListener = requestListener;
     }
+    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") {
@@ -759,12 +1250,13 @@
       } 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) {
         const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
-        if (!https2) https2 = __require("https");
         this.nativeServer = https2.createServer(this.options, (req, res) => {
           const incomingMessage = new IncomingMessage2(req);
           const serverResponse = new ServerResponse2(incomingMessage, res);
@@ -774,11 +1266,19 @@
             self.emit("request", incomingMessage, serverResponse);
           }
         });
-        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;
@@ -803,7 +1303,7 @@
           },
           error: (error) => {
             this.emit("error", error);
-            return createErrorResponse2();
+            return createErrorResponse();
           }
         };
         if (this.options.key || this.options.cert) {
@@ -817,7 +1317,7 @@
           tlsOptions.tls = this.options.tls;
         }
         this.nativeServer = Bun.serve(tlsOptions);
-        emitListeningWithCallback2(this, callback);
+        emitListeningWithCallback(this, callback);
       } else if (isDeno) {
         const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
         const serveOptions = {
@@ -837,7 +1337,7 @@
           },
           onError: (error) => {
             this.emit("error", error);
-            return createErrorResponse2();
+            return createErrorResponse();
           }
         };
         if (this.options.key && this.options.cert) {
@@ -845,23 +1345,23 @@
           serveOptions.key = this.options.key;
         }
         this.nativeServer = Deno.serve(serveOptions);
-        emitListeningWithCallback2(this, callback);
+        emitListeningWithCallback(this, callback);
       }
       return this;
     }
     close(callback) {
       if (!this.nativeServer) {
-        if (callback) queueMicrotask(() => callback());
+        if (callback) queueCallback(() => callback());
         return this;
       }
       if (isNode) {
         this.nativeServer.close(callback);
       } else if (isBun) {
         this.nativeServer.stop();
-        closeAndEmit2(this, callback);
+        closeAndEmit(this, callback);
       } else if (isDeno) {
         this.nativeServer.shutdown();
-        closeAndEmit2(this, callback);
+        closeAndEmit(this, callback);
       }
       return this;
     }
@@ -871,14 +1371,16 @@
         const addr = this.nativeServer.address();
         if (!addr) return null;
         if (typeof addr === "string") {
-          return createAddress2(0, addr, "unix");
+          return createAddress(0, addr, "unix");
         }
         return addr;
-      } else if (isBun) {
-        return createAddress2(this.nativeServer.port, this.nativeServer.hostname);
-      } else if (isDeno) {
+      }
+      if (isBun) {
+        return createAddress(this.nativeServer.port, this.nativeServer.hostname);
+      }
+      if (isDeno) {
         const addr = this.nativeServer.addr;
-        return createAddress2(addr.port, addr.hostname);
+        return createAddress(addr.port, addr.hostname);
       }
       return null;
     }
@@ -886,78 +1388,18 @@
       return this._listening;
     }
   };
-  var ClientRequest2 = class extends import_events.EventEmitter {
-    constructor(_url, _options = {}) {
-      super();
-    }
-    write(_chunk) {
-      return true;
-    }
-    end(callback) {
-      queueCallback2(callback);
-    }
-  };
-  var Agent2 = class {
-    constructor(options) {
-      this.options = options;
-    }
-  };
-  function createServer2(options, requestListener) {
+  function createServer2(options = {}, requestListener) {
     return new Server2(options, requestListener);
   }
-  function request2(url, options, callback) {
-    const urlString = typeof url === "string" ? url : url.toString();
-    const req = new ClientRequest2(urlString, options);
-    if (isNode) {
-      const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
-      if (!https2) https2 = __require("https");
-      const nodeReq = https2.request(urlString, {
-        method: options?.method || "GET",
-        headers: options?.headers,
-        timeout: options?.timeout,
-        signal: options?.signal
-      }, (res) => {
-        const incomingMessage = new IncomingMessage2(res);
-        if (callback) callback(incomingMessage);
-        req.emit("response", incomingMessage);
-      });
-      nodeReq.on("error", (error) => req.emit("error", error));
-      nodeReq.end();
-    } else {
-      const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
-      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 IncomingMessage2(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 get2(url, options, callback) {
-    return request2(url, { ...options, method: "GET" }, callback);
-  }
-  function getRuntime2() {
-    return runtime;
-  }
+
+  // src/server/https/index.ts
   var https_default = {
     createServer: createServer2,
     request: request2,
     get: get2,
     Server: Server2,
-    Agent: Agent2,
-    ClientRequest: ClientRequest2,
+    Agent,
+    ClientRequest,
     getRuntime: getRuntime2
   };
 })();