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

package/dist/base.js

@@ -6,6 +6,7 @@ const require_type_bridge = require('./type/bridge.js');
 const require_universal_is_production = require('./universal/is-production.js');
 const require_compile_aot = require('./compile/aot.js');
 const require_generation = require('./generation.js');
+const require_compile_handler_descriptor = require('./compile/handler/descriptor.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');
@@ -17,6 +18,9 @@ memoirist = require_runtime.__toESM(memoirist);
 
 //#region src/base.ts
 const useNodesBuffer = [];
+const propagatedRegistrations = /* @__PURE__ */ new WeakMap();
+const liftedRequests = /* @__PURE__ */ new WeakMap();
+const hocOriginOf = (o) => typeof o === "object" ? o.origin : o;
 const emptyHistory = Object.freeze([]);
 let mutationEpoch = 0;
 const extCallbackIndexes = /* @__PURE__ */ new WeakMap();
@@ -42,6 +46,13 @@ const markStoredSingletons = (table, source) => {
 	if (!table) return;
 	for (const key in source) require_utils.markSingletons(table[key]);
 };
+const sharedTables = [
+	"decorator",
+	"store",
+	"headers",
+	"models",
+	"parser"
+];
 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) => {
@@ -108,6 +119,7 @@ function expandPaths(path, needsEncode, registerLoose, explicit) {
 	return paths;
 }
 var Elysia = class Elysia {
+	#pending = 0;
 	get history() {
 		const generation = this["~generation"];
 		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedHistory !== void 0) return this.cachedHistory;
@@ -161,8 +173,6 @@ var Elysia = class Elysia {
 		return this;
 	}
 	constructor(config) {
-		this._pending = 0;
-		this.routerBuilt = false;
 		/**
 		* ! Don't tune
 		*
@@ -208,7 +218,7 @@ var Elysia = class Elysia {
 		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.pluginHash(JSON.stringify(seed === void 0 ? [name] : [name, seed], require_utils.serializeMacroSeed));
 			if (adapter?.setup) this.#useFn(adapter.setup);
 		} else this["~Prefix"] = void 0;
 	}
@@ -224,11 +234,12 @@ var Elysia = class Elysia {
 		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);
+			require_compile_handler_index.runIntrospect(merged);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
 				if (!entry?.response) continue;
 				merged.response = require_utils.mergeResponse(merged.response, entry.response);
 			}
-			if (merged?.response && !require_utils.isRecordNumber(merged.response)) merged.response = { 200: merged.response };
+			if (merged?.response) merged.response = require_utils.isRecordNumber(merged.response) ? { ...merged.response } : { 200: merged.response };
 			return {
 				method,
 				path,
@@ -246,10 +257,10 @@ var Elysia = class Elysia {
 	decorate(typeOrNameOrDecorators, nameOrDecorators, value) {
 		return this.#setField("decorator", arguments.length, typeOrNameOrDecorators, nameOrDecorators, value);
 	}
-	#setField(field, length, typeOrName, nameOrValue, value) {
+	#setField(field, argCount, typeOrName, nameOrValue, value) {
 		let as = "append";
 		let name = "";
-		switch (length) {
+		switch (argCount) {
 			case 1:
 				value = typeOrName;
 				break;
@@ -264,10 +275,11 @@ var Elysia = class Elysia {
 				break;
 			default: return this;
 		}
-		this.#assertMutable(field === "store" ? "state" : "decorate");
-		const ext = this.ext;
-		const fresh = !ext[field];
-		const target = ext[field] ??= require_utils.nullObject();
+		this.#assertTableMutable(field === "store" ? "state" : "decorate");
+		const ext = this.#ext;
+		let fresh = true;
+		for (let app = this; fresh && app; app = app.scopeParent) fresh = !app["~ext"]?.[field];
+		const target = this.#table(field);
 		switch (typeof value) {
 			case "object":
 				if (!value) return this;
@@ -303,9 +315,8 @@ var Elysia = class Elysia {
 		return this.#setField("store", arguments.length, typeOrNameOrStore, nameOrStore, value);
 	}
 	headers(headers) {
-		this.#assertMutable("headers");
-		const ext = this.ext;
-		ext.headers = Object.assign(ext.headers ?? require_utils.nullObject(), headers);
+		this.#assertTableMutable("headers");
+		Object.assign(this.#table("headers"), headers);
 		return this;
 	}
 	#on(type, fn, scope = this["~config"]?.as) {
@@ -314,32 +325,30 @@ var Elysia = class Elysia {
 		const added = require_utils.nullObject();
 		added[type] = fn;
 		if (type === "trace") this["~hasTrace"] = true;
-		this.#link(added, scope, this);
-		this.#tagOrigin(fn);
+		this.#pushChainNode(added, scope);
 		return this;
 	}
-	#link(added, scope, owner, mayRef = true, propagated) {
+	#pushChainNode(added, scope, registration, origin, owner) {
 		const parent = this["~hookChain"];
-		const refs = parent !== void 0 && parent.refs || mayRef && Elysia.#hookHasString(added);
-		this["~hookChain"] = propagated ? {
+		const refs = parent !== void 0 && parent.refs || Elysia.#hookHasString(added);
+		this["~hookChain"] = registration ? {
 			added,
 			parent,
 			refs,
 			scope,
-			propagated,
-			owner
+			propagated: true,
+			owner,
+			origin,
+			registration
 		} : {
 			added,
 			parent,
 			refs,
 			scope,
-			owner
+			owner: this,
+			origin: this.hash
 		};
 	}
-	#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);
 	}
@@ -354,9 +363,8 @@ var Elysia = class Elysia {
 		return this.#onBranch("parse", scopeOrFnOrName, fn);
 	}
 	parser(name, fn) {
-		this.#assertMutable("parser");
-		const ext = this.ext;
-		const parsers = ext.parser ??= require_utils.nullObject();
+		this.#assertTableMutable("parser");
+		const parsers = this.#table("parser");
 		parsers[name] = fn;
 		return this;
 	}
@@ -376,7 +384,7 @@ var Elysia = class Elysia {
 	*/
 	setup(handler) {
 		this.#assertMutable("setup");
-		(this.ext.setup ??= []).push(...[].concat(handler));
+		(this.#ext.setup ??= []).push(...[].concat(handler));
 		return this;
 	}
 	transform(scopeOrFn, fn) {
@@ -415,13 +423,13 @@ var Elysia = class Elysia {
 				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object") return this;
 				return this.#onBranch("error", scopeOrFnOrError);
 			case 2:
-				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#errorClass(scopeOrFnOrError, fnOrError);
+				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#onErrorClass(scopeOrFnOrError, fnOrError);
 				return this.#onBranch("error", scopeOrFnOrError, fnOrError);
-			case 3: return this.#errorClass(fnOrError, fn, scopeOrFnOrError);
+			case 3: return this.#onErrorClass(fnOrError, fn, scopeOrFnOrError);
 		}
 		return this;
 	}
-	#errorClass(ErrorClass, fn, scope) {
+	#onErrorClass(ErrorClass, fn, scope) {
 		const run = typeof fn === "function" ? fn : () => fn;
 		return this.#on("error", require_utils.createErrorEventHandler(run, ErrorClass), scope);
 	}
@@ -440,9 +448,10 @@ var Elysia = class Elysia {
 				node = node.over;
 				continue;
 			}
-			if (node.scope !== "global") {
+			if (node.scope !== "global" && (node.scope !== scope || node.propagated)) {
 				node.scope = scope;
 				node.propagated = false;
+				require_utils.invalidateMacroEpoch();
 			}
 			node = node.parent;
 		}
@@ -462,13 +471,11 @@ var Elysia = class Elysia {
 		if (hook) assertSchemaShape(hook, ".guard()");
 		hook = require_schema_snapshot.snapshotHookSchemas(hook);
 		require_utils.hookToGuard(hook);
-		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;
 	}
 	group() {
-		this.#assertMutable("group");
+		this.#assertTableMutable("group");
 		const prefix = arguments[0];
 		const schemaOrRun = arguments[1];
 		const run = arguments[2];
@@ -487,12 +494,8 @@ var Elysia = class Elysia {
 		const src = this["~ext"];
 		if (src) {
 			const ext = child["~ext"] ??= require_utils.nullObject();
-			if (src.decorator) ext.decorator = Object.assign(require_utils.nullObject(), src.decorator);
-			if (src.store) ext.store = Object.assign(require_utils.nullObject(), src.store);
-			if (src.headers) ext.headers = Object.assign(require_utils.nullObject(), src.headers);
-			if (src.models) ext.models = Object.assign(require_utils.nullObject(), src.models);
+			for (const field of sharedTables) if (src[field]) ext[field] = src[field];
 			if (src.macro) ext.macro = Object.create(src.macro);
-			if (src.parser) ext.parser = Object.assign(require_utils.nullObject(), src.parser);
 			if (src.capability) {
 				const cap = ext.capability = require_utils.nullObject();
 				if (src.capability.trace) cap.trace = src.capability.trace;
@@ -505,9 +508,13 @@ var Elysia = class Elysia {
 		this.#use(child);
 		return this;
 	}
-	get ext() {
+	get #ext() {
 		return this["~ext"] ??= require_utils.nullObject();
 	}
+	/** A group child starts or takes up its parent's table, see `group()` */
+	#table(field) {
+		return this.#ext[field] ??= this.scopeParent ? this.scopeParent.#table(field) : require_utils.nullObject();
+	}
 	["~resolvedCapability"](kind) {
 		if (kind === "ws") {
 			const ws = this["~ext"]?.capability?.ws;
@@ -524,7 +531,7 @@ 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;
 		ext.macro = parent ? Object.create(parent.#ensureMacroTable()) : require_utils.nullObject();
@@ -543,7 +550,7 @@ var Elysia = class Elysia {
 			}
 		}
 		if (hook.trace) this["~hasTrace"] = true;
-		this.#link(hook, scope, this);
+		this.#pushChainNode(hook, scope);
 		return this;
 	}
 	macro(macro, definition) {
@@ -580,7 +587,7 @@ var Elysia = class Elysia {
 				const seedSource = hook.seed ?? value;
 				const seedType = typeof seedSource;
 				let seedKey;
-				if (seedSource === null || seedType !== "object") seedKey = key + "\0" + seedType + "\0" + String(seedSource);
+				if (seedSource === null || seedType !== "object") seedKey = `${key}\0${seedType}\0${require_utils.serializeMacroSeed("", seedSource)}`;
 				else try {
 					seedKey = key + "\0object\0" + JSON.stringify(seedSource, require_utils.serializeMacroSeed);
 				} catch {
@@ -597,7 +604,7 @@ var Elysia = class Elysia {
 				const v = hook[k];
 				if (k === "seed" || k === "meta" || k === "$type") continue;
 				if (k === "introspect") {
-					v?.(input);
+					if (v) (input["~introspect"] ??= []).push(v);
 					delete input[key];
 					continue;
 				}
@@ -633,15 +640,9 @@ var Elysia = class Elysia {
 				if (require_utils.eventProperties.has(k) || k === "derive") {
 					const incoming = Array.isArray(v) ? v : [v];
 					const existing = k in input ? Array.isArray(input[k]) ? input[k] : [input[k]] : [];
-					const added = [];
-					for (const fn of incoming) if (!existing.includes(fn) && !added.includes(fn)) added.push(fn);
 					const at = insertions.get(k) ?? 0;
-					input[k] = [
-						...existing.slice(0, at),
-						...added,
-						...existing.slice(at)
-					];
-					insertions.set(k, at + added.length);
+					input[k] = existing.toSpliced(at, 0, ...incoming);
+					insertions.set(k, at + incoming.length);
 				} else if (k in input) {
 					if (Array.isArray(input[k])) {
 						for (const item of Array.isArray(v) ? v : [v]) if (!input[k].includes(item)) input[k].unshift(item);
@@ -654,7 +655,7 @@ var Elysia = class Elysia {
 	}
 	use(app) {
 		if (!app) return this;
-		this.#assertMutable("use");
+		this.#assertTableMutable("use");
 		if (typeof app === "function") return this.#useFn(app);
 		if (typeof app.then === "function") return this.#useAsync(app);
 		if (Array.isArray(app)) {
@@ -667,6 +668,9 @@ var Elysia = class Elysia {
 		this.#use(app);
 		return this;
 	}
+	has(plugin) {
+		return this.childrenHash?.has(plugin.hash ?? require_utils.pluginId(plugin)) ?? false;
+	}
 	#useFn(app) {
 		const prevBaseline = this.macroBaseline;
 		const baseline = /* @__PURE__ */ new Set();
@@ -708,14 +712,15 @@ var Elysia = class Elysia {
 		const config = app["~config"];
 		if (app["~introspect"] || config?.introspect) this["~introspect"] = true;
 		const name = config?.name;
-		if (name) {
-			const hash = app.hash;
-			if (this.childrenHash?.has(hash)) return;
+		const childKey = name ? app.hash : require_utils.pluginId(app);
+		const exists = this.childrenHash?.has(childKey);
+		if (name && exists) return;
+		if (!exists) {
 			this.childrenHash ??= /* @__PURE__ */ new Set();
-			this.childrenHash.add(hash);
-			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(hash);
+			this.childrenHash.add(childKey);
+			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(childKey);
 		}
-		if (app.childrenHash) addedByThisCall = this.#absorbChildrenHash(app, addedByThisCall);
+		if (app.childrenHash && !app["~scopeChild"]) 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();
@@ -728,20 +733,17 @@ var Elysia = class Elysia {
 			for (const child of app["~scopeChildren"]) children.push(child);
 		}
 		const hookChain = app["~hookChain"];
-		if (app["~ext"]) this.#absorbExt(app);
+		if (app["~ext"]) this.#absorbExt(app, 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 childrenHash = this.childrenHash;
+		for (let h of app.childrenHash) {
+			if (typeof h === "object") h = require_utils.pluginId(h);
+			if (childrenHash.has(h)) continue;
+			childrenHash.add(h);
 			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(h);
 		}
-		else {
-			this.childrenHash = new Set(incoming);
-			addedByThisCall = new Set(incoming);
-		}
 		return addedByThisCall;
 	}
 	/**
@@ -770,22 +772,26 @@ var Elysia = class Elysia {
 	*
 	* Keep the cold blocks in their own frames.
 	*/
-	#absorbExt(app) {
-		const { decorator, store, headers, models, parser, macro, hoc, setup, cleanup, capability } = app["~ext"];
+	#absorbExt(app, addedByThisCall) {
+		const source = app["~ext"];
+		const { decorator, store, headers, models, parser, macro, hoc, setup, cleanup, capability } = source;
 		const ext = this["~ext"] ??= require_utils.nullObject();
-		if (decorator) {
+		if (app.scopeParent === this) {
+			for (const field of sharedTables) if (source[field]) ext[field] ??= source[field];
+		}
+		if (decorator && decorator !== ext.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 (store && store !== ext.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 (headers && headers !== ext.headers) ext.headers = Object.assign(ext.headers ?? require_utils.nullObject(), headers);
+		if (models && models !== ext.models) ext.models = Object.assign(ext.models ?? require_utils.nullObject(), models);
+		if (parser && parser !== ext.parser) ext.parser = Object.assign(ext.parser ?? require_utils.nullObject(), parser);
 		if (macro) if (app["~scopeChild"]) {
 			const pluginMacros = app.pluginMacros;
 			let changed = false;
@@ -806,7 +812,20 @@ var Elysia = class Elysia {
 			}
 			require_utils.invalidateMacroEpoch();
 		}
-		if (hoc) ext.hoc = mergeExtCallbacks(ext.hoc, hoc);
+		if (hoc) {
+			const childrenHash = this.childrenHash;
+			const target = ext.hoc ??= [];
+			const origins = ext.hocOrigin ??= [];
+			for (let i = 0; i < hoc.length; i++) {
+				const fn = hoc[i];
+				const registration = source.hocOrigin?.[i] ?? app.hash;
+				const origin = typeof registration === "object" ? registration.origin ??= app.hash : registration;
+				if (origin !== void 0 && childrenHash.has(origin) && !addedByThisCall?.has(origin)) continue;
+				if (target.some((f, j) => f === fn && hocOriginOf(origins[j]) === origin)) continue;
+				origins.push(registration);
+				target.push(fn);
+			}
+		}
 		if (setup) ext.setup = mergeExtCallbacks(ext.setup, setup);
 		if (cleanup) ext.cleanup = mergeExtCallbacks(ext.cleanup, cleanup);
 		if (capability) {
@@ -844,10 +863,6 @@ var Elysia = class Elysia {
 	* Split out from #use, see #absorbExt
 	*/
 	#propagateHooks(app, hookChain, addedByThisCall) {
-		let pluginEvents;
-		let globalEvents;
-		let pluginMayRef = false;
-		let globalMayRef = false;
 		const nodes = useNodesBuffer;
 		nodes.length = 0;
 		let current = hookChain;
@@ -859,96 +874,71 @@ var Elysia = class Elysia {
 			nodes.push(current);
 			current = current.parent;
 		}
+		const childrenHash = this.childrenHash;
+		const scopeChild = app["~scopeChild"];
+		let held = propagatedRegistrations.get(this);
+		const lifted = liftedRequests.get(this);
+		let lifting;
 		for (let i = nodes.length - 1; i >= 0; i--) {
 			const node = nodes[i];
-			const nodeScope = node.scope;
-			if (nodeScope !== "plugin" && nodeScope !== "global") continue;
-			if (nodeScope === "plugin" && node.propagated) continue;
-			const isGlobal = nodeScope === "global";
-			const added = node.added;
-			const keys = Object.keys(added);
-			for (let k = 0; k < keys.length; k++) {
-				const key = keys[k];
-				if (key === "schemas") {
-					const schemas = added.schemas;
-					if (!schemas) continue;
-					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);
-					continue;
-				}
-				if (key === "schema") continue;
-				if (require_utils.eventProperties.has(key)) {
-					const raw = added[key];
-					const many = Array.isArray(raw);
-					const count = many ? raw.length : 1;
-					for (let f = 0; f < count; f++) {
-						const fn = many ? raw[f] : raw;
-						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);
-					}
-					continue;
-				}
-				if (key === "~deriveEntries") {
-					const entries = added[key];
-					if (!entries) continue;
-					const target = isGlobal ? globalEvents ??= require_utils.nullObject() : pluginEvents ??= require_utils.nullObject();
-					const list = target[key] ??= [];
-					for (let j = 0; j < entries.length; j++) list.push(entries[j]);
-					continue;
-				}
-				const target = isGlobal ? globalEvents ??= require_utils.nullObject() : pluginEvents ??= require_utils.nullObject();
-				if (isGlobal) globalMayRef = true;
-				else pluginMayRef = true;
-				target[key] = added[key];
+			const scope = node.scope;
+			if (scope === "plugin" ? node.propagated : scope !== "global") continue;
+			let source = node.added;
+			if (scopeChild) {
+				const request = source.request;
+				if (!request) continue;
+				source = require_utils.nullObject();
+				source.request = request;
+			}
+			const origin = node.origin ?? app.hash;
+			const registration = node.registration ?? node;
+			let added = source;
+			let repeated = false;
+			if (origin !== void 0) {
+				if (!held) propagatedRegistrations.set(this, held = /* @__PURE__ */ new WeakMap());
+				const through = held.get(registration);
+				if (!through) held.set(registration, [origin]);
+				else if (through.includes(origin)) repeated = true;
+				else through.push(origin);
 			}
+			const registrant = registration.origin;
+			if (repeated) {
+				const schemas = source.schemas;
+				if (!schemas) continue;
+				added = require_utils.nullObject();
+				added.schemas = schemas;
+			} else if (registrant !== void 0 && childrenHash?.has(registrant) && !addedByThisCall?.has(registrant)) {
+				added = require_utils.nullObject();
+				for (const key in source) if (key !== "~deriveEntries" && !require_utils.eventProperties.has(key)) added[key] = source[key];
+			}
+			let dropRequest = false;
+			if (origin !== void 0 && "request" in added) {
+				if (lifted?.has(origin)) dropRequest = true;
+				else if (scopeChild) (lifting ??= new Set(lifted)).add(origin);
+			}
+			if ("schema" in added || dropRequest) {
+				if (added === source) added = Object.assign(require_utils.nullObject(), source);
+				delete added.schema;
+				if (dropRequest) delete added.request;
+			}
+			if (require_utils.isNotEmpty(added)) this.#pushChainNode(added, scope, registration, origin, app);
 		}
+		if (lifting) liftedRequests.set(this, lifting);
 		nodes.length = 0;
-		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;
 		const limit = declared.length;
-		const tail = app["~hookChain"];
-		let recent;
-		let hasLocal = false;
+		const callback = app["~scopeChild"] ? app["~hookChain"] : void 0;
 		let lastChildChain;
 		let lastCombined;
-		let lastTailChild = null;
-		let lastTailCombined;
+		let lastInner = null;
+		let lastCovered;
 		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 (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;
+			if (childChain === void 0) inheritedChain = preChain;
 			else if (preChain === void 0) inheritedChain = childChain;
 			else if (childChain === lastChildChain) inheritedChain = lastCombined;
 			else {
@@ -959,6 +949,19 @@ var Elysia = class Elysia {
 					refs: childChain.refs || preChain.refs
 				};
 			}
+			if (callback) {
+				if (inheritedChain !== lastInner) {
+					lastInner = inheritedChain;
+					lastCovered = {
+						combine: inheritedChain,
+						over: void 0,
+						callback,
+						inner: childChain,
+						refs: !!(inheritedChain?.refs || callback.refs)
+					};
+				}
+				inheritedChain = lastCovered;
+			}
 			this.#emitRoute(route, this["~scopeChild"] ? this : void 0, this["~Prefix"], inheritedChain, name);
 		}
 	}
@@ -988,11 +991,11 @@ var Elysia = class Elysia {
 		});
 	}
 	get pending() {
-		return this._pending > 0;
+		return this.#pending > 0;
 	}
 	#useAsync(promise) {
 		if (!this.ready) this._error = void 0;
-		this._pending++;
+		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;
@@ -1016,19 +1019,19 @@ var Elysia = class Elysia {
 				}
 			}
 		}).finally(() => {
-			this._pending--;
+			this.#pending--;
 		}).then(() => {}, (err) => {
 			this._error ??= { error: err };
 			console.error(err);
 		}).finally(() => {
-			if (this._pending > 0) return;
+			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;
+			this.#routerBuilt = false;
 			require_context.clearContextCache(this);
 			try {
 				this.#buildRouter(false);
@@ -1080,7 +1083,7 @@ var Elysia = class Elysia {
 			handler,
 			this
 		]);
-		if (this.routerBuilt || this.compiled !== void 0) this.#invalidate();
+		if (this.#routerBuilt || this.compiled !== void 0) this.#invalidateRouter();
 		return this;
 	}
 	#assertMutable(api) {
@@ -1088,8 +1091,15 @@ var Elysia = class Elysia {
 		if (this["~generation"] === void 0) return;
 		throw new Error(`[Elysia] .${api}() called after the app was sealed by its first request, listen or compile`);
 	}
+	/**
+	* `#assertMutable` for the tables a group child shares with its parents:
+	* a child kept past its callback must not write into a sealed one
+	*/
+	#assertTableMutable(api) {
+		for (let app = this; app; app = app.scopeParent) app.#assertMutable(api);
+	}
 	get #isCacheable() {
-		return this["~generation"] !== void 0 && this.routerBuilt && !require_compile_aot.Capture.isCapturing();
+		return this["~generation"] !== void 0 && this.#routerBuilt && !require_compile_aot.Capture.isCapturing();
 	}
 	#cacheRoutes(generation) {
 		if (this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch) return;
@@ -1112,29 +1122,29 @@ var Elysia = class Elysia {
 		const sequence = routes.length;
 		routes.push(route);
 		if (source) (this.routeSources ??= [])[sequence] = source;
-		if (this.routerBuilt || this.compiled !== void 0) this.#invalidate();
+		if (this.#routerBuilt || this.compiled !== void 0) this.#invalidateRouter();
 	}
-	#invalidate() {
+	#invalidateRouter() {
 		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;
+		this.#routerBuilt = false;
 	}
 	model(name, model) {
-		this.#assertMutable("model");
-		const models = this.ext.models ??= require_utils.nullObject();
+		this.#assertTableMutable("model");
+		const models = this.#table("models");
 		switch (typeof name) {
 			case "object":
 				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);
-				const next = require_utils.nullObject();
+				const next = remapped === models ? models : require_utils.nullObject();
 				for (const key in remapped) next[key] = toModel(key, remapped[key]);
-				this.ext.models = next;
+				this.#ext.models = next;
 				return this;
 			}
 			case "string":
@@ -1146,7 +1156,7 @@ var Elysia = class Elysia {
 	* Registered reusable models (via `.model()`), keyed by name.
 	*/
 	get models() {
-		return this["~ext"]?.models ?? require_utils.nullObject();
+		return this["~ext"]?.models ?? this.scopeParent?.models ?? require_utils.nullObject();
 	}
 	Ref(key) {
 		return require_type_bridge.Ref(key);
@@ -1243,13 +1253,13 @@ var Elysia = class Elysia {
 	compile() {
 		this["~config"] ??= require_utils.nullObject();
 		this["~config"].precompile = true;
-		this.#invalidate();
+		this.#invalidateRouter();
 		this.fetch;
 		return this;
 	}
 	handler(index, immediate, route, aliases, table) {
 		if (this.compiled?.[index]) return this.compiled[index];
-		const indexedTable = table ?? (this.routerBuilt ? this["~routeTable"] : void 0);
+		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]);
@@ -1268,7 +1278,7 @@ var Elysia = class Elysia {
 		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);
+		return (context) => this["~dispatch"](index, context);
 	}
 	#staticAliases(table, index) {
 		const flags = table.flags[index];
@@ -1294,6 +1304,7 @@ var Elysia = class Elysia {
 		};
 	}
 	#releaseJit() {
+		require_compile_handler_descriptor.releaseAnalysisCaches();
 		require_compile_aot.Compiled.release(this["~programId"]);
 		this.jitColdRemaining = void 0;
 		this.jitRoute = void 0;
@@ -1312,7 +1323,7 @@ var Elysia = class Elysia {
 		this.#releaseJit();
 		return true;
 	}
-	#jitDispatch(index, context) {
+	"~dispatch"(index, context) {
 		if (this.compiled[index]) return this.compiled[index](context);
 		const route = this.jitRoute?.[index];
 		const table = this.jitTable ?? this["~routeTable"];
@@ -1324,7 +1335,7 @@ var Elysia = class Elysia {
 		} 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);
+			if (finalize) return finalize(context, routeError, void 0, true);
 			throw routeError;
 		}
 		this.compiled[index] = handler;
@@ -1369,11 +1380,11 @@ var Elysia = class Elysia {
 		}
 		return false;
 	}
-	static #slotHasTypeBox(value, models, record) {
+	static #slotHasTypeBox(value, models, allowStatusMap) {
 		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;
+		if (!allowStatusMap || "~standard" in value) return false;
 		for (const status in value) if (Elysia.#slotHasTypeBox(value[status], models)) return true;
 		return false;
 	}
@@ -1399,7 +1410,7 @@ var Elysia = class Elysia {
 				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;
+				if (Elysia.#chainHasTypeBox(node.combine, models, seen, resolve)) return true;
 				node = node.over;
 			}
 		}
@@ -1430,8 +1441,9 @@ 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;
 		}
@@ -1466,8 +1478,8 @@ var Elysia = class Elysia {
 				Object.assign(previousRouter, nextRouter);
 				this["~router"] = previousRouter;
 			}
-			this.routerBuilt = true;
 			if (seal) this.#publishGeneration();
+			this.#routerBuilt = true;
 			buildSucceeded = true;
 		} catch (error) {
 			this["~map"] = previousMap;
@@ -1519,9 +1531,10 @@ var Elysia = class Elysia {
 			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);
+		if (ext?.decorator) require_utils.markPropertySingletons(ext.decorator);
+		if (ext?.store) require_utils.markPropertySingletons(ext.store);
 	}
 	#buildRouterUnsafe() {
 		const precompile = this["~config"]?.precompile;
@@ -1624,8 +1637,14 @@ var Elysia = class Elysia {
 			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, table);
-				for (let p = 0; p < paths.length; p++) router.add(routeMethod, paths[p], handler);
+				let store;
+				if (precompile || this.compiled?.[i]) store = this.handler(i, precompile, void 0, void 0, table);
+				else {
+					this.compiled ??= new Array(length);
+					this.jitTable = table;
+					store = i;
+				}
+				for (let p = 0; p < paths.length; p++) router.add(routeMethod, paths[p], store);
 			} else {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
 				const handler = this.handler(i, precompile, void 0, {
@@ -1643,15 +1662,15 @@ var Elysia = class Elysia {
 			const run = () => this.fetch(request, ...rest);
 			return this.ready ? this.modules.then(run, run) : run();
 		};
-		return this.#dispatch();
+		return this.#buildFetch();
 	}
-	#dispatch() {
-		this.#buildRouter(!this._pending);
+	#buildFetch() {
+		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));
 	}
 	get handle() {
-		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);
+		return this._handle ??= async (requestOrUrl, options) => (this.fetchFn ?? this.#buildFetch())(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;
@@ -1671,17 +1690,18 @@ var Elysia = class Elysia {
 	*
 	* new Elysia()
 	*	.wrap(
-	*		(fetch) => (request) =>
-	*			ctx.run({ counter: 0 }, () => fetch(request))
+	*		(fetch) => (request, ...rest) =>
+	*			ctx.run({ counter: 0 }, () => fetch(request, ...rest))
 	*	)
 	*	.get('/', () => ctx.getStore())
 	* ```
 	*/
 	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);
+		(ext.hocOrigin ??= []).push(this.hash ?? {});
 		return this;
 	}
 	/**
@@ -1700,7 +1720,7 @@ var Elysia = class Elysia {
 	cleanup(handler) {
 		if (this["~ext"]?.cleanupEpoch?.(handler)) return this;
 		this.#assertMutable("cleanup");
-		(this.ext.cleanup ??= []).push(...[].concat(handler));
+		(this.#ext.cleanup ??= []).push(...[].concat(handler));
 		return this;
 	}
 	/**