elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/base.js

@@ -9,8 +9,8 @@ const require_generation = require('./generation.js');
 const require_compile_handler_index = require('./compile/handler/index.js');
 const require_route_table = require('./route-table.js');
 const require_adapter_bun_index = require('./adapter/bun/index.js');
+const require_context = require('./context.js');
 const require_handler_fetch = require('./handler/fetch.js');
-const require_compile_analysis_cache = require('./compile/analysis-cache.js');
 const require_schema_snapshot = require('./schema-snapshot.js');
 let memoirist = require("memoirist");
 memoirist = require_runtime.__toESM(memoirist);
@@ -18,27 +18,105 @@ memoirist = require_runtime.__toESM(memoirist);
 //#region src/base.ts
 const useNodesBuffer = [];
 const emptyHistory = Object.freeze([]);
+let mutationEpoch = 0;
+const extCallbackIndexes = /* @__PURE__ */ new WeakMap();
+const mergeExtCallbacks = (target, incoming) => {
+	if (!target) return incoming.slice();
+	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;
+	return target;
+};
+const markStoredSingletons = (table, source) => {
+	if (!table) return;
+	for (const key in source) require_utils.markSingletons(table[key]);
+};
 const canRegisterLoose = (path, isDynamic) => !isDynamic && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
+const isSingleSchema = (value) => "~kind" in value || "~elyAcl" in value || "~standard" in value;
+const isSchemaValue = (value) => {
+	if (value == null || typeof value === "string") return true;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	return isSingleSchema(value) || typeof value.Check === "function";
+};
+const toModel = (key, value) => {
+	if ("~standard" in value) return value;
+	value = require_schema_snapshot.snapshotSchema(value);
+	value.$id ??= key;
+	return value;
+};
+const hookKeys = new Set([
+	...require_utils.schemaProperties,
+	...require_utils.eventProperties,
+	"detail",
+	"tags"
+]);
+const assertScope = (scope) => {
+	if (scope !== void 0 && scope !== "local" && scope !== "plugin" && scope !== "global") throw new Error(`[Elysia] Invalid hook scope ${JSON.stringify(scope)}, expected 'local', 'plugin' or 'global' (1.x 'scoped' is 'plugin')`);
+};
+const hasHookKeys = (value) => {
+	for (const key in value) if (hookKeys.has(key)) return true;
+	return false;
+};
+function assertSchemaShape(hook, where) {
+	for (const key in hook) {
+		if (!require_utils.schemaProperties.has(key)) continue;
+		const value = hook[key];
+		if (isSchemaValue(value)) continue;
+		if (key === "response" && require_utils.isPlainObject(value)) {
+			let isStatusMap = true;
+			for (const status in value) if (status !== "default" && isNaN(+status) || !isSchemaValue(value[status])) {
+				isStatusMap = false;
+				break;
+			}
+			if (isStatusMap) continue;
+		}
+		throw new Error(`[Elysia] ${where}: "${key}" is not a schema — use t.Object({ ... })`);
+	}
+}
+/**
+* Every key a single route must answer to, in registration order.
+*
+* `registerLoose` is the caller's call, not this helper's: HTTP gates it on
+* `canRegisterLoose` because its lookup retries the trailing slash, while WS
+* has no such retry and must own both directions outright
+*/
+function expandPaths(path, needsEncode, registerLoose, explicit) {
+	const variants = [path];
+	if (needsEncode) {
+		const encoded = encodeURI(path);
+		if (encoded !== path) variants.push(encoded);
+	}
+	if (!registerLoose) return variants;
+	const paths = [];
+	for (let v = 0; v < variants.length; v++) {
+		const p = variants[v];
+		paths.push(p);
+		const loose = require_utils.getLoosePath(p);
+		if (loose !== p && !explicit?.has(loose)) paths.push(loose);
+	}
+	return paths;
+}
 var Elysia = class Elysia {
-	#hasPlugin;
-	#hasGlobal;
-	#ready;
-	#pending = 0;
-	#error;
-	#hash;
-	#childrenHash;
-	#scopeParent;
-	#pluginMacros;
-	#macroBaseline;
-	#declaredRoutes;
-	#routeSources;
 	get history() {
-		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
-		if (!this.#declaredRoutes?.length) return emptyHistory;
-		const history = new Array(this.#declaredRoutes.length);
-		for (let sequence = 0; sequence < this.#declaredRoutes.length; sequence++) {
-			const route = this.#declaredRoutes[sequence];
-			const source = this.#routeSources?.[sequence];
+		const generation = this["~generation"];
+		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedHistory !== void 0) return this.cachedHistory;
+		if (this.declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
+		if (!this.declaredRoutes?.length) return emptyHistory;
+		const history = new Array(this.declaredRoutes.length);
+		for (let sequence = 0; sequence < this.declaredRoutes.length; sequence++) {
+			const route = this.declaredRoutes[sequence];
+			const source = this.routeSources?.[sequence];
 			history[sequence] = Object.freeze({
 				sequence,
 				method: route[0],
@@ -46,12 +124,17 @@ var Elysia = class Elysia {
 				...source === void 0 ? {} : { source }
 			});
 		}
-		return Object.freeze(history);
+		Object.freeze(history);
+		if (this.#isCacheable) {
+			this.#cacheRoutes(generation);
+			this.cachedHistory = history;
+		}
+		return history;
 	}
 	get ["~routes"]() {
-		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
-		if (!this.#declaredRoutes?.length) return [];
-		const routes = this.#declaredRoutes;
+		if (this.declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
+		if (!this.declaredRoutes?.length) return [];
+		const routes = this.declaredRoutes;
 		if (!this["~ext"]?.macro && !this["~scopeChildren"]) return routes;
 		return routes.map((r) => {
 			const localHook = r[4];
@@ -74,17 +157,16 @@ var Elysia = class Elysia {
 		this.#registerRoute(route);
 		return this;
 	}
-	#compiled;
-	#jitColdRemaining;
-	#jitTable;
-	#jitRoute;
-	#jitStatic;
-	#jitAliases;
+	get ["~programId"]() {
+		return this;
+	}
 	constructor(config) {
+		this._pending = 0;
+		this.routerBuilt = false;
 		/**
 		* ! Don't tune
 		*
-		* Interesting JSC internal: These `= undefined` are load-bearing
+		* Interesting JSC internal: These `= undefined` shouldn't be removed
 		*
 		* Inline slots live inside the object cell, so JSC must pick their
 		* count at allocation before any initializer runs
@@ -102,7 +184,8 @@ var Elysia = class Elysia {
 		* Don't omitted field either for monomorphic access
 		*
 		* @see test/memory/instance-footprint.test.ts
-		* Est. Overflow 37 -> 21 = butterfly 64 -> 32 slots = 738B -> 450B/instance
+		* Est. overflow 37 -> 21 = butterfly 64 -> 32 slots = 738B -> 450B;
+		* reusing the app as its program identity brings the current cell to ~386B.
 		**/
 		this["~config"] = config;
 		this["~ext"] = void 0;
@@ -122,18 +205,24 @@ var Elysia = class Elysia {
 		this["~introspect"] = void 0;
 		this["~scopeChild"] = void 0;
 		this["~scopeChildren"] = void 0;
-		this["~programId"] = require_compile_aot.createProgramId();
 		if (config) {
 			const { prefix, name, seed, adapter } = config;
 			this["~Prefix"] = prefix ? prefix.charCodeAt(0) === 47 ? prefix : `/${prefix}` : void 0;
-			if (name) this.#hash = require_utils.fnv1a(seed ? `${name}_${typeof seed === "object" ? JSON.stringify(seed, require_utils.serializeMacroSeed) : seed}` : name);
+			if (name) this.hash = require_utils.fnv1a(seed ? `${name}_${typeof seed === "object" ? JSON.stringify(seed, require_utils.serializeMacroSeed) : seed}` : name);
 			if (adapter?.setup) this.#useFn(adapter.setup);
 		} else this["~Prefix"] = void 0;
 	}
+	/**
+	* Every registered route with its merged hooks.
+	* Development shares a frozen cache. Production rebuilds the list so its
+	* metadata can be released after startup.
+	*/
 	get routes() {
-		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
-		if (!this.#declaredRoutes?.length) return [];
-		return this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
+		const generation = this["~generation"];
+		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedRoutes !== void 0) return this.cachedRoutes;
+		if (this.declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
+		if (!this.declaredRoutes?.length) return [];
+		const routes = this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
 			const merged = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, this, macroScope);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
 				if (!entry?.response) continue;
@@ -147,20 +236,36 @@ var Elysia = class Elysia {
 				hooks: merged
 			};
 		});
+		if (this.#isCacheable && !require_universal_is_production.isProduction()) {
+			Object.freeze(routes);
+			this.#cacheRoutes(generation);
+			this.cachedRoutes = routes;
+		}
+		return routes;
 	}
 	decorate(typeOrNameOrDecorators, nameOrDecorators, value) {
-		switch (arguments.length) {
-			case 1: return this.#decorate("append", "", typeOrNameOrDecorators);
+		return this.#setField("decorator", arguments.length, typeOrNameOrDecorators, nameOrDecorators, value);
+	}
+	#setField(field, length, typeOrName, nameOrValue, value) {
+		let as = "append";
+		let name = "";
+		switch (length) {
+			case 1:
+				value = typeOrName;
+				break;
 			case 2:
-				if (typeOrNameOrDecorators === "append" || typeOrNameOrDecorators === "override") return this.#decorate(typeOrNameOrDecorators, "", nameOrDecorators);
-				return this.#decorate("append", typeOrNameOrDecorators, nameOrDecorators);
-			case 3: return this.#decorate(typeOrNameOrDecorators, nameOrDecorators, value);
+				if (typeOrName === "append" || typeOrName === "override") as = typeOrName;
+				else name = typeOrName;
+				value = nameOrValue;
+				break;
+			case 3:
+				as = typeOrName;
+				name = nameOrValue;
+				break;
+			default: return this;
 		}
-		return this;
-	}
-	#setField(field, as, name, value) {
-		if (this["~generation"] !== void 0) this.#assertMutable(field === "store" ? "state" : "decorate");
-		const ext = this.#ext;
+		this.#assertMutable(field === "store" ? "state" : "decorate");
+		const ext = this.ext;
 		const fresh = !ext[field];
 		const target = ext[field] ??= require_utils.nullObject();
 		switch (typeof value) {
@@ -169,69 +274,71 @@ var Elysia = class Elysia {
 				if (!name && require_utils.isEmpty(value)) return this;
 				if (name) {
 					const existing = target[name];
-					if (!fresh && name in target && !!existing && typeof existing === "object" && !Array.isArray(existing) && !Array.isArray(value)) target[name] = require_utils.mergeDeep(target[name], value, void 0, as === "override");
+					if (existing && typeof existing === "object" && !Array.isArray(existing) && !Array.isArray(value)) target[name] = require_utils.mergeDeep(target[name], value, void 0, as === "override");
 					else target[name] = value;
+					require_utils.markSingletons(target[name]);
 					return this;
 				}
 				if (fresh) Object.assign(target, value);
 				else ext[field] = require_utils.mergeDeep(target, value, void 0, as === "override");
+				markStoredSingletons(ext[field], value);
 				return this;
 			case "function":
 				if (name) {
-					if (as === "override" || !(name in target)) target[name] = value;
-				} else ext[field] = value(target);
+					if (as === "override" || !(name in target)) {
+						target[name] = value;
+						require_utils.markSingletons(value);
+					}
+				} else {
+					ext[field] = value(target);
+					markStoredSingletons(ext[field], ext[field]);
+				}
 				return this;
 			default:
 				if (as === "override" || !(name in target)) target[name] = value;
 				return this;
 		}
 	}
-	#decorate(as, name, value) {
-		return this.#setField("decorator", as, name, value);
-	}
 	state(typeOrNameOrStore, nameOrStore, value) {
-		switch (arguments.length) {
-			case 1: return this.#state("append", "", typeOrNameOrStore);
-			case 2:
-				if (typeOrNameOrStore === "append" || typeOrNameOrStore === "override") return this.#state(typeOrNameOrStore, "", nameOrStore);
-				return this.#state("append", typeOrNameOrStore, nameOrStore);
-			case 3: return this.#state(typeOrNameOrStore, nameOrStore, value);
-		}
-		return this;
-	}
-	#state(as, name, value) {
-		return this.#setField("store", as, name, value);
+		return this.#setField("store", arguments.length, typeOrNameOrStore, nameOrStore, value);
 	}
 	headers(headers) {
 		this.#assertMutable("headers");
-		const ext = this.#ext;
-		if (ext.headers) Object.assign(ext.headers, headers);
-		else ext.headers = Object.assign(require_utils.nullObject(), headers);
+		const ext = this.ext;
+		ext.headers = Object.assign(ext.headers ?? require_utils.nullObject(), headers);
 		return this;
 	}
 	#on(type, fn, scope = this["~config"]?.as) {
-		if (this["~generation"] !== void 0) this.#assertMutable("on" + (type[0].toUpperCase() + type.slice(1)));
+		this.#assertMutable(type);
+		assertScope(scope);
 		const added = require_utils.nullObject();
 		added[type] = fn;
 		if (type === "trace") this["~hasTrace"] = true;
+		this.#link(added, scope, this);
+		this.#tagOrigin(fn);
+		return this;
+	}
+	#link(added, scope, owner, mayRef = true, propagated) {
 		const parent = this["~hookChain"];
-		this["~hookChain"] = {
+		const refs = parent !== void 0 && parent.refs || mayRef && Elysia.#hookHasString(added);
+		this["~hookChain"] = propagated ? {
+			added,
+			parent,
+			refs,
+			scope,
+			propagated,
+			owner
+		} : {
 			added,
 			parent,
-			refs: parent !== void 0 && parent.refs || Elysia.#hookHasString(added),
+			refs,
 			scope,
-			owner: this
+			owner
 		};
-		if (scope === "plugin") this.#hasPlugin = true;
-		else if (scope === "global") this.#hasGlobal = true;
-		if (this.#hash !== void 0) {
-			const tag = (f) => {
-				if (typeof f === "function" && !require_utils.fnOrigin.has(f)) require_utils.fnOrigin.set(f, this.#hash);
-			};
-			if (Array.isArray(fn)) for (const f of fn) tag(f);
-			else tag(fn);
-		}
-		return this;
+	}
+	#tagOrigin(value) {
+		if (this.hash === void 0) return;
+		for (const fn of Array.isArray(value) ? value : [value]) if (typeof fn === "function" && !require_utils.fnOrigin.has(fn)) require_utils.fnOrigin.set(fn, this.hash);
 	}
 	#onBranch(type, scopeOrFn, fn) {
 		return fn ? this.#on(type, fn, scopeOrFn) : this.#on(type, scopeOrFn);
@@ -248,7 +355,7 @@ var Elysia = class Elysia {
 	}
 	parser(name, fn) {
 		this.#assertMutable("parser");
-		const ext = this.#ext;
+		const ext = this.ext;
 		const parsers = ext.parser ??= require_utils.nullObject();
 		parsers[name] = fn;
 		return this;
@@ -269,9 +376,7 @@ var Elysia = class Elysia {
 	*/
 	setup(handler) {
 		this.#assertMutable("setup");
-		const arr = this.#ext.setup ??= [];
-		if (Array.isArray(handler)) arr.push(...handler);
-		else arr.push(handler);
+		(this.ext.setup ??= []).push(...[].concat(handler));
 		return this;
 	}
 	transform(scopeOrFn, fn) {
@@ -281,26 +386,18 @@ var Elysia = class Elysia {
 		return this.#onBranch("beforeHandle", scopeOrFn, fn);
 	}
 	derive(scopeOrFn, fn) {
-		const result = this.#onBranch("beforeHandle", scopeOrFn, fn);
-		const node = this["~hookChain"];
-		if (node?.added) {
-			const d = fn ?? scopeOrFn;
-			const entries = node.added["~deriveEntries"] ??= [];
-			if (Array.isArray(d)) for (const f of d) entries.push(f);
-			else entries.push(d);
-		}
-		return result;
+		return this.#derive(scopeOrFn, fn);
+	}
+	#derive(scopeOrFn, fn, map) {
+		this.#onBranch("beforeHandle", scopeOrFn, fn);
+		const d = fn ?? scopeOrFn;
+		const entries = this["~hookChain"].added["~deriveEntries"] ??= [];
+		if (Array.isArray(d)) for (const f of d) entries.push(map ? map(f) : f);
+		else entries.push(map ? map(d) : d);
+		return this;
 	}
 	mapDerive(scopeOrFn, fn) {
-		const result = this.#onBranch("beforeHandle", scopeOrFn, fn);
-		const node = this["~hookChain"];
-		if (node?.added) {
-			const d = fn ?? scopeOrFn;
-			const entries = node.added["~deriveEntries"] ??= [];
-			if (Array.isArray(d)) for (const f of d) entries.push(require_utils.mapDeriveEntry(f));
-			else entries.push(require_utils.mapDeriveEntry(d));
-		}
-		return result;
+		return this.#derive(scopeOrFn, fn, require_utils.mapDeriveEntry);
 	}
 	afterHandle(scopeOrFn, fn) {
 		return this.#onBranch("afterHandle", scopeOrFn, fn);
@@ -315,26 +412,19 @@ var Elysia = class Elysia {
 		this.#assertMutable("error");
 		switch (arguments.length) {
 			case 1:
-				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object") {
-					for (const [code, ErrorClass] of Object.entries(scopeOrFnOrError)) if (typeof ErrorClass === "function") (this.#ext.error ??= /* @__PURE__ */ new Map()).set(ErrorClass, code);
-					return this;
-				}
+				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object") return this;
 				return this.#onBranch("error", scopeOrFnOrError);
 			case 2:
-				if (typeof scopeOrFnOrError === "function" && (scopeOrFnOrError === Error || scopeOrFnOrError.prototype instanceof Error)) {
-					const run = typeof fnOrError === "function" ? fnOrError : () => fnOrError;
-					(this.#ext.error ??= /* @__PURE__ */ new Map()).set(scopeOrFnOrError, scopeOrFnOrError.name);
-					return this.#onBranch("error", require_utils.createErrorEventHandler(run, scopeOrFnOrError));
-				}
+				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#errorClass(scopeOrFnOrError, fnOrError);
 				return this.#onBranch("error", scopeOrFnOrError, fnOrError);
-			case 3: {
-				const run = typeof fn === "function" ? fn : () => fn;
-				(this.#ext.error ??= /* @__PURE__ */ new Map()).set(fnOrError, fnOrError.name);
-				return this.#onBranch("error", scopeOrFnOrError, require_utils.createErrorEventHandler(run, fnOrError));
-			}
+			case 3: return this.#errorClass(fnOrError, fn, scopeOrFnOrError);
 		}
 		return this;
 	}
+	#errorClass(ErrorClass, fn, scope) {
+		const run = typeof fn === "function" ? fn : () => fn;
+		return this.#on("error", require_utils.createErrorEventHandler(run, ErrorClass), scope);
+	}
 	trace(scopeOrFn, fn) {
 		return this.#onBranch("trace", scopeOrFn, fn);
 	}
@@ -353,21 +443,13 @@ var Elysia = class Elysia {
 			if (node.scope !== "global") {
 				node.scope = scope;
 				node.propagated = false;
-				for (const key in node.added) {
-					if (!require_utils.eventProperties.has(key)) continue;
-					const v = node.added[key];
-					const fns = Array.isArray(v) ? v : [v];
-					for (const fn of fns) {
-						if (typeof fn !== "function") continue;
-						if (scope === "plugin") this.#hasPlugin = true;
-						else this.#hasGlobal = true;
-					}
-				}
 			}
 			node = node.parent;
 		}
 	}
 	guard() {
+		const maybeHook = typeof arguments[0] === "string" ? arguments[1] : arguments[0];
+		if (maybeHook && typeof maybeHook === "object" && "as" in maybeHook && maybeHook.as !== void 0) throw new Error(`[elysia] guard({ as: '${maybeHook.as}' }) was removed in 2.0. Pass the scope as the first argument instead: guard('${maybeHook.as === "scoped" ? "plugin" : maybeHook.as}', { ... }). To combine a guard schema with a route's own schema for the same slot, add schema: 'merge'.`);
 		if (arguments.length === 1) return this.#guard("local", arguments[0]);
 		if (arguments.length === 2) {
 			if (typeof arguments[1] === "function") return this.group("", arguments[0], arguments[1]);
@@ -376,21 +458,12 @@ var Elysia = class Elysia {
 		return this;
 	}
 	#guard(scope, hook) {
+		assertScope(scope);
+		if (hook) assertSchemaShape(hook, ".guard()");
 		hook = require_schema_snapshot.snapshotHookSchemas(hook);
 		require_utils.hookToGuard(hook);
-		const trackFn = (fn) => {
-			if (typeof fn !== "function") return;
-			if (this.#hash !== void 0 && !require_utils.fnOrigin.has(fn)) require_utils.fnOrigin.set(fn, this.#hash);
-		};
-		for (const key in hook) {
-			if (!require_utils.eventProperties.has(key)) continue;
-			const raw = hook[key];
-			if (raw === null) continue;
-			if (Array.isArray(raw)) for (const fn of raw) trackFn(fn);
-			else trackFn(raw);
-		}
-		if (hook.derive) if (Array.isArray(hook.derive)) for (const fn of hook.derive) trackFn(fn);
-		else trackFn(hook.derive);
+		for (const key in hook) if (require_utils.eventProperties.has(key)) this.#tagOrigin(hook[key]);
+		this.#tagOrigin(hook.derive);
 		this.#pushHook(hook, scope);
 		return this;
 	}
@@ -409,7 +482,7 @@ var Elysia = class Elysia {
 			prefix
 		} : void 0);
 		child["~scopeChild"] = true;
-		child.#scopeParent = this;
+		child.scopeParent = this;
 		(this["~scopeChildren"] ??= []).push(child);
 		const src = this["~ext"];
 		if (src) {
@@ -432,7 +505,7 @@ var Elysia = class Elysia {
 		this.#use(child);
 		return this;
 	}
-	get #ext() {
+	get ext() {
 		return this["~ext"] ??= require_utils.nullObject();
 	}
 	["~resolvedCapability"](kind) {
@@ -451,9 +524,9 @@ var Elysia = class Elysia {
 		return provider;
 	}
 	#ensureMacroTable() {
-		const ext = this.#ext;
+		const ext = this.ext;
 		if (ext.macro) return ext.macro;
-		const parent = this["~scopeChild"] ? this.#scopeParent : void 0;
+		const parent = this["~scopeChild"] ? this.scopeParent : void 0;
 		ext.macro = parent ? Object.create(parent.#ensureMacroTable()) : require_utils.nullObject();
 		return ext.macro;
 	}
@@ -461,41 +534,30 @@ var Elysia = class Elysia {
 		this.#assertMutable("guard");
 		let hook = _hook;
 		if (hook.derive) {
-			const promoted = require_utils.nullObject();
-			for (const key of Object.keys(hook)) {
-				if (key === "derive") continue;
-				promoted[key] = hook[key];
-			}
-			const extras = [];
-			if (hook.derive) if (Array.isArray(hook.derive)) extras.push(...hook.derive);
-			else extras.push(hook.derive);
+			const { derive, ...rest } = hook;
+			const extras = [].concat(derive);
+			hook = Object.assign(require_utils.nullObject(), rest);
 			if (extras.length) {
-				const existing = promoted.beforeHandle;
-				if (existing) promoted.beforeHandle = Array.isArray(existing) ? [...extras, ...existing] : [...extras, existing];
-				else promoted.beforeHandle = extras;
-				(promoted["~deriveEntries"] ??= []).push(...extras);
+				hook.beforeHandle = extras.concat(hook.beforeHandle || []);
+				(hook["~deriveEntries"] ??= []).push(...extras);
 			}
-			hook = promoted;
 		}
 		if (hook.trace) this["~hasTrace"] = true;
-		const parent = this["~hookChain"];
-		this["~hookChain"] = {
-			added: hook,
-			parent,
-			refs: parent !== void 0 && parent.refs || Elysia.#hookHasString(hook),
-			scope,
-			owner: this
-		};
+		this.#link(hook, scope, this);
 		return this;
 	}
-	macro(macro) {
+	macro(macro, definition) {
 		this.#assertMutable("macro");
 		if (typeof macro === "function") throw new Error("use `.macro({ name: fn })` instead of `.macro(fn)`");
+		if (definition != null || typeof macro === "string") throw new Error("[Elysia] .macro(name, definition) was removed in 2.0 — use .macro({ [name]: definition })");
 		const m = this.#ensureMacroTable();
-		const baseline = this.#macroBaseline;
+		const baseline = this.macroBaseline;
 		for (const key in macro) {
-			if (typeof macro[key] === "object") macro[key] = require_utils.hookToGuard(macro[key]);
-			if (this.#hash !== void 0 && !require_utils.macroOrigin.has(macro[key])) require_utils.macroOrigin.set(macro[key], this.#hash);
+			if (typeof macro[key] === "object") {
+				if (macro[key]) assertSchemaShape(macro[key], `.macro(${key})`);
+				macro[key] = require_utils.hookToGuard(macro[key]);
+			}
+			if (this.hash !== void 0 && !require_utils.macroOrigin.has(macro[key])) require_utils.macroOrigin.set(macro[key], this.hash);
 			if (baseline?.has(key) && key in m && m[key] !== macro[key]) throw new Error(`[Elysia] Macro "${key}" can be only define once`);
 		}
 		Object.assign(m, macro);
@@ -518,7 +580,7 @@ var Elysia = class Elysia {
 				const seedSource = hook.seed ?? value;
 				const seedType = typeof seedSource;
 				let seedKey;
-				if (seedSource === null || seedSource === void 0 || seedType !== "object") seedKey = key + "\0" + seedType + "\0" + String(seedSource);
+				if (seedSource === null || seedType !== "object") seedKey = key + "\0" + seedType + "\0" + String(seedSource);
 				else try {
 					seedKey = key + "\0object\0" + JSON.stringify(seedSource, require_utils.serializeMacroSeed);
 				} catch {
@@ -533,7 +595,7 @@ var Elysia = class Elysia {
 			}
 			for (const k in hook) {
 				const v = hook[k];
-				if (k === "seed") continue;
+				if (k === "seed" || k === "meta" || k === "$type") continue;
 				if (k === "introspect") {
 					v?.(input);
 					delete input[key];
@@ -582,11 +644,9 @@ var Elysia = class Elysia {
 					insertions.set(k, at + added.length);
 				} else if (k in input) {
 					if (Array.isArray(input[k])) {
-						if (Array.isArray(v)) {
-							for (const item of v) if (!input[k].some((e) => e === item)) input[k].unshift(item);
-						} else if (!input[k].some((item) => item === v)) input[k].unshift(v);
+						for (const item of Array.isArray(v) ? v : [v]) if (!input[k].includes(item)) input[k].unshift(item);
 					} else if (input[k] !== v) input[k] = [v, input[k]];
-				} else input[k] = require_utils.eventProperties.has(k) ? Array.isArray(v) ? v.slice() : [v] : Array.isArray(v) ? v.slice() : v;
+				} else input[k] = Array.isArray(v) ? v.slice() : v;
 				delete input[key];
 			}
 		}
@@ -594,7 +654,7 @@ var Elysia = class Elysia {
 	}
 	use(app) {
 		if (!app) return this;
-		if (this["~generation"] !== void 0) this.#assertMutable("use");
+		this.#assertMutable("use");
 		if (typeof app === "function") return this.#useFn(app);
 		if (typeof app.then === "function") return this.#useAsync(app);
 		if (Array.isArray(app)) {
@@ -608,21 +668,37 @@ var Elysia = class Elysia {
 		return this;
 	}
 	#useFn(app) {
-		const prevBaseline = this.#macroBaseline;
+		const prevBaseline = this.macroBaseline;
 		const baseline = /* @__PURE__ */ new Set();
 		const existingMacro = this["~ext"]?.macro;
 		if (existingMacro) for (const k in existingMacro) baseline.add(k);
-		this.#macroBaseline = baseline;
+		this.macroBaseline = baseline;
+		let wantSnapshot = false;
+		let settled = false;
+		let beforeMacro;
+		queueMicrotask(() => {
+			if (wantSnapshot && !settled) {
+				beforeMacro = new Map(Object.entries(this["~ext"]?.macro ?? require_utils.nullObject()));
+				(this.macroSnapshots ??= /* @__PURE__ */ new Set()).add(beforeMacro);
+			}
+		});
 		const result = app(this);
-		this.#macroBaseline = prevBaseline;
+		this.macroBaseline = prevBaseline;
 		if (result && typeof result.then === "function") {
-			const beforeMacro = new Map(Object.entries(this["~ext"]?.macro ?? require_utils.nullObject()));
-			return this.#useAsync(result.then((value) => {
+			wantSnapshot = true;
+			return this.#useAsync(Promise.resolve(result).then((value) => {
+				settled = true;
+				if (!beforeMacro) return value;
+				this.macroSnapshots?.delete(beforeMacro);
 				const after = this["~ext"]?.macro;
 				if (after) {
 					for (const [k, def] of Object.entries(after)) if (beforeMacro.get(k) !== def) throw new Error(`Macro ${k} can only run in sync plugin`);
 				}
 				return value;
+			}, (err) => {
+				settled = true;
+				if (beforeMacro) this.macroSnapshots?.delete(beforeMacro);
+				throw err;
 			}));
 		}
 		return this;
@@ -633,17 +709,17 @@ var Elysia = class Elysia {
 		if (app["~introspect"] || config?.introspect) this["~introspect"] = true;
 		const name = config?.name;
 		if (name) {
-			const hash = app.#hash;
-			if (this.#childrenHash?.has(hash)) return;
-			this.#childrenHash ??= /* @__PURE__ */ new Set();
-			this.#childrenHash.add(hash);
+			const hash = app.hash;
+			if (this.childrenHash?.has(hash)) return;
+			this.childrenHash ??= /* @__PURE__ */ new Set();
+			this.childrenHash.add(hash);
 			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(hash);
 		}
-		if (app.#childrenHash) addedByThisCall = this.#absorbChildrenHash(app, addedByThisCall);
+		if (app.childrenHash) addedByThisCall = this.#absorbChildrenHash(app, addedByThisCall);
 		if (app["~ext"]) this.#assertMacroUnique(app, addedByThisCall);
 		if (app["~hasTrace"]) this["~hasTrace"] = true;
-		if (app.#declaredRoutes === void 0 && app["~routeTable"]?.length) app.#materializeDeclaredRoutes();
-		if (app.#declaredRoutes?.length) {
+		if (app.declaredRoutes === void 0 && app["~routeTable"]?.length) app.#materializeDeclaredRoutes();
+		if (app.declaredRoutes?.length) {
 			if (app["~hasWS"]) this["~hasWS"] = true;
 			this.#emitChildRoutes(app, this["~hookChain"], name);
 		}
@@ -653,17 +729,17 @@ var Elysia = class Elysia {
 		}
 		const hookChain = app["~hookChain"];
 		if (app["~ext"]) this.#absorbExt(app);
-		if (app.#hasPlugin || app.#hasGlobal || hookChain) this.#propagateHooks(app, hookChain, addedByThisCall);
+		if (hookChain) this.#propagateHooks(app, hookChain, addedByThisCall);
 	}
 	#absorbChildrenHash(app, addedByThisCall) {
-		const incoming = app.#childrenHash;
-		if (this.#childrenHash) for (const h of incoming) {
-			if (this.#childrenHash.has(h)) continue;
-			this.#childrenHash.add(h);
+		const incoming = app.childrenHash;
+		if (this.childrenHash) for (const h of incoming) {
+			if (this.childrenHash.has(h)) continue;
+			this.childrenHash.add(h);
 			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(h);
 		}
 		else {
-			this.#childrenHash = new Set(incoming);
+			this.childrenHash = new Set(incoming);
 			addedByThisCall = new Set(incoming);
 		}
 		return addedByThisCall;
@@ -682,7 +758,7 @@ var Elysia = class Elysia {
 			if (existing === incoming) continue;
 			const origin = require_utils.macroOrigin.get(existing);
 			if (origin !== void 0 && origin === require_utils.macroOrigin.get(incoming)) continue;
-			if (addedByThisCall) for (const h of addedByThisCall) this.#childrenHash.delete(h);
+			if (addedByThisCall) for (const h of addedByThisCall) this.childrenHash.delete(h);
 			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
 	}
@@ -695,80 +771,54 @@ var Elysia = class Elysia {
 	* Keep the cold blocks in their own frames.
 	*/
 	#absorbExt(app) {
-		const { decorator, store, headers, models, parser, macro, error, hoc, setup, cleanup, capability } = app["~ext"];
+		const { decorator, store, headers, models, parser, macro, hoc, setup, cleanup, capability } = app["~ext"];
 		const ext = this["~ext"] ??= require_utils.nullObject();
-		if (decorator) if (ext.decorator) require_utils.mergeDeep(ext.decorator, decorator, void 0, true, false, void 0, { map: void 0 });
-		else ext.decorator = require_utils.clonePlainDecorators(decorator);
-		if (store) if (ext.store) require_utils.mergeDeep(ext.store, store);
-		else ext.store = Object.assign(require_utils.nullObject(), store);
-		if (headers) if (ext.headers) Object.assign(ext.headers, headers);
-		else ext.headers = Object.assign(require_utils.nullObject(), headers);
-		if (models) if (ext.models) Object.assign(ext.models, models);
-		else ext.models = Object.assign(require_utils.nullObject(), models);
-		if (parser) if (ext.parser) Object.assign(ext.parser, parser);
-		else ext.parser = Object.assign(require_utils.nullObject(), parser);
+		if (decorator) {
+			if (ext.decorator) require_utils.mergeDeep(ext.decorator, decorator, void 0, true, false, void 0, { map: void 0 });
+			else ext.decorator = require_utils.clonePlainDecorators(decorator);
+			markStoredSingletons(ext.decorator, decorator);
+		}
+		if (store) {
+			if (ext.store) require_utils.mergeDeep(ext.store, store);
+			else ext.store = Object.assign(require_utils.nullObject(), store);
+			markStoredSingletons(ext.store, store);
+		}
+		if (headers) ext.headers = Object.assign(ext.headers ?? require_utils.nullObject(), headers);
+		if (models) ext.models = Object.assign(ext.models ?? require_utils.nullObject(), models);
+		if (parser) ext.parser = Object.assign(ext.parser ?? require_utils.nullObject(), parser);
 		if (macro) if (app["~scopeChild"]) {
-			const pluginMacros = app.#pluginMacros;
+			const pluginMacros = app.pluginMacros;
 			let changed = false;
 			if (pluginMacros?.size) {
 				const target = this.#ensureMacroTable();
 				for (const [name, def] of pluginMacros) if (!(name in target)) {
 					target[name] = def;
 					changed = true;
-					if (this["~scopeChild"]) (this.#pluginMacros ??= /* @__PURE__ */ new Map()).set(name, def);
+					if (this["~scopeChild"]) (this.pluginMacros ??= /* @__PURE__ */ new Map()).set(name, def);
 				}
 			}
 			if (changed) require_utils.invalidateMacroEpoch();
 		} else {
 			Object.assign(this.#ensureMacroTable(), macro);
 			if (this["~scopeChild"]) {
-				const pluginMacros = this.#pluginMacros ??= /* @__PURE__ */ new Map();
+				const pluginMacros = this.pluginMacros ??= /* @__PURE__ */ new Map();
 				for (const name in macro) pluginMacros.set(name, macro[name]);
 			}
 			require_utils.invalidateMacroEpoch();
 		}
-		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) ext.hoc = mergeExtCallbacks(ext.hoc, hoc);
+		if (setup) ext.setup = mergeExtCallbacks(ext.setup, setup);
+		if (cleanup) ext.cleanup = mergeExtCallbacks(ext.cleanup, cleanup);
 		if (capability) {
 			const target = ext.capability ??= require_utils.nullObject();
-			if (capability.trace) {
-				const incoming = capability.trace.provider;
-				if (!target.trace) target.trace = { provider: incoming };
-			}
+			if (capability.trace) target.trace ??= { provider: capability.trace.provider };
 			if (capability.ws) {
-				const incoming = capability.ws.provider;
-				const existing = target.ws;
 				const incomingOptions = capability.ws.options;
-				if (!existing) target.ws = {
-					provider: incoming,
-					options: incomingOptions?.length ? incomingOptions.map((entry) => ({
-						depth: entry.depth + 1,
-						value: entry.value,
-						origin: entry.origin
-					})) : void 0
+				const existing = target.ws ??= {
+					provider: capability.ws.provider,
+					options: void 0
 				};
-				else if (incomingOptions?.length) {
+				if (incomingOptions?.length) {
 					const base = existing.options ?? [];
 					const seen = new Set(base.map((e) => e.origin));
 					let next;
@@ -798,7 +848,6 @@ var Elysia = class Elysia {
 		let globalEvents;
 		let pluginMayRef = false;
 		let globalMayRef = false;
-		if (app.#hasGlobal) this.#hasGlobal = true;
 		const nodes = useNodesBuffer;
 		nodes.length = 0;
 		let current = hookChain;
@@ -826,10 +875,7 @@ var Elysia = class Elysia {
 					const target = isGlobal ? globalEvents ??= require_utils.nullObject() : pluginEvents ??= require_utils.nullObject();
 					if (isGlobal) globalMayRef = true;
 					else pluginMayRef = true;
-					for (const s of schemas) {
-						(target.schemas ??= []).push(s);
-						if (isGlobal) this.#hasGlobal = true;
-					}
+					for (const s of schemas) (target.schemas ??= []).push(s);
 					continue;
 				}
 				if (key === "schema") continue;
@@ -839,13 +885,12 @@ var Elysia = class Elysia {
 					const count = many ? raw.length : 1;
 					for (let f = 0; f < count; f++) {
 						const fn = many ? raw[f] : raw;
-						const childrenHash = this.#childrenHash;
+						const childrenHash = this.childrenHash;
 						if (childrenHash !== void 0) {
 							const origin = require_utils.fnOrigin.get(fn);
 							if (origin !== void 0 && childrenHash.has(origin) && !addedByThisCall?.has(origin)) continue;
 						}
 						require_utils.pushField(isGlobal ? globalEvents ??= require_utils.nullObject() : pluginEvents ??= require_utils.nullObject(), key, fn);
-						if (isGlobal) this.#hasGlobal = true;
 					}
 					continue;
 				}
@@ -864,40 +909,46 @@ var Elysia = class Elysia {
 			}
 		}
 		nodes.length = 0;
-		if (globalEvents) {
-			const parent = this["~hookChain"];
-			this["~hookChain"] = {
-				added: globalEvents,
-				parent,
-				refs: parent !== void 0 && parent.refs || globalMayRef && Elysia.#hookHasString(globalEvents),
-				scope: "global",
-				propagated: true,
-				owner: app
-			};
-		}
-		if (pluginEvents) {
-			const parent = this["~hookChain"];
-			this["~hookChain"] = {
-				added: pluginEvents,
-				parent,
-				refs: parent !== void 0 && parent.refs || pluginMayRef && Elysia.#hookHasString(pluginEvents),
-				scope: "plugin",
-				propagated: true,
-				owner: app
-			};
-		}
+		if (globalEvents) this.#link(globalEvents, "global", app, globalMayRef, true);
+		if (pluginEvents) this.#link(pluginEvents, "plugin", app, pluginMayRef, true);
 	}
 	#emitChildRoutes(app, preChain, name) {
-		const declared = app.#declaredRoutes;
-		if (!declared?.length) return;
+		const declared = app.declaredRoutes;
 		const limit = declared.length;
+		const tail = app["~hookChain"];
+		let recent;
+		let hasLocal = false;
 		let lastChildChain;
 		let lastCombined;
+		let lastTailChild = null;
+		let lastTailCombined;
 		for (let i = 0; i < limit; i++) {
 			const route = declared[i];
 			const childChain = route[6];
+			const absorbed = tail !== void 0 && route[3] !== app;
+			if (absorbed && recent === void 0) {
+				recent = /* @__PURE__ */ new Set();
+				for (let node = tail; node && "added" in node; node = node.parent) {
+					recent.add(node);
+					if (require_utils.isLocalScope(node.scope)) {
+						hasLocal = true;
+						break;
+					}
+				}
+			}
 			let inheritedChain;
-			if (childChain === void 0) inheritedChain = preChain;
+			if (absorbed && hasLocal && !recent.has(require_utils.rootSnapshot(childChain))) {
+				if (childChain !== lastTailChild) {
+					lastTailChild = childChain;
+					lastTailCombined = {
+						combine: childChain,
+						over: preChain,
+						tail,
+						refs: !!(childChain?.refs || preChain?.refs || tail.refs)
+					};
+				}
+				inheritedChain = lastTailCombined;
+			} else if (childChain === void 0) inheritedChain = preChain;
 			else if (preChain === void 0) inheritedChain = childChain;
 			else if (childChain === lastChildChain) inheritedChain = lastCombined;
 			else {
@@ -926,55 +977,91 @@ var Elysia = class Elysia {
 		], source);
 	}
 	get modules() {
-		const ready = this.#ready;
+		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.#ready && this.#ready !== ready) return this.modules;
+			if (this._error !== void 0) throw this._error.error;
+			if (this.ready && this.ready !== ready) return this.modules;
 		});
 	}
 	get pending() {
-		return this.#pending > 0;
+		return this._pending > 0;
 	}
 	#useAsync(promise) {
-		if (!this.#ready) this.#error = void 0;
-		this.#pending++;
-		const next = (this.#ready ?? Promise.resolve()).then(() => promise).then((value) => {
+		if (!this.ready) this._error = void 0;
+		this._pending++;
+		const next = (this.ready ?? Promise.resolve()).then(() => promise).then((value) => {
 			const plugin = value && typeof value === "object" && "default" in value && value.default ? value.default : value;
+			const snapshots = this.macroSnapshots;
+			let before;
+			if (snapshots?.size) {
+				const macro = this["~ext"]?.macro;
+				before = macro ? new Map(Object.entries(macro)) : /* @__PURE__ */ new Map();
+			}
 			if (plugin) try {
 				this.use(plugin);
 			} catch (err) {
-				this.#error ??= err;
+				this._error ??= { error: err };
 				console.error(err);
 			}
+			if (before) {
+				const after = this["~ext"]?.macro;
+				if (after) {
+					for (const [k, def] of Object.entries(after)) if (before.get(k) !== def) {
+						for (const snap of snapshots) if (snap.has(k) === before.has(k) && snap.get(k) === before.get(k)) snap.set(k, def);
+					}
+				}
+			}
 		}).finally(() => {
-			this.#pending--;
+			this._pending--;
 		}).then(() => {}, (err) => {
-			this.#error ??= err;
+			this._error ??= { error: err };
 			console.error(err);
-		}).finally(() => this.#tryDrain(next));
-		this.#ready = next;
+		}).finally(() => {
+			if (this._pending > 0) return;
+			if (this.ready !== next) return;
+			const previousCompiled = this.compiled;
+			const previousJitColdRemaining = this.jitColdRemaining;
+			this.ready = void 0;
+			this.compiled = void 0;
+			this.fetchFn = void 0;
+			this.routerBuilt = false;
+			require_context.clearContextCache(this);
+			try {
+				this.#buildRouter(false);
+			} catch (error) {
+				this.compiled = previousCompiled;
+				this.jitColdRemaining = previousJitColdRemaining;
+				this._error ??= { error };
+			}
+		});
+		this.ready = next;
 		return this;
 	}
-	#tryDrain(sentinel) {
-		if (this.#pending > 0) return;
-		if (this.#ready !== sentinel) return;
-		this.#ready = void 0;
-		this.#fetchFn = void 0;
-		this.#routerBuilt = false;
-		this.#buildRouter(false);
-	}
 	#add(method, path, hookOrFn, fn, hasHook = fn !== void 0) {
 		if (this["~Prefix"]) path = require_utils.joinPath(this["~Prefix"], path);
 		else if (path && path.charCodeAt(0) !== 47) path = "/" + path;
+		if (typeof hookOrFn === "function" && require_utils.isPlainObject(fn) && !hasHookKeys(hookOrFn)) {
+			let isHook = hasHookKeys(fn);
+			const macro = this["~ext"]?.macro;
+			if (!isHook && macro) {
+				for (const key in fn) if (key in macro) {
+					isHook = true;
+					break;
+				}
+			}
+			if (isHook) throw new Error(`[Elysia] .${method === "*" ? "all" : method.toLowerCase()}('${path}', handler, hook) is the 1.x order; Elysia 2 takes (path, hook, handler) — see the 2.0 migration guide`);
+		}
+		if (hasHook && hookOrFn) assertSchemaShape(hookOrFn, `${method} ${path}`);
 		const handler = hasHook ? fn : hookOrFn;
 		const hook = hasHook ? require_schema_snapshot.snapshotHookSchemas(hookOrFn) : void 0;
 		const appHook = this["~hookChain"];
-		if (this["~generation"] !== void 0) this.#assertMutable("route");
-		(this.#declaredRoutes ?? this.#materializeDeclaredRoutes()).push(appHook ? [
+		const verb = this["~generation"] === void 0 ? "method" : method === "*" ? "all" : method.toLowerCase();
+		this.#assertMutable(verb in this ? verb : "method");
+		(this.declaredRoutes ?? this.#materializeDeclaredRoutes()).push(appHook ? [
 			method,
 			path,
 			handler,
@@ -993,76 +1080,61 @@ var Elysia = class Elysia {
 			handler,
 			this
 		]);
-		if (this.#routerBuilt || this.#compiled !== void 0) {
-			this.#compiled = void 0;
-			this.#jitColdRemaining = void 0;
-			this.#jitTable = void 0;
-			this.#jitRoute = void 0;
-			this.#jitStatic = void 0;
-			this.#jitAliases = void 0;
-			this.#fetchFn = void 0;
-			this.#routerBuilt = false;
-		}
+		if (this.routerBuilt || this.compiled !== void 0) this.#invalidate();
 		return this;
 	}
 	#assertMutable(api) {
+		mutationEpoch++;
 		if (this["~generation"] === void 0) return;
-		throw new Error(`[Elysia] .${api}() called after the app was sealed`);
+		throw new Error(`[Elysia] .${api}() called after the app was sealed by its first request, listen or compile`);
+	}
+	get #isCacheable() {
+		return this["~generation"] !== void 0 && this.routerBuilt && !require_compile_aot.Capture.isCapturing();
+	}
+	#cacheRoutes(generation) {
+		if (this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch) return;
+		this.cachedGeneration = generation;
+		this.cachedEpoch = mutationEpoch;
+		this.cachedRoutes = void 0;
+		this.cachedHistory = void 0;
 	}
 	#materializeDeclaredRoutes() {
-		if (this.#declaredRoutes !== void 0) return this.#declaredRoutes;
+		if (this.declaredRoutes !== void 0) return this.declaredRoutes;
 		const table = this["~routeTable"];
-		if (!table) return this.#declaredRoutes = [];
+		if (!table) return this.declaredRoutes = [];
 		const routes = new Array(table.length);
 		for (let i = 0; i < table.length; i++) routes[i] = require_route_table.routeRow(table, i);
-		return this.#declaredRoutes = routes;
+		return this.declaredRoutes = routes;
 	}
 	#registerRoute(route, source) {
-		if (this["~generation"] !== void 0) this.#assertMutable("route");
-		const routes = this.#declaredRoutes ?? this.#materializeDeclaredRoutes();
+		this.#assertMutable("route");
+		const routes = this.declaredRoutes ?? this.#materializeDeclaredRoutes();
 		const sequence = routes.length;
 		routes.push(route);
-		if (source) (this.#routeSources ??= [])[sequence] = source;
-		if (this.#routerBuilt || this.#compiled !== void 0) {
-			this.#compiled = void 0;
-			this.#jitColdRemaining = void 0;
-			this.#jitTable = void 0;
-			this.#jitRoute = void 0;
-			this.#jitStatic = void 0;
-			this.#jitAliases = void 0;
-			this.#fetchFn = void 0;
-			this.#routerBuilt = false;
-		}
+		if (source) (this.routeSources ??= [])[sequence] = source;
+		if (this.routerBuilt || this.compiled !== void 0) this.#invalidate();
+	}
+	#invalidate() {
+		this.compiled = void 0;
+		this.jitColdRemaining = void 0;
+		this.jitTable = void 0;
+		this.jitRoute = void 0;
+		this.jitAliases = void 0;
+		this.fetchFn = void 0;
+		this.routerBuilt = false;
 	}
 	model(name, model) {
 		this.#assertMutable("model");
-		const models = this.#ext.models ??= require_utils.nullObject();
+		const models = this.ext.models ??= require_utils.nullObject();
 		switch (typeof name) {
 			case "object":
-				const entries = Object.entries(name);
-				if (entries.length) for (let [key, value] of entries) {
-					if (key in models) continue;
-					if ("~standard" in value) models[key] = value;
-					else {
-						value = require_schema_snapshot.snapshotSchema(value);
-						value.$id ??= key;
-						models[key] = value;
-					}
-				}
+				for (const [key, value] of Object.entries(name)) if (!(key in models)) models[key] = toModel(key, value);
 				return this;
 			case "function": {
-				const remapped = name(models ?? require_utils.nullObject());
+				const remapped = name(models);
 				const next = require_utils.nullObject();
-				for (const key in remapped) {
-					let value = remapped[key];
-					if ("~standard" in value) next[key] = value;
-					else {
-						value = require_schema_snapshot.snapshotSchema(value);
-						value.$id ??= key;
-						next[key] = value;
-					}
-				}
-				this.#ext.models = next;
+				for (const key in remapped) next[key] = toModel(key, remapped[key]);
+				this.ext.models = next;
 				return this;
 			}
 			case "string":
@@ -1097,6 +1169,9 @@ var Elysia = class Elysia {
 	options(path, hookOrFn, fn) {
 		return this.#add("OPTIONS", path, hookOrFn, fn);
 	}
+	query(path, hookOrFn, fn) {
+		return this.#add("QUERY", path, hookOrFn, fn);
+	}
 	head(path, hookOrFn, fn) {
 		return this.#add("HEAD", path, hookOrFn, fn);
 	}
@@ -1121,22 +1196,18 @@ var Elysia = class Elysia {
 		this.#add("WS", path, opts, void 0, true);
 		return this;
 	}
-	mount(path, handleOrConfig, config) {
+	mount(path, handler) {
 		const options = {
-			...config,
 			parse: "none",
-			detail: {
-				...config?.detail,
-				hide: true
-			}
+			detail: { hide: true }
 		};
 		if (typeof path === "function" || path === "" || path === "/") {
-			const run = typeof path === "function" ? path : typeof handleOrConfig === "function" ? handleOrConfig : null;
+			const run = typeof path === "function" ? path : typeof handler === "function" ? handler : null;
 			if (!run) throw new Error("Invalid handler");
 			this.all("/*", options, Elysia.#mountHandler(run, 2));
 			return this;
 		}
-		const handle = typeof handleOrConfig === "function" ? handleOrConfig : null;
+		const handle = typeof handler === "function" ? handler : null;
 		if (!handle) throw new Error("Invalid handler");
 		const endsStar = path.endsWith("*") ? 1 : 0;
 		const wildcardSuffix = path.endsWith("/") ? "*" : "/*";
@@ -1172,75 +1243,102 @@ var Elysia = class Elysia {
 	compile() {
 		this["~config"] ??= require_utils.nullObject();
 		this["~config"].precompile = true;
-		this.#routerBuilt = false;
-		this.#compiled = void 0;
-		this.#jitColdRemaining = void 0;
-		this.#jitTable = void 0;
-		this.#jitRoute = void 0;
-		this.#jitStatic = void 0;
-		this.#jitAliases = void 0;
-		this.#fetchFn = void 0;
+		this.#invalidate();
 		this.fetch;
 		return this;
 	}
-	handler(index, immediate = this["~config"]?.precompile, route, precomputedStatic, aliases, table) {
-		if (this.#compiled?.[index]) return this.#compiled[index];
-		const compiled = this.#compiled ??= new Array(table?.length ?? this["~routes"].length);
-		if (immediate) {
-			const row = route ?? (table ? require_route_table.routeRow(table, index) : this["~routes"][index]);
+	handler(index, immediate, route, aliases, table) {
+		if (this.compiled?.[index]) return this.compiled[index];
+		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 ?? (indexedTable ? require_route_table.routeRow(indexedTable, index) : this["~routes"][index]);
+			const exactDuplicate = ((indexedTable?.flags[index] ?? 0) & require_route_table.RouteFlag.ExactDuplicate) !== 0;
 			let handler;
 			try {
-				handler = require_compile_handler_index.compileHandler(row, this, precomputedStatic);
+				handler = require_compile_handler_index.compileHandler(row, this, exactDuplicate && require_compile_aot.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);
-	}
-	#jitHandler(index, route, precomputedStatic, aliases, table) {
-		if (table !== void 0) this.#jitTable = table;
-		if (route !== void 0) (this.#jitRoute ??= [])[index] = route;
-		if (precomputedStatic !== void 0) (this.#jitStatic ??= [])[index] = precomputedStatic;
-		if (aliases !== void 0) (this.#jitAliases ??= [])[index] = aliases;
+		const jitRoute = route ?? (indexedTable ? void 0 : this["~routes"][index]);
+		if (indexedTable !== void 0) this.jitTable = indexedTable;
+		if (jitRoute !== void 0) (this.jitRoute ??= [])[index] = jitRoute;
+		if (aliases !== void 0) (this.jitAliases ??= [])[index] = aliases;
 		return (context) => this.#jitDispatch(index, context);
 	}
+	#staticAliases(table, index) {
+		const flags = table.flags[index];
+		if ((flags & (require_route_table.RouteFlag.WS | require_route_table.RouteFlag.Dynamic)) !== 0) return;
+		const path = table.path[index];
+		const method = table.method[index];
+		const needsEncode = (flags & require_route_table.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] & require_route_table.RouteFlag.Encode) !== 0) explicit.add(encodeURI(declared));
+			}
+		}
+		return {
+			method,
+			paths: expandPaths(path, needsEncode, registerLoose, explicit)
+		};
+	}
+	#releaseJit() {
+		require_compile_aot.Compiled.release(this["~programId"]);
+		this.jitColdRemaining = void 0;
+		this.jitRoute = void 0;
+		this.jitAliases = void 0;
+		this.jitTable = void 0;
+	}
+	#satisfyJit(table, index) {
+		if ((table.flags[index] & require_route_table.RouteFlag.ExactDuplicate) !== 0) return false;
+		if (this.jitColdRemaining === void 0) {
+			if (this["~generation"] === void 0 && this["~config"]?.precompile !== true && require_universal_is_production.isProduction() && !require_compile_aot.Capture.isAotBuildEnv()) table.flags[index] |= require_route_table.RouteFlag.JITSatisfied;
+			return false;
+		}
+		if ((table.flags[index] & require_route_table.RouteFlag.JITCold) === 0) return false;
+		table.flags[index] &= ~require_route_table.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] ?? require_route_table.routeRow(this.#jitTable, index);
+		if (this.compiled[index]) return this.compiled[index](context);
+		const route = this.jitRoute?.[index];
+		const table = this.jitTable ?? this["~routeTable"];
+		const materialized = route ?? require_route_table.routeRow(table, index);
+		const exactDuplicate = ((table?.flags[index] ?? 0) & require_route_table.RouteFlag.ExactDuplicate) !== 0;
 		let handler;
 		try {
-			handler = require_compile_handler_index.compileHandler(materialized, this, this.#jitStatic?.[index]);
+			handler = require_compile_handler_index.compileHandler(materialized, this, exactDuplicate && require_compile_aot.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"];
 			if (finalize) return finalize(context, routeError);
 			throw routeError;
 		}
-		this.#compiled[index] = handler;
-		let releasedNow = false;
-		if (this.#jitColdRemaining !== void 0 && --this.#jitColdRemaining === 0) {
-			require_compile_aot.Compiled.release(this["~programId"]);
-			this.#jitColdRemaining = void 0;
-			releasedNow = true;
+		this.compiled[index] = handler;
+		if (!exactDuplicate) {
+			const aliases = this.jitAliases?.[index] ?? (table ? this.#staticAliases(table, index) : void 0);
+			if (aliases) {
+				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(materialized[0], materialized[1], handler);
 		}
-		const aliases = this.#jitAliases?.[index];
-		if (aliases) {
-			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(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 (this.#jitRoute) this.#jitRoute[index] = void 0;
-			if (this.#jitStatic) this.#jitStatic[index] = void 0;
-			if (this.#jitAliases) this.#jitAliases[index] = void 0;
+		if (!(table ? this.#satisfyJit(table, index) : false)) {
+			if (this.jitRoute) this.jitRoute[index] = void 0;
+			if (this.jitAliases) this.jitAliases[index] = void 0;
 		}
 		return handler(context);
 	}
@@ -1257,7 +1355,7 @@ var Elysia = class Elysia {
 		if (typeof response === "string") return true;
 		if (response && typeof response === "object") {
 			const record = response;
-			if (!("~kind" in record) && !("~elyAcl" in record) && !("~standard" in record)) {
+			if (!isSingleSchema(record)) {
 				for (const status in record) if (typeof record[status] === "string") return true;
 			}
 		}
@@ -1271,16 +1369,41 @@ var Elysia = class Elysia {
 		}
 		return false;
 	}
-	#routeMayHaveModelRef(table, i) {
-		const macroScope = table.macroScope?.get(i);
-		const owner = table.owner[i];
-		const candidate = macroScope ?? owner ?? this;
-		if ((candidate === this ? this : require_compile_handler_index.localMacroRoot(candidate, this))["~ext"]?.macro) return true;
-		if (Elysia.#hookHasString(table.localHook[i])) return true;
-		const appHook = table.appHook[i];
-		if (appHook !== void 0 && appHook.refs) return true;
-		const inheritedChain = table.inheritedChain[i];
-		return inheritedChain !== void 0 && inheritedChain.refs;
+	static #slotHasTypeBox(value, models, record) {
+		if (typeof value === "string") value = models?.[value];
+		if (!value || typeof value !== "object") return false;
+		if ("~kind" in value || "~elyAcl" in value) return true;
+		if (!record || "~standard" in value) return false;
+		for (const status in value) if (Elysia.#slotHasTypeBox(value[status], models)) return true;
+		return false;
+	}
+	static #hookHasTypeBox(h, models) {
+		if (!h || typeof h !== "object") return false;
+		for (const key in h) {
+			if (key === "schemas") {
+				const schemas = h[key];
+				if (Array.isArray(schemas)) {
+					for (let s = 0; s < schemas.length; s++) if (Elysia.#hookHasTypeBox(schemas[s], models)) return true;
+				}
+				continue;
+			}
+			if (require_utils.schemaProperties.has(key) && Elysia.#slotHasTypeBox(h[key], models, key === "response")) return true;
+		}
+		return false;
+	}
+	static #chainHasTypeBox(node, models, seen, resolve) {
+		while (node) {
+			if (seen.has(node)) return false;
+			seen.add(node);
+			if ("added" in node) {
+				if (Elysia.#hookHasTypeBox(resolve ? resolve(node) : node.added, models)) return true;
+				node = node.parent;
+			} else {
+				if (Elysia.#chainHasTypeBox(node.combine, models, seen, resolve) || Elysia.#chainHasTypeBox(node.tail, models, seen, resolve)) return true;
+				node = node.over;
+			}
+		}
+		return false;
 	}
 	#assertRouteModelRefs(route, method) {
 		const models = this["~ext"]?.models;
@@ -1294,7 +1417,7 @@ var Elysia = class Elysia {
 					if (!models || !(v in models)) throw new Error(`[Elysia] Unknown model reference "${v}" for ${key} on route ${method} ${path}.`);
 				} else if (key === "response" && v && typeof v === "object") {
 					const record = v;
-					if ("~kind" in record || "~elyAcl" in record || "~standard" in record) continue;
+					if (isSingleSchema(record)) continue;
 					for (const status in record) {
 						const r = record[status];
 						if (typeof r === "string" && (!models || !(r in models))) throw new Error(`[Elysia] Unknown model reference "${r}" for response ${status} on route ${method} ${path}.`);
@@ -1307,30 +1430,27 @@ var Elysia = class Elysia {
 		const schemas = hook?.schemas;
 		if (Array.isArray(schemas)) for (let s = 0; s < schemas.length; s++) checkSlots(schemas[s]);
 	}
-	#routerBuilt = false;
 	#buildRouter(seal = false) {
-		if (this.#routerBuilt) {
+		if (this.routerBuilt) {
 			if (seal && this["~generation"] === void 0) this.#publishGeneration();
 			return;
 		}
 		const compilerSession = require_compile_aot.beginCompilerSession(this);
 		const previousMap = this["~map"];
 		const previousRouter = this["~router"];
-		const previousCompiled = this.#compiled;
-		const previousJitTable = this.#jitTable;
-		const previousJitRoute = this.#jitRoute;
-		const previousJitStatic = this.#jitStatic;
-		const previousJitAliases = this.#jitAliases;
+		const previousCompiled = this.compiled;
+		const previousJitTable = this.jitTable;
+		const previousJitRoute = this.jitRoute;
+		const previousJitAliases = this.jitAliases;
 		const previousHasDynamicWS = this["~hasDynamicWS"];
 		const previousGeneration = this["~generation"];
 		this["~map"] = void 0;
 		this["~router"] = void 0;
-		this.#compiled = previousCompiled?.slice();
-		this.#jitColdRemaining = void 0;
-		this.#jitTable = void 0;
-		this.#jitRoute = void 0;
-		this.#jitStatic = void 0;
-		this.#jitAliases = void 0;
+		this.compiled = previousCompiled?.slice();
+		this.jitColdRemaining = void 0;
+		this.jitTable = void 0;
+		this.jitRoute = void 0;
+		this.jitAliases = void 0;
 		this["~hasDynamicWS"] = void 0;
 		this["~generation"] = void 0;
 		let buildSucceeded = false;
@@ -1346,18 +1466,17 @@ var Elysia = class Elysia {
 				Object.assign(previousRouter, nextRouter);
 				this["~router"] = previousRouter;
 			}
-			this.#routerBuilt = true;
+			this.routerBuilt = true;
 			if (seal) this.#publishGeneration();
 			buildSucceeded = true;
 		} catch (error) {
 			this["~map"] = previousMap;
 			this["~router"] = previousRouter;
-			this.#compiled = previousCompiled;
-			this.#jitColdRemaining = void 0;
-			this.#jitTable = previousJitTable;
-			this.#jitRoute = previousJitRoute;
-			this.#jitStatic = previousJitStatic;
-			this.#jitAliases = previousJitAliases;
+			this.compiled = previousCompiled;
+			this.jitColdRemaining = void 0;
+			this.jitTable = previousJitTable;
+			this.jitRoute = previousJitRoute;
+			this.jitAliases = previousJitAliases;
 			this["~hasDynamicWS"] = previousHasDynamicWS;
 			this["~generation"] = previousGeneration;
 			throw error;
@@ -1378,26 +1497,31 @@ var Elysia = class Elysia {
 			"~wsConfig": this["~wsConfig"]
 		};
 		if (require_universal_is_production.isProduction() && !require_compile_aot.Capture.isAotBuildEnv()) {
-			if (this["~config"]?.precompile) require_compile_aot.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 compiled = this.#compiled;
-				for (let i = 0; i < routeCount; i++) if (table !== void 0 && (table.flags[i] & require_route_table.RouteFlag.WS) !== 0 || compiled?.[i] !== void 0) cold--;
-				if (cold <= 0) require_compile_aot.Compiled.release(this["~programId"]);
-				else this.#jitColdRemaining = cold;
+				const routeCount = table.length;
+				const compiled = this.compiled;
+				let cold = 0;
+				for (let i = 0; i < routeCount; i++) {
+					const satisfied = (table.flags[i] & require_route_table.RouteFlag.JITSatisfied) !== 0;
+					table.flags[i] &= ~(require_route_table.RouteFlag.JITCold | require_route_table.RouteFlag.JITSatisfied);
+					const flags = table.flags[i];
+					if (satisfied || (flags & (require_route_table.RouteFlag.WS | require_route_table.RouteFlag.ExactDuplicate)) !== 0 || compiled?.[i] !== void 0) continue;
+					table.flags[i] |= require_route_table.RouteFlag.JITCold;
+					cold++;
+				}
+				if (cold === 0) this.#releaseJit();
+				else this.jitColdRemaining = cold;
 			}
-			require_compile_analysis_cache.clearAuthoringAnalysisCaches(this);
-			if (!this["~ext"]?.macro && !this["~scopeChildren"]) this.#declaredRoutes = void 0;
+			require_compile_handler_index.clearHandlerAnalysisCaches(this);
+			require_utils.clearFlattenChainMemo(this);
+			if (!this["~ext"]?.macro && !this["~scopeChildren"]) this.declaredRoutes = void 0;
 		}
-	}
-	["~newGeneration"]() {
-		this.#fetchFn = void 0;
-		this.#routerBuilt = false;
-		this["~generation"] = void 0;
-		this.#buildRouter(true);
-		return this;
+		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);
 	}
 	#buildRouterUnsafe() {
 		const precompile = this["~config"]?.precompile;
@@ -1413,21 +1537,52 @@ var Elysia = class Elysia {
 		const length = table.length;
 		const appChain = this["~hookChain"];
 		if (this["~ext"]?.macro || this["~scopeChildren"] || appChain !== void 0 && appChain.refs) for (let i = 0; i < length; i++) this.#assertRouteModelRefs(require_route_table.routeRow(table, i), method[i]);
-		else 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());
+		else for (let i = 0; i < length; i++) {
+			const macroScope = table.macroScope?.get(i);
+			const owner = table.owner[i];
+			const candidate = macroScope ?? owner ?? this;
+			if ((candidate === this ? this : require_compile_handler_index.localMacroRoot(candidate, this))["~ext"]?.macro || Elysia.#hookHasString(table.localHook[i]) || table.appHook[i]?.refs || table.inheritedChain[i]?.refs) this.#assertRouteModelRefs(require_route_table.routeRow(table, i), method[i]);
+		}
+		let hasTypeBoxSchema = false;
+		if (length) {
+			const models = this["~ext"]?.models;
+			const resolve = require_compile_handler_index.chainResolver(this);
+			const rootChain = this["~hookChain"];
+			const seen = /* @__PURE__ */ new Set();
+			const { localHook, appHook, inheritedChain, owner } = table;
+			for (let i = 0; i < table.length; i++) if (Elysia.#hookHasTypeBox(localHook[i], models) || Elysia.#chainHasTypeBox(appHook[i], models, seen, resolve) || Elysia.#chainHasTypeBox(inheritedChain[i], models, seen, resolve) || owner[i] !== this && Elysia.#chainHasTypeBox(rootChain, models, seen, resolve)) {
+				hasTypeBoxSchema = true;
+				break;
+			}
+		}
+		if (hasTypeBoxSchema) try {
+			require_type_bridge.warmTypebox();
+		} catch {}
+		let markDuplicates = false;
+		if (length) {
+			const programId = this["~programId"];
+			if (!require_compile_aot.Compiled.claim(programId, this["~aotFingerprint"] = require_compile_aot.createAotFingerprint())) require_compile_aot.Compiled.assertUncontested(programId);
+			markDuplicates = require_compile_aot.Compiled.hasProgram(programId) || precompile !== true && require_universal_is_production.isProduction() && !require_compile_aot.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] & require_route_table.RouteFlag.Encode) !== 0) {
+				let paths = seen.get(m);
+				if (!paths) seen.set(m, paths = /* @__PURE__ */ new Map());
+				if (markDuplicates && (flags[i] & require_route_table.RouteFlag.WS) === 0) {
+					const displaced = paths.get(p);
+					if (displaced !== void 0 && displaced >= 0) flags[displaced] |= require_route_table.RouteFlag.ExactDuplicate;
+					paths.set(p, i);
+				} else paths.set(p, -1);
+				if (collectExplicit && (flags[i] & require_route_table.RouteFlag.Encode) !== 0) {
 					const encoded = encodeURI(p);
-					if (encoded !== p) set.add(encoded);
+					if (encoded !== p && !paths.has(encoded)) paths.set(encoded, -1);
 				}
 			}
 		}
@@ -1440,54 +1595,40 @@ var Elysia = class Elysia {
 				const handler = ws[0];
 				const options = ws[1];
 				if (wsConfig === void 0 && wsCap.options) wsConfig = wsCap.options;
+				const wsNeedsEncode = (routeFlags & require_route_table.RouteFlag.Encode) !== 0;
 				if ((routeFlags & require_route_table.RouteFlag.Dynamic) !== 0) {
-					(this["~router"] ??= new memoirist.default({ loosePath: isLoose })).add("WS", routePath, handler);
+					const wsRouter = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
+					const wsPaths = expandPaths(routePath, wsNeedsEncode, false, void 0);
+					for (let v = 0; v < wsPaths.length; v++) wsRouter.add("WS", wsPaths[v], handler);
 					this["~hasDynamicWS"] = true;
 				} else {
-					this.#initMap();
 					const wsMap = this["~map"]["WS"] ??= require_utils.nullObject();
-					wsMap[routePath] = handler;
-					if (isLoose) {
-						const loose = require_utils.getLoosePath(routePath);
-						if (loose !== routePath && !explicitPaths?.get("WS")?.has(loose)) wsMap[loose] = handler;
-					}
+					const wsPaths = expandPaths(routePath, wsNeedsEncode, isLoose, isLoose ? explicitPaths?.get("WS") : void 0);
+					for (let v = 0; v < wsPaths.length; v++) wsMap[wsPaths[v]] = handler;
 				}
 				if (options && require_utils.isNotEmpty(options)) {
 					wsConfig ??= require_utils.nullObject();
-					wsCap.provider.accumulateOptions(wsConfig, options, routePath);
+					wsCap.provider.accumulateOptions(wsConfig, options);
 				}
 				continue;
 			}
 			const isDynamic = (routeFlags & require_route_table.RouteFlag.Dynamic) !== 0;
 			const needsEncode = (routeFlags & require_route_table.RouteFlag.Encode) !== 0;
 			const registerLoose = isLoose && canRegisterLoose(routePath, isDynamic);
-			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, void 0, void 0, void 0, table);
+				map[routePath] = this.handler(i, precompile, void 0, void 0, table);
 				continue;
 			}
-			const variants = [routePath];
-			if (needsEncode) {
-				const encoded = encodeURI(routePath);
-				if (encoded !== routePath) variants.push(encoded);
-			}
-			const paths = [];
-			for (let v = 0; v < variants.length; v++) {
-				const p = variants[v];
-				paths.push(p);
-				if (registerLoose) {
-					const loose = require_utils.getLoosePath(p);
-					if (loose !== p && !explicitMain?.has(loose)) paths.push(loose);
-				}
-			}
+			const paths = expandPaths(routePath, needsEncode, registerLoose, registerLoose ? explicitPaths?.get(routeMethod) : void 0);
 			if (isDynamic) {
+				if (require_utils.isHTMLBundle(table.handler[i])) continue;
 				const router = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
-				const handler = this.handler(i, precompile, void 0, void 0, void 0, table);
+				const handler = this.handler(i, precompile, 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, void 0, void 0, {
+				const handler = this.handler(i, precompile, void 0, {
 					method: routeMethod,
 					paths
 				}, table);
@@ -1496,19 +1637,28 @@ var Elysia = class Elysia {
 		}
 		this["~wsConfig"] = wsConfig;
 	}
-	#fetchFn;
 	get fetch() {
-		if (this.#fetchFn) return this.#fetchFn;
-		this.#buildRouter(!this.#pending);
-		return this.#fetchFn ??= require_handler_fetch.applyHoc(this, require_handler_fetch.createFetchHandler(this));
+		if (this.fetchFn) return this.fetchFn;
+		if (this.ready) return (request, ...rest) => {
+			const run = () => this.fetch(request, ...rest);
+			return this.ready ? this.modules.then(run, run) : run();
+		};
+		return this.#dispatch();
+	}
+	#dispatch() {
+		this.#buildRouter(!this._pending);
+		if (this.ready) return require_handler_fetch.applyHoc(this, require_handler_fetch.createFetchHandler(this));
+		return this.fetchFn ??= require_handler_fetch.applyHoc(this, require_handler_fetch.createFetchHandler(this));
 	}
-	#handle;
 	get handle() {
-		return this.#handle ??= async (requestOrUrl, options) => this.fetch(typeof requestOrUrl === "string" ? new Request(requestOrUrl.charCodeAt(0) === 47 ? `http://e.ly${requestOrUrl}` : requestOrUrl, options) : requestOrUrl);
+		return this._handle ??= async (requestOrUrl, options) => (this.fetchFn ?? this.#dispatch())(typeof requestOrUrl === "string" ? new Request(requestOrUrl.charCodeAt(0) === 47 ? `http://e.ly${requestOrUrl}` : requestOrUrl, options) : requestOrUrl);
 	}
 	listen(options, callback) {
 		const listen = (this["~config"]?.adapter ?? (require_universal_constants.isBun ? require_adapter_bun_index.BunAdapter : void 0))?.listen;
-		if (!listen) throw new Error("No adapter provided for listen()");
+		if (!listen) {
+			const deno = typeof Deno !== "undefined";
+			throw new Error(`[Elysia] listen() requires an adapter on ${deno ? "Deno" : typeof process === "undefined" ? "this runtime" : "Node.js"} — https://elysiajs.com/integrations/${deno ? "deno" : "node"}`);
+		}
 		if (!require_compile_aot.Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}
@@ -1529,8 +1679,8 @@ var Elysia = class Elysia {
 	*/
 	wrap(callback) {
 		this.#assertMutable("wrap");
-		if (this.#fetchFn && !this.#pending) console.warn("[Elysia] .wrap() was called after the fetch handler was built");
-		const ext = this.#ext;
+		if (this.fetchFn && !this._pending) console.warn("[Elysia] .wrap() was called after the fetch handler was built");
+		const ext = this.ext;
 		(ext.hoc ??= []).push(callback);
 		return this;
 	}
@@ -1548,31 +1698,49 @@ 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);
-		else arr.push(handler);
+		(this.ext.cleanup ??= []).push(...[].concat(handler));
 		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
 	*
-	* @param closeActiveConnections Pass `true` to terminate in-flight
-	*   requests and WebSocket connections immediately. Defaults to
-	*   draining gracefully.
+	* Awaiting `stop()` from inside a `setup`, `cleanup` or WebSocket lifecycle
+	* callback is only supported while that callback is still synchronous
+	*
+	* @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);
+			}
+			require_utils.throwLifecycleErrors(errors);
+		})();
 	}
 };