elysia 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/base.mjs

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

package/dist/compile/aot-capture.js

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

package/dist/compile/aot-capture.mjs

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

package/dist/compile/aot.d.ts

@@ -8,8 +8,7 @@ interface AotFingerprint {
 interface ProgramId {
   readonly _: unique symbol;
 }
-declare const createProgramId: () => ProgramId;
-declare function createAotFingerprint(): AotFingerprint;
+declare const createAotFingerprint: () => AotFingerprint;
 interface CompilerSession {
   readonly sucroseCache: Map<number, {
     content: string;
@@ -91,7 +90,7 @@ interface HandlerManifest {
 }
 interface CompiledSnapshot {
   registered: CompiledProgramRegistration | undefined;
-  claimed: boolean;
+  claimed: WeakRef<ProgramId> | undefined;
   programs: WeakMap<ProgramId, CompiledProgram>;
 }
 interface CompiledProgramRegistration {
@@ -131,9 +130,11 @@ declare function reconstruct(): ReconstructImpl;
 declare abstract class Compiled {
   static register(manifest: CompiledProgramRegistration): void;
   static claim(id: ProgramId, fingerprint: AotFingerprint): boolean;
+  static assertUncontested(id: ProgramId): void;
   static get reconstruct(): ReconstructImpl | undefined;
   static set reconstruct(impl: ReconstructImpl | undefined);
   static getHandler(id: ProgramId | undefined, method: string, path: string): FrozenHandler | undefined;
+  static hasProgram(id: ProgramId | undefined): boolean;
   static getValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): FrozenValidator | undefined;
   static hasValidator(method: string, path: string, slot: ValidatorSlot, id?: ProgramId): boolean;
   static getPlanRebuilder(id?: ProgramId): ((original: unknown, plan: CoercePlan) => any) | undefined;
@@ -284,4 +285,4 @@ interface CaptureImpl {
 declare let captureImpl: CaptureImpl | undefined;
 declare function setCaptureImpl(impl: CaptureImpl | undefined): void;
 //#endregion
-export { AOT_ABI, AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, createProgramId, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };
+export { AOT_ABI, AOT_MANIFEST_FORMAT, AotFingerprint, Capture, CaptureImpl, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, CompiledProgramRegistration, CompiledSnapshot, CompilerSession, CompilerState, EMPTY_EXTERNALS, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, ProgramId, ReconstructImpl, StringCodecNode, ValidatorManifest, ValidatorSlot, aotActivationError, beginCompilerSession, captureImpl, createAotFingerprint, endCompilerSession, getCompilerSession, reconstruct, setCaptureImpl };

package/dist/compile/aot.js

@@ -6,11 +6,8 @@ const require_package = require('../package.js');
 //#region src/compile/aot.ts
 const AOT_MANIFEST_FORMAT = 3;
 const AOT_ABI = `${require_package.version}:${3}`;
-const createProgramId = () => ({});
 const sharedAotFingerprint = Object.freeze({ abi: AOT_ABI });
-function createAotFingerprint() {
-	return sharedAotFingerprint;
-}
+const createAotFingerprint = () => sharedAotFingerprint;
 let activeSession;
 const newCompilerSession = () => ({ sucroseCache: /* @__PURE__ */ new Map() });
 function beginCompilerSession(app) {
@@ -41,7 +38,12 @@ function reconstruct() {
 	return reconstructImpl;
 }
 let registered;
-let claimed = false;
+/**
+* App that consumed this process's manifest, held weakly: it only has to
+* recognise a re-claim by the *same* app, and `assertUncontested` always
+* compares against a live id, so a cleared ref answers as a strong one would
+*/
+let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
 const fingerprintMismatch = (manifest, actual) => {
@@ -54,14 +56,14 @@ const fingerprintMismatch = (manifest, actual) => {
 var Compiled = class {
 	static register(manifest) {
 		registered = manifest;
-		claimed = false;
+		claimed = void 0;
 	}
 	static claim(id, fingerprint) {
 		if (!registered || claimed) return false;
 		const manifest = registered;
 		const differences = fingerprintMismatch(manifest, fingerprint);
 		if (differences.length) throw new Error(`[elysia-aot] Registered manifest fingerprint mismatch: ${differences.join("; ")}.`);
-		claimed = true;
+		claimed = new WeakRef(id);
 		registered = void 0;
 		programs.set(id, {
 			...manifest,
@@ -69,6 +71,10 @@ var Compiled = class {
 		});
 		return true;
 	}
+	static assertUncontested(id) {
+		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
+		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
+	}
 	static get reconstruct() {
 		return reconstructImpl;
 	}
@@ -78,6 +84,9 @@ var Compiled = class {
 	static getHandler(id, method, path) {
 		return programFor(id)?.handlers?.[method]?.[path];
 	}
+	static hasProgram(id) {
+		return programFor(id) !== void 0;
+	}
 	static getValidator(method, path, slot, id) {
 		const program = programFor(id);
 		if (!program) return void 0;
@@ -116,7 +125,7 @@ var Compiled = class {
 	/** @internal test isolation */
 	static clear() {
 		registered = void 0;
-		claimed = false;
+		claimed = void 0;
 		programs = /* @__PURE__ */ new WeakMap();
 	}
 };
@@ -213,7 +222,6 @@ Object.defineProperty(exports, 'captureImpl', {
   }
 });
 exports.createAotFingerprint = createAotFingerprint;
-exports.createProgramId = createProgramId;
 exports.endCompilerSession = endCompilerSession;
 exports.getCompilerSession = getCompilerSession;
 exports.reconstruct = reconstruct;