elysia 2.0.0-beta.3 → 2.0.0-beta.4

package/dist/base.mjs

@@ -1,5 +1,5 @@
 import { isBun } from "./universal/constants.mjs";
-import { clonePlainDecorators, clonePlainDeep, coalesceSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed } from "./utils.mjs";
+import { clonePlainDecorators, clonePlainDeep, coalesceSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed, throwLifecycleErrors } from "./utils.mjs";
 import { Ref } from "./type/bridge.mjs";
 import { isProduction } from "./universal/is-production.mjs";
 import { Capture, Compiled, beginCompilerSession, createAotFingerprint, endCompilerSession } from "./compile/aot.mjs";
@@ -7,6 +7,7 @@ import { traceCapabilityRequired, wsCapabilityRequired } from "./generation.mjs"
 import { compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook } from "./compile/handler/index.mjs";
 import { RouteFlag, buildRouteTable, routeRow } from "./route-table.mjs";
 import { BunAdapter } from "./adapter/bun/index.mjs";
+import { clearContextCache } from "./context.mjs";
 import { applyHoc, createFetchHandler } from "./handler/fetch.mjs";
 import { clearAuthoringAnalysisCaches } from "./compile/analysis-cache.mjs";
 import { snapshotHookSchemas, snapshotSchema } from "./schema-snapshot.mjs";
@@ -15,6 +16,23 @@ import Memoirist from "memoirist";
 //#region src/base.ts
 const useNodesBuffer = [];
 const emptyHistory = Object.freeze([]);
+const extCallbackIndexes = /* @__PURE__ */ new WeakMap();
+const mergeExtCallbacks = (target, incoming) => {
+	let index = extCallbackIndexes.get(target);
+	if (!index) {
+		index = {
+			indexedLength: target.length,
+			seen: new Set(target)
+		};
+		extCallbackIndexes.set(target, index);
+	} else for (let i = index.indexedLength; i < target.length; i++) index.seen.add(target[i]);
+	for (const fn of incoming) {
+		if (index.seen.has(fn)) continue;
+		target.push(fn);
+		index.seen.add(fn);
+	}
+	index.indexedLength = target.length;
+};
 const canRegisterLoose = (path, isDynamic) => !isDynamic && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
 /**
 * Every key a single route must answer to, in registration order.
@@ -752,27 +770,12 @@ var Elysia = class Elysia {
 		}
 		if (error) if (ext.error) for (const [code, handler] of error) ext.error.set(code, handler);
 		else ext.error = new Map(error);
-		if (hoc) if (ext.hoc) {
-			const seen = new Set(ext.hoc);
-			for (const fn of hoc) if (!seen.has(fn)) {
-				seen.add(fn);
-				ext.hoc.push(fn);
-			}
-		} else ext.hoc = hoc.slice();
-		if (setup) if (ext.setup) {
-			const seen = new Set(ext.setup);
-			for (const fn of setup) if (!seen.has(fn)) {
-				seen.add(fn);
-				ext.setup.push(fn);
-			}
-		} else ext.setup = setup.slice();
-		if (cleanup) if (ext.cleanup) {
-			const seen = new Set(ext.cleanup);
-			for (const fn of cleanup) if (!seen.has(fn)) {
-				seen.add(fn);
-				ext.cleanup.push(fn);
-			}
-		} else ext.cleanup = cleanup.slice();
+		if (hoc) if (ext.hoc) mergeExtCallbacks(ext.hoc, hoc);
+		else ext.hoc = hoc.slice();
+		if (setup) if (ext.setup) mergeExtCallbacks(ext.setup, setup);
+		else ext.setup = setup.slice();
+		if (cleanup) if (ext.cleanup) mergeExtCallbacks(ext.cleanup, cleanup);
+		else ext.cleanup = cleanup.slice();
 		if (capability) {
 			const target = ext.capability ??= nullObject();
 			if (capability.trace) {
@@ -951,11 +954,11 @@ var Elysia = class Elysia {
 	get modules() {
 		const ready = this.#ready;
 		if (!ready) {
-			if (this.#error !== void 0) return Promise.reject(this.#error);
+			if (this.#error !== void 0) return Promise.reject(this.#error.error);
 			return Promise.resolve();
 		}
 		return ready.then(() => {
-			if (this.#error !== void 0) throw this.#error;
+			if (this.#error !== void 0) throw this.#error.error;
 			if (this.#ready && this.#ready !== ready) return this.modules;
 		});
 	}
@@ -970,13 +973,13 @@ var Elysia = class Elysia {
 			if (plugin) try {
 				this.use(plugin);
 			} catch (err) {
-				this.#error ??= err;
+				this.#error ??= { error: err };
 				console.error(err);
 			}
 		}).finally(() => {
 			this.#pending--;
 		}).then(() => {}, (err) => {
-			this.#error ??= err;
+			this.#error ??= { error: err };
 			console.error(err);
 		}).finally(() => this.#tryDrain(next));
 		this.#ready = next;
@@ -985,10 +988,20 @@ var Elysia = class Elysia {
 	#tryDrain(sentinel) {
 		if (this.#pending > 0) return;
 		if (this.#ready !== sentinel) return;
+		const previousCompiled = this.#compiled;
+		const previousJitColdRemaining = this.#jitColdRemaining;
 		this.#ready = void 0;
+		this.#compiled = void 0;
 		this.#fetchFn = void 0;
 		this.#routerBuilt = false;
-		this.#buildRouter(false);
+		clearContextCache(this);
+		try {
+			this.#buildRouter(false);
+		} catch (error) {
+			this.#compiled = previousCompiled;
+			this.#jitColdRemaining = previousJitColdRemaining;
+			this.#error ??= { error };
+		}
 	}
 	#add(method, path, hookOrFn, fn, hasHook = fn !== void 0) {
 		if (this["~Prefix"]) path = joinPath(this["~Prefix"], path);
@@ -1208,20 +1221,22 @@ var Elysia = class Elysia {
 	}
 	handler(index, immediate, route, precomputedStatic, aliases, table) {
 		if (this.#compiled?.[index]) return this.#compiled[index];
-		const compiled = this.#compiled ??= new Array(table?.length ?? this["~routes"].length);
+		const indexedTable = table ?? (this.#routerBuilt ? this["~routeTable"] : void 0);
+		const compiled = this.#compiled ??= new Array(indexedTable?.length ?? this["~routes"].length);
 		if (immediate ?? this["~config"]?.precompile) {
-			const row = route ?? (table ? routeRow(table, index) : this["~routes"][index]);
+			const row = route ?? (indexedTable ? routeRow(indexedTable, index) : this["~routes"][index]);
+			const exactDuplicate = ((indexedTable?.flags[index] ?? 0) & RouteFlag.ExactDuplicate) !== 0;
 			let handler;
 			try {
-				handler = compileHandler(row, this, precomputedStatic);
+				handler = compileHandler(row, this, precomputedStatic, exactDuplicate && Compiled.hasProgram(this["~programId"]));
 			} catch (error) {
 				throw new Error(`[Elysia] Failed to compile route ${row[0]} ${row[1]}: ${error?.message ?? error}`, { cause: error });
 			}
 			compiled[index] = handler;
-			this.#saveHandler(row[0], row[1], handler);
+			if (indexedTable) this.#satisfyJit(indexedTable, index);
 			return handler;
 		}
-		return this.#jitHandler(index, route ?? (table ? void 0 : this["~routes"][index]), precomputedStatic, aliases, table);
+		return this.#jitHandler(index, route ?? (indexedTable ? void 0 : this["~routes"][index]), precomputedStatic, aliases, indexedTable);
 	}
 	#jitHandler(index, route, precomputedStatic, aliases, table) {
 		if (table !== void 0) this.#jitTable = table;
@@ -1230,12 +1245,58 @@ var Elysia = class Elysia {
 		if (aliases !== void 0) (this.#jitAliases ??= [])[index] = aliases;
 		return (context) => this.#jitDispatch(index, context);
 	}
+	#staticAliases(table, index) {
+		const flags = table.flags[index];
+		if ((flags & (RouteFlag.WS | RouteFlag.Dynamic)) !== 0) return;
+		const path = table.path[index];
+		const method = table.method[index];
+		const needsEncode = (flags & RouteFlag.Encode) !== 0;
+		const registerLoose = this["~config"]?.strictPath !== true && canRegisterLoose(path, false);
+		if (!needsEncode && !registerLoose) return;
+		let explicit;
+		if (registerLoose) {
+			explicit = /* @__PURE__ */ new Set();
+			for (let i = 0; i < table.length; i++) {
+				if (table.method[i] !== method) continue;
+				const declared = table.path[i];
+				explicit.add(declared);
+				if ((table.flags[i] & RouteFlag.Encode) !== 0) explicit.add(encodeURI(declared));
+			}
+		}
+		return {
+			method,
+			paths: expandPaths(path, needsEncode, registerLoose, explicit)
+		};
+	}
+	#releaseJit() {
+		Compiled.release(this["~programId"]);
+		this.#jitColdRemaining = void 0;
+		this.#jitRoute = void 0;
+		this.#jitStatic = void 0;
+		this.#jitAliases = void 0;
+		this.#jitTable = void 0;
+	}
+	#satisfyJit(table, index) {
+		if ((table.flags[index] & RouteFlag.ExactDuplicate) !== 0) return false;
+		if (this.#jitColdRemaining === void 0) {
+			if (this["~generation"] === void 0 && this["~config"]?.precompile !== true && isProduction() && !Capture.isAotBuildEnv()) table.flags[index] |= RouteFlag.JITSatisfied;
+			return false;
+		}
+		if ((table.flags[index] & RouteFlag.JITCold) === 0) return false;
+		table.flags[index] &= ~RouteFlag.JITCold;
+		if (--this.#jitColdRemaining > 0) return false;
+		this.#releaseJit();
+		return true;
+	}
 	#jitDispatch(index, context) {
 		if (this.#compiled[index]) return this.#compiled[index](context);
-		const materialized = this.#jitRoute?.[index] ?? routeRow(this.#jitTable, index);
+		const route = this.#jitRoute?.[index];
+		const table = this.#jitTable ?? this["~routeTable"];
+		const materialized = route ?? routeRow(table, index);
+		const exactDuplicate = ((table?.flags[index] ?? 0) & RouteFlag.ExactDuplicate) !== 0;
 		let handler;
 		try {
-			handler = compileHandler(materialized, this, this.#jitStatic?.[index]);
+			handler = compileHandler(materialized, this, this.#jitStatic?.[index], exactDuplicate && Compiled.hasProgram(this["~programId"]));
 		} catch (error) {
 			const routeError = new Error(`[Elysia] Failed to compile route ${materialized[0]} ${materialized[1]}: ${error?.message ?? error}`, { cause: error });
 			const finalize = this["~finalizeError"];
@@ -1243,24 +1304,15 @@ var Elysia = class Elysia {
 			throw routeError;
 		}
 		this.#compiled[index] = handler;
-		let releasedNow = false;
-		if (this.#jitColdRemaining !== void 0 && --this.#jitColdRemaining === 0) {
-			Compiled.release(this["~programId"]);
-			this.#jitColdRemaining = void 0;
-			releasedNow = true;
+		if (!exactDuplicate) {
+			const aliases = this.#jitAliases?.[index] ?? (table ? this.#staticAliases(table, index) : void 0);
+			if (aliases) {
+				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(materialized[0], materialized[1], handler);
 		}
-		const aliases = this.#jitAliases?.[index];
-		if (aliases) {
-			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(materialized[0], materialized[1], handler);
-		if (releasedNow) {
-			this.#jitRoute = void 0;
-			this.#jitStatic = void 0;
-			this.#jitAliases = void 0;
-			this.#jitTable = void 0;
-		} else {
+		if (!(table ? this.#satisfyJit(table, index) : false)) {
 			if (this.#jitRoute) this.#jitRoute[index] = void 0;
 			if (this.#jitStatic) this.#jitStatic[index] = void 0;
 			if (this.#jitAliases) this.#jitAliases[index] = void 0;
@@ -1401,19 +1453,30 @@ var Elysia = class Elysia {
 			"~wsConfig": this["~wsConfig"]
 		};
 		if (isProduction() && !Capture.isAotBuildEnv()) {
-			if (this["~config"]?.precompile) Compiled.release(this["~programId"]);
+			if (this["~config"]?.precompile) this.#releaseJit();
 			else {
 				const table = this["~routeTable"];
-				const routeCount = table?.length ?? this["~routes"].length;
-				let cold = routeCount;
+				const routeCount = table.length;
 				const compiled = this.#compiled;
-				for (let i = 0; i < routeCount; i++) if (table !== void 0 && (table.flags[i] & RouteFlag.WS) !== 0 || compiled?.[i] !== void 0) cold--;
-				if (cold <= 0) Compiled.release(this["~programId"]);
+				let cold = 0;
+				for (let i = 0; i < routeCount; i++) {
+					const satisfied = (table.flags[i] & RouteFlag.JITSatisfied) !== 0;
+					table.flags[i] &= ~(RouteFlag.JITCold | RouteFlag.JITSatisfied);
+					const flags = table.flags[i];
+					if (satisfied || (flags & (RouteFlag.WS | RouteFlag.ExactDuplicate)) !== 0 || compiled?.[i] !== void 0) continue;
+					table.flags[i] |= RouteFlag.JITCold;
+					cold++;
+				}
+				if (cold === 0) this.#releaseJit();
 				else this.#jitColdRemaining = cold;
 			}
 			clearAuthoringAnalysisCaches(this);
 			if (!this["~ext"]?.macro && !this["~scopeChildren"]) this.#declaredRoutes = void 0;
 		}
+		const ext = this["~ext"];
+		if (ext?.hoc) extCallbackIndexes.delete(ext.hoc);
+		if (ext?.setup) extCallbackIndexes.delete(ext.setup);
+		if (ext?.cleanup) extCallbackIndexes.delete(ext.cleanup);
 	}
 	["~newGeneration"]() {
 		this.#fetchFn = void 0;
@@ -1437,23 +1500,31 @@ var Elysia = class Elysia {
 		const appChain = this["~hookChain"];
 		if (this["~ext"]?.macro || this["~scopeChildren"] || appChain !== void 0 && appChain.refs) for (let i = 0; i < length; i++) this.#assertRouteModelRefs(routeRow(table, i), method[i]);
 		else for (let i = 0; i < length; i++) if (this.#routeMayHaveModelRef(table, i)) this.#assertRouteModelRefs(routeRow(table, i), method[i]);
+		let markDuplicates = false;
 		if (length) {
 			const programId = this["~programId"];
 			if (!Compiled.claim(programId, this["~aotFingerprint"] = createAotFingerprint())) Compiled.assertUncontested(programId);
+			markDuplicates = Compiled.hasProgram(programId) || precompile !== true && isProduction() && !Capture.isAotBuildEnv();
 		}
 		const isLoose = this["~config"]?.strictPath !== true;
+		const collectExplicit = isLoose && table.hasLoose;
 		let explicitPaths;
-		if (isLoose && table.hasLoose) {
-			explicitPaths = /* @__PURE__ */ new Map();
+		if (markDuplicates || collectExplicit) {
+			const seen = /* @__PURE__ */ new Map();
+			if (collectExplicit) explicitPaths = seen;
 			for (let i = 0; i < length; i++) {
 				const m = method[i];
 				const p = path[i];
-				let set = explicitPaths.get(m);
-				if (!set) explicitPaths.set(m, set = /* @__PURE__ */ new Set());
-				set.add(p);
-				if ((flags[i] & RouteFlag.Encode) !== 0) {
+				let paths = seen.get(m);
+				if (!paths) seen.set(m, paths = /* @__PURE__ */ new Map());
+				if (markDuplicates && (flags[i] & RouteFlag.WS) === 0) {
+					const displaced = paths.get(p);
+					if (displaced !== void 0 && displaced >= 0) flags[displaced] |= RouteFlag.ExactDuplicate;
+					paths.set(p, i);
+				} else paths.set(p, -1);
+				if (collectExplicit && (flags[i] & RouteFlag.Encode) !== 0) {
 					const encoded = encodeURI(p);
-					if (encoded !== p) set.add(encoded);
+					if (encoded !== p && !paths.has(encoded)) paths.set(encoded, -1);
 				}
 			}
 		}
@@ -1560,6 +1631,7 @@ var Elysia = class Elysia {
 	* ```
 	*/
 	cleanup(handler) {
+		if (this["~ext"]?.cleanupEpoch?.(handler)) return this;
 		this.#assertMutable("cleanup");
 		const arr = this.#ext.cleanup ??= [];
 		if (Array.isArray(handler)) arr.push(...handler);
@@ -1567,24 +1639,49 @@ var Elysia = class Elysia {
 		return this;
 	}
 	/**
-	* Stop the underlying server (if any), running every `cleanup` handler once
-	* it has stopped. Mirrors `Server.stop()`.
+	* Stop the underlying server (if any), then run every `cleanup` handler.
+	* Omitted and `false` are the same graceful stop: new requests are gated,
+	* tracked WebSockets are settled and active HTTP is drained, then cleanup
+	* runs and the epoch is released. `true` force-closes the transport
+	* instead of draining it, and escalates a graceful stop already in flight.
+	*
+	* Awaiting `stop()` from inside a `setup`, `cleanup` or WebSocket lifecycle
+	* callback is only supported while that callback is still synchronous; the
+	* teardown is waiting on the callback, so after an `await` it can only be
+	* issued as `void app.stop()`.
 	*
-	* @param closeActiveConnections Pass `true` to terminate in-flight
-	*   requests and WebSocket connections immediately. Defaults to
-	*   draining gracefully.
+	* @param closeActiveConnections Pass `true` to terminate active
+	*   transports. Omit (or pass `false`) to drain safely.
 	*/
 	stop(closeActiveConnections) {
+		const stop = this["~ext"]?.stop;
+		if (stop) return stop(closeActiveConnections);
 		const server = this.server;
 		if (!server) return;
-		const r = server.stop?.(closeActiveConnections);
-		this.server = void 0;
+		let result;
+		const errors = [];
+		try {
+			result = server.stop?.(closeActiveConnections);
+		} catch (error) {
+			errors.push(error);
+		} finally {
+			this.server = void 0;
+		}
 		const handlers = this["~ext"]?.cleanup;
-		const fire = handlers ? async () => {
-			for (let i = 0; i < handlers.length; i++) await handlers[i](this);
-		} : void 0;
-		if (r && typeof r.then === "function") return fire ? r.then(fire) : r;
-		return fire?.();
+		if (!errors.length && !handlers?.length) return result && typeof result.then === "function" ? result : void 0;
+		return (async () => {
+			try {
+				await result;
+			} catch (error) {
+				errors.push(error);
+			}
+			if (handlers) for (let i = 0; i < handlers.length; i++) try {
+				await handlers[i](this);
+			} catch (error) {
+				errors.push(error);
+			}
+			throwLifecycleErrors(errors);
+		})();
 	}
 };
 

package/dist/compile/aot-capture.js

@@ -13,8 +13,8 @@ const require_type_validator_frozen_check = require('../type/validator/frozen-ch
 const require_type_validator_custom_error = require('../type/validator/custom-error.js');
 const require_type_validator_exact_mirror = require('../type/validator/exact-mirror.js');
 const require_type_validator_string_codec_aot = require('../type/validator/string-codec-aot.js');
-let typebox_value = require("typebox/value");
 let typebox_schema = require("typebox/schema");
+let typebox_value = require("typebox/value");
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {

package/dist/compile/aot-capture.mjs

@@ -11,8 +11,8 @@ import { buildFrozenCheck } from "../type/validator/frozen-check.mjs";
 import { captureCustomErrors } from "../type/validator/custom-error.mjs";
 import { getExactMirror } from "../type/validator/exact-mirror.mjs";
 import { captureStringCodecEntries } from "../type/validator/string-codec-aot.mjs";
-import { Default } from "typebox/value";
 import { Build, Compile } from "typebox/schema";
+import { Default } from "typebox/value";
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {

package/dist/compile/aot.d.ts

@@ -134,6 +134,7 @@ declare abstract class Compiled {
   static get reconstruct(): ReconstructImpl | undefined;
   static set reconstruct(impl: ReconstructImpl | undefined);
   static getHandler(id: ProgramId | undefined, method: string, path: string): FrozenHandler | undefined;
+  static hasProgram(id: ProgramId | undefined): boolean;
   static getValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): FrozenValidator | undefined;
   static hasValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): boolean;
   static getPlanRebuilder(id?: ProgramId): ((original: unknown, plan: CoercePlan) => any) | undefined;

package/dist/compile/aot.js

@@ -84,6 +84,9 @@ var Compiled = class {
 	static getHandler(id, method, path) {
 		return programFor(id)?.handlers?.[method]?.[path];
 	}
+	static hasProgram(id) {
+		return programFor(id) !== void 0;
+	}
 	static getValidator(method, path, slot, id) {
 		const program = programFor(id);
 		if (!program) return void 0;

package/dist/compile/aot.mjs

@@ -83,6 +83,9 @@ var Compiled = class {
 	static getHandler(id, method, path) {
 		return programFor(id)?.handlers?.[method]?.[path];
 	}
+	static hasProgram(id) {
+		return programFor(id) !== void 0;
+	}
 	static getValidator(method, path, slot, id) {
 		const program = programFor(id);
 		if (!program) return void 0;

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

@@ -32,9 +32,12 @@ interface FrozenRouteValidatorShape {
   cookie?: FrozenSlotValidator;
   response?: Record<number, FrozenSlotValidator>;
 }
+declare const REQUEST_SLOTS: readonly ["body", "headers", "query", "params", "cookie"];
 declare const isStandardSchema: (schema: unknown) => schema is object & Record<"~standard", unknown>;
 declare function mergeSchemasAllStandard(schemas: Array<Record<string, unknown>> | undefined): boolean;
+declare function resolveModelRef(schema: unknown, root: AnyElysia): unknown;
 declare function buildFrozenRouteValidator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): FrozenRouteValidatorShape | undefined;
+declare const isResponseMap: (schema: unknown) => schema is Record<string, unknown>;
 declare function isCapturedBridgeFree(c: CapturedValidator, schema: unknown, coerced?: unknown): boolean;
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isStandardSchema, mergeSchemasAllStandard };
+export { REQUEST_SLOTS, buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isResponseMap, isStandardSchema, mergeSchemasAllStandard, resolveModelRef };

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

@@ -294,7 +294,9 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 	}
 	const response = hook?.response;
 	if (response) {
-		const statuses = isResponseMap(response) ? response : { 200: response };
+		const resolved = resolveModelRef(response, root);
+		if (!resolved) return void 0;
+		const statuses = isResponseMap(resolved) ? resolved : { 200: resolved };
 		const responseOut = {};
 		for (const status in statuses) {
 			const raw = statuses[status];
@@ -313,7 +315,7 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 	}
 	return out;
 }
-const isResponseMap = (schema) => !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
+const isResponseMap = (schema) => schema !== null && typeof schema === "object" && !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
 const capturedBothMarker = (() => ({}));
 function isCapturedBridgeFree(c, schema, coerced = schema) {
 	if (typeof schema === "string") return false;
@@ -340,10 +342,13 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 }
 
 //#endregion
+exports.REQUEST_SLOTS = REQUEST_SLOTS;
 exports.buildFrozenRouteValidator = buildFrozenRouteValidator;
 exports.isBridgeNotInitialized = isBridgeNotInitialized;
 exports.isCapturedBridgeFree = isCapturedBridgeFree;
 exports.isCompactDiagnosable = isCompactDiagnosable;
 exports.isCompactWalkable = isCompactWalkable;
+exports.isResponseMap = isResponseMap;
 exports.isStandardSchema = isStandardSchema;
-exports.mergeSchemasAllStandard = mergeSchemasAllStandard;
+exports.mergeSchemasAllStandard = mergeSchemasAllStandard;
+exports.resolveModelRef = resolveModelRef;

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

@@ -293,7 +293,9 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 	}
 	const response = hook?.response;
 	if (response) {
-		const statuses = isResponseMap(response) ? response : { 200: response };
+		const resolved = resolveModelRef(response, root);
+		if (!resolved) return void 0;
+		const statuses = isResponseMap(resolved) ? resolved : { 200: resolved };
 		const responseOut = {};
 		for (const status in statuses) {
 			const raw = statuses[status];
@@ -312,7 +314,7 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 	}
 	return out;
 }
-const isResponseMap = (schema) => !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
+const isResponseMap = (schema) => schema !== null && typeof schema === "object" && !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
 const capturedBothMarker = (() => ({}));
 function isCapturedBridgeFree(c, schema, coerced = schema) {
 	if (typeof schema === "string") return false;
@@ -339,4 +341,4 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 }
 
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isStandardSchema, mergeSchemasAllStandard };
+export { REQUEST_SLOTS, buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isResponseMap, isStandardSchema, mergeSchemasAllStandard, resolveModelRef };

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

@@ -14,6 +14,6 @@ declare function clearHandlerAnalysisCaches(root: AnyElysia): void;
 declare const localMacroRoot: (instance: AnyElysia, root: AnyElysia) => AnyElysia;
 declare function buildNativeStaticResponse(route: InternalRoute, root: AnyElysia): Response | undefined;
 declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia): AnyLocalHook | undefined;
-declare function compileHandler(route: InternalRoute, root: AnyElysia, precomputedStatic?: Response): CompiledHandler;
+declare function compileHandler(route: InternalRoute, root: AnyElysia, precomputedStatic?: Response, liveOnly?: boolean): CompiledHandler;
 //#endregion
 export { buildNativeStaticResponse, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };

package/dist/compile/handler/index.js

@@ -274,14 +274,14 @@ function isContextFreeHandler(handler) {
 	const source = Function.prototype.toString.call(handler);
 	return isBareArrow.test(source) && !isSucroseOpaque.test(source);
 }
-function compileHandler(route, root, precomputedStatic) {
+function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 	let [_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope] = route;
 	const frozenRoot = require_generation.frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
 	const method = _method;
 	const mountMeta = typeof handler === "function" ? handler["~mount"] : void 0;
 	if (mountMeta) handler = resolveMountHandler(mountMeta, path);
-	const reconstructed = require_compile_aot.Compiled.getHandler(frozenRoot["~programId"], method, path);
+	const reconstructed = liveOnly ? void 0 : require_compile_aot.Compiled.getHandler(frozenRoot["~programId"], method, path);
 	if (reconstructed && !precomputedStatic && typeof handler === "function" && !frozenRoot["~ext"]?.macro && !require_generation.frozenRootOf(localMacroRoot(macroScope ?? instance, root))["~ext"]?.macro && !reconstructNeedsHookState(reconstructed.a)) return reconstructed.f(handler, ...require_compile_handler_params.resolveHandlerParams(reconstructed.a, {
 		root,
 		parse: adapter.parse,
@@ -302,7 +302,7 @@ function compileHandler(route, root, precomputedStatic) {
 		toArray("afterResponse", hook);
 		toArray("error", hook);
 	}
-	const buildValidator = () => hook ? require_compile_handler_reconstruct.Reconstrct.validator(hook, root, method, path) : void 0;
+	const buildValidator = () => hook ? require_compile_handler_reconstruct.Reconstrct.validator(hook, root, method, path, liveOnly) : void 0;
 	if (handler instanceof Error) {
 		const error = handler;
 		handler = () => {

package/dist/compile/handler/index.mjs

@@ -273,14 +273,14 @@ function isContextFreeHandler(handler) {
 	const source = Function.prototype.toString.call(handler);
 	return isBareArrow.test(source) && !isSucroseOpaque.test(source);
 }
-function compileHandler(route, root, precomputedStatic) {
+function compileHandler(route, root, precomputedStatic, liveOnly = false) {
 	let [_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope] = route;
 	const frozenRoot = frozenRootOf(root);
 	const adapter = frozenRoot["~config"]?.adapter ?? defaultAdapter;
 	const method = _method;
 	const mountMeta = typeof handler === "function" ? handler["~mount"] : void 0;
 	if (mountMeta) handler = resolveMountHandler(mountMeta, path);
-	const reconstructed = Compiled.getHandler(frozenRoot["~programId"], method, path);
+	const reconstructed = liveOnly ? void 0 : Compiled.getHandler(frozenRoot["~programId"], method, path);
 	if (reconstructed && !precomputedStatic && typeof handler === "function" && !frozenRoot["~ext"]?.macro && !frozenRootOf(localMacroRoot(macroScope ?? instance, root))["~ext"]?.macro && !reconstructNeedsHookState(reconstructed.a)) return reconstructed.f(handler, ...resolveHandlerParams(reconstructed.a, {
 		root,
 		parse: adapter.parse,
@@ -301,7 +301,7 @@ function compileHandler(route, root, precomputedStatic) {
 		toArray("afterResponse", hook);
 		toArray("error", hook);
 	}
-	const buildValidator = () => hook ? Reconstrct.validator(hook, root, method, path) : void 0;
+	const buildValidator = () => hook ? Reconstrct.validator(hook, root, method, path, liveOnly) : void 0;
 	if (handler instanceof Error) {
 		const error = handler;
 		handler = () => {

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

@@ -4,7 +4,7 @@ import { AnyElysia } from "../../base.js";
 
 //#region src/compile/handler/reconstruct.d.ts
 declare abstract class Reconstrct {
-  static validator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): any;
+  static validator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string, liveOnly?: boolean): any;
   static cookie(hook: AnyLocalHook, root: AnyElysia): CompiledCookieConfig;
   static trace(hook: AnyLocalHook, root: AnyElysia): any;
 }

package/dist/compile/handler/reconstruct.js

@@ -7,9 +7,9 @@ const require_compile_handler_frozen_validator = require('./frozen-validator.js'
 
 //#region src/compile/handler/reconstruct.ts
 var Reconstrct = class {
-	static validator(hook, root, method, path) {
+	static validator(hook, root, method, path, liveOnly = false) {
 		const frozenRoot = require_generation.frozenRootOf(root);
-		if (!require_type_bridge.isBridgeLive()) {
+		if (!liveOnly && !require_type_bridge.isBridgeLive()) {
 			const frozen = require_compile_handler_frozen_validator.buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 		}
@@ -20,7 +20,7 @@ var Reconstrct = class {
 				normalize: frozenRoot["~config"]?.normalize,
 				sanitize: frozenRoot["~config"]?.sanitize,
 				schemas: hook?.schemas,
-				aot: {
+				aot: liveOnly ? void 0 : {
 					method,
 					path
 				},
@@ -28,6 +28,7 @@ var Reconstrct = class {
 			});
 		} catch (error) {
 			if (!require_compile_handler_frozen_validator.isBridgeNotInitialized(error)) throw error;
+			if (liveOnly) throw new Error("Duplicate route must compile JIT but the TypeBox bridge is not initialized", { cause: error });
 			const frozen = require_compile_handler_frozen_validator.buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 			throw error;

package/dist/compile/handler/reconstruct.mjs

@@ -6,9 +6,9 @@ import { buildFrozenRouteValidator, isBridgeNotInitialized } from "./frozen-vali
 
 //#region src/compile/handler/reconstruct.ts
 var Reconstrct = class {
-	static validator(hook, root, method, path) {
+	static validator(hook, root, method, path, liveOnly = false) {
 		const frozenRoot = frozenRootOf(root);
-		if (!isBridgeLive()) {
+		if (!liveOnly && !isBridgeLive()) {
 			const frozen = buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 		}
@@ -19,7 +19,7 @@ var Reconstrct = class {
 				normalize: frozenRoot["~config"]?.normalize,
 				sanitize: frozenRoot["~config"]?.sanitize,
 				schemas: hook?.schemas,
-				aot: {
+				aot: liveOnly ? void 0 : {
 					method,
 					path
 				},
@@ -27,6 +27,7 @@ var Reconstrct = class {
 			});
 		} catch (error) {
 			if (!isBridgeNotInitialized(error)) throw error;
+			if (liveOnly) throw new Error("Duplicate route must compile JIT but the TypeBox bridge is not initialized", { cause: error });
 			const frozen = buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 			throw error;