elysia 2.0.0-exp.43 → 2.0.0-exp.45

package/dist/base.d.ts

@@ -849,7 +849,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    * on the config and triggers a fresh build of the fetch handler).
    */
   compile(): this;
-  handler(index: number, immediate?: boolean | undefined, route?: InternalRoute, precomputedStatic?: Response, aliases?: StaticMapAliases): CompiledHandler;
+  handler(index: number, immediate?: boolean | undefined, route?: InternalRoute, precomputedStatic?: Response, aliases?: StaticMapAliases, table?: RouteTable): CompiledHandler;
   ['~newGeneration'](): this;
   get fetch(): (request: Request, ...rest: any[]) => MaybePromise<Response>;
   get handle(): (url: string | Request, options?: RequestInit) => Promise<Response>;

package/dist/base.js

@@ -1119,30 +1119,32 @@ var Elysia = class Elysia {
 		this.fetch;
 		return this;
 	}
-	handler(index, immediate = this["~config"]?.precompile, route = this["~routes"][index], precomputedStatic, aliases) {
+	handler(index, immediate = this["~config"]?.precompile, route, precomputedStatic, aliases, table) {
 		if (this.#compiled?.[index]) return this.#compiled[index];
 		const compiled = this.#compiled ??= new Array(this["~routes"].length);
 		if (immediate) {
+			const row = route ?? this["~routes"][index];
 			let handler;
 			try {
-				handler = require_compile_handler_index.compileHandler(route, this, precomputedStatic);
+				handler = require_compile_handler_index.compileHandler(row, this, precomputedStatic);
 			} catch (error) {
-				throw new Error(`[Elysia] Failed to compile route ${route[0]} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+				throw new Error(`[Elysia] Failed to compile route ${row[0]} ${row[1]}: ${error?.message ?? error}`, { cause: error });
 			}
 			compiled[index] = handler;
-			this.#saveHandler(route[0], route[1], handler);
+			this.#saveHandler(row[0], row[1], handler);
 			return handler;
 		}
-		return this.#jitHandler(index, route, precomputedStatic, aliases);
+		return this.#jitHandler(index, route ?? (table ? void 0 : this["~routes"][index]), precomputedStatic, aliases, table);
 	}
-	#jitHandler(index, route, precomputedStatic, aliases) {
+	#jitHandler(index, route, precomputedStatic, aliases, table) {
 		return (context) => {
 			if (this.#compiled[index]) return this.#compiled[index](context);
+			const materialized = route ?? require_route_table.routeRow(table, index);
 			let handler;
 			try {
-				handler = require_compile_handler_index.compileHandler(route, this, precomputedStatic);
+				handler = require_compile_handler_index.compileHandler(materialized, this, precomputedStatic);
 			} catch (error) {
-				const routeError = new Error(`[Elysia] Failed to compile route ${route[0]} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+				const routeError = new Error(`[Elysia] Failed to compile route ${materialized[0]} ${materialized[1]}: ${error?.message ?? error}`, { cause: error });
 				const finalize = this["~finalizeError"];
 				if (finalize) return finalize(context, routeError);
 				throw routeError;
@@ -1152,7 +1154,7 @@ var Elysia = class Elysia {
 				this.#initMap();
 				const map = this["~map"][aliases.method] ??= require_utils.nullObject();
 				for (let p = 0; p < aliases.paths.length; p++) map[aliases.paths[p]] = handler;
-			} else this.#saveHandler(route[0], route[1], handler);
+			} else this.#saveHandler(materialized[0], materialized[1], handler);
 			return handler(context);
 		};
 	}
@@ -1221,11 +1223,13 @@ var Elysia = class Elysia {
 		}
 		return memo.get(start);
 	}
-	#routeMayHaveModelRef(route) {
+	#routeMayHaveModelRef(table, i) {
 		if (this["~ext"]?.macro || this["~scopeChildren"]) return true;
-		if (require_compile_handler_index.localMacroRoot(route[7] ?? route[3] ?? this, this)["~ext"]?.macro) return true;
-		if (Elysia.#hookHasString(route[4])) return true;
-		return this.#chainHasModelRef(route[5]) || this.#chainHasModelRef(route[6]) || this.#chainHasModelRef(this["~hookChain"]);
+		const macroScope = table.macroScope.get(i);
+		const owner = table.owner[i];
+		if (require_compile_handler_index.localMacroRoot(macroScope ?? owner ?? this, this)["~ext"]?.macro) return true;
+		if (Elysia.#hookHasString(table.localHook[i])) return true;
+		return this.#chainHasModelRef(table.appHook[i]) || this.#chainHasModelRef(table.inheritedChain[i]) || this.#chainHasModelRef(this["~hookChain"]);
 	}
 	#assertRouteModelRefs(route, method) {
 		const models = this["~ext"]?.models;
@@ -1335,10 +1339,7 @@ var Elysia = class Elysia {
 		const path = table.path;
 		const flags = table.flags;
 		const length = table.length;
-		for (let i = 0; i < length; i++) {
-			const row = require_route_table.routeRow(table, i);
-			if (this.#routeMayHaveModelRef(row)) this.#assertRouteModelRefs(row, method[i]);
-		}
+		for (let i = 0; i < length; i++) if (this.#routeMayHaveModelRef(table, i)) this.#assertRouteModelRefs(require_route_table.routeRow(table, i), method[i]);
 		if (length) require_compile_aot.Compiled.claim(this["~programId"], this["~aotFingerprint"] = require_compile_aot.createAotFingerprint());
 		const isLoose = this["~config"]?.strictPath !== true;
 		let hasLooseCandidate = false;
@@ -1401,7 +1402,7 @@ var Elysia = class Elysia {
 			const explicitMain = registerLoose ? explicitPaths?.get(routeMethod) : void 0;
 			if (!isDynamic && !needsEncode && !registerLoose) {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
-				map[routePath] = this.handler(i, precompile, require_route_table.routeRow(table, i), void 0);
+				map[routePath] = this.handler(i, precompile, void 0, void 0, void 0, table);
 				continue;
 			}
 			const variants = [routePath];
@@ -1420,14 +1421,14 @@ var Elysia = class Elysia {
 			}
 			if (isDynamic) {
 				const router = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
-				const handler = this.handler(i, precompile, require_route_table.routeRow(table, i), void 0);
+				const handler = this.handler(i, precompile, void 0, void 0, void 0, table);
 				for (let p = 0; p < paths.length; p++) router.add(routeMethod, paths[p], handler);
 			} else {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
-				const handler = this.handler(i, precompile, require_route_table.routeRow(table, i), void 0, {
+				const handler = this.handler(i, precompile, void 0, void 0, {
 					method: routeMethod,
 					paths
-				});
+				}, table);
 				for (let p = 0; p < paths.length; p++) map[paths[p]] = handler;
 			}
 		}

package/dist/base.mjs

@@ -1116,30 +1116,32 @@ var Elysia = class Elysia {
 		this.fetch;
 		return this;
 	}
-	handler(index, immediate = this["~config"]?.precompile, route = this["~routes"][index], precomputedStatic, aliases) {
+	handler(index, immediate = this["~config"]?.precompile, route, precomputedStatic, aliases, table) {
 		if (this.#compiled?.[index]) return this.#compiled[index];
 		const compiled = this.#compiled ??= new Array(this["~routes"].length);
 		if (immediate) {
+			const row = route ?? this["~routes"][index];
 			let handler;
 			try {
-				handler = compileHandler(route, this, precomputedStatic);
+				handler = compileHandler(row, this, precomputedStatic);
 			} catch (error) {
-				throw new Error(`[Elysia] Failed to compile route ${route[0]} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+				throw new Error(`[Elysia] Failed to compile route ${row[0]} ${row[1]}: ${error?.message ?? error}`, { cause: error });
 			}
 			compiled[index] = handler;
-			this.#saveHandler(route[0], route[1], handler);
+			this.#saveHandler(row[0], row[1], handler);
 			return handler;
 		}
-		return this.#jitHandler(index, route, precomputedStatic, aliases);
+		return this.#jitHandler(index, route ?? (table ? void 0 : this["~routes"][index]), precomputedStatic, aliases, table);
 	}
-	#jitHandler(index, route, precomputedStatic, aliases) {
+	#jitHandler(index, route, precomputedStatic, aliases, table) {
 		return (context) => {
 			if (this.#compiled[index]) return this.#compiled[index](context);
+			const materialized = route ?? routeRow(table, index);
 			let handler;
 			try {
-				handler = compileHandler(route, this, precomputedStatic);
+				handler = compileHandler(materialized, this, precomputedStatic);
 			} catch (error) {
-				const routeError = new Error(`[Elysia] Failed to compile route ${route[0]} ${route[1]}: ${error?.message ?? error}`, { cause: error });
+				const routeError = new Error(`[Elysia] Failed to compile route ${materialized[0]} ${materialized[1]}: ${error?.message ?? error}`, { cause: error });
 				const finalize = this["~finalizeError"];
 				if (finalize) return finalize(context, routeError);
 				throw routeError;
@@ -1149,7 +1151,7 @@ var Elysia = class Elysia {
 				this.#initMap();
 				const map = this["~map"][aliases.method] ??= nullObject();
 				for (let p = 0; p < aliases.paths.length; p++) map[aliases.paths[p]] = handler;
-			} else this.#saveHandler(route[0], route[1], handler);
+			} else this.#saveHandler(materialized[0], materialized[1], handler);
 			return handler(context);
 		};
 	}
@@ -1218,11 +1220,13 @@ var Elysia = class Elysia {
 		}
 		return memo.get(start);
 	}
-	#routeMayHaveModelRef(route) {
+	#routeMayHaveModelRef(table, i) {
 		if (this["~ext"]?.macro || this["~scopeChildren"]) return true;
-		if (localMacroRoot(route[7] ?? route[3] ?? this, this)["~ext"]?.macro) return true;
-		if (Elysia.#hookHasString(route[4])) return true;
-		return this.#chainHasModelRef(route[5]) || this.#chainHasModelRef(route[6]) || this.#chainHasModelRef(this["~hookChain"]);
+		const macroScope = table.macroScope.get(i);
+		const owner = table.owner[i];
+		if (localMacroRoot(macroScope ?? owner ?? this, this)["~ext"]?.macro) return true;
+		if (Elysia.#hookHasString(table.localHook[i])) return true;
+		return this.#chainHasModelRef(table.appHook[i]) || this.#chainHasModelRef(table.inheritedChain[i]) || this.#chainHasModelRef(this["~hookChain"]);
 	}
 	#assertRouteModelRefs(route, method) {
 		const models = this["~ext"]?.models;
@@ -1332,10 +1336,7 @@ var Elysia = class Elysia {
 		const path = table.path;
 		const flags = table.flags;
 		const length = table.length;
-		for (let i = 0; i < length; i++) {
-			const row = routeRow(table, i);
-			if (this.#routeMayHaveModelRef(row)) this.#assertRouteModelRefs(row, method[i]);
-		}
+		for (let i = 0; i < length; i++) if (this.#routeMayHaveModelRef(table, i)) this.#assertRouteModelRefs(routeRow(table, i), method[i]);
 		if (length) Compiled.claim(this["~programId"], this["~aotFingerprint"] = createAotFingerprint());
 		const isLoose = this["~config"]?.strictPath !== true;
 		let hasLooseCandidate = false;
@@ -1398,7 +1399,7 @@ var Elysia = class Elysia {
 			const explicitMain = registerLoose ? explicitPaths?.get(routeMethod) : void 0;
 			if (!isDynamic && !needsEncode && !registerLoose) {
 				const map = methods[routeMethod] ??= nullObject();
-				map[routePath] = this.handler(i, precompile, routeRow(table, i), void 0);
+				map[routePath] = this.handler(i, precompile, void 0, void 0, void 0, table);
 				continue;
 			}
 			const variants = [routePath];
@@ -1417,14 +1418,14 @@ var Elysia = class Elysia {
 			}
 			if (isDynamic) {
 				const router = this["~router"] ??= new Memoirist({ loosePath: isLoose });
-				const handler = this.handler(i, precompile, routeRow(table, i), void 0);
+				const handler = this.handler(i, precompile, void 0, void 0, void 0, table);
 				for (let p = 0; p < paths.length; p++) router.add(routeMethod, paths[p], handler);
 			} else {
 				const map = methods[routeMethod] ??= nullObject();
-				const handler = this.handler(i, precompile, routeRow(table, i), void 0, {
+				const handler = this.handler(i, precompile, void 0, void 0, {
 					method: routeMethod,
 					paths
-				});
+				}, table);
 				for (let p = 0; p < paths.length; p++) map[paths[p]] = handler;
 			}
 		}

package/dist/compile/aot.js

@@ -219,7 +219,11 @@ function captureEntry({ method, path, slot }) {
 const aotActivationError = /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
 function beginValidatorCapture() {
 	if (captureImpl === void 0) throw aotActivationError;
-	if (activeSession?.capture !== void 0) throw new Error("[elysia-aot]: A capture session is already active.");
+	if (activeSession?.capture !== void 0) {
+		if (activeSession.explicitCapture) throw new Error("[elysia-aot]: A capture session is already active.");
+		activeSession.explicitCapture = true;
+		return;
+	}
 	if (activeSession && !activeSession.external) throw new Error("[elysia-aot]: A compiler session is already active.");
 	const session = activeSession ?? (activeSession = newCompilerSession());
 	session.external = true;

package/dist/compile/aot.mjs

@@ -218,7 +218,11 @@ function captureEntry({ method, path, slot }) {
 const aotActivationError = /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
 function beginValidatorCapture() {
 	if (captureImpl === void 0) throw aotActivationError;
-	if (activeSession?.capture !== void 0) throw new Error("[elysia-aot]: A capture session is already active.");
+	if (activeSession?.capture !== void 0) {
+		if (activeSession.explicitCapture) throw new Error("[elysia-aot]: A capture session is already active.");
+		activeSession.explicitCapture = true;
+		return;
+	}
 	if (activeSession && !activeSession.external) throw new Error("[elysia-aot]: A compiler session is already active.");
 	const session = activeSession ?? (activeSession = newCompilerSession());
 	session.external = true;

package/dist/compile/handler/index.js

@@ -344,12 +344,14 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		isStaticResponse,
 		isPromiseHandler
 	});
-	let descriptors = require_compile_handler_descriptor.routeDescriptors.get(root);
-	if (!descriptors) {
-		descriptors = /* @__PURE__ */ new Map();
-		require_compile_handler_descriptor.routeDescriptors.set(root, descriptors);
+	if (root["~introspect"] === true || root["~config"]?.introspect === true) {
+		let descriptors = require_compile_handler_descriptor.routeDescriptors.get(root);
+		if (!descriptors) {
+			descriptors = /* @__PURE__ */ new Map();
+			require_compile_handler_descriptor.routeDescriptors.set(root, descriptors);
+		}
+		descriptors.set(`${method} ${path}`, state.descriptor);
 	}
-	descriptors.set(`${method} ${path}`, state.descriptor);
 	const resumeEmit = frozenRoot["~config"]?.experimental?.resumeEmit;
 	if (resumeEmit) {
 		if (typeof resumeEmit.planRoute !== "function" || typeof resumeEmit.emitResume !== "function") throw new TypeError("[elysia] experimental.resumeEmit must be imported from \"elysia/experimental/resume\".");

package/dist/compile/handler/index.mjs

@@ -343,12 +343,14 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 		isStaticResponse,
 		isPromiseHandler
 	});
-	let descriptors = routeDescriptors.get(root);
-	if (!descriptors) {
-		descriptors = /* @__PURE__ */ new Map();
-		routeDescriptors.set(root, descriptors);
+	if (root["~introspect"] === true || root["~config"]?.introspect === true) {
+		let descriptors = routeDescriptors.get(root);
+		if (!descriptors) {
+			descriptors = /* @__PURE__ */ new Map();
+			routeDescriptors.set(root, descriptors);
+		}
+		descriptors.set(`${method} ${path}`, state.descriptor);
 	}
-	descriptors.set(`${method} ${path}`, state.descriptor);
 	const resumeEmit = frozenRoot["~config"]?.experimental?.resumeEmit;
 	if (resumeEmit) {
 		if (typeof resumeEmit.planRoute !== "function" || typeof resumeEmit.emitResume !== "function") throw new TypeError("[elysia] experimental.resumeEmit must be imported from \"elysia/experimental/resume\".");

package/dist/compile/handler/jit.js

@@ -137,39 +137,24 @@ function schemaMediaKind(schema) {
 	return result;
 }
 const fromArgs = (type, isAsync) => `'${type}'${isAsync ? ",true" : ""}`;
-const createInlineHandler = (map, h, root) => ((c) => {
-	try {
-		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)).catch((error) => require_handler_utils.finalizeRouteError(root, c, error));
-		const response = map(r, c.request);
-		return typeof response?.then === "function" ? Promise.resolve(response).catch((error) => require_handler_utils.finalizeRouteError(root, c, error)) : response;
-	} catch (error) {
-		return require_handler_utils.finalizeRouteError(root, c, error);
-	}
+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, root) => ((c) => {
-	try {
-		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)).catch((error) => require_handler_utils.finalizeRouteError(root, c, error));
-		const response = map(r, c.set, c.request);
-		return typeof response?.then === "function" ? Promise.resolve(response).catch((error) => require_handler_utils.finalizeRouteError(root, c, error)) : response;
-	} catch (error) {
-		return require_handler_utils.finalizeRouteError(root, c, error);
-	}
+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);
 });
-const createInlineHandlerWithDefaultHeaders = (map, h, root) => ((c) => {
-	try {
-		require_adapter_utils.materializeSetHeaders(c.set);
-		const r = h(c);
-		if (r instanceof Error) throw r;
-		if (r instanceof Promise) return r.then((v) => map(require_handler_utils.forwardError(v), c.set, c.request)).catch((error) => require_handler_utils.finalizeRouteError(root, c, error));
-		const response = map(r, c.set, c.request);
-		return typeof response?.then === "function" ? Promise.resolve(response).catch((error) => require_handler_utils.finalizeRouteError(root, c, error)) : response;
-	} catch (error) {
-		return require_handler_utils.finalizeRouteError(root, c, error);
-	}
+const createInlineHandlerWithDefaultHeaders = (map, h) => ((c) => {
+	require_adapter_utils.materializeSetHeaders(c.set);
+	const r = h(c);
+	if (r instanceof Error) throw r;
+	if (r instanceof Promise) return r.then((v) => map(require_handler_utils.forwardError(v), c.set, c.request));
+	return map(r, c.set, c.request);
 });
 function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapter, isHandleFunction, isStaticResponse, isPromiseHandler, state }) {
 	const { vali, inference, cookieConfig, beforeHandlePrefix, traceHandlers, tracePhases, hasAnyPhase, traceHandleOn, descriptor: { async: isAsync, responseMode, hasBody, bodyValiIsAsync, headersValiIsAsync, paramsValiIsAsync, queryValiIsAsync, cookieValiIsAsync: cookieValidIsAsync, responseValiAsync, hasCookieSign, syncCookieSign, asyncCookieSign, lazyCookieVerify, hasErrorHook, hasAfterResponse, hasBeforeHandle, hasAfterHandle, hasMapResponse, hasResponseValidator, hasTrace, traceCount, hasLifecycleHook, callHandlerSyncOnAsync, syncErrorHook, syncAfterResponse } } = state;
@@ -516,8 +501,8 @@ if(typeof _er?.then==='function')return Promise.resolve(_er).then(${asyncCookieS
 	const inlineAlias = alias.startsWith("rt,fre,") ? alias.slice(7) : alias;
 	const isGeneratorHandler = isHandleFunction && handler.constructor.name.endsWith("GeneratorFunction");
 	if (!hasTrace && isHandleFunction && !isGeneratorHandler && !inlineUnsafe) {
-		if (inlineAlias === "rc" || !isAsync && !syncErrorHook && inlineAlias === "rc,fe") return createInlineHandler(res.compact ?? res.map, handler, errorRoot);
-		else if (inlineAlias === "rm" || inlineAlias === "msh,rm" || !isAsync && !syncErrorHook && (inlineAlias === "rm,fe" || inlineAlias === "msh,rm,fe")) return responseMode === "set-with-default-headers" && inference.set ? createInlineHandlerWithDefaultHeaders(responseMap, handler, errorRoot) : createInlineHandlerWithSet(responseMap, handler, errorRoot);
+		if (inlineAlias === "rc" || !isAsync && !syncErrorHook && inlineAlias === "rc,fe") return createInlineHandler(res.compact ?? res.map, handler);
+		else if (inlineAlias === "rm" || inlineAlias === "msh,rm" || !isAsync && !syncErrorHook && (inlineAlias === "rm,fe" || inlineAlias === "msh,rm,fe")) return responseMode === "set-with-default-headers" && inference.set ? createInlineHandlerWithDefaultHeaders(responseMap, handler) : createInlineHandlerWithSet(responseMap, handler);
 	}
 	require_compile_jit_probe.JITProbe.record("handler:new-function");
 	return new Function("h", alias, `return ${code}`)(handler, ...paramValues);

package/dist/compile/handler/jit.mjs

@@ -136,39 +136,24 @@ function schemaMediaKind(schema) {
 	return result;
 }
 const fromArgs = (type, isAsync) => `'${type}'${isAsync ? ",true" : ""}`;
-const createInlineHandler = (map, h, root) => ((c) => {
-	try {
-		const r = h(c);
-		if (r instanceof Error) throw r;
-		if (r instanceof Promise) return r.then((v) => map(forwardError(v), c.request)).catch((error) => finalizeRouteError(root, c, error));
-		const response = map(r, c.request);
-		return typeof response?.then === "function" ? Promise.resolve(response).catch((error) => finalizeRouteError(root, c, error)) : response;
-	} catch (error) {
-		return finalizeRouteError(root, c, error);
-	}
+const createInlineHandler = (map, h) => ((c) => {
+	const r = h(c);
+	if (r instanceof Error) throw r;
+	if (r instanceof Promise) return r.then((v) => map(forwardError(v), c.request));
+	return map(r, c.request);
 });
-const createInlineHandlerWithSet = (map, h, root) => ((c) => {
-	try {
-		const r = h(c);
-		if (r instanceof Error) throw r;
-		if (r instanceof Promise) return r.then((v) => map(forwardError(v), c.set, c.request)).catch((error) => finalizeRouteError(root, c, error));
-		const response = map(r, c.set, c.request);
-		return typeof response?.then === "function" ? Promise.resolve(response).catch((error) => finalizeRouteError(root, c, error)) : response;
-	} catch (error) {
-		return finalizeRouteError(root, c, error);
-	}
+const createInlineHandlerWithSet = (map, h) => ((c) => {
+	const r = h(c);
+	if (r instanceof Error) throw r;
+	if (r instanceof Promise) return r.then((v) => map(forwardError(v), c.set, c.request));
+	return map(r, c.set, c.request);
 });
-const createInlineHandlerWithDefaultHeaders = (map, h, root) => ((c) => {
-	try {
-		materializeSetHeaders(c.set);
-		const r = h(c);
-		if (r instanceof Error) throw r;
-		if (r instanceof Promise) return r.then((v) => map(forwardError(v), c.set, c.request)).catch((error) => finalizeRouteError(root, c, error));
-		const response = map(r, c.set, c.request);
-		return typeof response?.then === "function" ? Promise.resolve(response).catch((error) => finalizeRouteError(root, c, error)) : response;
-	} catch (error) {
-		return finalizeRouteError(root, c, error);
-	}
+const createInlineHandlerWithDefaultHeaders = (map, h) => ((c) => {
+	materializeSetHeaders(c.set);
+	const r = h(c);
+	if (r instanceof Error) throw r;
+	if (r instanceof Promise) return r.then((v) => map(forwardError(v), c.set, c.request));
+	return map(r, c.set, c.request);
 });
 function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapter, isHandleFunction, isStaticResponse, isPromiseHandler, state }) {
 	const { vali, inference, cookieConfig, beforeHandlePrefix, traceHandlers, tracePhases, hasAnyPhase, traceHandleOn, descriptor: { async: isAsync, responseMode, hasBody, bodyValiIsAsync, headersValiIsAsync, paramsValiIsAsync, queryValiIsAsync, cookieValiIsAsync: cookieValidIsAsync, responseValiAsync, hasCookieSign, syncCookieSign, asyncCookieSign, lazyCookieVerify, hasErrorHook, hasAfterResponse, hasBeforeHandle, hasAfterHandle, hasMapResponse, hasResponseValidator, hasTrace, traceCount, hasLifecycleHook, callHandlerSyncOnAsync, syncErrorHook, syncAfterResponse } } = state;
@@ -515,8 +500,8 @@ if(typeof _er?.then==='function')return Promise.resolve(_er).then(${asyncCookieS
 	const inlineAlias = alias.startsWith("rt,fre,") ? alias.slice(7) : alias;
 	const isGeneratorHandler = isHandleFunction && handler.constructor.name.endsWith("GeneratorFunction");
 	if (!hasTrace && isHandleFunction && !isGeneratorHandler && !inlineUnsafe) {
-		if (inlineAlias === "rc" || !isAsync && !syncErrorHook && inlineAlias === "rc,fe") return createInlineHandler(res.compact ?? res.map, handler, errorRoot);
-		else if (inlineAlias === "rm" || inlineAlias === "msh,rm" || !isAsync && !syncErrorHook && (inlineAlias === "rm,fe" || inlineAlias === "msh,rm,fe")) return responseMode === "set-with-default-headers" && inference.set ? createInlineHandlerWithDefaultHeaders(responseMap, handler, errorRoot) : createInlineHandlerWithSet(responseMap, handler, errorRoot);
+		if (inlineAlias === "rc" || !isAsync && !syncErrorHook && inlineAlias === "rc,fe") return createInlineHandler(res.compact ?? res.map, handler);
+		else if (inlineAlias === "rm" || inlineAlias === "msh,rm" || !isAsync && !syncErrorHook && (inlineAlias === "rm,fe" || inlineAlias === "msh,rm,fe")) return responseMode === "set-with-default-headers" && inference.set ? createInlineHandlerWithDefaultHeaders(responseMap, handler) : createInlineHandlerWithSet(responseMap, handler);
 	}
 	JITProbe.record("handler:new-function");
 	return new Function("h", alias, `return ${code}`)(handler, ...paramValues);

package/dist/compile/lexer.d.ts

@@ -1,5 +1,5 @@
 //#region src/compile/lexer.d.ts
-declare const isSpace: (ch: string) => ch is "\n" | " " | "\t" | "\r";
+declare const isSpace: (ch: string) => ch is " " | "\n" | "\t" | "\r";
 declare const isIdentChar: (ch: string) => boolean;
 declare const isIdentCharCode: (code: number) => boolean;
 declare function skipString(src: string, start: number): number;

package/dist/handler/fetch.js

@@ -56,6 +56,11 @@ function finalizeError(context, handleError, afterResponse, error) {
 	return resp;
 }
 const catchError = (context, handleError, afterResponse) => (error) => finalizeError(context, handleError, afterResponse, error);
+function dispatchResult(result, context, handleError, afterResponse) {
+	if (result instanceof Promise) return result.catch(catchError(context, handleError, afterResponse));
+	if (typeof result?.then === "function") return Promise.resolve(result).catch(catchError(context, handleError, afterResponse));
+	return result;
+}
 function findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS) {
 	const path = context.path;
 	if (hasWS && request.method === "GET") {
@@ -85,11 +90,11 @@ function findRoute(context, request, map, router, hasError, handleError, afterRe
 			handler = anyMap?.[path] ?? anyMap?.[loose];
 		}
 	} else handler = map["*"]?.[path];
-	if (handler) return handler(context);
+	if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
 	const found = router?.find(method, path) ?? router?.find("*", path);
 	if (found) {
 		context.params = decodeParams(found.params);
-		return found.store(context);
+		return dispatchResult(found.store(context), context, handleError, afterResponse);
 	}
 	if (hasError) throw new require_error.NotFound();
 	afterResponse?.(context, 404);
@@ -296,22 +301,26 @@ function createFetchHandler(app) {
 				}
 			}
 		}
-		const methodMap = map[method];
-		let handler = methodMap?.[path];
-		if (handler) return handler(context);
-		if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
-			const loose = path.slice(0, -1);
-			handler = methodMap?.[loose];
-			if (!handler) {
-				const anyMap = map["*"];
-				handler = anyMap?.[path] ?? anyMap?.[loose];
+		try {
+			const methodMap = map[method];
+			let handler = methodMap?.[path];
+			if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
+			if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
+				const loose = path.slice(0, -1);
+				handler = methodMap?.[loose];
+				if (!handler) {
+					const anyMap = map["*"];
+					handler = anyMap?.[path] ?? anyMap?.[loose];
+				}
+			} else handler = map["*"]?.[path];
+			if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
+			const result = router?.find(method, path) ?? router?.find("*", path);
+			if (result) {
+				context.params = decodeParams(result.params);
+				return dispatchResult(result.store(context), context, handleError, afterResponse);
 			}
-		} else handler = map["*"]?.[path];
-		if (handler) return handler(context);
-		const result = router?.find(method, path) ?? router?.find("*", path);
-		if (result) {
-			context.params = decodeParams(result.params);
-			return result.store(context);
+		} catch (error) {
+			return finalizeError(context, handleError, afterResponse, error);
 		}
 		if (hasError) return finalizeError(context, handleError, afterResponse, new require_error.NotFound());
 		afterResponse?.(context, 404);

package/dist/handler/fetch.mjs

@@ -54,6 +54,11 @@ function finalizeError(context, handleError, afterResponse, error) {
 	return resp;
 }
 const catchError = (context, handleError, afterResponse) => (error) => finalizeError(context, handleError, afterResponse, error);
+function dispatchResult(result, context, handleError, afterResponse) {
+	if (result instanceof Promise) return result.catch(catchError(context, handleError, afterResponse));
+	if (typeof result?.then === "function") return Promise.resolve(result).catch(catchError(context, handleError, afterResponse));
+	return result;
+}
 function findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS) {
 	const path = context.path;
 	if (hasWS && request.method === "GET") {
@@ -83,11 +88,11 @@ function findRoute(context, request, map, router, hasError, handleError, afterRe
 			handler = anyMap?.[path] ?? anyMap?.[loose];
 		}
 	} else handler = map["*"]?.[path];
-	if (handler) return handler(context);
+	if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
 	const found = router?.find(method, path) ?? router?.find("*", path);
 	if (found) {
 		context.params = decodeParams(found.params);
-		return found.store(context);
+		return dispatchResult(found.store(context), context, handleError, afterResponse);
 	}
 	if (hasError) throw new NotFound();
 	afterResponse?.(context, 404);
@@ -294,22 +299,26 @@ function createFetchHandler(app) {
 				}
 			}
 		}
-		const methodMap = map[method];
-		let handler = methodMap?.[path];
-		if (handler) return handler(context);
-		if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
-			const loose = path.slice(0, -1);
-			handler = methodMap?.[loose];
-			if (!handler) {
-				const anyMap = map["*"];
-				handler = anyMap?.[path] ?? anyMap?.[loose];
+		try {
+			const methodMap = map[method];
+			let handler = methodMap?.[path];
+			if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
+			if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
+				const loose = path.slice(0, -1);
+				handler = methodMap?.[loose];
+				if (!handler) {
+					const anyMap = map["*"];
+					handler = anyMap?.[path] ?? anyMap?.[loose];
+				}
+			} else handler = map["*"]?.[path];
+			if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
+			const result = router?.find(method, path) ?? router?.find("*", path);
+			if (result) {
+				context.params = decodeParams(result.params);
+				return dispatchResult(result.store(context), context, handleError, afterResponse);
 			}
-		} else handler = map["*"]?.[path];
-		if (handler) return handler(context);
-		const result = router?.find(method, path) ?? router?.find("*", path);
-		if (result) {
-			context.params = decodeParams(result.params);
-			return result.store(context);
+		} catch (error) {
+			return finalizeError(context, handleError, afterResponse, error);
 		}
 		if (hasError) return finalizeError(context, handleError, afterResponse, new NotFound());
 		afterResponse?.(context, 404);

package/dist/package.js

@@ -1,6 +1,6 @@
 
 //#region package.json
-var version = "2.0.0-exp.43";
+var version = "2.0.0-exp.45";
 
 //#endregion
 Object.defineProperty(exports, 'version', {

package/dist/package.mjs

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "2.0.0-exp.43";
+var version = "2.0.0-exp.45";
 
 //#endregion
 export { version };

package/dist/type/bridge-live.d.ts

@@ -5,8 +5,8 @@ import { hasTypes } from "./utils.js";
 import { useTypebox as useTypebox$1 } from "./bridge.js";
 import { applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure } from "./coerce.js";
 import { Ref } from "typebox/type";
-import { Compile } from "typebox/compile";
 import { Clone, Create, Decode, Default, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
 
 //#region src/type/bridge-live.d.ts
 declare function useTypebox(_mod?: Parameters<typeof useTypebox$1>[0]): void;

package/dist/type/bridge.d.ts

@@ -1,17 +1,17 @@
 import { TypeBoxValidatorCache as TypeBoxValidatorCache$1 } from "./validator/validator-cache.js";
 import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
-import { Intersect as Intersect$1 } from "./elysia/intersect.js";
+import { Intersect as Intersect$2 } from "./elysia/intersect.js";
 import { hasTypes as hasTypes$1 } from "./utils.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
+import { Clone as Clone$1, Create as Create$1, Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 import { Compile as Compile$1 } from "typebox/compile";
-import { Clone as Clone$1, Create as Create$1, Decode as Decode$1, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {
   Compile: typeof Compile$1;
   Create: typeof Create$1;
-  Decode: typeof Decode$1;
+  Decode: typeof Decode$2;
   applyCoercions: typeof applyCoercions$1;
   TypeBoxValidator: TypeBoxValidator$1;
   TypeBoxValidatorCache: TypeBoxValidatorCache$1;
@@ -22,14 +22,14 @@ interface TypeboxModule {
   coerceBody: typeof coerceBody$1;
   hasTypes: typeof hasTypes$1;
   HasCodec: typeof HasCodec$1;
-  Intersect: typeof Intersect$1;
+  Intersect: typeof Intersect$2;
   Default: typeof Default$1;
   Ref: typeof Ref$1;
   Clone: typeof Clone$1;
 }
 declare let Compile: typeof Compile$1;
 declare let Create: typeof Create$1;
-declare let Decode: typeof Decode$1;
+declare let Decode: typeof Decode$2;
 declare let applyCoercions: typeof applyCoercions$1;
 declare let TypeBoxValidator: TypeBoxValidator$1;
 type TypeBoxValidator<T extends TSchema = TAny> = TypeBoxValidator$1<T>;
@@ -42,7 +42,7 @@ declare let coerceStringToStructure: typeof coerceStringToStructure$1;
 declare let coerceBody: typeof coerceBody$1;
 declare let hasTypes: typeof hasTypes$1;
 declare let HasCodec: typeof HasCodec$1;
-declare let Intersect: typeof Intersect$1;
+declare let Intersect: typeof Intersect$2;
 declare let Default: typeof Default$1;
 declare let Ref: typeof Ref$1;
 declare let Clone: typeof Clone$1;

package/dist/type/constants.d.ts

@@ -17,7 +17,7 @@ declare const ELYSIA_TYPES: {
   readonly NoValidate: 15;
 };
 type ELYSIA_TYPES = typeof ELYSIA_TYPES;
-declare const primitiveElysiaTypes: Set<1 | 2 | 6 | 10 | 3 | 11 | 13 | 14>;
+declare const primitiveElysiaTypes: Set<1 | 2 | 6 | 3 | 10 | 11 | 13 | 14>;
 declare const noEnumerable: {
   readonly enumerable: false;
 };

package/dist/type/validator/index.d.ts

@@ -2,8 +2,8 @@ import { TypeBoxValidatorCache } from "./validator-cache.js";
 import { Validator as Validator$1, ValidatorOptions } from "../../validator/index.js";
 import { MaybePromise } from "../../types.js";
 import { Static, StaticDecode, StaticEncode, TAny, TSchema } from "typebox/type";
-import { TLocalizedValidationError } from "typebox/error";
 import { Validator } from "typebox/schema";
+import { TLocalizedValidationError } from "typebox/error";
 
 //#region src/type/validator/index.d.ts
 declare function shallowMergeObjects(members: any[]): TSchema | null;

package/dist/type/validator/index.js

@@ -23,6 +23,24 @@ exact_mirror = require_runtime.__toESM(exact_mirror);
 const moduleCache = /* @__PURE__ */ new WeakMap();
 let activeRefineValidation;
 const refinementGroups = /* @__PURE__ */ new WeakMap();
+const freshRefineValidation = (groups) => {
+	const slots = /* @__PURE__ */ new Map();
+	for (const group of groups) slots.set(group, {
+		epoch: 0,
+		replayEpoch: 0,
+		occurrences: 0,
+		recorded: 0,
+		verdicts: []
+	});
+	return {
+		slots,
+		epoch: 0,
+		replayEpoch: 0,
+		replay: false,
+		active: false,
+		checking: false
+	};
+};
 function collectRefinements(schema, out = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new WeakSet()) {
 	if (!schema || typeof schema !== "object" || seen.has(schema)) return out;
 	seen.add(schema);
@@ -41,18 +59,31 @@ function collectRefinements(schema, out = /* @__PURE__ */ new Set(), seen = /* @
 					const refinement = members[index];
 					refinement.check = function(value) {
 						const validation = activeRefineValidation;
-						if (!validation?.groups.has(group)) return group.checks[index].call(this, value);
-						let occurrence = validation.occurrences.get(group) ?? 0;
-						if (index === 0) {
-							validation.occurrences.set(group, ++occurrence);
-							if (!validation.replay) {
-								const results = group.checks.map((check) => Boolean(check.call(this, value)));
-								const calls = validation.results.get(group);
-								if (calls) calls.push(results);
-								else validation.results.set(group, [results]);
+						const slot = validation?.slots.get(group);
+						if (slot === void 0) return group.checks[index].call(this, value);
+						if (!validation.replay) {
+							if (slot.epoch !== validation.epoch) {
+								slot.epoch = validation.epoch;
+								slot.occurrences = 0;
+								slot.recorded = 0;
+							}
+							if (index === 0) {
+								const occurrence = slot.occurrences++;
+								slot.recorded = slot.occurrences;
+								let results = slot.verdicts[occurrence];
+								if (results === void 0) slot.verdicts[occurrence] = results = [];
+								const checks = group.checks;
+								for (let i = 0; i < checks.length; i++) results[i] = Boolean(checks[i].call(this, value));
 							}
+							return slot.verdicts[slot.occurrences - 1][index];
 						}
-						return validation.results.get(group)?.[occurrence - 1]?.[index] ?? true;
+						if (slot.replayEpoch !== validation.replayEpoch) {
+							slot.replayEpoch = validation.replayEpoch;
+							slot.occurrences = 0;
+						}
+						if (index === 0) slot.occurrences++;
+						if (slot.occurrences > slot.recorded) return true;
+						return slot.verdicts[slot.occurrences - 1][index];
 					};
 				}
 			}
@@ -169,6 +200,7 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 	#decodeMirror;
 	#encodeMirror;
 	#refinements;
+	#refineScratch;
 	#findCustomError;
 	#defaultFastPath;
 	#noValidate;
@@ -290,21 +322,22 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 	}
 	#validate(value) {
 		if (!this.#refinements) return this.Check(value) ? void 0 : [];
+		const pool = this.#refineScratch ??= freshRefineValidation(this.#refinements);
+		const usingPool = !pool.active;
+		const validation = usingPool ? pool : freshRefineValidation(this.#refinements);
 		const previous = activeRefineValidation;
-		const validation = {
-			groups: this.#refinements,
-			results: /* @__PURE__ */ new Map(),
-			replay: false,
-			occurrences: /* @__PURE__ */ new Map()
-		};
+		if (usingPool) pool.active = true;
+		validation.epoch++;
+		validation.replay = false;
 		activeRefineValidation = validation;
 		try {
 			if (this.Check(value)) return;
 			validation.replay = true;
-			validation.occurrences.clear();
+			validation.replayEpoch++;
 			return this.Errors(value);
 		} finally {
 			activeRefineValidation = previous;
+			if (usingPool) pool.active = false;
 		}
 	}
 	#setupMirror(schema, options, frozen) {
@@ -367,6 +400,27 @@ var TypeBoxValidator = class extends require_validator_index.Validator {
 		} catch {}
 	}
 	Check(value) {
+		const pool = this.#refineScratch;
+		if (pool?.active && this.#refinements) {
+			if (pool.checking) {
+				const previous = activeRefineValidation;
+				activeRefineValidation = void 0;
+				try {
+					return this.#rawCheck(value);
+				} finally {
+					activeRefineValidation = previous;
+				}
+			}
+			pool.checking = true;
+			try {
+				return this.#rawCheck(value);
+			} finally {
+				pool.checking = false;
+			}
+		}
+		return this.#rawCheck(value);
+	}
+	#rawCheck(value) {
 		if (this.reconstructedCheck) return this.reconstructedCheck(value);
 		return this.tb.Check(value);
 	}

package/dist/type/validator/index.mjs

@@ -20,6 +20,24 @@ import createMirror from "exact-mirror";
 const moduleCache = /* @__PURE__ */ new WeakMap();
 let activeRefineValidation;
 const refinementGroups = /* @__PURE__ */ new WeakMap();
+const freshRefineValidation = (groups) => {
+	const slots = /* @__PURE__ */ new Map();
+	for (const group of groups) slots.set(group, {
+		epoch: 0,
+		replayEpoch: 0,
+		occurrences: 0,
+		recorded: 0,
+		verdicts: []
+	});
+	return {
+		slots,
+		epoch: 0,
+		replayEpoch: 0,
+		replay: false,
+		active: false,
+		checking: false
+	};
+};
 function collectRefinements(schema, out = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new WeakSet()) {
 	if (!schema || typeof schema !== "object" || seen.has(schema)) return out;
 	seen.add(schema);
@@ -38,18 +56,31 @@ function collectRefinements(schema, out = /* @__PURE__ */ new Set(), seen = /* @
 					const refinement = members[index];
 					refinement.check = function(value) {
 						const validation = activeRefineValidation;
-						if (!validation?.groups.has(group)) return group.checks[index].call(this, value);
-						let occurrence = validation.occurrences.get(group) ?? 0;
-						if (index === 0) {
-							validation.occurrences.set(group, ++occurrence);
-							if (!validation.replay) {
-								const results = group.checks.map((check) => Boolean(check.call(this, value)));
-								const calls = validation.results.get(group);
-								if (calls) calls.push(results);
-								else validation.results.set(group, [results]);
+						const slot = validation?.slots.get(group);
+						if (slot === void 0) return group.checks[index].call(this, value);
+						if (!validation.replay) {
+							if (slot.epoch !== validation.epoch) {
+								slot.epoch = validation.epoch;
+								slot.occurrences = 0;
+								slot.recorded = 0;
+							}
+							if (index === 0) {
+								const occurrence = slot.occurrences++;
+								slot.recorded = slot.occurrences;
+								let results = slot.verdicts[occurrence];
+								if (results === void 0) slot.verdicts[occurrence] = results = [];
+								const checks = group.checks;
+								for (let i = 0; i < checks.length; i++) results[i] = Boolean(checks[i].call(this, value));
 							}
+							return slot.verdicts[slot.occurrences - 1][index];
 						}
-						return validation.results.get(group)?.[occurrence - 1]?.[index] ?? true;
+						if (slot.replayEpoch !== validation.replayEpoch) {
+							slot.replayEpoch = validation.replayEpoch;
+							slot.occurrences = 0;
+						}
+						if (index === 0) slot.occurrences++;
+						if (slot.occurrences > slot.recorded) return true;
+						return slot.verdicts[slot.occurrences - 1][index];
 					};
 				}
 			}
@@ -166,6 +197,7 @@ var TypeBoxValidator = class extends Validator$1 {
 	#decodeMirror;
 	#encodeMirror;
 	#refinements;
+	#refineScratch;
 	#findCustomError;
 	#defaultFastPath;
 	#noValidate;
@@ -287,21 +319,22 @@ var TypeBoxValidator = class extends Validator$1 {
 	}
 	#validate(value) {
 		if (!this.#refinements) return this.Check(value) ? void 0 : [];
+		const pool = this.#refineScratch ??= freshRefineValidation(this.#refinements);
+		const usingPool = !pool.active;
+		const validation = usingPool ? pool : freshRefineValidation(this.#refinements);
 		const previous = activeRefineValidation;
-		const validation = {
-			groups: this.#refinements,
-			results: /* @__PURE__ */ new Map(),
-			replay: false,
-			occurrences: /* @__PURE__ */ new Map()
-		};
+		if (usingPool) pool.active = true;
+		validation.epoch++;
+		validation.replay = false;
 		activeRefineValidation = validation;
 		try {
 			if (this.Check(value)) return;
 			validation.replay = true;
-			validation.occurrences.clear();
+			validation.replayEpoch++;
 			return this.Errors(value);
 		} finally {
 			activeRefineValidation = previous;
+			if (usingPool) pool.active = false;
 		}
 	}
 	#setupMirror(schema, options, frozen) {
@@ -364,6 +397,27 @@ var TypeBoxValidator = class extends Validator$1 {
 		} catch {}
 	}
 	Check(value) {
+		const pool = this.#refineScratch;
+		if (pool?.active && this.#refinements) {
+			if (pool.checking) {
+				const previous = activeRefineValidation;
+				activeRefineValidation = void 0;
+				try {
+					return this.#rawCheck(value);
+				} finally {
+					activeRefineValidation = previous;
+				}
+			}
+			pool.checking = true;
+			try {
+				return this.#rawCheck(value);
+			} finally {
+				pool.checking = false;
+			}
+		}
+		return this.#rawCheck(value);
+	}
+	#rawCheck(value) {
 		if (this.reconstructedCheck) return this.reconstructedCheck(value);
 		return this.tb.Check(value);
 	}

package/dist/types.d.ts

@@ -11,8 +11,8 @@ import { Context, ErrorContext, LifecycleContext, PreContext } from "./context.j
 import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { AnyElysia, Elysia } from "./base.js";
 import { ElysiaAdapter } from "./adapter/index.js";
-import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
 import { Instruction } from "exact-mirror";
+import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/types.d.ts

package/dist/utils.d.ts

@@ -1,7 +1,6 @@
 import { AnyLocalHook, AppHook, ElysiaFormData, EventFn, EventScope, GuardSchemaType, InputSchema, Macro, MaybeArray, Prettify, SSEPayload } from "./types.js";
 import { Context } from "./context.js";
 import { AnySchema, StandardSchemaV1Like } from "./type/types.js";
-
 //#region src/utils.d.ts
 declare const nullObject: () => any;
 type DeriveEntry = Function | readonly [Function, 'mapDerive'];

package/dist/validator/index.js

@@ -55,19 +55,23 @@ var Validator = class Validator {
 			const skipCache = options?.normalize === false || !!options?.sanitize;
 			const aot = options?.aot;
 			const slot = options?.slot;
-			const normalizeKey = options?.normalize === "typebox" ? "typebox" : "";
-			const bypassCache = !!aot && !!slot && (require_compile_aot.Capture.isCapturing() || options?.normalize !== "typebox" && require_compile_aot.Compiled.hasValidator(aot.method, aot.path, slot, options?.app?.["~programId"]));
-			const cache = options?.app ? tbCaches.get(options.app) : tbCache;
+			const normalizeKey = (options?.normalize === "typebox" ? "typebox" : "") + (slot?.startsWith("response") ? "\0r" : "");
+			const appHasFrozen = !!aot && !!slot && require_compile_aot.Compiled.hasValidator(aot.method, aot.path, slot, options?.app?.["~programId"]);
+			const appSpecific = appHasFrozen || require_compile_aot.Capture.isCapturing();
+			const app = options?.app;
+			const bypassCache = !!aot && !!slot && require_compile_aot.Capture.isCapturing() || appHasFrozen && options?.normalize !== "typebox" || appSpecific && !app;
+			let cache = appSpecific ? app ? tbCaches.get(app) : void 0 : tbCache;
 			if (!isIntersectable && !skipCache && !bypassCache && cache) {
 				const cached = cache.get(schema, options?.coerces, normalizeKey, options?.models);
 				if (cached) return cached;
-			} else if (!cache) {
+			} else if (!cache && !bypassCache) {
 				const created = new require_type_bridge.TypeBoxValidatorCache();
-				if (options?.app) tbCaches.set(options.app, created);
+				cache = created;
+				if (appSpecific && app) tbCaches.set(app, created);
 				else tbCache = created;
 			}
 			const validator = new require_type_bridge.TypeBoxValidator(schema, options, typeof name === "string" ? name : void 0, isIntersectable);
-			if (!isIntersectable && !skipCache && !bypassCache) (options?.app ? tbCaches.get(options.app) : tbCache).set(schema, options?.coerces, validator, normalizeKey, options?.models);
+			if (!isIntersectable && !skipCache && !bypassCache) cache.set(schema, options?.coerces, validator, normalizeKey, options?.models);
 			return validator;
 		}
 		if ("~standard" in schema) return new StandardValidator(schema);

package/dist/validator/index.mjs

@@ -54,19 +54,23 @@ var Validator = class Validator {
 			const skipCache = options?.normalize === false || !!options?.sanitize;
 			const aot = options?.aot;
 			const slot = options?.slot;
-			const normalizeKey = options?.normalize === "typebox" ? "typebox" : "";
-			const bypassCache = !!aot && !!slot && (Capture.isCapturing() || options?.normalize !== "typebox" && Compiled.hasValidator(aot.method, aot.path, slot, options?.app?.["~programId"]));
-			const cache = options?.app ? tbCaches.get(options.app) : tbCache;
+			const normalizeKey = (options?.normalize === "typebox" ? "typebox" : "") + (slot?.startsWith("response") ? "\0r" : "");
+			const appHasFrozen = !!aot && !!slot && Compiled.hasValidator(aot.method, aot.path, slot, options?.app?.["~programId"]);
+			const appSpecific = appHasFrozen || Capture.isCapturing();
+			const app = options?.app;
+			const bypassCache = !!aot && !!slot && Capture.isCapturing() || appHasFrozen && options?.normalize !== "typebox" || appSpecific && !app;
+			let cache = appSpecific ? app ? tbCaches.get(app) : void 0 : tbCache;
 			if (!isIntersectable && !skipCache && !bypassCache && cache) {
 				const cached = cache.get(schema, options?.coerces, normalizeKey, options?.models);
 				if (cached) return cached;
-			} else if (!cache) {
+			} else if (!cache && !bypassCache) {
 				const created = new TypeBoxValidatorCache();
-				if (options?.app) tbCaches.set(options.app, created);
+				cache = created;
+				if (appSpecific && app) tbCaches.set(app, created);
 				else tbCache = created;
 			}
 			const validator = new TypeBoxValidator(schema, options, typeof name === "string" ? name : void 0, isIntersectable);
-			if (!isIntersectable && !skipCache && !bypassCache) (options?.app ? tbCaches.get(options.app) : tbCache).set(schema, options?.coerces, validator, normalizeKey, options?.models);
+			if (!isIntersectable && !skipCache && !bypassCache) cache.set(schema, options?.coerces, validator, normalizeKey, options?.models);
 			return validator;
 		}
 		if ("~standard" in schema) return new StandardValidator(schema);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "2.0.0-exp.43",
+	"version": "2.0.0-exp.45",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",