elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/types.d.ts

@@ -1,15 +1,15 @@
 import { CookieOptions } from "./cookie/types.js";
-import { TraceHandler } from "./trace.js";
-import { ElysiaFile } from "./universal/file.js";
+import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { StatusMap, StatusMapBack } from "./constants.js";
-import { Serve } from "./universal/server.js";
+import { ElysiaError, ElysiaStatus, ProblemResponseBody, ValidationErrorResponse } from "./error.js";
 import { ChainNode } from "./utils.js";
-import { ElysiaError, ElysiaStatus, ProblemResponseBody } from "./error.js";
+import { Serve } from "./universal/server.js";
 import { Context, ErrorContext, LifecycleContext, PreContext } from "./context.js";
-import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
+import { TraceHandler } from "./trace.js";
+import { ElysiaFile } from "./universal/file.js";
 import { AnyElysia, Elysia } from "./base.js";
 import { ElysiaAdapter } from "./adapter/index.js";
-import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
+import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TRef, TSchema } from "typebox";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/types.d.ts
@@ -70,7 +70,8 @@ interface ElysiaConfig<in out Prefix extends string | undefined, in out Scope ex
    *
    * Only required for root instance (instance which use listen) to effect
    *
-   * ! If performing a benchmark, it's recommended to set this to `true`
+   * TypeBox loads during build when needed, regardless of this setting.
+   * Enable this only to compile route handlers and validators before listen().
    *
    * @default false
    */
@@ -127,18 +128,6 @@ interface ElysiaConfig<in out Prefix extends string | undefined, in out Scope ex
    * @default 'exactMirror'
    */
   normalize?: boolean | 'exactMirror' | 'typebox';
-  handler?: {
-    /**
-     * optimization for standard internet hostname
-     * this will assume hostname is always use a standard internet hostname
-     * assuming hostname is at minimum of 11 length of string (http://a.bc)
-     *
-     * setting this to true will skip the first 11 character of the hostname
-     *
-     * @default true
-     */
-    standardHostname?: boolean;
-  };
   /**
    * Enable Bun adapter native static response collection for eligible literal
    * static routes.
@@ -192,7 +181,7 @@ type ElysiaFormData<T extends Record<keyof any, unknown>> = FormData & {
   ['~ely-form']: Replace<T, Blob | ElysiaFile, File> extends infer A ? { [key in keyof A]: IsTuple<A[key]> extends true ? A[key][number] extends Blob | ElysiaFile ? File[] : A[key] : A[key] } : T;
 };
 type ContentType = MaybeArray<'none' | 'text' | 'json' | 'formdata' | 'urlencoded' | 'arrayBuffer' | 'text/plain' | 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded' | 'application/octet-stream'>;
-type HTTPMethod = (string & {}) | 'ACL' | 'BIND' | 'CHECKOUT' | 'CONNECT' | 'COPY' | 'DELETE' | 'GET' | 'HEAD' | 'LINK' | 'LOCK' | 'M-SEARCH' | 'MERGE' | 'MKACTIVITY' | 'MKCALENDAR' | 'MKCOL' | 'MOVE' | 'NOTIFY' | 'OPTIONS' | 'PATCH' | 'POST' | 'PROPFIND' | 'PROPPATCH' | 'PURGE' | 'PUT' | 'REBIND' | 'REPORT' | 'SEARCH' | 'SOURCE' | 'SUBSCRIBE' | 'TRACE' | 'UNBIND' | 'UNLINK' | 'UNLOCK' | 'UNSUBSCRIBE' | 'ALL';
+type HTTPMethod = (string & {}) | 'ACL' | 'BIND' | 'CHECKOUT' | 'CONNECT' | 'COPY' | 'DELETE' | 'GET' | 'HEAD' | 'LINK' | 'LOCK' | 'M-SEARCH' | 'MERGE' | 'MKACTIVITY' | 'MKCALENDAR' | 'MKCOL' | 'MOVE' | 'NOTIFY' | 'OPTIONS' | 'PATCH' | 'POST' | 'PROPFIND' | 'PROPPATCH' | 'PURGE' | 'PUT' | 'QUERY' | 'REBIND' | 'REPORT' | 'SEARCH' | 'SOURCE' | 'SUBSCRIBE' | 'TRACE' | 'UNBIND' | 'UNLINK' | 'UNLOCK' | 'UNSUBSCRIBE' | 'ALL';
 type UnwrapArray<T> = T extends (infer U)[] ? U : T;
 type AppEvent = 'start' | 'stop' | 'request' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'mapResponse' | 'afterResponse' | 'error' | 'trace';
 interface AppHook {
@@ -293,6 +282,11 @@ type GuardLocalHook<Input extends BaseMacro | undefined, Schema extends RouteSch
    * @since 1.3.0
    */
   schema?: GuardType;
+  /**
+   * Removed in 2.0 — pass the scope as guard's first argument instead:
+   * `.guard('plugin', { ... })` (1.x `as: 'scoped'` maps to `'plugin'`)
+   */
+  as?: never;
   detail?: DocumentDecoration;
   /**
    * Short for 'Content-Type'
@@ -393,7 +387,13 @@ interface RouteSchema {
   params?: unknown;
   cookie?: unknown;
   response?: unknown;
+  '~input'?: {
+    body?: unknown;
+    headers?: unknown;
+    query?: unknown;
+  };
 }
+type RouteInput<S extends RouteSchema> = '~input' extends keyof S ? NonNullable<S['~input']> : S;
 type OptionalHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = DefaultSingleton, Path extends string | undefined = undefined, ParamsScope extends 'local' | 'plugin' | 'global' = 'local'> = (context: LifecycleContext<Route, Singleton, Path, ParamsScope>) => MaybePromise<{} extends Route['response'] ? unknown : Route['response'][keyof Route['response']] | InlineHandlerResponse<Route['response']> | void>;
 type AfterHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = DefaultSingleton, Path extends string | undefined = undefined, ParamsScope extends 'local' | 'plugin' | 'global' = 'local'> = (context: LifecycleContext<Route, Singleton, Path, ParamsScope> & {
   responseValue: {} extends Route['response'] ? unknown : Route['response'][keyof Route['response']];
@@ -429,7 +429,7 @@ interface BunHTMLBundlelike {
   }[];
 }
 type InlineResponse = string | number | boolean | Record<any, unknown> | Response | AnyElysiaStatus | ElysiaFile | Blob | BunHTMLBundlelike | Error;
-type InlineHandlerResponse<Route extends RouteSchema['response']> = { [Status in keyof Route]: ElysiaStatus<Status, Route[Status], Status> }[keyof Route];
+type InlineHandlerResponse<Route extends RouteSchema['response']> = { [Status in keyof Route]: ElysiaStatus<Status, Route[Status], Status> | (Status extends keyof StatusMapBack ? ElysiaStatus<StatusMapBack[Status], Route[Status]> : never) }[keyof Route];
 type InlineHandler<Route extends RouteSchema = {}, Singleton extends SingletonBase = DefaultSingleton, MacroContext extends {
   response: PossibleResponse;
   return: PossibleResponse;
@@ -441,7 +441,7 @@ type InlineHandler<Route extends RouteSchema = {}, Singleton extends SingletonBa
 }> = InlineHandlerNonMacro<Route & MacroContext, Singleton & {
   derive: MacroContext['resolve'];
 }>;
-type InlineHandlerNonMacro<Route extends RouteSchema = {}, Singleton extends SingletonBase = DefaultSingleton> = MaybePromise<InlineHandlerResponse<Route['response']> | ({} extends Route['response'] ? InlineResponse : Route['response'][keyof Route['response']])> | ((context: Context<Route, Singleton>) => MaybePromise<Response> | MaybePromise<{} extends Route['response'] ? unknown : (Route['response'] extends {
+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;
 } ? Route['response'][200] | ElysiaStatus<200, Route['response'][200], 200> | Generator<Route['response'][200]> | AsyncGenerator<Route['response'][200]> : unknown) | Route['response'][keyof Route['response']] | InlineHandlerResponse<Route['response']>>);
 type Handler = (context: Context) => unknown;
@@ -458,7 +458,7 @@ type ErrorHandler<T extends ErrorDefinition[] = [], in out Route extends RouteSc
   decorator: Singleton['decorator'];
   derive: {};
 }> & {
-  error: T[number]['error'] | Error;
+  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'> & {
   params: ResolvePath<Path>;
@@ -471,6 +471,7 @@ type MergeSchema<A extends RouteSchema, B extends RouteSchema, Path extends stri
   params: AParamsPathDerived extends true ? IsNever<keyof B['params']> extends true ? A['params'] : B['params'] : IsNever<keyof A['params']> extends true ? IsNever<keyof B['params']> extends true ? ResolvePath<Path> : B['params'] : A['params'];
   cookie: undefined extends A['cookie'] ? B['cookie'] : A['cookie'];
   response: {} extends A['response'] ? {} extends B['response'] ? {} : B['response'] : {} extends B['response'] ? A['response'] : A['response'] & Omit<B['response'], keyof A['response']>;
+  '~input'?: { [K in 'body' | 'headers' | 'query']: undefined extends A[K] ? RouteInput<B>[K] : RouteInput<A>[K] };
 };
 type AnyWSLocalHook = any;
 type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
@@ -499,6 +500,19 @@ type MacroProperty<Macro extends BaseMacro = {}, TypedRoute extends RouteSchema
   afterResponse?: MaybeArray<AfterResponseHandler<TypedRoute, Singleton>>;
   derive?: MaybeArray<ResolveHandler<TypedRoute, Singleton>>;
   detail?: DocumentDecoration;
+  /**
+   * Type-level route metadata surfaced on the route's Eden type
+   * (`CreateEdenResponse['meta']`). Reserved key like `seed`/`detail`/
+   * `introspect` — stripped at runtime, never lands on route hooks
+   */
+  meta?: unknown;
+  /**
+   * 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
+   */
+  $type?: MacroTypeLambda;
   /**
    * Introspect hook option for documentation generation or analysis
    *
@@ -616,24 +630,75 @@ type ContextAppendType = 'append' | 'override';
 type OptionalField = {
   '~optional': true;
 };
-type StaticCyclic<T extends TypeBoxSchema, Definitions extends Record<string, AnySchema>> = {} extends Definitions ? StaticDecode<T> : StaticDecode<T, Definitions>;
-type UnwrapSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = Schema extends undefined ? unknown : Schema extends TypeBoxSchema ? Schema extends OptionalField ? Partial<StaticCyclic<Schema, Definitions>> : StaticCyclic<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['output'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['output'] : unknown : unknown : unknown;
-type UnwrapBodySchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = undefined extends Schema ? unknown : Schema extends TypeBoxSchema ? Schema extends OptionalField ? Partial<StaticCyclic<Schema, Definitions>> | null : StaticCyclic<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['output'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['output'] : unknown : unknown : unknown;
+type IsOptionalRoot<Schema, Definitions, Seen extends string = never> = Schema extends OptionalField ? true : Schema extends TRef<infer Ref> ? Ref extends Seen ? false : Ref extends keyof Definitions ? IsOptionalRoot<Definitions[Ref], Definitions, Seen | Ref> : false : false;
+type SchemaSide = 'input' | 'output';
+type StaticCyclic<T extends TypeBoxSchema, Definitions extends Record<string, AnySchema>, Side extends SchemaSide = 'output'> = Side extends 'input' ? {} extends Definitions ? StaticEncode<T> : StaticEncode<T, Definitions> : {} extends Definitions ? StaticDecode<T> : StaticDecode<T, Definitions>;
+type UnwrapSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}, Side extends SchemaSide = 'output'> = Schema extends undefined ? unknown : Schema extends TypeBoxSchema ? true extends IsOptionalRoot<Schema, Definitions> ? Partial<StaticCyclic<Schema, Definitions, Side>> : StaticCyclic<Schema, Definitions, Side> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>[Side] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? true extends IsOptionalRoot<Definitions[Schema], Definitions> ? Partial<StaticCyclic<Definitions[Schema], Definitions, Side>> : StaticCyclic<Definitions[Schema], Definitions, Side> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>[Side] : unknown : unknown : unknown;
+type UnwrapBodySchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}, Side extends SchemaSide = 'output'> = undefined extends Schema ? unknown : Schema extends TypeBoxSchema ? true extends IsOptionalRoot<Schema, Definitions> ? Partial<StaticCyclic<Schema, Definitions, Side>> | null | undefined : StaticCyclic<Schema, Definitions, Side> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>[Side] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? true extends IsOptionalRoot<Definitions[Schema], Definitions> ? Partial<StaticCyclic<Definitions[Schema], Definitions, Side>> | null | undefined : StaticCyclic<Definitions[Schema], Definitions, Side> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>[Side] : unknown : unknown : unknown;
+type CodecFreeKind = 'Any' | 'BigInt' | 'Boolean' | 'Enum' | 'Integer' | 'Literal' | 'Never' | 'Null' | 'Number' | 'String' | 'Symbol' | 'TemplateLiteral' | 'Undefined' | 'Unknown' | 'Void';
+interface CodecFreeBase {
+  '~codec'?: never;
+}
+interface CodecFreeLeaf extends CodecFreeBase {
+  '~kind': CodecFreeKind;
+}
+interface CodecFreeObject extends CodecFreeBase {
+  '~kind': 'Object';
+  properties: {
+    [key: PropertyKey]: CodecFreeSchema;
+  };
+}
+interface CodecFreeRecord extends CodecFreeBase {
+  '~kind': 'Record';
+  patternProperties: {
+    [key: PropertyKey]: CodecFreeSchema;
+  };
+}
+interface CodecFreeArray extends CodecFreeBase {
+  '~kind': 'Array';
+  items: CodecFreeSchema;
+}
+interface CodecFreeTuple extends CodecFreeBase {
+  '~kind': 'Tuple';
+  items: CodecFreeSchema[];
+}
+interface CodecFreeUnion extends CodecFreeBase {
+  '~kind': 'Union';
+  anyOf: CodecFreeSchema[];
+}
+interface CodecFreeIntersect extends CodecFreeBase {
+  '~kind': 'Intersect';
+  allOf: CodecFreeSchema[];
+}
+type CodecFreeSchema = CodecFreeLeaf | CodecFreeObject | CodecFreeRecord | CodecFreeArray | CodecFreeTuple | CodecFreeUnion | CodecFreeIntersect;
+type InputSide<Schema, Definitions> = [Schema] extends [CodecFreeSchema] ? 'output' : [Schema] extends [keyof Definitions] ? [Definitions[Schema & keyof Definitions]] extends [CodecFreeSchema] ? 'output' : 'input' : 'input';
+type UnwrapInputSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = {
+  output: UnwrapSchema<Schema, Definitions>;
+  input: UnwrapSchema<Schema, Definitions, 'input'>;
+}[InputSide<Schema, Definitions>];
+type UnwrapInputBodySchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = {
+  output: UnwrapBodySchema<Schema, Definitions>;
+  input: UnwrapBodySchema<Schema, Definitions, 'input'>;
+}[InputSide<Schema, Definitions>];
 type FormInnerProperties<Schema> = Extract<Schema extends TIntersect<infer Members> ? Members[number] : never, TObject>['properties'];
-type UnwrapResponseSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = Schema extends TypeBoxSchema ? StaticEncode<Schema> extends ElysiaFormData<any> ? ElysiaFormData<{ [K in keyof FormInnerProperties<Schema>]: Static<FormInnerProperties<Schema>[K] & TSchema> }> : UnwrapSchema<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['input'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['input'] : unknown : unknown : unknown;
+type UnwrapResponseSchema<Schema extends AnySchema | string | undefined, Definitions extends DefinitionBase['typebox'] = {}> = Schema extends TypeBoxSchema ? StaticEncode<Schema> extends ElysiaFormData<any> ? ElysiaFormData<{ [K in keyof FormInnerProperties<Schema>]: Static<FormInnerProperties<Schema>[K] & TSchema> }> : Schema extends OptionalField ? Partial<StaticCyclic<Schema, Definitions>> : StaticCyclic<Schema, Definitions> : Schema extends StandardSchemaV1Like ? NonNullable<Schema['~standard']['types']>['input'] : Schema extends string ? Schema extends keyof Definitions ? Definitions[Schema] extends TypeBoxSchema ? StaticCyclic<Definitions[Schema], Definitions> : Definitions[Schema] extends StandardSchemaV1Like ? NonNullable<Definitions[Schema]['~standard']['types']>['input'] : unknown : unknown : unknown;
 interface UnwrapRoute<in out Schema extends InputSchema<any>, in out Definitions extends DefinitionBase['typebox'] = {}, in out Path extends string = ''> {
   body: UnwrapBodySchema<Schema['body'], Definitions>;
   headers: UnwrapSchema<Schema['headers'], Definitions>;
   query: UnwrapSchema<Schema['query'], Definitions>;
   params: {} extends Schema['params'] ? ResolvePath<Path> : {} extends Schema ? ResolvePath<Path> : UnwrapSchema<Schema['params'], Definitions>;
   cookie: UnwrapSchema<Schema['cookie'], Definitions>;
+  '~input': {
+    body: UnwrapInputBodySchema<Schema['body'], Definitions>;
+    headers: UnwrapInputSchema<Schema['headers'], Definitions>;
+    query: UnwrapInputSchema<Schema['query'], Definitions>;
+  };
   response: Schema['response'] extends AnySchema | string ? {
     200: UnwrapResponseSchema<Schema['response'], Definitions> extends infer A ? A extends File ? File | ElysiaFile : A : unknown;
   } : 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 LocalLifecycleProperty = 'detail' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'mapResponse' | 'afterResponse' | 'error' | 'tags';
+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 NonResolvableMacroKey = LocalLifecycleProperty | keyof InputSchema | 'derive';
 interface RouteSchemaWithResolvedMacro extends RouteSchema {
   response: PossibleResponse;
   return: PossibleResponse;
@@ -646,6 +711,11 @@ interface IntersectIfObjectSchema<A extends RouteSchema, B extends RouteSchema>
   query: IntersectIfObject<A['query'], B['query']>;
   params: IntersectIfObject<A['params'], B['params']>;
   cookie: IntersectIfObject<A['cookie'], B['cookie']>;
+  '~input'?: {
+    body: IntersectIfObject<RouteInput<A>['body'], RouteInput<B>['body']>;
+    headers: IntersectIfObject<RouteInput<A>['headers'], RouteInput<B>['headers']>;
+    query: IntersectIfObject<RouteInput<A>['query'], RouteInput<B>['query']>;
+  };
   response: {} extends A['response'] ? {} extends B['response'] ? A['response'] : B['response'] : {} extends B['response'] ? A['response'] : { [K in keyof A['response'] | keyof B['response']]: K extends keyof A['response'] ? K extends keyof B['response'] ? IntersectIfObject<A['response'][K], B['response'][K]> : A['response'][K] : K extends keyof B['response'] ? B['response'][K] : never };
 }
 interface MergeScopedSchemas<Global extends RouteSchema, Scoped extends RouteSchema, Local extends RouteSchema> {
@@ -654,12 +724,13 @@ interface MergeScopedSchemas<Global extends RouteSchema, Scoped extends RouteSch
   query: Global['query'] & Scoped['query'] & Local['query'];
   params: Global['params'] & Scoped['params'] & Local['params'];
   cookie: Global['cookie'] & Scoped['cookie'] & Local['cookie'];
+  '~input'?: { [K in 'body' | 'headers' | 'query']: RouteInput<Global>[K] & RouteInput<Scoped>[K] & RouteInput<Local>[K] };
   response: { [K in keyof Global['response'] | keyof Scoped['response'] | keyof Local['response']]: K extends keyof Local['response'] ? Local['response'][K] : K extends keyof Scoped['response'] ? Scoped['response'][K] : K extends keyof Global['response'] ? Global['response'][K] : never };
 }
 type ReturnTypeIfPossible<T, Enabled = true> = false extends Enabled ? {} : T extends ((...a: any) => infer R) ? R : T;
-type FunctionArrayReturnType<T> = any[] extends T ? never : T extends any[] ? _FunctionArrayReturnType<T> : Awaited<ReturnType<T>>;
+type FunctionArrayReturnType<T> = any[] extends T ? never : T extends any[] ? _FunctionArrayReturnType<T> : Awaited<ReturnType<NonNullable<T>>>;
 type _FunctionArrayReturnType<T, Carry = undefined> = T extends [infer Fn, ...infer Rest] ? _FunctionArrayReturnType<Rest, Awaited<ReturnType<Fn>> extends infer A ? IsNever<A> extends true ? Carry : A | Carry : Carry> : Carry;
-type FunctionArrayReturnTypeNonNullable<T> = any[] extends T ? never : T extends any[] ? _FunctionArrayReturnTypeNonNullable<T> : NonNullable<Awaited<ReturnType<T>>>;
+type FunctionArrayReturnTypeNonNullable<T> = any[] extends T ? never : T extends any[] ? _FunctionArrayReturnTypeNonNullable<T> : NonNullable<Awaited<ReturnType<NonNullable<T>>>>;
 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 & {} : {};
@@ -667,8 +738,8 @@ type ExtractResolveFromMacro<A> = IsNever<A> extends true ? {} : A extends AnyEl
 type ExtractOnlyResponseFromMacro<A> = IsNever<A> extends true ? {} : Extract<A, AnyElysiaStatus> extends infer A ? IsNever<A> extends true ? {} : {
   return: MergeResponseStatus<A>;
 } : {};
-type MergeResponseStatus<A> = { [status in keyof UnionToIntersect<A extends ElysiaStatus<any, any, infer Status> ? { [A in Status]: 1 } : never>]: Extract<A, {
-  code: status;
+type MergeResponseStatus<A> = { [status in keyof UnionToIntersect<A extends ElysiaStatus<any, any, infer Status> ? { [A in Status]: 1 } : never>]: Extract<A, AnyElysiaStatus & {
+  status: status;
 }>['response'] extends infer Value ? IsAny<Value> extends true ? StatusMapBack[status] : Value : never };
 type ExtractAllResponseFromMacro<A> = IsNever<A> extends true ? {} : {
   return: MergeResponseStatus<A> & (Exclude<A, AnyElysiaStatus> extends infer A ? IsAny<A> extends true ? {} : IsNever<A> extends true ? {} : NonNullable<void> extends A ? {} : undefined extends A ? {} : {
@@ -676,6 +747,22 @@ 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
+ */
+interface MacroTypeLambda {
+  input: unknown;
+}
+type MacroLambdaContext<Value, HookValue> = NonNullable<Value> extends {
+  $type?: infer Lambda extends MacroTypeLambda;
+} ? Lambda & {
+  input: HookValue;
+} extends {
+  output: infer Output;
+} ? Output : {} : {};
 type UnionMacroContext<A> = UnionToIntersect<{ [K in Exclude<keyof A, 'return'>]: A[K] }> & {
   return: {
     _: A['return'];
@@ -684,10 +771,10 @@ type UnionMacroContext<A> = UnionToIntersect<{ [K in Exclude<keyof 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<{
   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 ? {
-  q: UnwrapMacroSchema<Value, Definitions>;
-  resolve: ExtractResolveFromMacro<Extract<Exclude<FunctionArrayReturnType<Value['derive']>, AnyElysiaStatus>, Record<any, unknown>>>;
-} & UnwrapMacroSchema<Value, Definitions> & ExtractAllResponseFromMacro<FunctionArrayReturnTypeNonNullable<Value['beforeHandle']>> & ExtractAllResponseFromMacro<FunctionArrayReturnTypeNonNullable<Value['afterHandle']>> & ExtractAllResponseFromMacro<FunctionArrayReturnType<Value['error']>> & ExtractOnlyResponseFromMacro<FunctionArrayReturnTypeNonNullable<Value['derive']>> & InnerMacroToContext<MacroFn, Pick<Value, Extract<keyof MacroFn, keyof Value>>, Definitions, [...R, 1]> : {} }[keyof SelectedMacro]>;
+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]>;
+} & 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;
   headers: 'headers' extends keyof T ? T['headers'] : undefined;
@@ -698,19 +785,27 @@ type UnwrapMacroSchema<T extends Partial<InputSchema<any>>, Definitions extends
 }, Definitions>;
 type MacroPropertyKey = keyof MacroProperty;
 type AsMacroSchemaField<T> = [T] extends [never] ? undefined : [unknown] extends [T] ? undefined : T extends AnySchema | string ? T : undefined;
-type MacroDefSchema<K, MBody, MHeaders, MQuery, MParams, MCookie> = {
-  body: AsMacroSchemaField<K extends keyof MBody ? MBody[K] : undefined>;
-  headers: AsMacroSchemaField<K extends keyof MHeaders ? MHeaders[K] : undefined>;
-  query: AsMacroSchemaField<K extends keyof MQuery ? MQuery[K] : undefined>;
-  params: AsMacroSchemaField<K extends keyof MParams ? MParams[K] : undefined>;
-  cookie: AsMacroSchemaField<K extends keyof MCookie ? MCookie[K] : undefined>;
+type RefDefSchema<D> = {
+  body: AsMacroSchemaField<D extends {
+    body: infer X;
+  } ? X : undefined>;
+  headers: AsMacroSchemaField<D extends {
+    headers: infer X;
+  } ? X : undefined>;
+  query: AsMacroSchemaField<D extends {
+    query: infer X;
+  } ? X : undefined>;
+  params: AsMacroSchemaField<D extends {
+    params: infer X;
+  } ? X : undefined>;
+  cookie: AsMacroSchemaField<D extends {
+    cookie: infer X;
+  } ? X : undefined>;
   response: undefined;
 };
-type MacroSchemaChannel<Definitions extends DefinitionBase> = Record<keyof any, AnySchema | (keyof Definitions['typebox'] & string)>;
-type MacroChannel<Channel, Key extends keyof InputSchema, Definitions extends DefinitionBase> = { [K in keyof Channel]: MaybeValueOrVoidFunction<{ [F in Key]?: Channel[K] | (keyof Definitions['typebox'] & string) } & Record<string, unknown>> };
 /**
  * Captures the verbatim `.macro()` definition record into a separate first-pass
- * generic (mirrors {@link MacroChannel}). This lets each definition's enabled
+ * 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}.
@@ -737,20 +832,25 @@ type MacroRefResolve<MacroFn, SelectedMacro, Definitions> = MacroToContext<Macro
  * still flow into `N` (the verbatim definitions, stored in
  * `Metadata['macroFn']` for the consuming route)
  */
-type ObjectMacroDefs<Body, Headers, Query, Params, Cookie, N, AmbientSchema extends RouteSchema, ScopedSchemas extends RouteSchema, Singleton extends SingletonBase, Definitions extends DefinitionBase, MacroNames extends BaseMacro, MacroFn = {}, Refs = {}> = MacroChannel<Body, 'body', Definitions> & MacroChannel<Headers, 'headers', Definitions> & MacroChannel<Query, 'query', Definitions> & MacroChannel<Params, 'params', Definitions> & MacroChannel<Cookie, 'cookie', Definitions> & MacroRefChannel<Refs> & { [K in keyof N]: MaybeValueOrVoidFunction<MacroProperty<MacroNames & InputSchema<keyof Definitions['typebox'] & string>, IntersectIfObjectSchema<MergeSchema<UnwrapMacroSchema<MacroDefSchema<K, Body, Headers, Query, Params, Cookie>, Definitions['typebox']>, AmbientSchema>, ScopedSchemas>, Singleton & {
+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']>;
-}, 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 MacroNames | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
+}, 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>;
 type _CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `${infer Start}/${infer Rest}` ? { [x in Start]: _CreateEden<Rest, Property> } : Path extends '' ? Property : { [x in Path]: Property };
 /**
  * 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 claims nothing, and `undefined` is excluded — it falls through
- * to the next tier rather than being served
+ * 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
  */
-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 : unknown extends Resolved ? never : Resolved : never : never;
+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 */
 type AnnotationFallsThrough<V> = undefined extends Awaited<V extends ((...args: any) => infer Returned) ? Returned : V> ? true : false;
 /**
@@ -774,6 +874,16 @@ type OwnedError<E> = E extends {
 type ErrorProblemType<E> = OwnedError<E> extends true ? E extends {
   type: infer T extends string;
 } ? T : 'about:blank' : 'about:blank';
+/**
+ * `code` extension member an error contributes a class made by
+ * `HTTPError.id`, or a built-in `ElysiaError`. `type` may be widened to a URI
+ * by `HTTPError.typeBase`, `code` never is
+ */
+type ErrorProblemCode<E> = E extends {
+  code: infer C extends string;
+} ? string extends C ? {} : {
+  code: C;
+} : {};
 /**
  * Problem document served for a `detail` annotation. `detail` is carried
  * verbatim, objects included — it is never spread into the envelope
@@ -781,7 +891,7 @@ type ErrorProblemType<E> = OwnedError<E> extends true ? E extends {
 type ProblemOf<E, Detail> = ProblemResponseBody<ErrorFallbackStatus<E>, {
   type: ErrorProblemType<E>;
   detail: Detail;
-}>;
+} & ErrorProblemCode<E>>;
 /**
  * Tier 3 — nothing annotated. An error that claimed a problem serves its
  * message as `detail`, anything else keeps the legacy raw lane
@@ -826,23 +936,34 @@ type UnhandledErrorResponse<E> = [E] extends [never] ? {} : MergeStatusUnion<E e
   500: E;
 } : SelfDescribedResponse<E> : never>;
 type CreateEdenResponse<Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Res extends PossibleResponse, Err extends Error = never> = RouteSchema extends MacroContext ? {
-  body: Schema['body'];
+  body: RouteInput<Schema>['body'];
   params: IsNever<keyof Schema['params']> extends true ? ResolvePath<Path> : Schema['params'];
-  query: Schema['query'];
-  headers: Schema['headers'];
+  query: RouteInput<Schema>['query'];
+  headers: RouteInput<Schema>['headers'];
   response: Prettify<UnionResponseStatus<Res, UnhandledErrorResponse<Err>>>;
   error: Err;
 } : {
-  body: Prettify<Schema['body'] & MacroContext['body']>;
+  body: Prettify<RouteInput<Schema>['body'] & RouteInput<MacroContext>['body']>;
   params: IsNever<keyof (Schema['params'] & MacroContext['params'])> extends true ? ResolvePath<Path> : Prettify<Schema['params'] & MacroContext['params']>;
-  query: Prettify<Schema['query'] & MacroContext['query']>;
-  headers: Prettify<Schema['headers'] & MacroContext['headers']>;
+  query: Prettify<RouteInput<Schema>['query'] & RouteInput<MacroContext>['query']>;
+  headers: Prettify<RouteInput<Schema>['headers'] & RouteInput<MacroContext>['headers']>;
   response: Prettify<UnionResponseStatus<Res, UnhandledErrorResponse<Err>>>;
   error: Err;
-};
+} & (MacroContext extends {
+  meta: infer Meta;
+} ? IsNever<Meta> extends true ? {} : unknown extends Meta ? {} : {
+  meta: Meta;
+} : {});
 type CreateWSEdenResponse<Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Res extends PossibleResponse> = Omit<CreateEdenResponse<Path, Schema, MacroContext, Res>, 'error'>;
 type Extract200<T> = T extends AnyElysiaStatus ? Exclude<T, AnyElysiaStatus> | Extract<T, ElysiaStatus<200, any, 200>>['response'] : T;
-type ValueToResponseSchema<Value, Errors extends ErrorDefinition[] = []> = ExtractErrorFromHandle<Exclude<Value, Error>> & ExtractReturnedError<Value, Errors> & (Extract200<Exclude<Value, Error>> extends infer R200 ? undefined extends R200 ? {} : IsNever<R200> extends true ? {} : {
+/**
+ * A returned value types as an error only if it declares `stack`, as `Error`
+ * and zod's `ZodError` do. `{ name, message }` data is structurally an `Error`
+ * too, but the runtime serves it as a 200
+ */
+type ErrorOf<T> = T extends Error ? 'stack' extends keyof T ? T : never : never;
+type NonErrorOf<T> = T extends Error ? ('stack' extends keyof T ? never : T) : T;
+type ValueToResponseSchema<Value, Errors extends ErrorDefinition[] = []> = ExtractErrorFromHandle<NonErrorOf<Value>> & ExtractReturnedError<Value, Errors> & (Extract200<NonErrorOf<Value>> extends infer R200 ? undefined extends R200 ? {} : IsNever<R200> extends true ? {} : {
   200: R200;
 } : {});
 type ValueOrFunctionToResponseSchema<T, Errors extends ErrorDefinition[] = []> = T extends ((...a: any) => MaybePromise<infer R>) ? ValueToResponseSchema<R, Errors> : ValueToResponseSchema<T, Errors>;
@@ -851,20 +972,12 @@ type ElysiaHandlerToResponseSchemas<Handle extends Function[], Carry extends Pos
 type ElysiaHandlerToResponseSchemaAmbiguous<Schemas extends MaybeArray<Function>> = MaybeArray<(...a: any) => any> extends Schemas ? {} : Schemas extends Function ? ElysiaHandlerToResponseSchema<Schemas> : Schemas extends Function[] ? ElysiaHandlerToResponseSchemas<Schemas> : {};
 type ReconcileStatus<in out A extends Record<number, unknown>, in out B extends Record<number, unknown>> = { [K in keyof A | keyof B]: K extends keyof A ? A[K] : B[K] };
 type UnionResponseStatus<A, B> = {} extends A ? B : {} extends B ? A : { [key in keyof A | keyof B]: key extends keyof A ? key extends keyof B ? A[key] | B[key] : A[key] : key extends keyof B ? B[key] : never };
+type ParentResponse<M extends MetadataBase, E extends EphemeralType, V extends EphemeralType> = UnionResponseStatus<M['response'], UnionResponseStatus<E['response'], V['response']>>;
 type HasInputValidator<Schema extends RouteSchema, Path extends string> = EmptyInputSchema extends Pick<Schema, Exclude<InputSchemaKey, 'params' | 'response'>> ? undefined extends Schema['params'] ? false : Schema['params'] extends ResolvePath<Path> ? ResolvePath<Path> extends Schema['params'] ? false : true : true : true;
 type ComposeElysiaResponse<Schema extends RouteSchema, Handle, Possibility extends PossibleResponse, Errors extends ErrorDefinition[] = [], Path extends string = string> = ReconcileStatus<Schema['response'], UnionResponseStatus<ValueOrFunctionToResponseSchema<Handle, Errors>, Possibility & (HasInputValidator<Schema, Path> extends false ? {} : {
-  422: {
-    type: 'validation';
-    title: 'Validation Error';
-    status: 422;
-    detail?: string;
-    on: string;
-    found?: unknown;
-    property?: string;
-    expected?: string;
-  };
+  422: ValidationErrorResponse;
 })>>;
-type ExtractErrorFromHandle<in out Handle> = { [ErrorResponse in Extract<Handle, AnyElysiaStatus> as ErrorResponse extends AnyElysiaStatus ? ErrorResponse['code'] : never]: Prettify<ErrorResponse['response']> };
+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
@@ -887,8 +1000,44 @@ type ErrorDefinitionEntry<E extends abstract new (...args: any) => Error, R> = {
 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 UnhandledReturnedError<Value, Errors extends ErrorDefinition[]> = 0 extends 1 & Value ? never : Extract<Value, Error> extends infer Es ? Es extends Error ? HasErrorMatch<Es, Errors> extends true ? never : Es : never : never;
+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>;
+/**
+ * Returned errors a `.error(Class, handler)` already consumed, each paired
+ * with the response that handler contributed. Carried on the route under
+ * `~handled` so a parent handler registered before `.use()`, which runs first
+ * at runtime, can take the error over
+ */
+type HandledReturnedError<Value, Errors extends ErrorDefinition[]> = Errors extends [] ? never : 0 extends 1 & Value ? never : ErrorOf<Value> extends infer Es ? Es extends Error ? HasErrorMatch<Es, Errors> extends true ? {
+  error: Es;
+  response: MatchRegisteredError<Es, Errors>;
+} : never : never : never;
+type HandledReturnedErrorOf<T, Errors extends ErrorDefinition[]> = Errors extends [] ? never : T extends ((...a: any) => MaybePromise<infer R>) ? HandledReturnedError<R, Errors> : HandledReturnedError<T, Errors>;
+type WithHandledErrors<Route, Handle, Errors extends ErrorDefinition[]> = Errors extends [] ? Route : Route & HandledErrorKey<HandledReturnedErrorOf<Handle, Errors>>;
+type HandledErrorKey<Handled> = [Handled] extends [never] ? {} : {
+  '~handled': Handled;
+};
+type RouteHandled<Route> = Route extends {
+  '~handled': infer H;
+} ? H : never;
+/**
+ * Strip what the handlers in `Taken` contributed from a route's response.
+ * Same caveat as `WithoutUnhandledErrorResponse`: a value the handler itself
+ * also returns at that status is indistinguishable and goes too
+ */
+type WithoutHandledResponse<Response, Contributed> = { [K in keyof Response as K extends keyof Contributed ? IsNever<Exclude<Response[K], Contributed[K]>> extends true ? never : K : K]: K extends keyof Contributed ? Exclude<Response[K], Contributed[K]> : Response[K] };
+type TakenOverError<H, Errors extends ErrorDefinition[]> = H extends {
+  error: infer V;
+} ? HasErrorMatch<V, Errors> extends true ? H : never : never;
+type HandledResponseOf<H> = H extends {
+  response: infer R;
+} ? R : never;
+type RehandledError<Won, Errors extends ErrorDefinition[]> = Won extends {
+  error: infer V;
+} ? {
+  error: V;
+  response: MatchRegisteredError<V, Errors>;
+} : never;
 /**
  * Strip what `UnhandledErrorResponse` contributed for `Err` from a route's
  * response, so a now-handled error doesn't leave a stale status behind.
@@ -896,24 +1045,56 @@ type UnhandledReturnedErrorOf<T, Errors extends ErrorDefinition[]> = T extends (
  * A response that merely shares the same status survives, unless it's
  * indistinguishable from the error's own body
  */
-type WithoutUnhandledErrorResponse<Response, Err> = UnhandledErrorResponse<Err> extends infer Contributed ? { [K in keyof Response as K extends keyof Contributed ? IsNever<Exclude<Response[K], Contributed[K]>> extends true ? never : K : K]: K extends keyof Contributed ? Exclude<Response[K], Contributed[K]> : Response[K] } : never;
+type WithoutUnhandledErrorResponse<Response, Err> = WithoutHandledResponse<Response, UnhandledErrorResponse<Err>>;
+type ResolveRouteLeafErrors<Route extends {
+  response: any;
+  error: any;
+}, Errors extends ErrorDefinition[]> = [Route['error']] extends [never] ? Route : Omit<Route, 'response' | 'error' | '~handled'> & {
+  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;
-} ? [Routes[K]['error']] extends [never] ? Routes[K] : Omit<Routes[K], 'response' | 'error'> & {
-  response: Prettify<UnionResponseStatus<WithoutUnhandledErrorResponse<Routes[K]['response'], Routes[K]['error']>, UnionResponseStatus<ExtractReturnedError<Routes[K]['error'], Errors>, UnhandledErrorResponse<UnhandledReturnedError<Routes[K]['error'], Errors>>>>>;
-  error: UnhandledReturnedError<Routes[K]['error'], Errors>;
-} : Routes[K] extends Record<keyof any, any> ? ResolveRouteErrors<Routes[K], Errors> : Routes[K] };
+} ? 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
+ * handled goes to the parent's matching handler instead
+ */
+type PrependRouteLeafErrors<Route extends {
+  response: any;
+  error: any;
+}, Errors extends ErrorDefinition[]> = TakenOverError<RouteHandled<Route>, Errors> extends infer Won ? [Won] extends [never] ? ResolveRouteLeafErrors<Route, Errors> : ResolveRouteLeafErrors<Omit<Route, 'response' | '~handled'> & {
+  response: Prettify<UnionResponseStatus<WithoutHandledResponse<Route['response'], MergeStatusUnion<HandledResponseOf<Won>>>, UnionResponseStatus<MergeStatusUnion<HandledResponseOf<Exclude<RouteHandled<Route>, Won>>>, MergeStatusUnion<HandledResponseOf<RehandledError<Won, Errors>>>>>>;
+  '~handled': Exclude<RouteHandled<Route>, Won> | RehandledError<Won, Errors>;
+}, Errors> : never;
+/**
+ * A parent's hooks registered before `.use()` run on the plugin's routes too,
+ * so what they can respond with joins each route's response, the same as on
+ * a route the parent declares itself
+ */
+type WithParentResponse<Route, Response> = {} extends Response ? Route : { [K in keyof Route]: K extends 'response' ? UnionParentResponse<Route[K], Response> : Route[K] };
+type UnionParentResponse<Own, Response> = { [S in keyof Own | keyof Response]: Own[S & keyof Own] | Response[S & keyof Response] };
+type ResolveUsedRouteErrors<Routes, Errors extends ErrorDefinition[], Response = {}> = Errors extends [] ? {} extends Response ? Routes : UsedRoutes<Routes, Errors, Response> : UsedRoutes<Routes, Errors, Response>;
+type UsedRoutes<Routes, Errors extends ErrorDefinition[], Response> = string extends keyof Routes ? Routes : PrependUsedRoutes<Routes, Errors, Response>;
+/**
+ * Found by its keys alone: matching a route structurally would resolve its
+ * `params`, `query`, `headers` and `error` too, which reading its `response`
+ * never does
+ */
+type RouteKey = 'params' | 'query' | 'headers' | 'response';
+type PrependUsedRoutes<Routes, Errors extends ErrorDefinition[], Response> = { [K in keyof Routes]: RouteKey extends keyof Routes[K] ? WithParentResponse<Errors extends [] ? Routes[K] : 'error' extends keyof Routes[K] ? PrependRouteLeafErrors<Routes[K], Errors> : Routes[K], Response> : PrependUsedRoutes<Routes[K], Errors, Response> };
 type MergeStatusUnion<U> = { [K in U extends unknown ? keyof U : never]: U extends unknown ? K extends keyof U ? U[K] : never : never };
 /**
  * Map `Error` instances in a handler's return type to the response of their
  * matching `.error(Class, handler)`. Returned errors are forwarded to the
  * error pipeline at runtime, so they never appear in the 200 response
  */
-type ExtractReturnedError<Value, Errors extends ErrorDefinition[]> = 0 extends 1 & Value ? {} : Extract<Value, Error> extends infer Es ? IsNever<Es> extends true ? {} : MergeStatusUnion<Es extends Error ? MatchRegisteredError<Es, Errors> : never> : {};
+type ExtractReturnedError<Value, Errors extends ErrorDefinition[]> = 0 extends 1 & Value ? {} : ErrorOf<Value> extends infer Es ? IsNever<Es> extends true ? {} : MergeStatusUnion<Es extends Error ? MatchRegisteredError<Es, Errors> : never> : {};
 type MergeElysiaInstances<Instances extends AnyElysia[] = [], Prefix extends string = '', Scope extends EventScope = 'local', Singleton extends SingletonBase = DefaultSingleton, Definitions extends DefinitionBase = {
   typebox: {};
   error: [];
@@ -926,13 +1107,13 @@ 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 `` ? ResolveRouteErrors<Current['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]> : CreateEden<Prefix, ResolveRouteErrors<Current['~Routes'], [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>>)> : Elysia<Prefix, Scope, {
+}, 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, {
   decorator: Singleton['decorator'];
   store: Prettify<Singleton['store']>;
   derive: Singleton['derive'];
 }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
 type WrapFn<Callback extends (...params: any) => MaybePromise<Response> = (request: Request, ...rest: any[]) => MaybePromise<Response>> = (fetch: (request: Request, ...rest: any[]) => MaybePromise<Response>) => Callback;
-type AddRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Method extends string, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Handle> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateEden<JoinPath<BasePath, Path>, { [method in Method]: CreateEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Handle, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>, UnhandledReturnedErrorOf<Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>> }>, Ephemeral, Volatile>;
+type AddRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Method extends string, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Handle> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateRouteEden<BasePath, Path, { [method in Method]: WithHandledErrors<CreateEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Handle, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>, UnhandledReturnedErrorOf<Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>>, Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]> }>, Ephemeral, Volatile>;
 type HookContextSchema<Metadata extends MetadataBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, BasePath extends string> = MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>, BasePath> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'];
 type HookContextSingleton<Singleton extends SingletonBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType> = Singleton & {
   derive: Ephemeral['derive'] & Volatile['derive'];
@@ -1033,7 +1214,7 @@ type ScopedMapDeriveReturn<HookScope extends EventScope, BasePath extends string
   response: UnionResponseStatus<Volatile['response'], ResponseAddition>;
   error: Volatile['error'];
 }>;
-type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Response> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateEden<JoinPath<BasePath, Path>, {
+type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton extends SingletonBase, Definitions extends DefinitionBase, Metadata extends MetadataBase, Routes extends RouteBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Response> = Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & CreateRouteEden<BasePath, Path, {
   subscribe: CreateWSEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Response, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']], Path>>;
 }>, Ephemeral, Volatile>;
 type GuardHookSingleton<Singleton extends SingletonBase, Ephemeral extends EphemeralType, Volatile extends EphemeralType, MacroContext> = Singleton & {
@@ -1043,18 +1224,5 @@ interface StaticMapAliases {
   method: string;
   paths: string[];
 }
-type LazyComposeEntry = {
-  kind: 'route';
-  route: InternalRoute;
-  source?: string;
-} | {
-  kind: 'use';
-  child: AnyElysia;
-  preChain: ChainNode | undefined;
-  childBaseLen: number;
-  childPlan: LazyComposeEntry[] | undefined;
-  childPlanLen: number;
-  source?: 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, Handler, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, JoinPath, LazyComposeEntry, LocalHook, LocalHookReturn, Macro, MacroProperty, MacroPropertyKey, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, RouteBase, RouteSchema, SSEPayload, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, type StandardSchemaV1Like, StaticMapAliases, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WrapFn };
+export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, 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 };