elysia 2.0.0-exp.26 → 2.0.0-exp.28

package/dist/base.d.ts

@@ -2,7 +2,7 @@ import { ElysiaStatus } from "./error.js";
 import { TraceHandler } from "./trace.js";
 import { AnySchema } from "./type/types.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
-import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardLocalHook, HTTPMethod, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { WSHandlerResponse, WSLocalHook, WSMessageHandler } from "./ws/types.js";
@@ -16,9 +16,6 @@ interface StaticMapAliases {
   paths: string[];
   head: boolean;
 }
-type GuardHookSingleton<Singleton extends SingletonBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, MacroContext> = Singleton & {
-  derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['resolve'];
-};
 declare class Elysia<const in out BasePath extends string = '', const in out Scope extends EventScope = 'local', const in out Singleton extends SingletonBase = DefaultSingleton, const in out Definitions extends DefinitionBase = {
   typebox: {};
   error: [];
@@ -801,13 +798,6 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   /**
    * Force all route handlers to compile immediately (sets `precompile: true`
    * on the config and triggers a fresh build of the fetch handler).
-   *
-   * @remarks
-   * **Memory trade-off (bench-memory-1):** each compiled route retains ~4.8 KB
-   * (no schema) to ~6.6 KB (validated body) of memory (JSC compiled-function
-   * representation + closure scope); 1 000 validated routes ≈ 6.6 MB. Without
-   * this call, routes compile lazily on first request, spreading that cost over
-   * time. Use the AOT build plugin for the lowest cold-start footprint.
    */
   compile(): this;
   handler(index: number, immediate?: boolean | undefined, route?: InternalRoute, precomputedStatic?: Response, aliases?: StaticMapAliases): CompiledHandler;
@@ -838,28 +828,6 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    *   draining gracefully.
    */
   stop(closeActiveConnections?: boolean): Promise<void> | void;
-  /** @deprecated renamed to `.error()` in Elysia 2 */
-  onError: 'onError was renamed to .error() in Elysia 2';
-  /** @deprecated renamed to `.request()` in Elysia 2 */
-  onRequest: 'onRequest was renamed to .request() in Elysia 2';
-  /** @deprecated renamed to `.parse()` in Elysia 2 */
-  onParse: 'onParse was renamed to .parse() in Elysia 2';
-  /** @deprecated renamed to `.transform()` in Elysia 2 */
-  onTransform: 'onTransform was renamed to .transform() in Elysia 2';
-  /** @deprecated renamed to `.beforeHandle()` in Elysia 2 */
-  onBeforeHandle: 'onBeforeHandle was renamed to .beforeHandle() in Elysia 2';
-  /** @deprecated renamed to `.afterHandle()` in Elysia 2 */
-  onAfterHandle: 'onAfterHandle was renamed to .afterHandle() in Elysia 2';
-  /** @deprecated renamed to `.afterResponse()` in Elysia 2 */
-  onAfterResponse: 'onAfterResponse was renamed to .afterResponse() in Elysia 2';
-  /** @deprecated renamed to `.mapResponse()` in Elysia 2 */
-  onResponse: 'onResponse was renamed to .mapResponse() in Elysia 2';
-  /** @deprecated removed in Elysia 2 — use the `listen(port, callback)` callback */
-  onStart: 'onStart was removed in Elysia 2 — use the listen(port, callback) callback';
-  /** @deprecated removed in Elysia 2 — use `.cleanup()` */
-  onStop: 'onStop was removed in Elysia 2 — use .cleanup()';
-  /** @deprecated removed in Elysia 2 — use `.derive()` */
-  resolve: 'resolve was removed in Elysia 2 — use .derive() instead';
 }
 //#endregion
 export { AnyElysia, Elysia };

package/dist/base.js

@@ -15,22 +15,6 @@ memoirist = require_runtime.__toESM(memoirist);
 
 //#region src/base.ts
 const useNodesBuffer = [];
-const macroSeedRefIds = /* @__PURE__ */ new WeakMap();
-let macroSeedRefCounter = 0;
-function macroSeedRefId(ref) {
-	let id = macroSeedRefIds.get(ref);
-	if (id === void 0) macroSeedRefIds.set(ref, id = ++macroSeedRefCounter);
-	return id;
-}
-function macroSeedReplacer(_key, value) {
-	switch (typeof value) {
-		case "function": return "\0fn:" + macroSeedRefId(value);
-		case "bigint": return "\0bigint:" + value.toString();
-		case "symbol": return "\0sym:" + String(value);
-		case "undefined": return "\0undefined";
-		default: return value;
-	}
-}
 var Elysia = class Elysia {
 	#hasPlugin;
 	#hasGlobal;
@@ -415,7 +399,7 @@ var Elysia = class Elysia {
 		for (const key in macro) {
 			if (typeof macro[key] === "object") macro[key] = require_utils.hookToGuard(macro[key]);
 			if (this.#hash !== void 0 && !require_utils.macroOrigin.has(macro[key])) require_utils.macroOrigin.set(macro[key], this.#hash);
-			if (baseline?.has(key) && key in m && m[key] !== macro[key]) throw new Error(`Macro "${key}" is defined by more than one plugin. Rename one of them (macro names must be unique across composed plugins), or give the plugin a \`name\` so repeated instances deduplicate.`);
+			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;
@@ -440,7 +424,7 @@ var Elysia = class Elysia {
 				let seedKey;
 				if (seedSource === null || seedSource === void 0 || seedType !== "object") seedKey = key + "\0" + seedType + "\0" + String(seedSource);
 				else try {
-					seedKey = key + "\0object\0" + JSON.stringify(seedSource, macroSeedReplacer);
+					seedKey = key + "\0object\0" + JSON.stringify(seedSource, require_utils.serializeMacroSeed);
 				} catch {
 					throw new Error(`[Elysia] macro "${key}" received a circular seed value; pass a primitive \`seed\` to dedup it.`);
 				}
@@ -530,7 +514,7 @@ var Elysia = class Elysia {
 				return this.#useAsync(result.then((value) => {
 					const after = this["~ext"]?.macro;
 					if (after) {
-						for (const [k, def] of Object.entries(after)) if (beforeMacro.get(k) !== def) throw new Error(`Macro ${k} was added by an async plugin which Elysia can't ensure the soundness. Please register macro in the plugin synchronously instead of async.`);
+						for (const [k, def] of Object.entries(after)) if (beforeMacro.get(k) !== def) throw new Error(`Macro ${k} can only run in sync plugin`);
 					}
 					return value;
 				}));
@@ -577,7 +561,7 @@ var Elysia = class Elysia {
 			const origin = require_utils.macroOrigin.get(existing);
 			if (origin !== void 0 && origin === require_utils.macroOrigin.get(incoming)) continue;
 			if (addedByThisCall) for (const h of addedByThisCall) this.#childrenHash.delete(h);
-			throw new Error(`Macro "${macroName}" is defined by more than one plugin.Rename one of them (macro names must be unique across composed plugins), or give the plugin a \`name\` so repeated instances deduplicate.`);
+			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
 		if (app.#history) {
 			if (app["~hasWS"]) this["~hasWS"] = true;
@@ -782,28 +766,29 @@ var Elysia = class Elysia {
 		this.#routerBuilt = false;
 		this.#buildRouter();
 	}
-	#add(method, path, fn, hook) {
-		if (hook !== void 0 && (typeof hook !== "object" || hook === null)) throw new Error(`Elysia 2 route signature is (path, hook, handler) — received ${typeof hook} in the hook position for "${method} ${path}". Did you use the Elysia 1 order (path, handler, hook)?`);
+	#add(method, path, hookOrFn, fn, hasHook = fn !== void 0) {
 		if (this["~Prefix"]) path = require_utils.joinPath(this["~Prefix"], path);
 		else if (path && path.charCodeAt(0) !== 47) path = "/" + path;
+		const handler = hasHook ? fn : hookOrFn;
+		const hook = hasHook ? hookOrFn : void 0;
 		const appHook = this["~hookChain"];
 		(this.#history ??= []).push(appHook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook,
 			appHook
 		] : hook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook
 		] : [
 			method,
 			path,
-			fn,
+			handler,
 			this
 		]);
 		this.#cachedRoutes = void 0;
@@ -855,32 +840,31 @@ var Elysia = class Elysia {
 		return require_type_bridge.Ref(key);
 	}
 	get(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.GET, path, hookOrFn) : this.#add(require_constants.MethodMap.GET, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.GET, path, hookOrFn, fn);
 	}
 	post(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.POST, path, hookOrFn) : this.#add(require_constants.MethodMap.POST, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.POST, path, hookOrFn, fn);
 	}
 	put(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.PUT, path, hookOrFn) : this.#add(require_constants.MethodMap.PUT, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.PUT, path, hookOrFn, fn);
 	}
 	patch(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.PATCH, path, hookOrFn) : this.#add(require_constants.MethodMap.PATCH, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.PATCH, path, hookOrFn, fn);
 	}
 	delete(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.DELETE, path, hookOrFn) : this.#add(require_constants.MethodMap.DELETE, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.DELETE, path, hookOrFn, fn);
 	}
 	options(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.OPTIONS, path, hookOrFn) : this.#add(require_constants.MethodMap.OPTIONS, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.OPTIONS, path, hookOrFn, fn);
 	}
 	head(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(require_constants.MethodMap.HEAD, path, hookOrFn) : this.#add(require_constants.MethodMap.HEAD, path, fn, hookOrFn);
+		return this.#add(require_constants.MethodMap.HEAD, path, hookOrFn, fn);
 	}
 	method(method, path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(method, path, hookOrFn) : this.#add(method, path, fn, hookOrFn);
+		return this.#add(method, path, hookOrFn, fn);
 	}
 	all(path, hookOrFn, fn) {
-		if (fn === void 0) this.#add("*", path, hookOrFn);
-		else this.#add("*", path, fn, hookOrFn);
+		this.#add("*", path, hookOrFn, fn);
 		return this;
 	}
 	ws(path, optionsOrHandler, handler) {
@@ -896,7 +880,7 @@ var Elysia = class Elysia {
 			opts = require_utils.nullObject();
 			opts.message = optionsOrHandler;
 		} else opts = optionsOrHandler;
-		this.#add("WS", path, void 0, opts);
+		this.#add("WS", path, opts, void 0, true);
 		return this;
 	}
 	mount(path, handleOrConfig, config) {
@@ -946,13 +930,6 @@ var Elysia = class Elysia {
 	/**
 	* Force all route handlers to compile immediately (sets `precompile: true`
 	* on the config and triggers a fresh build of the fetch handler).
-	*
-	* @remarks
-	* **Memory trade-off (bench-memory-1):** each compiled route retains ~4.8 KB
-	* (no schema) to ~6.6 KB (validated body) of memory (JSC compiled-function
-	* representation + closure scope); 1 000 validated routes ≈ 6.6 MB. Without
-	* this call, routes compile lazily on first request, spreading that cost over
-	* time. Use the AOT build plugin for the lowest cold-start footprint.
 	*/
 	compile() {
 		this["~config"] ??= require_utils.nullObject();
@@ -1032,13 +1009,13 @@ var Elysia = class Elysia {
 				if (!require_utils.schemaProperties.has(key)) continue;
 				const v = hook[key];
 				if (typeof v === "string") {
-					if (!models || !(v in models)) throw new Error(`[Elysia] Unknown model reference "${v}" for ${key} on route ${method} ${path}. Register it with .model('${v}', ...) before listen()/compile().`);
+					if (!models || !(v in models)) throw new Error(`[Elysia] Unknown model reference "${v}" for ${key} on route ${method} ${path}.`);
 				} else if (key === "response" && v && typeof v === "object") {
 					const record = v;
 					if ("~kind" in record || "~elyAcl" in record || "~standard" in record) continue;
 					for (const status in record) {
 						const r = record[status];
-						if (typeof r === "string" && (!models || !(r in models))) throw new Error(`[Elysia] Unknown model reference "${r}" for response ${status} on route ${method} ${path}. Register it with .model('${r}', ...) before listen()/compile().`);
+						if (typeof r === "string" && (!models || !(r in models))) throw new Error(`[Elysia] Unknown model reference "${r}" for response ${status} on route ${method} ${path}.`);
 					}
 				}
 			}
@@ -1123,7 +1100,7 @@ var Elysia = class Elysia {
 					const existing = this["~config"].websocket;
 					if (existing && require_universal_constants.isBun) {
 						for (const key in options) if (key in existing && existing[key] !== options[key]) {
-							console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, so per-route values are not enforced (the last-registered route wins).`);
+							console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, per-route values are not enforced (the last-registered route wins).`);
 							console.warn((/* @__PURE__ */ new Error()).stack);
 						}
 						Object.assign(existing, options);
@@ -1250,26 +1227,6 @@ var Elysia = class Elysia {
 		return r;
 	}
 };
-for (const [old, hint] of [
-	["onError", "use .error() instead"],
-	["onRequest", "use .request() instead"],
-	["onParse", "use .parse() instead"],
-	["onTransform", "use .transform() instead"],
-	["onBeforeHandle", "use .beforeHandle() instead"],
-	["onAfterHandle", "use .afterHandle() instead"],
-	["onAfterResponse", "use .afterResponse() instead"],
-	["onResponse", "use .mapResponse() instead"],
-	["onStart", "use the listen(port, callback) callback instead"],
-	["onStop", "use .cleanup() instead"],
-	["resolve", "use .derive() instead"]
-]) Object.defineProperty(Elysia.prototype, old, {
-	value: function removed() {
-		throw new Error(`.${old}() was removed in Elysia 2 — ${hint}`);
-	},
-	writable: true,
-	enumerable: false,
-	configurable: true
-});
 
 //#endregion
 exports.Elysia = Elysia;

package/dist/base.mjs

@@ -1,6 +1,6 @@
 import { isBun } from "./universal/constants.mjs";
 import { MethodMap, isDynamicRegex, needEncodeRegex } from "./constants.mjs";
-import { clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapMethodBack, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties } from "./utils.mjs";
+import { clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapMethodBack, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed } from "./utils.mjs";
 import { Ref } from "./type/bridge.mjs";
 import { isProduction } from "./error.mjs";
 import { Capture } from "./compile/aot.mjs";
@@ -12,22 +12,6 @@ import Memoirist from "memoirist";
 
 //#region src/base.ts
 const useNodesBuffer = [];
-const macroSeedRefIds = /* @__PURE__ */ new WeakMap();
-let macroSeedRefCounter = 0;
-function macroSeedRefId(ref) {
-	let id = macroSeedRefIds.get(ref);
-	if (id === void 0) macroSeedRefIds.set(ref, id = ++macroSeedRefCounter);
-	return id;
-}
-function macroSeedReplacer(_key, value) {
-	switch (typeof value) {
-		case "function": return "\0fn:" + macroSeedRefId(value);
-		case "bigint": return "\0bigint:" + value.toString();
-		case "symbol": return "\0sym:" + String(value);
-		case "undefined": return "\0undefined";
-		default: return value;
-	}
-}
 var Elysia = class Elysia {
 	#hasPlugin;
 	#hasGlobal;
@@ -412,7 +396,7 @@ var Elysia = class Elysia {
 		for (const key in macro) {
 			if (typeof macro[key] === "object") macro[key] = hookToGuard(macro[key]);
 			if (this.#hash !== void 0 && !macroOrigin.has(macro[key])) macroOrigin.set(macro[key], this.#hash);
-			if (baseline?.has(key) && key in m && m[key] !== macro[key]) throw new Error(`Macro "${key}" is defined by more than one plugin. Rename one of them (macro names must be unique across composed plugins), or give the plugin a \`name\` so repeated instances deduplicate.`);
+			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;
@@ -437,7 +421,7 @@ var Elysia = class Elysia {
 				let seedKey;
 				if (seedSource === null || seedSource === void 0 || seedType !== "object") seedKey = key + "\0" + seedType + "\0" + String(seedSource);
 				else try {
-					seedKey = key + "\0object\0" + JSON.stringify(seedSource, macroSeedReplacer);
+					seedKey = key + "\0object\0" + JSON.stringify(seedSource, serializeMacroSeed);
 				} catch {
 					throw new Error(`[Elysia] macro "${key}" received a circular seed value; pass a primitive \`seed\` to dedup it.`);
 				}
@@ -527,7 +511,7 @@ var Elysia = class Elysia {
 				return this.#useAsync(result.then((value) => {
 					const after = this["~ext"]?.macro;
 					if (after) {
-						for (const [k, def] of Object.entries(after)) if (beforeMacro.get(k) !== def) throw new Error(`Macro ${k} was added by an async plugin which Elysia can't ensure the soundness. Please register macro in the plugin synchronously instead of async.`);
+						for (const [k, def] of Object.entries(after)) if (beforeMacro.get(k) !== def) throw new Error(`Macro ${k} can only run in sync plugin`);
 					}
 					return value;
 				}));
@@ -574,7 +558,7 @@ var Elysia = class Elysia {
 			const origin = macroOrigin.get(existing);
 			if (origin !== void 0 && origin === macroOrigin.get(incoming)) continue;
 			if (addedByThisCall) for (const h of addedByThisCall) this.#childrenHash.delete(h);
-			throw new Error(`Macro "${macroName}" is defined by more than one plugin.Rename one of them (macro names must be unique across composed plugins), or give the plugin a \`name\` so repeated instances deduplicate.`);
+			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
 		if (app.#history) {
 			if (app["~hasWS"]) this["~hasWS"] = true;
@@ -779,28 +763,29 @@ var Elysia = class Elysia {
 		this.#routerBuilt = false;
 		this.#buildRouter();
 	}
-	#add(method, path, fn, hook) {
-		if (hook !== void 0 && (typeof hook !== "object" || hook === null)) throw new Error(`Elysia 2 route signature is (path, hook, handler) — received ${typeof hook} in the hook position for "${method} ${path}". Did you use the Elysia 1 order (path, handler, hook)?`);
+	#add(method, path, hookOrFn, fn, hasHook = fn !== void 0) {
 		if (this["~Prefix"]) path = joinPath(this["~Prefix"], path);
 		else if (path && path.charCodeAt(0) !== 47) path = "/" + path;
+		const handler = hasHook ? fn : hookOrFn;
+		const hook = hasHook ? hookOrFn : void 0;
 		const appHook = this["~hookChain"];
 		(this.#history ??= []).push(appHook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook,
 			appHook
 		] : hook ? [
 			method,
 			path,
-			fn,
+			handler,
 			this,
 			hook
 		] : [
 			method,
 			path,
-			fn,
+			handler,
 			this
 		]);
 		this.#cachedRoutes = void 0;
@@ -852,32 +837,31 @@ var Elysia = class Elysia {
 		return Ref(key);
 	}
 	get(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.GET, path, hookOrFn) : this.#add(MethodMap.GET, path, fn, hookOrFn);
+		return this.#add(MethodMap.GET, path, hookOrFn, fn);
 	}
 	post(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.POST, path, hookOrFn) : this.#add(MethodMap.POST, path, fn, hookOrFn);
+		return this.#add(MethodMap.POST, path, hookOrFn, fn);
 	}
 	put(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.PUT, path, hookOrFn) : this.#add(MethodMap.PUT, path, fn, hookOrFn);
+		return this.#add(MethodMap.PUT, path, hookOrFn, fn);
 	}
 	patch(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.PATCH, path, hookOrFn) : this.#add(MethodMap.PATCH, path, fn, hookOrFn);
+		return this.#add(MethodMap.PATCH, path, hookOrFn, fn);
 	}
 	delete(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.DELETE, path, hookOrFn) : this.#add(MethodMap.DELETE, path, fn, hookOrFn);
+		return this.#add(MethodMap.DELETE, path, hookOrFn, fn);
 	}
 	options(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.OPTIONS, path, hookOrFn) : this.#add(MethodMap.OPTIONS, path, fn, hookOrFn);
+		return this.#add(MethodMap.OPTIONS, path, hookOrFn, fn);
 	}
 	head(path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(MethodMap.HEAD, path, hookOrFn) : this.#add(MethodMap.HEAD, path, fn, hookOrFn);
+		return this.#add(MethodMap.HEAD, path, hookOrFn, fn);
 	}
 	method(method, path, hookOrFn, fn) {
-		return fn === void 0 ? this.#add(method, path, hookOrFn) : this.#add(method, path, fn, hookOrFn);
+		return this.#add(method, path, hookOrFn, fn);
 	}
 	all(path, hookOrFn, fn) {
-		if (fn === void 0) this.#add("*", path, hookOrFn);
-		else this.#add("*", path, fn, hookOrFn);
+		this.#add("*", path, hookOrFn, fn);
 		return this;
 	}
 	ws(path, optionsOrHandler, handler) {
@@ -893,7 +877,7 @@ var Elysia = class Elysia {
 			opts = nullObject();
 			opts.message = optionsOrHandler;
 		} else opts = optionsOrHandler;
-		this.#add("WS", path, void 0, opts);
+		this.#add("WS", path, opts, void 0, true);
 		return this;
 	}
 	mount(path, handleOrConfig, config) {
@@ -943,13 +927,6 @@ var Elysia = class Elysia {
 	/**
 	* Force all route handlers to compile immediately (sets `precompile: true`
 	* on the config and triggers a fresh build of the fetch handler).
-	*
-	* @remarks
-	* **Memory trade-off (bench-memory-1):** each compiled route retains ~4.8 KB
-	* (no schema) to ~6.6 KB (validated body) of memory (JSC compiled-function
-	* representation + closure scope); 1 000 validated routes ≈ 6.6 MB. Without
-	* this call, routes compile lazily on first request, spreading that cost over
-	* time. Use the AOT build plugin for the lowest cold-start footprint.
 	*/
 	compile() {
 		this["~config"] ??= nullObject();
@@ -1029,13 +1006,13 @@ var Elysia = class Elysia {
 				if (!schemaProperties.has(key)) continue;
 				const v = hook[key];
 				if (typeof v === "string") {
-					if (!models || !(v in models)) throw new Error(`[Elysia] Unknown model reference "${v}" for ${key} on route ${method} ${path}. Register it with .model('${v}', ...) before listen()/compile().`);
+					if (!models || !(v in models)) throw new Error(`[Elysia] Unknown model reference "${v}" for ${key} on route ${method} ${path}.`);
 				} else if (key === "response" && v && typeof v === "object") {
 					const record = v;
 					if ("~kind" in record || "~elyAcl" in record || "~standard" in record) continue;
 					for (const status in record) {
 						const r = record[status];
-						if (typeof r === "string" && (!models || !(r in models))) throw new Error(`[Elysia] Unknown model reference "${r}" for response ${status} on route ${method} ${path}. Register it with .model('${r}', ...) before listen()/compile().`);
+						if (typeof r === "string" && (!models || !(r in models))) throw new Error(`[Elysia] Unknown model reference "${r}" for response ${status} on route ${method} ${path}.`);
 					}
 				}
 			}
@@ -1120,7 +1097,7 @@ var Elysia = class Elysia {
 					const existing = this["~config"].websocket;
 					if (existing && isBun) {
 						for (const key in options) if (key in existing && existing[key] !== options[key]) {
-							console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, so per-route values are not enforced (the last-registered route wins).`);
+							console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, per-route values are not enforced (the last-registered route wins).`);
 							console.warn((/* @__PURE__ */ new Error()).stack);
 						}
 						Object.assign(existing, options);
@@ -1247,26 +1224,6 @@ var Elysia = class Elysia {
 		return r;
 	}
 };
-for (const [old, hint] of [
-	["onError", "use .error() instead"],
-	["onRequest", "use .request() instead"],
-	["onParse", "use .parse() instead"],
-	["onTransform", "use .transform() instead"],
-	["onBeforeHandle", "use .beforeHandle() instead"],
-	["onAfterHandle", "use .afterHandle() instead"],
-	["onAfterResponse", "use .afterResponse() instead"],
-	["onResponse", "use .mapResponse() instead"],
-	["onStart", "use the listen(port, callback) callback instead"],
-	["onStop", "use .cleanup() instead"],
-	["resolve", "use .derive() instead"]
-]) Object.defineProperty(Elysia.prototype, old, {
-	value: function removed() {
-		throw new Error(`.${old}() was removed in Elysia 2 — ${hint}`);
-	},
-	writable: true,
-	enumerable: false,
-	configurable: true
-});
 
 //#endregion
 export { Elysia };

package/dist/compile/aot.js

@@ -273,15 +273,9 @@ function captureGet(loc) {
 	return capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
 }
 const isAotBuildEnv = () => !!require_universal_env.env.ELYSIA_AOT_BUILD;
-let captureLogEmitted = false;
 const isValidatorCapturing = () => {
 	if (capture !== void 0) return true;
-	if (!isAotBuildEnv()) return false;
-	if (!captureLogEmitted) {
-		captureLogEmitted = true;
-		console.log("[elysia-aot] build capture mode enabled");
-	}
-	return true;
+	return isAotBuildEnv();
 };
 const Capture = {
 	set: captureSet,
@@ -296,9 +290,7 @@ const Capture = {
 * Reset module-level capture lifecycle state.
 * FOR TESTS ONLY — not exported from the package index.
 */
-const resetCaptureLifecycleForTests = () => {
-	captureLogEmitted = false;
-};
+const resetCaptureLifecycleForTests = () => void 0;
 
 //#endregion
 exports.Capture = Capture;

package/dist/compile/aot.mjs

@@ -272,15 +272,9 @@ function captureGet(loc) {
 	return capture?.get(`${loc.method}_${loc.path}_${loc.slot}`);
 }
 const isAotBuildEnv = () => !!env.ELYSIA_AOT_BUILD;
-let captureLogEmitted = false;
 const isValidatorCapturing = () => {
 	if (capture !== void 0) return true;
-	if (!isAotBuildEnv()) return false;
-	if (!captureLogEmitted) {
-		captureLogEmitted = true;
-		console.log("[elysia-aot] build capture mode enabled");
-	}
-	return true;
+	return isAotBuildEnv();
 };
 const Capture = {
 	set: captureSet,
@@ -295,9 +289,7 @@ const Capture = {
 * Reset module-level capture lifecycle state.
 * FOR TESTS ONLY — not exported from the package index.
 */
-const resetCaptureLifecycleForTests = () => {
-	captureLogEmitted = false;
-};
+const resetCaptureLifecycleForTests = () => void 0;
 
 //#endregion
 export { Capture, Compiled, EMPTY_EXTERNALS, Source, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck, resetCaptureLifecycleForTests };

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

@@ -6,27 +6,6 @@ const require_compile_aot = require('../aot.js');
 
 //#region src/compile/handler/frozen-validator.ts
 const isBridgeNotInitialized = (error) => error instanceof Error && error.message.startsWith("Typebox module isn't initialized");
-/**
-* A codec (`k`) slot is bridge-free ONLY when it is a slot-level SCALAR coercion
-* schema whose coerced form equals the raw hook schema — i.e. the user wrote the
-* coercion type explicitly (`t.Numeric()`/`t.IntegerString()`/`t.BooleanString()`
-* /`t.Date()`, optionally `t.Optional(...)`), so no coerce PLAN (`cp`) was baked.
-*
-* The reconstruction consumes only TypeBox-free `aot.ts` helpers off the raw
-* schema: `instantiateFrozenBoth` (check + Clean, wiring `e`/`u` from the schema),
-* `instantiateFrozenDecodeMirror` (the string→typed decode + Clean, `dm`). The
-* decode leaves and Refine predicates are pure closures already frozen into the
-* schema, so nothing here touches TypeBox.
-*
-* Refuses the cases the frozen `From` cannot serve bridge-free:
-*  - `cp`: needs `buildCoercedFromPlan` (drags TypeBox) to rebuild the schema.
-*  - `ic`: `t.ObjectString`/`t.ArrayString` inner codecs (JSON-in-string).
-*  - `em`: response-side encode mirror (request codec slots don't set it, but
-*    refuse defensively — the frozen `From` only wires the decode direction).
-*  - `ce`/`a`: custom errors / async refinement — the non-codec path refuses
-*    these too.
-*  - defaults not preallocated (`d` && !`ps`): would call the severed `Default`.
-*/
 function codecCoercionBridgeFree(f) {
 	return f.k === 1 && !!f.dm && !f.cp && !f.ic && !f.em && !f.ce && f.a !== 1 && !(f.d === 1 && f.ps !== 1);
 }

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

@@ -5,27 +5,6 @@ import { Compiled, EMPTY_EXTERNALS, instantiateFrozenBoth, instantiateFrozenDeco
 
 //#region src/compile/handler/frozen-validator.ts
 const isBridgeNotInitialized = (error) => error instanceof Error && error.message.startsWith("Typebox module isn't initialized");
-/**
-* A codec (`k`) slot is bridge-free ONLY when it is a slot-level SCALAR coercion
-* schema whose coerced form equals the raw hook schema — i.e. the user wrote the
-* coercion type explicitly (`t.Numeric()`/`t.IntegerString()`/`t.BooleanString()`
-* /`t.Date()`, optionally `t.Optional(...)`), so no coerce PLAN (`cp`) was baked.
-*
-* The reconstruction consumes only TypeBox-free `aot.ts` helpers off the raw
-* schema: `instantiateFrozenBoth` (check + Clean, wiring `e`/`u` from the schema),
-* `instantiateFrozenDecodeMirror` (the string→typed decode + Clean, `dm`). The
-* decode leaves and Refine predicates are pure closures already frozen into the
-* schema, so nothing here touches TypeBox.
-*
-* Refuses the cases the frozen `From` cannot serve bridge-free:
-*  - `cp`: needs `buildCoercedFromPlan` (drags TypeBox) to rebuild the schema.
-*  - `ic`: `t.ObjectString`/`t.ArrayString` inner codecs (JSON-in-string).
-*  - `em`: response-side encode mirror (request codec slots don't set it, but
-*    refuse defensively — the frozen `From` only wires the decode direction).
-*  - `ce`/`a`: custom errors / async refinement — the non-codec path refuses
-*    these too.
-*  - defaults not preallocated (`d` && !`ps`): would call the severed `Default`.
-*/
 function codecCoercionBridgeFree(f) {
 	return f.k === 1 && !!f.dm && !f.cp && !f.ic && !f.em && !f.ce && f.a !== 1 && !(f.d === 1 && f.ps !== 1);
 }

package/dist/constants.js

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/constants.ts
 const mapBack = (map) => Object.fromEntries(Object.entries(map).map(([key, value]) => [value, key]));
-const MethodMap = {
+const MethodMap = (/*#__PURE__*/ {
 	GET: 0,
 	HEAD: 1,
 	POST: 2,
@@ -12,9 +12,9 @@ const MethodMap = {
 	OPTIONS: 6,
 	CONNECT: 7,
 	TRACE: 8
-};
+});
 const MethodMapBack = mapBack(MethodMap);
-const StatusMap = {
+const StatusMap = (/*#__PURE__*/ {
 	Continue: 100,
 	"Switching Protocols": 101,
 	Processing: 102,
@@ -76,7 +76,7 @@ const StatusMap = {
 	"Loop Detected": 508,
 	"Not Extended": 510,
 	"Network Authentication Required": 511
-};
+});
 const traceEvents = [
 	"request",
 	"parse",

package/dist/constants.mjs

@@ -1,6 +1,6 @@
 //#region src/constants.ts
 const mapBack = (map) => Object.fromEntries(Object.entries(map).map(([key, value]) => [value, key]));
-const MethodMap = {
+const MethodMap = (/*#__PURE__*/ {
 	GET: 0,
 	HEAD: 1,
 	POST: 2,
@@ -10,9 +10,9 @@ const MethodMap = {
 	OPTIONS: 6,
 	CONNECT: 7,
 	TRACE: 8
-};
+});
 const MethodMapBack = mapBack(MethodMap);
-const StatusMap = {
+const StatusMap = (/*#__PURE__*/ {
 	Continue: 100,
 	"Switching Protocols": 101,
 	Processing: 102,
@@ -74,7 +74,7 @@ const StatusMap = {
 	"Loop Detected": 508,
 	"Not Extended": 510,
 	"Network Authentication Required": 511
-};
+});
 const traceEvents = [
 	"request",
 	"parse",

package/dist/plugin/core.js

@@ -359,8 +359,6 @@ async function generateCompiledArtifacts(file, options) {
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;
 		const frozenSlots = artifacts.validators.length;
 		const { plan: stub, mode } = planFromReport(strip, report, hasWS, aliases, artifacts.handlers.length > 0 && !routesForbidSeal && frozenSlots >= expectedSlots && artifacts.validators.every((v) => v.bridgeFree === true));
-		const stubbed = Object.keys(stub).filter((key) => stub[key]);
-		console.log(`[elysia-aot] routes=${routes.length} handlers=${artifacts.handlers.length} validators=${frozenSlots}/${expectedSlots} mode=${mode} stub=${stubbed.join(",") || "none"}` + (report.jit ? "" : ` jit-reachable (${report.reasons.join(", ") || "unknown"})`));
 		if (options?.target === "workerd") {
 			if (!report.jit) throw new Error(`[elysia-aot] target 'workerd' but handler JIT is still reachable (${report.reasons.join(", ") || "unknown"}). Every route must be captured into the AOT manifest.`);
 			if (frozenSlots < expectedSlots) console.warn(`[elysia-aot] target 'workerd': only ${frozenSlots}/${expectedSlots} validator slots were frozen unfrozen slots compile at runtime and will fail on workerd.`);

package/dist/plugin/core.mjs

@@ -357,8 +357,6 @@ async function generateCompiledArtifacts(file, options) {
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;
 		const frozenSlots = artifacts.validators.length;
 		const { plan: stub, mode } = planFromReport(strip, report, hasWS, aliases, artifacts.handlers.length > 0 && !routesForbidSeal && frozenSlots >= expectedSlots && artifacts.validators.every((v) => v.bridgeFree === true));
-		const stubbed = Object.keys(stub).filter((key) => stub[key]);
-		console.log(`[elysia-aot] routes=${routes.length} handlers=${artifacts.handlers.length} validators=${frozenSlots}/${expectedSlots} mode=${mode} stub=${stubbed.join(",") || "none"}` + (report.jit ? "" : ` jit-reachable (${report.reasons.join(", ") || "unknown"})`));
 		if (options?.target === "workerd") {
 			if (!report.jit) throw new Error(`[elysia-aot] target 'workerd' but handler JIT is still reachable (${report.reasons.join(", ") || "unknown"}). Every route must be captured into the AOT manifest.`);
 			if (frozenSlots < expectedSlots) console.warn(`[elysia-aot] target 'workerd': only ${frozenSlots}/${expectedSlots} validator slots were frozen unfrozen slots compile at runtime and will fail on workerd.`);

package/dist/plugin/vite.js

@@ -64,7 +64,7 @@ const aot = (entry, options) => {
 			virtualType = generated.virtualType;
 		},
 		buildEnd() {
-			if (!entryMatched) throw new Error(`[elysia-aot] entry "${entry}" never appeared in the Vite module graph — the compiled manifest was not injected. Check that the plugin entry matches a build input.`);
+			if (!entryMatched) throw new Error(`[elysia-aot] entry "${entry}" never appeared in the Vite module graph. Compiled manifest was not injected. Check that the plugin entry matches a build input.`);
 		},
 		resolveId(id) {
 			if (id === "elysia/compiled") return VIRTUAL;

package/dist/plugin/vite.mjs

@@ -62,7 +62,7 @@ const aot = (entry, options) => {
 			virtualType = generated.virtualType;
 		},
 		buildEnd() {
-			if (!entryMatched) throw new Error(`[elysia-aot] entry "${entry}" never appeared in the Vite module graph — the compiled manifest was not injected. Check that the plugin entry matches a build input.`);
+			if (!entryMatched) throw new Error(`[elysia-aot] entry "${entry}" never appeared in the Vite module graph. Compiled manifest was not injected. Check that the plugin entry matches a build input.`);
 		},
 		resolveId(id) {
 			if (id === "elysia/compiled") return VIRTUAL;

package/dist/type/bridge.d.ts

@@ -1,16 +1,16 @@
-import { Intersect as Intersect$1 } from "./elysia/intersect.js";
+import { Intersect as Intersect$2 } from "./elysia/intersect.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
 import { hasTypes as hasTypes$1 } from "./utils.js";
 import { TypeBoxValidatorCache as TypeBoxValidatorCache$1 } from "./validator/validator-cache.js";
 import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
 import { Compile as Compile$1 } from "typebox/compile";
-import { Clone as Clone$1, Decode as Decode$1, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
+import { Clone as Clone$1, Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {
   Compile: typeof Compile$1;
-  Decode: typeof Decode$1;
+  Decode: typeof Decode$2;
   applyCoercions: typeof applyCoercions$1;
   TypeBoxValidator: TypeBoxValidator$1;
   TypeBoxValidatorCache: TypeBoxValidatorCache$1;
@@ -21,13 +21,13 @@ interface TypeboxModule {
   coerceBody: typeof coerceBody$1;
   hasTypes: typeof hasTypes$1;
   HasCodec: typeof HasCodec$1;
-  Intersect: typeof Intersect$1;
+  Intersect: typeof Intersect$2;
   Default: typeof Default$1;
   Ref: typeof Ref$1;
   Clone: typeof Clone$1;
 }
 declare let Compile: typeof Compile$1;
-declare let Decode: typeof Decode$1;
+declare let Decode: typeof Decode$2;
 declare let applyCoercions: typeof applyCoercions$1;
 declare let TypeBoxValidator: TypeBoxValidator$1;
 type TypeBoxValidator<T extends TSchema = TAny> = TypeBoxValidator$1<T>;
@@ -40,7 +40,7 @@ declare let coerceStringToStructure: typeof coerceStringToStructure$1;
 declare let coerceBody: typeof coerceBody$1;
 declare let hasTypes: typeof hasTypes$1;
 declare let HasCodec: typeof HasCodec$1;
-declare let Intersect: typeof Intersect$1;
+declare let Intersect: typeof Intersect$2;
 declare let Default: typeof Default$1;
 declare let Ref: typeof Ref$1;
 declare let Clone: typeof Clone$1;

package/dist/type/coerce.d.ts

@@ -36,7 +36,7 @@ declare const coerceQuery: () => CoerceOption[];
 declare const coerceBody: () => CoerceOption[];
 declare const coerceFormData: () => CoerceOption[];
 declare const coerceStringToStructure: () => CoerceOption[];
-declare function applyCoercions(schema: BaseSchema | TSchema, coerces: CoerceOption[] | undefined): TSchema | BaseSchema;
+declare function applyCoercions(schema: BaseSchema | TSchema, coerces: CoerceOption[] | undefined): BaseSchema | TSchema;
 interface CoerceLeaf {
   e: number;
   c?: Record<string, unknown>;

package/dist/type/constants.d.ts

@@ -17,7 +17,7 @@ declare const ELYSIA_TYPES: {
   readonly NoValidate: 15;
 };
 type ELYSIA_TYPES = typeof ELYSIA_TYPES;
-declare const primitiveElysiaTypes: Set<3 | 1 | 2 | 6 | 14 | 13 | 11 | 10>;
+declare const primitiveElysiaTypes: Set<1 | 2 | 3 | 6 | 10 | 11 | 13 | 14>;
 declare const noEnumerable: {
   readonly enumerable: false;
 };

package/dist/types.d.ts

@@ -914,5 +914,8 @@ type GlobalHookReturn<BasePath extends string, Scope extends EventScope, Singlet
 type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Response> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateEden<JoinPath<BasePath, Path>, {
   subscribe: CreateWSEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Response, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>>;
 }>, Ephemeral, Volatile>;
+type GuardHookSingleton<Singleton extends SingletonBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, MacroContext> = Singleton & {
+  derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['resolve'];
+};
 //#endregion
-export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GlobalHookReturn, GracefulHandler, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, Handler, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InlineSchemaResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, IsUnknown, JoinPath, LocalHook, LocalHookReturn, Macro, MacroProperty, MacroPropertyKey, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, RouteBase, RouteSchema, SSEPayload, SingletonBase, type StandardSchemaV1Like, TraceHandler, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WrapFn };
+export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, Handler, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InlineSchemaResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, IsUnknown, JoinPath, LocalHook, LocalHookReturn, Macro, MacroProperty, MacroPropertyKey, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, RouteBase, RouteSchema, SSEPayload, SingletonBase, type StandardSchemaV1Like, TraceHandler, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WrapFn };

package/dist/utils.d.ts

@@ -147,5 +147,6 @@ declare function prefix<T extends string, Models extends Record<string, AnySchem
 declare namespace prefix {
   var capitalize: <T extends string, Models extends Record<string, AnySchema>>(prefix: T, models: Models) => { [k in keyof Models as `${T}.${Capitalize<k & string>}`]: Models[k] };
 }
+declare function serializeMacroSeed(_key: string, value: unknown): unknown;
 //#endregion
-export { ChainNode, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, sse };
+export { ChainNode, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };

package/dist/utils.js

@@ -509,6 +509,22 @@ prefix.capitalize = function prefixModelsCapitalize(prefix, models) {
 	for (const key in models) prefixed[`${prefix}.${capitalize(key)}`] = models[key];
 	return prefixed;
 };
+const macroSeedRefIds = /* @__PURE__ */ new WeakMap();
+let macroSeedRefCounter = 0;
+function macroSeedRefId(ref) {
+	let id = macroSeedRefIds.get(ref);
+	if (id === void 0) macroSeedRefIds.set(ref, id = ++macroSeedRefCounter);
+	return id;
+}
+function serializeMacroSeed(_key, value) {
+	switch (typeof value) {
+		case "function": return "\0fn:" + macroSeedRefId(value);
+		case "bigint": return "\0bigint:" + value.toString();
+		case "symbol": return "\0sym:" + String(value);
+		case "undefined": return "\0undefined";
+		default: return value;
+	}
+}
 
 //#endregion
 exports.cloneHook = cloneHook;
@@ -550,4 +566,5 @@ exports.redirect = redirect;
 exports.replaceUrlPath = replaceUrlPath;
 exports.requestId = requestId;
 exports.schemaProperties = schemaProperties;
+exports.serializeMacroSeed = serializeMacroSeed;
 exports.sse = sse;

package/dist/utils.mjs

@@ -508,6 +508,22 @@ prefix.capitalize = function prefixModelsCapitalize(prefix, models) {
 	for (const key in models) prefixed[`${prefix}.${capitalize(key)}`] = models[key];
 	return prefixed;
 };
+const macroSeedRefIds = /* @__PURE__ */ new WeakMap();
+let macroSeedRefCounter = 0;
+function macroSeedRefId(ref) {
+	let id = macroSeedRefIds.get(ref);
+	if (id === void 0) macroSeedRefIds.set(ref, id = ++macroSeedRefCounter);
+	return id;
+}
+function serializeMacroSeed(_key, value) {
+	switch (typeof value) {
+		case "function": return "\0fn:" + macroSeedRefId(value);
+		case "bigint": return "\0bigint:" + value.toString();
+		case "symbol": return "\0sym:" + String(value);
+		case "undefined": return "\0undefined";
+		default: return value;
+	}
+}
 
 //#endregion
-export { cloneHook, clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, sse };
+export { cloneHook, clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };

package/dist/validator/index.js

@@ -94,7 +94,7 @@ const isCompiledSchema = (schema) => schema != null && typeof schema.Check === "
 const isSingleSchema = (schema) => "~kind" in schema || "~elyAcl" in schema || "~standard" in schema;
 const toStatusBased = (schema) => isSingleSchema(schema) ? { 200: schema } : schema;
 const isAsyncStandardSchema = (schema) => require_compile_utils.isAsyncFunction(schema["~standard"].validate);
-const asyncStandardSchemaError = () => /* @__PURE__ */ new Error("[Elysia] An asynchronous Standard Schema was used where only synchronous validation is supported. Declare the schema validate function as async so Elysia can emit an async route.");
+const asyncStandardSchemaError = () => /* @__PURE__ */ new Error("[Elysia] An asynchronous Standard Schema was used where only synchronous validation is supported.");
 var StandardValidator = class extends Validator {
 	#validate;
 	constructor(schema) {

package/dist/validator/index.mjs

@@ -93,7 +93,7 @@ const isCompiledSchema = (schema) => schema != null && typeof schema.Check === "
 const isSingleSchema = (schema) => "~kind" in schema || "~elyAcl" in schema || "~standard" in schema;
 const toStatusBased = (schema) => isSingleSchema(schema) ? { 200: schema } : schema;
 const isAsyncStandardSchema = (schema) => isAsyncFunction(schema["~standard"].validate);
-const asyncStandardSchemaError = () => /* @__PURE__ */ new Error("[Elysia] An asynchronous Standard Schema was used where only synchronous validation is supported. Declare the schema validate function as async so Elysia can emit an async route.");
+const asyncStandardSchemaError = () => /* @__PURE__ */ new Error("[Elysia] An asynchronous Standard Schema was used where only synchronous validation is supported.");
 var StandardValidator = class extends Validator {
 	#validate;
 	constructor(schema) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "2.0.0-exp.26",
+	"version": "2.0.0-exp.28",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",