elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/compile/handler/jit.js

@@ -10,53 +10,70 @@ 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;
+/**
+* @internal test hook: receives each route's emitted source. A sync-first
+* route's async tail is a helper beside it, so `toString()` of the compiled
+* handler does not show the whole pipeline
+*/
+let onEmit;
+const setOnEmit = (fn) => {
+	onEmit = fn;
+};
+/**
+* @internal test hook: `false` compiles sync-first routes on the `async`
+* lane instead, the reference the async tail is differentially tested
+* against. `undefined` restores the default (see `tail` below)
+*/
+let asyncTailOn;
+const setAsyncTail = (on) => {
+	asyncTailOn = on;
+};
 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) {
-	if (parsers && typeof parsers === "function") parsers = [parsers];
+function parse(adapter, hook, bodyVali, hasHeaders, link, report, arm) {
+	let parsers = hook?.parse;
 	if (typeof parsers === "string" || parsers?.length === 1 && typeof parsers[0] === "string") {
 		if (parsers.length === 1) parsers = parsers[0];
 		const builtinName = parsers;
 		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;
@@ -66,18 +83,18 @@ function parse(adapter, parsers, bodyVali, hasHeaders, link, report) {
 			break;
 		}
 	}
-	const bodyKind = hasFn ? void 0 : bodyMediaKind(bodyVali);
+	const bodyKind = hasFn ? void 0 : schemaMediaKind(bodyVali?.schema);
 	let code = `let ct=((${hasHeaders ? "c.headers['content-type']" : "c.request.headers.get('content-type')"})||'')\nlet cti=ct.indexOf(";")
 if(cti!==-1)ct=ct.slice(0,cti)
 ` + (hasFn ? "c.contentType=ct\n" : "");
 	if (parsers) for (let i = 0; i < parsers.length; i++) {
 		const parser = parsers[i];
 		if (typeof parser === "function") {
-			link(0, "");
+			link(hook, "ho");
 			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 +103,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,14 +121,14 @@ 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)", 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");
 	}
 	return hasFn ? "let hasBody=false,_bp\n" + code : code;
 }
-const bodyMediaKind = (bodyVali) => schemaMediaKind(bodyVali?.schema);
 function schemaMediaKind(schema) {
 	if (!schema || typeof schema !== "object" || "~standard" in schema) return;
 	const elyType = schema["~elyTyp"];
@@ -141,55 +158,45 @@ 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));
-	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));
-	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;
+function compileHandlerJit(options, tailPass) {
+	const { method, path, handler, root, errorRoot, hook, adapter, isHandleFunction, isStaticResponse, isPromiseHandler, errorClasses, state, shape } = options;
+	const { vali, inference, cookieConfig, beforeHandlePrefix, traceHandlers, tracePhases, hasAnyPhase, traceHandleOn, descriptor: { async: isAsync, tail: tailRoute, 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 hasDeriveDispose = !!hook?.["~deriveEntries"]?.length;
+	const hasDynamicAfterResponse = !!inference.afterResponse || hasDeriveDispose;
+	const hasStl = (hasAfterResponse || hasTrace || hasDeriveDispose) && !syncAfterResponse;
+	const tail = tailRoute && (asyncTailOn ?? captureHeaderShorthand ?? require_universal_constants.isBun);
+	const asyncMode = tail ? tailPass ?? {
+		async: false,
+		n: 0,
+		live: hasStl ? ",_stl,_sv" : "",
+		sites: []
+	} : isAsync;
+	const plain = (code) => require_compile_handler_utils.tailPlain(asyncMode, code);
 	const seenKeys = new Set(["rt", "fre"]);
 	const paramValues = [errorRoot, require_handler_utils.finalizeRouteError];
 	const aliasKeys = [];
 	function link(v, key) {
-		if (v === 0) {
-			if (!seenKeys.has("ho")) {
-				seenKeys.add("ho");
-				paramValues.push(hook);
-				aliasKeys.push("ho");
-			}
-			return;
-		}
 		if (!seenKeys.has(key)) {
 			seenKeys.add(key);
 			paramValues.push(v);
 			aliasKeys.push(key);
 		}
 	}
+	if (errorClasses) link(require_handler_utils.forwardErrorOf(errorClasses), "ie");
+	const fwd = errorClasses ? "ie" : "fe";
+	const rethrow = (v) => errorClasses ? `ie(${v})\n` : `if(${v} instanceof Error)throw ${v}\n`;
 	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)" : "";
+	let abortSchedule = "";
+	let discard = "";
+	const abortCheck = () => abortOn ? plain(abortSchedule || discard ? `if(${abortPeek}){${discard}${abortSchedule}return emp.clone()}\n` : `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 "";
@@ -208,7 +215,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		if (!phaseOn(phase)) return;
 		return { resolveChild(name) {
 			let begin = "";
-			for (let i = 0; i < traceCount; i++) begin += `rpc${i}=rp${i}.resolveChild?.shift?.()?.({id:c.rid,event:'${phase}',name:${JSON.stringify(name)},begin:performance.now()})\n`;
+			for (let i = 0; i < traceCount; i++) begin += `rpc${i}=rp${i}.shift?.()?.({id:c.rid,event:'${phase}',name:${JSON.stringify(name)},begin:performance.now()})\n`;
 			return {
 				begin,
 				end(errBinding) {
@@ -220,14 +227,17 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 			};
 		} };
 	};
-	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` : `_r=h\n`;
-	let code = `${isAsync ? "async " : ""}function route(c){\n`;
+	const needsStaticClone = !isHandleFunction && !isStaticResponse && !isPromiseHandler && (hasAfterHandle || hasMapResponse) && typeof handler === "object" && handler !== null;
+	if (needsStaticClone) link(require_compile_handler_utils.cloneStaticValue, "scl");
+	const callHandler = () => isHandleFunction ? require_compile_handler_utils.awaitSite("h(c)", handler, asyncMode, "_r", arm) : isStaticResponse ? `_r=cr(h)\n` : isPromiseHandler ? `_r=h.then(cr)\n` : needsStaticClone ? `_r=scl(h)\n` : `_r=h\n`;
+	const stageSite = (call, target, fn, at = "") => require_compile_handler_utils.asyncTail(asyncMode) ? require_compile_handler_utils.tailStage(require_compile_handler_utils.asyncTail(asyncMode)) + require_compile_handler_utils.awaitSite(call, fn, asyncMode, target, at) + "}\n" : require_compile_handler_utils.awaitSite(call, fn, asyncMode, target, at);
+	let code = `${isAsync && !tail ? "async " : ""}function route(c){\n`;
 	if (abortOn) {
 		link(require_handler_utils.emptyResponse, "emp");
 		link(require_compile_handler_utils.armEntryAbort, "ea");
 		code += `if(ea(c))return emp.clone()\n`;
 	}
-	if ((hasAfterResponse || hasTrace) && !syncAfterResponse) code += "let _stl\n";
+	if (hasStl) code += "let _stl,_sv\n";
 	if (asyncCookieSign) code += "let _sg\n";
 	if (hasTrace) {
 		const traceProvider = require_generation.resolvedTraceOf(root) ?? require_generation.resolvedTraceOf(errorRoot);
@@ -252,7 +262,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	code += "try{\n";
 	if (responseMode === "set-with-default-headers" && (inference.set || hasTrace)) {
 		link(require_adapter_utils.materializeSetHeaders, "msh");
-		code += `msh(c.set)\n`;
+		code += plain(`msh(c.set)\n`);
 	}
 	const hasHeaders = inference.headers || !!vali?.headers;
 	if (inference.query || vali?.query) {
@@ -266,18 +276,18 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 			link(channels.object, "qo");
 			parseArgs += `${channels.array ? "" : ",undefined"},qo`;
 		}
-		code += `c.query=pq(c.request.url,c.qi${parseArgs})\n`;
+		code += plain(`c.query=pq(c.request.url,c.qi${parseArgs})\n`);
 		link(require_parse_query.parseQueryFromURL, "pq");
 	}
 	if (hasHeaders) {
-		if (captureHeaderShorthand === void 0 && require_compile_aot.Capture.isCapturing()) code += `c.headers=c.request.headers.toJSON?.()??Object.fromEntries(c.request.headers)\n`;
-		else code += `c.headers=${captureHeaderShorthand ?? require_universal_constants.hasHeaderShorthand ? "c.request.headers.toJSON()" : "Object.fromEntries(c.request.headers)"}\n`;
+		if (captureHeaderShorthand === void 0 && require_compile_aot.Capture.isCapturing()) code += plain(`c.headers=c.request.headers.toJSON?.()??Object.fromEntries(c.request.headers)\n`);
+		else code += plain(`c.headers=${captureHeaderShorthand ?? require_universal_constants.hasHeaderShorthand ? "c.request.headers.toJSON()" : "Object.fromEntries(c.request.headers)"}\n`);
 		inlineUnsafe = true;
 	}
 	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, 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`;
@@ -290,30 +300,30 @@ 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, [
+				asyncMode,
+				buildReport("transform"),
+				arm
+			], abortChainGuard(), require_compile_handler_utils.asyncTail(asyncMode));
 		}
 		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`;
-	}
-	if (vali?.headers) {
+	for (const [slot, slotIsAsync] of [
+		["body", bodyValiIsAsync],
+		["headers", headersValiIsAsync],
+		["params", paramsValiIsAsync],
+		["query", queryValiIsAsync]
+	]) if (vali?.[slot]) {
 		link(vali, "va");
-		code += `c.headers=${headersValiIsAsync ? "await " : ""}va.headers.From(c.headers,${fromArgs("headers", !!headersValiIsAsync)})\n`;
-	}
-	if (vali?.params) {
-		link(vali, "va");
-		code += `c.params=${paramsValiIsAsync ? "await " : ""}va.params.From(c.params,${fromArgs("params", !!paramsValiIsAsync)})\n`;
-	}
-	if (vali?.query) {
-		link(vali, "va");
-		code += `c.query=${queryValiIsAsync ? "await " : ""}va.query.From(c.query,${fromArgs("query", !!queryValiIsAsync)})\n`;
+		const value = `va.${slot}.From(c.${slot},${fromArgs(slot, slotIsAsync)})`;
+		code += plain(`c.${slot}=${slotIsAsync ? awaitValue(value, arm) : value}\n`);
 	}
 	if (cookieConfig) {
+		const cookieStart = code.length;
 		link(require_cookie_utils.buildCookieJar, "bcj");
 		link(cookieConfig, "cc");
+		const asyncLazyVerify = asyncCookieSign && cookieConfig.verify === "lazy" && !vali?.cookie;
 		const cookieHeaderExpr = hasHeaders && !vali?.headers ? "c.headers['cookie']" : "c.request.headers.get('cookie')";
 		if (lazyCookieVerify) {
 			link(require_cookie_utils.parseCookieRawLazy, "pcrl");
@@ -334,42 +344,57 @@ 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${asyncLazyVerify ? ",1" : ""})`, 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`;
 		}
+		code = code.slice(0, cookieStart) + plain(code.slice(cookieStart));
 	}
-	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;
+	if (hasSet) link(responseMap, "rm");
+	else link(responseCompact, "rc");
+	const map = hasSet ? "rm" : "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`;
 	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 ? (() => {
-		let s = "";
-		for (let i = 0; i < traceCount; i++) s += `tr${i}.r(_hr${i},_ser)\n`;
-		return s;
-	})() : "";
+	let resolveHandlePostDrain = "";
+	if (traceHandleOn) for (let i = 0; i < traceCount; i++) resolveHandlePostDrain += `tr${i}.r(_hr${i},_ser)\n`;
 	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 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` : "";
+	if (hasDeriveDispose) link(require_handler_utils.drainDisposables, "dds");
+	const deriveDisposeOnly = hasDeriveDispose && !hasAfterResponse && !hasTrace;
+	const disposeGuard = deriveDisposeOnly ? "c['~dispose']&&" : "";
+	const scheduleAfterResponse = hasAfterResponse || traceNeedsSchedule || hasDeriveDispose ? (deriveDisposeOnly ? `if(c['~dispose']){\n` : "") + "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` : "") + (hasDeriveDispose ? `await dds(c)\n` : "") + endTrace("afterResponse") + `})\n` + (deriveDisposeOnly ? `}\n` : "") : "";
+	const dedupSchedule = !!scheduleAfterResponse && !syncAfterResponse && !syncErrorHook;
+	const scheduleArgs = tail ? "c,_stl" : "";
+	const scheduleDecl = dedupSchedule ? `function _sc(${scheduleArgs}){\n${scheduleAfterResponse}}\n` : "";
+	const schedule = dedupSchedule ? `_sc(${scheduleArgs})\n` : scheduleAfterResponse;
+	const syncScheduleDecl = syncAfterResponse && scheduleAfterResponse ? `function _scf(c,_stl){\n${scheduleAfterResponse}}\n` : "";
+	const catchSchedule = dedupSchedule ? `_sc(${scheduleArgs})\n` : syncScheduleDecl ? `_scf(c)\n` : "";
+	abortSchedule = hasDeriveDispose ? syncAfterResponse ? catchSchedule : schedule : "";
+	const freThenSchedule = (arg) => catchSchedule ? `if(c._arf)return fre(rt,c,${arg})\n${deriveDisposeOnly ? `if(c['~dispose'])` : ""}c._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 mapThenSchedule = (s, onReject) => `if(typeof _m?.then==='function')return Promise.resolve(_m).then((_v)=>{\n${s}return _v\n},${onReject})\n` + s + `return _m\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 = "";
+	let tailCatch = -1;
 	if (hasBeforeHandle || hasAfterHandle || hasMapResponse || hasAfterResponse || hasResponseValidator || hasCookieSign || hasTrace) {
-		code += `let _r,tmp\n`;
+		code += `let _r${require_compile_handler_utils.asyncTail(asyncMode) ? "=_lr" : ""},tmp${hasDeriveDispose ? ",_v" : ""}\n`;
+		if (typeof asyncMode === "object") asyncMode.r = true;
 		if (hasBeforeHandle || hasTrace) {
 			const bfLen = (beforeHandlePrefix?.length ?? 0) + (hook?.beforeHandle?.length ?? 0);
 			code += beginTrace("beforeHandle", bfLen);
@@ -379,7 +404,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`;
@@ -390,53 +415,53 @@ 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, asyncMode, buildReport("beforeHandle"), chainGuard, arm);
 					code += beforeHandlePrefix ? `if(${chainGuard ? `!${chainGuard}&&` : ""}_r===undefined){\n${mapped}}\n` : mapped;
 				}
 			}
 			code += endTrace("beforeHandle");
 			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` : "";
+		if (hasAfterResponse || traceHandleOn || hasDeriveDispose) {
+			link(require_adapter_utils.tee, "tee");
+			link(require_adapter_utils.observeStream, "obs");
+		}
+		const teeBlock = (hasAfterResponse || traceHandleOn || hasDeriveDispose) && !syncAfterResponse ? `if(${disposeGuard}_r&&(_r[Symbol.iterator]||_r[Symbol.asyncIterator])&&typeof _r.next==='function'){\nconst _s=tee(_r,2)\n_sv=_r=_s[0]\n` + (traceHandleOn ? `_trs=_s[1]\n` : `_stl=_s[1]\n`) + `}else if(${disposeGuard}_r instanceof ReadableStream){const _o=obs(_r)\nif(_o){_r=_o[0];_stl=_o[1];_sv=_o[2]}}\n` : "";
 		if (traceHandleOn) {
 			const handleName = handler?.name && typeof handler.name === "string" ? handler.name : "anonymous";
 			code += beginTrace("handle", 1, handleName);
 			const handleChild = buildReport("handle").resolveChild(handleName);
 			code += handleChild.begin;
-			if (hasBeforeHandle) code += `if(_r===undefined){\n${callHandler}${teeBlock}}\n`;
-			else code += callHandler + teeBlock;
+			if (hasBeforeHandle) code += `if(_r===undefined){\n${callHandler()}${teeBlock}}\n`;
+			else code += callHandler() + teeBlock;
 			code += handleChild.end("_r");
 			code += `if(_trs){\n`;
 			for (let i = 0; i < traceCount; i++) code += `_hr${i}=rp${i};\n`;
 			code += `}else{\n`;
 			code += endTrace("handle");
 			code += `}\n`;
-		} else if (hasBeforeHandle) code += `if(_r===undefined){\n${callHandler}${teeBlock}}\n`;
-		else code += callHandler + teeBlock;
+		} else if (isHandleFunction && require_compile_handler_utils.asyncTail(asyncMode)) code += require_compile_handler_utils.tailStage(require_compile_handler_utils.asyncTail(asyncMode), hasBeforeHandle ? "_r===undefined" : void 0) + callHandler() + teeBlock + "}\n";
+		else if (hasBeforeHandle) code += plain(`if(_r===undefined){\n${callHandler()}${teeBlock}}\n`);
+		else code += plain(callHandler() + teeBlock);
+		if (teeBlock) discard = "_sv?.return()\n";
 		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";
+			if (!errorClasses) link(require_handler_utils.forwardError, "fe");
+			factoryHelpers += syncScheduleDecl + `function _fin(c,_r){\n` + rethrow("_r") + "if(_r&&(_r[Symbol.iterator]||_r[Symbol.asyncIterator])&&typeof _r.next==='function'){\nconst _s=tee(_r,2)\nreturn _fin2(c,_s[0],_s[1],_s[0])\n}\nif(_r instanceof ReadableStream){const _o=obs(_r)\nif(_o)return _fin2(c,_o[0],_o[1],_o[2])}\nreturn _fin2(c,_r)\n}\nfunction _fin2(c,_r,_stl,_sv){try{\nc.responseValue=_r\n" + signPrefix + `const _m=${mapValue("_r")}\n` + mapThenSchedule(syncScheduleDecl ? `_scf(c,_stl)\n` : scheduleAfterResponse, `(_e)=>{_sv?.return()\n${freThenSchedule("_e")}}`) + `}catch(_e){_sv?.return();throw _e}}\n`;
+			code += `if(typeof _r?.then==='function')return Promise.resolve(_r).then(${fwd}).then((_v)=>_fin(c,_v)).catch((_e)=>{${freThenSchedule("_e")}})\nreturn _fin(c,_r)\n`;
 		} else {
-			code += `if(_r instanceof Error)throw _r\n`;
+			code += plain(rethrow("_r"));
 			if (!isAsync) {
-				link(require_handler_utils.forwardError, "fe");
-				code += `else if(_r instanceof Promise)_r=_r.then(fe)\n`;
+				if (!errorClasses) link(require_handler_utils.forwardError, "fe");
+				code += `${errorClasses ? "" : "else "}if(typeof _r?.then==='function')_r=Promise.resolve(_r).then(${fwd})\n`;
 			}
-			if (hasAfterHandle || hasMapResponse || hasAfterResponse || hasTrace) code += `c.responseValue=_r\n`;
+			if (hasAfterHandle || hasMapResponse || hasAfterResponse || hasTrace) code += plain(`c.responseValue=_r\n`);
 			if (hasAfterHandle || hasTrace) {
 				const afLen = hook?.afterHandle?.length ?? 0;
 				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.mapChainHook(hook.afterHandle, "af", asyncMode, buildReport("afterHandle"), abortChainGuard(), arm);
 				}
 				code += endTrace("afterHandle");
 				if (hasAfterHandle) code += abortCheck();
@@ -446,7 +471,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.mapChainHook(hook.mapResponse, "mr", asyncMode, buildReport("mapResponse"), abortChainGuard(), arm);
 				}
 				code += endTrace("mapResponse");
 				if (hasMapResponse) code += abortCheck();
@@ -454,27 +479,34 @@ 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 " : "";
-				code += `if(_r instanceof es){
-const _vr=va.response[_r.code]
-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`;
+				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 += plain(`if(_r instanceof es){
+const _vr=va.response[_r.status]
+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;
-			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 deferSchedule = !!schedule;
+			code += plain(signPrefix);
+			const finalMap = mapValue("_r");
+			const onMapReject = syncErrorHook ? `(_e)=>_ce(_e,c)` : dedupSchedule ? `(_e)=>{${freThenSchedule("_e")}}` : `(_e)=>fre(rt,c,_e)`;
+			if (tail) code += `let _m\n${stageSite(finalMap, "_m")}` + (deferSchedule ? schedule : "") + `return _m\n`;
+			else 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 ? mapThenSchedule(schedule, onMapReject) : `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`);
-	} else code += `const _m=${mapReturn.trim()}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n`;
+		if (!isAsync && !errorClasses) link(require_handler_utils.forwardError, "fe");
+		const finalMap = mapValue("_r");
+		if (typeof asyncMode === "object") {
+			code += `let _r${require_compile_handler_utils.asyncTail(asyncMode) ? "=_lr" : ""}\n`;
+			asyncMode.r = true;
+			code += stageSite("h(c)", "_r", handler, arm);
+		} else code += `let ${callHandler()}`;
+		code += abortCheck() + plain(rethrow("_r")) + (tail ? `let _m\n${stageSite(finalMap, "_m")}return _m\n` : isAsync ? `return await ${finalMap}\n` : `if(typeof _r?.then==='function')_r=Promise.resolve(_r).then(${fwd})\nconst _m=${finalMap}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>${syncErrorHook ? "_ce(_e,c)" : "fre(rt,c,_e)"}):_m\n`);
+	} else code += plain(`const _m=${mapValue(isStaticResponse ? "cr(h)" : isPromiseHandler ? "h.then(cr)" : "h")}\nreturn typeof _m?.then==='function'?Promise.resolve(_m).catch((_e)=>fre(rt,c,_e)):_m\n`);
 	if (hasErrorHook || hasTrace) {
 		let body = "";
 		if (hasTrace) {
@@ -486,28 +518,48 @@ 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";
-			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, [
+			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";
+			const errorHead = plain(`c.error=e\n` + (allowUnsafeDetail ? `if(e instanceof verr)e.allowUnsafeValidationDetails=true\n` : ``) + "if(e?.status)c.set.status=e.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n");
+			if (typeof asyncMode === "object") {
+				tailCatch = asyncMode.n;
+				asyncMode.r = false;
+				asyncMode.e = true;
+			}
+			body += errorHead + `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.mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : 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`;
-		}
+				asyncMode,
+				arm
+			], abortChainGuard(), require_compile_handler_utils.asyncTail(asyncMode)) + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule) + `return _efb(e,c)\n`;
+		} else body += endTrace("error") + freThenSchedule("e");
+		const hookThrew = `catch(_ee){${freThenSchedule("_ee").trimEnd()}}}\n`;
 		if (syncErrorHook) {
-			factoryHelpers += `function _ce(e,c){${abortOn ? "let _as\n" : ""}try{\n${body}}catch(_ee){return fre(rt,c,_ee)}}\n`;
+			factoryHelpers += `function _ce(e,c){${abortOn ? "let _as\n" : ""}try{\n${body}}${hookThrew}`;
 			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 += `}catch(e){try{\n${body}}${hookThrew}`;
+	} else code += catchSchedule ? `}catch(e){${freThenSchedule("e")}}\n` : `}catch(e){return fre(rt,c,e)}\n`;
+	if (tailPass) return code;
 	code += "}";
-	code = head + (abortOn && code.includes("_as") ? "let _as\n" : "") + scheduleDecl + code;
+	code = head + (abortOn && code.includes("_as") ? "let _as\n" : "") + (abortOn && code.includes("_av") ? "let _av\n" : "") + (tail ? "" : scheduleDecl) + code;
+	if (tail) {
+		const { n, live, sites } = asyncMode;
+		const pass = {
+			async: true,
+			n: 0,
+			live,
+			sites: []
+		};
+		const pipeline = compileHandlerJit(options, pass);
+		if (pass.sites.join("\n") !== sites.join("\n") || !pipeline.startsWith("try{\n")) throw new Error("[elysia] async tail out of step with its route");
+		factoryHelpers += scheduleDecl + `async function _t(c,_rk,_y,_lr,_le${live}){\n` + (abortOn && pipeline.includes("_as") ? "let _as\n" : "") + "try{\n" + (tailCatch !== -1 && tailCatch < n ? `if(_rk>=${tailCatch})throw _le\n` : "") + pipeline.slice(5) + "}\n";
+	}
+	if (syncCookieSign || asyncCookieSign) {
+		code = code.replaceAll("fre(rt,c,", "_sfre(rt,c,");
+		factoryHelpers = factoryHelpers.replaceAll("fre(rt,c,", "_sfre(rt,c,") + `function _sgn(s){return scv(s.cookie,cc)}\nfunction _sfre(rt,c,e){return fre(rt,c,e,_sgn)}\n`;
+	}
 	if (factoryHelpers) code = `(function(){\n${factoryHelpers}return ${code}})()`;
 	const alias = aliasKeys.join(",");
 	const fullAlias = alias ? `rt,fre,${alias}` : "rt,fre";
@@ -515,12 +567,32 @@ let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapErro
 		method,
 		path,
 		alias: fullAlias,
-		code
+		code,
+		k: shape
 	});
+	onEmit?.(code);
 	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);
-		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);
+		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")) {
+			const rmap = responseMap;
+			const h = handler;
+			let inlineHandler;
+			if (responseMode === "set-with-default-headers" && inference.set) inlineHandler = ((c) => {
+				require_adapter_utils.materializeSetHeaders(c.set);
+				const r = h(c);
+				if (r instanceof Error) throw r;
+				if (typeof r?.then === "function") return Promise.resolve(r).then((v) => rmap(require_handler_utils.forwardError(v), c.set, c.request, true));
+				return rmap(r, c.set, c.request, true);
+			});
+			else inlineHandler = ((c) => {
+				const r = h(c);
+				if (r instanceof Error) throw r;
+				if (typeof r?.then === "function") return Promise.resolve(r).then((v) => rmap(require_handler_utils.forwardError(v), c.set, c.request, true));
+				return rmap(r, c.set, c.request, true);
+			});
+			return inlineHandler;
+		}
 	}
 	require_compile_jit_probe.JITProbe.record("handler:new-function");
 	return new Function("h", fullAlias, `return ${code}`)(handler, ...paramValues);
@@ -529,5 +601,6 @@ let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapErro
 //#endregion
 exports.compileHandlerJit = compileHandlerJit;
 exports.createInlineHandler = createInlineHandler;
-exports.schemaMediaKind = schemaMediaKind;
-exports.setCaptureHeaderShorthand = setCaptureHeaderShorthand;
+exports.setAsyncTail = setAsyncTail;
+exports.setCaptureHeaderShorthand = setCaptureHeaderShorthand;
+exports.setOnEmit = setOnEmit;