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

package/dist/compile/handler/index.mjs

@@ -1,31 +1,28 @@
 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 { Capture, Compiled } from "../aot.mjs";
+import { cloneHook, compactBeforeHandleConflicts, compactBeforeHandlePrefix, compositionKeys, eventProperties, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, isCompactBeforeHandleOnly, isHTMLBundle, isLocalScope, isNotEmpty, macroEpoch, mergeHook, nullObject, refTargets, replaceUrlPath, rootSnapshot } from "../../utils.mjs";
+import { ElysiaStatus } from "../../error.mjs";
+import { mapResponse } from "../../adapter/web-standard/handler.mjs";
+import { Capture, Compiled, aotDrift, warnAotDrift } from "../aot.mjs";
 import { frozenRootOf } from "../../generation.mjs";
+import { isAsyncFunction } from "../utils.mjs";
+import { returnedErrorClasses } from "../../handler/utils.mjs";
+import { deriveModes } from "./utils.mjs";
 import { resolveHandlerParams } from "./params.mjs";
 import { compileHandlerJit, createInlineHandler, setCaptureHeaderShorthand } from "./jit.mjs";
-import { describeRoute, isEmptyPipelineHook, routeDescriptors } from "./descriptor.mjs";
+import { isResponseMap } from "./frozen-validator.mjs";
 import { Reconstrct } from "./reconstruct.mjs";
+import { describeRoute, routeDescriptors } from "./descriptor.mjs";
 import { defaultAdapter } from "../../adapter/constants.mjs";
 
 //#region src/compile/handler/index.ts
-function resolveMountHandler(meta, path) {
-	const { handle, suffixLen } = meta;
-	const rawRoot = suffixLen ? path.slice(0, path.length - suffixLen) : path;
-	const encRoot = encodeURI(rawRoot);
-	const rawLen = rawRoot.length;
-	const encLen = encRoot.length;
-	return (c) => handle(new Request(replaceUrlPath(c.request.url, c.path.slice(c.path.startsWith(encRoot) ? encLen : rawLen) || "/"), c.request));
-}
-function applyHook(localHook, appHook, rootHook, appHookFresh = false) {
+function applyHook(localHook, appHook, rootHook) {
 	let hook;
 	if (localHook && appHook) hook = mergeHook(cloneHook(localHook), appHook, true);
 	else {
-		const base = localHook ?? appHook;
-		const ownsBase = appHookFresh && !localHook && base !== void 0;
-		if (!rootHook) return ownsBase ? base : base ? cloneHook(base) : base;
-		hook = ownsBase ? base : base ? cloneHook(base) : nullObject();
+		const base = localHook ? cloneHook(localHook) : appHook;
+		if (!rootHook) return base;
+		hook = base ?? nullObject();
 	}
 	if (rootHook) mergeHook(hook, rootHook, true, true);
 	return hook;
@@ -77,21 +74,6 @@ function dropHooksByOrigin(hook, skip) {
 	}
 	return out;
 }
-function reconstructNeedsHookState(names) {
-	for (let i = 0; i < names.length; i++) switch (names[i]) {
-		case "ho":
-		case "tf":
-		case "bf":
-		case "af":
-		case "mr":
-		case "er":
-		case "ar":
-		case "va":
-		case "cc":
-		case "tr": return true;
-	}
-	return false;
-}
 function promoteDerive(hook) {
 	const derive = hook.derive;
 	if (derive === void 0) return;
@@ -120,30 +102,33 @@ function memoScope(memos, root, scope) {
 	}
 	return perScope;
 }
+function hasMacroKey(hook, scopeMacro, rootMacro) {
+	if (scopeMacro || rootMacro) {
+		for (const key in hook) if (scopeMacro && key in scopeMacro || rootMacro && key in rootMacro) return true;
+	}
+	return false;
+}
+function applyMacros(hook, scope, frozenRoot, scopeMacro, rootMacro) {
+	if (scopeMacro) {
+		frozenRootOf(scope)["~applyMacro"](hook);
+		if (rootMacro) {
+			for (const k in hook) if (k in scopeMacro) delete hook[k];
+		}
+	}
+	if (rootMacro) frozenRoot["~applyMacro"](hook);
+}
 const localHookMemos = /* @__PURE__ */ new WeakMap();
 function resolveLocalHook(scope, hook, root = scope) {
 	if (!hook) return hook;
 	const frozenRoot = frozenRootOf(root);
 	const scopeMacro = frozenRootOf(scope)["~ext"]?.macro;
 	const rootMacro = root === scope ? void 0 : frozenRoot["~ext"]?.macro;
-	if (!scopeMacro && !rootMacro) return hook;
-	let hasMacroKey = false;
-	for (const key in hook) if (scopeMacro && key in scopeMacro || rootMacro && key in rootMacro) {
-		hasMacroKey = true;
-		break;
-	}
-	if (!hasMacroKey) return hook;
+	if (!hasMacroKey(hook, scopeMacro, rootMacro)) return hook;
 	const perScope = memoScope(localHookMemos, root, scope);
 	let resolved = perScope.get(hook);
 	if (resolved === void 0) {
 		resolved = cloneHook(hook);
-		if (scopeMacro) {
-			frozenRootOf(scope)["~applyMacro"](resolved);
-			if (rootMacro) {
-				for (const k in resolved) if (k in scopeMacro) delete resolved[k];
-			}
-		}
-		if (rootMacro) frozenRoot["~applyMacro"](resolved);
+		applyMacros(resolved, scope, frozenRoot, scopeMacro, rootMacro);
 		perScope.set(hook, resolved);
 	}
 	return resolved;
@@ -171,84 +156,110 @@ function resolveChainNode(root, node) {
 	const frozenRoot = frozenRootOf(root);
 	const scopeMacro = frozenRootOf(scope)["~ext"]?.macro;
 	const rootMacro = root === scope ? void 0 : frozenRoot["~ext"]?.macro;
-	let needsMacro = false;
-	if (scopeMacro || rootMacro) {
-		for (const key in added) if (scopeMacro && key in scopeMacro || rootMacro && key in rootMacro) {
-			needsMacro = true;
-			break;
-		}
-	}
+	const needsMacro = hasMacroKey(added, scopeMacro, rootMacro);
 	if (!needsMacro && added.derive === void 0) return added;
 	const perScope = memoScope(chainNodeMemos, root, scope);
 	let resolved = perScope.get(added);
 	if (resolved === void 0) {
 		resolved = cloneHook(added);
-		if (needsMacro) {
-			if (scopeMacro) {
-				frozenRootOf(scope)["~applyMacro"](resolved);
-				if (rootMacro) {
-					for (const k in resolved) if (k in scopeMacro) delete resolved[k];
-				}
-			}
-			if (rootMacro) frozenRoot["~applyMacro"](resolved);
-		}
+		if (needsMacro) applyMacros(resolved, scope, frozenRoot, scopeMacro, rootMacro);
 		promoteDerive(resolved);
 		perScope.set(added, resolved);
 	}
 	return resolved;
 }
-const chainResolver = (root) => {
+function chainResolver(root) {
 	const frozenRoot = frozenRootOf(root);
 	return frozenRoot["~ext"]?.macro || frozenRoot["~scopeChildren"] ? (node) => resolveChainNode(root, node) : void 0;
-};
+}
 const localMacroRoot = (instance, root) => instance !== root && instance["~scopeChild"] === true && frozenRootOf(instance)["~ext"]?.macro ? instance : root;
-function composeRootHook(root, inheritedChain) {
-	const resolve = chainResolver(root);
-	const locals = flattenChain(frozenRootOf(root)["~hookChain"], isLocalScope, inheritedChain, resolve);
-	const inherited = locals ? flattenChainMemo(root, inheritedChain, resolve) : flattenChainMemoReadonly(root, inheritedChain, resolve);
-	if (!inherited) return locals;
-	if (!locals) return inherited;
-	return mergeHook(inherited, locals);
+/** Whether a hook can be skipped by a native static response. */
+function isEmptyPipelineHook(hook) {
+	if (!hook) return true;
+	for (const key in hook) {
+		if (key === "detail" || key === "tags" || key === "error") continue;
+		const value = hook[key];
+		if (value !== void 0 && value !== false && (!Array.isArray(value) || value.length)) return false;
+	}
+	return true;
+}
+function mapStaticValue(response, map, set, value) {
+	const mapped = map === mapResponse ? mapResponse(value, set, null) : Reflect.apply(map, response, [value, set]);
+	if (!(mapped instanceof Response)) return;
+	const body = value instanceof ElysiaStatus ? value.response : value;
+	if ((typeof body === "string" || typeof body === "number" || typeof body === "boolean") && !mapped.headers.has("content-type")) mapped.headers.set("content-type", "text/plain;charset=utf-8");
+	return mapped;
 }
-function buildNativeStaticResponse([, , handler, instance, localHook, appHook, inheritedChain, macroScope], root) {
+function afterUseHooks(node, resolve) {
+	let after;
+	while (node && "combine" in node) {
+		if (node.tail) {
+			const own = flattenChain(node.tail, isLocalScope, rootSnapshot(node.combine), resolve);
+			if (own) after = after ? mergeHook(own, after, false, true) : own;
+		}
+		node = node.combine;
+	}
+	return after;
+}
+function buildNativeStaticResponse(route, root) {
+	const [, , handler, instance, localHook, appHook, inheritedChain, macroScope] = route;
 	if (typeof handler === "function" || handler instanceof Error || handler instanceof Promise) return;
 	const frozenRoot = frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? defaultAdapter;
-	const hook = applyHook(resolveLocalHook(localMacroRoot(macroScope ?? instance, root), localHook, root), flattenChainMemo(root, appHook, chainResolver(root)), instance !== root ? composeRootHook(root, inheritedChain) : void 0, true);
+	const ownedHook = resolveLocalHook(localMacroRoot(macroScope ?? instance, root), localHook, root);
+	const resolve = chainResolver(root);
+	const flatAppHook = flattenChainMemo(root, appHook, resolve);
+	let rootHook;
+	if (instance !== root) {
+		const locals = flattenChain(frozenRootOf(root)["~hookChain"], isLocalScope, rootSnapshot(inheritedChain), resolve);
+		const inherited = locals ? flattenChainMemo(root, inheritedChain, resolve) : flattenChainMemoReadonly(root, inheritedChain, resolve);
+		if (!inherited) rootHook = locals;
+		else if (!locals) rootHook = inherited;
+		else rootHook = mergeHook(inherited, locals);
+		const after = afterUseHooks(inheritedChain, resolve);
+		if (after) rootHook = rootHook ? mergeHook(after, rootHook) : after;
+	}
+	const hook = applyHook(ownedHook, flatAppHook, rootHook);
 	if (hook && !isEmptyPipelineHook(hook)) return;
+	if (returnedErrorClasses(hook, root)?.some((C) => handler instanceof C)) 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() });
-	if (mapped instanceof Response) {
-		if (!mapped.headers.has("content-type") && (typeof handler === "string" || typeof handler === "number" || typeof handler === "boolean")) mapped.headers.set("content-type", "text/plain;charset=utf-8");
-		return mapped;
-	}
+	const response = adapter.response;
+	const map = response.map;
+	return mapStaticValue(response, map, { headers: rootHeaders ? Object.assign(nullObject(), rootHeaders) : nullObject() }, 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 = false) {
 	const resolve = chainResolver(root);
 	localHook = resolveLocalHook(localMacroRoot(macroScope ?? instance, root), localHook, root);
+	if (localHook && localHook.derive !== void 0) {
+		localHook = cloneHook(localHook);
+		promoteDerive(localHook);
+	}
 	const flatAppHook = appHook ? flattenChainMemo(root, appHook, resolve) : void 0;
-	let locals = instance !== root ? flattenChain(frozenRootOf(root)["~hookChain"], isLocalScope, inheritedChain, resolve) : void 0;
+	let locals = instance !== root ? flattenChain(frozenRootOf(root)["~hookChain"], isLocalScope, rootSnapshot(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)) {
-		let hook = applyHook(localHook, flatAppHook, void 0, true);
+		let hook = applyHook(localHook, flatAppHook, void 0);
 		if (locals) hook = hook ? mergeHook(hook, locals, false, true) : locals;
 		hook ??= nullObject();
 		hook["~beforeHandlePrefix"] = compactPrefix;
 		return hook;
 	}
 	let inherited = instance !== root ? flattenChainMemoReadonly(root, inheritedChain, resolve) : void 0;
-	if ((inherited || locals) && (flatAppHook || localHook) && present?.size) {
+	let after = instance !== root ? afterUseHooks(inheritedChain, resolve) : void 0;
+	if ((inherited || after || locals) && (flatAppHook || localHook) && present?.size) {
 		if (inherited) inherited = dropHooksByOrigin(inherited, present);
+		if (after) after = dropHooksByOrigin(after, present);
 		if (locals) locals = dropHooksByOrigin(locals, present);
 	}
-	let hook = applyHook(localHook, flatAppHook, inherited ? cloneHook(inherited) : void 0, true);
+	let hook = applyHook(localHook, flatAppHook, inherited ? cloneHook(inherited) : void 0);
+	if (after) hook = hook ? mergeHook(hook, after, false, true) : after;
 	if (locals) hook = hook ? mergeHook(hook, locals, false, true) : locals;
 	if (instance !== root) {
 		const errors = instanceLocal?.error;
@@ -265,30 +276,148 @@ function composeRouteHook(instance, localHook, appHook, inheritedChain, root, ma
 	}
 	return hook;
 }
+const shapeEvents = [
+	"parse",
+	"transform",
+	"beforeHandle",
+	"afterHandle",
+	"mapResponse",
+	"afterResponse",
+	"error",
+	"trace"
+];
+const shapeSlots = [
+	"body",
+	"headers",
+	"params",
+	"query",
+	"cookie",
+	"response"
+];
+const isCookieAt = (at) => at === "cookie" || at === "field";
+function childAt(at, k, value, deferred) {
+	if (at.endsWith("*")) return at.slice(0, -1);
+	if (at.endsWith("^")) return k === "0" ? at.slice(0, -1) + (Array.isArray(value) ? "*" : "") : "";
+	if (!isCookieAt(at)) return "";
+	switch (k) {
+		case "$ref": return at;
+		case "properties": return at === "cookie" ? "field*" : "";
+		case "parameters": return deferred ? at + "^" : "";
+	}
+	return k === "$defs" || compositionKeys.includes(k) ? at + "*" : "";
+}
+function routeShape(hook, handler, root) {
+	const frozenRoot = frozenRootOf(root);
+	const config = frozenRoot["~config"];
+	const models = frozenRoot["~ext"]?.models;
+	const refs = /* @__PURE__ */ new Map();
+	const addRef = (name, at = "") => {
+		if (!isCookieAt(at)) at = "";
+		if (at === "cookie" || !refs.get(name)) refs.set(name, at);
+	};
+	const ids = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	let unsupported = false;
+	for (const _ in []) return;
+	const shape = (v, at = "") => {
+		switch (typeof v) {
+			case "string": return JSON.stringify(v);
+			case "number": return "n" + (Object.is(v, -0) ? "-0" : v);
+			case "bigint": return "b" + v;
+			case "boolean": return v ? "T" : "F";
+			case "undefined": return "U";
+			case "function":
+				if (ids.has(v)) return "#" + ids.get(v);
+				ids.set(v, ids.size);
+				return isAsyncFunction(v) ? "fa" : "fs";
+			case "symbol":
+				unsupported = true;
+				return "";
+		}
+		if (v === null) return "N";
+		if ("~standard" in v) return "S";
+		if (visiting.has(v)) {
+			unsupported = true;
+			return "";
+		}
+		let tag = "";
+		const list = Array.isArray(v);
+		const proto = Object.getPrototypeOf(v);
+		if (list ? proto !== Array.prototype : proto !== null && proto !== Object.prototype) {
+			const kind = proto && Object.getOwnPropertyDescriptor(proto, "~kind");
+			if (!kind || !("value" in kind) || Reflect.ownKeys(proto).length !== 1 || Object.getPrototypeOf(proto) !== Object.prototype) {
+				unsupported = true;
+				return "";
+			}
+			tag = shape(kind.value);
+		}
+		visiting.add(v);
+		const map = at === "response" && isResponseMap(v);
+		const deferred = v["~kind"] === "Deferred";
+		let s = (list ? "[" : "{") + tag;
+		for (const k of Reflect.ownKeys(v)) {
+			const d = Object.getOwnPropertyDescriptor(v, k);
+			if (typeof k === "symbol" || !("value" in d)) {
+				unsupported = true;
+				break;
+			}
+			const value = d.value;
+			if (k === "$ref" && typeof value === "string") addRef(value, at);
+			s += "," + (d.enumerable ? "" : "!") + JSON.stringify(k) + ":";
+			if (map) s += named(value);
+			else if (k === "config" && isCookieAt(at)) s += shape([value?.sign, !!value?.secrets]);
+			else if (k === "secrets" && (typeof value === "string" || Array.isArray(value))) s += shape(!!value);
+			else s += shape(value, childAt(at, k, value, deferred));
+		}
+		visiting.delete(v);
+		return s + (list ? "]" : "}");
+	};
+	const named = (v, at) => {
+		if (typeof v === "string") addRef(v, at);
+		return shape(v, at);
+	};
+	let s = typeof handler === "function" || handler == null ? shape(handler) : handler instanceof Response ? "R" : handler instanceof Promise ? "P" : typeof handler === "object" ? "O" : "V";
+	for (const event of shapeEvents) {
+		s += "|";
+		const fns = hook?.[event];
+		if (fns) for (const fn of Array.isArray(fns) ? fns : [fns]) s += shape(fn);
+	}
+	const bf = hook?.beforeHandle;
+	s += "|" + JSON.stringify(bf && deriveModes(Array.isArray(bf) ? bf : [bf], hook["~deriveEntries"]));
+	for (const from of [hook, ...hook?.schemas || []]) for (const slot of shapeSlots) s += "|" + named(from?.[slot], slot);
+	let targets;
+	for (const [ref, at] of refs) for (const target of at ? (targets ??= refTargets([], models))(ref) : [models?.[ref]]) s += "|" + JSON.stringify(ref) + shape(target, at);
+	s += "|" + JSON.stringify([
+		config?.cookie?.sign,
+		config?.cookie?.verify,
+		config?.normalize,
+		!!config?.allowUnsafeValidationDetails,
+		config?.abortSignal !== false,
+		isNotEmpty(frozenRoot["~ext"]?.headers),
+		!!(config?.adapter ?? defaultAdapter).response.supportsDefaultHeaderSink,
+		!!returnedErrorClasses(hook, root)
+	]) + shape(config?.sanitize);
+	return unsupported ? void 0 : fnv1a(s);
+}
 const isBareArrow = /^(?:async\s*)?\(\s*\)\s*=>/;
 const isSucroseOpaque = /arguments|eval|\[native code\]/;
-function isContextFreeHandler(handler) {
-	if (Object.hasOwn(handler, "toString")) return false;
-	const source = Function.prototype.toString.call(handler);
-	return isBareArrow.test(source) && !isSucroseOpaque.test(source);
-}
-function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope], root, precomputedStatic) {
+function compileHandler(route, root, liveOnly = false) {
+	let [_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope] = route;
 	const frozenRoot = frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? defaultAdapter;
 	const method = _method;
 	const mountMeta = typeof handler === "function" ? handler["~mount"] : void 0;
-	if (mountMeta) handler = resolveMountHandler(mountMeta, path);
-	const reconstructed = Compiled.getHandler(frozenRoot["~programId"], method, path);
-	if (reconstructed && !precomputedStatic && typeof handler === "function" && !frozenRoot["~ext"]?.macro && !frozenRootOf(localMacroRoot(macroScope ?? instance, root))["~ext"]?.macro && !reconstructNeedsHookState(reconstructed.a)) return reconstructed.f(handler, ...resolveHandlerParams(reconstructed.a, {
-		root,
-		parse: adapter.parse,
-		res: adapter.response,
-		hook: nullObject(),
-		vali: void 0,
-		cookieConfig: void 0,
-		tracers: void 0
-	}));
-	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope);
+	if (mountMeta) {
+		const { handle, suffixLen } = mountMeta;
+		const rawRoot = suffixLen ? path.slice(0, path.length - suffixLen) : path;
+		const encRoot = encodeURI(rawRoot);
+		const rawLen = rawRoot.length;
+		const encLen = encRoot.length;
+		handler = (c) => handle(new Request(replaceUrlPath(c.request.url, c.path.slice(c.path.startsWith(encRoot) ? encLen : rawLen) || "/"), c.request));
+	}
+	const reconstructed = liveOnly ? void 0 : Compiled.getHandler(frozenRoot["~programId"], method, path);
+	if (!reconstructed) liveOnly ||= Compiled.hasProgram(frozenRoot["~programId"]);
+	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope, !reconstructed);
 	if (hook) {
 		promoteDerive(hook);
 		toArray("parse", hook);
@@ -299,20 +428,24 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		toArray("afterResponse", hook);
 		toArray("error", hook);
 	}
-	const buildValidator = () => hook ? Reconstrct.validator(hook, root, method, path) : void 0;
-	if (handler instanceof Error) {
+	const buildValidator = () => hook ? Reconstrct.validator(hook, root, method, path, liveOnly) : void 0;
+	const errorClasses = returnedErrorClasses(hook, root);
+	if (handler instanceof Error || typeof handler !== "function" && errorClasses?.some((C) => handler instanceof C)) {
 		const error = handler;
 		handler = () => {
 			throw error;
 		};
-	}
+	} else if (isHTMLBundle(handler)) handler = () => {
+		throw new Error(`[Elysia] ${method} ${path} is an HTML bundle, only Bun's native router serves it`);
+	};
+	const declaresResponse = !!hook && (hook.response != null || !!hook.schemas?.some((schema) => schema?.response));
 	const isHandleFunction = typeof handler === "function";
-	if (precomputedStatic) handler = precomputedStatic;
-	else if (!isHandleFunction && !(handler instanceof Promise) && !(!isBun && handler instanceof ElysiaFile)) {
+	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);
-		if (mapped instanceof Response) handler = mapped;
+		const response = adapter.response;
+		const mapped = mapStaticValue(response, response.map, set, handler);
+		if (mapped) handler = mapped;
 	}
 	const isStaticResponse = !isHandleFunction && handler instanceof Response;
 	const isPromiseHandler = !isHandleFunction && handler instanceof Promise;
@@ -321,6 +454,20 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		const resolve = (p) => typeof p === "string" && p in namedParsers ? namedParsers[p] : p;
 		hook.parse = Array.isArray(hook.parse) ? hook.parse.map(resolve) : resolve(hook.parse);
 	}
+	let shape;
+	if (reconstructed || Capture.isCapturing()) {
+		shape = routeShape(hook, handler, root);
+		if (reconstructed && (!shape || reconstructed.k !== shape)) {
+			let live;
+			try {
+				live = compileHandler(route, root, true);
+			} catch (cause) {
+				throw new Error(aotDrift(method, path), { cause });
+			}
+			warnAotDrift(method, path);
+			return live;
+		}
+	}
 	if (reconstructed) return reconstructed.f(handler, ...resolveHandlerParams(reconstructed.a, {
 		root,
 		parse: adapter.parse,
@@ -330,10 +477,19 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		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 && !errorClasses && isHandleFunction && !mountMeta && (method === "GET" || method === "HEAD") && !root["~hasTrace"] && root["~introspect"] !== true && root["~config"]?.introspect !== true && !isNotEmpty(frozenRoot["~ext"]?.headers) && !Capture.isAotBuildEnv() && !Capture.isCapturing()) {
+		let isContextFree = false;
+		if (!Object.hasOwn(handler, "toString")) {
+			const source = Function.prototype.toString.call(handler);
+			isContextFree = isBareArrow.test(source) && !isSucroseOpaque.test(source);
+		}
+		if (isContextFree) {
+			const compact = adapter.response.compact;
+			if (compact) return createInlineHandler(compact, handler);
+		}
+	}
 	const state = describeRoute({
 		method,
-		path,
 		handler,
 		root,
 		adapter,
@@ -355,7 +511,6 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		method,
 		path,
 		handler,
-		instance,
 		root: frozenRoot,
 		errorRoot: root,
 		hook,
@@ -363,9 +518,11 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		isHandleFunction,
 		isStaticResponse,
 		isPromiseHandler,
-		state
+		errorClasses,
+		state,
+		shape
 	});
 }
 
 //#endregion
-export { buildNativeStaticResponse, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };
+export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, routeShape, setCaptureHeaderShorthand };

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

@@ -1,18 +1,25 @@
-import { AnyLocalHook, CompiledHandler } from "../../types.js";
 import { Context } from "../../context.js";
+import { AnyLocalHook, CompiledHandler } from "../../types.js";
 import { AnyElysia } from "../../base.js";
 import { ElysiaAdapter } from "../../adapter/index.js";
 import { RouteCompileState } from "./descriptor.js";
+import { TailMode } from "./utils.js";
 
 //#region src/compile/handler/jit.d.ts
+/**
+ * @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
+ */
+declare let onEmit: ((code: string) => void) | undefined;
+declare const setOnEmit: (fn: typeof onEmit) => void;
+declare const setAsyncTail: (on: boolean | undefined) => void;
 declare const setCaptureHeaderShorthand: (value: boolean | undefined) => void;
-declare function schemaMediaKind(schema: any): number | undefined;
 declare const createInlineHandler: (map: (value: unknown, ...rest: unknown[]) => unknown, h: (context: Context) => unknown) => CompiledHandler;
 interface CompileHandlerJitOptions {
   method: string;
   path: string;
   handler: unknown;
-  instance: AnyElysia;
   root: AnyElysia;
   errorRoot: AnyElysia;
   hook: AnyLocalHook | undefined;
@@ -20,24 +27,19 @@ interface CompileHandlerJitOptions {
   isHandleFunction: boolean;
   isStaticResponse: boolean;
   isPromiseHandler: boolean;
+  /**
+   * Non-Error classes a returned value is rethrown for, see
+   * `returnedErrorClasses`
+   */
+  errorClasses?: Function[];
   /**
    * Per-route descriptor + compile artifacts, computed by `describeRoute`.
    * The JIT no longer re-derives these facts; it names its emissions off them.
    */
   state: RouteCompileState;
+  /** `routeShape`, recorded with the captured code */
+  shape?: number;
 }
-declare function compileHandlerJit({
-  method,
-  path,
-  handler,
-  root,
-  errorRoot,
-  hook,
-  adapter,
-  isHandleFunction,
-  isStaticResponse,
-  isPromiseHandler,
-  state
-}: CompileHandlerJitOptions): CompiledHandler;
+declare function compileHandlerJit(options: CompileHandlerJitOptions, tailPass?: TailMode): CompiledHandler;
 //#endregion
-export { CompileHandlerJitOptions, compileHandlerJit, createInlineHandler, schemaMediaKind, setCaptureHeaderShorthand };
+export { CompileHandlerJitOptions, compileHandlerJit, createInlineHandler, setAsyncTail, setCaptureHeaderShorthand, setOnEmit };