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

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,7 +19,47 @@ 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.
+*
+* `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 = require_utils.getLoosePath(p);
+		if (loose !== p && !explicit?.has(loose)) paths.push(loose);
+	}
+	return paths;
+};
 var Elysia = class Elysia {
 	#hasPlugin;
 	#hasGlobal;
@@ -80,11 +121,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
@@ -102,7 +146,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,7 +167,6 @@ 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;
@@ -729,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) {
@@ -928,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;
 		});
 	}
@@ -947,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;
@@ -962,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);
@@ -1183,22 +1222,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 ? require_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 ? 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;
@@ -1207,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"];
@@ -1220,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;
@@ -1378,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;
@@ -1414,20 +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]);
-		if (length) require_compile_aot.Compiled.claim(this["~programId"], this["~aotFingerprint"] = require_compile_aot.createAotFingerprint());
+		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,17 +1540,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 & 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();
@@ -1461,26 +1561,12 @@ var Elysia = class Elysia {
 			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);
 				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) {
 				const router = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
 				const handler = this.handler(i, precompile, void 0, void 0, void 0, table);
@@ -1548,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);
@@ -1555,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);
+		})();
 	}
 };