elit 3.6.6 → 3.6.8

package/dist/wss.js

@@ -27,10 +27,10 @@
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/runtime.ts
+  // src/shares/runtime.ts
   var runtime, isNode, isBun, isDeno;
   var init_runtime = __esm({
-    "src/runtime.ts"() {
+    "src/shares/runtime.ts"() {
       "use strict";
       runtime = (() => {
         if (typeof Deno !== "undefined") return "deno";
@@ -43,25 +43,78 @@
     }
   });
 
-  // 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
-  });
-  function queueCallback(callback) {
+  // src/server/http/utils.ts
+  function queueCallback2(callback) {
     if (callback) queueMicrotask(callback);
   }
+  function getRequestPath2(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) {
@@ -79,76 +132,110 @@
   function emitListeningWithCallback(server, callback) {
     server._listening = true;
     server.emit("listening");
-    queueCallback(callback);
+    queueCallback2(callback);
   }
   function closeAndEmit(server, callback) {
     server._listening = false;
     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/server/http/agent.ts
+  var Agent;
+  var init_agent = __esm({
+    "src/server/http/agent.ts"() {
+      "use strict";
+      Agent = 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, ClientRequest;
+  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();
+      ClientRequest = 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));
+          queueCallback2(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) {
+            queueCallback2(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));
+          }
+          queueCallback2(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 = getRequestPath2(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 = getRequestPath2(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 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;
+  }
+  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;
@@ -351,7 +532,7 @@
             return this._nodeRes.write(chunk, encoding, callback);
           }
           this._body += chunk;
-          queueCallback(callback);
+          queueCallback2(callback);
           return true;
         }
         end(chunk, encoding, callback) {
@@ -384,14 +565,13 @@
             if (this._resolve) {
               this._resolve(response);
             }
-            queueCallback(callback);
+            queueCallback2(callback);
           }
           return this;
         }
         _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 getRuntime3() {
+    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,229 +1006,62 @@
           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;
-        }
-      };
-      http_default = {
-        createServer,
-        request,
-        get,
-        Server,
-        IncomingMessage,
-        ServerResponse,
-        Agent,
-        ClientRequest,
-        METHODS,
-        STATUS_CODES,
-        getRuntime
-      };
     }
   });
 
-  // src/wss.ts
-  var import_events3 = __require("events");
-
-  // src/https.ts
-  var import_events = __require("events");
-  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());
-  }
-  function loadHttpClasses() {
-    const httpModule = (init_http(), __toCommonJS(http_exports));
-    return {
-      IncomingMessage: httpModule.IncomingMessage,
-      ServerResponse: httpModule.ServerResponse
-    };
-  }
-  var https2;
-  var Server2 = class extends import_events.EventEmitter {
-    constructor(options, requestListener) {
-      super();
-      this._listening = false;
-      this.options = options;
-      this.requestListener = requestListener;
-    }
-    listen(...args) {
-      let port = 3e3;
-      let hostname = "0.0.0.0";
-      let callback;
-      const firstArg = args[0];
-      if (typeof firstArg === "number") {
-        port = firstArg;
-        const secondArg = args[1];
-        if (typeof secondArg === "string") {
-          hostname = secondArg;
-          callback = args[2] || args[3];
-        } else if (typeof secondArg === "function") {
-          callback = secondArg;
-        }
-      } else if (firstArg && typeof firstArg === "object") {
-        port = firstArg.port || 3e3;
-        hostname = firstArg.hostname || "0.0.0.0";
-        callback = args[1];
-      }
-      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);
-          if (self.requestListener) {
-            self.requestListener(incomingMessage, serverResponse);
-          } else {
-            self.emit("request", incomingMessage, serverResponse);
-          }
-        });
-        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;
-          this.emit("close");
-        });
-      } else if (isBun) {
-        const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
-        const tlsOptions = {
-          port,
-          hostname,
-          fetch: (req) => {
-            return new Promise((resolve) => {
-              const incomingMessage = new IncomingMessage2(req);
-              const serverResponse = new ServerResponse2();
-              serverResponse._setResolver(resolve);
-              if (self.requestListener) {
-                self.requestListener(incomingMessage, serverResponse);
-              } else {
-                self.emit("request", incomingMessage, serverResponse);
-              }
-            });
-          },
-          error: (error) => {
-            this.emit("error", error);
-            return createErrorResponse2();
-          }
-        };
-        if (this.options.key || this.options.cert) {
-          tlsOptions.tls = {
-            key: this.options.key,
-            cert: this.options.cert,
-            ca: this.options.ca,
-            passphrase: this.options.passphrase
-          };
-        } else if (this.options.tls) {
-          tlsOptions.tls = this.options.tls;
-        }
-        this.nativeServer = Bun.serve(tlsOptions);
-        emitListeningWithCallback2(this, callback);
-      } else if (isDeno) {
-        const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
-        const serveOptions = {
-          port,
-          hostname,
-          handler: (req) => {
-            return new Promise((resolve) => {
-              const incomingMessage = new IncomingMessage2(req);
-              const serverResponse = new ServerResponse2();
-              serverResponse._setResolver(resolve);
-              if (self.requestListener) {
-                self.requestListener(incomingMessage, serverResponse);
-              } else {
-                self.emit("request", incomingMessage, serverResponse);
-              }
-            });
-          },
-          onError: (error) => {
-            this.emit("error", error);
-            return createErrorResponse2();
-          }
-        };
-        if (this.options.key && this.options.cert) {
-          serveOptions.cert = this.options.cert;
-          serveOptions.key = this.options.key;
-        }
-        this.nativeServer = Deno.serve(serveOptions);
-        emitListeningWithCallback2(this, callback);
-      }
-      return this;
-    }
-    close(callback) {
-      if (!this.nativeServer) {
-        if (callback) queueMicrotask(() => callback());
-        return this;
-      }
-      if (isNode) {
-        this.nativeServer.close(callback);
-      } else if (isBun) {
-        this.nativeServer.stop();
-        closeAndEmit2(this, callback);
-      } else if (isDeno) {
-        this.nativeServer.shutdown();
-        closeAndEmit2(this, callback);
-      }
-      return this;
-    }
-    address() {
-      if (!this.nativeServer) return null;
-      if (isNode) {
-        const addr = this.nativeServer.address();
-        if (!addr) return null;
-        if (typeof addr === "string") {
-          return createAddress2(0, addr, "unix");
-        }
-        return addr;
-      } else if (isBun) {
-        return createAddress2(this.nativeServer.port, this.nativeServer.hostname);
-      } else if (isDeno) {
-        const addr = this.nativeServer.addr;
-        return createAddress2(addr.port, addr.hostname);
-      }
-      return null;
-    }
-    get listening() {
-      return this._listening;
+  // src/server/http/index.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: () => getRuntime3,
+    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,
+        get,
+        Server,
+        IncomingMessage,
+        ServerResponse,
+        Agent,
+        ClientRequest,
+        METHODS,
+        STATUS_CODES,
+        getRuntime: getRuntime3
+      };
     }
-  };
-  function createServer2(options, requestListener) {
-    return new Server2(options, requestListener);
-  }
+  });
 
-  // src/ws.ts
-  var import_events2 = __require("events");
-  init_runtime();
+  // src/server/ws/constants.ts
   var ReadyState = /* @__PURE__ */ ((ReadyState2) => {
     ReadyState2[ReadyState2["CONNECTING"] = 0] = "CONNECTING";
     ReadyState2[ReadyState2["OPEN"] = 1] = "OPEN";
@@ -920,7 +1086,14 @@
     BAD_GATEWAY: 1014,
     TLS_HANDSHAKE_FAIL: 1015
   };
-  function queueCallback3(callback, error) {
+
+  // src/server/ws/server.ts
+  var import_events2 = __require("events");
+  init_runtime();
+
+  // src/server/ws/utils.ts
+  init_runtime();
+  function queueCallback(callback, error) {
     if (callback) {
       queueMicrotask(() => callback(error));
     }
@@ -935,7 +1108,74 @@
     const [pathname = "/"] = (url || "/").split("?");
     return pathname || "/";
   }
-  var WebSocket = class extends import_events2.EventEmitter {
+  function isIgnorableConnectionError(error) {
+    const errorCode = error?.code;
+    return errorCode === "ECONNABORTED" || errorCode === "ECONNRESET" || errorCode === "EPIPE";
+  }
+  function coerceBunMessage(message) {
+    const isBinary = typeof message !== "string";
+    const payload = typeof message === "string" ? message : message instanceof ArrayBuffer ? Buffer.from(message) : ArrayBuffer.isView(message) ? Buffer.from(message.buffer, message.byteOffset, message.byteLength) : Buffer.from(String(message));
+    return { payload, isBinary };
+  }
+  function parseFrame(data) {
+    if (data.length < 2) {
+      return null;
+    }
+    const firstByte = data[0];
+    const secondByte = data[1];
+    const opcode = firstByte & 15;
+    const isMasked = (secondByte & 128) === 128;
+    let payloadLength = secondByte & 127;
+    let offset = 2;
+    if (payloadLength === 126) {
+      payloadLength = data.readUInt16BE(2);
+      offset = 4;
+    } else if (payloadLength === 127) {
+      payloadLength = Number(data.readBigUInt64BE(2));
+      offset = 10;
+    }
+    let payload = data.subarray(offset);
+    if (isMasked) {
+      const maskKey = data.subarray(offset, offset + 4);
+      payload = data.subarray(offset + 4, offset + 4 + payloadLength);
+      for (let index = 0; index < payload.length; index += 1) {
+        payload[index] ^= maskKey[index % 4];
+      }
+    }
+    if (opcode === 1) {
+      return payload.toString("utf8");
+    }
+    return null;
+  }
+  function createFrame(data) {
+    const payload = typeof data === "string" ? Buffer.from(data) : data;
+    const payloadLength = Buffer.isBuffer(payload) ? payload.length : 0;
+    let frame;
+    let offset = 2;
+    if (payloadLength < 126) {
+      frame = Buffer.allocUnsafe(2 + payloadLength);
+      frame[1] = payloadLength;
+    } else if (payloadLength < 65536) {
+      frame = Buffer.allocUnsafe(4 + payloadLength);
+      frame[1] = 126;
+      frame.writeUInt16BE(payloadLength, 2);
+      offset = 4;
+    } else {
+      frame = Buffer.allocUnsafe(10 + payloadLength);
+      frame[1] = 127;
+      frame.writeBigUInt64BE(BigInt(payloadLength), 2);
+      offset = 10;
+    }
+    frame[0] = 129;
+    if (Buffer.isBuffer(payload)) {
+      payload.copy(frame, offset);
+    }
+    return frame;
+  }
+
+  // src/server/ws/websocket.ts
+  var import_events = __require("events");
+  var WebSocket = class extends import_events.EventEmitter {
     constructor(address, protocols, _options) {
       super();
       this.readyState = 0 /* CONNECTING */;
@@ -965,22 +1205,23 @@
       };
     }
     /**
-     * Send data through WebSocket
+     * Send data through WebSocket.
      */
     send(data, options, callback) {
       const cb = typeof options === "function" ? options : callback;
       if (this.readyState !== 1 /* OPEN */) {
-        return queueCallback3(cb, new Error("WebSocket is not open"));
+        queueCallback(cb, new Error("WebSocket is not open"));
+        return;
       }
       try {
         this._socket.send(data);
-        queueCallback3(cb);
+        queueCallback(cb);
       } catch (error) {
-        queueCallback3(cb, error);
+        queueCallback(cb, error);
       }
     }
     /**
-     * Close the WebSocket connection
+     * Close the WebSocket connection.
      */
     close(code, reason) {
       if (this.readyState === 3 /* CLOSED */ || this.readyState === 2 /* CLOSING */) {
@@ -990,41 +1231,43 @@
       this._socket.close(code, typeof reason === "string" ? reason : reason?.toString());
     }
     /**
-     * Pause the socket (no-op for native WebSocket)
+     * Pause the socket (no-op for native WebSocket).
      */
     pause() {
     }
     /**
-     * Resume the socket (no-op for native WebSocket)
+     * Resume the socket (no-op for native WebSocket).
      */
     resume() {
     }
     /**
-     * Send a ping frame (no-op for native WebSocket)
+     * Send a ping frame (no-op for native WebSocket).
      */
     ping(_data, _mask, callback) {
-      queueCallback3(callback);
+      queueCallback(callback);
     }
     /**
-     * Send a pong frame (no-op for native WebSocket)
+     * Send a pong frame (no-op for native WebSocket).
      */
     pong(_data, _mask, callback) {
-      queueCallback3(callback);
+      queueCallback(callback);
     }
     /**
-     * Terminate the connection
+     * Terminate the connection.
      */
     terminate() {
       this._socket.close();
       this.readyState = 3 /* CLOSED */;
     }
     /**
-     * Get buffered amount
+     * Get buffered amount.
      */
     get bufferedAmount() {
       return this._socket.bufferedAmount || 0;
     }
   };
+
+  // src/server/ws/server.ts
   var WebSocketServer = class extends import_events2.EventEmitter {
     constructor(options, callback) {
       super();
@@ -1036,8 +1279,7 @@
         if (options?.server) {
           this._httpServer = options.server;
           this._setupUpgradeHandler();
-        } else if (options?.noServer) {
-        } else {
+        } else if (!options?.noServer) {
           const http2 = __require("http");
           this._httpServer = http2.createServer();
           this._ownsHttpServer = true;
@@ -1051,30 +1293,30 @@
           this._httpServer = options.server;
           options.server.registerWebSocketServer(this);
         }
-        queueCallback3(callback);
+        queueCallback(callback);
       } else {
-        queueCallback3(callback);
+        queueCallback(callback);
       }
     }
     _setupUpgradeHandler() {
-      this._httpServer.on("upgrade", (request2, socket, head) => {
-        const requestPath = getRequestPath(request2.url);
+      this._httpServer.on("upgrade", (request3, socket, head) => {
+        const requestPath = getRequestPath(request3.url);
         console.log("[WebSocket] Upgrade request:", requestPath, "Expected:", this.path || "(any)");
         if (this.path && requestPath !== this.path) {
           console.log("[WebSocket] Path mismatch, ignoring");
           return;
         }
-        this.handleUpgrade(request2, socket, head, (client) => {
+        this.handleUpgrade(request3, socket, head, (client) => {
           console.log("[WebSocket] Client connected");
-          this.emit("connection", client, request2);
+          this.emit("connection", client, request3);
         });
       });
     }
     /**
-     * Handle HTTP upgrade for WebSocket
+     * Handle HTTP upgrade for WebSocket.
      */
-    handleUpgrade(request2, socket, _head, callback) {
-      const key = request2.headers["sec-websocket-key"];
+    handleUpgrade(request3, socket, _head, callback) {
+      const key = request3.headers["sec-websocket-key"];
       if (!key) {
         socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
         return;
@@ -1110,7 +1352,7 @@
       client._socket = socket;
       socket.on("data", (data) => {
         try {
-          const message = this._parseFrame(data);
+          const message = parseFrame(data);
           if (message) {
             client.emit("message", message, false);
           }
@@ -1123,36 +1365,34 @@
         client.emit("close", CLOSE_CODES.NORMAL, "");
       });
       socket.on("error", (error) => {
-        const errorCode = error.code;
-        if (errorCode === "ECONNABORTED" || errorCode === "ECONNRESET" || errorCode === "EPIPE") {
+        if (isIgnorableConnectionError(error)) {
           return;
         }
         client.emit("error", error);
       });
       client.send = (data, _options, callback) => {
         if (!socket.writable || client.readyState !== 1 /* OPEN */) {
-          const err = new Error("WebSocket is not open");
-          err.code = "WS_NOT_OPEN";
-          queueCallback3(callback, err);
+          const error = new Error("WebSocket is not open");
+          error.code = "WS_NOT_OPEN";
+          queueCallback(callback, error);
           return;
         }
         try {
-          const frame = this._createFrame(data);
-          socket.write(frame, (err) => {
-            if (err) {
-              const errorCode = err.code;
-              if (errorCode !== "ECONNABORTED" && errorCode !== "ECONNRESET" && errorCode !== "EPIPE") {
-                queueCallback3(callback, err);
-              } else {
-                client.readyState = 3 /* CLOSED */;
-                queueCallback3(callback);
-              }
-            } else {
-              queueCallback3(callback);
+          const frame = createFrame(data);
+          socket.write(frame, (error) => {
+            if (!error) {
+              queueCallback(callback);
+              return;
             }
+            if (isIgnorableConnectionError(error)) {
+              client.readyState = 3 /* CLOSED */;
+              queueCallback(callback);
+              return;
+            }
+            queueCallback(callback, error);
           });
         } catch (error) {
-          queueCallback3(callback, error);
+          queueCallback(callback, error);
         }
       };
       client.close = (_code, _reason) => {
@@ -1172,14 +1412,14 @@
       client._socket = socket;
       client.send = (data, _options, callback) => {
         if (client.readyState !== 1 /* OPEN */) {
-          queueCallback3(callback, new Error("WebSocket is not open"));
+          queueCallback(callback, new Error("WebSocket is not open"));
           return;
         }
         try {
           socket.send(data);
-          queueCallback3(callback);
+          queueCallback(callback);
         } catch (error) {
-          queueCallback3(callback, error);
+          queueCallback(callback, error);
         }
       };
       client.close = (code, reason) => {
@@ -1187,7 +1427,7 @@
           return;
         }
         client.readyState = 2 /* CLOSING */;
-        socket.close(code ?? CLOSE_CODES.NORMAL, reason);
+        socket.close(code ?? CLOSE_CODES.NORMAL, typeof reason === "string" ? reason : reason?.toString());
       };
       client.terminate = () => {
         socket.close();
@@ -1195,7 +1435,7 @@
       };
       return client;
     }
-    _handleBunOpen(socket, request2 = {}) {
+    _handleBunOpen(socket, request3 = {}) {
       const client = this._createClientFromBunSocket(socket);
       if (socket.data) {
         socket.data.client = client;
@@ -1207,9 +1447,9 @@
         });
       }
       const incomingRequest = {
-        url: request2.url || this.path,
-        headers: request2.headers || {},
-        socket: request2.socket || { remoteAddress: void 0 }
+        url: request3.url || this.path,
+        headers: request3.headers || {},
+        socket: request3.socket || { remoteAddress: void 0 }
       };
       this.emit("connection", client, incomingRequest);
     }
@@ -1218,8 +1458,7 @@
       if (!client) {
         return;
       }
-      const isBinary = typeof message !== "string";
-      const payload = typeof message === "string" ? message : message instanceof ArrayBuffer ? Buffer.from(message) : ArrayBuffer.isView(message) ? Buffer.from(message.buffer, message.byteOffset, message.byteLength) : Buffer.from(String(message));
+      const { payload, isBinary } = coerceBunMessage(message);
       client.emit("message", payload, isBinary);
     }
     _handleBunClose(socket, code, reason) {
@@ -1231,98 +1470,290 @@
       client.emit("close", code, typeof reason === "string" ? reason : reason?.toString() || "");
       this.clients.delete(client);
     }
-    _parseFrame(data) {
-      if (data.length < 2) return null;
-      const firstByte = data[0];
-      const secondByte = data[1];
-      const opcode = firstByte & 15;
-      const isMasked = (secondByte & 128) === 128;
-      let payloadLength = secondByte & 127;
-      let offset = 2;
-      if (payloadLength === 126) {
-        payloadLength = data.readUInt16BE(2);
-        offset = 4;
-      } else if (payloadLength === 127) {
-        payloadLength = Number(data.readBigUInt64BE(2));
-        offset = 10;
-      }
-      let payload = data.subarray(offset);
-      if (isMasked) {
-        const maskKey = data.subarray(offset, offset + 4);
-        payload = data.subarray(offset + 4, offset + 4 + payloadLength);
-        for (let i = 0; i < payload.length; i++) {
-          payload[i] ^= maskKey[i % 4];
-        }
-      }
-      if (opcode === 1) {
-        return payload.toString("utf8");
-      }
-      return null;
-    }
-    _createFrame(data) {
-      const payload = typeof data === "string" ? Buffer.from(data) : data;
-      const payloadLength = Buffer.isBuffer(payload) ? payload.length : 0;
-      let frame;
-      let offset = 2;
-      if (payloadLength < 126) {
-        frame = Buffer.allocUnsafe(2 + payloadLength);
-        frame[1] = payloadLength;
-      } else if (payloadLength < 65536) {
-        frame = Buffer.allocUnsafe(4 + payloadLength);
-        frame[1] = 126;
-        frame.writeUInt16BE(payloadLength, 2);
-        offset = 4;
-      } else {
-        frame = Buffer.allocUnsafe(10 + payloadLength);
-        frame[1] = 127;
-        frame.writeBigUInt64BE(BigInt(payloadLength), 2);
-        offset = 10;
-      }
-      frame[0] = 129;
-      if (Buffer.isBuffer(payload)) {
-        payload.copy(frame, offset);
-      }
-      return frame;
-    }
     /**
-     * Close the server
+     * Close the server.
      */
     close(callback) {
       this.clients.forEach((client) => client.close());
       this.clients.clear();
       if (this._httpServer && this._ownsHttpServer) {
         this._httpServer.close(callback);
-      } else {
-        if (runtime === "bun" && this._httpServer?.unregisterWebSocketServer) {
-          this._httpServer.unregisterWebSocketServer(this);
-        }
-        this.emit("close");
-        queueCallback3(callback);
+        return;
       }
+      if (runtime === "bun" && this._httpServer?.unregisterWebSocketServer) {
+        this._httpServer.unregisterWebSocketServer(this);
+      }
+      this.emit("close");
+      queueCallback(callback);
     }
     /**
-     * Check if server should handle request
+     * Check if server should handle request.
      */
-    shouldHandle(request2) {
-      if (this.path && getRequestPath(request2.url) !== this.path) {
+    shouldHandle(request3) {
+      if (this.path && getRequestPath(request3.url) !== this.path) {
         return false;
       }
       return true;
     }
     /**
-     * Get server address
+     * Get server address.
      */
     address() {
-      if (this._httpServer && this._httpServer.address) {
+      if (this._httpServer?.address) {
         return this._httpServer.address();
       }
       return null;
     }
   };
 
-  // src/wss.ts
+  // src/server/ws/runtime.ts
+  init_runtime();
+
+  // src/server/wss/client.ts
+  var WSSClient = class extends WebSocket {
+    constructor(address, protocols, options) {
+      const urlString = typeof address === "string" ? address : address.toString();
+      const secureUrl = urlString.replace(/^ws:\/\//i, "wss://");
+      super(secureUrl, protocols, options);
+    }
+  };
+  function createWSSClient(address, protocols, options) {
+    return new WSSClient(address, protocols, options);
+  }
+
+  // src/server/wss/runtime.ts
+  init_runtime();
+  function getRuntime2() {
+    return runtime;
+  }
+
+  // src/server/wss/server.ts
+  var import_events3 = __require("events");
+
+  // src/server/https/client-request.ts
+  var import_node_events = __require("events");
+  init_utils();
+
+  // src/server/https/request-api.ts
+  init_runtime();
+
+  // src/server/https/http-classes.ts
+  function loadHttpClasses() {
+    const httpModule = (init_http(), __toCommonJS(http_exports));
+    return {
+      IncomingMessage: httpModule.IncomingMessage,
+      ServerResponse: httpModule.ServerResponse
+    };
+  }
+
+  // src/server/https/node-modules.ts
+  init_runtime();
+  var https2;
+  if (isNode && typeof process !== "undefined") {
+    try {
+      https2 = __require("https");
+    } catch {
+      https2 = __require("https");
+    }
+  }
+
+  // src/server/https/runtime.ts
+  init_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") {
+        port = firstArg;
+        const secondArg = args[1];
+        if (typeof secondArg === "string") {
+          hostname = secondArg;
+          callback = args[2] || args[3];
+        } else if (typeof secondArg === "function") {
+          callback = secondArg;
+        }
+      } 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();
+        this.nativeServer = https2.createServer(this.options, (req, res) => {
+          const incomingMessage = new IncomingMessage2(req);
+          const serverResponse = new ServerResponse2(incomingMessage, res);
+          if (self.requestListener) {
+            self.requestListener(incomingMessage, serverResponse);
+          } else {
+            self.emit("request", incomingMessage, serverResponse);
+          }
+        });
+        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;
+          this.emit("close");
+        });
+      } else if (isBun) {
+        const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
+        const tlsOptions = {
+          port,
+          hostname,
+          fetch: (req) => {
+            return new Promise((resolve) => {
+              const incomingMessage = new IncomingMessage2(req);
+              const serverResponse = new ServerResponse2();
+              serverResponse._setResolver(resolve);
+              if (self.requestListener) {
+                self.requestListener(incomingMessage, serverResponse);
+              } else {
+                self.emit("request", incomingMessage, serverResponse);
+              }
+            });
+          },
+          error: (error) => {
+            this.emit("error", error);
+            return createErrorResponse();
+          }
+        };
+        if (this.options.key || this.options.cert) {
+          tlsOptions.tls = {
+            key: this.options.key,
+            cert: this.options.cert,
+            ca: this.options.ca,
+            passphrase: this.options.passphrase
+          };
+        } else if (this.options.tls) {
+          tlsOptions.tls = this.options.tls;
+        }
+        this.nativeServer = Bun.serve(tlsOptions);
+        emitListeningWithCallback(this, callback);
+      } else if (isDeno) {
+        const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
+        const serveOptions = {
+          port,
+          hostname,
+          handler: (req) => {
+            return new Promise((resolve) => {
+              const incomingMessage = new IncomingMessage2(req);
+              const serverResponse = new ServerResponse2();
+              serverResponse._setResolver(resolve);
+              if (self.requestListener) {
+                self.requestListener(incomingMessage, serverResponse);
+              } else {
+                self.emit("request", incomingMessage, serverResponse);
+              }
+            });
+          },
+          onError: (error) => {
+            this.emit("error", error);
+            return createErrorResponse();
+          }
+        };
+        if (this.options.key && this.options.cert) {
+          serveOptions.cert = this.options.cert;
+          serveOptions.key = this.options.key;
+        }
+        this.nativeServer = Deno.serve(serveOptions);
+        emitListeningWithCallback(this, callback);
+      }
+      return this;
+    }
+    close(callback) {
+      if (!this.nativeServer) {
+        if (callback) queueCallback2(() => callback());
+        return this;
+      }
+      if (isNode) {
+        this.nativeServer.close(callback);
+      } else if (isBun) {
+        this.nativeServer.stop();
+        closeAndEmit(this, callback);
+      } else if (isDeno) {
+        this.nativeServer.shutdown();
+        closeAndEmit(this, callback);
+      }
+      return this;
+    }
+    address() {
+      if (!this.nativeServer) return null;
+      if (isNode) {
+        const addr = this.nativeServer.address();
+        if (!addr) return null;
+        if (typeof addr === "string") {
+          return createAddress(0, addr, "unix");
+        }
+        return addr;
+      }
+      if (isBun) {
+        return createAddress(this.nativeServer.port, this.nativeServer.hostname);
+      }
+      if (isDeno) {
+        const addr = this.nativeServer.addr;
+        return createAddress(addr.port, addr.hostname);
+      }
+      return null;
+    }
+    get listening() {
+      return this._listening;
+    }
+  };
+  function createServer2(options = {}, requestListener) {
+    return new Server2(options, requestListener);
+  }
+
+  // src/server/wss/server.ts
   init_runtime();
-  function queueCallback4(callback) {
+
+  // src/server/wss/utils.ts
+  function queueCallback3(callback) {
     if (callback) {
       queueMicrotask(callback);
     }
@@ -1339,15 +1770,10 @@
   }
   function emitCloseWithCallback(emitter, callback) {
     emitter.emit("close");
-    queueCallback4(callback);
+    queueCallback3(callback);
   }
-  var WSSClient = class extends WebSocket {
-    constructor(address, protocols, options) {
-      const urlString = typeof address === "string" ? address : address.toString();
-      const secureUrl = urlString.replace(/^ws:\/\//i, "wss://");
-      super(secureUrl, protocols, options);
-    }
-  };
+
+  // src/server/wss/server.ts
   var WSSServer = class extends import_events3.EventEmitter {
     constructor(options, callback) {
       super();
@@ -1360,7 +1786,7 @@
           this._setupServer(callback);
         } else if (options?.noServer) {
           this._wsServer = new WebSocketServer({ noServer: true });
-          queueCallback4(callback);
+          queueCallback3(callback);
         } else {
           this._httpsServer = createServer2(buildHttpsOptions(options));
           this._setupServer(callback);
@@ -1370,7 +1796,7 @@
         }
       } else {
         this._wsServer = new WebSocketServer(options);
-        queueCallback4(callback);
+        queueCallback3(callback);
       }
     }
     _setupServer(callback) {
@@ -1379,44 +1805,44 @@
         server: this._httpsServer,
         noServer: false
       });
-      this._wsServer.on("connection", (client, request2) => {
+      this._wsServer.on("connection", (client, request3) => {
         if (this.options.clientTracking !== false) {
           this.clients.add(client);
           client.on("close", () => {
             this.clients.delete(client);
           });
         }
-        this.emit("connection", client, request2);
+        this.emit("connection", client, request3);
       });
       this._wsServer.on("error", (error) => {
         this.emit("error", error);
       });
       if (!this.options?.port) {
-        queueCallback4(callback);
+        queueCallback3(callback);
       }
     }
     /**
-     * Handle HTTP upgrade for WebSocket
+     * Handle HTTP upgrade for WebSocket.
      */
-    handleUpgrade(request2, socket, head, callback) {
+    handleUpgrade(request3, socket, head, callback) {
       if (this._wsServer) {
-        this._wsServer.handleUpgrade(request2, socket, head, callback);
+        this._wsServer.handleUpgrade(request3, socket, head, callback);
       }
     }
     /**
-     * Check if server should handle request
+     * Check if server should handle request.
      */
-    shouldHandle(request2) {
+    shouldHandle(request3) {
       if (this._wsServer) {
-        return this._wsServer.shouldHandle(request2);
+        return this._wsServer.shouldHandle(request3);
       }
-      if (this.path && request2.url !== this.path) {
+      if (this.path && request3.url !== this.path) {
         return false;
       }
       return true;
     }
     /**
-     * Close the server
+     * Close the server.
      */
     close(callback) {
       this.clients.forEach((client) => client.close());
@@ -1429,17 +1855,19 @@
             emitCloseWithCallback(this, callback);
           }
         });
-      } else if (this._httpsServer) {
+        return;
+      }
+      if (this._httpsServer) {
         this._httpsServer.close(callback);
-      } else {
-        emitCloseWithCallback(this, callback);
+        return;
       }
+      emitCloseWithCallback(this, callback);
     }
     /**
-     * Get server address
+     * Get server address.
      */
     address() {
-      if (this._httpsServer && this._httpsServer.address) {
+      if (this._httpsServer?.address) {
         return this._httpsServer.address();
       }
       if (this._wsServer) {
@@ -1448,15 +1876,11 @@
       return null;
     }
   };
-  function createWSSClient(address, protocols, options) {
-    return new WSSClient(address, protocols, options);
-  }
   function createWSSServer(options, callback) {
     return new WSSServer(options, callback);
   }
-  function getRuntime2() {
-    return runtime;
-  }
+
+  // src/server/wss/index.ts
   var wss_default = {
     WSSClient,
     WSSServer,