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

package/dist/compile/handler/jit.mjs

@@ -9,45 +9,44 @@ import { parseQueryFromURL } from "../../parse-query.mjs";
 import { Capture } from "../aot.mjs";
 import { resolvedTraceOf, traceCapabilityRequired } from "../../generation.mjs";
 import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, parseCookieRawSigned, parseCookieRawSync, signCookieValues } from "../../cookie/utils.mjs";
-import { isAsyncFunction } from "../utils.mjs";
 import { emptyResponse, finalizeRouteError, forwardError } from "../../handler/utils.mjs";
 import { fallbackResponse } from "../../handler/error.mjs";
-import { armEntryAbort, cloneResponse, cloneStaticValue, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, runBeforeHandlePrefix, runBeforeHandlePrefixAsync } from "./utils.mjs";
+import { armEntryAbort, awaitGuard, cloneResponse, cloneStaticValue, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, runBeforeHandlePrefix, runBeforeHandlePrefixAsync } from "./utils.mjs";
 import { JITProbe } from "../jit-probe.mjs";
 
 //#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];
@@ -55,7 +54,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;
@@ -76,7 +75,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 += 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` + awaitGuard(parser, true, "_bp", arm) + `c.body=_bp\n`;
 			code += "hasBody=c.body!==undefined\n";
 			if (child) code += child.end();
 			if (i) code += "}\n";
@@ -85,7 +84,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;
@@ -103,7 +102,8 @@ if(cti!==-1)ct=ct.slice(0,cti)
 			code += `if(ct&&!(${mediaGuard}))throw new es(415,'Unsupported Media Type')\n`;
 			link(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(hasRequestBody, "hb");
 		link(adapter.json, "pj");
 		link(adapter.default, "pd");
@@ -140,24 +140,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(forwardError(v), c.request, true));
+	if (typeof r?.then === "function") return Promise.resolve(r).then((v) => map(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(forwardError(v), c.set, c.request, true));
+	if (typeof r?.then === "function") return Promise.resolve(r).then((v) => map(forwardError(v), c.set, c.request, true));
 	return map(r, c.set, c.request, true);
 });
 const createInlineHandlerWithDefaultHeaders = (map, h) => ((c) => {
 	materializeSetHeaders(c.set);
 	const r = h(c);
 	if (r instanceof Error) throw r;
-	if (r instanceof Promise) return r.then((v) => map(forwardError(v), c.set, c.request, true));
+	if (typeof r?.then === "function") return Promise.resolve(r).then((v) => map(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"]);
@@ -180,15 +180,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 "";
@@ -221,7 +216,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(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${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(emptyResponse, "emp");
@@ -278,7 +273,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(ParseError, "pe");
 		code += "try{\n" + parseCode + `}catch(e){${preserveParseStatus ? "if(e instanceof es)throw e\n" : ""}throw new pe(e)}\n`;
@@ -291,26 +286,34 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		if (transformLen) {
 			link(hook.transform, "tf");
 			if (isAsync) code += "let _tf\n";
-			code += mapTransform(hook.transform, [isAsync, buildReport("transform")], abortChainGuard());
+			code += 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(buildCookieJar, "bcj");
@@ -335,25 +338,30 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 				code += `let _ck=pcrsg(${cookieHeaderExpr},cc)\n`;
 			} else {
 				link(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 && (Capture.isAotBuildEnv() || 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(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 ? (() => {
@@ -369,7 +377,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	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)await _sg\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(signCookieValues, "scv");
 	let factoryHelpers = "";
 	if (hasBeforeHandle || hasAfterHandle || hasMapResponse || hasAfterResponse || hasResponseValidator || hasCookieSign || hasTrace) {
@@ -383,7 +391,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 					const rbpAbort = abortOn ? ",1" : "";
 					if (isAsync) {
 						link(runBeforeHandlePrefixAsync, "rbp");
-						code += `tmp=await rbp(bp,c${rbpAbort})\n`;
+						code += `tmp=${awaitValue(`rbp(bp,c${rbpAbort})`, arm)}\n`;
 					} else {
 						link(runBeforeHandlePrefix, "rbp");
 						code += `tmp=rbp(bp,c${rbpAbort})\n`;
@@ -394,7 +402,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 					link(hook.beforeHandle, "bf");
 					const deriveEntries = hook["~deriveEntries"];
 					const chainGuard = abortChainGuard();
-					const mapped = mapBeforeHandle(hook.beforeHandle, deriveEntries, link, isAsync, buildReport("beforeHandle"), chainGuard);
+					const mapped = mapBeforeHandle(hook.beforeHandle, deriveEntries, link, isAsync, buildReport("beforeHandle"), chainGuard, arm);
 					code += beforeHandlePrefix ? `if(${chainGuard ? `!${chainGuard}&&` : ""}_r===undefined){\n${mapped}}\n` : mapped;
 				}
 			}
@@ -402,9 +410,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 			if (hasBeforeHandle) code += abortCheck();
 		}
 		if (hasAfterResponse || traceHandleOn) link(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);
@@ -423,16 +429,13 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		code += abortCheck();
 		if (syncAfterResponse) {
 			link(forwardError, "fe");
-			factoryHelpers += syncScheduleDecl + `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` + (syncScheduleDecl ? `_scf(c,_stl)\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(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) {
@@ -440,7 +443,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 += mapAfterHandle(hook.afterHandle, isAsync, buildReport("afterHandle"), abortChainGuard());
+					code += mapAfterHandle(hook.afterHandle, isAsync, buildReport("afterHandle"), abortChainGuard(), arm);
 				}
 				code += endTrace("afterHandle");
 				if (hasAfterHandle) code += abortCheck();
@@ -450,7 +453,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 += mapMapResponse(hook.mapResponse, isAsync, buildReport("mapResponse"), abortChainGuard());
+					code += mapMapResponse(hook.mapResponse, isAsync, buildReport("mapResponse"), abortChainGuard(), arm);
 				}
 				code += endTrace("mapResponse");
 				if (hasMapResponse) code += abortCheck();
@@ -458,15 +461,16 @@ const _s=tee(_r,${teeCount})\nreturn _fin2(c,_s[0],_s[1])\n}\nreturn _fin2(c,_r,
 			if (hasResponseValidator) {
 				link(vali, "va");
 				link(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();
 			}
 			const deferSchedule = !!schedule;
 			code += signPrefix;
-			const finalMap = hasSet ? `${map}(_r,c.set,c.request,true)` : `${map}(_r,c.request,true)`;
+			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 {
@@ -476,9 +480,9 @@ if(_vr)_r.response=${awaitStr}${responseValiAsync ? `(_vr.mayReturnPromise?_vr.F
 		}
 	} else if (isHandleFunction) {
 		if (!isAsync) link(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 = "";
@@ -491,17 +495,18 @@ if(_vr)_r.response=${awaitStr}${responseValiAsync ? `(_vr.mayReturnPromise?_vr.F
 			link(fallbackResponse, "fbr");
 			const allowUnsafeDetail = !!root["~config"]?.allowUnsafeValidationDetails;
 			if (allowUnsafeDetail) link(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` + mapError(hook.error, [
 				map,
 				link,
-				res.map,
-				(hasMapResponse ? `c.responseValue=_r\n` + mapMapResponse(hook.mapResponse, isAsync, void 0, abortOn ? abortArm : void 0) : "") + endTrace("error") + abortCatch + schedule,
+				responseMap,
+				(hasMapResponse ? `c.responseValue=_r\n` + 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`;
+				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`;
@@ -509,7 +514,7 @@ let _r${hasMapResponse ? ",tmp" : ""}\n` + mapError(hook.error, [
 		} else code += `}catch(e){try{\n${body}}catch(_ee){return fre(rt,c,_ee)}}\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 +526,7 @@ let _r${hasMapResponse ? ",tmp" : ""}\n` + mapError(hook.error, [
 	});
 	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);
 	}
 	JITProbe.record("handler:new-function");

package/dist/compile/handler/params.js

@@ -7,6 +7,7 @@ const require_cookie_utils = require('../../cookie/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_handler_static_clone_resolver = require('./static-clone-resolver.js');
 
 //#region src/compile/handler/params.ts
 let _handlerParams;
@@ -22,7 +23,7 @@ const handlerParams = () => _handlerParams ??= {
 	qa: (c) => require_compile_handler_utils.getQueryParseChannels(c.vali?.query?.schema)?.array,
 	qo: (c) => require_compile_handler_utils.getQueryParseChannels(c.vali?.query?.schema)?.object,
 	rm: (c) => c.res.map,
-	rc: (c) => c.res.compact ?? c.res.map,
+	rc: (c) => c.res.compact,
 	rid: () => require_utils.requestId,
 	pq: () => require_parse_query.parseQueryFromURL,
 	pe: () => require_error.ParseError,
@@ -34,7 +35,7 @@ const handlerParams = () => _handlerParams ??= {
 	tee: () => require_adapter_utils.tee,
 	msh: () => require_adapter_utils.materializeSetHeaders,
 	cr: () => require_compile_handler_utils.cloneResponse,
-	scl: () => require_compile_handler_utils.cloneStaticValue,
+	scl: require_compile_handler_static_clone_resolver.staticCloneResolver,
 	pcr: () => require_cookie_utils.parseCookieRaw,
 	pcrs: () => require_cookie_utils.parseCookieRawSync,
 	pcrsg: () => require_cookie_utils.parseCookieRawSigned,

package/dist/compile/handler/params.mjs

@@ -5,7 +5,8 @@ import { parseQueryFromURL } from "../../parse-query.mjs";
 import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, parseCookieRawSigned, parseCookieRawSync, signCookieValues } from "../../cookie/utils.mjs";
 import { emptyResponse, finalizeRouteError, forwardError } from "../../handler/utils.mjs";
 import { adoptErrorType, fallbackResponse } from "../../handler/error.mjs";
-import { armEntryAbort, cloneResponse, cloneStaticValue, getQueryParseChannels, hasRequestBody, replaceDeriveContext, runBeforeHandlePrefix } from "./utils.mjs";
+import { armEntryAbort, cloneResponse, getQueryParseChannels, hasRequestBody, replaceDeriveContext, runBeforeHandlePrefix } from "./utils.mjs";
+import { staticCloneResolver } from "./static-clone-resolver.mjs";
 
 //#region src/compile/handler/params.ts
 let _handlerParams;
@@ -21,7 +22,7 @@ const handlerParams = () => _handlerParams ??= {
 	qa: (c) => getQueryParseChannels(c.vali?.query?.schema)?.array,
 	qo: (c) => getQueryParseChannels(c.vali?.query?.schema)?.object,
 	rm: (c) => c.res.map,
-	rc: (c) => c.res.compact ?? c.res.map,
+	rc: (c) => c.res.compact,
 	rid: () => requestId,
 	pq: () => parseQueryFromURL,
 	pe: () => ParseError,
@@ -33,7 +34,7 @@ const handlerParams = () => _handlerParams ??= {
 	tee: () => tee,
 	msh: () => materializeSetHeaders,
 	cr: () => cloneResponse,
-	scl: () => cloneStaticValue,
+	scl: staticCloneResolver,
 	pcr: () => parseCookieRaw,
 	pcrs: () => parseCookieRawSync,
 	pcrsg: () => parseCookieRawSigned,

package/dist/compile/handler/static-clone-resolver.d.ts

@@ -0,0 +1,6 @@
+import { cloneStaticValue } from "./utils.js";
+
+//#region src/compile/handler/static-clone-resolver.d.ts
+declare const staticCloneResolver: () => typeof cloneStaticValue;
+//#endregion
+export { staticCloneResolver };

package/dist/compile/handler/static-clone-resolver.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_compile_handler_utils = require('./utils.js');
+
+//#region src/compile/handler/static-clone-resolver.ts
+const staticCloneResolver = () => require_compile_handler_utils.cloneStaticValue;
+
+//#endregion
+exports.staticCloneResolver = staticCloneResolver;

package/dist/compile/handler/static-clone-resolver.mjs

@@ -0,0 +1,7 @@
+import { cloneStaticValue } from "./utils.mjs";
+
+//#region src/compile/handler/static-clone-resolver.ts
+const staticCloneResolver = () => cloneStaticValue;
+
+//#endregion
+export { staticCloneResolver };

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

@@ -22,24 +22,25 @@ declare function hasRequestBody(request: Request): boolean;
  * @see `../../adapter/origin` for the provenance channel
  */
 declare function armEntryAbort(context: any): any;
-declare const mapTransform: (event: MaybeArray<TransformHandler<any, any, undefined, "local">>, rest?: [isAsync: boolean, report?: TraceReporter | undefined] | undefined, abortGuard?: string) => string;
+declare const mapTransform: (event: MaybeArray<TransformHandler<any, any, undefined, "local">>, rest?: [isAsync: boolean, report?: TraceReporter | undefined, arm?: string | undefined] | undefined, abortGuard?: string) => string;
 declare function replaceDeriveContext(context: any, derivative: any): any;
 declare function deriveModes(hooks: Function[], entries?: readonly DeriveEntry[]): (boolean | undefined)[] | undefined;
-declare function mapBeforeHandle(_hooks: AppHook['beforeHandle'] | AppHook['beforeHandle'][0], derive: readonly DeriveEntry[] | undefined, link: Link, isAsync: boolean, report?: TraceReporter, abortGuard?: string): string;
+declare function mapBeforeHandle(_hooks: AppHook['beforeHandle'] | AppHook['beforeHandle'][0], derive: readonly DeriveEntry[] | undefined, link: Link, isAsync: boolean, report?: TraceReporter, abortGuard?: string, arm?: string): string;
 type BeforeHandleContext = {
   request: Request;
   '~sig'?: AbortSignal;
 };
 declare function runBeforeHandlePrefix(prefix: CompactBeforeHandlePrefix, context: BeforeHandleContext, abort?: 1): any;
 declare function runBeforeHandlePrefixAsync(prefix: CompactBeforeHandlePrefix, context: BeforeHandleContext, abort?: 1): Promise<any>;
-declare const mapAfterHandle: (_hooks: AppHook["afterHandle"] | AppHook["afterHandle"][0], isAsync: boolean, report?: TraceReporter, abortGuard?: string) => string;
-declare const mapMapResponse: (_hooks: AppHook["mapResponse"] | AppHook["mapResponse"][0], isAsync: boolean, report?: TraceReporter, abortGuard?: string) => string;
+declare const mapAfterHandle: (_hooks: AppHook["afterHandle"] | AppHook["afterHandle"][0], isAsync: boolean, report?: TraceReporter, abortGuard?: string, arm?: string) => string;
+declare const mapMapResponse: (_hooks: AppHook["mapResponse"] | AppHook["mapResponse"][0], isAsync: boolean, report?: TraceReporter, abortGuard?: string, arm?: string) => string;
 declare const mapAfterResponse: (event: MaybeArray<AfterResponseHandler<any, any, undefined, "local">>, rest?: [report?: TraceReporter | undefined] | undefined, abortGuard?: string) => string;
-declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, isAsync: boolean] | undefined, abortGuard?: string) => string;
+declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, isAsync: boolean, arm?: string | undefined] | undefined, abortGuard?: string) => string;
 interface QueryWalkState {
   array: Record<string, 1> | undefined;
   object: Record<string, 1> | undefined;
 }
 declare function getQueryParseChannels(querySchema: any): QueryWalkState | undefined;
+declare function awaitGuard(fn: Function, isAsync: boolean, target: string, arm?: string): string;
 //#endregion
-export { Link, TraceReporter, armEntryAbort, cloneResponse, cloneStaticValue, deriveModes, emptyResponse, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync };
+export { Link, TraceReporter, armEntryAbort, awaitGuard, cloneResponse, cloneStaticValue, deriveModes, emptyResponse, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync };

package/dist/compile/handler/utils.js

@@ -25,7 +25,9 @@ function cloneResponse(r) {
 }
 function cloneStaticValue(value) {
 	try {
-		return structuredClone(value);
+		const cloned = structuredClone(value);
+		if (Object.getPrototypeOf(value) === require_error.ElysiaStatus.prototype) Object.setPrototypeOf(cloned, require_error.ElysiaStatus.prototype);
+		return cloned;
 	} catch {
 		return value;
 	}
@@ -51,10 +53,9 @@ function armEntryAbort(context) {
 }
 const trace = (report, fn) => report?.resolveChild(childName(fn)) ?? noTrace;
 const toArray = (v) => Array.isArray(v) ? v : [v];
-const mapTransform = /* @__PURE__ */ map((i, fn, [isAsync, report]) => {
+const mapTransform = /* @__PURE__ */ map((i, fn, [isAsync, report, arm]) => {
 	const t = trace(report, fn);
-	const guard = awaitGuard(fn, isAsync, "_tf");
-	const call = guard ? `_tf=tf${at(i)}(c)\n${guard}` : `${Await(fn)}tf${at(i)}(c)\n`;
+	const call = isAsync ? `_tf=tf${at(i)}(c)\n${awaitGuard(fn, isAsync, "_tf", arm)}` : `tf${at(i)}(c)\n`;
 	return t.begin + call + t.end();
 });
 const deriveKeyCache = /* @__PURE__ */ new WeakMap();
@@ -318,7 +319,7 @@ function skipValue(src, i) {
 	}
 	return -1;
 }
-function mapBeforeHandle(_hooks, derive, link, isAsync, report, abortGuard) {
+function mapBeforeHandle(_hooks, derive, link, isAsync, report, abortGuard, arm) {
 	const hooks = toArray(_hooks);
 	const modes = deriveModes(hooks, derive);
 	let code = "";
@@ -332,8 +333,8 @@ function mapBeforeHandle(_hooks, derive, link, isAsync, report, abortGuard) {
 		}
 		const t = trace(report, fn);
 		code += t.begin;
-		code += `tmp=${Await(fn)}bf${at(i)}(c)\n`;
-		code += awaitGuard(fn, isAsync, "tmp");
+		code += `tmp=bf${at(i)}(c)\n`;
+		code += awaitGuard(fn, isAsync, "tmp", arm);
 		if (modes?.[i] !== void 0) {
 			needsEs = true;
 			if (modes[i]) {
@@ -379,7 +380,7 @@ async function runBeforeHandlePrefixAsync(prefix, context, abort) {
 			if (!first && abort && context["~sig"]?.aborted) return;
 			first = false;
 			let result = values[j](context);
-			if (result instanceof Promise) {
+			if (typeof result?.then === "function") {
 				result = await result;
 				if (abort) context["~sig"] ??= context.request.signal;
 			}
@@ -387,7 +388,7 @@ async function runBeforeHandlePrefixAsync(prefix, context, abort) {
 		}
 	}
 }
-function mapChainHook(hooks, prefix, isAsync, report, abortGuard) {
+function mapChainHook(hooks, prefix, isAsync, report, abortGuard, arm) {
 	let code = "";
 	let depth = 0;
 	for (let i = 0; i < hooks.length; i++) {
@@ -398,25 +399,25 @@ function mapChainHook(hooks, prefix, isAsync, report, abortGuard) {
 		}
 		const t = trace(report, fn);
 		code += t.begin;
-		code += `tmp=${Await(fn)}${prefix}${at(i)}(c)\n`;
-		code += awaitGuard(fn, isAsync, "tmp");
+		code += `tmp=${prefix}${at(i)}(c)\n`;
+		code += awaitGuard(fn, isAsync, "tmp", arm);
 		code += t.end("tmp");
 	}
 	code += "}".repeat(depth);
 	code += `if(tmp!==undefined)_r=c.responseValue=tmp\n`;
 	return code;
 }
-const mapAfterHandle = (_hooks, isAsync, report, abortGuard) => mapChainHook(toArray(_hooks), "af", isAsync, report, abortGuard);
-const mapMapResponse = (_hooks, isAsync, report, abortGuard) => mapChainHook(toArray(_hooks), "mr", isAsync, report, abortGuard);
+const mapAfterHandle = (_hooks, isAsync, report, abortGuard, arm) => mapChainHook(toArray(_hooks), "af", isAsync, report, abortGuard, arm);
+const mapMapResponse = (_hooks, isAsync, report, abortGuard, arm) => mapChainHook(toArray(_hooks), "mr", isAsync, report, abortGuard, arm);
 const mapAfterResponse = /* @__PURE__ */ map((i, fn, [report]) => {
 	const t = trace(report, fn);
-	const call = require_compile_utils.isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(_ar instanceof Promise)await _ar\n`;
+	const call = require_compile_utils.isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(typeof _ar?.then==='function')await _ar\n`;
 	return `try{${t.begin}${call}${t.end()}}catch(_e){${t.end("_e")}console.error(_e)}\n`;
 });
-const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, isAsync]) => {
+const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, isAsync, arm]) => {
 	link(mapResponse, "rm");
 	link(require_handler_error.adoptErrorType, "aet");
-	return `_r=${Await(fn)}er${at(i)}(c)\n` + awaitGuard(fn, isAsync, "_r") + "if(_r!==undefined){\nif(_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
+	return `_r=er${at(i)}(c)\n` + awaitGuard(fn, isAsync, "_r", arm) + "if(_r!==undefined){\nif(_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
 });
 function map(map) {
 	return function(event, rest, abortGuard) {
@@ -502,11 +503,15 @@ function getQueryParseChannels(querySchema) {
 	queryParseChannelsCache.set(querySchema, result);
 	return result ?? void 0;
 }
-const Await = (fn) => require_compile_utils.isAsyncFunction(fn) ? "await " : "";
-const awaitGuard = (fn, isAsync, target) => isAsync && !require_compile_utils.isAsyncFunction(fn) ? `if(${target} instanceof Promise)${target}=await ${target}\n` : "";
+function awaitGuard(fn, isAsync, target, arm = "") {
+	if (!isAsync) return "";
+	const code = `${arm ? `;${arm}\n` : ""}${target}=await ${target}\n`;
+	return require_compile_utils.isAsyncFunction(fn) ? code : `if(typeof ${target}?.then==='function'){${code}}\n`;
+}
 
 //#endregion
 exports.armEntryAbort = armEntryAbort;
+exports.awaitGuard = awaitGuard;
 exports.cloneResponse = cloneResponse;
 exports.cloneStaticValue = cloneStaticValue;
 exports.deriveModes = deriveModes;