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

package/dist/compile/handler/index.js

@@ -2,31 +2,28 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../../universal/constants.js');
 const require_universal_file = require('../../universal/file.js');
 const require_utils = require('../../utils.js');
+const require_error = require('../../error.js');
+const require_adapter_web_standard_handler = require('../../adapter/web-standard/handler.js');
 const require_compile_aot = require('../aot.js');
 const require_generation = require('../../generation.js');
+const require_compile_utils = require('../utils.js');
+const require_handler_utils = require('../../handler/utils.js');
+const require_compile_handler_utils = require('./utils.js');
 const require_compile_handler_params = require('./params.js');
 const require_compile_handler_jit = require('./jit.js');
-const require_compile_handler_descriptor = require('./descriptor.js');
+const require_compile_handler_frozen_validator = require('./frozen-validator.js');
 const require_compile_handler_reconstruct = require('./reconstruct.js');
+const require_compile_handler_descriptor = require('./descriptor.js');
 const require_adapter_constants = require('../../adapter/constants.js');
 
 //#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(require_utils.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 = require_utils.mergeHook(require_utils.cloneHook(localHook), appHook, true);
 	else {
-		const base = localHook ?? appHook;
-		const ownsBase = appHookFresh && !localHook && base !== void 0;
-		if (!rootHook) return ownsBase ? base : base ? require_utils.cloneHook(base) : base;
-		hook = ownsBase ? base : base ? require_utils.cloneHook(base) : require_utils.nullObject();
+		const base = localHook ? require_utils.cloneHook(localHook) : appHook;
+		if (!rootHook) return base;
+		hook = base ?? require_utils.nullObject();
 	}
 	if (rootHook) require_utils.mergeHook(hook, rootHook, true, true);
 	return hook;
@@ -78,21 +75,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;
@@ -121,30 +103,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) {
+		require_generation.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 = require_generation.frozenRootOf(root);
 	const scopeMacro = require_generation.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 = require_utils.cloneHook(hook);
-		if (scopeMacro) {
-			require_generation.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;
@@ -172,84 +157,110 @@ function resolveChainNode(root, node) {
 	const frozenRoot = require_generation.frozenRootOf(root);
 	const scopeMacro = require_generation.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 = require_utils.cloneHook(added);
-		if (needsMacro) {
-			if (scopeMacro) {
-				require_generation.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 = require_generation.frozenRootOf(root);
 	return frozenRoot["~ext"]?.macro || frozenRoot["~scopeChildren"] ? (node) => resolveChainNode(root, node) : void 0;
-};
+}
 const localMacroRoot = (instance, root) => instance !== root && instance["~scopeChild"] === true && require_generation.frozenRootOf(instance)["~ext"]?.macro ? instance : root;
-function composeRootHook(root, inheritedChain) {
-	const resolve = chainResolver(root);
-	const locals = require_utils.flattenChain(require_generation.frozenRootOf(root)["~hookChain"], require_utils.isLocalScope, inheritedChain, resolve);
-	const inherited = locals ? require_utils.flattenChainMemo(root, inheritedChain, resolve) : require_utils.flattenChainMemoReadonly(root, inheritedChain, resolve);
-	if (!inherited) return locals;
-	if (!locals) return inherited;
-	return require_utils.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 buildNativeStaticResponse([, , handler, instance, localHook, appHook, inheritedChain, macroScope], root) {
+function mapStaticValue(response, map, set, value) {
+	const mapped = map === require_adapter_web_standard_handler.mapResponse ? require_adapter_web_standard_handler.mapResponse(value, set, null) : Reflect.apply(map, response, [value, set]);
+	if (!(mapped instanceof Response)) return;
+	const body = value instanceof require_error.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 afterUseHooks(node, resolve) {
+	let after;
+	while (node && "combine" in node) {
+		if (node.tail) {
+			const own = require_utils.flattenChain(node.tail, require_utils.isLocalScope, require_utils.rootSnapshot(node.combine), resolve);
+			if (own) after = after ? require_utils.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 = require_generation.frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
-	const hook = applyHook(resolveLocalHook(localMacroRoot(macroScope ?? instance, root), localHook, root), require_utils.flattenChainMemo(root, appHook, chainResolver(root)), instance !== root ? composeRootHook(root, inheritedChain) : void 0, true);
-	if (hook && !require_compile_handler_descriptor.isEmptyPipelineHook(hook)) return;
+	const ownedHook = resolveLocalHook(localMacroRoot(macroScope ?? instance, root), localHook, root);
+	const resolve = chainResolver(root);
+	const flatAppHook = require_utils.flattenChainMemo(root, appHook, resolve);
+	let rootHook;
+	if (instance !== root) {
+		const locals = require_utils.flattenChain(require_generation.frozenRootOf(root)["~hookChain"], require_utils.isLocalScope, require_utils.rootSnapshot(inheritedChain), resolve);
+		const inherited = locals ? require_utils.flattenChainMemo(root, inheritedChain, resolve) : require_utils.flattenChainMemoReadonly(root, inheritedChain, resolve);
+		if (!inherited) rootHook = locals;
+		else if (!locals) rootHook = inherited;
+		else rootHook = require_utils.mergeHook(inherited, locals);
+		const after = afterUseHooks(inheritedChain, resolve);
+		if (after) rootHook = rootHook ? require_utils.mergeHook(after, rootHook) : after;
+	}
+	const hook = applyHook(ownedHook, flatAppHook, rootHook);
+	if (hook && !isEmptyPipelineHook(hook)) return;
+	if (require_handler_utils.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(require_utils.nullObject(), rootHeaders) : require_utils.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(require_utils.nullObject(), rootHeaders) : require_utils.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 = require_utils.cloneHook(localHook);
+		promoteDerive(localHook);
+	}
 	const flatAppHook = appHook ? require_utils.flattenChainMemo(root, appHook, resolve) : void 0;
-	let locals = instance !== root ? require_utils.flattenChain(require_generation.frozenRootOf(root)["~hookChain"], require_utils.isLocalScope, inheritedChain, resolve) : void 0;
+	let locals = instance !== root ? require_utils.flattenChain(require_generation.frozenRootOf(root)["~hookChain"], require_utils.isLocalScope, require_utils.rootSnapshot(inheritedChain), resolve) : void 0;
 	const instanceLocal = instance !== root ? require_utils.flattenChain(instance["~hookChain"], require_utils.isLocalScope) : void 0;
-	const compactPrefix = instance !== root && !require_compile_aot.Capture.isCapturing() && !require_compile_aot.Capture.isAotBuildEnv() && resolve === void 0 && require_utils.isCompactBeforeHandleOnly(localHook) && require_utils.isCompactBeforeHandleOnly(flatAppHook) && require_utils.isCompactBeforeHandleOnly(locals) && !instanceLocal?.error ? require_utils.compactBeforeHandlePrefix(inheritedChain) : void 0;
+	const compactPrefix = allowCompactPrefix && instance !== root && !require_compile_aot.Capture.isCapturing() && !require_compile_aot.Capture.isAotBuildEnv() && resolve === void 0 && require_utils.isCompactBeforeHandleOnly(localHook) && require_utils.isCompactBeforeHandleOnly(flatAppHook) && require_utils.isCompactBeforeHandleOnly(locals) && !instanceLocal?.error ? require_utils.compactBeforeHandlePrefix(inheritedChain) : void 0;
 	let present = collectHookOrigins(localHook, void 0);
 	present = collectHookOrigins(flatAppHook, present);
 	if (compactPrefix && !present?.size && !require_utils.compactBeforeHandleConflicts(localHook) && !require_utils.compactBeforeHandleConflicts(flatAppHook) && !require_utils.compactBeforeHandleConflicts(locals)) {
-		let hook = applyHook(localHook, flatAppHook, void 0, true);
+		let hook = applyHook(localHook, flatAppHook, void 0);
 		if (locals) hook = hook ? require_utils.mergeHook(hook, locals, false, true) : locals;
 		hook ??= require_utils.nullObject();
 		hook["~beforeHandlePrefix"] = compactPrefix;
 		return hook;
 	}
 	let inherited = instance !== root ? require_utils.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 ? require_utils.cloneHook(inherited) : void 0, true);
+	let hook = applyHook(localHook, flatAppHook, inherited ? require_utils.cloneHook(inherited) : void 0);
+	if (after) hook = hook ? require_utils.mergeHook(hook, after, false, true) : after;
 	if (locals) hook = hook ? require_utils.mergeHook(hook, locals, false, true) : locals;
 	if (instance !== root) {
 		const errors = instanceLocal?.error;
@@ -266,30 +277,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" || require_utils.compositionKeys.includes(k) ? at + "*" : "";
+}
+function routeShape(hook, handler, root) {
+	const frozenRoot = require_generation.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 require_compile_utils.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" && require_compile_handler_frozen_validator.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 && require_compile_handler_utils.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 ??= require_utils.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,
+		require_utils.isNotEmpty(frozenRoot["~ext"]?.headers),
+		!!(config?.adapter ?? require_adapter_constants.defaultAdapter).response.supportsDefaultHeaderSink,
+		!!require_handler_utils.returnedErrorClasses(hook, root)
+	]) + shape(config?.sanitize);
+	return unsupported ? void 0 : require_utils.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 = require_generation.frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
 	const method = _method;
 	const mountMeta = typeof handler === "function" ? handler["~mount"] : void 0;
-	if (mountMeta) handler = resolveMountHandler(mountMeta, path);
-	const reconstructed = require_compile_aot.Compiled.getHandler(frozenRoot["~programId"], method, path);
-	if (reconstructed && !precomputedStatic && typeof handler === "function" && !frozenRoot["~ext"]?.macro && !require_generation.frozenRootOf(localMacroRoot(macroScope ?? instance, root))["~ext"]?.macro && !reconstructNeedsHookState(reconstructed.a)) return reconstructed.f(handler, ...require_compile_handler_params.resolveHandlerParams(reconstructed.a, {
-		root,
-		parse: adapter.parse,
-		res: adapter.response,
-		hook: require_utils.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(require_utils.replaceUrlPath(c.request.url, c.path.slice(c.path.startsWith(encRoot) ? encLen : rawLen) || "/"), c.request));
+	}
+	const reconstructed = liveOnly ? void 0 : require_compile_aot.Compiled.getHandler(frozenRoot["~programId"], method, path);
+	if (!reconstructed) liveOnly ||= require_compile_aot.Compiled.hasProgram(frozenRoot["~programId"]);
+	const hook = composeRouteHook(instance, localHook, appHook, inheritedChain, root, macroScope, !reconstructed);
 	if (hook) {
 		promoteDerive(hook);
 		toArray("parse", hook);
@@ -300,20 +429,24 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		toArray("afterResponse", hook);
 		toArray("error", hook);
 	}
-	const buildValidator = () => hook ? require_compile_handler_reconstruct.Reconstrct.validator(hook, root, method, path) : void 0;
-	if (handler instanceof Error) {
+	const buildValidator = () => hook ? require_compile_handler_reconstruct.Reconstrct.validator(hook, root, method, path, liveOnly) : void 0;
+	const errorClasses = require_handler_utils.returnedErrorClasses(hook, root);
+	if (handler instanceof Error || typeof handler !== "function" && errorClasses?.some((C) => handler instanceof C)) {
 		const error = handler;
 		handler = () => {
 			throw error;
 		};
-	}
+	} else if (require_utils.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) && !(!require_universal_constants.isBun && handler instanceof require_universal_file.ElysiaFile)) {
+	if (!isHandleFunction && !(handler instanceof Promise) && !(!require_universal_constants.isBun && handler instanceof require_universal_file.ElysiaFile) && !declaresResponse) {
 		const rootHeaders = frozenRoot["~ext"]?.headers;
 		const set = { headers: rootHeaders ? Object.assign(require_utils.nullObject(), rootHeaders) : require_utils.nullObject() };
-		const mapped = adapter.response.map(handler, set);
-		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;
@@ -322,6 +455,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 || require_compile_aot.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(require_compile_aot.aotDrift(method, path), { cause });
+			}
+			require_compile_aot.warnAotDrift(method, path);
+			return live;
+		}
+	}
 	if (reconstructed) return reconstructed.f(handler, ...require_compile_handler_params.resolveHandlerParams(reconstructed.a, {
 		root,
 		parse: adapter.parse,
@@ -331,10 +478,19 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		cookieConfig: reconstructed.a.includes("cc") ? require_compile_handler_reconstruct.Reconstrct.cookie(hook, root) : void 0,
 		tracers: reconstructed.a.includes("tr") ? require_compile_handler_reconstruct.Reconstrct.trace(hook, root) : void 0
 	}));
-	if (hook === void 0 && isHandleFunction && !precomputedStatic && !mountMeta && (method === "GET" || method === "HEAD") && !root["~hasTrace"] && root["~introspect"] !== true && root["~config"]?.introspect !== true && !require_utils.isNotEmpty(frozenRoot["~ext"]?.headers) && !require_compile_aot.Capture.isAotBuildEnv() && !require_compile_aot.Capture.isCapturing() && isContextFreeHandler(handler)) return require_compile_handler_jit.createInlineHandler(adapter.response.compact ?? adapter.response.map, handler);
+	if (hook === void 0 && !errorClasses && isHandleFunction && !mountMeta && (method === "GET" || method === "HEAD") && !root["~hasTrace"] && root["~introspect"] !== true && root["~config"]?.introspect !== true && !require_utils.isNotEmpty(frozenRoot["~ext"]?.headers) && !require_compile_aot.Capture.isAotBuildEnv() && !require_compile_aot.Capture.isCapturing()) {
+		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 require_compile_handler_jit.createInlineHandler(compact, handler);
+		}
+	}
 	const state = require_compile_handler_descriptor.describeRoute({
 		method,
-		path,
 		handler,
 		root,
 		adapter,
@@ -356,7 +512,6 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		method,
 		path,
 		handler,
-		instance,
 		root: frozenRoot,
 		errorRoot: root,
 		hook,
@@ -364,16 +519,20 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		isHandleFunction,
 		isStaticResponse,
 		isPromiseHandler,
-		state
+		errorClasses,
+		state,
+		shape
 	});
 }
 
 //#endregion
 exports.buildNativeStaticResponse = buildNativeStaticResponse;
+exports.chainResolver = chainResolver;
 exports.clearHandlerAnalysisCaches = clearHandlerAnalysisCaches;
 exports.compileHandler = compileHandler;
 exports.composeRouteHook = composeRouteHook;
 exports.localMacroRoot = localMacroRoot;
 exports.resolveLocalHook = resolveLocalHook;
 exports.resolveWSLocalHook = resolveWSLocalHook;
+exports.routeShape = routeShape;
 exports.setCaptureHeaderShorthand = require_compile_handler_jit.setCaptureHeaderShorthand;