elysia 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/base.d.ts

@@ -5,7 +5,7 @@ import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { TraceCapability, TraceHandler } from "./trace.js";
 import { AnySchema } from "./type/types.js";
 import { AotFingerprint, CompilerSession, ProgramId } from "./compile/aot.js";
-import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CatchAllEntries, CatchAllHookReturn, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DeriveResponse, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, ErrorHookStatus, EventScope, ExcludeElysiaResponse, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LegacyScope, LocalHook, LocalHookReturn, Macro, MacroCatchAll, MacroOptionContext, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, ObjectMacroDefs, OptionalHandler, ParentResponse, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveUsedRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WithErrorEntries, WithoutMacroCatch, WrapFn } from "./types.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CatchAllEntries, CatchAllHookReturn, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DeriveResponse, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, ErrorHookStatus, EventScope, ExcludeElysiaResponse, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HeadersKeyCheck, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InstanceHookReturn, InternalRoute, IntersectIfObjectSchema, JoinPath, LegacyScope, LocalHook, LocalHookReturn, Macro, MacroCatchAll, MacroOptionContext, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, ObjectMacroDefs, OptionalHandler, ParentInput, ParentResponse, PluginHookReturn, PreHandler, PreValidationTransform, Prettify, PublicRoute, ResolveUsedRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, UnionResponseStatus, UnwrapRoute, UnwrapSchema, UsedRoutesUnder, WithErrorEntries, WithoutMacroCatch, WrapFn } from "./types.js";
 import { RouteErrorHooks } from "./handler/utils.js";
 import { WSCapability, WSHandlerResponse, WSLocalHook, WSMessageHandler, WSOptions, WSOptionsEntry } from "./ws/types.js";
 import { RouteTable } from "./route-table.js";
@@ -260,13 +260,13 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    * ```
    */
   onStart(handler: MaybeArray<GracefulHandler<this>>): this;
-  onTransform(fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>): this;
+  onTransform(fn: MaybeArray<PreValidationTransform<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>): this;
   /** @deprecated 1.x syntax, use `.onTransform('plugin', fn)`, `'scoped'` is now `'plugin'` */
   onTransform<const As extends 'local' | 'scoped' | 'global'>(options: {
     as: As;
-  }, fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>): this;
-  onTransform<const HookScope extends EventScope>(scope: HookScope, fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>): this;
-  onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  }, fn: MaybeArray<PreValidationTransform<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>): this;
+  onTransform<const HookScope extends EventScope>(scope: HookScope, fn: MaybeArray<PreValidationTransform<MergeSchema<{}, {}, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>): this;
+  onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, Scope>>>(fn: Handler): InstanceHookReturn<Scope, BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(scope: 'local', fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>>>(scope: 'plugin', fn: Handler): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   onBeforeHandle<const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>>>(scope: 'global', fn: Handler): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
@@ -275,7 +275,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     as: As;
   }, fn: Handler): ScopedHookReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   onBeforeHandle<const HookScope extends EventScope, const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>>>(scope: HookScope, fn: Handler): ScopedHookReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
-  derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | Error | void>(transform: (context: Context<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>) => MaybePromise<Derivative>): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, DeriveResponse<Derivative>, ExcludeElysiaResponse<Derivative>>;
+  derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | Error | void>(transform: (context: [Scope] extends ['local'] ? Context<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>> : LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, Scope>) => MaybePromise<Derivative>): InstanceHookReturn<Scope, BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, DeriveResponse<Derivative>, ExcludeElysiaResponse<Derivative>>;
   derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | Error | void>(scope: 'local', transform: (context: Context<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>) => MaybePromise<Derivative>): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, DeriveResponse<Derivative>, ExcludeElysiaResponse<Derivative>>;
   derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | Error | void>(scope: 'plugin', transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>) => MaybePromise<Derivative>): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, DeriveResponse<Derivative>, ExcludeElysiaResponse<Derivative>>;
   derive<const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | Error | void>(scope: 'global', transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>) => MaybePromise<Derivative>): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, DeriveResponse<Derivative>, ExcludeElysiaResponse<Derivative>>;
@@ -322,7 +322,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     as: As;
   }, transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>) => MaybePromise<Derivative>): ScopedMapDeriveReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, DeriveResponse<Derivative>, ExcludeElysiaResponse<Derivative>>;
   mapDerive<const HookScope extends EventScope, const Derivative extends Record<string, unknown> | ElysiaStatus<any, any, any> | Error | void>(scope: HookScope, transform: (context: LifecycleContext<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>) => MaybePromise<Derivative>): ScopedMapDeriveReturn<HookScope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, DeriveResponse<Derivative>, ExcludeElysiaResponse<Derivative>>;
-  onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
+  onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, Scope>>>(fn: Handler): InstanceHookReturn<Scope, BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>>>>(scope: 'local', fn: Handler): LocalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'plugin'>>>(scope: 'plugin', fn: Handler): PluginHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
   onAfterHandle<const Handler extends MaybeArray<AfterHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, 'global'>>>(scope: 'global', fn: Handler): GlobalHookReturn<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler>>;
@@ -343,7 +343,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     as: As;
   }, fn: AfterResponseHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>): this;
   onAfterResponse<const HookScope extends EventScope>(scope: HookScope, fn: AfterResponseHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, HookScope>): this;
-  onError<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton>>>(fn: Handler): CatchAllHookReturn<'local', BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Handler>;
+  onError<const Handler extends MaybeArray<ErrorHandler<[...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], {}, Singleton>>>(fn: Handler): CatchAllHookReturn<Scope, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Handler>;
   onError<const E extends AnyErrorConstructor & (abstract new (...args: any) => Error), const Fn extends (context: ErrorContext<{}, Singleton & {
     derive: Scope extends 'local' ? Partial<Ephemeral['derive'] & Volatile['derive']> : Scope extends 'plugin' ? Ephemeral['derive'] & Partial<Volatile['derive']> : Ephemeral['derive'] & Volatile['derive'];
   }> & {
@@ -695,7 +695,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, {
     typebox: Definitions['typebox'] & NewElysia['~Definitions']['typebox'];
     error: [...Definitions['error'], ...NewElysia['~Definitions']['error']];
-  }, MergeMetadata<Metadata, NewElysia['~Metadata']>, BasePath extends `` ? Routes & ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>> : Routes & CreateEden<BasePath, ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>>>, Ephemeral, {
+  }, MergeMetadata<Metadata, NewElysia['~Metadata']>, BasePath extends `` ? Routes & ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>, ParentInput<Metadata, Ephemeral, Volatile>> : Routes & UsedRoutesUnder<BasePath, ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>, ParentInput<Metadata, Ephemeral, Volatile>>>, Ephemeral, {
     derive: Volatile['derive'] & NewElysia['~Ephemeral']['derive'];
     schema: Volatile['schema'] & NewElysia['~Ephemeral']['schema'];
     schemas: Volatile['schemas'] & NewElysia['~Ephemeral']['schemas'];
@@ -725,7 +725,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, {
     typebox: Definitions['typebox'] & NewElysia['~Definitions']['typebox'];
     error: [...Definitions['error'], ...NewElysia['~Definitions']['error']];
-  }, MergeMetadata<Metadata, NewElysia['~Metadata']>, BasePath extends `` ? Routes & ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>> : Routes & CreateEden<BasePath, ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>>>, Ephemeral, {
+  }, MergeMetadata<Metadata, NewElysia['~Metadata']>, BasePath extends `` ? Routes & ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>, ParentInput<Metadata, Ephemeral, Volatile>> : Routes & UsedRoutesUnder<BasePath, ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>, ParentInput<Metadata, Ephemeral, Volatile>>>, Ephemeral, {
     derive: Volatile['derive'] & NewElysia['~Ephemeral']['derive'];
     schema: Volatile['schema'] & NewElysia['~Ephemeral']['schema'];
     schemas: Volatile['schemas'] & NewElysia['~Ephemeral']['schemas'];
@@ -771,7 +771,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, {
     typebox: Definitions['typebox'] & NewElysia['~Definitions']['typebox'];
     error: [...Definitions['error'], ...NewElysia['~Definitions']['error']];
-  }, MergeMetadata<Metadata, NewElysia['~Metadata']>, BasePath extends `` ? Routes & ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>> : Routes & CreateEden<BasePath, ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>>>, Ephemeral, {
+  }, MergeMetadata<Metadata, NewElysia['~Metadata']>, BasePath extends `` ? Routes & ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>, ParentInput<Metadata, Ephemeral, Volatile>> : Routes & UsedRoutesUnder<BasePath, ResolveUsedRouteErrors<NewElysia['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>, ParentInput<Metadata, Ephemeral, Volatile>>>, Ephemeral, {
     derive: Volatile['derive'] & Partial<NewElysia['~Ephemeral']['derive']>;
     schema: Volatile['schema'] & NewElysia['~Ephemeral']['schema'];
     schemas: Volatile['schemas'] & NewElysia['~Ephemeral']['schemas'];
@@ -845,7 +845,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   get<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'get', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'get', Path, Schema, MacroContext, Handle, Input>;
   get<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'get', Path, Schema, {}, Handle>;
@@ -865,7 +865,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   post<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'post', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'post', Path, Schema, MacroContext, Handle, Input>;
   post<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'post', Path, Schema, {}, Handle>;
@@ -885,7 +885,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   put<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'put', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'put', Path, Schema, MacroContext, Handle, Input>;
   put<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'put', Path, Schema, {}, Handle>;
@@ -905,7 +905,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   patch<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'patch', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'patch', Path, Schema, MacroContext, Handle, Input>;
   patch<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'patch', Path, Schema, {}, Handle>;
@@ -925,7 +925,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   delete<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'delete', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'delete', Path, Schema, MacroContext, Handle, Input>;
   delete<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'delete', Path, Schema, {}, Handle>;
@@ -945,7 +945,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   options<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'options', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'options', Path, Schema, MacroContext, Handle, Input>;
   options<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'options', Path, Schema, {}, Handle>;
@@ -965,7 +965,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   query<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'query', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'query', Path, Schema, MacroContext, Handle, Input>;
   query<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'query', Path, Schema, {}, Handle>;
@@ -985,7 +985,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   head<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'head', Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'head', Path, Schema, MacroContext, Handle, Input>;
   head<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'head', Path, Schema, {}, Handle>;
@@ -1004,13 +1004,13 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   route<const Method extends HTTPMethod, const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string> & RouteHookCapture, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(method: Method, path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Method, Path, Schema, MacroContext, Handle, Input>;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(method: Method, path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Lowercase<Method>, Path, Schema, MacroContext, Handle, Input>;
   route<const Method extends HTTPMethod, const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(method: Method, path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Method, Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(method: Method, path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Lowercase<Method>, Path, Schema, {}, Handle>;
   all<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey>, fn: Handle): this;
+  }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>), UnknownKey extends PropertyKey = Exclude<keyof Input, HookObjectKey | keyof Metadata['macro']>>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']> & MacroOptionContext<Metadata['macroFn'], Schema, Decorator> & UnknownHookKey<UnknownKey> & NoInfer<HeadersKeyCheck<Input, UnwrapSchema<Input['headers'], Definitions['typebox']>>>, fn: Handle): this;
   all<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): this;

package/dist/base.js

@@ -18,12 +18,34 @@ memoirist = require_runtime.__toESM(memoirist);
 
 //#region src/base.ts
 const useNodesBuffer = [];
-const propagatedRegistrations = /* @__PURE__ */ new WeakMap();
-const liftedRequests = /* @__PURE__ */ new WeakMap();
+const chainKeys = /* @__PURE__ */ new WeakMap();
+const keyCounters = /* @__PURE__ */ new WeakMap();
+const requestOrigins = /* @__PURE__ */ new WeakMap();
 const hocOriginOf = (o) => typeof o === "object" ? o.origin : o;
 const emptyHistory = Object.freeze([]);
 let mutationEpoch = 0;
 const extCallbackIndexes = /* @__PURE__ */ new WeakMap();
+const warnedVariants = /* @__PURE__ */ new Set();
+const hookSource = (added) => {
+	let source = "";
+	for (const key in added) for (const v of [].concat(added[key])) source += key + (typeof v === "function" ? v : typeof v);
+	return source;
+};
+const warnVariant = (origin, a, b) => {
+	if (warnedVariants.has(origin) || hookSource(a.added) === hookSource(b.added)) return;
+	warnedVariants.add(origin);
+	console.warn("[Elysia] same-name plugin variants register different hooks, one is skipped: give each variant its own seed");
+};
+const hasHook = (v) => v != null && (!Array.isArray(v) || v.length > 0);
+const hollow = (added) => {
+	for (const key in added) if (key !== "schema" && hasHook(added[key])) return false;
+	return true;
+};
+const assignTable = (target, source, append) => {
+	if (!target || !append) return Object.assign(target ?? require_utils.nullObject(), source);
+	for (const key in source) if (!(key in target)) target[key] = source[key];
+	return target;
+};
 const mergeExtCallbacks = (target, incoming) => {
 	if (!target) return incoming.slice();
 	let index = extCallbackIndexes.get(target);
@@ -296,10 +318,12 @@ var Elysia = class Elysia {
 		this.#pushChainNode(added, scope);
 		return this;
 	}
-	#pushChainNode(added, scope, registration, origin, owner) {
+	#pushChainNode(added, scope, registration, origin, owner, key, dup) {
 		const parent = this["~hookChain"];
 		const refs = parent !== void 0 && parent.refs || Elysia.#hookHasString(added);
-		this["~hookChain"] = registration ? {
+		if (!registration && (scope === "plugin" || scope === "global") && !hollow(added)) key = this.#nameRegistration();
+		if (parent?.dup) dup = true;
+		const node = registration ? {
 			added,
 			parent,
 			refs,
@@ -307,15 +331,46 @@ var Elysia = class Elysia {
 			propagated: true,
 			owner,
 			origin,
-			registration
+			registration,
+			key
 		} : {
 			added,
 			parent,
 			refs,
 			scope,
 			owner: this["~scopeChild"] ? this : void 0,
-			origin: this.hash
+			origin: this.hash,
+			key
 		};
+		if (dup || !registration && key !== void 0 && this.#holdKey(key, node)) node.dup = true;
+		this["~hookChain"] = node;
+	}
+	#holdKey(key, registration) {
+		const keys = chainKeys.get(this);
+		if (!keys) return;
+		if (keys.has(key)) return true;
+		keys.set(key, registration);
+	}
+	#keysOf() {
+		let keys = chainKeys.get(this);
+		if (keys) return keys;
+		chainKeys.set(this, keys = /* @__PURE__ */ new Map());
+		const held = [];
+		for (let n = this["~hookChain"]; n; n = n.parent) if (n.key !== void 0 && !(n.registration && n.owner)) held.push(n);
+		for (let i = held.length - 1; i >= 0; i--) {
+			const n = held[i];
+			if (!keys.has(n.key)) keys.set(n.key, n.registration ?? n);
+		}
+		return keys;
+	}
+	#nameRegistration() {
+		if (this.hash === void 0) return;
+		let counter = keyCounters.get(this);
+		if (!counter) keyCounters.set(this, counter = {
+			p: this.hash.toString(36) + ":",
+			n: 0
+		});
+		return [counter.p, counter.n++].join("");
 	}
 	#onBranch(type, scopeOrFn, fn) {
 		return fn ? this.#on(type, fn, scopeOrFn) : this.#on(type, scopeOrFn);
@@ -397,15 +452,22 @@ var Elysia = class Elysia {
 		return this;
 	}
 	#as(node, scope) {
+		const tail = node;
+		let collided = false;
 		while (node) {
 			node = node;
 			if (node.scope !== "global" && (node.scope !== scope || node.propagated)) {
 				node.scope = scope;
 				node.propagated = false;
+				if (node.key === void 0 && !hollow(node.added)) {
+					node.key = this.#nameRegistration();
+					if (node.key !== void 0 && this.#holdKey(node.key, node.registration ?? node)) collided = true;
+				}
 				require_utils.invalidateMacroEpoch();
 			}
 			node = node.parent;
 		}
+		if (collided) for (let n = tail; n; n = n.parent) n.dup = true;
 	}
 	guard() {
 		const maybeHook = typeof arguments[0] === "string" ? arguments[1] : arguments[0];
@@ -656,35 +718,42 @@ var Elysia = class Elysia {
 	}
 	#use(app) {
 		let addedByThisCall;
+		let below = false;
 		const name = app["~config"]?.name;
 		if (name) {
 			const hash = app.hash;
-			if (this.childrenHash?.has(hash)) return;
-			this.childrenHash ??= /* @__PURE__ */ new Set();
-			this.childrenHash.add(hash);
-			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(hash);
+			const installed = this.childrenHash?.get(hash);
+			if (installed) return;
+			if (installed === false) below = true;
+			else {
+				(this.childrenHash ??= /* @__PURE__ */ new Map()).set(hash, true);
+				(addedByThisCall ??= /* @__PURE__ */ new Set()).add(hash);
+			}
 		}
 		if (app.childrenHash && !app["~scopeChild"]) addedByThisCall = this.#absorbChildrenHash(app, addedByThisCall);
 		if (app["~ext"]) this.#assertMacroUnique(app, addedByThisCall);
+		if (below) this.childrenHash.set(app.hash, true);
 		if (app["~hasTrace"]) this["~hasTrace"] = true;
-		if (app.declaredRoutes === void 0 && app["~routeTable"]?.length) app.#materializeDeclaredRoutes();
-		if (app.declaredRoutes?.length) {
-			if (app["~hasWS"]) this["~hasWS"] = true;
-			this.#emitChildRoutes(app, this["~hookChain"], name);
-		}
-		if (app["~scopeChildren"]) {
-			const children = this["~scopeChildren"] ??= [];
-			for (const child of app["~scopeChildren"]) children.push(child);
+		if (!below) {
+			if (app.declaredRoutes === void 0 && app["~routeTable"]?.length) app.#materializeDeclaredRoutes();
+			if (app.declaredRoutes?.length) {
+				if (app["~hasWS"]) this["~hasWS"] = true;
+				this.#emitChildRoutes(app, this["~hookChain"], name);
+			}
+			if (app["~scopeChildren"]) {
+				const children = this["~scopeChildren"] ??= [];
+				for (const child of app["~scopeChildren"]) children.push(child);
+			}
 		}
 		const hookChain = app["~hookChain"];
-		if (app["~ext"]) this.#absorbExt(app, addedByThisCall);
-		if (hookChain) this.#propagateHooks(app, hookChain, addedByThisCall);
+		if (app["~ext"]) this.#absorbExt(app, addedByThisCall, below);
+		if (hookChain) this.#propagateHooks(app, hookChain);
 	}
 	#absorbChildrenHash(app, addedByThisCall) {
-		const childrenHash = this.childrenHash ??= /* @__PURE__ */ new Set();
-		for (const h of app.childrenHash) {
+		const childrenHash = this.childrenHash ??= /* @__PURE__ */ new Map();
+		for (const h of app.childrenHash.keys()) {
 			if (childrenHash.has(h)) continue;
-			childrenHash.add(h);
+			childrenHash.set(h, false);
 			(addedByThisCall ??= /* @__PURE__ */ new Set()).add(h);
 		}
 		return addedByThisCall;
@@ -703,7 +772,7 @@ var Elysia = class Elysia {
 			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
 	}
-	#absorbExt(app, addedByThisCall) {
+	#absorbExt(app, addedByThisCall, append) {
 		const source = app["~ext"];
 		const { decorator, store, headers, models, parser, macro, hoc, setup, cleanup, capability } = source;
 		const ext = this["~ext"] ??= require_utils.nullObject();
@@ -711,17 +780,17 @@ var Elysia = class Elysia {
 			for (const field of sharedTables) if (source[field]) ext[field] ??= source[field];
 		}
 		if (decorator && decorator !== ext.decorator) {
-			if (ext.decorator) require_utils.mergeDeep(ext.decorator, decorator, void 0, true, false, void 0, { map: void 0 });
+			if (ext.decorator) require_utils.mergeDeep(ext.decorator, decorator, void 0, !append, false, void 0, { map: void 0 });
 			else ext.decorator = require_utils.clonePlainDecorators(decorator);
 			markStoredSingletons(ext.decorator, decorator);
 		}
-		if (store && store !== ext.store) if (ext.store) require_utils.mergeDeep(ext.store, store);
+		if (store && store !== ext.store) if (ext.store) require_utils.mergeDeep(ext.store, store, void 0, !append);
 		else ext.store = Object.assign(require_utils.nullObject(), store);
-		if (headers && headers !== ext.headers) ext.headers = Object.assign(ext.headers ?? require_utils.nullObject(), headers);
-		if (models && models !== ext.models) ext.models = Object.assign(ext.models ?? require_utils.nullObject(), models);
-		if (parser && parser !== ext.parser) ext.parser = Object.assign(ext.parser ?? require_utils.nullObject(), parser);
-		if (macro) if (app["~scopeChild"]) {
-			const pluginMacros = app.pluginMacros;
+		if (headers && headers !== ext.headers) ext.headers = assignTable(ext.headers, headers, append);
+		if (models && models !== ext.models) ext.models = assignTable(ext.models, models, append);
+		if (parser && parser !== ext.parser) ext.parser = assignTable(ext.parser, parser, append);
+		if (macro) if (app["~scopeChild"] || append) {
+			const pluginMacros = append ? new Map(Object.entries(macro)) : app.pluginMacros;
 			let changed = false;
 			if (pluginMacros?.size) {
 				const target = this.#ensureMacroTable();
@@ -780,7 +849,7 @@ var Elysia = class Elysia {
 			}
 		}
 	}
-	#propagateHooks(app, hookChain, addedByThisCall) {
+	#propagateHooks(app, hookChain) {
 		const nodes = useNodesBuffer;
 		nodes.length = 0;
 		let current = hookChain;
@@ -788,11 +857,12 @@ var Elysia = class Elysia {
 			nodes.push(current);
 			current = current.parent;
 		}
-		const childrenHash = this.childrenHash;
 		const scopeChild = app["~scopeChild"];
-		let held = propagatedRegistrations.get(this);
-		const lifted = liftedRequests.get(this);
-		let lifting;
+		const requests = requestOrigins.get(this);
+		let installing;
+		let keys = chainKeys.get(this);
+		let admitted;
+		let admittedMore;
 		for (let i = nodes.length - 1; i >= 0; i--) {
 			const node = nodes[i];
 			const scope = node.scope;
@@ -804,40 +874,39 @@ var Elysia = class Elysia {
 				source = require_utils.nullObject();
 				source.request = request;
 			}
+			if ((node.key === void 0 || scopeChild) && hollow(source)) continue;
 			const origin = node.origin ?? app.hash;
-			const registration = node.registration ?? node;
 			let added = source;
-			let repeated = false;
-			if (origin !== void 0) {
-				if (!held) propagatedRegistrations.set(this, held = /* @__PURE__ */ new WeakMap());
-				const through = held.get(registration);
-				if (!through) held.set(registration, [origin]);
-				else if (through.includes(origin)) repeated = true;
-				else through.push(origin);
-			}
-			const registrant = registration.origin;
-			if (repeated) {
-				const schemas = source.schemas;
-				if (!schemas) continue;
-				added = require_utils.nullObject();
-				added.schemas = schemas;
-			} else if (registrant !== void 0 && childrenHash?.has(registrant) && !addedByThisCall?.has(registrant)) {
-				added = require_utils.nullObject();
-				for (const key in source) if (key !== "~deriveEntries" && !require_utils.eventProperties.has(key)) added[key] = source[key];
-			}
+			const registration = node.registration ?? node;
+			let key = node.key;
+			let dup;
+			const held = key === void 0 ? void 0 : (keys ??= this.#keysOf()).get(key);
+			if (held) {
+				if (held !== registration && !require_universal_is_production.isProduction()) warnVariant(origin, held, registration);
+				if (scopeChild || held !== registration || origin !== admitted && !admittedMore?.has(origin)) {
+					const schemas = source.schemas;
+					if (!schemas) continue;
+					added = require_utils.nullObject();
+					added.schemas = schemas;
+					key = void 0;
+				} else dup = true;
+			} else if (key !== void 0 && origin !== admitted) if (admitted === void 0) admitted = origin;
+			else (admittedMore ??= /* @__PURE__ */ new Set()).add(origin);
 			let dropRequest = false;
-			if (origin !== void 0 && "request" in added) {
-				if (lifted?.has(origin)) dropRequest = true;
-				else if (scopeChild) (lifting ??= new Set(lifted)).add(origin);
-			}
+			if (origin !== void 0 && hasHook(added.request)) if (requests?.has(origin) && !installing?.has(origin)) dropRequest = true;
+			else (installing ??= /* @__PURE__ */ new Set()).add(origin);
 			if ("schema" in added || dropRequest) {
 				if (added === source) added = Object.assign(require_utils.nullObject(), source);
 				delete added.schema;
 				if (dropRequest) delete added.request;
 			}
-			if (require_utils.isNotEmpty(added)) this.#pushChainNode(added, scope, registration, origin, scopeChild ? app : void 0);
+			if (added !== source && hollow(added)) continue;
+			if (key === void 0 && !held) key = this.#nameRegistration();
+			if (key !== void 0 && !dup && !scopeChild) (keys ??= this.#keysOf()).set(key, registration);
+			this.#pushChainNode(added, scope, registration, origin, scopeChild ? app : void 0, key, dup);
 		}
-		if (lifting) liftedRequests.set(this, lifting);
+		if (installing) if (requests) for (const origin of installing) requests.add(origin);
+		else requestOrigins.set(this, installing);
 		nodes.length = 0;
 	}
 	#emitChildRoutes(app, preChain, name) {