elysia 2.0.0-exp.51 → 2.0.0-exp.53

package/dist/adapter/bun/index.js

@@ -4,9 +4,9 @@ const require_constants = require('../../constants.js');
 const require_utils = require('../../utils.js');
 const require_adapter_web_standard_index = require('../web-standard/index.js');
 const require_generation = require('../../generation.js');
+const require_adapter_origin = require('../origin.js');
 const require_compile_handler_index = require('../../compile/handler/index.js');
 const require_route_table = require('../../route-table.js');
-const require_adapter_origin = require('../origin.js');
 
 //#region src/adapter/bun/index.ts
 /**
@@ -15,12 +15,8 @@ const require_adapter_origin = require('../origin.js');
 * always run before the next request comes in
 * @see ../origin.ts
 *
-* Publish the request `Bun.serve` handed us so `createFetchHandler` can prove,
-* before its first suspension, that it holds the untouched original and may
-* defer materializing `request.signal`
-*
 * `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.
+* 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;

package/dist/adapter/bun/index.mjs

@@ -3,9 +3,9 @@ import { isDynamicRegex, needEncodeRegex } from "../../constants.mjs";
 import { flattenChain, getLoosePath, nullObject } from "../../utils.mjs";
 import { WebStandardAdapter } from "../web-standard/index.mjs";
 import { frozenRootOf, resolvedWsOf } from "../../generation.mjs";
+import { origin } from "../origin.mjs";
 import { buildNativeStaticResponse } from "../../compile/handler/index.mjs";
 import { routeRow } from "../../route-table.mjs";
-import { origin } from "../origin.mjs";
 
 //#region src/adapter/bun/index.ts
 /**
@@ -14,12 +14,8 @@ import { origin } from "../origin.mjs";
 * always run before the next request comes in
 * @see ../origin.ts
 *
-* Publish the request `Bun.serve` handed us so `createFetchHandler` can prove,
-* before its first suspension, that it holds the untouched original and may
-* defer materializing `request.signal`
-*
 * `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.
+* not awaited), so the slot is live only for the handler's synchronous prologue
 */
 const withOrigin = (fetch) => (request, server) => {
 	origin.request = request;

package/dist/adapter/origin.d.ts

@@ -11,7 +11,9 @@
  * and therefore must be observed synchronously.
  *
  * The Bun adapter publishes the untouched original here for the *synchronous*
- * prologue of `app.fetch` and clears it in `finally`, so the window closes
+ * 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
@@ -23,14 +25,16 @@
  * 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), and erases the whiteboard (`finally`)
+ * 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
+ * "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,

package/dist/adapter/origin.js

@@ -13,7 +13,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 * and therefore must be observed synchronously.
 *
 * The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and clears it in `finally`, so the window closes
+* 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
@@ -25,14 +27,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 * 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), and erases the whiteboard (`finally`)
+* 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
+* "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,

package/dist/adapter/origin.mjs

@@ -11,7 +11,9 @@
 * and therefore must be observed synchronously.
 *
 * The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and clears it in `finally`, so the window closes
+* 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
@@ -23,14 +25,16 @@
 * 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), and erases the whiteboard (`finally`)
+* 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
+* "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,

package/dist/adapter/utils.js

@@ -360,20 +360,20 @@ function createResponseHandler(handler) {
 		const explicitlyBorrowed = require_adapter_response_ownership.isBorrowedResponse(response);
 		const borrowed = !owned || explicitlyBorrowed;
 		const mustClone = owned && explicitlyBorrowed;
-		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests — a returned Response is request-owned; call borrow(response) to mark it reusable");
+		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
 		if (set) {
 			const status = mergeStatus(response.status, set.status);
 			const statusUnchanged = status === void 0 || status === response.status;
 			if (!mustClone && statusUnchanged && !set.cookie && !require_utils.isNotEmpty(set.headers)) return response;
 		} else if (!mustClone) return response;
-		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked — release the reader, or call borrow(response) if it must be reused");
+		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked");
 		let body = response.body;
 		if (borrowed) {
 			const bodyBefore = body;
 			const cloned = response.clone();
 			if (explicitlyBorrowed && bodyBefore && response.body !== bodyBefore && !warnedStreamBorrows.has(response)) {
 				warnedStreamBorrows.add(response);
-				console.warn("[elysia] borrow() was called on a stream-backed Response — its entire body will stay buffered in memory for as long as the borrowed object lives, and every reuse adds a tee layer. Borrow only buffered Responses (string / ArrayBuffer / Blob bodies), or construct a fresh Response per request.");
+				console.warn("[elysia] borrow() was called on a stream-backed Response");
 			}
 			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body, explicitlyBorrowed) : cloned.body;
 		}

package/dist/adapter/utils.mjs

@@ -359,20 +359,20 @@ function createResponseHandler(handler) {
 		const explicitlyBorrowed = isBorrowedResponse(response);
 		const borrowed = !owned || explicitlyBorrowed;
 		const mustClone = owned && explicitlyBorrowed;
-		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests — a returned Response is request-owned; call borrow(response) to mark it reusable");
+		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
 		if (set) {
 			const status = mergeStatus(response.status, set.status);
 			const statusUnchanged = status === void 0 || status === response.status;
 			if (!mustClone && statusUnchanged && !set.cookie && !isNotEmpty(set.headers)) return response;
 		} else if (!mustClone) return response;
-		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked — release the reader, or call borrow(response) if it must be reused");
+		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked");
 		let body = response.body;
 		if (borrowed) {
 			const bodyBefore = body;
 			const cloned = response.clone();
 			if (explicitlyBorrowed && bodyBefore && response.body !== bodyBefore && !warnedStreamBorrows.has(response)) {
 				warnedStreamBorrows.add(response);
-				console.warn("[elysia] borrow() was called on a stream-backed Response — its entire body will stay buffered in memory for as long as the borrowed object lives, and every reuse adds a tee layer. Borrow only buffered Responses (string / ArrayBuffer / Blob bodies), or construct a fresh Response per request.");
+				console.warn("[elysia] borrow() was called on a stream-backed Response");
 			}
 			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body, explicitlyBorrowed) : cloned.body;
 		}

package/dist/base.d.ts

@@ -524,16 +524,6 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'];
     response: Metadata['response'] & MacroContext['response'] & ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle>;
   }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
-  /**
-   * Single idempotent capability resolver-accessor (README rev 2.1). Reads
-   * the merged `~ext.capability` channel — never mutated during a build — and
-   * throws when a capability is used but its provider was never registered.
-   * For `trace` the resolved view IS the nearest-root provider (merge already
-   * keeps it); for `ws` it additionally resolves the depth-precedence base
-   * options. Called at the start of every router build and by `compileHandler`
-   * before it reads the frozen root, so direct-compiler paths resolve without
-   * a prior seal.
-   */
   ['~resolvedCapability'](kind: 'trace'): TraceCapability | undefined;
   ['~resolvedCapability'](kind: 'ws'): {
     provider: WSCapability;

package/dist/base.js

@@ -33,9 +33,7 @@ var Elysia = class Elysia {
 	#macroBaseline;
 	#declaredRoutes;
 	#routeSources;
-	#cachedHistory;
 	get history() {
-		if (this.#cachedHistory) return this.#cachedHistory;
 		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
 		if (!this.#declaredRoutes?.length) return emptyHistory;
 		const history = new Array(this.#declaredRoutes.length);
@@ -49,7 +47,7 @@ var Elysia = class Elysia {
 				...source === void 0 ? {} : { source }
 			});
 		}
-		return this.#cachedHistory = Object.freeze(history);
+		return Object.freeze(history);
 	}
 	get ["~routes"]() {
 		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
@@ -83,19 +81,59 @@ var Elysia = class Elysia {
 	#jitRoute;
 	#jitStatic;
 	#jitAliases;
-	#cachedRoutes;
 	constructor(config) {
-		this["~programId"] = require_compile_aot.createProgramId();
+		/**
+		* ! Don't tune
+		*
+		* Interesting JSC internal: These `= undefined` are load-bearing
+		*
+		* 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/instance
+		**/
 		this["~config"] = config;
-		this["~Prefix"] = config?.prefix;
-		if (this["~Prefix"] && !this["~Prefix"].startsWith("/")) this["~Prefix"] = `/${this["~Prefix"]}`;
-		if (config?.name) this.#hash = require_utils.fnv1a(config.seed ? `${config.name}_${typeof config.seed === "object" ? JSON.stringify(config.seed, require_utils.serializeMacroSeed) : config.seed}` : config.name);
+		this["~ext"] = void 0;
+		this["~hookChain"] = void 0;
+		this["~wsConfig"] = void 0;
+		this.server = void 0;
+		this["~router"] = void 0;
+		this["~map"] = void 0;
+		this["~routeTable"] = void 0;
+		this["~hasWS"] = void 0;
+		this["~hasDynamicWS"] = void 0;
+		this["~hasTrace"] = void 0;
+		this["~finalizeError"] = void 0;
+		this["~aotFingerprint"] = void 0;
+		this["~compilerSession"] = void 0;
+		this["~generation"] = void 0;
+		this["~introspect"] = void 0;
+		this["~scopeChild"] = void 0;
+		this["~scopeChildren"] = void 0;
+		this["~programId"] = require_compile_aot.createProgramId();
+		if (config) {
+			const { prefix, name, seed } = config;
+			this["~Prefix"] = prefix ? prefix.charCodeAt(0) === 47 ? prefix : `/${prefix}` : void 0;
+			if (name) this.#hash = require_utils.fnv1a(seed ? `${name}_${typeof seed === "object" ? JSON.stringify(seed, require_utils.serializeMacroSeed) : seed}` : name);
+		} else this["~Prefix"] = void 0;
 	}
 	get routes() {
-		if (this.#cachedRoutes) return this.#cachedRoutes;
 		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
 		if (!this.#declaredRoutes?.length) return [];
-		const routes = this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
+		return this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
 			const merged = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, this, macroScope);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
 				if (!entry?.response) continue;
@@ -109,8 +147,6 @@ var Elysia = class Elysia {
 				hooks: merged
 			};
 		});
-		this.#cachedRoutes = routes;
-		return routes;
 	}
 	decorate(typeOrNameOrDecorators, nameOrDecorators, value) {
 		switch (arguments.length) {
@@ -186,7 +222,6 @@ var Elysia = class Elysia {
 			scope,
 			owner: this
 		};
-		this.#cachedRoutes = void 0;
 		if (scope === "plugin") this.#hasPlugin = true;
 		else if (scope === "global") this.#hasGlobal = true;
 		if (this.#hash !== void 0) {
@@ -306,7 +341,6 @@ var Elysia = class Elysia {
 	as(target) {
 		this.#assertMutable("as");
 		this.#as(this["~hookChain"], target === "global" ? "global" : "plugin");
-		this.#cachedRoutes = void 0;
 		return this;
 	}
 	#as(node, scope) {
@@ -452,7 +486,6 @@ var Elysia = class Elysia {
 			scope,
 			owner: this
 		};
-		this.#cachedRoutes = void 0;
 		return this;
 	}
 	macro(macro) {
@@ -466,7 +499,6 @@ var Elysia = class Elysia {
 			if (baseline?.has(key) && key in m && m[key] !== macro[key]) throw new Error(`[Elysia] Macro "${key}" can be only define once`);
 		}
 		Object.assign(m, macro);
-		this.#cachedRoutes = void 0;
 		require_utils.invalidateMacroEpoch();
 		return this;
 	}
@@ -606,7 +638,6 @@ var Elysia = class Elysia {
 			this.#childrenHash.add(hash);
 			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(hash);
 		}
-		this.#cachedRoutes = void 0;
 		if (app.#childrenHash) addedByThisCall = this.#absorbChildrenHash(app, addedByThisCall);
 		if (app["~ext"]) this.#assertMacroUnique(app, addedByThisCall);
 		if (app["~hasTrace"]) this["~hasTrace"] = true;
@@ -961,9 +992,7 @@ var Elysia = class Elysia {
 			handler,
 			this
 		]);
-		if (this.#routerBuilt || this.#compiled !== void 0 || this.#cachedRoutes !== void 0 || this.#cachedHistory !== void 0) {
-			this.#cachedHistory = void 0;
-			this.#cachedRoutes = void 0;
+		if (this.#routerBuilt || this.#compiled !== void 0) {
 			this.#compiled = void 0;
 			this.#jitColdRemaining = void 0;
 			this.#jitTable = void 0;
@@ -993,9 +1022,7 @@ var Elysia = class Elysia {
 		const sequence = routes.length;
 		routes.push(route);
 		if (source) (this.#routeSources ??= [])[sequence] = source;
-		if (this.#routerBuilt || this.#compiled !== void 0 || this.#cachedRoutes !== void 0 || this.#cachedHistory !== void 0) {
-			this.#cachedHistory = void 0;
-			this.#cachedRoutes = void 0;
+		if (this.#routerBuilt || this.#compiled !== void 0) {
 			this.#compiled = void 0;
 			this.#jitColdRemaining = void 0;
 			this.#jitTable = void 0;

package/dist/base.mjs

@@ -30,9 +30,7 @@ var Elysia = class Elysia {
 	#macroBaseline;
 	#declaredRoutes;
 	#routeSources;
-	#cachedHistory;
 	get history() {
-		if (this.#cachedHistory) return this.#cachedHistory;
 		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
 		if (!this.#declaredRoutes?.length) return emptyHistory;
 		const history = new Array(this.#declaredRoutes.length);
@@ -46,7 +44,7 @@ var Elysia = class Elysia {
 				...source === void 0 ? {} : { source }
 			});
 		}
-		return this.#cachedHistory = Object.freeze(history);
+		return Object.freeze(history);
 	}
 	get ["~routes"]() {
 		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
@@ -80,19 +78,59 @@ var Elysia = class Elysia {
 	#jitRoute;
 	#jitStatic;
 	#jitAliases;
-	#cachedRoutes;
 	constructor(config) {
-		this["~programId"] = createProgramId();
+		/**
+		* ! Don't tune
+		*
+		* Interesting JSC internal: These `= undefined` are load-bearing
+		*
+		* 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/instance
+		**/
 		this["~config"] = config;
-		this["~Prefix"] = config?.prefix;
-		if (this["~Prefix"] && !this["~Prefix"].startsWith("/")) this["~Prefix"] = `/${this["~Prefix"]}`;
-		if (config?.name) this.#hash = fnv1a(config.seed ? `${config.name}_${typeof config.seed === "object" ? JSON.stringify(config.seed, serializeMacroSeed) : config.seed}` : config.name);
+		this["~ext"] = void 0;
+		this["~hookChain"] = void 0;
+		this["~wsConfig"] = void 0;
+		this.server = void 0;
+		this["~router"] = void 0;
+		this["~map"] = void 0;
+		this["~routeTable"] = void 0;
+		this["~hasWS"] = void 0;
+		this["~hasDynamicWS"] = void 0;
+		this["~hasTrace"] = void 0;
+		this["~finalizeError"] = void 0;
+		this["~aotFingerprint"] = void 0;
+		this["~compilerSession"] = void 0;
+		this["~generation"] = void 0;
+		this["~introspect"] = void 0;
+		this["~scopeChild"] = void 0;
+		this["~scopeChildren"] = void 0;
+		this["~programId"] = createProgramId();
+		if (config) {
+			const { prefix, name, seed } = config;
+			this["~Prefix"] = prefix ? prefix.charCodeAt(0) === 47 ? prefix : `/${prefix}` : void 0;
+			if (name) this.#hash = fnv1a(seed ? `${name}_${typeof seed === "object" ? JSON.stringify(seed, serializeMacroSeed) : seed}` : name);
+		} else this["~Prefix"] = void 0;
 	}
 	get routes() {
-		if (this.#cachedRoutes) return this.#cachedRoutes;
 		if (this.#declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
 		if (!this.#declaredRoutes?.length) return [];
-		const routes = this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
+		return this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
 			const merged = composeRouteHook(instance, hook, appHook, inheritedChain, this, macroScope);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
 				if (!entry?.response) continue;
@@ -106,8 +144,6 @@ var Elysia = class Elysia {
 				hooks: merged
 			};
 		});
-		this.#cachedRoutes = routes;
-		return routes;
 	}
 	decorate(typeOrNameOrDecorators, nameOrDecorators, value) {
 		switch (arguments.length) {
@@ -183,7 +219,6 @@ var Elysia = class Elysia {
 			scope,
 			owner: this
 		};
-		this.#cachedRoutes = void 0;
 		if (scope === "plugin") this.#hasPlugin = true;
 		else if (scope === "global") this.#hasGlobal = true;
 		if (this.#hash !== void 0) {
@@ -303,7 +338,6 @@ var Elysia = class Elysia {
 	as(target) {
 		this.#assertMutable("as");
 		this.#as(this["~hookChain"], target === "global" ? "global" : "plugin");
-		this.#cachedRoutes = void 0;
 		return this;
 	}
 	#as(node, scope) {
@@ -449,7 +483,6 @@ var Elysia = class Elysia {
 			scope,
 			owner: this
 		};
-		this.#cachedRoutes = void 0;
 		return this;
 	}
 	macro(macro) {
@@ -463,7 +496,6 @@ var Elysia = class Elysia {
 			if (baseline?.has(key) && key in m && m[key] !== macro[key]) throw new Error(`[Elysia] Macro "${key}" can be only define once`);
 		}
 		Object.assign(m, macro);
-		this.#cachedRoutes = void 0;
 		invalidateMacroEpoch();
 		return this;
 	}
@@ -603,7 +635,6 @@ var Elysia = class Elysia {
 			this.#childrenHash.add(hash);
 			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(hash);
 		}
-		this.#cachedRoutes = void 0;
 		if (app.#childrenHash) addedByThisCall = this.#absorbChildrenHash(app, addedByThisCall);
 		if (app["~ext"]) this.#assertMacroUnique(app, addedByThisCall);
 		if (app["~hasTrace"]) this["~hasTrace"] = true;
@@ -958,9 +989,7 @@ var Elysia = class Elysia {
 			handler,
 			this
 		]);
-		if (this.#routerBuilt || this.#compiled !== void 0 || this.#cachedRoutes !== void 0 || this.#cachedHistory !== void 0) {
-			this.#cachedHistory = void 0;
-			this.#cachedRoutes = void 0;
+		if (this.#routerBuilt || this.#compiled !== void 0) {
 			this.#compiled = void 0;
 			this.#jitColdRemaining = void 0;
 			this.#jitTable = void 0;
@@ -990,9 +1019,7 @@ var Elysia = class Elysia {
 		const sequence = routes.length;
 		routes.push(route);
 		if (source) (this.#routeSources ??= [])[sequence] = source;
-		if (this.#routerBuilt || this.#compiled !== void 0 || this.#cachedRoutes !== void 0 || this.#cachedHistory !== void 0) {
-			this.#cachedHistory = void 0;
-			this.#cachedRoutes = void 0;
+		if (this.#routerBuilt || this.#compiled !== void 0) {
 			this.#compiled = void 0;
 			this.#jitColdRemaining = void 0;
 			this.#jitTable = void 0;

package/dist/compile/aot-capture.js

@@ -283,7 +283,7 @@ function captureBridgeFree(aot, slot, rawSchema) {
 	}
 }
 function beginValidatorCapture() {
-	if (require_compile_aot.captureImpl === void 0) throw require_compile_aot.aotActivationError;
+	if (require_compile_aot.captureImpl === void 0) throw require_compile_aot.aotActivationError();
 	const active = require_compile_aot.CompilerState.session;
 	if (active?.capture !== void 0) {
 		if (active.explicitCapture) throw new Error("[elysia-aot]: A capture session is already active.");

package/dist/compile/aot-capture.mjs

@@ -280,7 +280,7 @@ function captureBridgeFree(aot, slot, rawSchema) {
 	}
 }
 function beginValidatorCapture() {
-	if (captureImpl === void 0) throw aotActivationError;
+	if (captureImpl === void 0) throw aotActivationError();
 	const active = CompilerState.session;
 	if (active?.capture !== void 0) {
 		if (active.explicitCapture) throw new Error("[elysia-aot]: A capture session is already active.");

package/dist/compile/aot.d.ts

@@ -217,7 +217,7 @@ interface CapturedValidator {
   bridgeFree?: boolean;
 }
 /** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
-declare const aotActivationError: Error;
+declare const aotActivationError: () => Error;
 interface CapturedHandler {
   method: string;
   path: string;

package/dist/compile/aot.js

@@ -36,9 +36,8 @@ function endCompilerSession(app, session, failed = false) {
 }
 const getCompilerSession = () => activeSession;
 let reconstructImpl;
-const reconstructActivationError = /* @__PURE__ */ new Error("Elysia AOT reconstruct module is not activated.");
 function reconstruct() {
-	if (reconstructImpl === void 0) throw reconstructActivationError;
+	if (reconstructImpl === void 0) throw new Error("Elysia AOT reconstruct module is not activated");
 	return reconstructImpl;
 }
 let registered;
@@ -161,7 +160,7 @@ function captureEntry({ method, path, slot }) {
 	return e;
 }
 /** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
-const aotActivationError = /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
+const aotActivationError = () => /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
 function captureHandler(v) {
 	if (!isValidatorCapturing()) return;
 	const session = activeSession;
@@ -176,11 +175,11 @@ const captureGet = (loc) => activeSession?.capture?.get(`${loc.method}_${loc.pat
 const isAotBuildEnv = () => !!require_universal_env.env.ELYSIA_AOT_BUILD;
 const isValidatorCapturing = () => {
 	if (activeSession?.capture !== void 0) {
-		if (captureImpl === void 0) throw aotActivationError;
+		if (captureImpl === void 0) throw aotActivationError();
 		return true;
 	}
 	if (isAotBuildEnv()) {
-		if (captureImpl === void 0) throw aotActivationError;
+		if (captureImpl === void 0) throw aotActivationError();
 		return true;
 	}
 	return false;

package/dist/compile/aot.mjs

@@ -35,9 +35,8 @@ function endCompilerSession(app, session, failed = false) {
 }
 const getCompilerSession = () => activeSession;
 let reconstructImpl;
-const reconstructActivationError = /* @__PURE__ */ new Error("Elysia AOT reconstruct module is not activated.");
 function reconstruct() {
-	if (reconstructImpl === void 0) throw reconstructActivationError;
+	if (reconstructImpl === void 0) throw new Error("Elysia AOT reconstruct module is not activated");
 	return reconstructImpl;
 }
 let registered;
@@ -160,7 +159,7 @@ function captureEntry({ method, path, slot }) {
 	return e;
 }
 /** @internal shared with `aot-capture.ts` (`beginValidatorCapture`). */
-const aotActivationError = /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
+const aotActivationError = () => /* @__PURE__ */ new Error("Elysia AOT capture module is not activated.");
 function captureHandler(v) {
 	if (!isValidatorCapturing()) return;
 	const session = activeSession;
@@ -175,11 +174,11 @@ const captureGet = (loc) => activeSession?.capture?.get(`${loc.method}_${loc.pat
 const isAotBuildEnv = () => !!env.ELYSIA_AOT_BUILD;
 const isValidatorCapturing = () => {
 	if (activeSession?.capture !== void 0) {
-		if (captureImpl === void 0) throw aotActivationError;
+		if (captureImpl === void 0) throw aotActivationError();
 		return true;
 	}
 	if (isAotBuildEnv()) {
-		if (captureImpl === void 0) throw aotActivationError;
+		if (captureImpl === void 0) throw aotActivationError();
 		return true;
 	}
 	return false;

package/dist/compile/handler/frozen-validator.d.ts

@@ -4,7 +4,7 @@ import { AnyElysia } from "../../base.js";
 
 //#region src/compile/handler/frozen-validator.d.ts
 declare const isBridgeNotInitialized: (error: unknown) => boolean;
-/** `{ check, clean?, decode? }` — the slot's compiled predicate + cleaner. */
+/** `{ check, clean?, decode? }` the slot's compiled predicate + cleaner. */
 interface SlotCheckClean {
   check: (value: unknown) => boolean;
   clean?: (value: unknown) => unknown;

package/dist/compile/handler/frozen-validator.js

@@ -200,10 +200,7 @@ var FrozenSlotValidator = class {
 /**
 * The JIT/frozen slot validator: the reconstruct-free `FrozenSlotValidator`
 * base plus the codec/inner-codec branch re-added via the `buildCheckClean`
-* override.
-* The only reorder — `this.hasCodec` is set by the base ctor before this runs,
-* where the original set it after the `frozen.ic` side-effect — is unobservable
-* (`reconstructInnerCodecs` neither reads nor sets `hasCodec`).
+* override
 */
 var CodecFrozenSlotValidator = class extends FrozenSlotValidator {
 	buildCheckClean(frozen, schema, raw, normalize) {

package/dist/compile/handler/frozen-validator.mjs

@@ -199,10 +199,7 @@ var FrozenSlotValidator = class {
 /**
 * The JIT/frozen slot validator: the reconstruct-free `FrozenSlotValidator`
 * base plus the codec/inner-codec branch re-added via the `buildCheckClean`
-* override.
-* The only reorder — `this.hasCodec` is set by the base ctor before this runs,
-* where the original set it after the `frozen.ic` side-effect — is unobservable
-* (`reconstructInnerCodecs` neither reads nor sets `hasCodec`).
+* override
 */
 var CodecFrozenSlotValidator = class extends FrozenSlotValidator {
 	buildCheckClean(frozen, schema, raw, normalize) {