elysia 2.0.0-beta.26 → 2.0.0-beta.27

package/dist/adapter/bun/index.js

@@ -52,15 +52,6 @@ async function settleServerWebSockets(lifecycle, errors) {
 	} while (lifecycle.sockets.size);
 	return true;
 }
-/**
-* ! This may looks like it would cause race condition, but it is not
-* Bun is single-threaded and synchronous, so the `finally` block will
-* always run before the next request comes in
-* @see ../origin.ts
-*
-* `finally` runs on the synchronous return of `fetch` (the returned promise is
-* not awaited), so the slot is live only for the handler's synchronous prologue
-*/
 const withOrigin = (fetch) => (request, server) => {
 	require_adapter_origin.origin.request = request;
 	try {
@@ -92,16 +83,6 @@ function isNativePath(path) {
 	}
 	return true;
 }
-/**
-* HTML bundles served by Bun's native router.
-*
-* A `:param` / `*` bundle matches before `fetch`, so with a `handoff` every
-* other route of that method is registered natively too, pointing at `fetch`;
-* Bun's specificity (exact > param > wildcard) then picks the Elysia route over
-* the bundle (Elysia's own router skips these bundles, see `#buildRouterUnsafe`).
-* If any route can't be expressed in Bun's router, dynamic bundles are skipped
-* entirely, since the bundle would shadow that route.
-*/
 function collectHTMLBundleRoutes(app, handoff, routes) {
 	let dynamic;
 	let bundles;

package/dist/adapter/bun/index.mjs

@@ -52,15 +52,6 @@ async function settleServerWebSockets(lifecycle, errors) {
 	} while (lifecycle.sockets.size);
 	return true;
 }
-/**
-* ! This may looks like it would cause race condition, but it is not
-* Bun is single-threaded and synchronous, so the `finally` block will
-* always run before the next request comes in
-* @see ../origin.ts
-*
-* `finally` runs on the synchronous return of `fetch` (the returned promise is
-* not awaited), so the slot is live only for the handler's synchronous prologue
-*/
 const withOrigin = (fetch) => (request, server) => {
 	origin.request = request;
 	try {
@@ -92,16 +83,6 @@ function isNativePath(path) {
 	}
 	return true;
 }
-/**
-* HTML bundles served by Bun's native router.
-*
-* A `:param` / `*` bundle matches before `fetch`, so with a `handoff` every
-* other route of that method is registered natively too, pointing at `fetch`;
-* Bun's specificity (exact > param > wildcard) then picks the Elysia route over
-* the bundle (Elysia's own router skips these bundles, see `#buildRouterUnsafe`).
-* If any route can't be expressed in Bun's router, dynamic bundles are skipped
-* entirely, since the bundle would shadow that route.
-*/
 function collectHTMLBundleRoutes(app, handoff, routes) {
 	let dynamic;
 	let bundles;

package/dist/adapter/origin.js

@@ -1,63 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/adapter/origin.ts
-/**
-* Provenance channel for deferred abort-signal arming.
-*
-* Bun materializes `Request.signal` lazily (~214ns on the first read), so
-* Elysia only pays for it once the pipeline can actually observe an abort,
-* that is, after it suspends. Deferring that read is only sound for the exact
-* `Request` instance `Bun.serve` handed to `fetch`: any other request
-* (`app.handle`, a non-Bun adapter, or a `.wrap()` HOC that substitutes the
-* request) may carry a user-controlled signal that is already aborted at entry
-* and therefore must be observed synchronously.
-*
-* The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
-* to run, for the compiled route's own entry probe, which is still inside that
-* same synchronous frame, then clears it in `finally`, so the window closes
-* before the first suspension and cannot leak across concurrent requests.
-* A `.wrap()` HOC that replaces the request or defers calling `next()` past a
-* microtask simply misses the window, fetch handler falls back to eager check
-*
-* ## "A single shared slot that every request writes to, so a race condition?"
-*
-* It looks like one, but it can't be. Explained like you're five:
-*
-* JavaScript only ever does ONE thing at a time. When a request comes in, the
-* adapter writes its name on the whiteboard (`origin.request = request`),
-* walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens, in `fetch`'s prologue, or at the
-* compiled route's entry when `fetch` had no hook to run first), and erases
-* the whiteboard `finally`
-* all in one uninterruptible turn. The next request's turn CANNOT start
-* until this turn is completely finished, because that is how the event loop
-* works: run-to-completion, no preemption. So request B can never see request
-* A's name on the board, by the time B's turn starts, the board was already
-* erased at the end of A's turn.
-*
-* "But the handler is async!" the `await`s inside it run LATER, in separate
-* turns. That is fine, because the check already happened: the verdict was
-* copied onto that request's own context (`'~sig'`) during the synchronous
-* part, and the code that runs after an `await` only ever reads the context,
-* never this slot.
-*
-* And if any assumption here ever breaks, a runtime that re-enters, a wrap
-* that delays, a future edit that sneaks an `await` in before the check the
-* comparison simply MISSES and the request falls back to eager arming, which
-* is the exact pre-optimization behavior. Every failure mode makes a request
-* slightly slower, never incorrect
-*
-* Adversarial proof, not just argument: `test/core/abort-race.test.ts` storms
-* concurrent servers, in-process `handle()` calls, request-substituting and
-* `next()`-delaying wraps at this slot and asserts zero misclassification.
-*
-* Never infer the Bun runtime from `fetch`'s second argument: Cloudflare
-* Workers pass `env` there.
-*
-* It's insanely stupid, but it works. As Bun is single-threaded and synchronous
-* so the `finally` block will always run before the next request comes in.
-*/
 const origin = { request: void 0 };
 
 //#endregion

package/dist/adapter/origin.mjs

@@ -1,62 +1,5 @@
 // @bun
 //#region src/adapter/origin.ts
-/**
-* Provenance channel for deferred abort-signal arming.
-*
-* Bun materializes `Request.signal` lazily (~214ns on the first read), so
-* Elysia only pays for it once the pipeline can actually observe an abort,
-* that is, after it suspends. Deferring that read is only sound for the exact
-* `Request` instance `Bun.serve` handed to `fetch`: any other request
-* (`app.handle`, a non-Bun adapter, or a `.wrap()` HOC that substitutes the
-* request) may carry a user-controlled signal that is already aborted at entry
-* and therefore must be observed synchronously.
-*
-* The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
-* to run, for the compiled route's own entry probe, which is still inside that
-* same synchronous frame, then clears it in `finally`, so the window closes
-* before the first suspension and cannot leak across concurrent requests.
-* A `.wrap()` HOC that replaces the request or defers calling `next()` past a
-* microtask simply misses the window, fetch handler falls back to eager check
-*
-* ## "A single shared slot that every request writes to, so a race condition?"
-*
-* It looks like one, but it can't be. Explained like you're five:
-*
-* JavaScript only ever does ONE thing at a time. When a request comes in, the
-* adapter writes its name on the whiteboard (`origin.request = request`),
-* walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens, in `fetch`'s prologue, or at the
-* compiled route's entry when `fetch` had no hook to run first), and erases
-* the whiteboard `finally`
-* all in one uninterruptible turn. The next request's turn CANNOT start
-* until this turn is completely finished, because that is how the event loop
-* works: run-to-completion, no preemption. So request B can never see request
-* A's name on the board, by the time B's turn starts, the board was already
-* erased at the end of A's turn.
-*
-* "But the handler is async!" the `await`s inside it run LATER, in separate
-* turns. That is fine, because the check already happened: the verdict was
-* copied onto that request's own context (`'~sig'`) during the synchronous
-* part, and the code that runs after an `await` only ever reads the context,
-* never this slot.
-*
-* And if any assumption here ever breaks, a runtime that re-enters, a wrap
-* that delays, a future edit that sneaks an `await` in before the check the
-* comparison simply MISSES and the request falls back to eager arming, which
-* is the exact pre-optimization behavior. Every failure mode makes a request
-* slightly slower, never incorrect
-*
-* Adversarial proof, not just argument: `test/core/abort-race.test.ts` storms
-* concurrent servers, in-process `handle()` calls, request-substituting and
-* `next()`-delaying wraps at this slot and asserts zero misclassification.
-*
-* Never infer the Bun runtime from `fetch`'s second argument: Cloudflare
-* Workers pass `env` there.
-*
-* It's insanely stupid, but it works. As Bun is single-threaded and synchronous
-* so the `finally` block will always run before the next request comes in.
-*/
 const origin = { request: void 0 };
 
 //#endregion

package/dist/adapter/utils.js

@@ -132,7 +132,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		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 (init instanceof Promise) init = await init;
+		if (init instanceof Promise || typeof init?.then === "function") init = await init;
 		const sign = set?.["~sign"];
 		if (sign) try {
 			await sign(set);
@@ -430,12 +430,6 @@ const doneResult = {
 	done: true,
 	value: void 0
 };
-/**
-* Tee a returned `ReadableStream` so afterResponse, `defer()` and derive
-* dispose wait for it, as for a tee'd generator. A `bytes()` stream is left
-* alone (exact-stream contract), and so is a `Response`: reading its `.body`
-* would move it off Bun's native send path
-*/
 function observeStream(source) {
 	if (source.locked || require_utils.isByteStream(source)) return;
 	const reader = source.getReader();
@@ -467,24 +461,6 @@ function observeStream(source) {
 		value
 	];
 }
-/**
-* Split async source into `branches` independent iterators
-*
-* A producer drains the source ahead of consumers
-*
-* To prevent long/infinite stream, the unconsumed window is capped:
-* Consumed-by-every-branch entries are trimmed off the front
-* Producer backpressures whenever the window hits `cap` ENTRIES or
-* `capBytes` bytes, whichever comes first
-*
-* Streams below both caps buffer eagerly
-* Only streams exceeding one gate on the slowest consumer
-*
-* Branch 0 is the value consumer (response/client)
-* When `return()` (client abort / early exit), source is stopped
-* so the observer branches can still reach completion instead of spinning
-* an infinite source
-*/
 function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 	const iterator = source[Symbol.asyncIterator]?.() ?? source[Symbol.iterator]();
 	const buffer = [];

package/dist/adapter/utils.mjs

@@ -132,7 +132,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		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 (init instanceof Promise) init = await init;
+		if (init instanceof Promise || typeof init?.then === "function") init = await init;
 		const sign = set?.["~sign"];
 		if (sign) try {
 			await sign(set);
@@ -430,12 +430,6 @@ const doneResult = {
 	done: true,
 	value: void 0
 };
-/**
-* Tee a returned `ReadableStream` so afterResponse, `defer()` and derive
-* dispose wait for it, as for a tee'd generator. A `bytes()` stream is left
-* alone (exact-stream contract), and so is a `Response`: reading its `.body`
-* would move it off Bun's native send path
-*/
 function observeStream(source) {
 	if (source.locked || isByteStream(source)) return;
 	const reader = source.getReader();
@@ -467,24 +461,6 @@ function observeStream(source) {
 		value
 	];
 }
-/**
-* Split async source into `branches` independent iterators
-*
-* A producer drains the source ahead of consumers
-*
-* To prevent long/infinite stream, the unconsumed window is capped:
-* Consumed-by-every-branch entries are trimmed off the front
-* Producer backpressures whenever the window hits `cap` ENTRIES or
-* `capBytes` bytes, whichever comes first
-*
-* Streams below both caps buffer eagerly
-* Only streams exceeding one gate on the slowest consumer
-*
-* Branch 0 is the value consumer (response/client)
-* When `return()` (client abort / early exit), source is stopped
-* so the observer branches can still reach completion instead of spinning
-* an infinite source
-*/
 function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 	const iterator = source[Symbol.asyncIterator]?.() ?? source[Symbol.iterator]();
 	const buffer = [];

package/dist/adapter/web-standard/handler.js

@@ -86,7 +86,9 @@ function mapCompactResponse(response, request, owned) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
 		case "ElysiaForm": return new Response(require_utils.formToFormData(response));
-		case "Object": return Response.json(response);
+		case "Object":
+			if (typeof response?.next === "function") return handleStream(response, void 0, request, void 0, owned);
+			return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(String(response));
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);

package/dist/adapter/web-standard/handler.mjs

@@ -86,7 +86,9 @@ function mapCompactResponse(response, request, owned) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
 		case "ElysiaForm": return new Response(formToFormData(response));
-		case "Object": return Response.json(response);
+		case "Object":
+			if (typeof response?.next === "function") return handleStream(response, void 0, request, void 0, owned);
+			return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(String(response));
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);

package/dist/base.js

@@ -66,17 +66,11 @@ const toModel = (key, value) => {
 	value.$id ??= key;
 	return value;
 };
-const hookKeys = new Set([
-	...require_utils.schemaProperties,
-	...require_utils.eventProperties,
-	"detail",
-	"tags"
-]);
 const assertScope = (scope) => {
 	if (scope !== void 0 && scope !== "local" && scope !== "plugin" && scope !== "global") throw new Error(`[Elysia] Invalid hook scope ${JSON.stringify(scope)}, expected 'local', 'plugin' or 'global' (1.x 'scoped' is 'plugin')`);
 };
 const hasHookKeys = (value) => {
-	for (const key in value) if (hookKeys.has(key)) return true;
+	for (const key in value) if (require_utils.schemaProperties.has(key) || require_utils.eventProperties.has(key) || key === "detail" || key === "tags") return true;
 	return false;
 };
 function assertSchemaShape(hook, where) {
@@ -95,13 +89,6 @@ function assertSchemaShape(hook, where) {
 		throw new Error(`[Elysia] ${where}: "${key}" is not a schema — use t.Object({ ... })`);
 	}
 }
-/**
-* Every key a single route must answer to, in registration order.
-*
-* `registerLoose` is the caller's call, not this helper's: HTTP gates it on
-* `canRegisterLoose` because its lookup retries the trailing slash, while WS
-* has no such retry and must own both directions outright
-*/
 function expandPaths(path, needsEncode, registerLoose, explicit) {
 	const variants = [path];
 	if (needsEncode) {
@@ -172,31 +159,10 @@ var Elysia = class Elysia {
 	get ["~programId"]() {
 		return this;
 	}
+	static #nextScopeChild;
 	constructor(config) {
-		/**
-		* ! Don't tune
-		*
-		* 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
-		*
-		* Its only signal is counting `this.x =` in the ctor body;
-		* class-field initializers compile into a separate hidden function
-		* the guess never sees
-		*
-		* The cell can't grow afterwards, so once inline slots run out every
-		* later property spills into the butterfly, and capacity is by n^2
-		*
-		* Fields run first before ctor (here), so they take the inline slots
-		* these assignments reserve
-		*
-		* 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;
-		* reusing the app as its program identity brings the current cell to ~386B.
-		**/
+		const scopeChild = Elysia.#nextScopeChild;
+		Elysia.#nextScopeChild = void 0;
 		this["~config"] = config;
 		this["~ext"] = void 0;
 		this["~hookChain"] = void 0;
@@ -213,7 +179,7 @@ var Elysia = class Elysia {
 		this["~compilerSession"] = void 0;
 		this["~generation"] = void 0;
 		this["~introspect"] = void 0;
-		this["~scopeChild"] = void 0;
+		this["~scopeChild"] = scopeChild;
 		this["~scopeChildren"] = void 0;
 		if (config) {
 			const { prefix, name, seed, adapter } = config;
@@ -222,12 +188,6 @@ var Elysia = class Elysia {
 			if (adapter?.setup) this.#useFn(adapter.setup);
 		} else this["~Prefix"] = void 0;
 	}
-	/**
-	* Every registered route with its merged hooks.
-	* Development shares a frozen cache.
-	* Production rebuilds the list on every read
-	* so its metadata can be released after startup.
-	*/
 	get routes() {
 		const generation = this["~generation"];
 		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedRoutes !== void 0) return this.cachedRoutes;
@@ -346,7 +306,7 @@ var Elysia = class Elysia {
 			parent,
 			refs,
 			scope,
-			owner: this,
+			owner: this["~scopeChild"] ? this : void 0,
 			origin: this.hash
 		};
 	}
@@ -369,20 +329,6 @@ var Elysia = class Elysia {
 		parsers[name] = fn;
 		return this;
 	}
-	/**
-	* ### setup | Life cycle event
-	* Called after server is ready for serving
-	*
-	* ---
-	* @example
-	* ```typescript
-	* new Elysia()
-	*     .setup(({ server }) => {
-	*         console.log("Running at ${server?.url}:${server?.port}")
-	*     })
-	*     .listen(3000)
-	* ```
-	*/
 	setup(handler) {
 		this.#assertMutable("setup");
 		(this.#ext.setup ??= []).push(...[].concat(handler));
@@ -482,14 +428,15 @@ var Elysia = class Elysia {
 		const run = arguments[2];
 		const isSchema = typeof schemaOrRun === "object";
 		const callback = isSchema ? run : schemaOrRun;
-		const child = new Elysia(this["~config"] || prefix ? {
+		const config = this["~config"] || prefix ? {
 			...this["~config"],
 			name: void 0,
 			seed: void 0,
 			as: void 0,
 			prefix
-		} : void 0);
-		child["~scopeChild"] = true;
+		} : void 0;
+		Elysia.#nextScopeChild = true;
+		const child = new Elysia(config);
 		child.scopeParent = this;
 		(this["~scopeChildren"] ??= []).push(child);
 		const src = this["~ext"];
@@ -512,7 +459,6 @@ var Elysia = class Elysia {
 	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();
 	}
@@ -745,10 +691,6 @@ var Elysia = class Elysia {
 		}
 		return addedByThisCall;
 	}
-	/**
-	* Reject a second, unrelated definition of an already-registered macro.
-	* Split out of `#use` for the same reason as `#absorbExt`.
-	*/
 	#assertMacroUnique(app, addedByThisCall) {
 		const incomingMacro = app["~ext"]?.macro;
 		const existingMacro = this["~ext"]?.macro;
@@ -763,14 +705,6 @@ var Elysia = class Elysia {
 			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
 	}
-	/**
-	* Merge the absorbed app's `~ext` container into this one.
-	*
-	* `#use` needed a frame wide enoughfor every local in this block + `#propagateHooks`
-	* JSC pays that width on *entry*, before a single field is read
-	*
-	* Keep the cold blocks in their own frames.
-	*/
 	#absorbExt(app, addedByThisCall) {
 		const source = app["~ext"];
 		const { decorator, store, headers, models, parser, macro, hoc, setup, cleanup, capability } = source;
@@ -857,10 +791,6 @@ var Elysia = class Elysia {
 			}
 		}
 	}
-	/**
-	* Republish the absorbed app's plugin/global hooks onto this instance's chain.
-	* Split out from #use, see #absorbExt
-	*/
 	#propagateHooks(app, hookChain, addedByThisCall) {
 		const nodes = useNodesBuffer;
 		nodes.length = 0;
@@ -920,7 +850,7 @@ var Elysia = class Elysia {
 				delete added.schema;
 				if (dropRequest) delete added.request;
 			}
-			if (require_utils.isNotEmpty(added)) this.#pushChainNode(added, scope, registration, origin, app);
+			if (require_utils.isNotEmpty(added)) this.#pushChainNode(added, scope, registration, origin, scopeChild ? app : void 0);
 		}
 		if (lifting) liftedRequests.set(this, lifting);
 		nodes.length = 0;
@@ -1090,10 +1020,6 @@ 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);
 	}
@@ -1151,9 +1077,6 @@ var Elysia = class Elysia {
 				return this;
 		}
 	}
-	/**
-	* Registered reusable models (via `.model()`), keyed by name.
-	*/
 	get models() {
 		return this["~ext"]?.models ?? this.scopeParent?.models ?? require_utils.nullObject();
 	}
@@ -1245,10 +1168,6 @@ var Elysia = class Elysia {
 			OPTIONS: void 0
 		};
 	}
-	/**
-	* Force all route handlers to compile immediately (sets `precompile: true`
-	* on the config and triggers a fresh build of the fetch handler).
-	*/
 	compile() {
 		this["~config"] ??= require_utils.nullObject();
 		this["~config"].precompile = true;
@@ -1567,14 +1486,17 @@ var Elysia = class Elysia {
 				break;
 			}
 		}
-		if (hasTypeBoxSchema) try {
-			require_type_bridge.warmTypebox();
-		} catch {}
 		let markDuplicates = false;
+		let eager = 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();
+			if (hasTypeBoxSchema) try {
+				require_type_bridge.warmTypebox();
+			} catch {
+				if (!require_type_bridge.isBridgeLive() && !require_compile_aot.Compiled.hasProgram(programId)) eager = markDuplicates = true;
+			}
 		}
 		const isLoose = this["~config"]?.strictPath !== true;
 		const collectExplicit = isLoose && table.hasLoose;
@@ -1624,7 +1546,7 @@ var Elysia = class Elysia {
 				}
 				continue;
 			}
-			const lazy = !precompile && !this.compiled?.[i];
+			const lazy = (eager ? (routeFlags & require_route_table.RouteFlag.ExactDuplicate) !== 0 : !precompile) && !this.compiled?.[i];
 			if (lazy) {
 				this.compiled ??= new Array(length);
 				this.jitTable = table;
@@ -1634,14 +1556,14 @@ var Elysia = class Elysia {
 			const registerLoose = isLoose && canRegisterLoose(routePath, isDynamic);
 			if (!isDynamic && !needsEncode && !registerLoose) {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
-				map[routePath] = lazy ? ~i : this.handler(i, precompile, void 0, void 0, table);
+				map[routePath] = lazy ? ~i : this.handler(i, true, void 0, void 0, table);
 				continue;
 			}
 			const paths = expandPaths(routePath, needsEncode, registerLoose, registerLoose ? explicitPaths?.get(routeMethod) : void 0);
 			if (isDynamic) {
 				if (require_utils.isHTMLBundle(table.handler[i])) continue;
 				const router = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
-				const store = lazy ? i : this.handler(i, precompile, void 0, void 0, table);
+				const store = lazy ? i : this.handler(i, true, void 0, void 0, table);
 				for (let p = 0; p < paths.length; p++) router.add(routeMethod, paths[p], store);
 			} else {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
@@ -1649,7 +1571,7 @@ var Elysia = class Elysia {
 					method: routeMethod,
 					paths
 				};
-				const handler = lazy ? ~i : this.handler(i, precompile, void 0, void 0, table);
+				const handler = lazy ? ~i : this.handler(i, true, void 0, void 0, table);
 				for (let p = 0; p < paths.length; p++) map[paths[p]] = handler;
 			}
 		}
@@ -1680,21 +1602,6 @@ var Elysia = class Elysia {
 		if (!require_compile_aot.Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}
-	/**
-	* Add a higher order function over Elysia.fetch
-	*
-	* @example
-	* ```ts
-	* const ctx = new AsyncLocalStorage<{ counter: number }>()
-	*
-	* new Elysia()
-	*	.wrap(
-	*		(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");
@@ -1703,34 +1610,12 @@ var Elysia = class Elysia {
 		(ext.hocOrigin ??= []).push(this.hash ?? {});
 		return this;
 	}
-	/**
-	* ### cleanup | Life cycle event
-	* Called after server stop serving request
-	*
-	* ---
-	* @example
-	* ```typescript
-	* new Elysia()
-	*     .cleanup((app) => {
-	*         closeDatabase()
-	*     })
-	* ```
-	*/
 	cleanup(handler) {
 		if (this["~ext"]?.cleanupEpoch?.(handler)) return this;
 		this.#assertMutable("cleanup");
 		(this.#ext.cleanup ??= []).push(...[].concat(handler));
 		return this;
 	}
-	/**
-	* Stop the underlying server (if any), then run every `cleanup` handler
-	*
-	* Awaiting `stop()` from inside a `setup`, `cleanup` or WebSocket lifecycle
-	* callback is only supported while that callback is still synchronous
-	*
-	* @param closeActiveConnections Pass `true` to terminate active
-	*   transports. Omit (or pass `false`) to drain safely.
-	*/
 	stop(closeActiveConnections) {
 		const stop = this["~ext"]?.stop;
 		if (stop) return stop(closeActiveConnections);