@coderbuzz/ken 0.1.0

package/dist/node-JLUTIPEN.js

@@ -0,0 +1,816 @@
+import {
+  BaseContext
+} from "./chunk-2MK26YDD.js";
+import {
+  EMPTY_PARAMS,
+  PubSubHub,
+  Router,
+  WS_DEFAULTS,
+  WsReadyState,
+  createExecutor,
+  createNotFoundExecutor,
+  toResponse
+} from "./chunk-DPU3PBLP.js";
+
+// src/runtime/node.ts
+import { createServer } from "http";
+
+// src/context/node.ts
+var NodeContext = class extends BaseContext {
+  req;
+  _url;
+  _bodyBuffer = null;
+  constructor(req, url, params = EMPTY_PARAMS, getRemoteInfo, schema) {
+    super(params, getRemoteInfo, schema);
+    this.req = req;
+    this._url = url;
+  }
+  get url() {
+    return this._url;
+  }
+  get method() {
+    return this.req.method || "GET";
+  }
+  get body() {
+    return this.req;
+  }
+  _getRawHeaders() {
+    return this.req.headers;
+  }
+  _getRawUrl() {
+    return this._url;
+  }
+  /**
+   * Lazily parses and validates headers.
+   */
+  get headers() {
+    let cached = this._headers;
+    if (cached !== null) return cached;
+    const schema = this._schema?.headers;
+    const nodeHeaders = this.req.headers;
+    if (schema !== void 0) {
+      const result = {};
+      for (const key in schema) {
+        const validator = schema[key];
+        const value = nodeHeaders[key.toLowerCase()];
+        result[key] = validator(Array.isArray(value) ? value[0] : value || "");
+      }
+      this._headers = result;
+      return result;
+    }
+    const h = {};
+    for (const key in nodeHeaders) {
+      const value = nodeHeaders[key];
+      h[key] = Array.isArray(value) ? value[0] : value || "";
+    }
+    this._headers = h;
+    return h;
+  }
+  /**
+   * Read body buffer from IncomingMessage stream
+   */
+  async _readBody() {
+    if (this._bodyBuffer !== null) return this._bodyBuffer;
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      this.req.on("data", (chunk) => chunks.push(chunk));
+      this.req.on("end", () => {
+        this._bodyBuffer = Buffer.concat(chunks);
+        resolve(this._bodyBuffer);
+      });
+      this.req.on("error", reject);
+    });
+  }
+  /**
+   * Lazily parses and validates JSON body.
+   */
+  get json() {
+    if (this._json) return this._json;
+    const validator = this._schema?.json;
+    if (validator) {
+      this._json = (async () => {
+        const buffer = await this._readBody();
+        const data = JSON.parse(buffer.toString("utf8"));
+        try {
+          return validator(data);
+        } catch (err) {
+          throw new Error(`JSON Body validation failed: ${err.message}`);
+        }
+      })();
+    } else {
+      this._json = (async () => {
+        try {
+          const buffer = await this._readBody();
+          return JSON.parse(buffer.toString("utf8"));
+        } catch {
+          return null;
+        }
+      })();
+    }
+    return this._json;
+  }
+  /**
+   * Lazily parses and validates text body.
+   */
+  get text() {
+    if (this._text) return this._text;
+    const validator = this._schema?.text;
+    if (validator) {
+      this._text = (async () => {
+        const buffer = await this._readBody();
+        const data = buffer.toString("utf8");
+        try {
+          return validator(data);
+        } catch (err) {
+          throw new Error(`Text Body validation failed: ${err.message}`);
+        }
+      })();
+    } else {
+      this._text = (async () => {
+        const buffer = await this._readBody();
+        return buffer.toString("utf8");
+      })();
+    }
+    return this._text;
+  }
+  /**
+   * Lazily parses and validates form body.
+   * Supports both application/x-www-form-urlencoded and multipart/form-data
+   */
+  get form() {
+    if (this._form) return this._form;
+    const schema = this._schema?.form;
+    this._form = (async () => {
+      const buffer = await this._readBody();
+      const contentType = this.req.headers["content-type"] || "";
+      if (contentType.startsWith("multipart/form-data")) {
+        const protocol = this.req.socket.encrypted ? "https:" : "http:";
+        const host = this.req.headers.host || "localhost";
+        const fullUrl = `${protocol}//${host}${this._url}`;
+        const headers = new Headers();
+        for (const key in this.req.headers) {
+          const value = this.req.headers[key];
+          if (value) {
+            headers.set(key, Array.isArray(value) ? value[0] : value);
+          }
+        }
+        const request = new Request(fullUrl, {
+          method: this.method,
+          headers,
+          body: new Uint8Array(buffer),
+          // @ts-ignore - duplex is needed for streaming
+          duplex: "half"
+        });
+        const formData2 = await request.formData();
+        if (schema) {
+          const result = {};
+          for (const key in schema) {
+            try {
+              result[key] = schema[key](formData2.get(key));
+            } catch (err) {
+              throw new Error(`Form Body validation failed for "${key}": ${err.message}`);
+            }
+          }
+          return result;
+        }
+        return formData2;
+      }
+      const text = buffer.toString("utf8");
+      const formData = /* @__PURE__ */ new Map();
+      const pairs = text.split("&");
+      for (const pair of pairs) {
+        const [key, value] = pair.split("=");
+        if (key) {
+          formData.set(
+            decodeURIComponent(key),
+            value ? decodeURIComponent(value.replace(/\+/g, " ")) : ""
+          );
+        }
+      }
+      if (schema) {
+        const result = {};
+        for (const key in schema) {
+          try {
+            result[key] = schema[key](formData.get(key) ?? null);
+          } catch (err) {
+            throw new Error(`Form Body validation failed for "${key}": ${err.message}`);
+          }
+        }
+        return result;
+      }
+      return formData;
+    })();
+    return this._form;
+  }
+};
+
+// src/ws/node.ts
+import { createHash } from "crypto";
+var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var OPCODE_CONTINUATION = 0;
+var OPCODE_TEXT = 1;
+var OPCODE_BINARY = 2;
+var OPCODE_CLOSE = 8;
+var OPCODE_PING = 9;
+var OPCODE_PONG = 10;
+var FIN_BIT = 128;
+var MASK_BIT = 128;
+var OPCODE_MASK = 15;
+var LENGTH_MASK = 127;
+function unmaskPayload(payload, mask) {
+  const len = payload.length;
+  for (let i = 0; i < len; i++) {
+    payload[i] ^= mask[i & 3];
+  }
+}
+function createFrame(opcode, payload, fin = true) {
+  const payloadLen = payload.length;
+  let headerLen;
+  let extendedOffset;
+  if (payloadLen < 126) {
+    headerLen = 2;
+    extendedOffset = -1;
+  } else if (payloadLen < 65536) {
+    headerLen = 4;
+    extendedOffset = 2;
+  } else {
+    headerLen = 10;
+    extendedOffset = 2;
+  }
+  const frame = Buffer.allocUnsafe(headerLen + payloadLen);
+  frame[0] = (fin ? FIN_BIT : 0) | opcode;
+  if (payloadLen < 126) {
+    frame[1] = payloadLen;
+  } else if (payloadLen < 65536) {
+    frame[1] = 126;
+    frame.writeUInt16BE(payloadLen, extendedOffset);
+  } else {
+    frame[1] = 127;
+    frame.writeUInt32BE(0, extendedOffset);
+    frame.writeUInt32BE(payloadLen, extendedOffset + 4);
+  }
+  if (payloadLen > 0) {
+    if (Buffer.isBuffer(payload)) {
+      payload.copy(frame, headerLen);
+    } else {
+      frame.set(payload, headerLen);
+    }
+  }
+  return frame;
+}
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (typeof data === "string") return Buffer.from(data);
+  if (data instanceof ArrayBuffer) return Buffer.from(data);
+  if (data instanceof Uint8Array) return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  return Buffer.from(String(data));
+}
+var NodeWsPeer = class {
+  data;
+  readyState = WsReadyState.OPEN;
+  remoteAddress;
+  socket;
+  hub;
+  handler;
+  opts;
+  // Frame parsing state
+  frameBuffer = null;
+  fragments = [];
+  fragmentOpcode = 0;
+  // Ping/pong tracking
+  lastPongReceived = Date.now();
+  constructor(socket, data, hub, handler, opts) {
+    this.socket = socket;
+    this.data = data;
+    this.hub = hub;
+    this.handler = handler;
+    this.opts = opts;
+    this.remoteAddress = socket.remoteAddress || "0.0.0.0";
+    this.setupSocket();
+  }
+  setupSocket() {
+    const socket = this.socket;
+    socket.on("data", (chunk) => {
+      this.onData(chunk);
+    });
+    socket.on("close", () => {
+      if (this.readyState !== WsReadyState.CLOSED) {
+        this.readyState = WsReadyState.CLOSED;
+        this.hub.removeAll(this);
+        try {
+          this.handler.close?.(this, 1006, "Connection closed abnormally");
+        } catch {
+        }
+      }
+    });
+    socket.on("error", (err) => {
+      try {
+        this.handler.error?.(this, err);
+      } catch {
+      }
+    });
+    try {
+      this.handler.open?.(this);
+    } catch {
+    }
+  }
+  onData(chunk) {
+    let buffer;
+    if (this.frameBuffer) {
+      buffer = Buffer.concat([this.frameBuffer, chunk]);
+      this.frameBuffer = null;
+    } else {
+      buffer = chunk;
+    }
+    let offset = 0;
+    while (offset < buffer.length) {
+      if (buffer.length - offset < 2) {
+        this.frameBuffer = buffer.subarray(offset);
+        return;
+      }
+      const firstByte = buffer[offset];
+      const secondByte = buffer[offset + 1];
+      const isFin = (firstByte & FIN_BIT) !== 0;
+      const opcode = firstByte & OPCODE_MASK;
+      const isMasked = (secondByte & MASK_BIT) !== 0;
+      let payloadLen = secondByte & LENGTH_MASK;
+      let headerSize = 2;
+      if (payloadLen === 126) headerSize += 2;
+      else if (payloadLen === 127) headerSize += 8;
+      if (isMasked) headerSize += 4;
+      if (buffer.length - offset < headerSize) {
+        this.frameBuffer = buffer.subarray(offset);
+        return;
+      }
+      let extOffset = offset + 2;
+      if (payloadLen === 126) {
+        payloadLen = buffer.readUInt16BE(extOffset);
+        extOffset += 2;
+      } else if (payloadLen === 127) {
+        const high = buffer.readUInt32BE(extOffset);
+        if (high > 0) {
+          this.closeInternal(1009, "Message too large");
+          return;
+        }
+        payloadLen = buffer.readUInt32BE(extOffset + 4);
+        extOffset += 8;
+      }
+      if (payloadLen > this.opts.maxPayloadLength) {
+        this.closeInternal(1009, "Message too large");
+        return;
+      }
+      let mask = null;
+      if (isMasked) {
+        mask = buffer.subarray(extOffset, extOffset + 4);
+        extOffset += 4;
+      }
+      const totalFrameSize = extOffset - offset + payloadLen;
+      if (buffer.length - offset < totalFrameSize) {
+        this.frameBuffer = buffer.subarray(offset);
+        return;
+      }
+      const payload = Buffer.from(buffer.subarray(extOffset, extOffset + payloadLen));
+      if (mask) {
+        unmaskPayload(payload, mask);
+      }
+      offset += totalFrameSize;
+      this.processFrame(opcode, payload, isFin);
+    }
+  }
+  processFrame(opcode, payload, isFin) {
+    if (opcode >= 8) {
+      switch (opcode) {
+        case OPCODE_CLOSE:
+          this.handleClose(payload);
+          break;
+        case OPCODE_PING:
+          this.handlePing(payload);
+          break;
+        case OPCODE_PONG:
+          this.handlePong(payload);
+          break;
+      }
+      return;
+    }
+    if (opcode === OPCODE_CONTINUATION) {
+      this.fragments.push(payload);
+      if (isFin) {
+        const fullPayload = Buffer.concat(this.fragments);
+        this.fragments = [];
+        this.dispatchMessage(this.fragmentOpcode, fullPayload);
+      }
+    } else {
+      if (isFin) {
+        this.dispatchMessage(opcode, payload);
+      } else {
+        this.fragmentOpcode = opcode;
+        this.fragments = [payload];
+      }
+    }
+  }
+  dispatchMessage(opcode, payload) {
+    try {
+      const message = opcode === OPCODE_TEXT ? payload.toString("utf8") : payload;
+      this.handler.message(this, message);
+    } catch {
+    }
+  }
+  handleClose(payload) {
+    let code = 1e3;
+    let reason = "";
+    if (payload.length >= 2) {
+      code = payload.readUInt16BE(0);
+      if (payload.length > 2) {
+        reason = payload.subarray(2).toString("utf8");
+      }
+    }
+    if (this.readyState === WsReadyState.OPEN) {
+      this.readyState = WsReadyState.CLOSING;
+      const closePayload = Buffer.allocUnsafe(2);
+      closePayload.writeUInt16BE(code, 0);
+      this.sendFrame(OPCODE_CLOSE, closePayload);
+    }
+    this.readyState = WsReadyState.CLOSED;
+    this.hub.removeAll(this);
+    try {
+      this.handler.close?.(this, code, reason);
+    } catch {
+    }
+    this.socket.end();
+  }
+  handlePing(payload) {
+    this.sendFrame(OPCODE_PONG, payload);
+    try {
+      this.handler.ping?.(this, payload);
+    } catch {
+    }
+  }
+  handlePong(payload) {
+    this.lastPongReceived = Date.now();
+    this.hub.markAlive(this);
+    try {
+      this.handler.pong?.(this, payload);
+    } catch {
+    }
+  }
+  // ==================== Public API ====================
+  send(data, _compress) {
+    if (this.readyState !== WsReadyState.OPEN) return -1;
+    const buf = toBuffer(data);
+    const opcode = typeof data === "string" ? OPCODE_TEXT : OPCODE_BINARY;
+    return this.sendFrame(opcode, buf);
+  }
+  close(code = 1e3, reason) {
+    if (this.readyState !== WsReadyState.OPEN) return;
+    this.readyState = WsReadyState.CLOSING;
+    const reasonBuf = reason ? Buffer.from(reason) : Buffer.alloc(0);
+    const payload = Buffer.allocUnsafe(2 + reasonBuf.length);
+    payload.writeUInt16BE(code, 0);
+    if (reasonBuf.length > 0) reasonBuf.copy(payload, 2);
+    this.sendFrame(OPCODE_CLOSE, payload);
+    this.hub.removeAll(this);
+    try {
+      this.handler.close?.(this, code, reason || "");
+    } catch {
+    }
+    setTimeout(() => {
+      if (this.readyState !== WsReadyState.CLOSED) {
+        this.readyState = WsReadyState.CLOSED;
+        this.socket.end();
+      }
+    }, 1e3);
+  }
+  subscribe(topic) {
+    this.hub.subscribe(this, topic);
+  }
+  unsubscribe(topic) {
+    this.hub.unsubscribe(this, topic);
+  }
+  publish(topic, data, compress) {
+    this.hub.publish(this, topic, data, compress);
+  }
+  isSubscribed(topic) {
+    return this.hub.isSubscribed(this, topic);
+  }
+  ping(data) {
+    if (this.readyState !== WsReadyState.OPEN) return;
+    const buf = data ? toBuffer(data) : Buffer.alloc(0);
+    this.sendFrame(OPCODE_PING, buf);
+  }
+  pong(data) {
+    if (this.readyState !== WsReadyState.OPEN) return;
+    const buf = data ? toBuffer(data) : Buffer.alloc(0);
+    this.sendFrame(OPCODE_PONG, buf);
+  }
+  /** Check if pong was received within timeout */
+  isAlive(pongTimeout) {
+    return Date.now() - this.lastPongReceived < pongTimeout * 1e3;
+  }
+  // ==================== Internal ====================
+  sendFrame(opcode, payload) {
+    if (this.socket.destroyed) return -1;
+    const frame = createFrame(opcode, payload);
+    this.socket.write(frame);
+    return frame.length;
+  }
+  closeInternal(code, reason) {
+    if (this.readyState === WsReadyState.OPEN) {
+      this.close(code, reason);
+    }
+  }
+  /** Force-destroy the underlying socket */
+  destroy() {
+    this.readyState = WsReadyState.CLOSED;
+    this.hub.removeAll(this);
+    this.socket.destroy();
+  }
+};
+function computeAcceptKey(key) {
+  return createHash("sha1").update(key + WS_GUID).digest("base64");
+}
+function createNodeWsHandler(handler, options = {}) {
+  const opts = { ...WS_DEFAULTS, ...options };
+  const hub = new PubSubHub();
+  const peers = /* @__PURE__ */ new Set();
+  let heartbeatInterval = null;
+  async function handleUpgrade(req, socket, head) {
+    const key = req.headers["sec-websocket-key"];
+    const version = req.headers["sec-websocket-version"];
+    if (!key || version !== "13") {
+      socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    let data = void 0;
+    if (handler.upgrade) {
+      try {
+        const url = `http://${req.headers.host || "localhost"}${req.url || "/"}`;
+        const headers = new Headers();
+        for (const [k, v] of Object.entries(req.headers)) {
+          if (v) headers.set(k, Array.isArray(v) ? v.join(", ") : v);
+        }
+        const request = new Request(url, {
+          method: req.method || "GET",
+          headers
+        });
+        const result = await handler.upgrade(request);
+        if (result instanceof Response) {
+          const status = result.status;
+          const body = await result.text();
+          socket.write(`HTTP/1.1 ${status} ${result.statusText || "Error"}\r
+`);
+          result.headers.forEach((v, k) => {
+            socket.write(`${k}: ${v}\r
+`);
+          });
+          socket.write(`Content-Length: ${Buffer.byteLength(body)}\r
+`);
+          socket.write("\r\n");
+          socket.write(body);
+          socket.destroy();
+          return;
+        }
+        data = result;
+      } catch (err) {
+        socket.write("HTTP/1.1 500 Internal Server Error\r\n\r\n");
+        socket.destroy();
+        return;
+      }
+    }
+    const acceptKey = computeAcceptKey(key);
+    const upgradeResponse = `HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: ${acceptKey}\r
+\r
+`;
+    socket.write(upgradeResponse);
+    const peer = new NodeWsPeer(socket, data, hub, handler, opts);
+    peers.add(peer);
+    socket.on("close", () => {
+      peers.delete(peer);
+    });
+    if (head && head.length > 0) {
+      peer.onData(head);
+    }
+  }
+  function startHeartbeat() {
+    if (opts.pingInterval <= 0) return;
+    if (heartbeatInterval) return;
+    heartbeatInterval = setInterval(() => {
+      for (const peer of peers) {
+        if (peer.readyState !== WsReadyState.OPEN) continue;
+        if (opts.pongTimeout > 0 && !peer.isAlive(opts.pingInterval + opts.pongTimeout)) {
+          peer.destroy();
+          peers.delete(peer);
+          continue;
+        }
+        peer.ping();
+      }
+    }, opts.pingInterval * 1e3);
+    if (heartbeatInterval && typeof heartbeatInterval === "object" && "unref" in heartbeatInterval) {
+      heartbeatInterval.unref();
+    }
+  }
+  function stopHeartbeat() {
+    if (heartbeatInterval) {
+      clearInterval(heartbeatInterval);
+      heartbeatInterval = null;
+    }
+  }
+  return { hub, peers, handleUpgrade, startHeartbeat, stopHeartbeat };
+}
+
+// src/runtime/node.ts
+async function sendResponse(nodeRes, response) {
+  nodeRes.statusCode = response.status;
+  const setCookies = response.headers.getSetCookie();
+  if (setCookies.length > 0) {
+    nodeRes.setHeader("Set-Cookie", setCookies);
+  }
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() !== "set-cookie") {
+      nodeRes.setHeader(key, value);
+    }
+  });
+  const body = response.body;
+  if (!body) {
+    nodeRes.end();
+    return;
+  }
+  const reader = body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!nodeRes.write(value)) {
+        await new Promise((resolve) => nodeRes.once("drain", resolve));
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    nodeRes.end();
+  }
+}
+function getPathnameFromUrl(url) {
+  if (!url) return "/";
+  const idx = url.indexOf("?");
+  return idx === -1 ? url : url.slice(0, idx);
+}
+var nodeContextFactory = (req, params, getRemoteInfo, schema, url) => new NodeContext(req, url || req.url || "/", params, getRemoteInfo, schema);
+function server({ port, hostname, router }) {
+  let httpServer = void 0;
+  const compiledRouter = new Router();
+  for (const route of router.routes) {
+    let mergedSchema = route.schema;
+    if (typeof router.matchMiddleware === "function" && typeof router.mergeSchemas === "function") {
+      const matchedMiddleware = router.matchMiddleware(route.path);
+      mergedSchema = router.mergeSchemas(matchedMiddleware, route.schema);
+    }
+    if (route.handler) {
+      const executor = createExecutor(nodeContextFactory, route.handler, mergedSchema);
+      const nodeHandler = async (req, res, params, getRemoteInfo) => {
+        const url = req.url || "/";
+        try {
+          const result = await executor(req, params, getRemoteInfo, url);
+          const response = toResponse(result);
+          await sendResponse(res, response);
+        } catch (error) {
+          const errResponse = error instanceof Response ? error : new Response(error instanceof Error ? error.message : String(error), { status: 500 });
+          await sendResponse(res, errResponse);
+        }
+      };
+      compiledRouter.registerCompiled(route.method, route.path, nodeHandler, mergedSchema);
+    } else if (route.staticValue !== void 0) {
+      const cachedResponse = toResponse(route.staticValue);
+      const statusCode = cachedResponse.status;
+      cachedResponse.text().then((body) => {
+        const bodyBuffer = Buffer.from(body);
+        const headersObj = {};
+        cachedResponse.headers.forEach((v, k) => {
+          headersObj[k] = v;
+        });
+        headersObj["content-length"] = String(bodyBuffer.length);
+        const staticExecutor = (_req, res) => {
+          res.writeHead(statusCode, headersObj);
+          res.end(bodyBuffer);
+        };
+        compiledRouter.registerCompiled(route.method, route.path, staticExecutor, mergedSchema, cachedResponse);
+      });
+    }
+  }
+  const match = compiledRouter.matcher();
+  const notFoundExecutor = createNotFoundExecutor(router, nodeContextFactory);
+  const NOT_FOUND_BODY = "Not Found";
+  const wsRoutes = router.wsRoutes || [];
+  const wsHandlers = /* @__PURE__ */ new Map();
+  for (const wsRoute of wsRoutes) {
+    wsHandlers.set(wsRoute.path, createNodeWsHandler(wsRoute.handler, wsRoute.options));
+  }
+  return {
+    async run() {
+      httpServer?.close();
+      return new Promise((resolve, reject) => {
+        httpServer = createServer((req, res) => {
+          const pathname = getPathnameFromUrl(req.url);
+          const method = req.method || "GET";
+          const matchResult = match(method, pathname);
+          if (matchResult !== void 0) {
+            if (matchResult.response !== void 0) {
+              matchResult.handler(req, res);
+              return;
+            }
+            const getRemoteInfo = () => ({
+              address: req.socket.remoteAddress || "0.0.0.0",
+              port: req.socket.remotePort || 0
+            });
+            const result = matchResult.handler(req, res, matchResult.params, getRemoteInfo);
+            if (result && typeof result.then === "function") {
+              result.catch((error) => {
+                if (!res.headersSent) {
+                  res.statusCode = 500;
+                  res.end(error instanceof Error ? error.message : String(error));
+                }
+              });
+            }
+            return;
+          }
+          if (notFoundExecutor) {
+            const getRemoteInfo = () => ({
+              address: req.socket.remoteAddress || "0.0.0.0",
+              port: req.socket.remotePort || 0
+            });
+            const url = req.url || "/";
+            const result = notFoundExecutor(req, getRemoteInfo, pathname, url);
+            if (result && typeof result.then === "function") {
+              result.then(async (resp) => {
+                const response = toResponse(resp);
+                await sendResponse(res, response);
+              }).catch((error) => {
+                if (!res.headersSent) {
+                  res.statusCode = 500;
+                  res.end(error instanceof Error ? error.message : String(error));
+                }
+              });
+            } else {
+              const response = toResponse(result);
+              sendResponse(res, response).catch((error) => {
+                if (!res.headersSent) {
+                  res.statusCode = 500;
+                  res.end(error instanceof Error ? error.message : String(error));
+                }
+              });
+            }
+            return;
+          }
+          res.statusCode = 404;
+          res.end(NOT_FOUND_BODY);
+        });
+        httpServer.on("error", reject);
+        if (wsHandlers.size > 0) {
+          httpServer.on("upgrade", (req, socket, head) => {
+            const pathname = getPathnameFromUrl(req.url);
+            const wsHandler = wsHandlers.get(pathname);
+            if (wsHandler) {
+              wsHandler.handleUpgrade(req, socket, head);
+            } else {
+              socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+              socket.destroy();
+            }
+          });
+          for (const wsHandler of wsHandlers.values()) {
+            wsHandler.startHeartbeat();
+          }
+        }
+        httpServer.listen(port || 3e3, hostname || "0.0.0.0", () => {
+          const addr = httpServer?.address();
+          if (addr && typeof addr !== "string") {
+            resolve({ hostname: addr.address, port: addr.port });
+          } else {
+            resolve({ hostname: hostname || "0.0.0.0", port: port || 3e3 });
+          }
+        });
+      });
+    },
+    stop() {
+      for (const wsHandler of wsHandlers.values()) {
+        wsHandler.stopHeartbeat();
+      }
+      return new Promise((resolve, reject) => {
+        if (httpServer) {
+          httpServer.close((err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+          httpServer = void 0;
+        } else {
+          resolve();
+        }
+      });
+    }
+  };
+}
+export {
+  server
+};
+//# sourceMappingURL=node-JLUTIPEN.js.map