elysia 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/type/validator/validator-cache.js

@@ -75,24 +75,22 @@ function walk(value, key, mode, state) {
 }
 function walkObject(value, mode, state) {
 	const keys = Object.keys(value);
-	let serialized = "{";
-	let first = true;
+	const parts = ["{"];
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
 		const child = value[key];
 		const piece = walk(child, key, mode === CONTAINER ? NODE : mode === NODE ? childMode(key, child) : OFF, state);
 		if (piece === void 0) continue;
 		if (state.buildKey) {
-			if (first) first = false;
-			else serialized += ",";
-			serialized += quote(key) + ":" + piece;
+			if (parts.length > 1) parts.push(",");
+			parts.push(quote(key), ":", piece);
 		}
 	}
-	return serialized + "}";
+	parts.push("}");
+	return parts.join("");
 }
 function walkOptional(value, mode, state) {
-	let serialized = "{";
-	let first = true;
+	const parts = ["{"];
 	let emittedOptional = false;
 	for (const key in value) {
 		const child = value[key];
@@ -100,28 +98,29 @@ function walkOptional(value, mode, state) {
 		if (key === "~optional") emittedOptional = true;
 		if (piece === void 0) continue;
 		if (state.buildKey) {
-			if (first) first = false;
-			else serialized += ",";
-			serialized += quote(key) + ":" + piece;
+			if (parts.length > 1) parts.push(",");
+			parts.push(quote(key), ":", piece);
 		}
 	}
 	if (!emittedOptional && state.buildKey) {
-		if (!first) serialized += ",";
-		serialized += "\"~optional\":true";
+		if (parts.length > 1) parts.push(",");
+		parts.push("\"~optional\":true");
 	}
-	return serialized + "}";
+	parts.push("}");
+	return parts.join("");
 }
 function walkArray(value, mode, state) {
 	const elementMode = mode === CONTAINER ? NODE : OFF;
-	let serialized = "[";
+	const parts = ["["];
 	for (let i = 0; i < value.length; i++) {
 		const piece = walk(value[i], i, elementMode, state);
 		if (state.buildKey) {
-			if (i) serialized += ",";
-			serialized += piece === void 0 ? "null" : piece;
+			if (i) parts.push(",");
+			parts.push(piece === void 0 ? "null" : piece);
 		}
 	}
-	return serialized + "]";
+	parts.push("]");
+	return parts.join("");
 }
 function computeSchemaMeta(schema, forceKey) {
 	const state = {
@@ -253,6 +252,7 @@ var TypeBoxValidatorCache = class TypeBoxValidatorCache {
 		this.#referenceCache = /* @__PURE__ */ new WeakMap();
 		TypeBoxValidatorCache.#lastSchema = void 0;
 		TypeBoxValidatorCache.#lastMeta = void 0;
+		TypeBoxValidatorCache.#metaCache = /* @__PURE__ */ new WeakMap();
 		require_type_coerce.deferCoercions();
 	}
 };

package/dist/type/validator/validator-cache.mjs

@@ -1,3 +1,4 @@
+// @bun
 import { isCloudflareWorker } from "../../universal/constants.mjs";
 import { evictOldestHalf, nullObject } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
@@ -74,24 +75,22 @@ function walk(value, key, mode, state) {
 }
 function walkObject(value, mode, state) {
 	const keys = Object.keys(value);
-	let serialized = "{";
-	let first = true;
+	const parts = ["{"];
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
 		const child = value[key];
 		const piece = walk(child, key, mode === CONTAINER ? NODE : mode === NODE ? childMode(key, child) : OFF, state);
 		if (piece === void 0) continue;
 		if (state.buildKey) {
-			if (first) first = false;
-			else serialized += ",";
-			serialized += quote(key) + ":" + piece;
+			if (parts.length > 1) parts.push(",");
+			parts.push(quote(key), ":", piece);
 		}
 	}
-	return serialized + "}";
+	parts.push("}");
+	return parts.join("");
 }
 function walkOptional(value, mode, state) {
-	let serialized = "{";
-	let first = true;
+	const parts = ["{"];
 	let emittedOptional = false;
 	for (const key in value) {
 		const child = value[key];
@@ -99,28 +98,29 @@ function walkOptional(value, mode, state) {
 		if (key === "~optional") emittedOptional = true;
 		if (piece === void 0) continue;
 		if (state.buildKey) {
-			if (first) first = false;
-			else serialized += ",";
-			serialized += quote(key) + ":" + piece;
+			if (parts.length > 1) parts.push(",");
+			parts.push(quote(key), ":", piece);
 		}
 	}
 	if (!emittedOptional && state.buildKey) {
-		if (!first) serialized += ",";
-		serialized += "\"~optional\":true";
+		if (parts.length > 1) parts.push(",");
+		parts.push("\"~optional\":true");
 	}
-	return serialized + "}";
+	parts.push("}");
+	return parts.join("");
 }
 function walkArray(value, mode, state) {
 	const elementMode = mode === CONTAINER ? NODE : OFF;
-	let serialized = "[";
+	const parts = ["["];
 	for (let i = 0; i < value.length; i++) {
 		const piece = walk(value[i], i, elementMode, state);
 		if (state.buildKey) {
-			if (i) serialized += ",";
-			serialized += piece === void 0 ? "null" : piece;
+			if (i) parts.push(",");
+			parts.push(piece === void 0 ? "null" : piece);
 		}
 	}
-	return serialized + "]";
+	parts.push("]");
+	return parts.join("");
 }
 function computeSchemaMeta(schema, forceKey) {
 	const state = {
@@ -252,6 +252,7 @@ var TypeBoxValidatorCache = class TypeBoxValidatorCache {
 		this.#referenceCache = /* @__PURE__ */ new WeakMap();
 		TypeBoxValidatorCache.#lastSchema = void 0;
 		TypeBoxValidatorCache.#lastMeta = void 0;
+		TypeBoxValidatorCache.#metaCache = /* @__PURE__ */ new WeakMap();
 		deferCoercions();
 	}
 };

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,22 +499,33 @@ 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
    * (`CreateEdenResponse['meta']`). Reserved key like `seed`/`detail`/
-   * `introspect` — stripped at runtime, never lands on route hooks
+   * `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
+   * `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.
+   * A `schema: 'merge'` guard's response map
+   * (`hooks.schemas[i].response`) is read-only
    *
    * @param option
    */
@@ -698,11 +709,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 +745,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 +759,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 +804,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 +849,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 +877,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 +886,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 +1018,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 +1029,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 +1098,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 +1145,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 +1256,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 {  };