elysia 2.0.0-beta.11 → 2.0.0-beta.13

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,
@@ -378,6 +387,7 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 
 //#endregion
 exports.buildNativeStaticResponse = buildNativeStaticResponse;
+exports.chainResolver = chainResolver;
 exports.clearHandlerAnalysisCaches = clearHandlerAnalysisCaches;
 exports.compileHandler = compileHandler;
 exports.composeRouteHook = composeRouteHook;

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,
@@ -376,4 +385,4 @@ function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 }
 
 //#endregion
-export { buildNativeStaticResponse, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };
+export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };

package/dist/compile/handler/jit.js

@@ -10,45 +10,44 @@ const require_parse_query = require('../../parse-query.js');
 const require_compile_aot = require('../aot.js');
 const require_generation = require('../../generation.js');
 const require_cookie_utils = require('../../cookie/utils.js');
-const require_compile_utils = require('../utils.js');
 const require_handler_utils = require('../../handler/utils.js');
 const require_handler_error = require('../../handler/error.js');
 const require_compile_handler_utils = require('./utils.js');
 const require_compile_jit_probe = require('../jit-probe.js');
 
 //#region src/compile/handler/jit.ts
-const parseFormData = "c.body=await pf(c)\n";
+const awaitValue = (value, arm = "") => arm ? `await (_av=(${value}),${arm},_av)` : `await ${value}`;
 let captureHeaderShorthand;
 const setCaptureHeaderShorthand = (value) => {
 	captureHeaderShorthand = value;
 };
-function builtinParser(adapter, parse, link) {
+function builtinParser(adapter, parse, link, arm) {
 	switch (parse) {
 		case "formdata":
 		case "multipart/form-data":
 			link(adapter.formData, "pf");
-			return parseFormData;
+			return `c.body=${awaitValue("pf(c)", arm)}\n`;
 		case "json":
 		case "application/json":
 			link(adapter.json, "pj");
-			return "c.body=await pj(c)\n";
+			return `c.body=${awaitValue("pj(c)", arm)}\n`;
 		case "urlencoded":
 		case "application/x-www-form-urlencoded":
 			link(adapter.urlencoded, "pu");
-			return "c.body=await pu(c)\n";
+			return `c.body=${awaitValue("pu(c)", arm)}\n`;
 		case "arrayBuffer":
 		case "application/octet-stream":
 			link(adapter.arrayBuffer, "pa");
-			return "c.body=await pa(c)\n";
+			return `c.body=${awaitValue("pa(c)", arm)}\n`;
 		case "text":
 		case "text/plain":
 			link(adapter.text, "pt");
-			return "c.body=await pt(c)\n";
+			return `c.body=${awaitValue("pt(c)", arm)}\n`;
 		case "none": return "";
 		default: throw new Error(`Unsupported content type: ${parse}`);
 	}
 }
-function parse(adapter, parsers, bodyVali, hasHeaders, link, report) {
+function parse(adapter, parsers, bodyVali, hasHeaders, link, report, arm) {
 	if (parsers && typeof parsers === "function") parsers = [parsers];
 	if (typeof parsers === "string" || parsers?.length === 1 && typeof parsers[0] === "string") {
 		if (parsers.length === 1) parsers = parsers[0];
@@ -56,7 +55,7 @@ function parse(adapter, parsers, bodyVali, hasHeaders, link, report) {
 		const child = report?.resolveChild(builtinName);
 		const begin = child ? child.begin : "";
 		const end = child ? child.end() : "";
-		return begin + builtinParser(adapter, parsers, link) + end;
+		return begin + builtinParser(adapter, parsers, link, arm) + end;
 	}
 	let hasFn = false;
 	let hasType = false;
@@ -77,7 +76,7 @@ if(cti!==-1)ct=ct.slice(0,cti)
 			const child = report?.resolveChild(parser.name || "anonymous");
 			if (i) code += "if(!hasBody){";
 			if (child) code += child.begin;
-			code += require_compile_utils.isAsyncFunction(parser) ? `c.body=await ho.parse[${i}](c,ct)\n` : `_bp=ho.parse[${i}](c,ct)\nif(_bp instanceof Promise)_bp=await _bp\nc.body=_bp\n`;
+			code += `_bp=ho.parse[${i}](c,ct)\n` + require_compile_handler_utils.awaitGuard(parser, true, "_bp", arm) + `c.body=_bp\n`;
 			code += "hasBody=c.body!==undefined\n";
 			if (child) code += child.end();
 			if (i) code += "}\n";
@@ -86,7 +85,7 @@ if(cti!==-1)ct=ct.slice(0,cti)
 			const child = report?.resolveChild(parser);
 			if (i) code += "if(!hasBody){\n";
 			if (child) code += child.begin;
-			code += builtinParser(adapter, parser, link);
+			code += builtinParser(adapter, parser, link, arm);
 			if (child) code += child.end();
 			if (i) code += "}\n";
 			break;
@@ -104,7 +103,8 @@ if(cti!==-1)ct=ct.slice(0,cti)
 			code += `if(ct&&!(${mediaGuard}))throw new es(415,'Unsupported Media Type')\n`;
 			link(require_error.ElysiaStatus, "es");
 		}
-		code += hasFn ? `if(!hasBody&&${guard}){${begin}c.body=cj?await pj(c):await pd(c,ce,true)\n${end}}\n` : `if(${guard}){${begin}c.body=cj?await pj(c):await pd(c,ce,true)\n${end}}\n`;
+		const value = `c.body=cj?${awaitValue("pj(c)", arm)}:${awaitValue("pd(c,ce,true)", arm)}\n`;
+		code += hasFn ? `if(!hasBody&&${guard}){${begin}${value}${end}}\n` : `if(${guard}){${begin}${value}${end}}\n`;
 		if (!bodyVali) link(require_compile_handler_utils.hasRequestBody, "hb");
 		link(adapter.json, "pj");
 		link(adapter.default, "pd");
@@ -141,24 +141,24 @@ const fromArgs = (type, isAsync) => `'${type}'${isAsync ? ",true" : ""}`;
 const createInlineHandler = (map, h) => ((c) => {
 	const r = h(c);
 	if (r instanceof Error) throw r;
-	if (r instanceof Promise) return r.then((v) => map(require_handler_utils.forwardError(v), c.request, true));
+	if (typeof r?.then === "function") return Promise.resolve(r).then((v) => map(require_handler_utils.forwardError(v), c.request, true));
 	return map(r, c.request, true);
 });
 const createInlineHandlerWithSet = (map, h) => ((c) => {
 	const r = h(c);
 	if (r instanceof Error) throw r;
-	if (r instanceof Promise) return r.then((v) => map(require_handler_utils.forwardError(v), c.set, c.request, true));
+	if (typeof r?.then === "function") return Promise.resolve(r).then((v) => map(require_handler_utils.forwardError(v), c.set, c.request, true));
 	return map(r, c.set, c.request, true);
 });
 const createInlineHandlerWithDefaultHeaders = (map, h) => ((c) => {
 	require_adapter_utils.materializeSetHeaders(c.set);
 	const r = h(c);
 	if (r instanceof Error) throw r;
-	if (r instanceof Promise) return r.then((v) => map(require_handler_utils.forwardError(v), c.set, c.request, true));
+	if (typeof r?.then === "function") return Promise.resolve(r).then((v) => map(require_handler_utils.forwardError(v), c.set, c.request, true));
 	return map(r, c.set, c.request, true);
 });
 function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapter, isHandleFunction, isStaticResponse, isPromiseHandler, state }) {
-	const { vali, inference, cookieConfig, beforeHandlePrefix, traceHandlers, tracePhases, hasAnyPhase, traceHandleOn, descriptor: { async: isAsync, responseMode, hasBody, bodyValiIsAsync, headersValiIsAsync, paramsValiIsAsync, queryValiIsAsync, cookieValiIsAsync: cookieValidIsAsync, responseValiAsync, hasCookieSign, syncCookieSign, asyncCookieSign, lazyCookieVerify, hasErrorHook, hasAfterResponse, hasBeforeHandle, hasAfterHandle, hasMapResponse, hasResponseValidator, hasTrace, traceCount, hasLifecycleHook, callHandlerSyncOnAsync, syncErrorHook, syncAfterResponse } } = state;
+	const { vali, inference, cookieConfig, beforeHandlePrefix, traceHandlers, tracePhases, hasAnyPhase, traceHandleOn, descriptor: { async: isAsync, responseMode, hasBody, bodyValiIsAsync, headersValiIsAsync, paramsValiIsAsync, queryValiIsAsync, cookieValiIsAsync: cookieValidIsAsync, responseValiAsync, hasCookieSign, syncCookieSign, asyncCookieSign, lazyCookieVerify, hasErrorHook, hasAfterResponse, hasBeforeHandle, hasAfterHandle, hasMapResponse, hasResponseValidator, hasTrace, traceCount, hasLifecycleHook, syncErrorHook, syncAfterResponse } } = state;
 	const hasStaticAfterResponse = !!hook?.afterResponse?.length;
 	const hasDynamicAfterResponse = !!inference.afterResponse;
 	const seenKeys = new Set(["rt", "fre"]);
@@ -181,15 +181,10 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	}
 	const abortOn = hasLifecycleHook && root["~config"]?.abortSignal !== false;
 	const abortPeek = "c['~sig']?.aborted";
-	const abortArm = "(_as??=(c['~sig']??=c.request.signal)).aborted";
-	let suspended = false;
-	const abortExpression = () => {
-		if (!suspended && code.includes("await ")) suspended = true;
-		return suspended ? abortArm : abortPeek;
-	};
-	const abortCheck = () => abortOn ? `if(${abortExpression()})return emp.clone()\n` : "";
-	const abortChainGuard = () => abortOn ? isAsync ? abortArm : abortExpression() : void 0;
-	const abortCatch = abortOn ? `if(${abortArm})return emp.clone()\n` : "";
+	const arm = abortOn ? "_as??=(c['~sig']??=c.request.signal)" : "";
+	const abortCheck = () => abortOn ? `if(${abortPeek})return emp.clone()\n` : "";
+	const abortChainGuard = () => abortOn ? abortPeek : void 0;
+	const abortCatch = abortOn ? `if((${arm}).aborted)return emp.clone()\n` : "";
 	const phaseOn = (phase) => hasTrace && (tracePhases === null || tracePhases.has(phase));
 	const beginTrace = (phase, total, name = phase) => {
 		if (!phaseOn(phase)) return "";
@@ -222,7 +217,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	};
 	const needsStaticClone = !isHandleFunction && !isStaticResponse && !isPromiseHandler && (hasAfterHandle || hasMapResponse) && typeof handler === "object" && handler !== null;
 	if (needsStaticClone) link(require_compile_handler_utils.cloneStaticValue, "scl");
-	const callHandler = isHandleFunction ? callHandlerSyncOnAsync ? `_r=h(c)\nif(_r instanceof Promise)_r=await _r\n` : `_r=${isAsync ? "await " : ""}h(c)\n` : isStaticResponse ? `_r=cr(h)\n` : isPromiseHandler ? `_r=h.then(cr)\n` : needsStaticClone ? `_r=scl(h)\n` : `_r=h\n`;
+	const callHandler = isHandleFunction ? `_r=h(c)\n${require_compile_handler_utils.awaitGuard(handler, isAsync, "_r", arm)}` : isStaticResponse ? `_r=cr(h)\n` : isPromiseHandler ? `_r=h.then(cr)\n` : needsStaticClone ? `_r=scl(h)\n` : `_r=h\n`;
 	let code = `${isAsync ? "async " : ""}function route(c){\n`;
 	if (abortOn) {
 		link(require_handler_utils.emptyResponse, "emp");
@@ -279,7 +274,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	if (hasBody) {
 		const parseLen = Array.isArray(hook?.parse) ? hook.parse.length : 0;
 		if (hasTrace) code += beginTrace("parse", parseLen);
-		const parseCode = parse(adapter.parse, hook?.parse, vali?.body, hasHeaders, link, buildReport("parse"));
+		const parseCode = parse(adapter.parse, hook?.parse, vali?.body, hasHeaders, link, buildReport("parse"), arm);
 		const preserveParseStatus = seenKeys.has("es");
 		link(require_error.ParseError, "pe");
 		code += "try{\n" + parseCode + `}catch(e){${preserveParseStatus ? "if(e instanceof es)throw e\n" : ""}throw new pe(e)}\n`;
@@ -292,26 +287,34 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		if (transformLen) {
 			link(hook.transform, "tf");
 			if (isAsync) code += "let _tf\n";
-			code += require_compile_handler_utils.mapTransform(hook.transform, [isAsync, buildReport("transform")], abortChainGuard());
+			code += require_compile_handler_utils.mapTransform(hook.transform, [
+				isAsync,
+				buildReport("transform"),
+				arm
+			], abortChainGuard());
 		}
 		code += endTrace("transform");
 		if (transformLen) code += abortCheck();
 	}
 	if (vali?.body) {
 		link(vali, "va");
-		code += `c.body=${bodyValiIsAsync ? "await " : ""}va.body.From(c.body,${fromArgs("body", bodyValiIsAsync)})\n`;
+		const value = `va.body.From(c.body,${fromArgs("body", bodyValiIsAsync)})`;
+		code += `c.body=${bodyValiIsAsync ? awaitValue(value, arm) : value}\n`;
 	}
 	if (vali?.headers) {
 		link(vali, "va");
-		code += `c.headers=${headersValiIsAsync ? "await " : ""}va.headers.From(c.headers,${fromArgs("headers", !!headersValiIsAsync)})\n`;
+		const value = `va.headers.From(c.headers,${fromArgs("headers", !!headersValiIsAsync)})`;
+		code += `c.headers=${headersValiIsAsync ? awaitValue(value, arm) : value}\n`;
 	}
 	if (vali?.params) {
 		link(vali, "va");
-		code += `c.params=${paramsValiIsAsync ? "await " : ""}va.params.From(c.params,${fromArgs("params", !!paramsValiIsAsync)})\n`;
+		const value = `va.params.From(c.params,${fromArgs("params", !!paramsValiIsAsync)})`;
+		code += `c.params=${paramsValiIsAsync ? awaitValue(value, arm) : value}\n`;
 	}
 	if (vali?.query) {
 		link(vali, "va");
-		code += `c.query=${queryValiIsAsync ? "await " : ""}va.query.From(c.query,${fromArgs("query", !!queryValiIsAsync)})\n`;
+		const value = `va.query.From(c.query,${fromArgs("query", !!queryValiIsAsync)})`;
+		code += `c.query=${queryValiIsAsync ? awaitValue(value, arm) : value}\n`;
 	}
 	if (cookieConfig) {
 		link(require_cookie_utils.buildCookieJar, "bcj");
@@ -336,25 +339,30 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 				code += `let _ck=pcrsg(${cookieHeaderExpr},cc)\n`;
 			} else {
 				link(require_cookie_utils.parseCookieRaw, "pcr");
-				code += `let _ck=await pcr(${cookieHeaderExpr},cc)\n`;
+				code += `let _ck=${awaitValue(`pcr(${cookieHeaderExpr},cc)`, arm)}\n`;
 			}
 			if (vali?.cookie) {
 				link(vali, "va");
 				const cookieIsOptional = !!(hook?.cookie)?.["~optional"];
-				const validateExpr = `_ck=${cookieValidIsAsync ? "await " : ""}va.cookie.From(_ck,${fromArgs("cookie", !!cookieValidIsAsync)})\n`;
+				const value = `va.cookie.From(_ck,${fromArgs("cookie", !!cookieValidIsAsync)})`;
+				const validateExpr = `_ck=${cookieValidIsAsync ? awaitValue(value, arm) : value}\n`;
 				if (cookieIsOptional) code += `if(Object.keys(_ck).length){${validateExpr}}\n`;
 				else code += validateExpr;
 			}
 			code += `c.cookie=bcj(c.set,_ck,cc${deferDecode ? ",undefined,1" : ""})\n`;
 		}
 	}
-	const hasSet = responseMode !== "compact";
+	const compactEligible = responseMode === "compact";
 	const res = adapter.response;
 	const responseMap = res.map;
-	const map = hasSet ? link(res.map, "rm") ?? "rm" : link(res.compact ?? res.map, "rc") ?? "rc";
+	const responseCompact = compactEligible ? res.compact : void 0;
+	const portableCompact = compactEligible && (require_compile_aot.Capture.isAotBuildEnv() || require_compile_aot.Capture.isCapturing());
+	const hasSet = !compactEligible || !responseCompact && !portableCompact;
+	const map = hasSet ? link(responseMap, "rm") ?? "rm" : link(responseCompact, "rc") ?? "rc";
+	if (portableCompact) link(responseMap, "rm");
+	const mapValue = (value) => portableCompact ? `(rc?rc(${value},c.request,true):rm(${value},c.set,c.request,true))` : hasSet ? `${map}(${value},c.set,c.request,true)` : `${map}(${value},c.request,true)`;
 	if (isStaticResponse || isPromiseHandler) link(require_compile_handler_utils.cloneResponse, "cr");
-	const handleInstruction = isHandleFunction ? "h(c)" : isStaticResponse ? "cr(h)" : isPromiseHandler ? "h.then(cr)" : "h";
-	const mapReturn = hasSet ? `rm(${handleInstruction},c.set,c.request,true)\n` : `rc(${handleInstruction},c.request,true)\n`;
+	const mapReturn = `${mapValue(isHandleFunction ? "h(c)" : isStaticResponse ? "cr(h)" : isPromiseHandler ? "h.then(cr)" : "h")}\n`;
 	if (hasStaticAfterResponse) link(hook.afterResponse, "ar");
 	const drainTraceStream = traceHandleOn ? `let _ser\nif(_trs){try{for await(const v of _trs){}}catch(_te){_ser=_te}}\n` : "";
 	const resolveHandlePostDrain = traceHandleOn ? (() => {
@@ -363,11 +371,14 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		return s;
 	})() : "";
 	const traceNeedsSchedule = traceHandleOn || phaseOn("afterResponse");
-	const scheduleAfterResponse = hasAfterResponse || traceNeedsSchedule ? "c._arf=true\nqueueMicrotask(async()=>{if(_stl){try{for await(const v of _stl){}}catch{}}\n" + drainTraceStream + resolveHandlePostDrain + beginTrace("afterResponse", hook?.afterResponse?.length ?? 0) + (hasStaticAfterResponse ? require_compile_handler_utils.mapAfterResponse(hook.afterResponse, [buildReport("afterResponse")]) : "") + (hasDynamicAfterResponse ? "let _q=c['~afterResponse']\nif(_q){let _l=_q.length\nfor(let _i=0;_i<_l;_i++){try{await _q[_i](c)}catch{}}\n" + (!require_universal_is_production.isProduction() ? `if(_q.length!==_l)console.warn('[elysia] defer() called from inside the afterResponse drain is ignored')\n` : "") + `}\n` : "") + endTrace("afterResponse") + `})\n` : "";
-	const dedupSchedule = !!scheduleAfterResponse && (hasErrorHook || hasTrace) && !syncAfterResponse && !syncErrorHook;
+	const scheduleAfterResponse = hasAfterResponse || traceNeedsSchedule ? "c._arf=true\nqueueMicrotask(async()=>{if(_stl){try{for await(const v of _stl){}}catch{}}\n" + drainTraceStream + resolveHandlePostDrain + beginTrace("afterResponse", hook?.afterResponse?.length ?? 0) + (hasStaticAfterResponse ? require_compile_handler_utils.mapAfterResponse(hook.afterResponse, [buildReport("afterResponse")]) : "") + (hasDynamicAfterResponse ? "let _q=c['~afterResponse']\nif(_q){let _l=_q.length\nfor(let _i=0;_i<_l;_i++){try{await _q[_i](c)}catch(_e){console.error(_e)}}\n" + (!require_universal_is_production.isProduction() ? `if(_q.length!==_l)console.warn('[elysia] defer() called from inside the afterResponse drain is ignored')\n` : "") + `}\n` : "") + endTrace("afterResponse") + `})\n` : "";
+	const dedupSchedule = !!scheduleAfterResponse && !syncAfterResponse && !syncErrorHook;
 	const scheduleDecl = dedupSchedule ? `function _sc(){\n${scheduleAfterResponse}}\n` : "";
 	const schedule = dedupSchedule ? `_sc()\n` : scheduleAfterResponse;
-	const signPrefix = syncCookieSign ? `scv(c.set.cookie,cc)\n` : asyncCookieSign ? `_sg=scv(c.set.cookie,cc)\nif(_sg)await _sg\n` : "";
+	const syncScheduleDecl = syncAfterResponse && scheduleAfterResponse ? `function _scf(c,_stl){\n${scheduleAfterResponse}}\n` : "";
+	const catchSchedule = dedupSchedule ? `_sc()\n` : syncScheduleDecl ? `_scf(c)\n` : "";
+	const freThenSchedule = (arg) => catchSchedule ? `if(c._arf)return fre(rt,c,${arg})\nc._arf=true\nconst _fr=fre(rt,c,${arg})\nreturn typeof _fr?.then==='function'?_fr.then((_v)=>{${catchSchedule}return _v\n}):(${catchSchedule.trim()},_fr)\n` : `return fre(rt,c,${arg})\n`;
+	const signPrefix = syncCookieSign ? `scv(c.set.cookie,cc)\n` : asyncCookieSign ? `_sg=scv(c.set.cookie,cc)\nif(_sg){${arm ? `${arm}\n` : ""}await _sg}\n` : "";
 	if (syncCookieSign || asyncCookieSign) link(require_cookie_utils.signCookieValues, "scv");
 	let factoryHelpers = "";
 	if (hasBeforeHandle || hasAfterHandle || hasMapResponse || hasAfterResponse || hasResponseValidator || hasCookieSign || hasTrace) {
@@ -381,7 +392,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 					const rbpAbort = abortOn ? ",1" : "";
 					if (isAsync) {
 						link(require_compile_handler_utils.runBeforeHandlePrefixAsync, "rbp");
-						code += `tmp=await rbp(bp,c${rbpAbort})\n`;
+						code += `tmp=${awaitValue(`rbp(bp,c${rbpAbort})`, arm)}\n`;
 					} else {
 						link(require_compile_handler_utils.runBeforeHandlePrefix, "rbp");
 						code += `tmp=rbp(bp,c${rbpAbort})\n`;
@@ -392,7 +403,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 					link(hook.beforeHandle, "bf");
 					const deriveEntries = hook["~deriveEntries"];
 					const chainGuard = abortChainGuard();
-					const mapped = require_compile_handler_utils.mapBeforeHandle(hook.beforeHandle, deriveEntries, link, isAsync, buildReport("beforeHandle"), chainGuard);
+					const mapped = require_compile_handler_utils.mapBeforeHandle(hook.beforeHandle, deriveEntries, link, isAsync, buildReport("beforeHandle"), chainGuard, arm);
 					code += beforeHandlePrefix ? `if(${chainGuard ? `!${chainGuard}&&` : ""}_r===undefined){\n${mapped}}\n` : mapped;
 				}
 			}
@@ -400,9 +411,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 			if (hasBeforeHandle) code += abortCheck();
 		}
 		if (hasAfterResponse || traceHandleOn) link(require_adapter_utils.tee, "tee");
-		const teeConsumers = (hasAfterResponse ? 1 : 0) + (traceHandleOn ? 1 : 0);
-		const teeCount = teeConsumers + 1;
-		const teeBlock = teeConsumers > 0 && !syncAfterResponse ? `if(_r&&(_r[Symbol.iterator]||_r[Symbol.asyncIterator])&&typeof _r.next==='function'){\nconst _s=tee(_r,${teeCount})\n_r=_s[0]\n` + (hasAfterResponse ? `_stl=_s[1]\n` : "") + (traceHandleOn ? `_trs=_s[${1 + (hasAfterResponse ? 1 : 0)}]\n` : "") + `}\n` : "";
+		const teeBlock = (hasAfterResponse || traceHandleOn) && !syncAfterResponse ? "if(_r&&(_r[Symbol.iterator]||_r[Symbol.asyncIterator])&&typeof _r.next==='function'){\nconst _s=tee(_r,2)\n_r=_s[0]\n" + (traceHandleOn ? `_trs=_s[1]\n` : `_stl=_s[1]\n`) + `}\n` : "";
 		if (traceHandleOn) {
 			const handleName = handler?.name && typeof handler.name === "string" ? handler.name : "anonymous";
 			code += beginTrace("handle", 1, handleName);
@@ -421,16 +430,13 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		code += abortCheck();
 		if (syncAfterResponse) {
 			link(require_handler_utils.forwardError, "fe");
-			factoryHelpers += `function _fin(c,_r){
-if(_r instanceof Error)throw _r
-if(_r&&(_r[Symbol.iterator]||_r[Symbol.asyncIterator])&&typeof _r.next==='function'){
-const _s=tee(_r,${teeCount})\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,undefined)\n}\nfunction _fin2(c,_r,_stl){\nc.responseValue=_r\n` + scheduleAfterResponse + `const _m=${hasSet ? `${map}(_r,c.set,c.request,true)` : `${map}(_r,c.request,true)`}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n}\n`;
-			code += "if(_r instanceof Promise)return _r.then(fe).then((_v)=>_fin(c,_v)).catch((_e)=>fre(rt,c,_e))\nreturn _fin(c,_r)\n";
+			factoryHelpers += syncScheduleDecl + "function _fin(c,_r){\nif(_r instanceof Error)throw _r\nif(_r&&(_r[Symbol.iterator]||_r[Symbol.asyncIterator])&&typeof _r.next==='function'){\nconst _s=tee(_r,2)\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,undefined)\n}\nfunction _fin2(c,_r,_stl){\nc.responseValue=_r\n" + (syncScheduleDecl ? `_scf(c,_stl)\n` : scheduleAfterResponse) + `const _m=${mapValue("_r")}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n}\n`;
+			code += "if(typeof _r?.then==='function')return Promise.resolve(_r).then(fe).then((_v)=>_fin(c,_v)).catch((_e)=>fre(rt,c,_e))\nreturn _fin(c,_r)\n";
 		} else {
 			code += `if(_r instanceof Error)throw _r\n`;
 			if (!isAsync) {
 				link(require_handler_utils.forwardError, "fe");
-				code += `else if(_r instanceof Promise)_r=_r.then(fe)\n`;
+				code += `else if(typeof _r?.then==='function')_r=Promise.resolve(_r).then(fe)\n`;
 			}
 			if (hasAfterHandle || hasMapResponse || hasAfterResponse || hasTrace) code += `c.responseValue=_r\n`;
 			if (hasAfterHandle || hasTrace) {
@@ -438,7 +444,7 @@ const _s=tee(_r,${teeCount})\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,
 				code += beginTrace("afterHandle", afLen);
 				if (hasAfterHandle) {
 					link(hook.afterHandle, "af");
-					code += require_compile_handler_utils.mapAfterHandle(hook.afterHandle, isAsync, buildReport("afterHandle"), abortChainGuard());
+					code += require_compile_handler_utils.mapAfterHandle(hook.afterHandle, isAsync, buildReport("afterHandle"), abortChainGuard(), arm);
 				}
 				code += endTrace("afterHandle");
 				if (hasAfterHandle) code += abortCheck();
@@ -448,7 +454,7 @@ const _s=tee(_r,${teeCount})\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,
 				code += beginTrace("mapResponse", mrLen);
 				if (hasMapResponse) {
 					link(hook.mapResponse, "mr");
-					code += require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, buildReport("mapResponse"), abortChainGuard());
+					code += require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, buildReport("mapResponse"), abortChainGuard(), arm);
 				}
 				code += endTrace("mapResponse");
 				if (hasMapResponse) code += abortCheck();
@@ -456,26 +462,28 @@ const _s=tee(_r,${teeCount})\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,
 			if (hasResponseValidator) {
 				link(vali, "va");
 				link(require_error.ElysiaStatus, "es");
-				const awaitStr = responseValiAsync ? "await " : "";
+				const encodeStatus = responseValiAsync ? `(_vr.mayReturnPromise?_vr.From(_r.response,'response',true):_vr.EncodeFrom(_r.response,'response'))` : `_vr.EncodeFrom(_r.response,'response')`;
+				const encodeBody = responseValiAsync ? `(_vr.mayReturnPromise?_vr.From(_r,'response',true):_vr.EncodeFrom(_r,'response'))` : `_vr.EncodeFrom(_r,'response')`;
 				code += `if(_r instanceof es){
 const _vr=va.response[_r.status]
-if(_vr)_r.response=${awaitStr}${responseValiAsync ? `(_vr.mayReturnPromise?_vr.From(_r.response,'response',true):_vr.EncodeFrom(_r.response,'response'))` : `_vr.EncodeFrom(_r.response,'response')`}\n}else if(!(_r instanceof Response)&&!(_r instanceof ReadableStream)&&typeof _r?.next!=='function'){\nconst _vr=va.response[c.set.status??200]\nif(_vr)_r=${awaitStr}${responseValiAsync ? `(_vr.mayReturnPromise?_vr.From(_r,'response',true):_vr.EncodeFrom(_r,'response'))` : `_vr.EncodeFrom(_r,'response')`}\n}\n`;
+if(_vr)_r.response=${responseValiAsync ? awaitValue(encodeStatus, arm) : encodeStatus}\n}else if(!(_r instanceof Response)&&!(_r instanceof ReadableStream)&&typeof _r?.next!=='function'){\nconst _vr=va.response[c.set.status??200]\nif(_vr)_r=${responseValiAsync ? awaitValue(encodeBody, arm) : encodeBody}\n}\n`;
 				code += abortCheck();
 			}
-			code += schedule;
+			const deferSchedule = !!schedule;
 			code += signPrefix;
-			const finalMap = hasSet ? `${map}(_r,c.set,c.request,true)` : `${map}(_r,c.request,true)`;
-			if (isAsync) code += `return await ${finalMap}\n`;
+			const finalMap = mapValue("_r");
+			const onMapReject = syncErrorHook ? `(_e)=>_ce(_e,c)` : dedupSchedule ? `(_e)=>{${freThenSchedule("_e")}}` : `(_e)=>fre(rt,c,_e)`;
+			if (isAsync) code += deferSchedule ? `const _m=await ${finalMap}\n${schedule}return _m\n` : `return await ${finalMap}\n`;
 			else {
 				code += `const _m=${finalMap}\n`;
-				code += syncErrorHook ? `return typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>_ce(_e,c)):_m\n` : `return typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n`;
+				code += deferSchedule ? `if(typeof _m?.then==='function')return Promise.resolve(_m).then((_v)=>{\n${schedule}return _v\n},${onMapReject})\n` + schedule + `return _m\n` : `return typeof _m?.then==='function'?Promise.resolve(_m).catch(${onMapReject}):_m\n`;
 			}
 		}
 	} else if (isHandleFunction) {
 		if (!isAsync) link(require_handler_utils.forwardError, "fe");
-		const mapArgs = hasSet ? "c.set,c.request,true" : "c.request,true";
-		code += callHandlerSyncOnAsync ? `let _r=h(c)\nif(_r instanceof Promise)_r=await _r\n` : `let _r=${isAsync ? "await " : ""}h(c)\n`;
-		code += abortCheck() + `if(_r instanceof Error)throw _r\n` + (isAsync ? `return await ${map}(_r,${mapArgs})\n` : syncErrorHook ? `if(_r instanceof Promise)_r=_r.then(fe)\nconst _m=${map}(_r,${mapArgs})\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>_ce(_e,c)):_m\n` : `if(_r instanceof Promise)_r=_r.then(fe)\nconst _m=${map}(_r,${mapArgs})\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n`);
+		const finalMap = mapValue("_r");
+		code += `let ${callHandler}`;
+		code += abortCheck() + `if(_r instanceof Error)throw _r\n` + (isAsync ? `return await ${finalMap}\n` : syncErrorHook ? `if(typeof _r?.then==='function')_r=Promise.resolve(_r).then(fe)\nconst _m=${finalMap}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>_ce(_e,c)):_m\n` : `if(typeof _r?.then==='function')_r=Promise.resolve(_r).then(fe)\nconst _m=${finalMap}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n`);
 	} else code += `const _m=${mapReturn.trim()}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n`;
 	if (hasErrorHook || hasTrace) {
 		let body = "";
@@ -488,28 +496,26 @@ if(_vr)_r.response=${awaitStr}${responseValiAsync ? `(_vr.mayReturnPromise?_vr.F
 			link(require_handler_error.fallbackResponse, "fbr");
 			const allowUnsafeDetail = !!root["~config"]?.allowUnsafeValidationDetails;
 			if (allowUnsafeDetail) link(require_error.ValidationError, "verr");
-			factoryHelpers += `function _em(c,_r){return typeof _r?.then==='function'?Promise.resolve(_r).catch((_e)=>fre(rt,c,_e)):_r}\nfunction _fbm(_r,_s,_c){return ${map}(_r,_s,_c.request,true)}\n${asyncCookieSign ? "async " : ""}function _efb(e,c){\n` + (asyncCookieSign ? `let _sg\n` : ``) + signPrefix + "return _em(c,fbr(c,e,_fbm))\n}\n";
+			factoryHelpers += `function _em(c,_r){return typeof _r?.then==='function'?Promise.resolve(_r).catch((_e)=>fre(rt,c,_e)):_r}\nfunction _fbm(_r,_s,_c){return ${map}(_r,_s,_c.request,true)}\n${asyncCookieSign ? "async " : ""}function _efb(e,c){\n` + (asyncCookieSign ? `let _sg${arm ? ",_as" : ""}\n` : ``) + signPrefix + "return _em(c,fbr(c,e,_fbm))\n}\n";
 			body += `c.error=e\n` + (allowUnsafeDetail ? `if(e instanceof verr)e.allowUnsafeValidationDetails=true\n` : ``) + `if(e?.status)c.set.status=e.status
 else if(c.set.status===undefined||c.set.status===200)c.set.status=500
 let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapError(hook.error, [
 				map,
 				link,
-				res.map,
-				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, void 0, abortOn ? abortArm : void 0) : "") + endTrace("error") + abortCatch + schedule,
+				responseMap,
+				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapMapResponse(hook.mapResponse, isAsync, void 0, abortChainGuard(), arm) : "") + endTrace("error") + abortCatch + schedule,
 				signPrefix,
-				isAsync
-			], abortOn ? abortArm : void 0) + endTrace("error") + abortCatch + schedule + `return _efb(e,c)\n`;
-		} else {
-			body += endTrace("error") + schedule;
-			body += `return fre(rt,c,e)\n`;
-		}
+				isAsync,
+				arm
+			], abortChainGuard()) + endTrace("error") + abortCatch + schedule + `return _efb(e,c)\n`;
+		} else body += endTrace("error") + freThenSchedule("e");
 		if (syncErrorHook) {
 			factoryHelpers += `function _ce(e,c){${abortOn ? "let _as\n" : ""}try{\n${body}}catch(_ee){return fre(rt,c,_ee)}}\n`;
 			code += `}catch(e){return _ce(e,c)}\n`;
 		} else code += `}catch(e){try{\n${body}}catch(_ee){return fre(rt,c,_ee)}}\n`;
-	} else code += `}catch(e){return fre(rt,c,e)}\n`;
+	} else code += catchSchedule ? `}catch(e){${freThenSchedule("e")}}\n` : `}catch(e){return fre(rt,c,e)}\n`;
 	code += "}";
-	code = head + (abortOn && code.includes("_as") ? "let _as\n" : "") + scheduleDecl + code;
+	code = head + (abortOn && code.includes("_as") ? "let _as\n" : "") + (code.includes("_av") ? "let _av\n" : "") + scheduleDecl + code;
 	if (factoryHelpers) code = `(function(){\n${factoryHelpers}return ${code}})()`;
 	const alias = aliasKeys.join(",");
 	const fullAlias = alias ? `rt,fre,${alias}` : "rt,fre";
@@ -521,7 +527,7 @@ let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapErro
 	});
 	const isGeneratorHandler = isHandleFunction && handler.constructor.name.endsWith("GeneratorFunction");
 	if (!hasTrace && isHandleFunction && !isGeneratorHandler && !inlineUnsafe) {
-		if (alias === "rc" || !isAsync && !syncErrorHook && alias === "rc,fe") return createInlineHandler(res.compact ?? res.map, handler);
+		if (alias === "rc" || !isAsync && !syncErrorHook && alias === "rc,fe") return createInlineHandler(responseCompact, handler);
 		else if (alias === "rm" || alias === "msh,rm" || !isAsync && !syncErrorHook && (alias === "rm,fe" || alias === "msh,rm,fe")) return responseMode === "set-with-default-headers" && inference.set ? createInlineHandlerWithDefaultHeaders(responseMap, handler) : createInlineHandlerWithSet(responseMap, handler);
 	}
 	require_compile_jit_probe.JITProbe.record("handler:new-function");