elysia 2.0.0-beta.26 → 2.0.0-beta.28

package/README.md

@@ -15,7 +15,7 @@
 
 <br>
 
-![Elysia chan cover | bun creeate elysia app](https://github.com/user-attachments/assets/a649731a-8cba-4ca2-8424-6656cbf84956)
+![Elysia chan cover | bun create elysia app](https://github.com/user-attachments/assets/a649731a-8cba-4ca2-8424-6656cbf84956)
 
 <!---
 ```bash

package/dist/adapter/bun/index.js

@@ -52,15 +52,6 @@ async function settleServerWebSockets(lifecycle, errors) {
 	} while (lifecycle.sockets.size);
 	return true;
 }
-/**
-* ! This may looks like it would cause race condition, but it is not
-* Bun is single-threaded and synchronous, so the `finally` block will
-* always run before the next request comes in
-* @see ../origin.ts
-*
-* `finally` runs on the synchronous return of `fetch` (the returned promise is
-* not awaited), so the slot is live only for the handler's synchronous prologue
-*/
 const withOrigin = (fetch) => (request, server) => {
 	require_adapter_origin.origin.request = request;
 	try {
@@ -92,16 +83,6 @@ function isNativePath(path) {
 	}
 	return true;
 }
-/**
-* HTML bundles served by Bun's native router.
-*
-* A `:param` / `*` bundle matches before `fetch`, so with a `handoff` every
-* other route of that method is registered natively too, pointing at `fetch`;
-* Bun's specificity (exact > param > wildcard) then picks the Elysia route over
-* the bundle (Elysia's own router skips these bundles, see `#buildRouterUnsafe`).
-* If any route can't be expressed in Bun's router, dynamic bundles are skipped
-* entirely, since the bundle would shadow that route.
-*/
 function collectHTMLBundleRoutes(app, handoff, routes) {
 	let dynamic;
 	let bundles;

package/dist/adapter/bun/index.mjs

@@ -52,15 +52,6 @@ async function settleServerWebSockets(lifecycle, errors) {
 	} while (lifecycle.sockets.size);
 	return true;
 }
-/**
-* ! This may looks like it would cause race condition, but it is not
-* Bun is single-threaded and synchronous, so the `finally` block will
-* always run before the next request comes in
-* @see ../origin.ts
-*
-* `finally` runs on the synchronous return of `fetch` (the returned promise is
-* not awaited), so the slot is live only for the handler's synchronous prologue
-*/
 const withOrigin = (fetch) => (request, server) => {
 	origin.request = request;
 	try {
@@ -92,16 +83,6 @@ function isNativePath(path) {
 	}
 	return true;
 }
-/**
-* HTML bundles served by Bun's native router.
-*
-* A `:param` / `*` bundle matches before `fetch`, so with a `handoff` every
-* other route of that method is registered natively too, pointing at `fetch`;
-* Bun's specificity (exact > param > wildcard) then picks the Elysia route over
-* the bundle (Elysia's own router skips these bundles, see `#buildRouterUnsafe`).
-* If any route can't be expressed in Bun's router, dynamic bundles are skipped
-* entirely, since the bundle would shadow that route.
-*/
 function collectHTMLBundleRoutes(app, handoff, routes) {
 	let dynamic;
 	let bundles;

package/dist/adapter/origin.js

@@ -1,63 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/adapter/origin.ts
-/**
-* Provenance channel for deferred abort-signal arming.
-*
-* Bun materializes `Request.signal` lazily (~214ns on the first read), so
-* Elysia only pays for it once the pipeline can actually observe an abort,
-* that is, after it suspends. Deferring that read is only sound for the exact
-* `Request` instance `Bun.serve` handed to `fetch`: any other request
-* (`app.handle`, a non-Bun adapter, or a `.wrap()` HOC that substitutes the
-* request) may carry a user-controlled signal that is already aborted at entry
-* and therefore must be observed synchronously.
-*
-* The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
-* to run, for the compiled route's own entry probe, which is still inside that
-* same synchronous frame, then clears it in `finally`, so the window closes
-* before the first suspension and cannot leak across concurrent requests.
-* A `.wrap()` HOC that replaces the request or defers calling `next()` past a
-* microtask simply misses the window, fetch handler falls back to eager check
-*
-* ## "A single shared slot that every request writes to, so a race condition?"
-*
-* It looks like one, but it can't be. Explained like you're five:
-*
-* JavaScript only ever does ONE thing at a time. When a request comes in, the
-* adapter writes its name on the whiteboard (`origin.request = request`),
-* walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens, in `fetch`'s prologue, or at the
-* compiled route's entry when `fetch` had no hook to run first), and erases
-* the whiteboard `finally`
-* all in one uninterruptible turn. The next request's turn CANNOT start
-* until this turn is completely finished, because that is how the event loop
-* works: run-to-completion, no preemption. So request B can never see request
-* A's name on the board, by the time B's turn starts, the board was already
-* erased at the end of A's turn.
-*
-* "But the handler is async!" the `await`s inside it run LATER, in separate
-* turns. That is fine, because the check already happened: the verdict was
-* copied onto that request's own context (`'~sig'`) during the synchronous
-* part, and the code that runs after an `await` only ever reads the context,
-* never this slot.
-*
-* And if any assumption here ever breaks, a runtime that re-enters, a wrap
-* that delays, a future edit that sneaks an `await` in before the check the
-* comparison simply MISSES and the request falls back to eager arming, which
-* is the exact pre-optimization behavior. Every failure mode makes a request
-* slightly slower, never incorrect
-*
-* Adversarial proof, not just argument: `test/core/abort-race.test.ts` storms
-* concurrent servers, in-process `handle()` calls, request-substituting and
-* `next()`-delaying wraps at this slot and asserts zero misclassification.
-*
-* Never infer the Bun runtime from `fetch`'s second argument: Cloudflare
-* Workers pass `env` there.
-*
-* It's insanely stupid, but it works. As Bun is single-threaded and synchronous
-* so the `finally` block will always run before the next request comes in.
-*/
 const origin = { request: void 0 };
 
 //#endregion

package/dist/adapter/origin.mjs

@@ -1,62 +1,5 @@
 // @bun
 //#region src/adapter/origin.ts
-/**
-* Provenance channel for deferred abort-signal arming.
-*
-* Bun materializes `Request.signal` lazily (~214ns on the first read), so
-* Elysia only pays for it once the pipeline can actually observe an abort,
-* that is, after it suspends. Deferring that read is only sound for the exact
-* `Request` instance `Bun.serve` handed to `fetch`: any other request
-* (`app.handle`, a non-Bun adapter, or a `.wrap()` HOC that substitutes the
-* request) may carry a user-controlled signal that is already aborted at entry
-* and therefore must be observed synchronously.
-*
-* The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
-* to run, for the compiled route's own entry probe, which is still inside that
-* same synchronous frame, then clears it in `finally`, so the window closes
-* before the first suspension and cannot leak across concurrent requests.
-* A `.wrap()` HOC that replaces the request or defers calling `next()` past a
-* microtask simply misses the window, fetch handler falls back to eager check
-*
-* ## "A single shared slot that every request writes to, so a race condition?"
-*
-* It looks like one, but it can't be. Explained like you're five:
-*
-* JavaScript only ever does ONE thing at a time. When a request comes in, the
-* adapter writes its name on the whiteboard (`origin.request = request`),
-* walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens, in `fetch`'s prologue, or at the
-* compiled route's entry when `fetch` had no hook to run first), and erases
-* the whiteboard `finally`
-* all in one uninterruptible turn. The next request's turn CANNOT start
-* until this turn is completely finished, because that is how the event loop
-* works: run-to-completion, no preemption. So request B can never see request
-* A's name on the board, by the time B's turn starts, the board was already
-* erased at the end of A's turn.
-*
-* "But the handler is async!" the `await`s inside it run LATER, in separate
-* turns. That is fine, because the check already happened: the verdict was
-* copied onto that request's own context (`'~sig'`) during the synchronous
-* part, and the code that runs after an `await` only ever reads the context,
-* never this slot.
-*
-* And if any assumption here ever breaks, a runtime that re-enters, a wrap
-* that delays, a future edit that sneaks an `await` in before the check the
-* comparison simply MISSES and the request falls back to eager arming, which
-* is the exact pre-optimization behavior. Every failure mode makes a request
-* slightly slower, never incorrect
-*
-* Adversarial proof, not just argument: `test/core/abort-race.test.ts` storms
-* concurrent servers, in-process `handle()` calls, request-substituting and
-* `next()`-delaying wraps at this slot and asserts zero misclassification.
-*
-* Never infer the Bun runtime from `fetch`'s second argument: Cloudflare
-* Workers pass `env` there.
-*
-* It's insanely stupid, but it works. As Bun is single-threaded and synchronous
-* so the `finally` block will always run before the next request comes in.
-*/
 const origin = { request: void 0 };
 
 //#endregion

package/dist/adapter/utils.d.ts

@@ -15,7 +15,7 @@ declare function responseToSetHeaders(response: Response, set?: Context['set']):
   redirect?: never;
 } | {
   headers: any;
-  status: number | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
+  status: number | "Not Found" | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
 };
 interface CreateHandlerParameter {
   mapResponse(response: unknown, set: Context['set'], request?: Request, owned?: boolean): Response;

package/dist/adapter/utils.js

@@ -55,10 +55,8 @@ function handleFile(response, set, request, size = response.size) {
 	}
 	const body = "value" in response ? response.value : response;
 	const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
-	const defaultHeader = immutable ? require_utils.nullObject() : {
-		"accept-ranges": "bytes",
-		"content-range": size ? `bytes 0-${size - 1}/${size}` : void 0
-	};
+	const defaultHeader = immutable ? require_utils.nullObject() : { "accept-ranges": "bytes" };
+	if (!immutable && size) defaultHeader["content-range"] = `bytes 0-${size - 1}/${size}`;
 	if (!set && !size) return new Response(body);
 	if (!set) return new Response(body, { headers: defaultHeader });
 	if (set.headers instanceof Headers) {
@@ -132,7 +130,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
 		const sourceIterator = typeof generator.next === "function" ? generator : void 0;
 		let init = typedSSE ? void 0 : generator.next?.();
-		if (init instanceof Promise) init = await init;
+		if (init instanceof Promise || typeof init?.then === "function") init = await init;
 		const sign = set?.["~sign"];
 		if (sign) try {
 			await sign(set);
@@ -358,11 +356,6 @@ function mergeHeaders(responseHeaders, setHeaders) {
 	applySetHeaders(headers, setHeaders, responseHeaders);
 	return headers;
 }
-function mergeStatus(responseStatus, setStatus) {
-	if (typeof setStatus === "string") setStatus = require_constants.StatusMap[setStatus];
-	if (responseStatus === 200) return setStatus;
-	return responseStatus;
-}
 function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = false) {
 	const reader = clonedBody.getReader();
 	return new ReadableStream({
@@ -394,7 +387,8 @@ function createResponseHandler(handler) {
 		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
 		let status;
 		if (set) {
-			status = mergeStatus(response.status, set.status);
+			status = response.status === 200 ? set.status : response.status;
+			if (typeof status === "string") status = require_constants.StatusMap[status];
 			const statusUnchanged = status === void 0 || status === response.status;
 			if (!mustClone && statusUnchanged && !set.cookie && !require_utils.isNotEmpty(set.headers)) return response;
 		} else if (!mustClone) return response;
@@ -430,12 +424,6 @@ const doneResult = {
 	done: true,
 	value: void 0
 };
-/**
-* Tee a returned `ReadableStream` so afterResponse, `defer()` and derive
-* dispose wait for it, as for a tee'd generator. A `bytes()` stream is left
-* alone (exact-stream contract), and so is a `Response`: reading its `.body`
-* would move it off Bun's native send path
-*/
 function observeStream(source) {
 	if (source.locked || require_utils.isByteStream(source)) return;
 	const reader = source.getReader();
@@ -467,24 +455,6 @@ function observeStream(source) {
 		value
 	];
 }
-/**
-* Split async source into `branches` independent iterators
-*
-* A producer drains the source ahead of consumers
-*
-* To prevent long/infinite stream, the unconsumed window is capped:
-* Consumed-by-every-branch entries are trimmed off the front
-* Producer backpressures whenever the window hits `cap` ENTRIES or
-* `capBytes` bytes, whichever comes first
-*
-* Streams below both caps buffer eagerly
-* Only streams exceeding one gate on the slowest consumer
-*
-* Branch 0 is the value consumer (response/client)
-* When `return()` (client abort / early exit), source is stopped
-* so the observer branches can still reach completion instead of spinning
-* an infinite source
-*/
 function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 	const iterator = source[Symbol.asyncIterator]?.() ?? source[Symbol.iterator]();
 	const buffer = [];

package/dist/adapter/utils.mjs

@@ -55,10 +55,8 @@ function handleFile(response, set, request, size = response.size) {
 	}
 	const body = "value" in response ? response.value : response;
 	const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
-	const defaultHeader = immutable ? nullObject() : {
-		"accept-ranges": "bytes",
-		"content-range": size ? `bytes 0-${size - 1}/${size}` : void 0
-	};
+	const defaultHeader = immutable ? nullObject() : { "accept-ranges": "bytes" };
+	if (!immutable && size) defaultHeader["content-range"] = `bytes 0-${size - 1}/${size}`;
 	if (!set && !size) return new Response(body);
 	if (!set) return new Response(body, { headers: defaultHeader });
 	if (set.headers instanceof Headers) {
@@ -132,7 +130,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
 		const sourceIterator = typeof generator.next === "function" ? generator : void 0;
 		let init = typedSSE ? void 0 : generator.next?.();
-		if (init instanceof Promise) init = await init;
+		if (init instanceof Promise || typeof init?.then === "function") init = await init;
 		const sign = set?.["~sign"];
 		if (sign) try {
 			await sign(set);
@@ -358,11 +356,6 @@ function mergeHeaders(responseHeaders, setHeaders) {
 	applySetHeaders(headers, setHeaders, responseHeaders);
 	return headers;
 }
-function mergeStatus(responseStatus, setStatus) {
-	if (typeof setStatus === "string") setStatus = StatusMap[setStatus];
-	if (responseStatus === 200) return setStatus;
-	return responseStatus;
-}
 function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = false) {
 	const reader = clonedBody.getReader();
 	return new ReadableStream({
@@ -394,7 +387,8 @@ function createResponseHandler(handler) {
 		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
 		let status;
 		if (set) {
-			status = mergeStatus(response.status, set.status);
+			status = response.status === 200 ? set.status : response.status;
+			if (typeof status === "string") status = StatusMap[status];
 			const statusUnchanged = status === void 0 || status === response.status;
 			if (!mustClone && statusUnchanged && !set.cookie && !isNotEmpty(set.headers)) return response;
 		} else if (!mustClone) return response;
@@ -430,12 +424,6 @@ const doneResult = {
 	done: true,
 	value: void 0
 };
-/**
-* Tee a returned `ReadableStream` so afterResponse, `defer()` and derive
-* dispose wait for it, as for a tee'd generator. A `bytes()` stream is left
-* alone (exact-stream contract), and so is a `Response`: reading its `.body`
-* would move it off Bun's native send path
-*/
 function observeStream(source) {
 	if (source.locked || isByteStream(source)) return;
 	const reader = source.getReader();
@@ -467,24 +455,6 @@ function observeStream(source) {
 		value
 	];
 }
-/**
-* Split async source into `branches` independent iterators
-*
-* A producer drains the source ahead of consumers
-*
-* To prevent long/infinite stream, the unconsumed window is capped:
-* Consumed-by-every-branch entries are trimmed off the front
-* Producer backpressures whenever the window hits `cap` ENTRIES or
-* `capBytes` bytes, whichever comes first
-*
-* Streams below both caps buffer eagerly
-* Only streams exceeding one gate on the slowest consumer
-*
-* Branch 0 is the value consumer (response/client)
-* When `return()` (client abort / early exit), source is stopped
-* so the observer branches can still reach completion instead of spinning
-* an infinite source
-*/
 function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 	const iterator = source[Symbol.asyncIterator]?.() ?? source[Symbol.iterator]();
 	const buffer = [];

package/dist/adapter/web-standard/handler.js

@@ -13,7 +13,8 @@ const textPlainInit = { headers: { "content-type": "text/plain" } };
 function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, request) {
 	const contentType = file.type;
 	const headers = require_adapter_utils.materializeSetHeaders(set);
-	if (contentType !== "application/octet-stream") headers["content-type"] = contentType;
+	if (contentType !== "application/octet-stream") if (headers instanceof Headers) headers.set("content-type", contentType);
+	else headers["content-type"] = contentType;
 	const stats = file.stats;
 	if (stats) return stats.then((stat) => {
 		const size = stat.size;
@@ -63,7 +64,9 @@ function withStatus(response, set, request, owned) {
 		status: response.status,
 		headers: require_utils.nullObject()
 	};
-	if (response.headers) Object.assign(require_adapter_utils.materializeSetHeaders(set), response.headers);
+	if (response.headers) if (set.headers instanceof Headers) for (const [key, value] of Object.entries(response.headers)) if (key.toLowerCase() === "set-cookie") for (const cookie of Array.isArray(value) ? value : [value]) set.headers.append(key, cookie);
+	else set.headers.set(key, value);
+	else Object.assign(require_adapter_utils.materializeSetHeaders(set), response.headers);
 	return mapResponseWithSet(response.response, set, request, owned);
 }
 const checkRemovedSetRedirect = !require_universal_is_production.isProduction();
@@ -86,7 +89,9 @@ function mapCompactResponse(response, request, owned) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
 		case "ElysiaForm": return new Response(require_utils.formToFormData(response));
-		case "Object": return Response.json(response);
+		case "Object":
+			if (typeof response?.next === "function") return handleStream(response, void 0, request, void 0, owned);
+			return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(String(response));
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
@@ -125,17 +130,7 @@ function errorToResponse(error, set, request, owned = false) {
 function mapFallback(response, set, request, owned = false) {
 	if (response instanceof Response) return handleResponse(response, set, request, owned);
 	if (response instanceof Error) return errorToResponse(response, set, request, owned);
-	if (response instanceof require_error.ElysiaStatus) {
-		if (set && response.headers) {
-			set.status = response.status;
-			set.headers = {
-				...set.headers,
-				...response.headers
-			};
-			return mapResponse(response.response, set, request, owned);
-		}
-		return withStatus(response, set, request, owned);
-	}
+	if (response instanceof require_error.ElysiaStatus) return withStatus(response, set, request, owned);
 	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, set, request);
 	if (require_utils.isElysiaForm(response)) return new Response(require_utils.formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);

package/dist/adapter/web-standard/handler.mjs

@@ -13,7 +13,8 @@ const textPlainInit = { headers: { "content-type": "text/plain" } };
 function handleElysiaFile(file, set = { headers: nullObject() }, request) {
 	const contentType = file.type;
 	const headers = materializeSetHeaders(set);
-	if (contentType !== "application/octet-stream") headers["content-type"] = contentType;
+	if (contentType !== "application/octet-stream") if (headers instanceof Headers) headers.set("content-type", contentType);
+	else headers["content-type"] = contentType;
 	const stats = file.stats;
 	if (stats) return stats.then((stat) => {
 		const size = stat.size;
@@ -63,7 +64,9 @@ function withStatus(response, set, request, owned) {
 		status: response.status,
 		headers: nullObject()
 	};
-	if (response.headers) Object.assign(materializeSetHeaders(set), response.headers);
+	if (response.headers) if (set.headers instanceof Headers) for (const [key, value] of Object.entries(response.headers)) if (key.toLowerCase() === "set-cookie") for (const cookie of Array.isArray(value) ? value : [value]) set.headers.append(key, cookie);
+	else set.headers.set(key, value);
+	else Object.assign(materializeSetHeaders(set), response.headers);
 	return mapResponseWithSet(response.response, set, request, owned);
 }
 const checkRemovedSetRedirect = !isProduction();
@@ -86,7 +89,9 @@ function mapCompactResponse(response, request, owned) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
 		case "ElysiaForm": return new Response(formToFormData(response));
-		case "Object": return Response.json(response);
+		case "Object":
+			if (typeof response?.next === "function") return handleStream(response, void 0, request, void 0, owned);
+			return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(String(response));
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
@@ -125,17 +130,7 @@ function errorToResponse(error, set, request, owned = false) {
 function mapFallback(response, set, request, owned = false) {
 	if (response instanceof Response) return handleResponse(response, set, request, owned);
 	if (response instanceof Error) return errorToResponse(response, set, request, owned);
-	if (response instanceof ElysiaStatus) {
-		if (set && response.headers) {
-			set.status = response.status;
-			set.headers = {
-				...set.headers,
-				...response.headers
-			};
-			return mapResponse(response.response, set, request, owned);
-		}
-		return withStatus(response, set, request, owned);
-	}
+	if (response instanceof ElysiaStatus) return withStatus(response, set, request, owned);
 	if (response instanceof ElysiaFile) return handleElysiaFile(response, set, request);
 	if (isElysiaForm(response)) return new Response(formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);

package/dist/base.d.ts

@@ -1,10 +1,10 @@
 import { ElysiaStatus } from "./error.js";
+import { AnySchema } from "./type/types.js";
+import { AotFingerprint, CompilerSession, ProgramId } from "./compile/aot.js";
 import { ChainNode } from "./utils.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { TraceCapability, TraceHandler } from "./trace.js";
-import { AnySchema } from "./type/types.js";
-import { AotFingerprint, CompilerSession, ProgramId } from "./compile/aot.js";
 import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroOptionContext, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, ObjectMacroDefs, OptionalHandler, ParentResponse, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveUsedRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
 import { RouteErrorHooks } from "./handler/utils.js";
 import { WSCapability, WSHandlerResponse, WSLocalHook, WSMessageHandler, WSOptions, WSOptionsEntry } from "./ws/types.js";
@@ -99,7 +99,6 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~aotFingerprint'?: AotFingerprint;
   '~compilerSession'?: CompilerSession;
   '~generation'?: Generation;
-  '~introspect'?: boolean;
   '~scopeChild'?: boolean;
   '~scopeChildren'?: AnyElysia[];
   constructor(config?: ElysiaConfig<BasePath, Scope>);
@@ -228,7 +227,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    * ```typescript
    * new Elysia()
    *     .setup(({ server }) => {
-   *         console.log("Running at ${server?.url}:${server?.port}")
+   *         console.log(`Running at ${server?.url}`)
    *     })
    *     .listen(3000)
    * ```
@@ -403,7 +402,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    *     .post('/', ({ body }) => body)
    * ```
    */
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -423,7 +422,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
     error: Volatile['error'];
   }>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -465,7 +464,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: Volatile['response'];
     error: Volatile['error'];
   }>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'local', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'local', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -485,7 +484,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
     error: Volatile['error'];
   }>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'plugin', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'plugin', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -505,7 +504,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
     error: Ephemeral['error'];
   }, Volatile>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'global', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'global', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -543,7 +542,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'];
     response: Metadata['response'];
   }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
-  group<const Prefix extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Prefix>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(prefix: Prefix, schema: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
+  group<const Prefix extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Prefix>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(prefix: Prefix, schema: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
     schema: 'merge';
   } & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -922,7 +921,8 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): this;
   /**
    * ### ws
-   * Register a WebSocket route. Mirrors `.get`/`.post` ergonomics:
+   * Register a WebSocket route as `(path, options)`, `(path, handler)`, or `(path, options, handler)`.
+   * Requires `.use(websocket())` from `elysia/websocket`.
    */
   ws<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>)>(path: Path, options: WSLocalHook<Input, Schema & MacroContext, Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['derive'];