@elysiajs/node - npm Package Compare versions

Comparing version 1.4.0 to 1.4.1

dist/cjs/handle.d.ts

+import type { Context } from 'elysia/context';
+import type { AnyLocalHook } from 'elysia/types';
+export declare const mapResponse: (response: unknown, set: Context["set"], request?: Request) => Response;
+export declare const mapEarlyResponse: (response: unknown, set: Context["set"], request?: Request) => Response | undefined;
+export declare const mapCompactResponse: (response: unknown, request?: Request) => Response;
+export declare const errorToResponse: (error: Error, set?: Context["set"]) => Response;
+export declare const createStaticHandler: (handle: unknown, hooks: Partial<AnyLocalHook>, setHeaders?: Context["set"]["headers"]) => (() => Response) | undefined;

dist/cjs/handle.js

+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/handle.ts
+var handle_exports = {};
+__export(handle_exports, {
+  createStaticHandler: () => createStaticHandler,
+  errorToResponse: () => errorToResponse,
+  mapCompactResponse: () => mapCompactResponse,
+  mapEarlyResponse: () => mapEarlyResponse,
+  mapResponse: () => mapResponse
+});
+module.exports = __toCommonJS(handle_exports);
+var import_srvx2 = require("srvx");
+var import_utils2 = require("elysia/adapter/utils");
+
+// src/utils.ts
+var import_srvx = require("srvx");
+var import_utils = require("elysia/utils");
+var handleFile = (response, set2) => {
+  if (response instanceof Promise)
+    return response.then((res) => handleFile(res, set2));
+  const size = response.size;
+  const immutable = set2 && (set2.status === 206 || set2.status === 304 || set2.status === 412 || set2.status === 416);
+  const defaultHeader = immutable ? {
+    "transfer-encoding": "chunked"
+  } : {
+    "accept-ranges": "bytes",
+    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0,
+    "transfer-encoding": "chunked"
+  };
+  if (!set2 && !size) return new import_srvx.FastResponse(response);
+  if (!set2)
+    return new import_srvx.FastResponse(response, {
+      headers: defaultHeader
+    });
+  if (set2.headers instanceof Headers) {
+    let setHeaders = defaultHeader;
+    setHeaders = {};
+    for (const [key, value] of set2.headers.entries())
+      if (key in set2.headers) setHeaders[key] = value;
+    if (immutable) {
+      delete set2.headers["content-length"];
+      delete set2.headers["accept-ranges"];
+    }
+    return new import_srvx.FastResponse(response, {
+      status: set2.status,
+      headers: setHeaders
+    });
+  }
+  if ((0, import_utils.isNotEmpty)(set2.headers))
+    return new import_srvx.FastResponse(response, {
+      status: set2.status,
+      headers: Object.assign(defaultHeader, set2.headers)
+    });
+  return new import_srvx.FastResponse(response, {
+    status: set2.status,
+    headers: defaultHeader
+  });
+};
+
+// src/handle.ts
+var import_file = require("elysia/universal/file");
+var import_utils4 = require("elysia/utils");
+var import_cookies = require("elysia/cookies");
+var import_error = require("elysia/error");
+var handleElysiaFile = (file, set2 = {
+  headers: {}
+}) => {
+  const path = file.path;
+  const contentType = import_file.mime[path.slice(path.lastIndexOf(".") + 1)];
+  if (contentType) set2.headers["content-type"] = contentType;
+  if (file.stats && set2 && set2.status !== 206 && set2.status !== 304 && set2.status !== 412 && set2.status !== 416)
+    return file.stats.then((stat) => {
+      const size = stat.size;
+      if (size !== void 0) {
+        set2.headers["content-range"] = `bytes 0-${size - 1}/${size}`;
+        set2.headers["content-length"] = size;
+      }
+      return handleFile(file.value, set2);
+    });
+  return handleFile(file.value, set2);
+};
+var mapResponse = (response, set2, request) => {
+  if ((0, import_utils4.isNotEmpty)(set2.headers) || set2.status !== 200 || set2.cookie) {
+    (0, import_utils2.handleSet)(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new import_srvx2.FastResponse(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new import_srvx2.FastResponse(response, set2);
+      case void 0:
+        if (!response) return new import_srvx2.FastResponse("", set2);
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Promise":
+        return response.then(
+          (x) => mapResponse(x, set2, request)
+        );
+      case "Function":
+        return mapResponse(response(), set2, request);
+      case "Number":
+      case "Boolean":
+        return new import_srvx2.FastResponse(
+          response.toString(),
+          set2
+        );
+      case "Cookie":
+        if (response instanceof import_cookies.Cookie)
+          return new import_srvx2.FastResponse(response.value, set2);
+        return new import_srvx2.FastResponse(response?.toString(), set2);
+      case "FormData":
+        return new import_srvx2.FastResponse(response, set2);
+      default:
+        if (response instanceof import_srvx2.FastResponse)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof import_error.ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new import_srvx2.FastResponse(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new import_srvx2.FastResponse(response, set2);
+    }
+  }
+  if (response instanceof import_srvx2.FastResponse && !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+    return handleStream(
+      (0, import_utils2.streamResponse)(response),
+      (0, import_utils2.responseToSetHeaders)(response, set2),
+      request
+    );
+  if (
+    // @ts-expect-error
+    typeof response?.next === "function" || response instanceof ReadableStream
+  )
+    return handleStream(response, set2, request);
+  return mapCompactResponse(response, request);
+};
+var mapEarlyResponse = (response, set2, request) => {
+  if (response === void 0 || response === null) return;
+  if ((0, import_utils4.isNotEmpty)(set2.headers) || set2.status !== 200 || set2.cookie) {
+    (0, import_utils2.handleSet)(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new import_srvx2.FastResponse(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new import_srvx2.FastResponse(response, set2);
+      case void 0:
+        if (!response) return;
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Promise":
+        return response.then(
+          (x) => mapEarlyResponse(x, set2)
+        );
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapEarlyResponse(response(), set2);
+      case "Number":
+      case "Boolean":
+        return new import_srvx2.FastResponse(
+          response.toString(),
+          set2
+        );
+      case "FormData":
+        return new import_srvx2.FastResponse(response);
+      case "Cookie":
+        if (response instanceof import_cookies.Cookie)
+          return new import_srvx2.FastResponse(response.value, set2);
+        return new import_srvx2.FastResponse(response?.toString(), set2);
+      default:
+        if (response instanceof import_srvx2.FastResponse)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof import_error.ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new import_srvx2.FastResponse(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new import_srvx2.FastResponse(response, set2);
+    }
+  } else
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new import_srvx2.FastResponse(response);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new import_srvx2.FastResponse(response, {
+          headers: {
+            "Content-Type": "text/event-stream; charset=utf-8"
+          }
+        });
+      case void 0:
+        if (!response) return new import_srvx2.FastResponse("");
+        return new import_srvx2.FastResponse(JSON.stringify(response), {
+          headers: {
+            "content-type": "application/json"
+          }
+        });
+      case "Response":
+        if (!response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+          return handleStream(
+            (0, import_utils2.streamResponse)(response),
+            (0, import_utils2.responseToSetHeaders)(response),
+            request
+          );
+        return response;
+      case "Promise":
+        return response.then((x) => {
+          const r = mapEarlyResponse(x, set2);
+          if (r !== void 0) return r;
+        });
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapCompactResponse(response(), request);
+      case "Number":
+      case "Boolean":
+        return new import_srvx2.FastResponse(response.toString());
+      case "Cookie":
+        if (response instanceof import_cookies.Cookie)
+          return new import_srvx2.FastResponse(response.value, set2);
+        return new import_srvx2.FastResponse(response?.toString(), set2);
+      case "FormData":
+        return new import_srvx2.FastResponse(response);
+      default:
+        if (response instanceof import_srvx2.FastResponse) return response;
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof import_error.ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new import_srvx2.FastResponse(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new import_srvx2.FastResponse(response);
+    }
+};
+var mapCompactResponse = (response, request) => {
+  switch (response?.constructor?.name) {
+    case "String":
+      return new import_srvx2.FastResponse(response, {
+        headers: {
+          "Content-Type": "text/plain"
+        }
+      });
+    case "Object":
+    case "Array":
+      return new import_srvx2.FastResponse(JSON.stringify(response), {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    case "ElysiaFile":
+      return handleElysiaFile(response);
+    case "File":
+      return handleFile(response);
+    case "Blob":
+      return handleFile(response);
+    case "ElysiaCustomStatusResponse":
+      return mapResponse(
+        response.response,
+        {
+          status: response.code,
+          headers: {}
+        }
+      );
+    case "ReadableStream":
+      request?.signal?.addEventListener(
+        "abort",
+        {
+          handleEvent() {
+            if (request?.signal && !request?.signal?.aborted)
+              response.cancel();
+          }
+        },
+        {
+          once: true
+        }
+      );
+      return new import_srvx2.FastResponse(response, {
+        headers: {
+          "Content-Type": "text/event-stream; charset=utf-8"
+        }
+      });
+    case void 0:
+      if (!response) return new import_srvx2.FastResponse("");
+      return new import_srvx2.FastResponse(JSON.stringify(response), {
+        headers: {
+          "content-type": "application/json"
+        }
+      });
+    case "Response":
+      if (response.headers.get("transfer-encoding") === "chunked")
+        return handleStream(
+          (0, import_utils2.streamResponse)(response),
+          (0, import_utils2.responseToSetHeaders)(response),
+          request
+        );
+      return response;
+    case "Error":
+      return errorToResponse(response);
+    case "Promise":
+      return response.then(
+        (x) => mapCompactResponse(x, request)
+      );
+    // ? Maybe response or Blob
+    case "Function":
+      return mapCompactResponse(response(), request);
+    case "Number":
+    case "Boolean":
+      return new import_srvx2.FastResponse(response.toString());
+    case "FormData":
+      return new import_srvx2.FastResponse(response);
+    default:
+      if (response instanceof import_srvx2.FastResponse) return response;
+      if (response instanceof Promise)
+        return response.then(
+          (x) => mapCompactResponse(x, request)
+        );
+      if (response instanceof Error)
+        return errorToResponse(response);
+      if (response instanceof import_error.ElysiaCustomStatusResponse)
+        return mapResponse(
+          response.response,
+          {
+            status: response.code,
+            headers: {}
+          }
+        );
+      if (typeof response?.next === "function")
+        return handleStream(response, void 0, request);
+      if (typeof response?.then === "function")
+        return response.then((x) => mapResponse(x, set));
+      if (typeof response?.toResponse === "function")
+        return mapCompactResponse(response.toResponse());
+      if ("charCodeAt" in response) {
+        const code = response.charCodeAt(0);
+        if (code === 123 || code === 91) {
+          return new import_srvx2.FastResponse(JSON.stringify(response), {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+      }
+      return new import_srvx2.FastResponse(response);
+  }
+};
+var errorToResponse = (error, set2) => new import_srvx2.FastResponse(
+  JSON.stringify({
+    name: error?.name,
+    message: error?.message,
+    cause: error?.cause
+  }),
+  {
+    status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
+    headers: set2?.headers
+  }
+);
+var createStaticHandler = (handle, hooks, setHeaders = {}) => {
+  if (typeof handle === "function") return;
+  const response = mapResponse(handle, {
+    headers: setHeaders
+  });
+  if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
+    return response.clone.bind(response);
+};
+var handleResponse = (0, import_utils2.createResponseHandler)({
+  mapResponse,
+  mapCompactResponse
+});
+var handleStream = (0, import_utils2.createStreamHandler)({
+  mapResponse,
+  mapCompactResponse
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStaticHandler,
+  errorToResponse,
+  mapCompactResponse,
+  mapEarlyResponse,
+  mapResponse
+});

dist/cjs/utils.d.ts

+import type { ReadStream } from 'fs';
+import type { Context } from 'elysia/context';
+export declare const handleFile: (response: ReadStream | File | Blob, set?: Context["set"]) => Response;

dist/cjs/utils.js

+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  handleFile: () => handleFile
+});
+module.exports = __toCommonJS(utils_exports);
+var import_srvx = require("srvx");
+var import_utils = require("elysia/utils");
+var handleFile = (response, set) => {
+  if (response instanceof Promise)
+    return response.then((res) => handleFile(res, set));
+  const size = response.size;
+  const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
+  const defaultHeader = immutable ? {
+    "transfer-encoding": "chunked"
+  } : {
+    "accept-ranges": "bytes",
+    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0,
+    "transfer-encoding": "chunked"
+  };
+  if (!set && !size) return new import_srvx.FastResponse(response);
+  if (!set)
+    return new import_srvx.FastResponse(response, {
+      headers: defaultHeader
+    });
+  if (set.headers instanceof Headers) {
+    let setHeaders = defaultHeader;
+    setHeaders = {};
+    for (const [key, value] of set.headers.entries())
+      if (key in set.headers) setHeaders[key] = value;
+    if (immutable) {
+      delete set.headers["content-length"];
+      delete set.headers["accept-ranges"];
+    }
+    return new import_srvx.FastResponse(response, {
+      status: set.status,
+      headers: setHeaders
+    });
+  }
+  if ((0, import_utils.isNotEmpty)(set.headers))
+    return new import_srvx.FastResponse(response, {
+      status: set.status,
+      headers: Object.assign(defaultHeader, set.headers)
+    });
+  return new import_srvx.FastResponse(response, {
+    status: set.status,
+    headers: defaultHeader
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleFile
+});

dist/handle.d.ts

+import type { Context } from 'elysia/context';
+import type { AnyLocalHook } from 'elysia/types';
+export declare const mapResponse: (response: unknown, set: Context["set"], request?: Request) => Response;
+export declare const mapEarlyResponse: (response: unknown, set: Context["set"], request?: Request) => Response | undefined;
+export declare const mapCompactResponse: (response: unknown, request?: Request) => Response;
+export declare const errorToResponse: (error: Error, set?: Context["set"]) => Response;
+export declare const createStaticHandler: (handle: unknown, hooks: Partial<AnyLocalHook>, setHeaders?: Context["set"]["headers"]) => (() => Response) | undefined;

dist/handle.mjs

+// src/handle.ts
+import { FastResponse as Response2 } from "srvx";
+import {
+  createResponseHandler,
+  createStreamHandler,
+  handleSet,
+  responseToSetHeaders,
+  streamResponse
+} from "elysia/adapter/utils";
+
+// src/utils.ts
+import { FastResponse as Response } from "srvx";
+import { isNotEmpty } from "elysia/utils";
+var handleFile = (response, set2) => {
+  if (response instanceof Promise)
+    return response.then((res) => handleFile(res, set2));
+  const size = response.size;
+  const immutable = set2 && (set2.status === 206 || set2.status === 304 || set2.status === 412 || set2.status === 416);
+  const defaultHeader = immutable ? {
+    "transfer-encoding": "chunked"
+  } : {
+    "accept-ranges": "bytes",
+    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0,
+    "transfer-encoding": "chunked"
+  };
+  if (!set2 && !size) return new Response(response);
+  if (!set2)
+    return new Response(response, {
+      headers: defaultHeader
+    });
+  if (set2.headers instanceof Headers) {
+    let setHeaders = defaultHeader;
+    setHeaders = {};
+    for (const [key, value] of set2.headers.entries())
+      if (key in set2.headers) setHeaders[key] = value;
+    if (immutable) {
+      delete set2.headers["content-length"];
+      delete set2.headers["accept-ranges"];
+    }
+    return new Response(response, {
+      status: set2.status,
+      headers: setHeaders
+    });
+  }
+  if (isNotEmpty(set2.headers))
+    return new Response(response, {
+      status: set2.status,
+      headers: Object.assign(defaultHeader, set2.headers)
+    });
+  return new Response(response, {
+    status: set2.status,
+    headers: defaultHeader
+  });
+};
+
+// src/handle.ts
+import { mime } from "elysia/universal/file";
+import { isNotEmpty as isNotEmpty2 } from "elysia/utils";
+import { Cookie } from "elysia/cookies";
+import { ElysiaCustomStatusResponse } from "elysia/error";
+var handleElysiaFile = (file, set2 = {
+  headers: {}
+}) => {
+  const path = file.path;
+  const contentType = mime[path.slice(path.lastIndexOf(".") + 1)];
+  if (contentType) set2.headers["content-type"] = contentType;
+  if (file.stats && set2 && set2.status !== 206 && set2.status !== 304 && set2.status !== 412 && set2.status !== 416)
+    return file.stats.then((stat) => {
+      const size = stat.size;
+      if (size !== void 0) {
+        set2.headers["content-range"] = `bytes 0-${size - 1}/${size}`;
+        set2.headers["content-length"] = size;
+      }
+      return handleFile(file.value, set2);
+    });
+  return handleFile(file.value, set2);
+};
+var mapResponse = (response, set2, request) => {
+  if (isNotEmpty2(set2.headers) || set2.status !== 200 || set2.cookie) {
+    handleSet(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new Response2(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new Response2(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new Response2(response, set2);
+      case void 0:
+        if (!response) return new Response2("", set2);
+        return new Response2(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Promise":
+        return response.then(
+          (x) => mapResponse(x, set2, request)
+        );
+      case "Function":
+        return mapResponse(response(), set2, request);
+      case "Number":
+      case "Boolean":
+        return new Response2(
+          response.toString(),
+          set2
+        );
+      case "Cookie":
+        if (response instanceof Cookie)
+          return new Response2(response.value, set2);
+        return new Response2(response?.toString(), set2);
+      case "FormData":
+        return new Response2(response, set2);
+      default:
+        if (response instanceof Response2)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new Response2(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new Response2(response, set2);
+    }
+  }
+  if (response instanceof Response2 && !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+    return handleStream(
+      streamResponse(response),
+      responseToSetHeaders(response, set2),
+      request
+    );
+  if (
+    // @ts-expect-error
+    typeof response?.next === "function" || response instanceof ReadableStream
+  )
+    return handleStream(response, set2, request);
+  return mapCompactResponse(response, request);
+};
+var mapEarlyResponse = (response, set2, request) => {
+  if (response === void 0 || response === null) return;
+  if (isNotEmpty2(set2.headers) || set2.status !== 200 || set2.cookie) {
+    handleSet(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new Response2(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new Response2(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new Response2(response, set2);
+      case void 0:
+        if (!response) return;
+        return new Response2(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Promise":
+        return response.then(
+          (x) => mapEarlyResponse(x, set2)
+        );
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapEarlyResponse(response(), set2);
+      case "Number":
+      case "Boolean":
+        return new Response2(
+          response.toString(),
+          set2
+        );
+      case "FormData":
+        return new Response2(response);
+      case "Cookie":
+        if (response instanceof Cookie)
+          return new Response2(response.value, set2);
+        return new Response2(response?.toString(), set2);
+      default:
+        if (response instanceof Response2)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new Response2(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new Response2(response, set2);
+    }
+  } else
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new Response2(response);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new Response2(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new Response2(response, {
+          headers: {
+            "Content-Type": "text/event-stream; charset=utf-8"
+          }
+        });
+      case void 0:
+        if (!response) return new Response2("");
+        return new Response2(JSON.stringify(response), {
+          headers: {
+            "content-type": "application/json"
+          }
+        });
+      case "Response":
+        if (!response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+          return handleStream(
+            streamResponse(response),
+            responseToSetHeaders(response),
+            request
+          );
+        return response;
+      case "Promise":
+        return response.then((x) => {
+          const r = mapEarlyResponse(x, set2);
+          if (r !== void 0) return r;
+        });
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapCompactResponse(response(), request);
+      case "Number":
+      case "Boolean":
+        return new Response2(response.toString());
+      case "Cookie":
+        if (response instanceof Cookie)
+          return new Response2(response.value, set2);
+        return new Response2(response?.toString(), set2);
+      case "FormData":
+        return new Response2(response);
+      default:
+        if (response instanceof Response2) return response;
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new Response2(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new Response2(response);
+    }
+};
+var mapCompactResponse = (response, request) => {
+  switch (response?.constructor?.name) {
+    case "String":
+      return new Response2(response, {
+        headers: {
+          "Content-Type": "text/plain"
+        }
+      });
+    case "Object":
+    case "Array":
+      return new Response2(JSON.stringify(response), {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    case "ElysiaFile":
+      return handleElysiaFile(response);
+    case "File":
+      return handleFile(response);
+    case "Blob":
+      return handleFile(response);
+    case "ElysiaCustomStatusResponse":
+      return mapResponse(
+        response.response,
+        {
+          status: response.code,
+          headers: {}
+        }
+      );
+    case "ReadableStream":
+      request?.signal?.addEventListener(
+        "abort",
+        {
+          handleEvent() {
+            if (request?.signal && !request?.signal?.aborted)
+              response.cancel();
+          }
+        },
+        {
+          once: true
+        }
+      );
+      return new Response2(response, {
+        headers: {
+          "Content-Type": "text/event-stream; charset=utf-8"
+        }
+      });
+    case void 0:
+      if (!response) return new Response2("");
+      return new Response2(JSON.stringify(response), {
+        headers: {
+          "content-type": "application/json"
+        }
+      });
+    case "Response":
+      if (response.headers.get("transfer-encoding") === "chunked")
+        return handleStream(
+          streamResponse(response),
+          responseToSetHeaders(response),
+          request
+        );
+      return response;
+    case "Error":
+      return errorToResponse(response);
+    case "Promise":
+      return response.then(
+        (x) => mapCompactResponse(x, request)
+      );
+    // ? Maybe response or Blob
+    case "Function":
+      return mapCompactResponse(response(), request);
+    case "Number":
+    case "Boolean":
+      return new Response2(response.toString());
+    case "FormData":
+      return new Response2(response);
+    default:
+      if (response instanceof Response2) return response;
+      if (response instanceof Promise)
+        return response.then(
+          (x) => mapCompactResponse(x, request)
+        );
+      if (response instanceof Error)
+        return errorToResponse(response);
+      if (response instanceof ElysiaCustomStatusResponse)
+        return mapResponse(
+          response.response,
+          {
+            status: response.code,
+            headers: {}
+          }
+        );
+      if (typeof response?.next === "function")
+        return handleStream(response, void 0, request);
+      if (typeof response?.then === "function")
+        return response.then((x) => mapResponse(x, set));
+      if (typeof response?.toResponse === "function")
+        return mapCompactResponse(response.toResponse());
+      if ("charCodeAt" in response) {
+        const code = response.charCodeAt(0);
+        if (code === 123 || code === 91) {
+          return new Response2(JSON.stringify(response), {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+      }
+      return new Response2(response);
+  }
+};
+var errorToResponse = (error, set2) => new Response2(
+  JSON.stringify({
+    name: error?.name,
+    message: error?.message,
+    cause: error?.cause
+  }),
+  {
+    status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
+    headers: set2?.headers
+  }
+);
+var createStaticHandler = (handle, hooks, setHeaders = {}) => {
+  if (typeof handle === "function") return;
+  const response = mapResponse(handle, {
+    headers: setHeaders
+  });
+  if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
+    return response.clone.bind(response);
+};
+var handleResponse = createResponseHandler({
+  mapResponse,
+  mapCompactResponse
+});
+var handleStream = createStreamHandler({
+  mapResponse,
+  mapCompactResponse
+});
+export {
+  createStaticHandler,
+  errorToResponse,
+  mapCompactResponse,
+  mapEarlyResponse,
+  mapResponse
+};

dist/utils.d.ts

+import type { ReadStream } from 'fs';
+import type { Context } from 'elysia/context';
+export declare const handleFile: (response: ReadStream | File | Blob, set?: Context["set"]) => Response;

dist/utils.mjs

+// src/utils.ts
+import { FastResponse as Response } from "srvx";
+import { isNotEmpty } from "elysia/utils";
+var handleFile = (response, set) => {
+  if (response instanceof Promise)
+    return response.then((res) => handleFile(res, set));
+  const size = response.size;
+  const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
+  const defaultHeader = immutable ? {
+    "transfer-encoding": "chunked"
+  } : {
+    "accept-ranges": "bytes",
+    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0,
+    "transfer-encoding": "chunked"
+  };
+  if (!set && !size) return new Response(response);
+  if (!set)
+    return new Response(response, {
+      headers: defaultHeader
+    });
+  if (set.headers instanceof Headers) {
+    let setHeaders = defaultHeader;
+    setHeaders = {};
+    for (const [key, value] of set.headers.entries())
+      if (key in set.headers) setHeaders[key] = value;
+    if (immutable) {
+      delete set.headers["content-length"];
+      delete set.headers["accept-ranges"];
+    }
+    return new Response(response, {
+      status: set.status,
+      headers: setHeaders
+    });
+  }
+  if (isNotEmpty(set.headers))
+    return new Response(response, {
+      status: set.status,
+      headers: Object.assign(defaultHeader, set.headers)
+    });
+  return new Response(response, {
+    status: set.status,
+    headers: defaultHeader
+  });
+};
+export {
+  handleFile
+};

dist/cjs/index.d.ts

 export declare const node: () => {
     name: string;
+    handler: {
+        mapCompactResponse: (response: unknown, request?: Request) => Response;
+        mapEarlyResponse: (response: unknown, set: import("elysia").Context["set"], request?: Request) => Response | undefined;
+        mapResponse: (response: unknown, set: import("elysia").Context["set"], request?: Request) => Response;
+        createStaticHandler: (handle: unknown, hooks: Partial<import("elysia/types").AnyLocalHook>, setHeaders?: import("elysia").Context["set"]["headers"]) => (() => Response) | undefined;
+    };
+    ws: (app: import("elysia").AnyElysia, path: string, options: import("elysia/ws/types").AnyWSLocalHook) => void;
     listen(app: import("elysia").AnyElysia): (options: any, callback: import("elysia/universal/server").ListenCallback | undefined) => void;
     stop?(app: import("elysia").AnyElysia, closeActiveConnections?: boolean): Promise<void>;
     isWebStandard?: boolean;
-    handler: {
-        mapResponse(response: unknown, set: import("elysia").Context["set"], ...params: unknown[]): unknown;
-        mapEarlyResponse(response: unknown, set: import("elysia").Context["set"], ...params: unknown[]): unknown;
-        mapCompactResponse(response: unknown, ...params: unknown[]): unknown;
-        createStaticHandler?(handle: unknown, hooks: import("elysia/types").AnyLocalHook, setHeaders?: import("elysia").Context["set"]["headers"], ...params: unknown[]): (() => unknown) | undefined;
-        createNativeStaticHandler?(handle: unknown, hooks: import("elysia/types").AnyLocalHook, set?: import("elysia").Context["set"]): (() => import("elysia").MaybePromise<Response>) | undefined;
-    };
     composeHandler: {
@@ -39,5 +39,5 @@ mapResponseContext?: string;
     };
-    ws?(app: import("elysia").AnyElysia, path: string, handler: import("elysia/ws/types").AnyWSLocalHook): unknown;
     createSystemRouterHandler?(method: string, path: string, hook: import("elysia/types").AnyLocalHook, app: import("elysia").AnyElysia): void;
+    beforeCompile?(app: import("elysia").AnyElysia): void;
 };
 export default node;

dist/cjs/index.js

@@ -28,97 +28,842 @@ "use strict";
 var import_web_standard = require("elysia/adapter/web-standard");
-var import_node_server = require("@hono/node-server");
-var import_utils = require("elysia/utils");
+var import_utils7 = require("elysia/utils");
+var import_crossws = require("crossws");
+var import_server = require("crossws/server");
+
+// src/ws.ts
+var import_elysia = require("elysia");
+var import_utils = require("elysia/adapter/utils");
+var import_utils2 = require("elysia/utils");
+var import_ws = require("elysia/ws");
+function createWebSocketAdapter() {
+  const store = {};
+  function handler(app, path, options) {
+    const { parse, body, response, ...rest } = options;
+    const validateMessage = (0, import_elysia.getSchemaValidator)(body, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
+      // @ts-expect-error private property
+      models: app.definitions.type,
+      normalize: app.config.normalize
+    });
+    const validateResponse = (0, import_elysia.getSchemaValidator)(response, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
+      // @ts-expect-error private property
+      models: app.definitions.type,
+      normalize: app.config.normalize
+    });
+    const toServerWebSocket = (peer) => {
+      const ws = peer;
+      ws.data = peer.context.context;
+      ws.sendText = ws.send;
+      ws.sendBinary = ws.send;
+      ws.publishText = ws.publish;
+      ws.publishBinary = ws.publish;
+      ws.isSubscribed = (topic) => peer.topics.has(topic);
+      ws.cork = () => {
+        console.log("ws.cork is not supported yet");
+      };
+      return ws;
+    };
+    app.route(
+      "WS",
+      path,
+      // @ts-ignore
+      async (context) => {
+        const { set: set2, path: path2, qi, headers, query, params } = context;
+        const id = context.request.wsId;
+        context.validator = validateResponse;
+        if (options.upgrade) {
+          if (typeof options.upgrade === "function") {
+            const temp = options.upgrade(context);
+            if (temp instanceof Promise) await temp;
+          } else if (options.upgrade)
+            Object.assign(
+              set2.headers,
+              options.upgrade
+            );
+        }
+        if (set2.cookie && (0, import_utils2.isNotEmpty)(set2.cookie)) {
+          const cookie = (0, import_elysia.serializeCookie)(set2.cookie);
+          if (cookie) set2.headers["set-cookie"] = cookie;
+        }
+        if (set2.headers["set-cookie"] && Array.isArray(set2.headers["set-cookie"]))
+          set2.headers = (0, import_utils.parseSetCookies)(
+            new Headers(set2.headers),
+            set2.headers["set-cookie"]
+          );
+        const handleResponse2 = (0, import_ws.createHandleWSResponse)(validateResponse);
+        const parseMessage = parse ? (0, import_ws.createWSMessageParser)(parse) : void 0;
+        if (typeof options.beforeHandle === "function") {
+          const result = options.beforeHandle(context);
+          if (result instanceof Promise) await result;
+        }
+        const errorHandlers = [
+          ...options.error ? Array.isArray(options.error) ? options.error : [options.error] : [],
+          ...(app.event.error ?? []).map(
+            (x) => typeof x === "function" ? x : x.fn
+          )
+        ].filter((x) => x);
+        const handleErrors = errorHandlers.length ? async (ws, error) => {
+          for (const handleError of errorHandlers) {
+            let response2 = handleError(
+              Object.assign(context, { error })
+            );
+            if (response2 instanceof Promise)
+              response2 = await response2;
+            await handleResponse2(ws, response2);
+            if (response2) break;
+          }
+        } : void 0;
+        store[id] = {
+          data: context,
+          validateResponse,
+          ping(data) {
+            return options.ping?.(data);
+          },
+          pong(data) {
+            return options.pong?.(data);
+          },
+          async open(_ws) {
+            const ws = toServerWebSocket(_ws);
+            try {
+              await handleResponse2(
+                ws,
+                options.open?.(new import_ws.ElysiaWS(ws, context))
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async message(ws, message) {
+            if (message.includes("ping")) {
+              try {
+                return void ws.pong(message);
+              } catch (error) {
+                handleErrors?.(ws, error);
+              }
+            }
+            if (parseMessage)
+              message = await parseMessage(ws, message);
+            if (message) {
+              if (validateMessage?.Check(message) === false)
+                return void ws.send(
+                  new import_elysia.ValidationError(
+                    "message",
+                    validateMessage,
+                    message
+                  ).message
+                );
+            }
+            try {
+              await handleResponse2(
+                ws,
+                options.message?.(
+                  new import_ws.ElysiaWS(ws, context, message),
+                  message
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async drain(ws) {
+            try {
+              await handleResponse2(
+                ws,
+                options.drain?.(
+                  new import_ws.ElysiaWS(ws, context)
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async close(ws, code, reason) {
+            try {
+              await handleResponse2(
+                ws,
+                options.close?.(
+                  new import_ws.ElysiaWS(ws, context),
+                  code,
+                  reason
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          error(ws, error) {
+            handleErrors?.(ws, error);
+          }
+        };
+        return "";
+      },
+      {
+        ...rest,
+        websocket: options
+      }
+    );
+  }
+  return { handler, context: store };
+}
+
+// src/handle.ts
+var import_srvx2 = require("srvx");
+var import_utils4 = require("elysia/adapter/utils");
+
+// src/utils.ts
+var import_srvx = require("srvx");
+var import_utils3 = require("elysia/utils");
+var handleFile = (response, set2) => {
+  if (response instanceof Promise)
+    return response.then((res) => handleFile(res, set2));
+  const size = response.size;
+  const immutable = set2 && (set2.status === 206 || set2.status === 304 || set2.status === 412 || set2.status === 416);
+  const defaultHeader = immutable ? {
+    "transfer-encoding": "chunked"
+  } : {
+    "accept-ranges": "bytes",
+    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0,
+    "transfer-encoding": "chunked"
+  };
+  if (!set2 && !size) return new import_srvx.FastResponse(response);
+  if (!set2)
+    return new import_srvx.FastResponse(response, {
+      headers: defaultHeader
+    });
+  if (set2.headers instanceof Headers) {
+    let setHeaders = defaultHeader;
+    setHeaders = {};
+    for (const [key, value] of set2.headers.entries())
+      if (key in set2.headers) setHeaders[key] = value;
+    if (immutable) {
+      delete set2.headers["content-length"];
+      delete set2.headers["accept-ranges"];
+    }
+    return new import_srvx.FastResponse(response, {
+      status: set2.status,
+      headers: setHeaders
+    });
+  }
+  if ((0, import_utils3.isNotEmpty)(set2.headers))
+    return new import_srvx.FastResponse(response, {
+      status: set2.status,
+      headers: Object.assign(defaultHeader, set2.headers)
+    });
+  return new import_srvx.FastResponse(response, {
+    status: set2.status,
+    headers: defaultHeader
+  });
+};
+
+// src/handle.ts
+var import_file = require("elysia/universal/file");
+var import_utils6 = require("elysia/utils");
+var import_cookies = require("elysia/cookies");
+var import_error = require("elysia/error");
+var handleElysiaFile = (file, set2 = {
+  headers: {}
+}) => {
+  const path = file.path;
+  const contentType = import_file.mime[path.slice(path.lastIndexOf(".") + 1)];
+  if (contentType) set2.headers["content-type"] = contentType;
+  if (file.stats && set2 && set2.status !== 206 && set2.status !== 304 && set2.status !== 412 && set2.status !== 416)
+    return file.stats.then((stat) => {
+      const size = stat.size;
+      if (size !== void 0) {
+        set2.headers["content-range"] = `bytes 0-${size - 1}/${size}`;
+        set2.headers["content-length"] = size;
+      }
+      return handleFile(file.value, set2);
+    });
+  return handleFile(file.value, set2);
+};
+var mapResponse = (response, set2, request) => {
+  if ((0, import_utils6.isNotEmpty)(set2.headers) || set2.status !== 200 || set2.cookie) {
+    (0, import_utils4.handleSet)(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new import_srvx2.FastResponse(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new import_srvx2.FastResponse(response, set2);
+      case void 0:
+        if (!response) return new import_srvx2.FastResponse("", set2);
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Promise":
+        return response.then(
+          (x) => mapResponse(x, set2, request)
+        );
+      case "Function":
+        return mapResponse(response(), set2, request);
+      case "Number":
+      case "Boolean":
+        return new import_srvx2.FastResponse(
+          response.toString(),
+          set2
+        );
+      case "Cookie":
+        if (response instanceof import_cookies.Cookie)
+          return new import_srvx2.FastResponse(response.value, set2);
+        return new import_srvx2.FastResponse(response?.toString(), set2);
+      case "FormData":
+        return new import_srvx2.FastResponse(response, set2);
+      default:
+        if (response instanceof import_srvx2.FastResponse)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof import_error.ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new import_srvx2.FastResponse(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new import_srvx2.FastResponse(response, set2);
+    }
+  }
+  if (response instanceof import_srvx2.FastResponse && !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+    return handleStream(
+      (0, import_utils4.streamResponse)(response),
+      (0, import_utils4.responseToSetHeaders)(response, set2),
+      request
+    );
+  if (
+    // @ts-expect-error
+    typeof response?.next === "function" || response instanceof ReadableStream
+  )
+    return handleStream(response, set2, request);
+  return mapCompactResponse(response, request);
+};
+var mapEarlyResponse = (response, set2, request) => {
+  if (response === void 0 || response === null) return;
+  if ((0, import_utils6.isNotEmpty)(set2.headers) || set2.status !== 200 || set2.cookie) {
+    (0, import_utils4.handleSet)(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new import_srvx2.FastResponse(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new import_srvx2.FastResponse(response, set2);
+      case void 0:
+        if (!response) return;
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Promise":
+        return response.then(
+          (x) => mapEarlyResponse(x, set2)
+        );
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapEarlyResponse(response(), set2);
+      case "Number":
+      case "Boolean":
+        return new import_srvx2.FastResponse(
+          response.toString(),
+          set2
+        );
+      case "FormData":
+        return new import_srvx2.FastResponse(response);
+      case "Cookie":
+        if (response instanceof import_cookies.Cookie)
+          return new import_srvx2.FastResponse(response.value, set2);
+        return new import_srvx2.FastResponse(response?.toString(), set2);
+      default:
+        if (response instanceof import_srvx2.FastResponse)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof import_error.ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new import_srvx2.FastResponse(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new import_srvx2.FastResponse(response, set2);
+    }
+  } else
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new import_srvx2.FastResponse(response);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new import_srvx2.FastResponse(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new import_srvx2.FastResponse(response, {
+          headers: {
+            "Content-Type": "text/event-stream; charset=utf-8"
+          }
+        });
+      case void 0:
+        if (!response) return new import_srvx2.FastResponse("");
+        return new import_srvx2.FastResponse(JSON.stringify(response), {
+          headers: {
+            "content-type": "application/json"
+          }
+        });
+      case "Response":
+        if (!response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+          return handleStream(
+            (0, import_utils4.streamResponse)(response),
+            (0, import_utils4.responseToSetHeaders)(response),
+            request
+          );
+        return response;
+      case "Promise":
+        return response.then((x) => {
+          const r = mapEarlyResponse(x, set2);
+          if (r !== void 0) return r;
+        });
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapCompactResponse(response(), request);
+      case "Number":
+      case "Boolean":
+        return new import_srvx2.FastResponse(response.toString());
+      case "Cookie":
+        if (response instanceof import_cookies.Cookie)
+          return new import_srvx2.FastResponse(response.value, set2);
+        return new import_srvx2.FastResponse(response?.toString(), set2);
+      case "FormData":
+        return new import_srvx2.FastResponse(response);
+      default:
+        if (response instanceof import_srvx2.FastResponse) return response;
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof import_error.ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new import_srvx2.FastResponse(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new import_srvx2.FastResponse(response);
+    }
+};
+var mapCompactResponse = (response, request) => {
+  switch (response?.constructor?.name) {
+    case "String":
+      return new import_srvx2.FastResponse(response, {
+        headers: {
+          "Content-Type": "text/plain"
+        }
+      });
+    case "Object":
+    case "Array":
+      return new import_srvx2.FastResponse(JSON.stringify(response), {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    case "ElysiaFile":
+      return handleElysiaFile(response);
+    case "File":
+      return handleFile(response);
+    case "Blob":
+      return handleFile(response);
+    case "ElysiaCustomStatusResponse":
+      return mapResponse(
+        response.response,
+        {
+          status: response.code,
+          headers: {}
+        }
+      );
+    case "ReadableStream":
+      request?.signal?.addEventListener(
+        "abort",
+        {
+          handleEvent() {
+            if (request?.signal && !request?.signal?.aborted)
+              response.cancel();
+          }
+        },
+        {
+          once: true
+        }
+      );
+      return new import_srvx2.FastResponse(response, {
+        headers: {
+          "Content-Type": "text/event-stream; charset=utf-8"
+        }
+      });
+    case void 0:
+      if (!response) return new import_srvx2.FastResponse("");
+      return new import_srvx2.FastResponse(JSON.stringify(response), {
+        headers: {
+          "content-type": "application/json"
+        }
+      });
+    case "Response":
+      if (response.headers.get("transfer-encoding") === "chunked")
+        return handleStream(
+          (0, import_utils4.streamResponse)(response),
+          (0, import_utils4.responseToSetHeaders)(response),
+          request
+        );
+      return response;
+    case "Error":
+      return errorToResponse(response);
+    case "Promise":
+      return response.then(
+        (x) => mapCompactResponse(x, request)
+      );
+    // ? Maybe response or Blob
+    case "Function":
+      return mapCompactResponse(response(), request);
+    case "Number":
+    case "Boolean":
+      return new import_srvx2.FastResponse(response.toString());
+    case "FormData":
+      return new import_srvx2.FastResponse(response);
+    default:
+      if (response instanceof import_srvx2.FastResponse) return response;
+      if (response instanceof Promise)
+        return response.then(
+          (x) => mapCompactResponse(x, request)
+        );
+      if (response instanceof Error)
+        return errorToResponse(response);
+      if (response instanceof import_error.ElysiaCustomStatusResponse)
+        return mapResponse(
+          response.response,
+          {
+            status: response.code,
+            headers: {}
+          }
+        );
+      if (typeof response?.next === "function")
+        return handleStream(response, void 0, request);
+      if (typeof response?.then === "function")
+        return response.then((x) => mapResponse(x, set));
+      if (typeof response?.toResponse === "function")
+        return mapCompactResponse(response.toResponse());
+      if ("charCodeAt" in response) {
+        const code = response.charCodeAt(0);
+        if (code === 123 || code === 91) {
+          return new import_srvx2.FastResponse(JSON.stringify(response), {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+      }
+      return new import_srvx2.FastResponse(response);
+  }
+};
+var errorToResponse = (error, set2) => new import_srvx2.FastResponse(
+  JSON.stringify({
+    name: error?.name,
+    message: error?.message,
+    cause: error?.cause
+  }),
+  {
+    status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
+    headers: set2?.headers
+  }
+);
+var createStaticHandler = (handle, hooks, setHeaders = {}) => {
+  if (typeof handle === "function") return;
+  const response = mapResponse(handle, {
+    headers: setHeaders
+  });
+  if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
+    return response.clone.bind(response);
+};
+var handleResponse = (0, import_utils4.createResponseHandler)({
+  mapResponse,
+  mapCompactResponse
+});
+var handleStream = (0, import_utils4.createStreamHandler)({
+  mapResponse,
+  mapCompactResponse
+});
+
+// src/index.ts
 var node = () => {
+  const ws = createWebSocketAdapter();
   return {
     ...import_web_standard.WebStandardAdapter,
-    name: "node",
+    name: "@elysiajs/node",
+    handler: {
+      mapCompactResponse,
+      mapEarlyResponse,
+      mapResponse,
+      createStaticHandler
+    },
+    ws: ws.handler,
     listen(app) {
       return (options, callback) => {
         if (typeof options === "string") {
-          if (!(0, import_utils.isNumericString)(options))
+          if (!(0, import_utils7.isNumericString)(options))
             throw new Error("Port must be a numeric value");
           options = parseInt(options);
         }
-        const { promise: serverInfo, resolve: setServerInfo } = Promise.withResolvers();
-        app.server = serverInfo;
+        const websocket = (0, import_crossws.defineHooks)({
+          async upgrade(request) {
+            const id = request.wsId = (0, import_utils7.randomId)();
+            const response = await app.handle(request);
+            const context = ws.context[id];
+            if (!context) return response;
+            return {
+              context,
+              headers: context.data.set.headers
+            };
+          },
+          open(ws2) {
+            const context = ws2.context;
+            context.open(ws2);
+          },
+          message(ws2, message) {
+            const context = ws2.context;
+            context.message(
+              ws2,
+              message.text()
+            );
+          },
+          close(ws2, detail) {
+            const context = ws2.context;
+            context.close(
+              // ws is parsed in context.open
+              ws2,
+              detail.code,
+              detail.reason
+            );
+          },
+          error(ws2, error) {
+            const context = ws2.context;
+            context.error?.(ws2, error);
+          }
+        });
         const serverOptions = typeof options === "number" ? {
           port: options,
+          silent: true,
+          websocket,
           fetch: app.fetch
         } : {
           ...options,
-          // @ts-ignore
-          host: options?.hostname
+          silent: true,
+          websocket,
+          fetch: app.fetch
         };
-        let server = (0, import_node_server.serve)(serverOptions, () => {
-          const address = server.address();
-          const hostname = typeof address === "string" ? address : address ? address.address : "localhost";
-          const port = typeof address === "string" ? 0 : address?.port ?? 0;
-          const serverInfo2 = {
-            ...server,
-            id: (0, import_utils.randomId)(),
-            development: process.env.NODE_ENV !== "production",
-            fetch: app.fetch,
-            hostname,
-            get pendingRequests() {
-              const { promise, resolve, reject } = Promise.withResolvers();
-              server.getConnections((error, total) => {
-                if (error) reject(error);
-                resolve(total);
-              });
-              return promise;
-            },
-            get pendingWebSockets() {
-              return 0;
-            },
-            port,
-            publish() {
-              throw new Error(
-                "This adapter doesn't support uWebSocket Publish method"
-              );
-            },
-            ref() {
-              server.ref();
-            },
-            unref() {
-              server.unref();
-            },
-            reload() {
-              server.close(() => {
-                server = (0, import_node_server.serve)(serverOptions);
-              });
-            },
-            requestIP() {
-              throw new Error(
-                "This adapter doesn't support Bun requestIP method"
-              );
-            },
-            stop() {
-              server.close();
-            },
-            upgrade() {
-              throw new Error(
-                "This adapter doesn't support Web Standard Upgrade method"
-              );
-            },
-            url: new URL(
-              `http://${hostname === "::" ? "localhost" : hostname}:${port}`
-            ),
-            [Symbol.dispose]() {
-              server.close();
-            },
-            raw: server
-          };
-          setServerInfo(serverInfo2);
-          if (callback) callback(serverInfo2);
-          app.modules.then(() => {
-            try {
-              serverInfo2.reload(
-                typeof options === "object" ? options : {
-                  port: options
-                }
-              );
-            } catch {
-            }
-          });
-        });
+        let server = (0, import_server.serve)(serverOptions);
+        const nodeServer = server.node?.server;
+        const hostname = server.serveOptions.host ?? "localhost";
+        const port = server.options.port;
+        const serverInfo = {
+          ...server,
+          id: (0, import_utils7.randomId)(),
+          development: process.env.NODE_ENV !== "production",
+          fetch: app.fetch,
+          hostname,
+          get pendingRequests() {
+            const { promise, resolve, reject } = Promise.withResolvers();
+            nodeServer?.getConnections((error, total) => {
+              if (error) reject(error);
+              resolve(total);
+            });
+            return promise;
+          },
+          get pendingWebSockets() {
+            return 0;
+          },
+          port,
+          publish() {
+          },
+          ref() {
+            nodeServer?.ref();
+          },
+          unref() {
+            nodeServer?.unref();
+          },
+          reload() {
+            nodeServer?.close();
+            server = (0, import_server.serve)(serverOptions);
+          },
+          requestIP() {
+            throw new Error(
+              "This adapter doesn't support Bun requestIP method"
+            );
+          },
+          stop() {
+            server.close();
+          },
+          upgrade() {
+            throw new Error(
+              "This adapter doesn't support Web Standard Upgrade method"
+            );
+          },
+          url: new URL(
+            `http://${hostname === "::" ? "localhost" : hostname}:${port}`
+          ),
+          [Symbol.dispose]() {
+            server.close();
+          },
+          raw: server
+        };
+        if (callback) callback(serverInfo);
         app.router.http.build?.();
@@ -125,0 +870,0 @@ if (app.event.start)

dist/cjs/ws.js

 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ws.ts
+var ws_exports = {};
+__export(ws_exports, {
+  createWebSocketAdapter: () => createWebSocketAdapter
+});
+module.exports = __toCommonJS(ws_exports);
+var import_elysia = require("elysia");
+var import_utils = require("elysia/adapter/utils");
+var import_utils2 = require("elysia/utils");
+var import_ws = require("elysia/ws");
+function createWebSocketAdapter() {
+  const store = {};
+  function handler(app, path, options) {
+    const { parse, body, response, ...rest } = options;
+    const validateMessage = (0, import_elysia.getSchemaValidator)(body, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
+      // @ts-expect-error private property
+      models: app.definitions.type,
+      normalize: app.config.normalize
+    });
+    const validateResponse = (0, import_elysia.getSchemaValidator)(response, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
+      // @ts-expect-error private property
+      models: app.definitions.type,
+      normalize: app.config.normalize
+    });
+    const toServerWebSocket = (peer) => {
+      const ws = peer;
+      ws.data = peer.context.context;
+      ws.sendText = ws.send;
+      ws.sendBinary = ws.send;
+      ws.publishText = ws.publish;
+      ws.publishBinary = ws.publish;
+      ws.isSubscribed = (topic) => peer.topics.has(topic);
+      ws.cork = () => {
+        console.log("ws.cork is not supported yet");
+      };
+      return ws;
+    };
+    app.route(
+      "WS",
+      path,
+      // @ts-ignore
+      async (context) => {
+        const { set, path: path2, qi, headers, query, params } = context;
+        const id = context.request.wsId;
+        context.validator = validateResponse;
+        if (options.upgrade) {
+          if (typeof options.upgrade === "function") {
+            const temp = options.upgrade(context);
+            if (temp instanceof Promise) await temp;
+          } else if (options.upgrade)
+            Object.assign(
+              set.headers,
+              options.upgrade
+            );
+        }
+        if (set.cookie && (0, import_utils2.isNotEmpty)(set.cookie)) {
+          const cookie = (0, import_elysia.serializeCookie)(set.cookie);
+          if (cookie) set.headers["set-cookie"] = cookie;
+        }
+        if (set.headers["set-cookie"] && Array.isArray(set.headers["set-cookie"]))
+          set.headers = (0, import_utils.parseSetCookies)(
+            new Headers(set.headers),
+            set.headers["set-cookie"]
+          );
+        const handleResponse = (0, import_ws.createHandleWSResponse)(validateResponse);
+        const parseMessage = parse ? (0, import_ws.createWSMessageParser)(parse) : void 0;
+        if (typeof options.beforeHandle === "function") {
+          const result = options.beforeHandle(context);
+          if (result instanceof Promise) await result;
+        }
+        const errorHandlers = [
+          ...options.error ? Array.isArray(options.error) ? options.error : [options.error] : [],
+          ...(app.event.error ?? []).map(
+            (x) => typeof x === "function" ? x : x.fn
+          )
+        ].filter((x) => x);
+        const handleErrors = errorHandlers.length ? async (ws, error) => {
+          for (const handleError of errorHandlers) {
+            let response2 = handleError(
+              Object.assign(context, { error })
+            );
+            if (response2 instanceof Promise)
+              response2 = await response2;
+            await handleResponse(ws, response2);
+            if (response2) break;
+          }
+        } : void 0;
+        store[id] = {
+          data: context,
+          validateResponse,
+          ping(data) {
+            return options.ping?.(data);
+          },
+          pong(data) {
+            return options.pong?.(data);
+          },
+          async open(_ws) {
+            const ws = toServerWebSocket(_ws);
+            try {
+              await handleResponse(
+                ws,
+                options.open?.(new import_ws.ElysiaWS(ws, context))
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async message(ws, message) {
+            if (message.includes("ping")) {
+              try {
+                return void ws.pong(message);
+              } catch (error) {
+                handleErrors?.(ws, error);
+              }
+            }
+            if (parseMessage)
+              message = await parseMessage(ws, message);
+            if (message) {
+              if (validateMessage?.Check(message) === false)
+                return void ws.send(
+                  new import_elysia.ValidationError(
+                    "message",
+                    validateMessage,
+                    message
+                  ).message
+                );
+            }
+            try {
+              await handleResponse(
+                ws,
+                options.message?.(
+                  new import_ws.ElysiaWS(ws, context, message),
+                  message
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async drain(ws) {
+            try {
+              await handleResponse(
+                ws,
+                options.drain?.(
+                  new import_ws.ElysiaWS(ws, context)
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async close(ws, code, reason) {
+            try {
+              await handleResponse(
+                ws,
+                options.close?.(
+                  new import_ws.ElysiaWS(ws, context),
+                  code,
+                  reason
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          error(ws, error) {
+            handleErrors?.(ws, error);
+          }
+        };
+        return "";
+      },
+      {
+        ...rest,
+        websocket: options
+      }
+    );
+  }
+  return { handler, context: store };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWebSocketAdapter
+});

dist/index.d.ts

 export declare const node: () => {
     name: string;
+    handler: {
+        mapCompactResponse: (response: unknown, request?: Request) => Response;
+        mapEarlyResponse: (response: unknown, set: import("elysia").Context["set"], request?: Request) => Response | undefined;
+        mapResponse: (response: unknown, set: import("elysia").Context["set"], request?: Request) => Response;
+        createStaticHandler: (handle: unknown, hooks: Partial<import("elysia/types").AnyLocalHook>, setHeaders?: import("elysia").Context["set"]["headers"]) => (() => Response) | undefined;
+    };
+    ws: (app: import("elysia").AnyElysia, path: string, options: import("elysia/ws/types").AnyWSLocalHook) => void;
     listen(app: import("elysia").AnyElysia): (options: any, callback: import("elysia/universal/server").ListenCallback | undefined) => void;
     stop?(app: import("elysia").AnyElysia, closeActiveConnections?: boolean): Promise<void>;
     isWebStandard?: boolean;
-    handler: {
-        mapResponse(response: unknown, set: import("elysia").Context["set"], ...params: unknown[]): unknown;
-        mapEarlyResponse(response: unknown, set: import("elysia").Context["set"], ...params: unknown[]): unknown;
-        mapCompactResponse(response: unknown, ...params: unknown[]): unknown;
-        createStaticHandler?(handle: unknown, hooks: import("elysia/types").AnyLocalHook, setHeaders?: import("elysia").Context["set"]["headers"], ...params: unknown[]): (() => unknown) | undefined;
-        createNativeStaticHandler?(handle: unknown, hooks: import("elysia/types").AnyLocalHook, set?: import("elysia").Context["set"]): (() => import("elysia").MaybePromise<Response>) | undefined;
-    };
     composeHandler: {
@@ -39,5 +39,5 @@ mapResponseContext?: string;
     };
-    ws?(app: import("elysia").AnyElysia, path: string, handler: import("elysia/ws/types").AnyWSLocalHook): unknown;
     createSystemRouterHandler?(method: string, path: string, hook: import("elysia/types").AnyLocalHook, app: import("elysia").AnyElysia): void;
+    beforeCompile?(app: import("elysia").AnyElysia): void;
 };
 export default node;

dist/index.mjs

 // src/index.ts
 import { WebStandardAdapter } from "elysia/adapter/web-standard";
-import { serve } from "@hono/node-server";
 import { isNumericString, randomId } from "elysia/utils";
+import { defineHooks } from "crossws";
+import { serve } from "crossws/server";
+
+// src/ws.ts
+import {
+  getSchemaValidator,
+  serializeCookie,
+  ValidationError
+} from "elysia";
+import { parseSetCookies } from "elysia/adapter/utils";
+import { isNotEmpty } from "elysia/utils";
+import {
+  createHandleWSResponse,
+  createWSMessageParser,
+  ElysiaWS
+} from "elysia/ws";
+function createWebSocketAdapter() {
+  const store = {};
+  function handler(app, path, options) {
+    const { parse, body, response, ...rest } = options;
+    const validateMessage = getSchemaValidator(body, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
+      // @ts-expect-error private property
+      models: app.definitions.type,
+      normalize: app.config.normalize
+    });
+    const validateResponse = getSchemaValidator(response, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
+      // @ts-expect-error private property
+      models: app.definitions.type,
+      normalize: app.config.normalize
+    });
+    const toServerWebSocket = (peer) => {
+      const ws = peer;
+      ws.data = peer.context.context;
+      ws.sendText = ws.send;
+      ws.sendBinary = ws.send;
+      ws.publishText = ws.publish;
+      ws.publishBinary = ws.publish;
+      ws.isSubscribed = (topic) => peer.topics.has(topic);
+      ws.cork = () => {
+        console.log("ws.cork is not supported yet");
+      };
+      return ws;
+    };
+    app.route(
+      "WS",
+      path,
+      // @ts-ignore
+      async (context) => {
+        const { set: set2, path: path2, qi, headers, query, params } = context;
+        const id = context.request.wsId;
+        context.validator = validateResponse;
+        if (options.upgrade) {
+          if (typeof options.upgrade === "function") {
+            const temp = options.upgrade(context);
+            if (temp instanceof Promise) await temp;
+          } else if (options.upgrade)
+            Object.assign(
+              set2.headers,
+              options.upgrade
+            );
+        }
+        if (set2.cookie && isNotEmpty(set2.cookie)) {
+          const cookie = serializeCookie(set2.cookie);
+          if (cookie) set2.headers["set-cookie"] = cookie;
+        }
+        if (set2.headers["set-cookie"] && Array.isArray(set2.headers["set-cookie"]))
+          set2.headers = parseSetCookies(
+            new Headers(set2.headers),
+            set2.headers["set-cookie"]
+          );
+        const handleResponse2 = createHandleWSResponse(validateResponse);
+        const parseMessage = parse ? createWSMessageParser(parse) : void 0;
+        if (typeof options.beforeHandle === "function") {
+          const result = options.beforeHandle(context);
+          if (result instanceof Promise) await result;
+        }
+        const errorHandlers = [
+          ...options.error ? Array.isArray(options.error) ? options.error : [options.error] : [],
+          ...(app.event.error ?? []).map(
+            (x) => typeof x === "function" ? x : x.fn
+          )
+        ].filter((x) => x);
+        const handleErrors = errorHandlers.length ? async (ws, error) => {
+          for (const handleError of errorHandlers) {
+            let response2 = handleError(
+              Object.assign(context, { error })
+            );
+            if (response2 instanceof Promise)
+              response2 = await response2;
+            await handleResponse2(ws, response2);
+            if (response2) break;
+          }
+        } : void 0;
+        store[id] = {
+          data: context,
+          validateResponse,
+          ping(data) {
+            return options.ping?.(data);
+          },
+          pong(data) {
+            return options.pong?.(data);
+          },
+          async open(_ws) {
+            const ws = toServerWebSocket(_ws);
+            try {
+              await handleResponse2(
+                ws,
+                options.open?.(new ElysiaWS(ws, context))
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async message(ws, message) {
+            if (message.includes("ping")) {
+              try {
+                return void ws.pong(message);
+              } catch (error) {
+                handleErrors?.(ws, error);
+              }
+            }
+            if (parseMessage)
+              message = await parseMessage(ws, message);
+            if (message) {
+              if (validateMessage?.Check(message) === false)
+                return void ws.send(
+                  new ValidationError(
+                    "message",
+                    validateMessage,
+                    message
+                  ).message
+                );
+            }
+            try {
+              await handleResponse2(
+                ws,
+                options.message?.(
+                  new ElysiaWS(ws, context, message),
+                  message
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async drain(ws) {
+            try {
+              await handleResponse2(
+                ws,
+                options.drain?.(
+                  new ElysiaWS(ws, context)
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          async close(ws, code, reason) {
+            try {
+              await handleResponse2(
+                ws,
+                options.close?.(
+                  new ElysiaWS(ws, context),
+                  code,
+                  reason
+                )
+              );
+            } catch (error) {
+              handleErrors?.(ws, error);
+            }
+          },
+          error(ws, error) {
+            handleErrors?.(ws, error);
+          }
+        };
+        return "";
+      },
+      {
+        ...rest,
+        websocket: options
+      }
+    );
+  }
+  return { handler, context: store };
+}
+
+// src/handle.ts
+import { FastResponse as Response2 } from "srvx";
+import {
+  createResponseHandler,
+  createStreamHandler,
+  handleSet,
+  responseToSetHeaders,
+  streamResponse
+} from "elysia/adapter/utils";
+
+// src/utils.ts
+import { FastResponse as Response } from "srvx";
+import { isNotEmpty as isNotEmpty2 } from "elysia/utils";
+var handleFile = (response, set2) => {
+  if (response instanceof Promise)
+    return response.then((res) => handleFile(res, set2));
+  const size = response.size;
+  const immutable = set2 && (set2.status === 206 || set2.status === 304 || set2.status === 412 || set2.status === 416);
+  const defaultHeader = immutable ? {
+    "transfer-encoding": "chunked"
+  } : {
+    "accept-ranges": "bytes",
+    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0,
+    "transfer-encoding": "chunked"
+  };
+  if (!set2 && !size) return new Response(response);
+  if (!set2)
+    return new Response(response, {
+      headers: defaultHeader
+    });
+  if (set2.headers instanceof Headers) {
+    let setHeaders = defaultHeader;
+    setHeaders = {};
+    for (const [key, value] of set2.headers.entries())
+      if (key in set2.headers) setHeaders[key] = value;
+    if (immutable) {
+      delete set2.headers["content-length"];
+      delete set2.headers["accept-ranges"];
+    }
+    return new Response(response, {
+      status: set2.status,
+      headers: setHeaders
+    });
+  }
+  if (isNotEmpty2(set2.headers))
+    return new Response(response, {
+      status: set2.status,
+      headers: Object.assign(defaultHeader, set2.headers)
+    });
+  return new Response(response, {
+    status: set2.status,
+    headers: defaultHeader
+  });
+};
+
+// src/handle.ts
+import { mime } from "elysia/universal/file";
+import { isNotEmpty as isNotEmpty3 } from "elysia/utils";
+import { Cookie } from "elysia/cookies";
+import { ElysiaCustomStatusResponse } from "elysia/error";
+var handleElysiaFile = (file, set2 = {
+  headers: {}
+}) => {
+  const path = file.path;
+  const contentType = mime[path.slice(path.lastIndexOf(".") + 1)];
+  if (contentType) set2.headers["content-type"] = contentType;
+  if (file.stats && set2 && set2.status !== 206 && set2.status !== 304 && set2.status !== 412 && set2.status !== 416)
+    return file.stats.then((stat) => {
+      const size = stat.size;
+      if (size !== void 0) {
+        set2.headers["content-range"] = `bytes 0-${size - 1}/${size}`;
+        set2.headers["content-length"] = size;
+      }
+      return handleFile(file.value, set2);
+    });
+  return handleFile(file.value, set2);
+};
+var mapResponse = (response, set2, request) => {
+  if (isNotEmpty3(set2.headers) || set2.status !== 200 || set2.cookie) {
+    handleSet(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new Response2(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new Response2(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new Response2(response, set2);
+      case void 0:
+        if (!response) return new Response2("", set2);
+        return new Response2(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Promise":
+        return response.then(
+          (x) => mapResponse(x, set2, request)
+        );
+      case "Function":
+        return mapResponse(response(), set2, request);
+      case "Number":
+      case "Boolean":
+        return new Response2(
+          response.toString(),
+          set2
+        );
+      case "Cookie":
+        if (response instanceof Cookie)
+          return new Response2(response.value, set2);
+        return new Response2(response?.toString(), set2);
+      case "FormData":
+        return new Response2(response, set2);
+      default:
+        if (response instanceof Response2)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new Response2(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new Response2(response, set2);
+    }
+  }
+  if (response instanceof Response2 && !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+    return handleStream(
+      streamResponse(response),
+      responseToSetHeaders(response, set2),
+      request
+    );
+  if (
+    // @ts-expect-error
+    typeof response?.next === "function" || response instanceof ReadableStream
+  )
+    return handleStream(response, set2, request);
+  return mapCompactResponse(response, request);
+};
+var mapEarlyResponse = (response, set2, request) => {
+  if (response === void 0 || response === null) return;
+  if (isNotEmpty3(set2.headers) || set2.status !== 200 || set2.cookie) {
+    handleSet(set2);
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new Response2(response, set2);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new Response2(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        if (!set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ))
+          set2.headers["content-type"] = "text/event-stream; charset=utf-8";
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new Response2(response, set2);
+      case void 0:
+        if (!response) return;
+        return new Response2(JSON.stringify(response), set2);
+      case "Response":
+        return handleResponse(response, set2, request);
+      case "Promise":
+        return response.then(
+          (x) => mapEarlyResponse(x, set2)
+        );
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapEarlyResponse(response(), set2);
+      case "Number":
+      case "Boolean":
+        return new Response2(
+          response.toString(),
+          set2
+        );
+      case "FormData":
+        return new Response2(response);
+      case "Cookie":
+        if (response instanceof Cookie)
+          return new Response2(response.value, set2);
+        return new Response2(response?.toString(), set2);
+      default:
+        if (response instanceof Response2)
+          return handleResponse(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new Response2(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new Response2(response, set2);
+    }
+  } else
+    switch (response?.constructor?.name) {
+      case "String":
+        set2.headers["content-type"] = "text/plain";
+        return new Response2(response);
+      case "Array":
+      case "Object":
+        set2.headers["content-type"] = "application/json";
+        return new Response2(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleElysiaFile(response, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        set2.status = response.code;
+        return mapEarlyResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              if (request?.signal && !request?.signal?.aborted)
+                response.cancel();
+            }
+          },
+          {
+            once: true
+          }
+        );
+        return new Response2(response, {
+          headers: {
+            "Content-Type": "text/event-stream; charset=utf-8"
+          }
+        });
+      case void 0:
+        if (!response) return new Response2("");
+        return new Response2(JSON.stringify(response), {
+          headers: {
+            "content-type": "application/json"
+          }
+        });
+      case "Response":
+        if (!response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked")
+          return handleStream(
+            streamResponse(response),
+            responseToSetHeaders(response),
+            request
+          );
+        return response;
+      case "Promise":
+        return response.then((x) => {
+          const r = mapEarlyResponse(x, set2);
+          if (r !== void 0) return r;
+        });
+      case "Error":
+        return errorToResponse(response, set2);
+      case "Function":
+        return mapCompactResponse(response(), request);
+      case "Number":
+      case "Boolean":
+        return new Response2(response.toString());
+      case "Cookie":
+        if (response instanceof Cookie)
+          return new Response2(response.value, set2);
+        return new Response2(response?.toString(), set2);
+      case "FormData":
+        return new Response2(response);
+      default:
+        if (response instanceof Response2) return response;
+        if (response instanceof Promise)
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (response instanceof Error)
+          return errorToResponse(response, set2);
+        if (response instanceof ElysiaCustomStatusResponse) {
+          set2.status = response.code;
+          return mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        }
+        if (typeof response?.next === "function")
+          return handleStream(response, set2, request);
+        if (typeof response?.then === "function")
+          return response.then((x) => mapEarlyResponse(x, set2));
+        if (typeof response?.toResponse === "function")
+          return mapEarlyResponse(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91) {
+            if (!set2.headers["Content-Type"])
+              set2.headers["Content-Type"] = "application/json";
+            return new Response2(
+              JSON.stringify(response),
+              set2
+            );
+          }
+        }
+        return new Response2(response);
+    }
+};
+var mapCompactResponse = (response, request) => {
+  switch (response?.constructor?.name) {
+    case "String":
+      return new Response2(response, {
+        headers: {
+          "Content-Type": "text/plain"
+        }
+      });
+    case "Object":
+    case "Array":
+      return new Response2(JSON.stringify(response), {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    case "ElysiaFile":
+      return handleElysiaFile(response);
+    case "File":
+      return handleFile(response);
+    case "Blob":
+      return handleFile(response);
+    case "ElysiaCustomStatusResponse":
+      return mapResponse(
+        response.response,
+        {
+          status: response.code,
+          headers: {}
+        }
+      );
+    case "ReadableStream":
+      request?.signal?.addEventListener(
+        "abort",
+        {
+          handleEvent() {
+            if (request?.signal && !request?.signal?.aborted)
+              response.cancel();
+          }
+        },
+        {
+          once: true
+        }
+      );
+      return new Response2(response, {
+        headers: {
+          "Content-Type": "text/event-stream; charset=utf-8"
+        }
+      });
+    case void 0:
+      if (!response) return new Response2("");
+      return new Response2(JSON.stringify(response), {
+        headers: {
+          "content-type": "application/json"
+        }
+      });
+    case "Response":
+      if (response.headers.get("transfer-encoding") === "chunked")
+        return handleStream(
+          streamResponse(response),
+          responseToSetHeaders(response),
+          request
+        );
+      return response;
+    case "Error":
+      return errorToResponse(response);
+    case "Promise":
+      return response.then(
+        (x) => mapCompactResponse(x, request)
+      );
+    // ? Maybe response or Blob
+    case "Function":
+      return mapCompactResponse(response(), request);
+    case "Number":
+    case "Boolean":
+      return new Response2(response.toString());
+    case "FormData":
+      return new Response2(response);
+    default:
+      if (response instanceof Response2) return response;
+      if (response instanceof Promise)
+        return response.then(
+          (x) => mapCompactResponse(x, request)
+        );
+      if (response instanceof Error)
+        return errorToResponse(response);
+      if (response instanceof ElysiaCustomStatusResponse)
+        return mapResponse(
+          response.response,
+          {
+            status: response.code,
+            headers: {}
+          }
+        );
+      if (typeof response?.next === "function")
+        return handleStream(response, void 0, request);
+      if (typeof response?.then === "function")
+        return response.then((x) => mapResponse(x, set));
+      if (typeof response?.toResponse === "function")
+        return mapCompactResponse(response.toResponse());
+      if ("charCodeAt" in response) {
+        const code = response.charCodeAt(0);
+        if (code === 123 || code === 91) {
+          return new Response2(JSON.stringify(response), {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+      }
+      return new Response2(response);
+  }
+};
+var errorToResponse = (error, set2) => new Response2(
+  JSON.stringify({
+    name: error?.name,
+    message: error?.message,
+    cause: error?.cause
+  }),
+  {
+    status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
+    headers: set2?.headers
+  }
+);
+var createStaticHandler = (handle, hooks, setHeaders = {}) => {
+  if (typeof handle === "function") return;
+  const response = mapResponse(handle, {
+    headers: setHeaders
+  });
+  if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
+    return response.clone.bind(response);
+};
+var handleResponse = createResponseHandler({
+  mapResponse,
+  mapCompactResponse
+});
+var handleStream = createStreamHandler({
+  mapResponse,
+  mapCompactResponse
+});
+
+// src/index.ts
 var node = () => {
+  const ws = createWebSocketAdapter();
   return {
     ...WebStandardAdapter,
-    name: "node",
+    name: "@elysiajs/node",
+    handler: {
+      mapCompactResponse,
+      mapEarlyResponse,
+      mapResponse,
+      createStaticHandler
+    },
+    ws: ws.handler,
     listen(app) {
@@ -16,84 +754,105 @@ return (options, callback) => {
         }
-        const { promise: serverInfo, resolve: setServerInfo } = Promise.withResolvers();
-        app.server = serverInfo;
+        const websocket = defineHooks({
+          async upgrade(request) {
+            const id = request.wsId = randomId();
+            const response = await app.handle(request);
+            const context = ws.context[id];
+            if (!context) return response;
+            return {
+              context,
+              headers: context.data.set.headers
+            };
+          },
+          open(ws2) {
+            const context = ws2.context;
+            context.open(ws2);
+          },
+          message(ws2, message) {
+            const context = ws2.context;
+            context.message(
+              ws2,
+              message.text()
+            );
+          },
+          close(ws2, detail) {
+            const context = ws2.context;
+            context.close(
+              // ws is parsed in context.open
+              ws2,
+              detail.code,
+              detail.reason
+            );
+          },
+          error(ws2, error) {
+            const context = ws2.context;
+            context.error?.(ws2, error);
+          }
+        });
         const serverOptions = typeof options === "number" ? {
           port: options,
+          silent: true,
+          websocket,
           fetch: app.fetch
         } : {
           ...options,
-          // @ts-ignore
-          host: options?.hostname
+          silent: true,
+          websocket,
+          fetch: app.fetch
         };
-        let server = serve(serverOptions, () => {
-          const address = server.address();
-          const hostname = typeof address === "string" ? address : address ? address.address : "localhost";
-          const port = typeof address === "string" ? 0 : address?.port ?? 0;
-          const serverInfo2 = {
-            ...server,
-            id: randomId(),
-            development: process.env.NODE_ENV !== "production",
-            fetch: app.fetch,
-            hostname,
-            get pendingRequests() {
-              const { promise, resolve, reject } = Promise.withResolvers();
-              server.getConnections((error, total) => {
-                if (error) reject(error);
-                resolve(total);
-              });
-              return promise;
-            },
-            get pendingWebSockets() {
-              return 0;
-            },
-            port,
-            publish() {
-              throw new Error(
-                "This adapter doesn't support uWebSocket Publish method"
-              );
-            },
-            ref() {
-              server.ref();
-            },
-            unref() {
-              server.unref();
-            },
-            reload() {
-              server.close(() => {
-                server = serve(serverOptions);
-              });
-            },
-            requestIP() {
-              throw new Error(
-                "This adapter doesn't support Bun requestIP method"
-              );
-            },
-            stop() {
-              server.close();
-            },
-            upgrade() {
-              throw new Error(
-                "This adapter doesn't support Web Standard Upgrade method"
-              );
-            },
-            url: new URL(
-              `http://${hostname === "::" ? "localhost" : hostname}:${port}`
-            ),
-            [Symbol.dispose]() {
-              server.close();
-            },
-            raw: server
-          };
-          setServerInfo(serverInfo2);
-          if (callback) callback(serverInfo2);
-          app.modules.then(() => {
-            try {
-              serverInfo2.reload(
-                typeof options === "object" ? options : {
-                  port: options
-                }
-              );
-            } catch {
-            }
-          });
-        });
+        let server = serve(serverOptions);
+        const nodeServer = server.node?.server;
+        const hostname = server.serveOptions.host ?? "localhost";
+        const port = server.options.port;
+        const serverInfo = {
+          ...server,
+          id: randomId(),
+          development: process.env.NODE_ENV !== "production",
+          fetch: app.fetch,
+          hostname,
+          get pendingRequests() {
+            const { promise, resolve, reject } = Promise.withResolvers();
+            nodeServer?.getConnections((error, total) => {
+              if (error) reject(error);
+              resolve(total);
+            });
+            return promise;
+          },
+          get pendingWebSockets() {
+            return 0;
+          },
+          port,
+          publish() {
+          },
+          ref() {
+            nodeServer?.ref();
+          },
+          unref() {
+            nodeServer?.unref();
+          },
+          reload() {
+            nodeServer?.close();
+            server = serve(serverOptions);
+          },
+          requestIP() {
+            throw new Error(
+              "This adapter doesn't support Bun requestIP method"
+            );
+          },
+          stop() {
+            server.close();
+          },
+          upgrade() {
+            throw new Error(
+              "This adapter doesn't support Web Standard Upgrade method"
+            );
+          },
+          url: new URL(
+            `http://${hostname === "::" ? "localhost" : hostname}:${port}`
+          ),
+          [Symbol.dispose]() {
+            server.close();
+          },
+          raw: server
+        };
+        if (callback) callback(serverInfo);
         app.router.http.build?.();
@@ -100,0 +859,0 @@ if (app.event.start)

package.json

 {
 	"name": "@elysiajs/node",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"description": "Plugin for Elysia for retreiving Bearer token",
@@ -14,3 +14,4 @@ "license": "MIT",
 	"dependencies": {
-		"@hono/node-server": "^1.19.2"
+		"crossws": "^0.4.1",
+		"srvx": "^0.8.9"
 	},
@@ -21,6 +22,6 @@ "peerDependencies": {
 	"devDependencies": {
-		"@elysiajs/cors": "^1.3.0",
-		"@elysiajs/swagger": "^1.3.0",
+		"@elysiajs/cors": "^1.4.0",
+		"@elysiajs/openapi": "^1.4.0",
 		"@types/node": "^22.10.2",
-		"elysia": "^1.4.0",
+		"elysia": "^1.4.9",
 		"eslint": "9.17.0",
@@ -27,0 +28,0 @@ "tsup": "^8.3.5",

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Network access

Supply chain risk

This module accesses the network.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Fixed alerts

Network access

Supply chain risk

This module accesses the network.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

185800

127.4%

Number of package files

22

57.14%

Lines of code

3541

889.11%

Worsened metrics

Dependency count

3

50%

Number of medium supply chain risk alerts

13

62.5%

Dependency changes

• + Added

  crossws@^0.4.1

• + Added

  srvx@^0.8.9

• + Added

  crossws@0.4.5
  (transitive)

• + Added

  srvx@0.8.16
  (transitive)

• - Removed

  @hono/node-server@^1.19.2

• - Removed

  @hono/node-server@1.19.14
  (transitive)

• - Removed

  hono@4.12.23
  (transitive)