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

package/dist/compile/handler/jit.js

@@ -0,0 +1,445 @@
+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_adapter_utils = require('../../adapter/utils.js');
+const require_error = require('../../error.js');
+const require_parse_query = require('../../parse-query.js');
+const require_sucrose = require('../../sucrose.js');
+const require_compile_aot = require('../aot.js');
+const require_compile_utils = require('../utils.js');
+const require_compile_handler_utils = require('./utils.js');
+const require_cookie_config = require('../../cookie/config.js');
+const require_cookie_utils = require('../../cookie/utils.js');
+const require_handler_utils = require('../../handler/utils.js');
+const require_trace = require('../../trace.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 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 hasFn = false;
+	let hasType = false;
+	if (parsers) {
+		for (let i = 0; i < parsers.length; i++) if (typeof parsers[i] === "function") {
+			hasFn = true;
+			break;
+		}
+	}
+	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, "");
+			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&&hb(c.request)";
+		code += hasFn ? `if(!hasBody&&${guard}){${begin}c.body=ct.charCodeAt(12)===106?await pj(c):await pd(c,ct)\n${end}}\n` : `if(${guard}){${begin}c.body=ct.charCodeAt(12)===106?await pj(c):await pd(c,ct)\n${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 isAsyncValidator = (vali) => vali?.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));
+	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 compileHandlerJit({ method, path, handler, instance, root, hook, adapter, buildValidator, isHandleFunction, isStaticResponse, isPromiseHandler }) {
+	const vali = buildValidator();
+	require_compile_jit_probe.JITProbe.record("sucrose");
+	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;
+				}
+			};
+		} };
+	};
+	let responseValiAsync = false;
+	if (vali?.response) {
+		for (const code in vali.response) if (isAsyncValidator(vali.response[code])) {
+			responseValiAsync = true;
+			break;
+		}
+	}
+	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}})()`;
+	require_compile_aot.Capture.handler({
+		method,
+		path,
+		alias,
+		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);
+	}
+	require_compile_jit_probe.JITProbe.record("handler:new-function");
+	return new Function("h", alias, `return ${code}`)(handler, ...params);
+}
+
+//#endregion
+exports.compileHandlerJit = compileHandlerJit;
+exports.setCaptureHeaderShorthand = setCaptureHeaderShorthand;