elysia 2.0.0-beta.21 → 2.0.0-beta.22

package/dist/types.d.ts

@@ -1,16 +1,16 @@
-import { CookieOptions } from "./cookie/types.js";
-import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { StatusMap, StatusMapBack } from "./constants.js";
 import { ElysiaError, ElysiaStatus, ProblemResponseBody, ValidationErrorResponse } from "./error.js";
 import { ChainNode } from "./utils.js";
 import { Serve } from "./universal/server.js";
+import { CookieOptions } from "./cookie/types.js";
 import { Context, ErrorContext, LifecycleContext, PreContext } from "./context.js";
 import { TraceHandler } from "./trace.js";
 import { ElysiaFile } from "./universal/file.js";
+import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { AnyElysia, Elysia } from "./base.js";
 import { ElysiaAdapter } from "./adapter/index.js";
-import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TRef, TSchema } from "typebox";
 import { OpenAPIV3 } from "openapi-types";
+import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TRef, TSchema } from "typebox";
 
 //#region src/types.d.ts
 interface ElysiaConfig<in out Prefix extends string | undefined, in out Scope extends EventScope, in out Adapter extends ElysiaAdapter = ElysiaAdapter> {
@@ -235,43 +235,43 @@ type LocalHook<Input extends BaseMacro, Schema extends RouteSchemaWithResolvedMa
    * - 'arraybuffer': parse body as readable stream
    */
   parse?: MaybeArray<BodyHandler<Schema, Singleton & {
-    derive: Schema['resolve'];
+    derive: Schema['derive'];
   }> | ContentType | Parser>;
   /**
    * Transform context's value
    */
   transform?: MaybeArray<TransformHandler<Schema, Singleton & {
-    derive: Schema['resolve'];
+    derive: Schema['derive'];
   }>>;
   /**
    * Execute before main handler
    */
   beforeHandle?: MaybeArray<OptionalHandler<Schema, Singleton & {
-    derive: Schema['resolve'];
+    derive: Schema['derive'];
   }>>;
   /**
    * Execute after main handler
    */
   afterHandle?: MaybeArray<AfterHandler<Schema, Singleton & {
-    derive: Schema['resolve'];
+    derive: Schema['derive'];
   }>>;
   /**
    * Execute after main handler
    */
   mapResponse?: MaybeArray<MapResponse<Schema, Singleton & {
-    derive: Schema['resolve'];
+    derive: Schema['derive'];
   }>>;
   /**
    * Execute after response is sent
    */
   afterResponse?: MaybeArray<AfterResponseHandler<Schema, Singleton & {
-    derive: Schema['resolve'];
+    derive: Schema['derive'];
   }>>;
   /**
    * Catch error
    */
   error?: MaybeArray<ErrorHandler<Errors, Schema, Singleton & {
-    derive: Schema['resolve'];
+    derive: Schema['derive'];
   }>>;
   tags?: DocumentDecoration['tags'];
 } & (Input extends any ? Input : Prettify<Input>);
@@ -433,13 +433,13 @@ type InlineHandlerResponse<Route extends RouteSchema['response']> = { [Status in
 type InlineHandler<Route extends RouteSchema = {}, Singleton extends SingletonBase = DefaultSingleton, MacroContext extends {
   response: PossibleResponse;
   return: PossibleResponse;
-  resolve: Record<string, unknown>;
+  derive: Record<string, unknown>;
 } = {
   response: {};
   return: {};
-  resolve: {};
+  derive: {};
 }> = InlineHandlerNonMacro<Route & MacroContext, Singleton & {
-  derive: MacroContext['resolve'];
+  derive: MacroContext['derive'];
 }>;
 type InlineHandlerNonMacro<Route extends RouteSchema = {}, Singleton extends SingletonBase = DefaultSingleton> = (Route['response'] extends infer ResponseSchema ? {} extends ResponseSchema ? MaybePromise<InlineResponse> : MaybePromise<ResponseSchema[keyof ResponseSchema] | InlineHandlerResponse<ResponseSchema>> : never) | ((context: Context<Route, Singleton>) => MaybePromise<Response> | MaybePromise<{} extends Route['response'] ? unknown : (Route['response'] extends {
   200: any;
@@ -460,9 +460,9 @@ type ErrorHandler<T extends ErrorDefinition[] = [], in out Route extends RouteSc
 }> & {
   error: T[number]['error'] | unknown;
 }) => unknown;
-type MergeSchema<A extends RouteSchema, B extends RouteSchema, Path extends string = '', AParamsPathDerived extends boolean = false> = {} extends A ? Path extends PathParameterLike ? Omit<B, 'params'> & {
+type MergeSchema<A extends RouteSchema, B extends RouteSchema, Path extends string = '', AParamsPathDerived extends boolean = false> = {} extends A ? Path extends PathParameterLike ? IsNever<keyof B['params']> extends true ? Omit<B, 'params'> & {
   params: ResolvePath<Path>;
-} : B : {} extends B ? Path extends PathParameterLike ? Omit<A, 'params'> & {
+} : B : B : {} extends B ? Path extends PathParameterLike ? Omit<A, 'params'> & {
   params: ResolvePath<Path>;
 } : A : {
   body: undefined extends A['body'] ? B['body'] : A['body'];
@@ -499,6 +499,11 @@ type MacroProperty<Macro extends BaseMacro = {}, TypedRoute extends RouteSchema
   mapResponse?: MaybeArray<MapResponse<TypedRoute, Singleton>>;
   afterResponse?: MaybeArray<AfterResponseHandler<TypedRoute, Singleton>>;
   derive?: MaybeArray<ResolveHandler<TypedRoute, Singleton>>;
+  /**
+   * Wrap the route handler. The wrapper's return is the handler value.
+   * A macro listed later in the route options wraps outside an earlier one
+   */
+  handler?: (handler: (context: Context<TypedRoute, Singleton>) => unknown) => (context: Context<TypedRoute, Singleton>) => unknown;
   detail?: DocumentDecoration;
   /**
    * Type-level route metadata surfaced on the route's Eden type
@@ -509,12 +514,16 @@ type MacroProperty<Macro extends BaseMacro = {}, TypedRoute extends RouteSchema
   /**
    * Phantom {@link MacroTypeLambda} computing per call site context from
    * the route's literal hook value. Reserved key like `seed`/`meta`/
-   * `introspect` — carry it on the declared return type only; a runtime
-   * value is tolerated and stripped
+   * `introspect` — set it with `macroType<Lambda>()`; stripped at runtime
    */
   $type?: MacroTypeLambda;
   /**
-   * Introspect hook option for documentation generation or analysis
+   * Inspect or rewrite the hooks a route compiles with. Runs once per
+   * route at compile time, after every macro on the route has expanded,
+   * on the route's final hooks: its own, the ones every macro added and
+   * the ones it inherits from hooks registered before it. A WebSocket
+   * route hands over its own hooks only. Applied by
+   * a guard, it sees the guard's hooks once instead of each route's
    *
    * @param option
    */
@@ -698,11 +707,11 @@ interface UnwrapRoute<in out Schema extends InputSchema<any>, in out Definitions
   } : Schema['response'] extends { [status in number]: AnySchema | string } ? { [k in keyof Schema['response']]: UnwrapResponseSchema<Schema['response'][k], Definitions> extends infer A ? A extends File ? File | ElysiaFile : A : unknown } : unknown | void;
 }
 type UnwrapModels<T extends Record<string, unknown>, Iteration extends number[] = []> = Iteration['length'] extends 8 ? T : { [K in keyof T]: T[K] extends AnySchema ? UnwrapSchema<T[K]> : T[K] extends Record<string, unknown> ? UnwrapModels<T[K], [...Iteration, 0]> : T[K] };
-type MacroToProperty<in out T> = Prettify<{ [K in keyof T]: T[K] extends Function ? T[K] extends ((a: infer Params) => any) ? Params : boolean : boolean }>;
+type MacroToProperty<in out T> = Prettify<{ [K in keyof T]: T[K] extends Function ? T[K] extends ((a: infer Params) => any) ? MacroOptionLambda<T[K]> extends never ? Params : unknown : boolean : boolean }>;
 interface RouteSchemaWithResolvedMacro extends RouteSchema {
   response: PossibleResponse;
   return: PossibleResponse;
-  resolve: Record<string, unknown>;
+  derive: Record<string, unknown>;
 }
 type IntersectIfObject<A, B> = unknown extends A ? B : A extends Record<any, any> ? B extends Record<any, any> ? A & B : A : B extends Record<any, any> ? B : A;
 interface IntersectIfObjectSchema<A extends RouteSchema, B extends RouteSchema> {
@@ -734,7 +743,7 @@ type FunctionArrayReturnTypeNonNullable<T> = any[] extends T ? never : T extends
 type _FunctionArrayReturnTypeNonNullable<T, Carry = undefined> = T extends [infer Fn, ...infer Rest] ? _FunctionArrayReturnTypeNonNullable<Rest, NonNullable<Awaited<ReturnType<Fn>>> extends infer A ? IsNever<A> extends true ? Carry : A | Carry : Carry> : Carry;
 type AnyElysiaStatus = ElysiaStatus<any, any, any>;
 type ExcludeElysiaResponse<T> = Exclude<Awaited<T>, AnyElysiaStatus> extends infer A ? IsNever<A & {}> extends true ? {} : undefined extends A ? Partial<A & {}> : A & {} : {};
-type ExtractResolveFromMacro<A> = IsNever<A> extends true ? {} : A extends AnyElysiaStatus ? A : Exclude<A, AnyElysiaStatus> extends infer A ? IsAny<A> extends true ? {} : A : {};
+type ExtractDeriveFromMacro<A> = IsNever<A> extends true ? {} : A extends AnyElysiaStatus ? A : Exclude<A, AnyElysiaStatus> extends infer A ? IsAny<A> extends true ? {} : A : {};
 type ExtractOnlyResponseFromMacro<A> = IsNever<A> extends true ? {} : Extract<A, AnyElysiaStatus> extends infer A ? IsNever<A> extends true ? {} : {
   return: MergeResponseStatus<A>;
 } : {};
@@ -748,14 +757,44 @@ type ExtractAllResponseFromMacro<A> = IsNever<A> extends true ? {} : {
 };
 type FlattenMacroResponse<T> = T extends object ? '_' extends keyof T ? UnionResponseStatus<Omit<T, '_'>, FlattenMacroResponse<MergeStatusUnion<T['_']>>> : T : T;
 /**
- * Type-level lambda applied to a macro's per call site hook value. Extend
- * this interface, compute `output` from `this['input']`, and carry it on
- * the macro's declared return type as a phantom `$type` member — the
- * computed `output` joins the route's context
+ * Type-level lambda applied to a macro's per call site hook value
+ *
+ * Return type as `$type: macroType<Lambda>()`
+ * `output` will be added to route's context
+ *
+ * A function-form macro may also compute `option` from `this['context']`.
+ * The hook value is then typed as `option` per route, guard, group and ws,
+ * replacing the macro's declared parameter
+ *
+ * `this` is not allowed in a nested type literal
+ *
+ * ```ts
+ * interface LiveOption<Context> { topic?: (ctx: Context) => string }
+ * interface Live extends MacroTypeLambda { option: LiveOption<this['context']> }
+ *
+ * new Elysia().macro({
+ *     live: (option: LiveOption<Context>) => ({
+ *         $type: macroType<Live>(),
+ *         beforeHandle() {}
+ *     })
+ * })
+ * ```
  */
 interface MacroTypeLambda {
   input: unknown;
+  /**
+   * The call-site schema and accumulated singleton context, excluding output
+   * from macros selected at the same call site
+   */
+  context: unknown;
 }
+type MacroOptionLambda<Fn> = Fn extends ((option: any) => infer Def) ? NonNullable<Def> extends {
+  $type?: infer Lambda extends MacroTypeLambda;
+} ? 'option' extends keyof Lambda ? Lambda : never : never : never;
+type MacroOptionContext<MacroFn, Route extends RouteSchema, Singleton extends SingletonBase> = { [K in keyof MacroFn]?: MacroOptionLambda<MacroFn[K]> extends never ? unknown : ElaborateOption<(MacroOptionLambda<MacroFn[K]> & {
+  context: Context<Route, Singleton>;
+})['option']> };
+type ElaborateOption<Option, Keys extends PropertyKey = keyof Extract<Option, object>> = unknown extends Option ? Option : Option extends boolean ? Option & { [K in Exclude<Keys, keyof Option> as {} extends Record<K, 0> ? never : K]?: never } : Option;
 type MacroLambdaContext<Value, HookValue> = NonNullable<Value> extends {
   $type?: infer Lambda extends MacroTypeLambda;
 } ? Lambda & {
@@ -763,17 +802,21 @@ type MacroLambdaContext<Value, HookValue> = NonNullable<Value> extends {
 } extends {
   output: infer Output;
 } ? Output : {} : {};
-type UnionMacroContext<A> = UnionToIntersect<{ [K in Exclude<keyof A, 'return'>]: A[K] }> & {
+type UnionMacroContext<A> = UnionToIntersect<A extends unknown ? { [K in Exclude<keyof A, 'return'>]: A[K] } : never> & {
   return: {
     _: A['return'];
   };
 };
-type MacroToContext<in out MacroFn extends Macro = {}, in out SelectedMacro extends BaseMacro = {}, in out Definitions extends DefinitionBase['typebox'] = {}, in out R extends 1[] = []> = Prettify<InnerMacroToContext<MacroFn, Pick<SelectedMacro, Extract<keyof MacroFn, keyof SelectedMacro>>, Definitions, R> extends infer A ? { [K in Exclude<keyof A, 'return'>]: UnionToIntersect<A[K]> } & Prettify<{
+type MacroToContext<in out MacroFn extends Macro = {}, in out SelectedMacro extends BaseMacro = {}, in out Definitions extends DefinitionBase['typebox'] = {}, in out R extends 1[] = []> = Prettify<InnerMacroToContext<MacroFn, Pick<SelectedMacro, Extract<keyof MacroFn, keyof SelectedMacro>>, Definitions, R> extends infer A ? { [K in Exclude<keyof A, 'return'>]: K extends 'derive' ? UnionToIntersect<A[K]> : K extends 'meta' ? (A[K] & {
+  value: unknown;
+})['value'] : A[K] } & Prettify<{
   return: FlattenMacroResponse<A['return']>;
 }> : {}>;
 type InnerMacroToContext<MacroFn extends Macro = {}, SelectedMacro extends BaseMacro = {}, Definitions extends DefinitionBase['typebox'] = {}, R extends 1[] = []> = {} extends SelectedMacro ? {} : R['length'] extends 15 ? {} : UnionMacroContext<{ [key in keyof SelectedMacro]: ReturnTypeIfPossible<MacroFn[key], SelectedMacro[key]> extends infer Value ? NonNullable<Value> extends infer Def ? {
-  meta: 'meta' extends keyof Def ? Def['meta'] : never;
-  resolve: ExtractResolveFromMacro<Extract<Exclude<FunctionArrayReturnType<Def['derive']>, AnyElysiaStatus>, Record<any, unknown>>> & MacroLambdaContext<Value, SelectedMacro[key]>;
+  meta: 'meta' extends keyof Def ? {
+    value: Def['meta'];
+  } : unknown;
+  derive: ExtractDeriveFromMacro<Extract<Exclude<FunctionArrayReturnType<Def['derive']>, AnyElysiaStatus>, Record<any, unknown>>> & MacroLambdaContext<Value, SelectedMacro[key]>;
 } & UnwrapMacroSchema<Def, Definitions> & ExtractAllResponseFromMacro<FunctionArrayReturnTypeNonNullable<Def['beforeHandle']>> & ExtractAllResponseFromMacro<FunctionArrayReturnTypeNonNullable<Def['afterHandle']>> & ExtractAllResponseFromMacro<FunctionArrayReturnType<Def['error']>> & ExtractOnlyResponseFromMacro<FunctionArrayReturnTypeNonNullable<Def['derive']>> & InnerMacroToContext<MacroFn, Pick<Def, Extract<keyof MacroFn, keyof Def>>, Definitions, [...R, 1]> : {} : {} }[keyof SelectedMacro]>;
 type UnwrapMacroSchema<T extends Partial<InputSchema<any>>, Definitions extends DefinitionBase['typebox'] = {}> = UnwrapRoute<{
   body: 'body' extends keyof T ? T['body'] : undefined;
@@ -804,22 +847,21 @@ type RefDefSchema<D> = {
   response: undefined;
 };
 /**
- * Captures the verbatim `.macro()` definition record into a separate first-pass
- * generic. This lets each definition's enabled
- * sibling flags (`{ auth: true }`) be read back without reusing the contextually
- * typed `NewMacro`, which would form the record -> handler-typing inference
- * cycle documented on {@link ObjectMacroDefs}.
+ * Captures the verbatim `.macro()` definition record in a first-pass generic,
+ * so each definition's sibling flags (`{ auth: true }`) are read back without
+ * reusing the contextually typed `NewMacro`, which would form the inference
+ * cycle documented on {@link ObjectMacroDefs}
  */
 type MacroRefChannel<Refs> = { [K in keyof Refs]: MaybeValueOrVoidFunction<{ [M in keyof Refs[K]]?: Refs[K][M] } & Record<string, unknown>> };
 /**
- * `resolve` (derive) context contributed by the sibling macros a definition
+ * `derive` context contributed by the sibling macros a definition
  * enables via `{ name: true }`. Extracted through `infer` because
- * {@link MacroToContext} is a mapped type whose `resolve` key cannot be indexed
- * with a plain `['resolve']` on the generic form.
+ * {@link MacroToContext} is a mapped type whose `derive` key cannot be indexed
+ * with a plain `['derive']` on the generic form.
  */
-type MacroRefResolve<MacroFn, SelectedMacro, Definitions> = MacroToContext<MacroFn, SelectedMacro, Definitions> extends {
-  resolve: infer Resolve;
-} ? Resolve : {};
+type MacroRefDerive<MacroFn, SelectedMacro, Definitions> = MacroToContext<MacroFn, SelectedMacro, Definitions> extends {
+  derive: infer Derive;
+} ? Derive : {};
 /**
  * Parameter type of the object-form `.macro({ name: definition })`
  *
@@ -833,7 +875,7 @@ type MacroRefResolve<MacroFn, SelectedMacro, Definitions> = MacroToContext<Macro
  * `Metadata['macroFn']` for the consuming route)
  */
 type ObjectMacroDefs<N, AmbientSchema extends RouteSchema, ScopedSchemas extends RouteSchema, Singleton extends SingletonBase, Definitions extends DefinitionBase, MacroNames extends BaseMacro, MacroFn = {}, Refs = {}> = MacroRefChannel<Refs> & { [K in keyof N]: MaybeValueOrVoidFunction<MacroProperty<MacroNames & InputSchema<keyof Definitions['typebox'] & string>, IntersectIfObjectSchema<MergeSchema<UnwrapMacroSchema<RefDefSchema<K extends keyof Refs ? Refs[K] : {}>, Definitions['typebox']>, AmbientSchema>, ScopedSchemas>, Singleton & {
-  derive: Singleton['derive'] & MacroRefResolve<MacroFn, K extends keyof Refs ? Refs[K] : {}, Definitions['typebox']>;
+  derive: Singleton['derive'] & MacroRefDerive<MacroFn, K extends keyof Refs ? Refs[K] : {}, Definitions['typebox']>;
 }, Definitions['error']>> } & { [K in keyof N]: N[K] extends ((...a: any[]) => any) ? unknown : string extends keyof N[K] ? unknown : { [P in Exclude<keyof N[K], MacroPropertyKey | InputSchemaKey | keyof MacroFn | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
 type CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `/${infer Rest}` ? _CreateEden<Rest, Property> : Path extends '' | '/' ? Property : _CreateEden<Path, Property>;
 type CreateRouteEden<BasePath extends string, Path extends string, Property extends Record<string, unknown>> = string extends Path ? {} : CreateEden<JoinPath<BasePath, Path>, Property>;
@@ -842,13 +884,8 @@ type _CreateEden<Path extends string, Property extends Record<string, unknown> =
  * Value an annotation knob resolves to, `never` when it annotates nothing.
  *
  * Both knobs are canonically methods, so what they *return* is the
- * annotation. A value or getter reads as the value itself. An `unknown`
- * declaration resolves to `unknown` — the runtime serves whatever a knob
- * returns and can't see its declared type — and `undefined` is excluded, it
- * falls through to the next tier rather than being served.
- *
- * The base declares both knobs optional, so a subclass that doesn't override
- * them never reaches here
+ * annotation. A value or getter reads as the value itself. `unknown` stays
+ * `unknown`, and `undefined` is excluded: it falls through to the next tier
  */
 type ResolveAnnotation<V> = (V extends ((...args: any) => infer Returned) ? Returned : V) extends infer Value ? Exclude<Awaited<Value>, undefined> extends infer Resolved ? IsNever<Resolved> extends true ? never : Resolved : never : never;
 /** Whether a knob may resolve `undefined` and fall through to the next tier */
@@ -979,16 +1016,10 @@ type ComposeElysiaResponse<Schema extends RouteSchema, Handle, Possibility exten
 })>>;
 type ExtractErrorFromHandle<in out Handle> = { [ErrorResponse in Extract<Handle, AnyElysiaStatus> as ErrorResponse extends AnyElysiaStatus ? ErrorResponse['status'] : never]: Prettify<ErrorResponse['response']> };
 /**
- * Status used when an error handler returns a plain value (or falls through):
- * the error's declared literal `status`, otherwise 500
+ * Status used when an error handler returns a plain value: the error's
+ * declared literal `status`, otherwise 500
  */
 type ErrorFallbackStatus<E> = IsNever<LiteralErrorStatus<E>> extends true ? 500 : LiteralErrorStatus<E>;
-/**
- * Body produced when no error handler returns a value. Falling through lands
- * on exactly the lane an unhandled error takes, so it resolves the same three
- * tiers — `MessageTier` already carries the foreign `response` fallback
- */
-type ErrorFallbackBody<E> = ValueTier<E>;
 /**
  * `Definitions['error']` / `EphemeralType['error']` entry registered by an
  * `.error(Class, handler)` call
@@ -996,10 +1027,22 @@ type ErrorFallbackBody<E> = ValueTier<E>;
 type ErrorDefinitionEntry<E extends abstract new (...args: any) => Error, R> = {
   error: InstanceType<E>;
   response: ErrorHandlerResponseSchema<Awaited<R>, InstanceType<E>>;
+  /**
+   * The handler may return nothing, which passes the error on to the next
+   * hook: it answers sometimes, but doesn't handle the error
+   */
+  passes: undefined extends Awaited<R> ? true : false;
 };
-type ErrorHandlerResponseSchema<R, E> = ExtractErrorFromHandle<Exclude<R, Error>> & (Exclude<R, Extract<Exclude<R, Error>, AnyElysiaStatus> | undefined> | (undefined extends R ? ErrorFallbackBody<E> : never) extends infer Served ? ServedAtStatus<Served, ErrorFallbackStatus<E>> : {});
-type MatchRegisteredError<V, Errors extends ErrorDefinition[]> = Errors extends [infer Head extends ErrorDefinition, ...infer Rest extends ErrorDefinition[]] ? V extends Head['error'] ? Head['response'] : MatchRegisteredError<V, Rest> : never;
-type HasErrorMatch<V, Errors extends ErrorDefinition[]> = Errors extends [infer Head extends ErrorDefinition, ...infer Rest extends ErrorDefinition[]] ? [V] extends [Head['error']] ? true : HasErrorMatch<V, Rest> : false;
+type ErrorHandlerResponseSchema<R, E> = ExtractErrorFromHandle<Exclude<R, Error>> & (Exclude<R, Extract<Exclude<R, Error>, AnyElysiaStatus> | undefined | void> extends infer Served ? ServedAtStatus<Served, ErrorFallbackStatus<E>> : {});
+type PassesError<Entry> = Entry extends {
+  passes: true;
+} ? true : false;
+/**
+ * What the handlers registered for `V` respond with: the first one that
+ * always answers, and every one before it that may pass the error on
+ */
+type MatchRegisteredError<V, Errors extends ErrorDefinition[]> = Errors extends [infer Head extends ErrorDefinition, ...infer Rest extends ErrorDefinition[]] ? V extends Head['error'] ? PassesError<Head> extends true ? Head['response'] | MatchRegisteredError<V, Rest> : Head['response'] : MatchRegisteredError<V, Rest> : never;
+type HasErrorMatch<V, Errors extends ErrorDefinition[]> = Errors extends [infer Head extends ErrorDefinition, ...infer Rest extends ErrorDefinition[]] ? [V] extends [Head['error']] ? PassesError<Head> extends true ? HasErrorMatch<V, Rest> : true : HasErrorMatch<V, Rest> : false;
 type UnhandledReturnedError<Value, Errors extends ErrorDefinition[]> = 0 extends 1 & Value ? never : ErrorOf<Value> extends infer Es ? Es extends Error ? HasErrorMatch<Es, Errors> extends true ? never : Es : never : never;
 type UnhandledReturnedErrorOf<T, Errors extends ErrorDefinition[]> = T extends ((...a: any) => MaybePromise<infer R>) ? UnhandledReturnedError<R, Errors> : UnhandledReturnedError<T, Errors>;
 /**
@@ -1053,13 +1096,6 @@ type ResolveRouteLeafErrors<Route extends {
   response: Prettify<UnionResponseStatus<WithoutUnhandledErrorResponse<Route['response'], Route['error']>, UnionResponseStatus<ExtractReturnedError<Route['error'], Errors>, UnhandledErrorResponse<UnhandledReturnedError<Route['error'], Errors>>>>>;
   error: UnhandledReturnedError<Route['error'], Errors>;
 } & HandledErrorKey<RouteHandled<Route> | HandledReturnedError<Route['error'], Errors>>;
-type ResolveRouteErrors<Routes, Errors extends ErrorDefinition[]> = Errors extends [] ? Routes : { [K in keyof Routes]: Routes[K] extends {
-  params: any;
-  query: any;
-  headers: any;
-  response: any;
-  error: any;
-} ? ResolveRouteLeafErrors<Routes[K], Errors> : Routes[K] extends Record<keyof any, any> ? ResolveRouteErrors<Routes[K], Errors> : Routes[K] };
 /**
  * Take a parent's handlers registered before `.use()` in front of the
  * plugin's own: at runtime they run first, so an error the plugin already
@@ -1107,7 +1143,7 @@ type MergeElysiaInstances<Instances extends AnyElysia[] = [], Prefix extends str
   schemas: Volatile['schemas'] & Current['~Ephemeral']['schemas'];
   response: Volatile['response'] & Current['~Ephemeral']['response'];
   error: [...Volatile['error'], ...Current['~Ephemeral']['error']];
-}, ResolveRouteErrors<Routes, [...Current['~Definitions']['error'], ...Current['~Ephemeral']['error']]> & (Prefix extends `` ? ResolveUsedRouteErrors<Current['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>> : CreateEden<Prefix, ResolveUsedRouteErrors<Current['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>>>)> : Elysia<Prefix, Scope, {
+}, Routes & (Prefix extends `` ? ResolveUsedRouteErrors<Current['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>> : CreateEden<Prefix, ResolveUsedRouteErrors<Current['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], ParentResponse<Metadata, Ephemeral, Volatile>>>)> : Elysia<Prefix, Scope, {
   decorator: Singleton['decorator'];
   store: Prettify<Singleton['store']>;
   derive: Singleton['derive'];
@@ -1218,11 +1254,11 @@ type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton ext
   subscribe: CreateWSEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Response, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>>;
 }>, Ephemeral, Volatile>;
 type GuardHookSingleton<Singleton extends SingletonBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, MacroContext> = Singleton & {
-  derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['resolve'];
+  derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['derive'];
 };
 interface StaticMapAliases {
   method: string;
   paths: string[];
 }
 //#endregion
-export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, HandledErrorKey, HandledReturnedErrorOf, Handler, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, JoinPath, LocalHook, LocalHookReturn, Macro, MacroProperty, MacroPropertyKey, MacroToContext, MacroToProperty, MacroTypeLambda, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, ObjectMacroDefs, OptionalHandler, ParentResponse, PluginHookReturn, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, ResolveUsedRouteErrors, RouteBase, RouteInput, RouteSchema, SSEPayload, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, type StandardSchemaV1Like, StaticMapAliases, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapModels, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WithHandledErrors, WrapFn };
+export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, HandledErrorKey, HandledReturnedErrorOf, Handler, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, JoinPath, LocalHook, LocalHookReturn, Macro, MacroOptionContext, MacroProperty, MacroPropertyKey, MacroToContext, MacroToProperty, MacroTypeLambda, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, ObjectMacroDefs, OptionalHandler, ParentResponse, PluginHookReturn, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveUsedRouteErrors, RouteBase, RouteInput, RouteSchema, SSEPayload, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, type StandardSchemaV1Like, StaticMapAliases, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapModels, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WithHandledErrors, WrapFn };

package/dist/types.mjs

@@ -1 +1,2 @@
+// @bun
 export {  };

package/dist/universal/constants.mjs

@@ -1,3 +1,4 @@
+// @bun
 //#region src/universal/constants.ts
 const isBun = typeof Bun !== "undefined";
 const isFastly = typeof fastly !== "undefined";

package/dist/universal/file.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { isBun } from "./constants.mjs";
 
 //#region src/universal/file.ts

package/dist/universal/index.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { file } from "./file.mjs";
 import { env } from "./env.mjs";
 import { isProduction } from "./is-production.mjs";

package/dist/universal/is-production.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { env, hasReadableEnv } from "./env.mjs";
 
 //#region src/universal/is-production.ts

package/dist/universal/server.mjs

@@ -1 +1,2 @@
+// @bun
 export {  };

package/dist/utils.d.ts

@@ -1,13 +1,23 @@
-import { AnySchema, StandardSchemaV1Like } from "./type/types.js";
 import { Context } from "./context.js";
-import { AnyLocalHook, AppHook, BunHTMLBundlelike, ElysiaFormData, EventFn, EventScope, GuardSchemaType, InputSchema, Macro, MaybeArray, Prettify, SSEPayload } from "./types.js";
+import { AnySchema, StandardSchemaV1Like } from "./type/types.js";
+import { AnyLocalHook, AppHook, BunHTMLBundlelike, ElysiaFormData, EventFn, EventScope, GuardSchemaType, InputSchema, Macro, MacroTypeLambda, MaybeArray, Prettify, SSEPayload } from "./types.js";
 
 //#region src/utils.d.ts
-type DeriveEntry = Function | readonly [Function, 'mapDerive'];
+type DeriveEntry = Function | readonly [Function, 'mapDerive' | 'beforeHandle'];
 declare const nullObject: () => any;
 declare const mapDeriveEntry: (fn: Function) => DeriveEntry;
 declare const deriveEntryFn: (entry: DeriveEntry) => any;
 declare const isMapDeriveEntry: (entry: DeriveEntry) => boolean;
+declare const isPlainDeriveEntry: (entry: DeriveEntry) => boolean;
+/**
+ * `~deriveEntries` for `hooks` whose role per occurrence is `at` (an entry
+ * for a derive, undefined for a plain hook). `deriveModes` gives each
+ * function's entries to its occurrences in order, so a plain occurrence
+ * before a derive of the same function gets a placeholder
+ */
+declare function occurrenceDeriveEntries(hooks: readonly Function[], at: readonly (DeriveEntry | undefined)[]): DeriveEntry[];
+/** Each function's derive entries, in occurrence order */
+declare const deriveQueues: (entries: readonly DeriveEntry[] | undefined) => Map<any, DeriveEntry[]> | undefined;
 declare function isEmpty<T extends Object>(obj: T): boolean;
 declare const isNotEmpty: <T extends Object>(obj?: T) => boolean | undefined;
 /**
@@ -20,20 +30,20 @@ declare const isNotEmpty: <T extends Object>(obj?: T) => boolean | undefined;
  */
 declare function evictOldestHalf(cache: Map<any, any>): void;
 declare function fnv1a(str: string): number;
+/**
+ * 48-bit hash of a named plugin's key (fnv1a + 16 bits of a second hash): at
+ * 32 bits two plugins collide by ~77k and the second is dropped. 48 keeps
+ * `origin * 16 + slot` exact
+ */
+declare function pluginHash(str: string): number;
 declare const compositionKeys: readonly string[];
 declare function refTargets(roots: unknown[], models?: Record<string, unknown>): (name: string) => Iterable<unknown>;
+declare const macroOrigin: WeakMap<object | Function, number>;
 /**
- * Maps each lifecycle/derive function to the hash of the named plugin it was
- * first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
- * origin is already in `parent.#apps`, the parent has already absorbed that
- * named plugin via another path and should skip re-adding the fn.
- *
- * Anonymous plugins (no name) don't tag their fns - there's no hash to dedup
- * by, so their fns always propagate.
+ * Id of an unnamed plugin in `childrenHash`, negative so it never collides
+ * with a named plugin's unsigned hash
  */
-declare const fnOrigin: WeakMap<Function, number>;
-declare const macroOrigin: WeakMap<object | Function, number>;
-declare const isLocalScope: (s: EventScope | undefined) => s is "local" | undefined;
+declare const pluginId: (plugin: object) => number;
 /**
  * Linked-list representation of the scope/global hook chain of a route
  *
@@ -51,10 +61,9 @@ declare const isLocalScope: (s: EventScope | undefined) => s is "local" | undefi
  * without flattening - `over` is walked first (older / outer context),
  * then `combine` (newer / inner context)
  *
- * `tail` is the child's own chain head at that `.use()`. Its local hooks
- * registered after the child absorbed the route run after the route's own
- * hooks, as they would with the child as the root (`afterUseHooks` in
- * `compile/handler`)
+ * `callback` is the chain of a `.group()`/`.guard()` callback the route came
+ * out of: its error hooks cover every route the callback produced. Flattening
+ * never reads it
  *
  * Use with {@link flattenChain} to walk tail-first and reconstruct
  * flat `Partial<AppHook>` at compile time
@@ -66,18 +75,15 @@ type ChainNode = {
   scope?: EventScope;
   propagated?: boolean;
   owner?: object;
+  origin?: number;
+  registration?: ChainNode;
 } | {
   combine: ChainNode | undefined;
   over: ChainNode | undefined;
-  tail?: ChainNode;
+  callback?: ChainNode;
+  inner?: ChainNode;
   refs: boolean;
 };
-/**
- * The absorbing instance's chain as it stood at `.use()`: the `over` of a
- * combine node, or the node itself. A combine node is never on an instance's
- * own chain, so it can't serve as a `stopAt` directly
- */
-declare const rootSnapshot: (node: ChainNode | undefined) => ChainNode | undefined;
 interface CompactBeforeHandleChunk {
   parent?: CompactBeforeHandleChunk;
   values: readonly Function[];
@@ -91,19 +97,30 @@ interface CompactBeforeHandlePrefix {
 declare const isCompactBeforeHandleOnly: (hook: Partial<AppHook> | undefined) => boolean;
 declare function compactBeforeHandleConflicts(hook: Partial<AppHook> | undefined): boolean;
 declare function compactBeforeHandlePrefix(start: ChainNode | undefined): CompactBeforeHandlePrefix | undefined;
+interface ChainInfo {
+  installs?: ReadonlySet<number>;
+  named?: true;
+}
 /**
  * Walk the chain tail-first into a fresh `Partial<AppHook>`
  *
+ * Each instance chain a combine node links is one layer, outermost first.
+ * A named plugin's hook is skipped when an outer layer, or `skip`, already
+ * installed that plugin's same lifecycle event: it runs once, at its
+ * outermost position. Within a layer every registration stays
+ *
  * Explicit-stack walk (no recursion) so it works uniformly for linear
  * chains and combine nodes without risking stack overflow on deep chains
  */
-declare function flattenChain(start: ChainNode | undefined, keep?: (s: EventScope | undefined) => boolean, stopAt?: ChainNode, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
+declare function flattenChain(start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined, skip?: ReadonlySet<number>, info?: ChainInfo): Partial<AppHook> | undefined;
 declare const macroEpoch: () => number;
 declare const invalidateMacroEpoch: () => void;
 /** Drop this root's flattened-chain memo. Recomputable on next compile. */
 declare function clearFlattenChainMemo(root: object): void;
-declare function flattenChainMemoReadonly(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
-declare function flattenChainMemo(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
+/** What the chain installs, see {@link flattenChain} */
+declare function flattenChainInfo(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): ChainInfo | undefined;
+declare function flattenChainMemoReadonly(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined, skip?: ReadonlySet<number>): Partial<AppHook> | undefined;
+declare function flattenChainMemo(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined, skip?: ReadonlySet<number>): Partial<AppHook> | undefined;
 /**
  *
  * @param url URL to redirect to
@@ -130,6 +147,7 @@ declare function formToFormData(value: Record<keyof any, unknown>): FormData;
  * ```
  */
 declare const form: <const T extends Record<keyof any, unknown>>(value: T) => ElysiaFormData<T>;
+declare const macroType: <L extends MacroTypeLambda>() => L | undefined;
 declare const assignOwn: <T extends object>(target: T, source: any) => T;
 declare const getLoosePath: (path: string) => string;
 /**
@@ -171,7 +189,7 @@ declare function hookToGuard(a: Partial<AppHook & Macro> & {
   schema?: GuardSchemaType;
 }): Partial<AppHook & Macro>;
 declare function coalesceSchemas(existing: any[], incoming: any[]): void;
-declare function mergeHook(a: Partial<AppHook>, b: Partial<AppHook> | undefined, reverse?: boolean, dedup?: boolean): Partial<AppHook>;
+declare function mergeHook(a: Partial<AppHook>, b: Partial<AppHook> | undefined): Partial<AppHook>;
 declare const createErrorEventHandler: (fn: EventFn<"error">, error: Error) => (context: Context) => unknown;
 declare function mergeDeep<A extends Record<string, any>, B extends Record<string, any>>(target: A, source: B, skipKeys?: string[], override?: boolean, mergeArray?: boolean, seen?: WeakSet<object>, cloneAdopt?: {
   map?: WeakMap<object, any>;
@@ -181,7 +199,6 @@ declare function cloneHook<T extends Partial<AnyLocalHook> | Partial<AppHook>>(s
 declare function clonePlainDeep<T>(value: T, seen?: WeakMap<object, any>): T;
 declare function guardNonPlainLeaves(target: Record<string, unknown>, source: Record<string, unknown>): void;
 declare function joinPath(base: string, path: string): string;
-declare function pushField<K extends keyof any>(target: Record<K, unknown>, key: K, item: unknown): void;
 declare const requestId: typeof Bun.randomUUIDv7 | (() => `${string}-${string}-${string}-${string}-${string}`);
 /**
  * Offset of the first byte after `://`, so the authority is never scanned as
@@ -200,7 +217,8 @@ declare function serializeMacroSeed(_key: string, value: unknown): unknown;
 declare const throwLifecycleErrors: (errors: unknown[]) => void;
 declare const isDisposable: (value: any) => boolean;
 declare const isSingleton: (value: object) => boolean;
-declare const markSingletons: (value: unknown, depth?: number, seen?: Set<object>) => void;
+declare const markSingletons: (value: unknown, depth?: number) => void;
+declare const markPropertySingletons: (object: object) => void;
 declare const isSocketQuiet: (socket: {
   readyState: number;
   data: {
@@ -211,4 +229,4 @@ declare const isSocketQuiet: (socket: {
 }) => boolean;
 declare const isHTMLBundle: (value: unknown) => value is BunHTMLBundlelike;
 //#endregion
-export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, compositionKeys, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isLocalScope, isMapDeriveEntry, isNotEmpty, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, refTargets, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };
+export { ChainInfo, ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, compositionKeys, constantTimeEqual, createErrorEventHandler, deriveEntryFn, deriveQueues, eventProperties, evictOldestHalf, flattenChain, flattenChainInfo, flattenChainMemo, flattenChainMemoReadonly, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isMapDeriveEntry, isNotEmpty, isPlainDeriveEntry, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, macroType, mapDeriveEntry, markPropertySingletons, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, occurrenceDeriveEntries, pluginHash, pluginId, prefix, redirect, refTargets, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };