elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/compile/handler/index.js

@@ -1,113 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_universal_constants = require('../../universal/constants.js');
-const require_constants = require('../../constants.js');
 const require_utils = require('../../utils.js');
-const require_error = require('../../error.js');
-const require_cookie_config = require('../../cookie/config.js');
-const require_cookie_utils = require('../../cookie/utils.js');
-const require_adapter_utils = require('../../adapter/utils.js');
-const require_parse_query = require('../../parse-query.js');
-const require_sucrose = require('../../sucrose.js');
+const require_context = require('../../context.js');
 const require_compile_aot = require('../aot.js');
-const require_validator_route = require('../../validator/route.js');
-const require_compile_utils = require('../utils.js');
-const require_compile_handler_utils = require('./utils.js');
-const require_adapter_constants = require('../../adapter/constants.js');
-const require_handler_utils = require('../../handler/utils.js');
-const require_trace = require('../../trace.js');
 const require_compile_handler_params = require('./params.js');
+const require_compile_handler_jit = require('./jit.js');
+const require_compile_handler_reconstruct = require('./reconstruct.js');
+const require_adapter_constants = require('../../adapter/constants.js');
 
 //#region src/compile/handler/index.ts
-const parseFormData = "c.body=await pf(c)\n";
-const matchReturnIdentifier = /(?:=>|\breturn)\s+(?!(?:true|false|null|undefined|void|new|typeof|async|await|function|class)\b)[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*\s*(?![\w$([])/;
-const mayReturnIdentifier = (fn) => matchReturnIdentifier.test(fn.toString());
-let captureHeaderShorthand;
-const setCaptureHeaderShorthand = (value) => {
-	captureHeaderShorthand = value;
-};
-function builtinParser(adapter, parse, link) {
-	switch (parse) {
-		case "formdata":
-		case "multipart/form-data":
-			link(adapter.formData, "pf");
-			return parseFormData;
-		case "json":
-		case "application/json":
-			link(adapter.json, "pj");
-			return "c.body=await pj(c)\n";
-		case "urlencoded":
-		case "application/x-www-form-urlencoded":
-			link(adapter.urlencoded, "pu");
-			return "c.body=await pu(c)\n";
-		case "arrayBuffer":
-		case "application/octet-stream":
-			link(adapter.arrayBuffer, "pa");
-			return "c.body=await pa(c)\n";
-		case "text":
-		case "text/plain":
-			link(adapter.text, "pt");
-			return "c.body=await pt(c)\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];
-	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;
-	}
-	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)
-c.contentType=ct
-`;
-	let hasFn = false;
-	let hasType = false;
-	if (parsers) for (let i = 0; i < parsers.length; i++) {
-		const parser = parsers[i];
-		if (typeof parser === "function") {
-			hasFn = true;
-			link(0, "");
-			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 += "hasBody=c.body!==undefined\n";
-			if (child) code += child.end();
-			if (i) code += "}\n";
-		} else {
-			hasType = true;
-			const child = report?.resolveChild(parser);
-			if (i) code += "if(!hasBody){\n";
-			if (child) code += child.begin;
-			code += builtinParser(adapter, parser, link);
-			if (child) code += child.end();
-			if (i) code += "}\n";
-			break;
-		}
-	}
-	if (!hasType) {
-		const child = report?.resolveChild("default");
-		const begin = child ? child.begin : "";
-		const end = child ? child.end() : "";
-		const guard = bodyVali ? "ct" : "ct&&c.request.body";
-		code += hasFn ? `if(!hasBody&&${guard}){${begin}c.body=await pd(c,ct)\n${end}}\n` : `if(${guard}){${begin}c.body=await pd(c,ct)\n${end}}\n`;
-		link(adapter.default, "pd");
-	}
-	return hasFn ? "let hasBody=false,_bp\n" + code : code;
-}
-const isAsyncValidator = (vali) => vali?.isAsync ?? true;
-function applyHook(localHook, appHook, rootHook) {
+function applyHook(localHook, appHook, rootHook, appHookFresh = false) {
 	let hook;
 	if (localHook && appHook) hook = require_utils.mergeHook(require_utils.cloneHook(localHook), appHook, true);
 	else {
 		const base = localHook ?? appHook;
-		if (!rootHook) return base ? require_utils.cloneHook(base) : base;
-		hook = base ? require_utils.cloneHook(base) : require_utils.nullObject();
+		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();
 	}
 	if (rootHook) require_utils.mergeHook(hook, rootHook, true, true);
 	return hook;
@@ -135,11 +43,16 @@ function dropHooksByOrigin(hook, skip) {
 		const v = hook[key];
 		if (!v) continue;
 		if (Array.isArray(v)) {
-			const kept = v.filter((fn) => {
+			let kept;
+			for (let i = 0; i < v.length; i++) {
+				const fn = v[i];
 				const origin = require_utils.fnOrigin.get(fn);
-				return origin === void 0 || !skip.has(origin);
-			});
-			if (kept.length !== v.length) {
+				const keep = origin === void 0 || !skip.has(origin);
+				if (kept) {
+					if (keep) kept.push(fn);
+				} else if (!keep) kept = v.slice(0, i);
+			}
+			if (kept) {
 				if (out === hook) out = { ...hook };
 				out[key] = kept;
 			}
@@ -153,18 +66,21 @@ function dropHooksByOrigin(hook, skip) {
 	}
 	return out;
 }
-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));
-	return map(r, c.request);
-});
-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));
-	return map(r, c.set, c.request);
-});
+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;
@@ -196,17 +112,25 @@ function composeRootHook(root, inheritedChain) {
 	if (!locals) return inherited;
 	return require_utils.mergeHook(inherited, locals);
 }
-function buildNativeStaticResponse([, , handler, instance, localHook, appHook, inheritedChain], root) {
-	if (typeof handler === "function") return;
-	if (handler instanceof Error) return;
+function buildNativeStaticResponse([, , handler, instance, localHook, appHook, inheritedChain], root, hasMapResponse) {
+	if (typeof handler === "function" || handler instanceof Error) return;
 	const adapter = root["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
-	if (localHook) root["~applyMacro"](localHook);
-	resolveChainMacros(root, appHook);
-	if (inheritedChain) resolveChainMacros(root, inheritedChain);
-	const hook = applyHook(localHook, require_utils.flattenChainMemo(root, appHook), instance !== root ? composeRootHook(root, inheritedChain) : void 0);
-	const has = (v) => Array.isArray(v) ? v.length > 0 : !!v;
-	if (has(hook?.parse) || has(hook?.transform) || has(hook?.beforeHandle) || has(hook?.afterHandle) || has(hook?.mapResponse) || has(hook?.afterResponse) || has(hook?.trace)) return;
-	if (hook?.body || hook?.query || hook?.params || hook?.headers || hook?.cookie || (hook?.schemas)?.length) return;
+	if (hasMapResponse) {
+		if (localHook) root["~applyMacro"](localHook);
+		resolveChainMacros(root, appHook);
+		if (inheritedChain) resolveChainMacros(root, inheritedChain);
+		const hook = applyHook(localHook, require_utils.flattenChainMemo(root, appHook), instance !== root ? composeRootHook(root, inheritedChain) : void 0, true);
+		if (hook?.mapResponse) {
+			const context = new (require_context.createContext(root))(new Request("http://e.ly"));
+			context.responseValue = handler;
+			for (let i = 0; i < hook.mapResponse.length; i++) {
+				const fn = hook.mapResponse[i];
+				if (typeof fn !== "function") continue;
+				const mapped = fn(context);
+				if (mapped instanceof Response || mapped instanceof Promise) return mapped;
+			}
+		}
+	}
 	const rootHeaders = root["~ext"]?.headers;
 	const buildSet = () => ({ headers: rootHeaders ? Object.assign(require_utils.nullObject(), rootHeaders) : require_utils.nullObject() });
 	if (handler instanceof Promise) return handler.then((resolved) => {
@@ -216,22 +140,26 @@ function buildNativeStaticResponse([, , handler, instance, localHook, appHook, i
 	});
 	if (handler instanceof Response && !rootHeaders) return handler;
 	const mapped = adapter.response.map(handler, buildSet());
-	if (mapped instanceof Response) return mapped;
-	if (mapped instanceof Promise) return mapped;
+	if (mapped instanceof Response || mapped instanceof Promise) return mapped;
 }
 function toArray(name, hook) {
 	if (typeof hook[name] === "function") hook[name] = [hook[name]];
 }
 function composeRouteHook(instance, localHook, appHook, inheritedChain, root) {
 	const flatAppHook = appHook ? require_utils.flattenChainMemo(root, appHook) : void 0;
-	let rootHook = instance !== root ? composeRootHook(root, inheritedChain) : void 0;
-	if (rootHook && (flatAppHook || localHook)) {
+	let inherited = instance !== root ? require_utils.flattenChainMemo(root, inheritedChain) : void 0;
+	let locals = instance !== root ? require_utils.flattenChain(root["~hookChain"], require_utils.isLocalScope, inheritedChain) : void 0;
+	if ((inherited || locals) && (flatAppHook || localHook)) {
 		const present = /* @__PURE__ */ new Set();
 		collectHookOrigins(localHook, present);
 		collectHookOrigins(flatAppHook, present);
-		if (present.size) rootHook = dropHooksByOrigin(rootHook, present);
+		if (present.size) {
+			if (inherited) inherited = dropHooksByOrigin(inherited, present);
+			if (locals) locals = dropHooksByOrigin(locals, present);
+		}
 	}
-	let hook = applyHook(localHook, flatAppHook, rootHook);
+	let hook = applyHook(localHook, flatAppHook, inherited, true);
+	if (locals) hook = hook ? require_utils.mergeHook(hook, locals, false, true) : locals;
 	if (instance !== root) {
 		const errors = require_utils.flattenChain(instance["~hookChain"], require_utils.isLocalScope)?.error;
 		if (errors) {
@@ -249,6 +177,16 @@ function composeRouteHook(instance, localHook, appHook, inheritedChain, root) {
 }
 function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain], root, precomputedStatic) {
 	const adapter = root["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
+	const method = require_utils.mapMethodBack(_method);
+	const reconstructed = require_compile_aot.Compiled.handlers?.[method]?.[path];
+	if (reconstructed && !precomputedStatic && typeof handler === "function" && !root["~ext"]?.macro && !reconstructNeedsHookState(reconstructed.a)) return reconstructed.f(handler, ...require_compile_handler_params.resolveHandlerParams(reconstructed.a, {
+		parse: adapter.parse,
+		res: adapter.response,
+		hook: require_utils.nullObject(),
+		vali: void 0,
+		cookieConfig: void 0,
+		tracers: void 0
+	}));
 	if (root["~ext"]?.macro) {
 		if (localHook) root["~applyMacro"](localHook);
 		if (appHook) resolveChainMacros(root, appHook);
@@ -265,17 +203,7 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		toArray("afterResponse", hook);
 		toArray("error", hook);
 	}
-	const method = require_utils.mapMethodBack(_method);
-	const vali = hook ? new require_validator_route.RouteValidator(hook, {
-		models: root["~ext"]?.models,
-		normalize: root["~config"]?.normalize,
-		sanitize: root["~config"]?.sanitize,
-		schemas: hook?.schemas,
-		aot: {
-			method,
-			path
-		}
-	}) : void 0;
+	const buildValidator = () => hook ? require_compile_handler_reconstruct.Reconstrct.validator(hook, root, method, path) : void 0;
 	if (handler instanceof Error) {
 		const error = handler;
 		handler = () => {
@@ -297,330 +225,31 @@ 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);
 	}
-	const reconstructed = require_compile_aot.Compiled.handlers?.[method]?.[path];
 	if (reconstructed) return reconstructed.f(handler, ...require_compile_handler_params.resolveHandlerParams(reconstructed.a, {
 		parse: adapter.parse,
 		res: adapter.response,
 		hook: hook ?? require_utils.nullObject(),
-		vali,
-		cookieConfig: reconstructed.a.includes("cc") ? require_cookie_config.compileCookieConfig(hook?.cookie, root["~config"]?.cookie) : void 0,
-		tracers: reconstructed.a.includes("tr") ? (hook?.trace)?.map((fn) => require_trace.createTracer(fn)) : void 0
+		vali: reconstructed.a.includes("va") ? buildValidator() : void 0,
+		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) : void 0
 	}));
-	const inference = require_sucrose.sucrose(handler, hook);
-	const params = /* @__PURE__ */ new Set();
-	let alias = "";
-	function link(v, key) {
-		if (v === 0) {
-			if (!params.has(hook)) {
-				params.add(hook);
-				alias += `${alias ? "," : ""}ho`;
-			}
-			return;
-		}
-		if (!params.has(v)) {
-			params.add(v);
-			alias += `${alias ? "," : ""}${key}`;
-		}
-	}
-	if (hook && typeof hook.parse === "function") hook.parse = [hook.parse];
-	const parseLength = Array.isArray(hook?.parse) ? hook.parse.length : 0;
-	const parseFirst = Array.isArray(hook?.parse) ? hook.parse[0] : hook?.parse;
-	const hasStandaloneBody = !!hook?.schemas?.some((s) => s?.body);
-	const bodylessMethod = method === "GET" || method === "HEAD";
-	const hasBody = !!hook?.body || hasStandaloneBody || !bodylessMethod && (parseLength > 0 || inference.body) && parseFirst !== "none";
-	const bodyValiIsAsync = hasBody && isAsyncValidator(vali?.body);
-	const headersValiIsAsync = vali?.headers && isAsyncValidator(vali?.headers);
-	const paramsValiIsAsync = vali?.params && isAsyncValidator(vali?.params);
-	const queryValiIsAsync = vali?.query && isAsyncValidator(vali?.query);
-	const cookieValidIsAsync = vali?.cookie && isAsyncValidator(vali?.cookie);
-	const appCookieConfig = root["~config"]?.cookie;
-	const needsCookie = !!vali?.cookie || !!inference.cookie;
-	const cookieConfig = needsCookie ? require_cookie_config.compileCookieConfig(hook?.cookie, appCookieConfig) : void 0;
-	const hasCookieSign = !!cookieConfig?.hasSign;
-	const hasErrorHook = !!hook?.error?.length;
-	const hasAfterResponse = !!hook?.afterResponse?.length;
-	const hasBeforeHandle = !!hook?.beforeHandle?.length;
-	const hasAfterHandle = !!hook?.afterHandle?.length;
-	const hasMapResponse = !!hook?.mapResponse?.length;
-	const hasResponseValidator = !!vali?.response;
-	const traceHandlers = hook?.trace ?? void 0;
-	const hasTrace = !!traceHandlers?.length;
-	const traceCount = hasTrace ? traceHandlers.length : 0;
-	const beginTrace = (phase, total) => {
-		if (!hasTrace) return "";
-		let s = "";
-		for (let i = 0; i < traceCount; i++) s += `rp${i}=tr${i}.${phase}({id:c.rid,event:'${phase}',name:'${phase}',begin:performance.now(),total:${total}})\n`;
-		return s;
-	};
-	const endTrace = (errBinding) => {
-		if (!hasTrace) return "";
-		let s = "";
-		for (let i = 0; i < traceCount; i++) s += `rp${i}.resolve(${errBinding ?? ""})\n`;
-		return s;
-	};
-	const buildReport = (phase) => {
-		if (!hasTrace) 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`;
-			return {
-				begin,
-				end(errBinding) {
-					let close = "";
-					for (let i = 0; i < traceCount; i++) if (errBinding) close += `if(${errBinding} instanceof Error){rpc${i}?.(${errBinding})}else{rpc${i}?.()}\n`;
-					else close += `rpc${i}?.()\n`;
-					return close;
-				}
-			};
-		} };
-	};
-	const responseValiAsync = !!(vali?.response && Object.values(vali.response).find(isAsyncValidator));
-	const handlerIsAsync = isHandleFunction && require_compile_utils.isAsyncFunction(handler);
-	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator);
-	const responseValiForcesAsync = hasResponseValidator && isHandleFunction && !handlerIsAsync && (require_compile_utils.mayReturnPromise(handler) || mayReturnIdentifier(handler));
-	const afterResponseForcesAsync = hasAfterResponse && (require_compile_utils.isAsyncLifecycle(hook?.afterResponse) || hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
-	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || responseValiForcesAsync || afterResponseForcesAsync || hasTrace || hasCookieSign || responseValiAsync || hook && (!!require_compile_utils.isAsyncLifecycle(hook?.afterHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.beforeHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.transform) || !!require_compile_utils.isAsyncLifecycle(hook?.mapResponse) || !!require_compile_utils.isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
-	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
-	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
-	const syncAfterResponse = hasAfterResponse && !isAsync && !hasTrace && !hasErrorHook;
-	const callHandler = isHandleFunction ? callHandlerSyncOnAsync ? `_r=h(c)\nif(_r instanceof Promise)_r=await _r\n` : `_r=${isAsync ? "await " : ""}h(c)\n` : isStaticResponse ? `_r=h.clone()\n` : isPromiseHandler ? `_r=h.then(cr)\n` : `_r=h\n`;
-	let code = `${isAsync ? "async " : ""}function route(c){\n`;
-	if ((hasAfterResponse || hasTrace) && !syncAfterResponse) code += "let _stl\n";
-	if (hasCookieSign) code += "let _sg\n";
-	if (hasTrace) {
-		link(traceHandlers.map((fn) => require_trace.createTracer(fn)), "tr");
-		link(require_utils.requestId, "rid");
-		code += `c.rid??=rid()\n`;
-		for (let i = 0; i < traceCount; i++) code += `let rp${i},rpc${i},_hr${i};\n`;
-		code += `c.trace??=[`;
-		for (let i = 0; i < traceCount; i++) code += (i ? "," : "") + `tr[${i}](c)`;
-		code += `]\n`;
-		for (let i = 0; i < traceCount; i++) code += `const tr${i}=c.trace[${i}]\n`;
-		code += `let _trs\n`;
-	}
-	let inlineUnsafe = false;
-	if ((hasTrace || inference.route) && require_constants.isDynamicRegex.test(path)) {
-		code += `c.route=${JSON.stringify(path)}\n`;
-		inlineUnsafe = true;
-	}
-	const head = code;
-	code = "";
-	if (hasErrorHook || hasTrace) code += "try{\n";
-	const hasHeaders = inference.headers || !!vali?.headers;
-	if (inference.query || vali?.query) {
-		const parseArgs = require_compile_handler_utils.getQueryParseArgs((vali?.query)?.schema);
-		code += `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`;
-		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"));
-		link(require_error.ParseError, "pe");
-		code += "try{\n" + parseCode + "}catch(e){throw new pe(e)}\n";
-		if (hasTrace) code += endTrace();
-	} else if (hasTrace) code += beginTrace("parse", 0) + endTrace();
-	if (hook?.transform?.length || hasTrace) {
-		const transformLen = hook?.transform?.length ?? 0;
-		code += beginTrace("transform", transformLen);
-		if (transformLen) {
-			link(hook.transform, "tf");
-			code += require_compile_handler_utils.mapTransform(hook.transform, [buildReport("transform")]);
-		}
-		code += endTrace();
-	}
-	if (vali?.body) {
-		link(vali, "va");
-		code += `c.body=${bodyValiIsAsync ? "await " : ""}va.body.From(c.body,'body')\n`;
-	}
-	if (vali?.headers) {
-		link(vali, "va");
-		code += `c.headers=${headersValiIsAsync ? "await " : ""}va.headers.From(c.headers,'headers')\n`;
-	}
-	if (vali?.params) {
-		link(vali, "va");
-		code += `c.params=${paramsValiIsAsync ? "await " : ""}va.params.From(c.params,'params')\n`;
-	}
-	if (vali?.query) {
-		link(vali, "va");
-		code += `c.query=${queryValiIsAsync ? "await " : ""}va.query.From(c.query,'query')\n`;
-	}
-	if (cookieConfig) {
-		link(require_cookie_utils.buildCookieJar, "bcj");
-		link(cookieConfig, "cc");
-		if (!hasCookieSign && !cookieValidIsAsync) {
-			link(require_cookie_utils.parseCookieRawSync, "pcrs");
-			code += `let _ck=pcrs(c.request.headers.get('cookie'),cc)\n`;
-		} else {
-			link(require_cookie_utils.parseCookieRaw, "pcr");
-			code += `let _ck=await pcr(c.request.headers.get('cookie'),cc)\n`;
-		}
-		if (vali?.cookie) {
-			link(vali, "va");
-			const cookieIsOptional = !!(hook?.cookie)?.["~optional"];
-			const validateExpr = `_ck=${cookieValidIsAsync ? "await " : ""}va.cookie.From(_ck,'cookie')\n`;
-			if (cookieIsOptional) code += `if(Object.keys(_ck).length){${validateExpr}}\n`;
-			else code += validateExpr;
-		}
-		code += `c.cookie=bcj(c.set,_ck,cc)\n`;
-	}
-	const hasSet = inference.cookie || inference.set || !!root["~ext"]?.["headers"] || needsCookie || hasAfterResponse || hasErrorHook || hasResponseValidator || hasTrace;
-	const res = adapter.response;
-	const map = hasSet ? link(res.map, "rm") ?? "rm" : link(res.compact ?? res.map, "rc") ?? "rc";
-	if (isPromiseHandler) link(require_compile_handler_utils.cloneResponse, "cr");
-	const handleInstruction = isHandleFunction ? "h(c)" : isStaticResponse ? "h.clone()" : isPromiseHandler ? "h.then(cr)" : "h";
-	const mapReturn = hasSet ? `rm(${handleInstruction},c.set,c.request)\n` : `rc(${handleInstruction},c.request)\n`;
-	if (hasAfterResponse) link(hook.afterResponse, "ar");
-	const drainTraceStream = hasTrace ? `let _ser\nif(_trs){try{for await(const v of _trs){}}catch(_te){_ser=_te}}\n` : "";
-	const resolveHandlePostDrain = hasTrace ? (() => {
-		let s = "";
-		for (let i = 0; i < traceCount; i++) s += `_hr${i}?.resolve(_ser)\n`;
-		return s;
-	})() : "";
-	const setImmediateFn = require_compile_aot.Capture.isCapturing() ? ";(typeof setImmediate==='function'?setImmediate:(f)=>Promise.resolve().then(f))" : typeof setImmediate === "function" ? "setImmediate" : "Promise.resolve().then";
-	const scheduleAfterResponse = hasAfterResponse || hasTrace ? `c._arf=true\n${setImmediateFn}(async()=>{if(_stl)for await(const v of _stl){}\n` + drainTraceStream + resolveHandlePostDrain + beginTrace("afterResponse", hook?.afterResponse?.length ?? 0) + (hasAfterResponse ? require_compile_handler_utils.mapAfterResponse(hook.afterResponse, [buildReport("afterResponse")]) : "") + endTrace() + `})\n` : "";
-	const dedupSchedule = !!scheduleAfterResponse && (hasErrorHook || hasTrace) && !syncAfterResponse && !syncErrorHook;
-	const scheduleDecl = dedupSchedule ? `function _sc(){\n${scheduleAfterResponse}}\n` : "";
-	const schedule = dedupSchedule ? `_sc()\n` : scheduleAfterResponse;
-	const signPrefix = hasCookieSign ? `_sg=scv(c.set.cookie,cc)\nif(_sg)await _sg\n` : "";
-	if (hasCookieSign) link(require_cookie_utils.signCookieValues, "scv");
-	let factoryHelpers = "";
-	if (hasBeforeHandle || hasAfterHandle || hasMapResponse || hasAfterResponse || hasResponseValidator || hasCookieSign || hasTrace) {
-		code += `let _r,tmp\n`;
-		if (hasBeforeHandle || hasTrace) {
-			const bfLen = hook?.beforeHandle?.length ?? 0;
-			code += beginTrace("beforeHandle", bfLen);
-			if (hasBeforeHandle) {
-				link(hook.beforeHandle, "bf");
-				const rootDerive = root["~derive"];
-				const instanceDerive = instance?.["~derive"];
-				const deriveSet = rootDerive && instanceDerive ? { has: (fn) => rootDerive.has(fn) || instanceDerive.has(fn) } : rootDerive ?? instanceDerive;
-				code += require_compile_handler_utils.mapBeforeHandle(hook.beforeHandle, deriveSet, link, buildReport("beforeHandle"));
-			}
-			code += endTrace();
-		}
-		if (hasAfterResponse || hasTrace) link(require_adapter_utils.tee, "tee");
-		const teeConsumers = (hasAfterResponse ? 1 : 0) + (hasTrace ? 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=await tee(_r,${teeCount})\n_r=_s[0]\n` + (hasAfterResponse ? `_stl=_s[1]\n` : "") + (hasTrace ? `_trs=_s[${1 + (hasAfterResponse ? 1 : 0)}]\n` : "") + `}\n` : "";
-		if (hasTrace) {
-			const handleName = handler?.name && typeof handler.name === "string" ? handler.name : "anonymous";
-			code += beginTrace("handle", 1);
-			const handleChild = buildReport("handle").resolveChild(handleName);
-			code += handleChild.begin;
-			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();
-			code += `}\n`;
-		} else if (hasBeforeHandle) code += `if(_r===undefined){\n${callHandler}${teeBlock}}\n`;
-		else code += callHandler + teeBlock;
-		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'){
-return tee(_r,${teeCount}).then((_s)=>_fin2(c,_s[0],_s[1]))\n}\nreturn _fin2(c,_r,undefined)\n}\nfunction _fin2(c,_r,_stl){\nc.responseValue=_r\n` + scheduleAfterResponse + `return ${hasSet ? `${map}(_r,c.set,c.request)` : `${map}(_r,c.request)`}\n}\n`;
-			code += "if(_r instanceof Promise)return _r.then(fe).then((_v)=>_fin(c,_v))\nreturn _fin(c,_r)\n";
-		} else {
-			code += `if(_r instanceof Error)throw _r\n`;
-			if (!isAsync) {
-				link(require_handler_utils.forwardError, "fe");
-				code += `else if(_r instanceof Promise)_r=_r.then(fe)\n`;
-			}
-			if (hasAfterHandle || hasMapResponse || hasAfterResponse || hasTrace) code += `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, buildReport("afterHandle"));
-				}
-				code += endTrace();
-			}
-			if (hasMapResponse || hasTrace) {
-				const mrLen = hook?.mapResponse?.length ?? 0;
-				code += beginTrace("mapResponse", mrLen);
-				if (hasMapResponse) {
-					link(hook.mapResponse, "mr");
-					code += require_compile_handler_utils.mapMapResponse(hook.mapResponse, buildReport("mapResponse"));
-				}
-				code += endTrace();
-			}
-			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}_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}_vr.EncodeFrom(_r,'response')\n}\n`;
-			}
-			code += schedule;
-			code += signPrefix;
-			const finalMap = hasSet ? `${map}(_r,c.set,c.request)` : `${map}(_r,c.request)`;
-			if (syncErrorHook) code += `if(_r instanceof Promise)return ${finalMap}.catch((_e)=>_ce(_e,c))\n`;
-			code += `return ${finalMap}\n`;
-		}
-	} else if (isHandleFunction) {
-		if (!isAsync) link(require_handler_utils.forwardError, "fe");
-		const mapArgs = hasSet ? "c.set,c.request" : "c.request";
-		code += (callHandlerSyncOnAsync ? `let _r=h(c)\nif(_r instanceof Promise)_r=await _r\n` : `let _r=${isAsync ? "await " : ""}h(c)\n`) + `if(_r instanceof Error)throw _r\n` + (isAsync ? `return ${map}(_r,${mapArgs})\n` : syncErrorHook ? `if(_r instanceof Promise)return ${map}(_r.then(fe),${mapArgs}).catch((_e)=>_ce(_e,c))\nreturn ${map}(_r,${mapArgs})\n` : `if(_r instanceof Promise)_r=_r.then(fe)\nreturn ${map}(_r,${mapArgs})\n`);
-	} else code += `return ${mapReturn}`;
-	if (hasErrorHook || hasTrace) {
-		let body = "";
-		if (hasTrace) {
-			for (let i = 0; i < traceCount; i++) body += `rp${i}?.resolve(e);rpc${i}?.(e)\n`;
-			body += beginTrace("error", hook?.error?.length ?? 0);
-		}
-		if (hasErrorHook) {
-			link(hook.error, "er");
-			link(require_error.ElysiaStatus, "es");
-			const allowUnsafeDetail = !!root["~config"]?.allowUnsafeValidationDetails;
-			if (allowUnsafeDetail) link(require_error.ValidationError, "verr");
-			body += `c.error=e\n` + (allowUnsafeDetail ? `if(e instanceof verr)e.allowUnsafeValidationDetails=true\n` : ``) + `if(e?.status)c.set.status=e.status
-else if(c.set.status===undefined||c.set.status===200)c.set.status=500
-let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapError(hook.error, [
-				map,
-				link,
-				res.map,
-				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapMapResponse(hook.mapResponse, void 0) : "") + endTrace() + schedule,
-				signPrefix
-			]) + endTrace() + schedule + `if(typeof e?.toResponse==='function'){const _er=e.toResponse();if(_er instanceof Response){${signPrefix}return ${map}(_er,c.set,c.request)}}\nif(e instanceof es){${signPrefix}return ${map}(e,c.set,c.request)}\nif(e?.status){${signPrefix}return ${map}(e?.response??e?.message??'',c.set,c.request)}\nc.set.status=500\n` + signPrefix + `return ${map}(e?.message!=null?e.message:'Internal Server Error',c.set,c.request)\n`;
-		} else {
-			body += endTrace() + schedule;
-			body += `throw e\n`;
-		}
-		if (syncErrorHook) {
-			factoryHelpers += `function _ce(e,c){\n${body}}\n`;
-			code += `}catch(e){return _ce(e,c)}\n`;
-		} else code += `}catch(e){\n${body}}\n`;
-	}
-	code += "}";
-	code = head + scheduleDecl + code;
-	if (factoryHelpers) code = `(function(){\n${factoryHelpers}return ${code}})()`;
-	if (!hasTrace && isHandleFunction && !inlineUnsafe) {
-		if (alias === "rc" || !isAsync && !syncErrorHook && alias === "rc,fe") return createInlineHandler(res.compact ?? res.map, handler);
-		else if (alias === "rm" || !isAsync && !syncErrorHook && alias === "rm,fe") return createInlineHandlerWithSet(res.map, handler);
-	}
-	if (!precomputedStatic) require_compile_aot.Capture.handler({
+	return require_compile_handler_jit.compileHandlerJit({
 		method,
 		path,
-		alias,
-		code
+		handler,
+		instance,
+		root,
+		hook,
+		adapter,
+		buildValidator,
+		isHandleFunction,
+		isStaticResponse,
+		isPromiseHandler
 	});
-	return new Function("h", alias, `return ${code}`)(handler, ...params);
 }
 
 //#endregion
 exports.buildNativeStaticResponse = buildNativeStaticResponse;
 exports.compileHandler = compileHandler;
 exports.composeRouteHook = composeRouteHook;
-exports.setCaptureHeaderShorthand = setCaptureHeaderShorthand;
+exports.setCaptureHeaderShorthand = require_compile_handler_jit.setCaptureHeaderShorthand;