elysia 2.0.0-beta.31 → 2.0.0-beta.32

package/dist/base.d.ts

@@ -266,15 +266,15 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     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, true>>;
-  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, true>>;
-  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, true>>;
-  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, true>>;
+  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>>;
+  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>>;
   /** @deprecated 1.x syntax, use `.onBeforeHandle('plugin', fn)`, `'scoped'` is now `'plugin'` */
   onBeforeHandle<const As extends 'local' | 'scoped' | 'global', const Handler extends MaybeArray<OptionalHandler<HookContextSchema<Metadata, Ephemeral, Volatile, BasePath>, HookContextSingleton<Singleton, Ephemeral, Volatile>, undefined, LegacyScope<As>>>>(options: {
     as: As;
-  }, fn: Handler): ScopedHookReturn<LegacyScope<As>, BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, ElysiaHandlerToResponseSchemaAmbiguous<Handler, true>>;
-  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, true>>;
+  }, 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>(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>>;
@@ -475,7 +475,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Volatile['derive'] & MacroContext['derive'];
     schema: Volatile['schema'];
     schemas: Volatile['schemas'] & UnwrapRoute<Input, Definitions['typebox']> & MacroContext;
-    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
     error: [...Volatile['error'], ...CatchAllEntries<ErrorHandle>, ...MacroCatchAll<MacroContext['return' & keyof MacroContext]>];
   }>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
@@ -484,7 +484,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Volatile['derive'] & MacroContext['derive'];
     schema: {} extends Pick<Input, Extract<keyof Input, InputSchemaKey>> ? Volatile['schema'] : MergeSchema<UnwrapRoute<Input, Definitions['typebox']>, Volatile['schema']>;
     schemas: Volatile['schemas'] & MacroContext;
-    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
     error: [...Volatile['error'], ...CatchAllEntries<ErrorHandle>, ...MacroCatchAll<MacroContext['return' & keyof MacroContext]>];
   }>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
@@ -501,7 +501,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     macro: Metadata['macro'];
     macroFn: Metadata['macroFn'];
     parser: Metadata['parser'];
-    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
   }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -515,7 +515,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     macro: Metadata['macro'];
     macroFn: Metadata['macroFn'];
     parser: Metadata['parser'];
-    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
   }, {}, {
     derive: Ephemeral['derive'];
     schema: {};
@@ -537,7 +537,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Volatile['derive'] & MacroContext['derive'];
     schema: Volatile['schema'];
     schemas: Volatile['schemas'] & UnwrapRoute<Input, Definitions['typebox']> & MacroContext;
-    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
     error: [...Volatile['error'], ...CatchAllEntries<ErrorHandle>, ...MacroCatchAll<MacroContext['return' & keyof MacroContext]>];
   }>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'local', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
@@ -546,7 +546,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Volatile['derive'] & MacroContext['derive'];
     schema: {} extends Pick<Input, Extract<keyof Input, InputSchemaKey>> ? Volatile['schema'] : MergeSchema<UnwrapRoute<Input, Definitions['typebox']>, Volatile['schema']>;
     schemas: Volatile['schemas'] & MacroContext;
-    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Volatile['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
     error: [...Volatile['error'], ...CatchAllEntries<ErrorHandle>, ...MacroCatchAll<MacroContext['return' & keyof MacroContext]>];
   }>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'plugin', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
@@ -557,7 +557,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Ephemeral['derive'] & MacroContext['derive'];
     schema: Ephemeral['schema'];
     schemas: Ephemeral['schemas'] & UnwrapRoute<Input, Definitions['typebox']> & MacroContext;
-    response: UnionResponseStatus<UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
     error: [...Ephemeral['error'], ...CatchAllEntries<ErrorHandle>, ...MacroCatchAll<MacroContext['return' & keyof MacroContext]>];
   }, Volatile>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'plugin', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
@@ -566,7 +566,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Ephemeral['derive'] & MacroContext['derive'];
     schema: {} extends Pick<Input, Extract<keyof Input, InputSchemaKey>> ? Ephemeral['schema'] : MergeSchema<UnwrapRoute<Input, Definitions['typebox']>, Ephemeral['schema']>;
     schemas: Ephemeral['schemas'] & MacroContext;
-    response: UnionResponseStatus<UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
     error: [...Ephemeral['error'], ...CatchAllEntries<ErrorHandle>, ...MacroCatchAll<MacroContext['return' & keyof MacroContext]>];
   }, Volatile>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'global', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'merge'> & {
@@ -583,7 +583,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     macro: Metadata['macro'];
     macroFn: Metadata['macroFn'];
     parser: Metadata['parser'];
-    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
   }, Routes, Ephemeral, Volatile>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'global', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -597,7 +597,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     macro: Metadata['macro'];
     macroFn: Metadata['macroFn'];
     parser: Metadata['parser'];
-    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
   }, Routes, Ephemeral, Volatile>;
   group<const Prefix extends string, const NewElysia extends AnyElysia>(prefix: Prefix, run: (group: Elysia<Prefix extends '' ? BasePath : JoinPath<BasePath, Prefix>, Scope, Singleton, Definitions, {
     schema: MergeSchema<UnwrapRoute<{}, Definitions['typebox']>, Metadata['schema']>;
@@ -621,7 +621,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     macro: Metadata['macro'];
     macroFn: Metadata['macroFn'];
     parser: Metadata['parser'];
-    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
   }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
   group<const Prefix extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Prefix>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Input, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(prefix: Prefix, schema: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & MacroOptionContext<Metadata['macroFn'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, {
     derive: {};
@@ -635,7 +635,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     macro: Metadata['macro'];
     macroFn: Metadata['macroFn'];
     parser: Metadata['parser'];
-    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle, true>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
+    response: UnionResponseStatus<UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle>>, UnionResponseStatus<ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle>, UnionResponseStatus<ErrorHookStatus<ErrorHandle>, WithoutMacroCatch<MacroContext['return' & keyof MacroContext]> & {}>>>;
   }, {}, {
     derive: Ephemeral['derive'];
     schema: {};

package/dist/base.js

@@ -970,7 +970,7 @@ var Elysia = class Elysia {
 			this.fetchFn = void 0;
 			this.#routerBuilt = false;
 			require_context.clearContextCache(this);
-			try {
+			if (this["~map"]) try {
 				this.#buildRouter(false);
 			} catch (error) {
 				this.compiled = previousCompiled;
@@ -1499,7 +1499,7 @@ var Elysia = class Elysia {
 		let eager = false;
 		if (length) {
 			const programId = this["~programId"];
-			if (!require_compile_aot.Compiled.claim(programId, this["~aotFingerprint"] = require_compile_aot.createAotFingerprint())) require_compile_aot.Compiled.assertUncontested(programId);
+			require_compile_aot.Compiled.claim(programId, this["~aotFingerprint"] = require_compile_aot.createAotFingerprint(), this["~config"]?.name || "");
 			markDuplicates = require_compile_aot.Compiled.hasProgram(programId) || precompile !== true && require_universal_is_production.isProduction() && !require_compile_aot.Capture.isAotBuildEnv();
 			if (hasTypeBoxSchema) try {
 				require_type_bridge.warmTypebox();

package/dist/base.mjs

@@ -968,7 +968,7 @@ var Elysia = class Elysia {
 			this.fetchFn = void 0;
 			this.#routerBuilt = false;
 			clearContextCache(this);
-			try {
+			if (this["~map"]) try {
 				this.#buildRouter(false);
 			} catch (error) {
 				this.compiled = previousCompiled;
@@ -1497,7 +1497,7 @@ var Elysia = class Elysia {
 		let eager = false;
 		if (length) {
 			const programId = this["~programId"];
-			if (!Compiled.claim(programId, this["~aotFingerprint"] = createAotFingerprint())) Compiled.assertUncontested(programId);
+			Compiled.claim(programId, this["~aotFingerprint"] = createAotFingerprint(), this["~config"]?.name || "");
 			markDuplicates = Compiled.hasProgram(programId) || precompile !== true && isProduction() && !Capture.isAotBuildEnv();
 			if (hasTypeBoxSchema) try {
 				warmTypebox();

package/dist/compile/aot-capture.js

@@ -13,8 +13,8 @@ const require_type_validator_frozen_check = require('../type/validator/frozen-ch
 const require_type_validator_custom_error = require('../type/validator/custom-error.js');
 const require_type_validator_exact_mirror = require('../type/validator/exact-mirror.js');
 const require_type_validator_string_codec_aot = require('../type/validator/string-codec-aot.js');
-let typebox_value = require("typebox/value");
 let typebox_schema = require("typebox/schema");
+let typebox_value = require("typebox/value");
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {

package/dist/compile/aot-capture.mjs

@@ -12,8 +12,8 @@ import { buildFrozenCheck } from "../type/validator/frozen-check.mjs";
 import { captureCustomErrors } from "../type/validator/custom-error.mjs";
 import { getExactMirror } from "../type/validator/exact-mirror.mjs";
 import { captureStringCodecEntries, compileWithBuild } from "../type/validator/string-codec-aot.mjs";
-import { Default } from "typebox/value";
 import { Build, Compile } from "typebox/schema";
+import { Default } from "typebox/value";
 
 //#region src/compile/aot-capture.ts
 function emptyContainers(node, depth) {

package/dist/compile/aot.d.ts

@@ -89,8 +89,8 @@ interface HandlerManifest {
   };
 }
 interface CompiledSnapshot {
-  registered: CompiledProgramRegistration | undefined;
-  claimed: WeakRef<ProgramId> | undefined;
+  registered: Record<string, CompiledProgramRegistration | undefined> | undefined;
+  claimed: Record<string, WeakRef<ProgramId> | undefined> | undefined;
   programs: WeakMap<ProgramId, CompiledProgram>;
 }
 interface CompiledProgramRegistration {
@@ -129,9 +129,8 @@ declare function reconstruct(): ReconstructImpl;
 declare const aotDriftMessage: (method: string, path: string) => string;
 declare function warnAotDrift(method: string, path: string): void;
 declare abstract class Compiled {
-  static register(manifest: CompiledProgramRegistration): void;
-  static claim(id: ProgramId, fingerprint: AotFingerprint): boolean;
-  static assertUncontested(id: ProgramId): void;
+  static register(manifest: CompiledProgramRegistration, key?: string): void;
+  static claim(id: ProgramId, fingerprint: AotFingerprint, key?: string): boolean;
   static set reconstruct(impl: ReconstructImpl | undefined);
   static getHandler(id: ProgramId | undefined, method: string, path: string): FrozenHandler | undefined;
   static hasProgram(id: ProgramId | undefined): boolean;

package/dist/compile/aot.js

@@ -51,26 +51,25 @@ let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
 var Compiled = class {
-	static register(manifest) {
-		registered = manifest;
-		claimed = void 0;
+	static register(manifest, key = "") {
+		(registered ??= require_utils.nullObject())[key] = manifest;
+		claimed ??= require_utils.nullObject();
 	}
-	static claim(id, fingerprint) {
-		if (!registered || claimed) return false;
-		const manifest = registered;
+	static claim(id, fingerprint, key = "") {
+		const manifest = registered?.[key];
+		if (!manifest) {
+			if (claimed && claimed[key]?.deref() !== id && !isAotBuildEnv()) throw new Error(`[elysia-aot] App "${key}" has no AOT manifest. Name and export it, .mount() ones too`);
+			return false;
+		}
 		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
-		claimed = new WeakRef(id);
-		registered = void 0;
+		claimed[key] = new WeakRef(id);
+		registered[key] = void 0;
 		programs.set(id, {
 			...manifest,
 			builtGroups: /* @__PURE__ */ new Set()
 		});
 		return true;
 	}
-	static assertUncontested(id) {
-		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
-		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
-	}
 	static set reconstruct(impl) {
 		reconstructImpl = impl;
 	}

package/dist/compile/aot.mjs

@@ -51,26 +51,25 @@ let claimed;
 let programs = /* @__PURE__ */ new WeakMap();
 const programFor = (id) => id ? programs.get(id) : void 0;
 var Compiled = class {
-	static register(manifest) {
-		registered = manifest;
-		claimed = void 0;
+	static register(manifest, key = "") {
+		(registered ??= nullObject())[key] = manifest;
+		claimed ??= nullObject();
 	}
-	static claim(id, fingerprint) {
-		if (!registered || claimed) return false;
-		const manifest = registered;
+	static claim(id, fingerprint, key = "") {
+		const manifest = registered?.[key];
+		if (!manifest) {
+			if (claimed && claimed[key]?.deref() !== id && !isAotBuildEnv()) throw new Error(`[elysia-aot] App "${key}" has no AOT manifest. Name and export it, .mount() ones too`);
+			return false;
+		}
 		if (manifest.fingerprint.abi !== fingerprint.abi) throw new Error(`[elysia-aot] Mismatch fingerprint`);
-		claimed = new WeakRef(id);
-		registered = void 0;
+		claimed[key] = new WeakRef(id);
+		registered[key] = void 0;
 		programs.set(id, {
 			...manifest,
 			builtGroups: /* @__PURE__ */ new Set()
 		});
 		return true;
 	}
-	static assertUncontested(id) {
-		if (claimed === void 0 || claimed.deref() === id || isAotBuildEnv()) return;
-		throw new Error("[elysia-aot] A second Elysia app built a router in this process. An AOT build seals one app per process.");
-	}
 	static set reconstruct(impl) {
 		reconstructImpl = impl;
 	}

package/dist/compile/handler/jit.js

@@ -463,7 +463,7 @@ function compileHandlerJit(options, tailPass) {
 					code += require_compile_handler_utils.mapChainHook(hook.afterHandle, "af", asyncMode, buildReport("afterHandle"), abortChainGuard(), arm);
 				}
 				code += endTrace("afterHandle");
-				if (hasAfterHandle) code += abortCheck();
+				if (hasAfterHandle) code += abortCheck() + plain(rethrow("_r"));
 			}
 			if (hasMapResponse || hasTrace) {
 				const mrLen = hook?.mapResponse?.length ?? 0;
@@ -531,15 +531,17 @@ function compileHandlerJit(options, tailPass) {
 				asyncMode.r = false;
 				asyncMode.e = true;
 			}
+			const declined = endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule);
 			body += errorHead + `let _r${hasMapResponse ? ",tmp" : ""}\n` + require_compile_handler_utils.mapError(hook.error, [
 				map,
 				link,
 				responseMap,
-				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule),
+				(hasMapResponse ? `c.responseValue=_r\n` + require_compile_handler_utils.mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + declined,
 				signPrefix,
 				asyncMode,
-				arm
-			], abortChainGuard(), require_compile_handler_utils.asyncTail(asyncMode)) + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule) + `return _efb(e,c)\n`;
+				arm,
+				declined
+			], abortChainGuard(), require_compile_handler_utils.asyncTail(asyncMode)) + declined + `return _efb(e,c)\n`;
 		} else body += endTrace("error") + freThenSchedule("e");
 		const hookThrew = `catch(_ee){${freThenSchedule("_ee").trimEnd()}}}\n`;
 		const syncFirst = typeof asyncMode === "object" && !asyncMode.async;

package/dist/compile/handler/jit.mjs

@@ -463,7 +463,7 @@ function compileHandlerJit(options, tailPass) {
 					code += mapChainHook(hook.afterHandle, "af", asyncMode, buildReport("afterHandle"), abortChainGuard(), arm);
 				}
 				code += endTrace("afterHandle");
-				if (hasAfterHandle) code += abortCheck();
+				if (hasAfterHandle) code += abortCheck() + plain(rethrow("_r"));
 			}
 			if (hasMapResponse || hasTrace) {
 				const mrLen = hook?.mapResponse?.length ?? 0;
@@ -531,15 +531,17 @@ function compileHandlerJit(options, tailPass) {
 				asyncMode.r = false;
 				asyncMode.e = true;
 			}
+			const declined = endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule);
 			body += errorHead + `let _r${hasMapResponse ? ",tmp" : ""}\n` + mapError(hook.error, [
 				map,
 				link,
 				responseMap,
-				(hasMapResponse ? `c.responseValue=_r\n` + mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule),
+				(hasMapResponse ? `c.responseValue=_r\n` + mapChainHook(hook.mapResponse, "mr", asyncMode, void 0, abortChainGuard(), arm) : "") + declined,
 				signPrefix,
 				asyncMode,
-				arm
-			], abortChainGuard(), asyncTail(asyncMode)) + endTrace("error") + (hasDeriveDispose ? schedule + abortCatch : abortCatch + schedule) + `return _efb(e,c)\n`;
+				arm,
+				declined
+			], abortChainGuard(), asyncTail(asyncMode)) + declined + `return _efb(e,c)\n`;
 		} else body += endTrace("error") + freThenSchedule("e");
 		const hookThrew = `catch(_ee){${freThenSchedule("_ee").trimEnd()}}}\n`;
 		const syncFirst = typeof asyncMode === "object" && !asyncMode.async;

package/dist/compile/handler/utils.d.ts

@@ -39,7 +39,7 @@ declare function runBeforeHandlePrefix(prefix: CompactBeforeHandlePrefix, contex
 declare function runBeforeHandlePrefixAsync(prefix: CompactBeforeHandlePrefix, context: BeforeHandleContext, abort?: 1): Promise<any>;
 declare function mapChainHook(_hooks: Function | Function[], prefix: string, mode: AsyncMode, report?: TraceReporter, abortGuard?: string, arm?: string): string;
 declare const mapAfterResponse: (event: MaybeArray<AfterResponseHandler<any, any, undefined, "local">>, rest?: [report?: TraceReporter | undefined] | undefined, abortGuard?: string, tail?: TailMode) => string;
-declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, mode: AsyncMode, arm?: string | undefined] | undefined, abortGuard?: string, tail?: TailMode) => string;
+declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, mode: AsyncMode, arm: string | undefined, declined: string] | undefined, abortGuard?: string, tail?: TailMode) => string;
 interface QueryWalkState {
   array: Record<string, 1> | undefined;
   object: Record<string, 1> | undefined;

package/dist/compile/handler/utils.js

@@ -297,11 +297,11 @@ const mapAfterResponse = /* @__PURE__ */ map((i, fn, [report]) => {
 	const call = require_compile_utils.isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(typeof _ar?.then==='function')await _ar\n`;
 	return `try{${t.begin}${call}${t.end()}}catch(_e){${t.end("_e")}console.error(_e)}\n`;
 });
-const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm]) => {
+const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm, declined]) => {
 	link(mapResponse, "rm");
 	link(require_handler_error.adoptErrorType, "aet");
 	link(require_error.ElysiaStatus, "es");
-	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + "if(_r!==undefined){\nif(_r instanceof es||_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
+	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + `if(_r!==undefined){\nif(_r instanceof Error){c.set.status=_r.status||500\n${declined}return _efb(_r,c)}\nif(_r instanceof es||_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n` + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
 });
 function map(map) {
 	return function(event, rest, abortGuard, tail) {

package/dist/compile/handler/utils.mjs

@@ -297,11 +297,11 @@ const mapAfterResponse = /* @__PURE__ */ map((i, fn, [report]) => {
 	const call = isAsyncFunction(fn) ? `await ar${at(i)}(c)\n` : `let _ar=ar${at(i)}(c)\nif(typeof _ar?.then==='function')await _ar\n`;
 	return `try{${t.begin}${call}${t.end()}}catch(_e){${t.end("_e")}console.error(_e)}\n`;
 });
-const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm]) => {
+const mapError = /* @__PURE__ */ map((i, fn, [map, link, mapResponse, schedule, sign, mode, arm, declined]) => {
 	link(mapResponse, "rm");
 	link(adoptErrorType, "aet");
 	link(ElysiaStatus, "es");
-	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + "if(_r!==undefined){\nif(_r instanceof es||_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n" + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
+	return awaitSite(`er${at(i)}(c)`, fn, mode, "_r", arm) + `if(_r!==undefined){\nif(_r instanceof Error){c.set.status=_r.status||500\n${declined}return _efb(_r,c)}\nif(_r instanceof es||_r instanceof Response)c.set.status=_r.status\nelse if(c.set.status===undefined||c.set.status===200)c.set.status=500\n` + schedule + sign + `return _em(c,${map}(aet(_r,e),c.set,c.request,true))\n}\n`;
 });
 function map(map) {
 	return function(event, rest, abortGuard, tail) {

package/dist/error.d.ts

@@ -232,55 +232,36 @@ type TaggedHTTPError<Type extends string, Annotation = {}> = {
 /**
  * Self-describing HTTP error
  *
- * Annotate `status`, `headers` and `value` on the subclass and Elysia maps
- * the instance to a response on its own, no `.onError(Class, handler)` needed
+ * Set `status`, `headers`, `detail`, `extension` and `value` to map to response
  *
- * Everything an owned `HTTPError` serves is an RFC 9457 problem document:
- * `type` is the problem type carried on the wire, and the body (or the error
- * message, when there is none) becomes `detail`, an object nested verbatim
- * and never merged into the envelope. Given neither, the document has no
- * `detail`: `new OutOfCredit()` serves none, `new OutOfCredit('')` an empty one
+ * Send RFC 9457 problem document by default that can be overridden by `value()`
  *
- * - `detail()` - the common case. Whatever it returns becomes the `detail`
- *   member of the problem document, verbatim, objects included. The envelope
- *   still carries `type`, `status` and an auto-filled `title`
- * - `value()` - the escape hatch. Whatever it returns replaces the *whole*
- *   response: no envelope, no `application/problem+json`. The annotated
- *   `status` and `headers` still apply, only the content is yours
+ * - `detail` - add `detail` field to the problem document
+ * - `extension()` - add extension members to the problem document
+ * - `value()` - override the whole response, return `problem()` to keep the shape
  *
- * `value` wins over `detail`, `detail` over the error message. A knob
- * returning `undefined` falls through to the next one.
+ * `value` wins over `detail`, `detail` over an `extension()` string `detail`,
+ * that over message. A `value` returning `undefined` falls
+ * through to the next one. A response that depends on the request belongs in
+ * `.onError(Class, handler)`
  *
  * @example
  * ```ts
- * class OutOfCredit extends HTTPError<'OUT_OF_CREDIT'> {
- * 	type = 'OUT_OF_CREDIT' as const
- * 	override readonly status = 402
- *
- * 	detail() {
- * 		return { balance: 0, currency: 'usd' }
- * 	}
+ * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT') {
+ * 	   readonly status = 402
+ * 	   readonly detail = 'Top up to continue'
  * }
- * // → { type: 'OUT_OF_CREDIT', title: 'Payment Required', status: 402,
- * //     detail: { balance: 0, currency: 'usd' } }
  *
- * class Overdrawn extends HTTPError<'OVERDRAWN'> {
- * 	type = 'OVERDRAWN' as const
- * 	override readonly status = 402
+ * class Overdrawn extends Error implements HTTPError {
+ *     readonly type = 'OVERDRAWN'
+ * 	   readonly status = 402
  *
- * 	async detail() {
- * 		return await describeBalance()
- * 	}
- * }
- *
- * class Legacy extends HTTPError<'LEGACY'> {
- * 	type = 'LEGACY' as const
- * 	override readonly status = 402
- *
- * 	// full control, served as-is
- * 	value() {
- * 		return { code: 'OUT_OF_CREDIT', ok: false }
- * 	}
+ *     value() {
+ *         return problem(402, {
+ * 	           type: 'OVERDRAWN',
+ * 	            detail: await describeBalance()
+ * 	       })
+ *     }
  * }
  * ```
  *
@@ -329,18 +310,44 @@ declare abstract class HTTPError<const in out T extends string = string> extends
   /** Headers merged into `set.headers` when the error is served */
   readonly headers?: Record<string, string>;
   /**
-   * Return a value to serve as the whole response
+   * Return a value to serve as the whole response, may be `async`
    *
    * Supports `status()`/`problem()` for status-based Eden response
    */
   value?(): MaybePromise<unknown>;
   /**
-   * Return the `detail` member of the RFC 9457 problem document,
-   * similar to `problem()`
+   * `detail` member of the RFC 9457 problem document, served in place of
+   * the error message
    *
-   * Use `value()` to override the entire response
+   * Use `value()` for anything computed asynchronously
    */
-  detail?(): MaybePromise<unknown>;
+  readonly detail?: string;
+  /**
+   * Return RFC 9457 extension members added to the problem document,
+   * synchronously
+   *
+   * `type`, `code` and `status` stay the error's own. A string `detail` is
+   * served when the error has no `detail` of its own, in place of the
+   * message. `title` and `instance` may be overridden. Not served when
+   * `value()` answers
+   *
+   * Only a plain object's own data members are served, which types can't
+   * check: return an object literal, not a class instance
+   *
+   * @example
+   * ```ts
+   * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT', 402) {
+   *     constructor(readonly balance: number) {
+   *         super()
+   *     }
+   *
+   *     extension() {
+   *         return { balance: this.balance, accounts: ['/account/12345'] }
+   *     }
+   * }
+   * ```
+   */
+  extension?(): Record<string, unknown>;
   /**
    * Create a concrete `HTTPError` subclass carrying `code`, mirrored into
    * `type` unless {@link HTTPError.typeBase} is set
@@ -363,16 +370,14 @@ declare abstract class HTTPError<const in out T extends string = string> extends
    * Create a concrete `HTTPError` subclass carrying `code`, annotated with
    * `status` as a number or a status name
    *
-   * Annotate what is served with `detail()` (problem `detail` member) or
-   * `value()` (whole-response override), either of which may be `async`
+   * Annotate what is served with `detail` (problem `detail` member) or
+   * `value()` (whole-response override, may be `async`)
    *
    * @example
    * ```ts
    * class OutOfCredit extends HTTPError.id('OUT_OF_CREDIT', 402) {}
    * class Denied extends HTTPError.id('DENIED', 'Payment Required') {
-   *     async detail() {
-   *         return await describeBalance()
-   *     }
+   *     override readonly detail = 'Top up to continue'
    * }
    * ```
    */

package/dist/handler/error.d.ts

@@ -21,17 +21,16 @@ declare const resolveStatus: (status: unknown) => unknown;
  * Body served by an error that carries a status but no usable body:
  * its declared `response`, otherwise its message, or `mask` in its place
  * on a production 5xx
- *
- * As a problem `detail`, an error given no message has none (`undefined`):
- * `Error` only defines an own `message` for one passed, `''` included
  */
 declare function statusFallbackBody(error: any, status: unknown, mask?: string, asDetail?: boolean): any;
 /**
- * Read one annotation knob, a method (may be `async`) or a plain value.
- * A method may have side effects, so only an error claiming a problem type
- * gets it invoked; a plain value is read from any error
+ * RFC 9457 extension members of an error claiming a problem type. Sync
+ * only: anything but a plain object, a Promise included, adds nothing.
+ * `type`, `code` and `status` stay the error's own, `detail` only when a
+ * string
  */
-declare const readAnnotation: (self: any, key: "value" | "detail", claimsProblem: boolean) => any;
+declare function extensionOf(self: any): any;
+declare function readAnnotation(self: any, key: 'value' | 'detail', claimsProblem: boolean): any;
 declare function createErrorHandler(onErrors: AppHook['error'] | undefined, mapResponse: (response: unknown, set: Context['set'], ...any: unknown[]) => unknown, allowUnsafe?: boolean): (context: Context, error: Error, sign?: ((set: Context["set"]) => unknown) | undefined) => unknown;
 //#endregion
-export { adoptErrorType, claimsProblemType, createErrorHandler, fallbackResponse, readAnnotation, resolveStatus, statusFallbackBody };
+export { adoptErrorType, claimsProblemType, createErrorHandler, extensionOf, fallbackResponse, readAnnotation, resolveStatus, statusFallbackBody };