elysia 1.3.0 → 1.3.2-exp.0

package/dist/adapter/bun/compose.mjs

@@ -225,6 +225,11 @@ var isNotEmpty = (obj) => {
   for (let x in obj) return !0;
   return !1;
 };
+var supportPerMethodInlineHandler = (() => {
+  if (typeof Bun > "u") return !0;
+  let semver = Bun.version.split(".");
+  return !(+semver[0] < 1 || +semver[1] < 2 || +semver[2] < 14);
+})();
 
 // src/sucrose.ts
 var separateFunction = (code) => {
@@ -383,7 +388,7 @@ var findAlias = (type, body, depth = 0) => {
         parameters.query && (inference.query = !0), parameters.headers && (inference.headers = !0), parameters.body && (inference.body = !0), parameters.cookie && (inference.cookie = !0), parameters.set && (inference.set = !0), parameters.server && (inference.server = !0), parameters.url && (inference.url = !0), parameters.route && (inference.route = !0), parameters.path && (inference.path = !0);
         continue;
       }
-      if (!inference.query && access("query", alias) && (inference.query = !0), !inference.query && (code.includes("return " + alias) || code.includes("return " + alias + ".query")) && (inference.query = !0), !inference.headers && access("headers", alias) && (inference.headers = !0), !inference.body && access("body", alias) && (inference.body = !0), !inference.cookie && access("cookie", alias) && (inference.cookie = !0), !inference.set && access("set", alias) && (inference.set = !0), !inference.server && access("server", alias) && (inference.server = !0), inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.route && inference.url)
+      if (!inference.query && (access("query", alias) || code.includes("return " + alias) || code.includes("return " + alias + ".query")) && (inference.query = !0), !inference.headers && access("headers", alias) && (inference.headers = !0), !inference.body && access("body", alias) && (inference.body = !0), !inference.cookie && access("cookie", alias) && (inference.cookie = !0), !inference.set && access("set", alias) && (inference.set = !0), !inference.server && access("server", alias) && (inference.server = !0), !inference.route && access("route", alias) && (inference.route = !0), !inference.url && access("url", alias) && (inference.url = !0), !inference.path && access("path", alias) && (inference.path = !0), inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.route && inference.url && inference.path)
         break;
     }
   return aliases;
@@ -1155,6 +1160,134 @@ t.Form = ElysiaType.Form;
 // src/cookies.ts
 import { parse, serialize } from "cookie";
 import decode2 from "fast-decode-uri-component";
+var Cookie = class {
+  constructor(name, jar, initial = {}) {
+    this.name = name;
+    this.jar = jar;
+    this.initial = initial;
+  }
+  get cookie() {
+    return this.jar[this.name] ?? this.initial;
+  }
+  set cookie(jar) {
+    this.name in this.jar || (this.jar[this.name] = this.initial), this.jar[this.name] = jar;
+  }
+  get setCookie() {
+    return this.name in this.jar || (this.jar[this.name] = this.initial), this.jar[this.name];
+  }
+  set setCookie(jar) {
+    this.cookie = jar;
+  }
+  get value() {
+    return this.cookie.value;
+  }
+  set value(value) {
+    this.setCookie.value = value;
+  }
+  get expires() {
+    return this.cookie.expires;
+  }
+  set expires(expires) {
+    this.setCookie.expires = expires;
+  }
+  get maxAge() {
+    return this.cookie.maxAge;
+  }
+  set maxAge(maxAge) {
+    this.setCookie.maxAge = maxAge;
+  }
+  get domain() {
+    return this.cookie.domain;
+  }
+  set domain(domain) {
+    this.setCookie.domain = domain;
+  }
+  get path() {
+    return this.cookie.path;
+  }
+  set path(path) {
+    this.setCookie.path = path;
+  }
+  get secure() {
+    return this.cookie.secure;
+  }
+  set secure(secure) {
+    this.setCookie.secure = secure;
+  }
+  get httpOnly() {
+    return this.cookie.httpOnly;
+  }
+  set httpOnly(httpOnly) {
+    this.setCookie.httpOnly = httpOnly;
+  }
+  get sameSite() {
+    return this.cookie.sameSite;
+  }
+  set sameSite(sameSite) {
+    this.setCookie.sameSite = sameSite;
+  }
+  get priority() {
+    return this.cookie.priority;
+  }
+  set priority(priority) {
+    this.setCookie.priority = priority;
+  }
+  get partitioned() {
+    return this.cookie.partitioned;
+  }
+  set partitioned(partitioned) {
+    this.setCookie.partitioned = partitioned;
+  }
+  get secrets() {
+    return this.cookie.secrets;
+  }
+  set secrets(secrets) {
+    this.setCookie.secrets = secrets;
+  }
+  update(config) {
+    return this.setCookie = Object.assign(
+      this.cookie,
+      typeof config == "function" ? config(this.cookie) : config
+    ), this;
+  }
+  set(config) {
+    return this.setCookie = Object.assign(
+      {
+        ...this.initial,
+        value: this.value
+      },
+      typeof config == "function" ? config(this.cookie) : config
+    ), this;
+  }
+  remove() {
+    if (this.value !== void 0)
+      return this.set({
+        expires: /* @__PURE__ */ new Date(0),
+        maxAge: 0,
+        value: ""
+      }), this;
+  }
+  toString() {
+    return typeof this.value == "object" ? JSON.stringify(this.value) : this.value?.toString() ?? "";
+  }
+};
+var serializeCookie = (cookies) => {
+  if (!cookies || !isNotEmpty(cookies)) return;
+  let set2 = [];
+  for (let [key, property] of Object.entries(cookies)) {
+    if (!key || !property) continue;
+    let value = property.value;
+    value != null && set2.push(
+      serialize(
+        key,
+        typeof value == "object" ? JSON.stringify(value) : value + "",
+        property
+      )
+    );
+  }
+  if (set2.length !== 0)
+    return set2.length === 1 ? set2[0] : set2;
+};
 
 // src/compose.ts
 var createReport = ({
@@ -1259,6 +1392,605 @@ var createOnRequestHandler = (app, addFn) => {
   return `return function hocMap(${adapter.parameters}){return ${handler}(${adapter.parameters})}`;
 };
 
+// src/adapter/utils.ts
+var handleFile = (response, set2) => {
+  let size = response.size;
+  if (!set2 && size || size && set2 && set2.status !== 206 && set2.status !== 304 && set2.status !== 412 && set2.status !== 416) {
+    if (set2) {
+      if (set2.headers instanceof Headers) {
+        let setHeaders = {
+          "accept-ranges": "bytes",
+          "content-range": `bytes 0-${size - 1}/${size}`,
+          "transfer-encoding": "chunked"
+        };
+        if (hasHeaderShorthand)
+          setHeaders = set2.headers.toJSON();
+        else {
+          setHeaders = {};
+          for (let [key, value] of set2.headers.entries())
+            key in set2.headers && (setHeaders[key] = value);
+        }
+        return new Response(response, {
+          status: set2.status,
+          headers: setHeaders
+        });
+      }
+      if (isNotEmpty(set2.headers))
+        return new Response(response, {
+          status: set2.status,
+          headers: Object.assign(
+            {
+              "accept-ranges": "bytes",
+              "content-range": `bytes 0-${size - 1}/${size}`,
+              "transfer-encoding": "chunked"
+            },
+            set2.headers
+          )
+        });
+    }
+    return new Response(response, {
+      headers: {
+        "accept-ranges": "bytes",
+        "content-range": `bytes 0-${size - 1}/${size}`,
+        "transfer-encoding": "chunked"
+      }
+    });
+  }
+  return new Response(response);
+}, parseSetCookies = (headers, setCookie) => {
+  if (!headers) return headers;
+  headers.delete("set-cookie");
+  for (let i = 0; i < setCookie.length; i++) {
+    let index = setCookie[i].indexOf("=");
+    headers.append(
+      "set-cookie",
+      `${setCookie[i].slice(0, index)}=${setCookie[i].slice(index + 1) || ""}`
+    );
+  }
+  return headers;
+}, responseToSetHeaders = (response, set2) => {
+  if (set2?.headers) {
+    if (response)
+      if (hasHeaderShorthand)
+        Object.assign(set2.headers, response.headers.toJSON());
+      else
+        for (let [key, value] of response.headers.entries())
+          key in set2.headers && (set2.headers[key] = value);
+    return set2.status === 200 && (set2.status = response.status), set2.headers["content-encoding"] && delete set2.headers["content-encoding"], set2;
+  }
+  if (!response)
+    return {
+      headers: {},
+      status: set2?.status ?? 200
+    };
+  if (hasHeaderShorthand)
+    return set2 = {
+      headers: response.headers.toJSON(),
+      status: set2?.status ?? 200
+    }, set2.headers["content-encoding"] && delete set2.headers["content-encoding"], set2;
+  set2 = {
+    headers: {},
+    status: set2?.status ?? 200
+  };
+  for (let [key, value] of response.headers.entries())
+    key !== "content-encoding" && key in set2.headers && (set2.headers[key] = value);
+  return set2;
+}, createStreamHandler = ({ mapResponse: mapResponse2, mapCompactResponse: mapCompactResponse2 }) => async (generator, set2, request) => {
+  let init = generator.next();
+  return init instanceof Promise && (init = await init), init.done ? set2 ? mapResponse2(init.value, set2, request) : mapCompactResponse2(init.value, request) : (set2?.headers ? (set2.headers["transfer-encoding"] || (set2.headers["transfer-encoding"] = "chunked"), set2.headers["content-type"] || (set2.headers["content-type"] = "text/event-stream; charset=utf-8")) : set2 = {
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "transfer-encoding": "chunked"
+    }
+  }, new Response(
+    new ReadableStream({
+      async start(controller) {
+        let end = !1;
+        if (request?.signal?.addEventListener("abort", () => {
+          end = !0;
+          try {
+            controller.close();
+          } catch {
+          }
+        }), init.value !== void 0 && init.value !== null)
+          if (typeof init.value == "object")
+            try {
+              controller.enqueue(
+                Buffer.from(JSON.stringify(init.value))
+              );
+            } catch {
+              controller.enqueue(
+                Buffer.from(init.value.toString())
+              );
+            }
+          else
+            controller.enqueue(
+              Buffer.from(init.value.toString())
+            );
+        for await (let chunk of generator) {
+          if (end) break;
+          if (chunk != null) {
+            if (typeof chunk == "object")
+              try {
+                controller.enqueue(
+                  Buffer.from(JSON.stringify(chunk))
+                );
+              } catch {
+                controller.enqueue(
+                  Buffer.from(chunk.toString())
+                );
+              }
+            else
+              controller.enqueue(
+                Buffer.from(chunk.toString())
+              );
+            await new Promise(
+              (resolve) => setTimeout(() => resolve(), 0)
+            );
+          }
+        }
+        try {
+          controller.close();
+        } catch {
+        }
+      }
+    }),
+    set2
+  ));
+};
+async function* streamResponse(response) {
+  let body = response.body;
+  if (!body) return;
+  let reader = body.getReader(), decoder = new TextDecoder();
+  try {
+    for (; ; ) {
+      let { done, value } = await reader.read();
+      if (done) break;
+      yield decoder.decode(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var handleSet = (set2) => {
+  if (typeof set2.status == "string" && (set2.status = StatusMap[set2.status]), set2.cookie && isNotEmpty(set2.cookie)) {
+    let cookie = serializeCookie(set2.cookie);
+    cookie && (set2.headers["set-cookie"] = cookie);
+  }
+  set2.headers["set-cookie"] && Array.isArray(set2.headers["set-cookie"]) && (set2.headers = parseSetCookies(
+    new Headers(set2.headers),
+    set2.headers["set-cookie"]
+  ));
+}, createResponseHandler = (handler) => {
+  let handleStream2 = createStreamHandler(handler);
+  return (response, set2, request) => {
+    let isCookieSet = !1;
+    if (set2.headers instanceof Headers)
+      for (let key of set2.headers.keys())
+        if (key === "set-cookie") {
+          if (isCookieSet) continue;
+          isCookieSet = !0;
+          for (let cookie of set2.headers.getSetCookie())
+            response.headers.append("set-cookie", cookie);
+        } else response.headers.append(key, set2.headers?.get(key) ?? "");
+    else
+      for (let key in set2.headers)
+        response.headers.append(
+          key,
+          set2.headers[key]
+        );
+    let status2 = set2.status ?? 200;
+    return response.status !== status2 && status2 !== 200 && (response.status <= 300 || response.status > 400) ? response.text().then((value) => {
+      let newResponse = new Response(value, {
+        headers: response.headers,
+        status: set2.status
+      });
+      return !newResponse.headers.has("content-length") && newResponse.headers.get(
+        "transfer-encoding"
+      ) === "chunked" ? handleStream2(
+        streamResponse(newResponse),
+        responseToSetHeaders(newResponse, set2),
+        request
+      ) : newResponse;
+    }) : !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked" ? handleStream2(
+      streamResponse(response),
+      responseToSetHeaders(response, set2),
+      request
+    ) : response;
+  };
+};
+
+// src/adapter/bun/handler.ts
+var mapResponse = (response, set2, request) => {
+  if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
+    switch (handleSet(set2), response?.constructor?.name) {
+      case "String":
+        return new Response(response, set2);
+      case "Array":
+      case "Object":
+        return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
+      case "ElysiaFile":
+        return handleFile(response.value);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        return set2.status = response.code, mapResponse(
+          response.response,
+          set2,
+          request
+        );
+      case "ReadableStream":
+        return set2.headers["content-type"]?.startsWith(
+          "text/event-stream"
+        ) || (set2.headers["content-type"] = "text/event-stream; charset=utf-8"), request?.signal?.addEventListener(
+          "abort",
+          {
+            handleEvent() {
+              request?.signal && !request?.signal?.aborted && response.cancel();
+            }
+          },
+          {
+            once: !0
+          }
+        ), new Response(response, set2);
+      case void 0:
+        return response ? new Response(JSON.stringify(response), set2) : new 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 Response(
+          response.toString(),
+          set2
+        );
+      case "Cookie":
+        return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+      case "FormData":
+        return new Response(response, set2);
+      default:
+        if (response instanceof Response)
+          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)
+          return set2.status = response.code, 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) {
+          let code = response.charCodeAt(0);
+          if (code === 123 || code === 91)
+            return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(
+              JSON.stringify(response),
+              set2
+            );
+        }
+        return new Response(response, set2);
+    }
+  return response instanceof Response && !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked" ? handleStream(
+    streamResponse(response),
+    responseToSetHeaders(response, set2),
+    request
+  ) : (
+    // @ts-expect-error
+    typeof response?.next == "function" || response instanceof ReadableStream ? handleStream(response, set2, request) : mapCompactResponse(response, request)
+  );
+}, mapEarlyResponse = (response, set2, request) => {
+  if (response != null)
+    if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
+      switch (handleSet(set2), response?.constructor?.name) {
+        case "String":
+          return new Response(response, set2);
+        case "Array":
+        case "Object":
+          return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
+        case "ElysiaFile":
+          return handleFile(response.value);
+        case "File":
+          return handleFile(response, set2);
+        case "Blob":
+          return handleFile(response, set2);
+        case "ElysiaCustomStatusResponse":
+          return set2.status = response.code, mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        case "ReadableStream":
+          return set2.headers["content-type"]?.startsWith(
+            "text/event-stream"
+          ) || (set2.headers["content-type"] = "text/event-stream; charset=utf-8"), request?.signal?.addEventListener(
+            "abort",
+            {
+              handleEvent() {
+                request?.signal && !request?.signal?.aborted && response.cancel();
+              }
+            },
+            {
+              once: !0
+            }
+          ), new Response(response, set2);
+        case void 0:
+          return response ? new Response(JSON.stringify(response), set2) : void 0;
+        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 Response(
+            response.toString(),
+            set2
+          );
+        case "FormData":
+          return new Response(response);
+        case "Cookie":
+          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+        default:
+          if (response instanceof Response)
+            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)
+            return set2.status = response.code, 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) {
+            let code = response.charCodeAt(0);
+            if (code === 123 || code === 91)
+              return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(
+                JSON.stringify(response),
+                set2
+              );
+          }
+          return new Response(response, set2);
+      }
+    else
+      switch (response?.constructor?.name) {
+        case "String":
+          return new Response(response);
+        case "Array":
+        case "Object":
+          return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
+        case "ElysiaFile":
+          return handleFile(response.value);
+        case "File":
+          return handleFile(response, set2);
+        case "Blob":
+          return handleFile(response, set2);
+        case "ElysiaCustomStatusResponse":
+          return set2.status = response.code, mapEarlyResponse(
+            response.response,
+            set2,
+            request
+          );
+        case "ReadableStream":
+          return request?.signal?.addEventListener(
+            "abort",
+            {
+              handleEvent() {
+                request?.signal && !request?.signal?.aborted && response.cancel();
+              }
+            },
+            {
+              once: !0
+            }
+          ), new Response(response, {
+            headers: {
+              "Content-Type": "text/event-stream; charset=utf-8"
+            }
+          });
+        case void 0:
+          return response ? new Response(JSON.stringify(response), {
+            headers: {
+              "content-type": "application/json"
+            }
+          }) : new Response("");
+        case "Response":
+          return !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked" ? handleStream(
+            streamResponse(response),
+            responseToSetHeaders(response),
+            request
+          ) : response;
+        case "Promise":
+          return response.then((x) => {
+            let 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 Response(response.toString());
+        case "Cookie":
+          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+        case "FormData":
+          return new Response(response);
+        default:
+          if (response instanceof Response) 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)
+            return set2.status = response.code, 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) {
+            let code = response.charCodeAt(0);
+            if (code === 123 || code === 91)
+              return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(
+                JSON.stringify(response),
+                set2
+              );
+          }
+          return new Response(response);
+      }
+}, mapCompactResponse = (response, request) => {
+  switch (response?.constructor?.name) {
+    case "String":
+      return new Response(response);
+    case "Object":
+    case "Array":
+      return new Response(JSON.stringify(response), {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    case "ElysiaFile":
+      return handleFile(response.value);
+    case "File":
+      return handleFile(response);
+    case "Blob":
+      return handleFile(response);
+    case "ElysiaCustomStatusResponse":
+      return mapResponse(
+        response.response,
+        {
+          status: response.code,
+          headers: {}
+        }
+      );
+    case "ReadableStream":
+      return request?.signal?.addEventListener(
+        "abort",
+        {
+          handleEvent() {
+            request?.signal && !request?.signal?.aborted && response.cancel();
+          }
+        },
+        {
+          once: !0
+        }
+      ), new Response(response, {
+        headers: {
+          "Content-Type": "text/event-stream; charset=utf-8"
+        }
+      });
+    case void 0:
+      return response ? new Response(JSON.stringify(response), {
+        headers: {
+          "content-type": "application/json"
+        }
+      }) : new Response("");
+    case "Response":
+      return response.headers.get("transfer-encoding") === "chunked" ? handleStream(
+        streamResponse(response),
+        responseToSetHeaders(response),
+        request
+      ) : 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 Response(response.toString());
+    case "FormData":
+      return new Response(response);
+    default:
+      if (response instanceof Response) 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) {
+        let code = response.charCodeAt(0);
+        if (code === 123 || code === 91)
+          return new Response(JSON.stringify(response), {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+      }
+      return new Response(response);
+  }
+}, errorToResponse = (error, set2) => new Response(
+  JSON.stringify({
+    name: error?.name,
+    message: error?.message,
+    cause: error?.cause
+  }),
+  {
+    status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
+    headers: set2?.headers
+  }
+);
+var handleResponse = createResponseHandler({
+  mapResponse,
+  mapCompactResponse
+}), handleStream = createStreamHandler({
+  mapResponse,
+  mapCompactResponse
+});
+
 // src/adapter/bun/compose.ts
 var allocateIf = (value, condition) => condition ? value : "", createContext = (app, route, inference, isInline = !1) => {
   let fnLiteral = "", defaultHeaders = app.setHeaders, hasTrace = !!app.event.trace?.length;
@@ -1294,7 +2026,7 @@ return u.substring(s,qi)
     },
     inference
   );
-  let fnLiteral = "const handler=data.handler,app=data.app,store=data.store,decorator=data.decorator,redirect=data.redirect,route=data.route," + allocateIf("randomId=data.randomId,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID=data.ELYSIA_REQUEST_ID,", hasTrace) + allocateIf("ELYSIA_TRACE=data.ELYSIA_TRACE,", hasTrace) + allocateIf("trace=data.trace,", hasTrace) + allocateIf("hoc=data.hoc,", hasHoc) + `status=data.status
+  let fnLiteral = "const handler=data.handler,app=data.app,store=data.store,decorator=data.decorator,redirect=data.redirect,route=data.route,mapEarlyResponse=data.mapEarlyResponse," + allocateIf("randomId=data.randomId,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID=data.ELYSIA_REQUEST_ID,", hasTrace) + allocateIf("ELYSIA_TRACE=data.ELYSIA_TRACE,", hasTrace) + allocateIf("trace=data.trace,", hasTrace) + allocateIf("hoc=data.hoc,", hasHoc) + `status=data.status
 `;
   return app.event.request?.length && (fnLiteral += `const onRequest=app.event.request.map(x=>x.fn)
 `), fnLiteral += `${app.event.request?.find(isAsync) ? "async" : ""} function map(request){`, hasTrace || inference.query || app.event.request?.length ? (fnLiteral += createContext(app, route, inference), fnLiteral += createOnRequestHandler(app), fnLiteral += "return handler(c)}") : fnLiteral += `return handler(${createContext(app, route, inference, !0)})}`, fnLiteral += createHoc(app), Function(
@@ -1313,7 +2045,8 @@ return u.substring(s,qi)
     randomId: hasTrace ? randomId : void 0,
     ELYSIA_TRACE: hasTrace ? ELYSIA_TRACE : void 0,
     ELYSIA_REQUEST_ID: hasTrace ? ELYSIA_REQUEST_ID : void 0,
-    trace: hasTrace ? app.event.trace?.map((x) => x?.fn ?? x) : void 0
+    trace: hasTrace ? app.event.trace?.map((x) => x?.fn ?? x) : void 0,
+    mapEarlyResponse
   });
 };
 export {