elysia 2.0.0-beta.12 → 2.0.0-beta.13

package/dist/adapter/bun/index.js

@@ -167,12 +167,10 @@ const BunAdapter = require_adapter_index.createAdapter({
 	response: require_adapter_web_standard_index.WebStandardAdapter.response,
 	listen(app, options, callback) {
 		if (app.server || app["~ext"]?.stop) throw new Error("[Elysia] Cannot call listen() while a server or teardown is active");
+		const requestReady = Promise.withResolvers();
 		function gatedFetch(request, server) {
-			return live ? live(request, server) : Promise.resolve(ready).then(async () => {
-				if (!live) {
-					await startupShutdown;
-					throw new Error("[Elysia] Server was stopped before it was ready");
-				}
+			return live && !cancelled ? live(request, server) : requestReady.promise.then(() => {
+				if (cancelled || !live) return unavailableFetch();
 				return live(request, server);
 			});
 		}
@@ -194,7 +192,6 @@ const BunAdapter = require_adapter_index.createAdapter({
 		} : serve);
 		let live;
 		let cancelled = false;
-		let startupShutdown;
 		let shutdownAttempt;
 		let ready;
 		let wsLifecycle;
@@ -280,7 +277,9 @@ const BunAdapter = require_adapter_index.createAdapter({
 		};
 		const nativeStop = async (closeActiveConnections, errors) => {
 			try {
-				await server.stop(closeActiveConnections);
+				const stopping = server.stop(closeActiveConnections);
+				await (closeActiveConnections ? stopping : Promise.race([stopping, force.promise]));
+				if (!closeActiveConnections && forceRequested && !forceDone) return false;
 				nativeStopped = true;
 				if (closeActiveConnections) {
 					forceDone = true;
@@ -368,6 +367,7 @@ const BunAdapter = require_adapter_index.createAdapter({
 				if (!forceDone) forceRequested = true;
 			}
 			cancelled = true;
+			requestReady.resolve();
 			clearAppServer(app, server);
 			let outcome;
 			if (shutdownAttempt) {
@@ -436,7 +436,6 @@ const BunAdapter = require_adapter_index.createAdapter({
 					}
 				})().then(resolve, reject);
 			}
-			if (!published) startupShutdown ??= outcome;
 			if (!reentrant) return outcome;
 			if (observedOutcome !== outcome) {
 				observedOutcome = outcome;
@@ -448,18 +447,30 @@ const BunAdapter = require_adapter_index.createAdapter({
 		};
 		ext.stop = stop;
 		const publish = () => {
-			if (cancelled || app.server !== server) return;
-			built ??= build();
-			live = serve.fetch = withOrigin(built.fetch);
-			published = true;
-			if (built.websocket) serve.websocket = built.websocket;
-			if (built.routes) serve.routes = built.routes;
-			reloadServer(server, serve);
-			if (callback) callback(server);
+			if (cancelled || app.server !== server) {
+				requestReady.resolve();
+				return;
+			}
+			try {
+				built ??= build();
+				live = serve.fetch = withOrigin(built.fetch);
+				published = true;
+				if (built.websocket) serve.websocket = built.websocket;
+				if (built.routes) serve.routes = built.routes;
+				reloadServer(server, serve);
+				if (callback) callback(server);
+			} catch (error) {
+				startupFailure ??= { error };
+				throw error;
+			}
+			requestReady.resolve();
 		};
 		const start = () => {
 			modulesReady = void 0;
-			if (cancelled || app.server !== server) return;
+			if (cancelled || app.server !== server) {
+				requestReady.resolve();
+				return;
+			}
 			const setupReady = setup();
 			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
 			publish();

package/dist/adapter/bun/index.mjs

@@ -166,12 +166,10 @@ const BunAdapter = createAdapter({
 	response: WebStandardAdapter.response,
 	listen(app, options, callback) {
 		if (app.server || app["~ext"]?.stop) throw new Error("[Elysia] Cannot call listen() while a server or teardown is active");
+		const requestReady = Promise.withResolvers();
 		function gatedFetch(request, server) {
-			return live ? live(request, server) : Promise.resolve(ready).then(async () => {
-				if (!live) {
-					await startupShutdown;
-					throw new Error("[Elysia] Server was stopped before it was ready");
-				}
+			return live && !cancelled ? live(request, server) : requestReady.promise.then(() => {
+				if (cancelled || !live) return unavailableFetch();
 				return live(request, server);
 			});
 		}
@@ -193,7 +191,6 @@ const BunAdapter = createAdapter({
 		} : serve);
 		let live;
 		let cancelled = false;
-		let startupShutdown;
 		let shutdownAttempt;
 		let ready;
 		let wsLifecycle;
@@ -279,7 +276,9 @@ const BunAdapter = createAdapter({
 		};
 		const nativeStop = async (closeActiveConnections, errors) => {
 			try {
-				await server.stop(closeActiveConnections);
+				const stopping = server.stop(closeActiveConnections);
+				await (closeActiveConnections ? stopping : Promise.race([stopping, force.promise]));
+				if (!closeActiveConnections && forceRequested && !forceDone) return false;
 				nativeStopped = true;
 				if (closeActiveConnections) {
 					forceDone = true;
@@ -367,6 +366,7 @@ const BunAdapter = createAdapter({
 				if (!forceDone) forceRequested = true;
 			}
 			cancelled = true;
+			requestReady.resolve();
 			clearAppServer(app, server);
 			let outcome;
 			if (shutdownAttempt) {
@@ -435,7 +435,6 @@ const BunAdapter = createAdapter({
 					}
 				})().then(resolve, reject);
 			}
-			if (!published) startupShutdown ??= outcome;
 			if (!reentrant) return outcome;
 			if (observedOutcome !== outcome) {
 				observedOutcome = outcome;
@@ -447,18 +446,30 @@ const BunAdapter = createAdapter({
 		};
 		ext.stop = stop;
 		const publish = () => {
-			if (cancelled || app.server !== server) return;
-			built ??= build();
-			live = serve.fetch = withOrigin(built.fetch);
-			published = true;
-			if (built.websocket) serve.websocket = built.websocket;
-			if (built.routes) serve.routes = built.routes;
-			reloadServer(server, serve);
-			if (callback) callback(server);
+			if (cancelled || app.server !== server) {
+				requestReady.resolve();
+				return;
+			}
+			try {
+				built ??= build();
+				live = serve.fetch = withOrigin(built.fetch);
+				published = true;
+				if (built.websocket) serve.websocket = built.websocket;
+				if (built.routes) serve.routes = built.routes;
+				reloadServer(server, serve);
+				if (callback) callback(server);
+			} catch (error) {
+				startupFailure ??= { error };
+				throw error;
+			}
+			requestReady.resolve();
 		};
 		const start = () => {
 			modulesReady = void 0;
-			if (cancelled || app.server !== server) return;
+			if (cancelled || app.server !== server) {
+				requestReady.resolve();
+				return;
+			}
 			const setupReady = setup();
 			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
 			publish();

package/dist/adapter/utils.js

@@ -145,6 +145,7 @@ function enqueueBinaryChunk(controller, chunk) {
 }
 function createStreamHandler({ mapResponse, mapCompactResponse }) {
 	return async (generator, set, request, skipFormat, owned = false) => {
+		if (request === null) return void 0;
 		if (require_utils.isByteStream(generator)) {
 			if (generator.locked) throw new TypeError("Cannot transfer a locked or consumed byte stream");
 			if (set) {

package/dist/adapter/utils.mjs

@@ -144,6 +144,7 @@ function enqueueBinaryChunk(controller, chunk) {
 }
 function createStreamHandler({ mapResponse, mapCompactResponse }) {
 	return async (generator, set, request, skipFormat, owned = false) => {
+		if (request === null) return void 0;
 		if (isByteStream(generator)) {
 			if (generator.locked) throw new TypeError("Cannot transfer a locked or consumed byte stream");
 			if (set) {

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

@@ -137,11 +137,11 @@ function mapFallback(response, set, request, owned = false) {
 		status: response.status,
 		headers: response.headers ? { ...response.headers } : {}
 	}, request, owned);
-	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, void 0, request);
+	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);
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
-	if (Array.isArray(response)) return Response.json(response);
+	if (Array.isArray(response)) return Response.json(response, set);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
 	if (responseTag(response) === "Cookie" && require_cookie_cookie.Cookie.isCookie(response)) return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);

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

@@ -136,11 +136,11 @@ function mapFallback(response, set, request, owned = false) {
 		status: response.status,
 		headers: response.headers ? { ...response.headers } : {}
 	}, request, owned);
-	if (response instanceof ElysiaFile) return handleElysiaFile(response, void 0, request);
+	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);
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
-	if (Array.isArray(response)) return Response.json(response);
+	if (Array.isArray(response)) return Response.json(response, set);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
 	if (responseTag(response) === "Cookie" && Cookie.isCookie(response)) return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);

package/dist/compile/aot-emit.js

@@ -28,7 +28,7 @@ function reconstructCheckCode(build) {
 	const { defs, value } = reconstructCheck(build);
 	return checkCode(defs, value);
 }
-const checkFactorySource = (identifier, code) => `function(${identifier}){${code}}`;
+const checkFactorySource = (identifier, code) => `(${identifier})=>{${code}}`;
 const handlerFactorySource = (alias, code) => `function(h${alias ? "," + alias : ""}){return ${code}}`;
 function externalsMatch(a, b) {
 	if (a.length !== b.length) return false;

package/dist/compile/aot-emit.mjs

@@ -27,7 +27,7 @@ function reconstructCheckCode(build) {
 	const { defs, value } = reconstructCheck(build);
 	return checkCode(defs, value);
 }
-const checkFactorySource = (identifier, code) => `function(${identifier}){${code}}`;
+const checkFactorySource = (identifier, code) => `(${identifier})=>{${code}}`;
 const handlerFactorySource = (alias, code) => `function(h${alias ? "," + alias : ""}){return ${code}}`;
 function externalsMatch(a, b) {
 	if (a.length !== b.length) return false;

package/dist/compile/aot.d.ts

@@ -1,6 +1,6 @@
 import { CoerceNode } from "../type/coerce-plan.js";
 //#region src/compile/aot.d.ts
-declare const AOT_MANIFEST_FORMAT = 3;
+declare const AOT_MANIFEST_FORMAT = 4;
 declare const AOT_ABI: string;
 interface AotFingerprint {
   abi: string;

package/dist/compile/aot.js

@@ -4,8 +4,8 @@ const require_universal_env = require('../universal/env.js');
 const require_package = require('../package.js');
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 3;
-const AOT_ABI = `${require_package.version}:${3}`;
+const AOT_MANIFEST_FORMAT = 4;
+const AOT_ABI = `${require_package.version}:${4}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;

package/dist/compile/aot.mjs

@@ -3,8 +3,8 @@ import { env } from "../universal/env.mjs";
 import { version } from "../package.mjs";
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 3;
-const AOT_ABI = `${version}:${3}`;
+const AOT_MANIFEST_FORMAT = 4;
+const AOT_ABI = `${version}:${4}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;

package/dist/compile/handler/descriptor.d.ts

@@ -65,10 +65,9 @@ interface DescribeRouteInput {
  * Populated on each JIT compile, and read only by tests and introspection
  */
 declare const routeDescriptors: WeakMap<AnyElysia, Map<string, RouteDescriptor>>;
-declare function mayReturnIdentifier(fn: Function): boolean;
-declare const lifecycleMayReturnPromise: (handlers: MaybeArray<Function> | undefined, observed: boolean) => boolean;
+declare const lifecycleMayReturnPromise: (handlers: MaybeArray<Function> | undefined) => boolean;
 /** Whether a hook can be skipped by a native static response. */
 declare function isEmptyPipelineHook(hook: AnyLocalHook | undefined): boolean;
 declare function describeRoute(input: DescribeRouteInput): RouteCompileState;
 //#endregion
-export { DescribeRouteInput, RouteCompileState, RouteDescriptor, describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, mayReturnIdentifier, routeDescriptors };
+export { DescribeRouteInput, RouteCompileState, RouteDescriptor, describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, routeDescriptors };

package/dist/compile/handler/descriptor.js

@@ -15,16 +15,7 @@ const require_sucrose = require('../../sucrose.js');
 */
 const routeDescriptors = /* @__PURE__ */ new WeakMap();
 const noTracePhases = /* @__PURE__ */ new Set();
-const matchReturnIdentifier = /(?:=>\s*|\breturn\s+)(?!(?:true|false|null|undefined|void|new|typeof|async|await|function|class)\b)[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*\s*(?![\w$([])/;
-const mayReturnIdentifierCache = /* @__PURE__ */ new WeakMap();
-function mayReturnIdentifier(fn) {
-	let result = mayReturnIdentifierCache.get(fn);
-	if (result !== void 0) return result;
-	result = matchReturnIdentifier.test(fn.toString());
-	mayReturnIdentifierCache.set(fn, result);
-	return result;
-}
-const lifecycleMayReturnPromise = (handlers, observed) => handlers ? Array.isArray(handlers) ? handlers.some((fn) => !require_compile_utils.isAsyncFunction(fn) && (require_compile_utils.mayReturnPromise(fn) || observed && mayReturnIdentifier(fn))) : !require_compile_utils.isAsyncFunction(handlers) && (require_compile_utils.mayReturnPromise(handlers) || observed && mayReturnIdentifier(handlers)) : false;
+const lifecycleMayReturnPromise = (handlers) => handlers ? Array.isArray(handlers) ? handlers.some(require_compile_utils.mayReturnPromise) : require_compile_utils.mayReturnPromise(handlers) : false;
 const compactPrefixInference = /* @__PURE__ */ new WeakMap();
 const compactPrefixAsync = /* @__PURE__ */ new WeakMap();
 const inferCompactPrefix = (prefix) => {
@@ -66,7 +57,7 @@ function compactPrefixForcesAsync(prefix) {
 		const item = pending[i];
 		for (let j = 0; !value && j < item.added.length; j++) {
 			const fn = item.added[j];
-			value = require_compile_utils.isAsyncFunction(fn) || !require_compile_utils.isAsyncFunction(fn) && (require_compile_utils.mayReturnPromise(fn) || mayReturnIdentifier(fn));
+			value = require_compile_utils.mayReturnPromise(fn);
 		}
 		compactPrefixAsync.set(item, value);
 	}
@@ -134,11 +125,11 @@ function describeRoute(input) {
 		}
 	}
 	const handlerIsAsync = isHandleFunction && require_compile_utils.isAsyncFunction(handler);
-	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || require_compile_utils.isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error, false));
+	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || require_compile_utils.isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error));
 	const afterResponseForcesAsync = hasStaticAfterResponse && require_compile_utils.isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
-	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && (require_compile_utils.mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && (require_compile_utils.mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle, true) || lifecycleMayReturnPromise(hook.transform, false) || lifecycleMayReturnPromise(hook.afterHandle, true) || lifecycleMayReturnPromise(hook.mapResponse, true));
+	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && require_compile_utils.mayReturnPromise(handler);
+	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && require_compile_utils.mayReturnPromise(handler);
+	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle) || lifecycleMayReturnPromise(hook.transform) || lifecycleMayReturnPromise(hook.afterHandle) || lifecycleMayReturnPromise(hook.mapResponse));
 	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || hook && (!!require_compile_utils.isAsyncLifecycle(hook?.afterHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.beforeHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.transform) || !!require_compile_utils.isAsyncLifecycle(hook?.mapResponse) || !!require_compile_utils.isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
@@ -192,5 +183,4 @@ function describeRoute(input) {
 exports.describeRoute = describeRoute;
 exports.isEmptyPipelineHook = isEmptyPipelineHook;
 exports.lifecycleMayReturnPromise = lifecycleMayReturnPromise;
-exports.mayReturnIdentifier = mayReturnIdentifier;
 exports.routeDescriptors = routeDescriptors;

package/dist/compile/handler/descriptor.mjs

@@ -14,16 +14,7 @@ import { mergeInference, sucrose } from "../../sucrose.mjs";
 */
 const routeDescriptors = /* @__PURE__ */ new WeakMap();
 const noTracePhases = /* @__PURE__ */ new Set();
-const matchReturnIdentifier = /(?:=>\s*|\breturn\s+)(?!(?:true|false|null|undefined|void|new|typeof|async|await|function|class)\b)[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*\s*(?![\w$([])/;
-const mayReturnIdentifierCache = /* @__PURE__ */ new WeakMap();
-function mayReturnIdentifier(fn) {
-	let result = mayReturnIdentifierCache.get(fn);
-	if (result !== void 0) return result;
-	result = matchReturnIdentifier.test(fn.toString());
-	mayReturnIdentifierCache.set(fn, result);
-	return result;
-}
-const lifecycleMayReturnPromise = (handlers, observed) => handlers ? Array.isArray(handlers) ? handlers.some((fn) => !isAsyncFunction(fn) && (mayReturnPromise(fn) || observed && mayReturnIdentifier(fn))) : !isAsyncFunction(handlers) && (mayReturnPromise(handlers) || observed && mayReturnIdentifier(handlers)) : false;
+const lifecycleMayReturnPromise = (handlers) => handlers ? Array.isArray(handlers) ? handlers.some(mayReturnPromise) : mayReturnPromise(handlers) : false;
 const compactPrefixInference = /* @__PURE__ */ new WeakMap();
 const compactPrefixAsync = /* @__PURE__ */ new WeakMap();
 const inferCompactPrefix = (prefix) => {
@@ -65,7 +56,7 @@ function compactPrefixForcesAsync(prefix) {
 		const item = pending[i];
 		for (let j = 0; !value && j < item.added.length; j++) {
 			const fn = item.added[j];
-			value = isAsyncFunction(fn) || !isAsyncFunction(fn) && (mayReturnPromise(fn) || mayReturnIdentifier(fn));
+			value = mayReturnPromise(fn);
 		}
 		compactPrefixAsync.set(item, value);
 	}
@@ -133,11 +124,11 @@ function describeRoute(input) {
 		}
 	}
 	const handlerIsAsync = isHandleFunction && isAsyncFunction(handler);
-	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error, false));
+	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error));
 	const afterResponseForcesAsync = hasStaticAfterResponse && isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
-	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle, true) || lifecycleMayReturnPromise(hook.transform, false) || lifecycleMayReturnPromise(hook.afterHandle, true) || lifecycleMayReturnPromise(hook.mapResponse, true));
+	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && mayReturnPromise(handler);
+	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && mayReturnPromise(handler);
+	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle) || lifecycleMayReturnPromise(hook.transform) || lifecycleMayReturnPromise(hook.afterHandle) || lifecycleMayReturnPromise(hook.mapResponse));
 	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || hook && (!!isAsyncLifecycle(hook?.afterHandle) || !!isAsyncLifecycle(hook?.beforeHandle) || !!isAsyncLifecycle(hook?.transform) || !!isAsyncLifecycle(hook?.mapResponse) || !!isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
@@ -188,4 +179,4 @@ function describeRoute(input) {
 }
 
 //#endregion
-export { describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, mayReturnIdentifier, routeDescriptors };
+export { describeRoute, isEmptyPipelineHook, lifecycleMayReturnPromise, routeDescriptors };

package/dist/compile/handler/index.d.ts

@@ -14,7 +14,7 @@ declare function clearHandlerAnalysisCaches(root: AnyElysia): void;
 declare function chainResolver(root: AnyElysia): ((node: ChainNode) => Partial<AppHook> | undefined) | undefined;
 declare const localMacroRoot: (instance: AnyElysia, root: AnyElysia) => AnyElysia;
 declare function buildNativeStaticResponse(route: InternalRoute, root: AnyElysia): Response | undefined;
-declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia): AnyLocalHook | undefined;
+declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia, allowCompactPrefix?: boolean): AnyLocalHook | undefined;
 declare function compileHandler(route: InternalRoute, root: AnyElysia, precomputedStatic?: Response, liveOnly?: boolean): CompiledHandler;
 //#endregion
 export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };

package/dist/compile/handler/index.js

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../../universal/constants.js');
 const require_universal_file = require('../../universal/file.js');
 const require_utils = require('../../utils.js');
+const require_adapter_web_standard_handler = require('../../adapter/web-standard/handler.js');
 const require_compile_aot = require('../aot.js');
 const require_generation = require('../../generation.js');
 const require_compile_handler_params = require('./params.js');
@@ -224,13 +225,16 @@ function buildNativeStaticResponse(route, root) {
 	if (hook && !require_compile_handler_descriptor.isEmptyPipelineHook(hook)) return;
 	const rootHeaders = frozenRoot["~ext"]?.headers;
 	if (handler instanceof Response && !rootHeaders) return handler;
-	const mapped = adapter.response.map(handler, { headers: rootHeaders ? Object.assign(require_utils.nullObject(), rootHeaders) : require_utils.nullObject() });
+	const response = adapter.response;
+	const map = response.map;
+	const set = { headers: rootHeaders ? Object.assign(require_utils.nullObject(), rootHeaders) : require_utils.nullObject() };
+	const mapped = map === require_adapter_web_standard_handler.mapResponse ? require_adapter_web_standard_handler.mapResponse(handler, set, null) : Reflect.apply(map, response, [handler, set]);
 	if (mapped instanceof Response) return staticPrimitiveType(mapped, handler);
 }
 function toArray(name, hook) {
 	if (typeof hook[name] === "function") hook[name] = [hook[name]];
 }
-function composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope) {
+function composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope, allowCompactPrefix = true) {
 	const resolve = chainResolver(root);
 	localHook = resolveLocalHook(localMacroRoot(macroScope ?? instance, root), localHook, root);
 	if (localHook && localHook.derive !== void 0) {
@@ -240,7 +244,7 @@ function composeRouteHook(instance, localHook, appHook, inheritedChain, root, ma
 	const flatAppHook = appHook ? require_utils.flattenChainMemo(root, appHook, resolve) : void 0;
 	let locals = instance !== root ? require_utils.flattenChain(require_generation.frozenRootOf(root)["~hookChain"], require_utils.isLocalScope, inheritedChain, resolve) : void 0;
 	const instanceLocal = instance !== root ? require_utils.flattenChain(instance["~hookChain"], require_utils.isLocalScope) : void 0;
-	const compactPrefix = instance !== root && !require_compile_aot.Capture.isCapturing() && !require_compile_aot.Capture.isAotBuildEnv() && resolve === void 0 && require_utils.isCompactBeforeHandleOnly(localHook) && require_utils.isCompactBeforeHandleOnly(flatAppHook) && require_utils.isCompactBeforeHandleOnly(locals) && !instanceLocal?.error ? require_utils.compactBeforeHandlePrefix(inheritedChain) : void 0;
+	const compactPrefix = allowCompactPrefix && instance !== root && !require_compile_aot.Capture.isCapturing() && !require_compile_aot.Capture.isAotBuildEnv() && resolve === void 0 && require_utils.isCompactBeforeHandleOnly(localHook) && require_utils.isCompactBeforeHandleOnly(flatAppHook) && require_utils.isCompactBeforeHandleOnly(locals) && !instanceLocal?.error ? require_utils.compactBeforeHandlePrefix(inheritedChain) : void 0;
 	let present = collectHookOrigins(localHook, void 0);
 	present = collectHookOrigins(flatAppHook, present);
 	if (compactPrefix && !present?.size && !require_utils.compactBeforeHandleConflicts(localHook) && !require_utils.compactBeforeHandleConflicts(flatAppHook) && !require_utils.compactBeforeHandleConflicts(locals)) {
@@ -296,7 +300,7 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 		cookieConfig: void 0,
 		tracers: void 0
 	}));
-	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope);
+	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope, !reconstructed);
 	if (hook) {
 		promoteDerive(hook);
 		toArray("parse", hook);
@@ -320,7 +324,9 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 	else if (!isHandleFunction && !(handler instanceof Promise) && !(!require_universal_constants.isBun && handler instanceof require_universal_file.ElysiaFile) && !declaresResponse) {
 		const rootHeaders = frozenRoot["~ext"]?.headers;
 		const set = { headers: rootHeaders ? Object.assign(require_utils.nullObject(), rootHeaders) : require_utils.nullObject() };
-		const mapped = adapter.response.map(handler, set);
+		const response = adapter.response;
+		const map = response.map;
+		const mapped = map === require_adapter_web_standard_handler.mapResponse ? require_adapter_web_standard_handler.mapResponse(handler, set, null) : Reflect.apply(map, response, [handler, set]);
 		if (mapped instanceof Response) handler = staticPrimitiveType(mapped, handler);
 	}
 	const isStaticResponse = !isHandleFunction && handler instanceof Response;
@@ -339,7 +345,10 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 		cookieConfig: reconstructed.a.includes("cc") ? require_compile_handler_reconstruct.Reconstrct.cookie(hook, root) : void 0,
 		tracers: reconstructed.a.includes("tr") ? require_compile_handler_reconstruct.Reconstrct.trace(hook, root) : void 0
 	}));
-	if (hook === void 0 && isHandleFunction && !precomputedStatic && !mountMeta && (method === "GET" || method === "HEAD") && !root["~hasTrace"] && root["~introspect"] !== true && root["~config"]?.introspect !== true && !require_utils.isNotEmpty(frozenRoot["~ext"]?.headers) && !require_compile_aot.Capture.isAotBuildEnv() && !require_compile_aot.Capture.isCapturing() && isContextFreeHandler(handler)) return require_compile_handler_jit.createInlineHandler(adapter.response.compact ?? adapter.response.map, handler);
+	if (hook === void 0 && isHandleFunction && !precomputedStatic && !mountMeta && (method === "GET" || method === "HEAD") && !root["~hasTrace"] && root["~introspect"] !== true && root["~config"]?.introspect !== true && !require_utils.isNotEmpty(frozenRoot["~ext"]?.headers) && !require_compile_aot.Capture.isAotBuildEnv() && !require_compile_aot.Capture.isCapturing() && isContextFreeHandler(handler)) {
+		const compact = adapter.response.compact;
+		if (compact) return require_compile_handler_jit.createInlineHandler(compact, handler);
+	}
 	const state = require_compile_handler_descriptor.describeRoute({
 		method,
 		path,

package/dist/compile/handler/index.mjs

@@ -1,6 +1,7 @@
 import { isBun } from "../../universal/constants.mjs";
 import { ElysiaFile } from "../../universal/file.mjs";
 import { cloneHook, compactBeforeHandleConflicts, compactBeforeHandlePrefix, eventProperties, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, isCompactBeforeHandleOnly, isLocalScope, isNotEmpty, macroEpoch, mergeHook, nullObject, replaceUrlPath } from "../../utils.mjs";
+import { mapResponse } from "../../adapter/web-standard/handler.mjs";
 import { Capture, Compiled } from "../aot.mjs";
 import { frozenRootOf } from "../../generation.mjs";
 import { resolveHandlerParams } from "./params.mjs";
@@ -223,13 +224,16 @@ function buildNativeStaticResponse(route, root) {
 	if (hook && !isEmptyPipelineHook(hook)) return;
 	const rootHeaders = frozenRoot["~ext"]?.headers;
 	if (handler instanceof Response && !rootHeaders) return handler;
-	const mapped = adapter.response.map(handler, { headers: rootHeaders ? Object.assign(nullObject(), rootHeaders) : nullObject() });
+	const response = adapter.response;
+	const map = response.map;
+	const set = { headers: rootHeaders ? Object.assign(nullObject(), rootHeaders) : nullObject() };
+	const mapped = map === mapResponse ? mapResponse(handler, set, null) : Reflect.apply(map, response, [handler, set]);
 	if (mapped instanceof Response) return staticPrimitiveType(mapped, handler);
 }
 function toArray(name, hook) {
 	if (typeof hook[name] === "function") hook[name] = [hook[name]];
 }
-function composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope) {
+function composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope, allowCompactPrefix = true) {
 	const resolve = chainResolver(root);
 	localHook = resolveLocalHook(localMacroRoot(macroScope ?? instance, root), localHook, root);
 	if (localHook && localHook.derive !== void 0) {
@@ -239,7 +243,7 @@ function composeRouteHook(instance, localHook, appHook, inheritedChain, root, ma
 	const flatAppHook = appHook ? flattenChainMemo(root, appHook, resolve) : void 0;
 	let locals = instance !== root ? flattenChain(frozenRootOf(root)["~hookChain"], isLocalScope, inheritedChain, resolve) : void 0;
 	const instanceLocal = instance !== root ? flattenChain(instance["~hookChain"], isLocalScope) : void 0;
-	const compactPrefix = instance !== root && !Capture.isCapturing() && !Capture.isAotBuildEnv() && resolve === void 0 && isCompactBeforeHandleOnly(localHook) && isCompactBeforeHandleOnly(flatAppHook) && isCompactBeforeHandleOnly(locals) && !instanceLocal?.error ? compactBeforeHandlePrefix(inheritedChain) : void 0;
+	const compactPrefix = allowCompactPrefix && instance !== root && !Capture.isCapturing() && !Capture.isAotBuildEnv() && resolve === void 0 && isCompactBeforeHandleOnly(localHook) && isCompactBeforeHandleOnly(flatAppHook) && isCompactBeforeHandleOnly(locals) && !instanceLocal?.error ? compactBeforeHandlePrefix(inheritedChain) : void 0;
 	let present = collectHookOrigins(localHook, void 0);
 	present = collectHookOrigins(flatAppHook, present);
 	if (compactPrefix && !present?.size && !compactBeforeHandleConflicts(localHook) && !compactBeforeHandleConflicts(flatAppHook) && !compactBeforeHandleConflicts(locals)) {
@@ -295,7 +299,7 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 		cookieConfig: void 0,
 		tracers: void 0
 	}));
-	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope);
+	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope, !reconstructed);
 	if (hook) {
 		promoteDerive(hook);
 		toArray("parse", hook);
@@ -319,7 +323,9 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 	else if (!isHandleFunction && !(handler instanceof Promise) && !(!isBun && handler instanceof ElysiaFile) && !declaresResponse) {
 		const rootHeaders = frozenRoot["~ext"]?.headers;
 		const set = { headers: rootHeaders ? Object.assign(nullObject(), rootHeaders) : nullObject() };
-		const mapped = adapter.response.map(handler, set);
+		const response = adapter.response;
+		const map = response.map;
+		const mapped = map === mapResponse ? mapResponse(handler, set, null) : Reflect.apply(map, response, [handler, set]);
 		if (mapped instanceof Response) handler = staticPrimitiveType(mapped, handler);
 	}
 	const isStaticResponse = !isHandleFunction && handler instanceof Response;
@@ -338,7 +344,10 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 		cookieConfig: reconstructed.a.includes("cc") ? Reconstrct.cookie(hook, root) : void 0,
 		tracers: reconstructed.a.includes("tr") ? Reconstrct.trace(hook, root) : void 0
 	}));
-	if (hook === void 0 && isHandleFunction && !precomputedStatic && !mountMeta && (method === "GET" || method === "HEAD") && !root["~hasTrace"] && root["~introspect"] !== true && root["~config"]?.introspect !== true && !isNotEmpty(frozenRoot["~ext"]?.headers) && !Capture.isAotBuildEnv() && !Capture.isCapturing() && isContextFreeHandler(handler)) return createInlineHandler(adapter.response.compact ?? adapter.response.map, handler);
+	if (hook === void 0 && isHandleFunction && !precomputedStatic && !mountMeta && (method === "GET" || method === "HEAD") && !root["~hasTrace"] && root["~introspect"] !== true && root["~config"]?.introspect !== true && !isNotEmpty(frozenRoot["~ext"]?.headers) && !Capture.isAotBuildEnv() && !Capture.isCapturing() && isContextFreeHandler(handler)) {
+		const compact = adapter.response.compact;
+		if (compact) return createInlineHandler(compact, handler);
+	}
 	const state = describeRoute({
 		method,
 		path,