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

package/dist/adapter/utils.mjs

@@ -157,10 +157,12 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 			return new Response(generator, { headers: { "content-type": "application/octet-stream" } });
 		}
 		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
+		const sourceIterator = typeof generator.next === "function" ? generator : void 0;
 		let init = typedSSE ? void 0 : generator.next?.();
 		if (set) handleSet(set);
 		if (init instanceof Promise) init = await init;
-		if (init?.value instanceof ReadableStream) generator = init.value;
+		const yieldedStream = init?.value instanceof ReadableStream;
+		if (yieldedStream) generator = init.value;
 		else if (init && (typeof init?.done === "undefined" || init?.done)) {
 			if (set) return mapResponse(init.value, set, request, owned);
 			return mapCompactResponse(init.value, request, owned);
@@ -194,8 +196,32 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				connection: "keep-alive"
 			}
 		};
-		const iterator = typeof generator.next === "function" ? generator : generator[Symbol.asyncIterator]();
+		const sourceStream = generator instanceof ReadableStream ? generator : void 0;
+		let streamReader;
+		const iterator = sourceStream ? {
+			next: () => (streamReader ??= sourceStream.getReader()).read(),
+			async return() {
+				if (!streamReader) {
+					await sourceStream.cancel();
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+				try {
+					await streamReader.cancel();
+				} finally {
+					streamReader.releaseLock();
+				}
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+		} : sourceIterator ?? generator[Symbol.asyncIterator]();
+		const outerIterator = yieldedStream && !init.done ? sourceIterator : void 0;
 		let end = false;
+		let finalizing;
 		const signal = request?.signal;
 		let onAbort;
 		const cleanupAbort = () => {
@@ -204,17 +230,21 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				onAbort = void 0;
 			}
 		};
-		const safeReturn = () => {
+		const safeReturn = async (target) => {
 			try {
-				const r = iterator.return?.();
-				if (r && typeof r.then === "function") r.catch(() => {});
+				await target?.return?.();
 			} catch {}
 		};
-		const closeSafely = (controller) => {
+		const finalize = (mode, controller, error) => {
+			if (end) return finalizing;
+			end = true;
+			cleanupAbort();
+			finalizing = safeReturn(iterator).then(() => safeReturn(outerIterator));
+			if (!controller) return finalizing;
 			try {
-				controller.close();
+				if (mode === "error") controller.error(error);
+				else controller.close();
 			} catch {}
-			cleanupAbort();
 		};
 		const enqueueValue = async (controller, value) => {
 			if (value.toSSE) {
@@ -233,42 +263,33 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		return new Response(new ReadableStream({
 			async start(controller) {
 				if (signal) {
-					onAbort = () => {
-						cleanupAbort();
-						end = true;
-						safeReturn();
-						try {
-							controller.close();
-						} catch {}
-					};
+					onAbort = () => finalize("close", controller);
 					if (signal.aborted) onAbort();
 					else signal.addEventListener("abort", onAbort, { once: true });
 				}
 				if (!init || init.value instanceof ReadableStream || init.value === void 0 || init.value === null) return;
-				await enqueueValue(controller, init.value);
+				try {
+					await enqueueValue(controller, init.value);
+				} catch (error) {
+					finalize("error", controller, error);
+				}
 			},
 			async pull(controller) {
-				if (end) {
-					closeSafely(controller);
-					return;
-				}
+				if (end) return;
 				try {
 					const { value: chunk, done } = await iterator.next();
 					if (done || end) {
-						closeSafely(controller);
+						finalize("close", controller);
 						return;
 					}
 					if (chunk === void 0 || chunk === null) return;
 					await enqueueValue(controller, chunk);
 				} catch (error) {
-					cleanupAbort();
-					controller.error(error);
+					finalize("error", controller, error);
 				}
 			},
 			cancel() {
-				end = true;
-				cleanupAbort();
-				safeReturn();
+				finalize("close");
 			}
 		}, typedSSE ? { highWaterMark: 0 } : void 0), set);
 	};

package/dist/base.d.ts

@@ -39,6 +39,10 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     hoc?: WrapFn<any>[];
     setup?: GracefulHandler<any>[];
     cleanup?: GracefulHandler<any>[];
+    cleanupEpoch?: (handler: GracefulHandler<any> | GracefulHandler<any>[]) => boolean;
+    stop?: (closeActiveConnections?: boolean, failure?: {
+      error: unknown;
+    }) => Promise<void>;
     capability?: {
       trace?: {
         provider: TraceCapability;
@@ -900,12 +904,19 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   cleanup(handler: MaybeArray<GracefulHandler<this>>): 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.
    *
-   * @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; 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 active
+   *   transports. Omit (or pass `false`) to drain safely.
    */
   stop(closeActiveConnections?: boolean): Promise<void> | void;
 }

package/dist/base.js

@@ -9,6 +9,7 @@ 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');
@@ -18,6 +19,23 @@ memoirist = require_runtime.__toESM(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.
@@ -755,27 +773,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 ??= require_utils.nullObject();
 			if (capability.trace) {
@@ -954,11 +957,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;
 		});
 	}
@@ -973,13 +976,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;
@@ -988,10 +991,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);
+		require_context.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 = require_utils.joinPath(this["~Prefix"], path);
@@ -1211,20 +1224,22 @@ var Elysia = class Elysia {
 	}
 	handler(index, immediate, route, precomputedStatic, aliases, table) {
 		if (this.#compiled?.[index]) return this.#compiled[index];
-		const compiled = this.#compiled ??= new Array(table?.length ?? this["~routes"].length);
+		const indexedTable = table ?? (this.#routerBuilt ? this["~routeTable"] : void 0);
+		const compiled = this.#compiled ??= new Array(indexedTable?.length ?? this["~routes"].length);
 		if (immediate ?? this["~config"]?.precompile) {
-			const row = route ?? (table ? require_route_table.routeRow(table, index) : this["~routes"][index]);
+			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, precomputedStatic, 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);
+		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;
@@ -1233,12 +1248,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 & (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.#jitStatic = 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);
+		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, this.#jitStatic?.[index], 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"];
@@ -1246,24 +1307,15 @@ var Elysia = class Elysia {
 			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;
+		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 (!(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;
@@ -1404,19 +1456,30 @@ 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 routeCount = table.length;
 				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"]);
+				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;
 		}
+		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;
@@ -1440,23 +1503,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(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]);
+		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);
 				}
 			}
 		}
@@ -1563,6 +1634,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);
@@ -1570,24 +1642,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);
+			}
+			require_utils.throwLifecycleErrors(errors);
+		})();
 	}
 };