elysia 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/compile/aot-capture.js

@@ -70,7 +70,7 @@ function validateMergeSource(schema, source) {
 		} catch {
 			return false;
 		}
-		if (require_type_validator_default_precompute.canonical(expected) !== require_type_validator_default_precompute.canonical(actual)) return false;
+		if (require_type_validator_default_precompute.stableStringify(expected) !== require_type_validator_default_precompute.stableStringify(actual)) return false;
 	}
 	return true;
 }
@@ -99,7 +99,7 @@ function validateObjectDefault(schema, pod) {
 			return false;
 		}
 		const actual = require_type_validator_default_precompute.applyPrecomputed(pod, structuredClone(probe));
-		if (require_type_validator_default_precompute.canonical(expected) !== require_type_validator_default_precompute.canonical(actual)) return false;
+		if (require_type_validator_default_precompute.stableStringify(expected) !== require_type_validator_default_precompute.stableStringify(actual)) return false;
 	}
 	return true;
 }

package/dist/compile/aot-capture.mjs

@@ -1,10 +1,11 @@
+// @bun
 import { nullObject } from "../utils.mjs";
 import { env } from "../universal/env.mjs";
 import { Capture, CompilerState, aotActivationError, captureImpl, setCaptureImpl } from "./aot.mjs";
 import { isCapturedBridgeFree, isCompactWalkable } from "./handler/frozen-validator.mjs";
 import { buildCoercedFromPlan, captureCoercePlan } from "../type/coerce.mjs";
 import { isAsyncPredicate } from "../type/elysia/file-type.mjs";
-import { applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, canonical, createMergerFromSource, setDefaultProbeImpl, verifyPreallocatableDefault } from "../type/validator/default-precompute.mjs";
+import { applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, createMergerFromSource, setDefaultProbeImpl, stableStringify, verifyPreallocatableDefault } from "../type/validator/default-precompute.mjs";
 import { collectExternals } from "./aot-reconstruct.mjs";
 import { captureMirrorCodecs, captureMirrorUnions, installReconstructImpl } from "./aot-emit.mjs";
 import { buildFrozenCheck } from "../type/validator/frozen-check.mjs";
@@ -68,7 +69,7 @@ function validateMergeSource(schema, source) {
 		} catch {
 			return false;
 		}
-		if (canonical(expected) !== canonical(actual)) return false;
+		if (stableStringify(expected) !== stableStringify(actual)) return false;
 	}
 	return true;
 }
@@ -97,7 +98,7 @@ function validateObjectDefault(schema, pod) {
 			return false;
 		}
 		const actual = applyPrecomputed(pod, structuredClone(probe));
-		if (canonical(expected) !== canonical(actual)) return false;
+		if (stableStringify(expected) !== stableStringify(actual)) return false;
 	}
 	return true;
 }

package/dist/compile/aot-emit.js

@@ -54,29 +54,28 @@ function externalsMatch(a, b) {
 */
 function alignBuildExternals(build, schema) {
 	const variables = build.external.variables;
-	const canonical = require_compile_aot_reconstruct.collectExternals(schema);
+	const expected = require_compile_aot_reconstruct.collectExternals(schema);
 	const id = build.external.identifier;
 	if (!/^[A-Za-z_$][\w$]*$/.test(id)) return;
 	const slots = [];
 	let j = 0;
-	let same = variables.length === canonical.length;
-	for (let i = 0; i < variables.length; i++) {
-		const v = variables[i];
-		const c = canonical[j];
-		if (j < canonical.length && externalsMatch([c], [v])) slots.push(`${id}[${j++}]`);
+	let same = variables.length === expected.length;
+	for (const v of variables) {
+		const c = expected[j];
+		if (j < expected.length && externalsMatch([c], [v])) slots.push(`${id}[${j++}]`);
 		else if (Array.isArray(c) && c.length === 1 && c[0] === v) {
 			slots.push(`${id}[${j++}][0]`);
 			same = false;
 		} else return;
 	}
-	if (j !== canonical.length) return;
+	if (j !== expected.length) return;
 	if (same) return build;
 	return {
 		...build,
 		functions: [`${id}=[${slots.join(",")}]`, ...build.functions],
 		external: {
 			identifier: id,
-			variables: canonical
+			variables: expected
 		}
 	};
 }

package/dist/compile/aot-emit.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { Compiled } from "./aot.mjs";
 import { Reconstruct, collectExternals, collectMirrorCodecs, collectMirrorUnions } from "./aot-reconstruct.mjs";
 
@@ -53,29 +54,28 @@ function externalsMatch(a, b) {
 */
 function alignBuildExternals(build, schema) {
 	const variables = build.external.variables;
-	const canonical = collectExternals(schema);
+	const expected = collectExternals(schema);
 	const id = build.external.identifier;
 	if (!/^[A-Za-z_$][\w$]*$/.test(id)) return;
 	const slots = [];
 	let j = 0;
-	let same = variables.length === canonical.length;
-	for (let i = 0; i < variables.length; i++) {
-		const v = variables[i];
-		const c = canonical[j];
-		if (j < canonical.length && externalsMatch([c], [v])) slots.push(`${id}[${j++}]`);
+	let same = variables.length === expected.length;
+	for (const v of variables) {
+		const c = expected[j];
+		if (j < expected.length && externalsMatch([c], [v])) slots.push(`${id}[${j++}]`);
 		else if (Array.isArray(c) && c.length === 1 && c[0] === v) {
 			slots.push(`${id}[${j++}][0]`);
 			same = false;
 		} else return;
 	}
-	if (j !== canonical.length) return;
+	if (j !== expected.length) return;
 	if (same) return build;
 	return {
 		...build,
 		functions: [`${id}=[${slots.join(",")}]`, ...build.functions],
 		external: {
 			identifier: id,
-			variables: canonical
+			variables: expected
 		}
 	};
 }

package/dist/compile/aot-reconstruct.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { ELYSIA_TYPES } from "../type/constants.mjs";
 import { EMPTY_EXTERNALS } from "./aot.mjs";
 
@@ -18,8 +19,8 @@ import { EMPTY_EXTERNALS } from "./aot.mjs";
 const isValueLikeExternal = (v) => v === null || typeof v !== "object" && typeof v !== "function";
 /**
 * Rebuild TypeBox `External[]` for `schema` in `BuildSchema` traversal order:
-* object (patternProperties → properties) → array (items) → string (pattern) →
-* guard → const → enum → not/allOf/anyOf/oneOf → refine LAST.
+* object (patternProperties \u2192 properties) \u2192 array (items) \u2192 string (pattern) \u2192
+* guard \u2192 const \u2192 enum \u2192 not/allOf/anyOf/oneOf \u2192 refine LAST.
 */
 function collectExternals(schema, out = []) {
 	if (!schema || typeof schema !== "object") return out;

package/dist/compile/aot.d.ts

@@ -1,6 +1,6 @@
 import { CoerceNode } from "../type/coerce-plan.js";
 //#region src/compile/aot.d.ts
-declare const AOT_MANIFEST_FORMAT = 6;
+declare const AOT_MANIFEST_FORMAT = 7;
 interface AotFingerprint {
   abi: string;
 }
@@ -126,7 +126,7 @@ interface ReconstructImpl {
   reconstructInnerCodecs(ic: NonNullable<FrozenValidator['ic']>, schema: any): void;
 }
 declare function reconstruct(): ReconstructImpl;
-declare const aotDrift: (method: string, path: string) => string;
+declare const aotDriftMessage: (method: string, path: string) => string;
 declare function warnAotDrift(method: string, path: string): void;
 declare abstract class Compiled {
   static register(manifest: CompiledProgramRegistration): void;
@@ -282,4 +282,4 @@ interface CaptureImpl {
 declare let captureImpl: CaptureImpl | undefined;
 declare function setCaptureImpl(impl: CaptureImpl | undefined): void;
 //#endregion
-export { AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, aotDrift, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };
+export { AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, aotDriftMessage, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };

package/dist/compile/aot.js

@@ -4,8 +4,8 @@ const require_universal_env = require('../universal/env.js');
 const require_package = require('../package.js');
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 6;
-const AOT_ABI = `${require_package.version}:${6}`;
+const AOT_MANIFEST_FORMAT = 7;
+const AOT_ABI = `${require_package.version}:${7}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
@@ -38,13 +38,13 @@ function reconstruct() {
 	return reconstructImpl;
 }
 let drifted;
-const aotDrift = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
+const aotDriftMessage = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
 function warnAotDrift(method, path) {
 	const key = method + " " + path;
 	if (drifted?.has(key)) return;
 	drifted ??= /* @__PURE__ */ new Set();
 	drifted.add(key);
-	console.warn(aotDrift(method, path) + ", compiled at runtime");
+	console.warn(aotDriftMessage(method, path) + ", compiled at runtime");
 }
 let registered;
 let claimed;
@@ -194,7 +194,7 @@ exports.Compiled = Compiled;
 exports.CompilerState = CompilerState;
 exports.EMPTY_EXTERNALS = EMPTY_EXTERNALS;
 exports.aotActivationError = aotActivationError;
-exports.aotDrift = aotDrift;
+exports.aotDriftMessage = aotDriftMessage;
 exports.beginCompilerSession = beginCompilerSession;
 Object.defineProperty(exports, 'captureImpl', {
   enumerable: true,

package/dist/compile/aot.mjs

@@ -1,10 +1,11 @@
+// @bun
 import { nullObject } from "../utils.mjs";
 import { env } from "../universal/env.mjs";
 import { version } from "../package.mjs";
 
 //#region src/compile/aot.ts
-const AOT_MANIFEST_FORMAT = 6;
-const AOT_ABI = `${version}:${6}`;
+const AOT_MANIFEST_FORMAT = 7;
+const AOT_ABI = `${version}:${7}`;
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
 const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
@@ -37,13 +38,13 @@ function reconstruct() {
 	return reconstructImpl;
 }
 let drifted;
-const aotDrift = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
+const aotDriftMessage = (method, path) => `[elysia-aot] ${method} ${path} differs from the AOT build`;
 function warnAotDrift(method, path) {
 	const key = method + " " + path;
 	if (drifted?.has(key)) return;
 	drifted ??= /* @__PURE__ */ new Set();
 	drifted.add(key);
-	console.warn(aotDrift(method, path) + ", compiled at runtime");
+	console.warn(aotDriftMessage(method, path) + ", compiled at runtime");
 }
 let registered;
 let claimed;
@@ -187,4 +188,4 @@ function setCaptureImpl(impl) {
 }
 
 //#endregion
-export { AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, aotDrift, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };
+export { AOT_MANIFEST_FORMAT, Capture, Compiled, CompilerState, EMPTY_EXTERNALS, aotActivationError, aotDriftMessage, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl, warnAotDrift };

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

@@ -64,11 +64,8 @@ interface DescribeRouteInput {
   isStaticResponse: boolean;
   isPromiseHandler: boolean;
 }
-/**
- * Route descriptors, keyed by root instance → `METHOD path` → descriptor
- * Populated on each JIT compile, and read only by tests and introspection
- */
 declare const routeDescriptors: WeakMap<AnyElysia, Map<string, RouteDescriptor>>;
+declare function releaseAnalysisCaches(): void;
 declare function describeRoute(input: DescribeRouteInput): RouteCompileState;
 //#endregion
-export { DescribeRouteInput, RouteCompileState, RouteDescriptor, describeRoute, routeDescriptors };
+export { DescribeRouteInput, RouteCompileState, RouteDescriptor, describeRoute, releaseAnalysisCaches, routeDescriptors };

package/dist/compile/handler/descriptor.js

@@ -9,11 +9,11 @@ const require_sucrose = require('../../sucrose.js');
 const require_compile_handler_reconstruct = require('./reconstruct.js');
 
 //#region src/compile/handler/descriptor.ts
-/**
-* Route descriptors, keyed by root instance → `METHOD path` → descriptor
-* Populated on each JIT compile, and read only by tests and introspection
-*/
 const routeDescriptors = /* @__PURE__ */ new WeakMap();
+function releaseAnalysisCaches() {
+	require_sucrose.clearSucroseCache();
+	require_compile_utils.resetMayReturnPromiseCache();
+}
 const noTracePhases = /* @__PURE__ */ new Set();
 const lifecycleMayReturnPromise = (handlers) => handlers ? Array.isArray(handlers) ? handlers.some(require_compile_utils.mayReturnPromise) : require_compile_utils.mayReturnPromise(handlers) : false;
 const compactPrefixInference = /* @__PURE__ */ new WeakMap();
@@ -81,9 +81,9 @@ function describeRoute(input) {
 	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 cookieValiIsAsync = vali?.cookie && isAsyncValidator(vali.cookie);
 	const needsCookie = !!vali?.cookie || !!inference.cookie;
-	const cookieConfig = needsCookie ? require_compile_handler_reconstruct.Reconstrct.cookie(hook, root) : void 0;
+	const cookieConfig = needsCookie ? require_compile_handler_reconstruct.Reconstruct.cookie(hook, root) : void 0;
 	const hasCookieSign = !!cookieConfig?.hasSign;
 	const syncCookieSign = hasCookieSign && require_cookie_crypto.hasSyncHmac && !require_compile_aot.Capture.isCapturing();
 	const asyncCookieSign = hasCookieSign && !syncCookieSign;
@@ -105,22 +105,16 @@ function describeRoute(input) {
 	const phaseOn = (phase) => hasTrace && (tracePhases === null || tracePhases.has(phase));
 	const hasAnyPhase = hasTrace && (tracePhases === null || tracePhases.size > 0);
 	const traceHandleOn = phaseOn("handle");
-	let responseValiAsync = false;
-	if (vali?.response) {
-		for (const code in vali.response) if (isAsyncValidator(vali.response[code])) {
-			responseValiAsync = true;
-			break;
-		}
-	}
+	const responseValiAsync = !!vali?.response && [...vali.response.values()].some(isAsyncValidator);
 	const handlerIsAsync = isHandleFunction && require_compile_utils.isAsyncFunction(handler);
 	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || require_compile_utils.isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error));
 	const afterResponseForcesAsync = hasStaticAfterResponse && require_compile_utils.isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
 	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && require_compile_utils.mayReturnPromise(handler);
 	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && require_compile_utils.mayReturnPromise(handler);
 	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle) || lifecycleMayReturnPromise(hook.transform) || lifecycleMayReturnPromise(hook.afterHandle) || lifecycleMayReturnPromise(hook.mapResponse));
-	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync;
+	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValiIsAsync;
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
-	const tail = isAsync && !(hasErrorHook && hasMapResponse) && !hasBody && !handlerIsAsync && !asyncCookieSign && !responseValiAsync && !hasTrace && !beforeHandlePrefix?.length && !bodyValiIsAsync && !headersValiIsAsync && !paramsValiIsAsync && !queryValiIsAsync && !cookieValidIsAsync && !(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)));
+	const tail = isAsync && !(hasErrorHook && hasMapResponse) && !hasBody && !handlerIsAsync && !asyncCookieSign && !responseValiAsync && !hasTrace && !beforeHandlePrefix?.length && !bodyValiIsAsync && !headersValiIsAsync && !paramsValiIsAsync && !queryValiIsAsync && !cookieValiIsAsync && !(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)));
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
 	const syncAfterResponse = hasAfterResponse && !isAsync && !hasTrace && !hasErrorHook;
 	const handlerKind = isHandleFunction ? "function" : isStaticResponse ? "response" : isPromiseHandler ? "promise" : "static-value";
@@ -131,7 +125,7 @@ function describeRoute(input) {
 		descriptor: {
 			handlerKind,
 			async: !!isAsync,
-			tail,
+			tail: !!tail,
 			responseMode,
 			hasBeforeHandle,
 			hasAfterHandle,
@@ -147,7 +141,7 @@ function describeRoute(input) {
 			headersValiIsAsync: !!headersValiIsAsync,
 			paramsValiIsAsync: !!paramsValiIsAsync,
 			queryValiIsAsync: !!queryValiIsAsync,
-			cookieValiIsAsync: !!cookieValidIsAsync,
+			cookieValiIsAsync: !!cookieValiIsAsync,
 			responseValiAsync,
 			hasCookieSign,
 			syncCookieSign,
@@ -171,4 +165,5 @@ function describeRoute(input) {
 
 //#endregion
 exports.describeRoute = describeRoute;
+exports.releaseAnalysisCaches = releaseAnalysisCaches;
 exports.routeDescriptors = routeDescriptors;

package/dist/compile/handler/descriptor.mjs

@@ -1,18 +1,19 @@
+// @bun
 import { isNotEmpty } from "../../utils.mjs";
 import { hasSyncHmac } from "../../cookie/crypto.mjs";
 import { Capture } from "../aot.mjs";
 import { frozenRootOf, resolvedTraceOf, traceCapabilityRequired } from "../../generation.mjs";
-import { isAsyncFunction, isAsyncLifecycle, mayReturnPromise } from "../utils.mjs";
+import { isAsyncFunction, isAsyncLifecycle, mayReturnPromise, resetMayReturnPromiseCache } from "../utils.mjs";
 import { JITProbe } from "../jit-probe.mjs";
-import { mergeInference, sucrose } from "../../sucrose.mjs";
-import { Reconstrct } from "./reconstruct.mjs";
+import { clearSucroseCache, mergeInference, sucrose } from "../../sucrose.mjs";
+import { Reconstruct } from "./reconstruct.mjs";
 
 //#region src/compile/handler/descriptor.ts
-/**
-* Route descriptors, keyed by root instance → `METHOD path` → descriptor
-* Populated on each JIT compile, and read only by tests and introspection
-*/
 const routeDescriptors = /* @__PURE__ */ new WeakMap();
+function releaseAnalysisCaches() {
+	clearSucroseCache();
+	resetMayReturnPromiseCache();
+}
 const noTracePhases = /* @__PURE__ */ new Set();
 const lifecycleMayReturnPromise = (handlers) => handlers ? Array.isArray(handlers) ? handlers.some(mayReturnPromise) : mayReturnPromise(handlers) : false;
 const compactPrefixInference = /* @__PURE__ */ new WeakMap();
@@ -80,9 +81,9 @@ function describeRoute(input) {
 	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 cookieValiIsAsync = vali?.cookie && isAsyncValidator(vali.cookie);
 	const needsCookie = !!vali?.cookie || !!inference.cookie;
-	const cookieConfig = needsCookie ? Reconstrct.cookie(hook, root) : void 0;
+	const cookieConfig = needsCookie ? Reconstruct.cookie(hook, root) : void 0;
 	const hasCookieSign = !!cookieConfig?.hasSign;
 	const syncCookieSign = hasCookieSign && hasSyncHmac && !Capture.isCapturing();
 	const asyncCookieSign = hasCookieSign && !syncCookieSign;
@@ -104,22 +105,16 @@ function describeRoute(input) {
 	const phaseOn = (phase) => hasTrace && (tracePhases === null || tracePhases.has(phase));
 	const hasAnyPhase = hasTrace && (tracePhases === null || tracePhases.size > 0);
 	const traceHandleOn = phaseOn("handle");
-	let responseValiAsync = false;
-	if (vali?.response) {
-		for (const code in vali.response) if (isAsyncValidator(vali.response[code])) {
-			responseValiAsync = true;
-			break;
-		}
-	}
+	const responseValiAsync = !!vali?.response && [...vali.response.values()].some(isAsyncValidator);
 	const handlerIsAsync = isHandleFunction && isAsyncFunction(handler);
 	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error));
 	const afterResponseForcesAsync = hasStaticAfterResponse && isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
 	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && mayReturnPromise(handler);
 	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && mayReturnPromise(handler);
 	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle) || lifecycleMayReturnPromise(hook.transform) || lifecycleMayReturnPromise(hook.afterHandle) || lifecycleMayReturnPromise(hook.mapResponse));
-	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync;
+	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || traceForcesAsync || afterResponseForcesAsync || handlerResultObserved || lifecycleForcesAsync || asyncCookieSign || responseValiAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValiIsAsync;
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
-	const tail = isAsync && !(hasErrorHook && hasMapResponse) && !hasBody && !handlerIsAsync && !asyncCookieSign && !responseValiAsync && !hasTrace && !beforeHandlePrefix?.length && !bodyValiIsAsync && !headersValiIsAsync && !paramsValiIsAsync && !queryValiIsAsync && !cookieValidIsAsync && !(hook && (isAsyncLifecycle(hook.afterHandle) || isAsyncLifecycle(hook.beforeHandle) || isAsyncLifecycle(hook.transform) || isAsyncLifecycle(hook.mapResponse) || isAsyncLifecycle(hook.error)));
+	const tail = isAsync && !(hasErrorHook && hasMapResponse) && !hasBody && !handlerIsAsync && !asyncCookieSign && !responseValiAsync && !hasTrace && !beforeHandlePrefix?.length && !bodyValiIsAsync && !headersValiIsAsync && !paramsValiIsAsync && !queryValiIsAsync && !cookieValiIsAsync && !(hook && (isAsyncLifecycle(hook.afterHandle) || isAsyncLifecycle(hook.beforeHandle) || isAsyncLifecycle(hook.transform) || isAsyncLifecycle(hook.mapResponse) || isAsyncLifecycle(hook.error)));
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
 	const syncAfterResponse = hasAfterResponse && !isAsync && !hasTrace && !hasErrorHook;
 	const handlerKind = isHandleFunction ? "function" : isStaticResponse ? "response" : isPromiseHandler ? "promise" : "static-value";
@@ -130,7 +125,7 @@ function describeRoute(input) {
 		descriptor: {
 			handlerKind,
 			async: !!isAsync,
-			tail,
+			tail: !!tail,
 			responseMode,
 			hasBeforeHandle,
 			hasAfterHandle,
@@ -146,7 +141,7 @@ function describeRoute(input) {
 			headersValiIsAsync: !!headersValiIsAsync,
 			paramsValiIsAsync: !!paramsValiIsAsync,
 			queryValiIsAsync: !!queryValiIsAsync,
-			cookieValiIsAsync: !!cookieValidIsAsync,
+			cookieValiIsAsync: !!cookieValiIsAsync,
 			responseValiAsync,
 			hasCookieSign,
 			syncCookieSign,
@@ -169,4 +164,4 @@ function describeRoute(input) {
 }
 
 //#endregion
-export { describeRoute, routeDescriptors };
+export { describeRoute, releaseAnalysisCaches, routeDescriptors };

package/dist/compile/handler/frozen-validator.d.ts

@@ -1,5 +1,5 @@
-import { AnyLocalHook, HTTPMethod } from "../../types.js";
 import { CapturedValidator, FrozenValidator } from "../aot.js";
+import { AnyLocalHook, HTTPMethod } from "../../types.js";
 import { AnyElysia } from "../../base.js";
 
 //#region src/compile/handler/frozen-validator.d.ts
@@ -22,7 +22,7 @@ interface FrozenRouteValidatorShape {
   query?: FrozenSlotValidator;
   params?: FrozenSlotValidator;
   cookie?: FrozenSlotValidator;
-  response?: Record<number, FrozenSlotValidator>;
+  response?: Map<number, FrozenSlotValidator>;
 }
 declare const REQUEST_SLOTS: readonly ["body", "headers", "query", "params", "cookie"];
 declare const isStandardSchema: (schema: unknown) => schema is object & Record<"~standard", unknown>;

package/dist/compile/handler/frozen-validator.js

@@ -243,19 +243,19 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 		const resolved = resolveModelRef(response, root);
 		if (!resolved) return void 0;
 		const statuses = isResponseMap(resolved) ? resolved : { 200: resolved };
-		const responseOut = {};
+		const responseOut = /* @__PURE__ */ new Map();
 		for (const status in statuses) {
 			const raw = statuses[status];
 			if (!raw) continue;
 			const schema = resolveModelRef(raw, root);
 			if (!schema) return void 0;
 			if (isStandardSchema(schema)) {
-				responseOut[status] = new require_validator_index.StandardValidator(schema);
+				responseOut.set(+status, new require_validator_index.StandardValidator(schema));
 				continue;
 			}
 			const frozen = require_compile_aot.Compiled.getValidator(method, path, `response:${status}`, root["~programId"]);
 			if (!frozen || !isBridgeFreeComplete(frozen, schema, schema)) return void 0;
-			responseOut[status] = new FrozenSlotValidator(frozen, schema, schema, normalize);
+			responseOut.set(+status, new FrozenSlotValidator(frozen, schema, schema, normalize));
 		}
 		out.response = responseOut;
 	}

package/dist/compile/handler/frozen-validator.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { nullObject } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../../type/constants.mjs";
 import { ValidationError } from "../../error.mjs";
@@ -242,19 +243,19 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 		const resolved = resolveModelRef(response, root);
 		if (!resolved) return void 0;
 		const statuses = isResponseMap(resolved) ? resolved : { 200: resolved };
-		const responseOut = {};
+		const responseOut = /* @__PURE__ */ new Map();
 		for (const status in statuses) {
 			const raw = statuses[status];
 			if (!raw) continue;
 			const schema = resolveModelRef(raw, root);
 			if (!schema) return void 0;
 			if (isStandardSchema(schema)) {
-				responseOut[status] = new StandardValidator(schema);
+				responseOut.set(+status, new StandardValidator(schema));
 				continue;
 			}
 			const frozen = Compiled.getValidator(method, path, `response:${status}`, root["~programId"]);
 			if (!frozen || !isBridgeFreeComplete(frozen, schema, schema)) return void 0;
-			responseOut[status] = new FrozenSlotValidator(frozen, schema, schema, normalize);
+			responseOut.set(+status, new FrozenSlotValidator(frozen, schema, schema, normalize));
 		}
 		out.response = responseOut;
 	}

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

@@ -1,9 +1,11 @@
 import { ChainNode } from "../../utils.js";
 import { AnyLocalHook, AppHook, CompiledHandler, InternalRoute } from "../../types.js";
 import { AnyElysia } from "../../base.js";
+import { releaseAnalysisCaches } from "./descriptor.js";
 import { setCaptureHeaderShorthand } from "./jit.js";
 
 //#region src/compile/handler/index.d.ts
+declare function runIntrospect(hook: any): void;
 declare function resolveLocalHook(scope: AnyElysia, hook: Partial<AnyLocalHook> | undefined, root?: AnyElysia): Partial<AnyLocalHook> | undefined;
 declare function resolveWSLocalHook(scope: AnyElysia, hook: Partial<AnyLocalHook> | undefined, root?: AnyElysia): Partial<AnyLocalHook> | undefined;
 /**
@@ -18,4 +20,4 @@ declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLoc
 declare function routeShape(hook: AnyLocalHook | undefined, handler: unknown, root: AnyElysia): number | undefined;
 declare function compileHandler(route: InternalRoute, root: AnyElysia, liveOnly?: boolean): CompiledHandler;
 //#endregion
-export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, routeShape, setCaptureHeaderShorthand };
+export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, releaseAnalysisCaches, resolveLocalHook, resolveWSLocalHook, routeShape, runIntrospect, setCaptureHeaderShorthand };