elysia 2.0.0-exp.0 → 2.0.0-exp.1

package/dist/adapter/bun/index.d.ts

@@ -6,7 +6,7 @@ import { AnyElysia } from "../../base.js";
 declare function collectStaticRoutes(app: AnyElysia): readonly [Record<string, Record<string, Response>>, Promise<void>[]] | undefined;
 declare const BunAdapter: {
   parse: {
-    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<unknown[] | Record<string | number | symbol, undefined>> | Promise<ArrayBuffer> | Promise<Record<string, unknown>> | Promise<string> | undefined;
+    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<Record<string, unknown>> | Promise<ArrayBuffer> | Promise<string> | Promise<unknown[] | Record<string | number | symbol, undefined>> | undefined;
     json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
     text: (context: Context) => MaybePromise<string>;
     urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;

package/dist/adapter/bun/index.js

@@ -35,7 +35,12 @@ const BunAdapter = require_adapter_index.createAdapter({
 	name: "bun",
 	runtime: "bun",
 	listen(app, options, callback) {
-		const serve = typeof options === "object" ? options : { port: +options };
+		const _config = app["~config"]?.serve;
+		const _options = typeof options === "object" ? options : { port: +options };
+		const serve = _config ? {
+			..._config,
+			..._options
+		} : _options;
 		const hasWs = app["~hasWS"];
 		serve.fetch = (request, server) => app.fetch(request, server);
 		app.server = Bun.serve(serve);

package/dist/adapter/bun/index.mjs

@@ -34,7 +34,12 @@ const BunAdapter = createAdapter({
 	name: "bun",
 	runtime: "bun",
 	listen(app, options, callback) {
-		const serve = typeof options === "object" ? options : { port: +options };
+		const _config = app["~config"]?.serve;
+		const _options = typeof options === "object" ? options : { port: +options };
+		const serve = _config ? {
+			..._config,
+			..._options
+		} : _options;
 		const hasWs = app["~hasWS"];
 		serve.fetch = (request, server) => app.fetch(request, server);
 		app.server = Bun.serve(serve);

package/dist/adapter/constants.d.ts

@@ -5,7 +5,7 @@ import { AnyElysia } from "../base.js";
 //#region src/adapter/constants.d.ts
 declare const defaultAdapter: {
   parse: {
-    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<unknown[] | Record<string | number | symbol, undefined>> | Promise<ArrayBuffer> | Promise<Record<string, unknown>> | Promise<string> | undefined;
+    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<Record<string, unknown>> | Promise<ArrayBuffer> | Promise<string> | Promise<unknown[] | Record<string | number | symbol, undefined>> | undefined;
     json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
     text: (context: Context) => MaybePromise<string>;
     urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;

package/dist/adapter/index.d.ts

@@ -7,7 +7,7 @@ import { AnyElysia } from "../base.js";
 //#region src/adapter/index.d.ts
 declare function createAdapter(adapter: ElysiaAdapterOptions): {
   parse: {
-    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<unknown[] | Record<string | number | symbol, undefined>> | Promise<ArrayBuffer> | Promise<Record<string, unknown>> | Promise<string> | undefined;
+    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<Record<string, unknown>> | Promise<ArrayBuffer> | Promise<string> | Promise<unknown[] | Record<string | number | symbol, undefined>> | undefined;
     json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
     text: (context: Context) => MaybePromise<string>;
     urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;

package/dist/adapter/utils.js

@@ -209,7 +209,7 @@ async function* streamResponse(response) {
 function handleSet(set) {
 	if (typeof set.status === "string") set.status = require_constants.StatusMap[set.status];
 	const proto = Object.getPrototypeOf(set.headers);
-	if (proto !== null && proto !== Object.prototype) {
+	if (proto !== null && proto !== Object.prototype && !(set.headers instanceof Headers)) {
 		const flat = Object.create(null);
 		for (const key in set.headers) flat[key] = set.headers[key];
 		set.headers = flat;

package/dist/adapter/utils.mjs

@@ -208,7 +208,7 @@ async function* streamResponse(response) {
 function handleSet(set) {
 	if (typeof set.status === "string") set.status = StatusMap[set.status];
 	const proto = Object.getPrototypeOf(set.headers);
-	if (proto !== null && proto !== Object.prototype) {
+	if (proto !== null && proto !== Object.prototype && !(set.headers instanceof Headers)) {
 		const flat = Object.create(null);
 		for (const key in set.headers) flat[key] = set.headers[key];
 		set.headers = flat;

package/dist/adapter/web-standard/index.d.ts

@@ -5,7 +5,7 @@ import { AnyElysia } from "../../base.js";
 //#region src/adapter/web-standard/index.d.ts
 declare const WebStandardAdapter: {
   parse: {
-    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<unknown[] | Record<string | number | symbol, undefined>> | Promise<ArrayBuffer> | Promise<Record<string, unknown>> | Promise<string> | undefined;
+    default: (context: Context, contentType: string) => string | ArrayBuffer | unknown[] | Record<string, unknown> | Promise<Record<string, unknown>> | Promise<ArrayBuffer> | Promise<string> | Promise<unknown[] | Record<string | number | symbol, undefined>> | undefined;
     json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
     text: (context: Context) => MaybePromise<string>;
     urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;

package/dist/base.d.ts

@@ -1,7 +1,7 @@
 import { ElysiaStatus } from "./error.js";
 import { TraceHandler } from "./trace.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
-import { AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, AppEvent, BodyHandler, CompiledHandler, ComposeElysiaResponse, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GuardLocalHook, HTTPMethod, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, Macro, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, RouteSchema, SingletonBase, TransformHandler, UnhandledReturnedErrorOf, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, AppEvent, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GuardLocalHook, HTTPMethod, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, Macro, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
 import { AnySchema } from "./type/types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
@@ -11,22 +11,6 @@ import { TRef, TSchema } from "typebox";
 
 //#region src/base.d.ts
 type AnyElysia = Elysia<any, any, any, any, any, any, any, any>;
-/**
- * Shared return type for the HTTP verb methods' overloads — folds a single
- * route into the instance's Eden tree. Factored out so each verb's two
- * overloads (with-hook / no-hook) don't each re-spell the ~50-line type.
- * `Method` is a literal (`'get'`) for the verbs, or the generic method for
- * `.method()`. `MacroContext` is `{}` on the no-hook overload.
- */
-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']]>, UnhandledReturnedErrorOf<Handle, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>> }>, Ephemeral, Volatile>;
-/**
- * `AddRoute`'s WebSocket sibling — folds a `.ws()` route into the Eden tree
- * under the `subscribe` key. `Response` is `void` for the options-only form,
- * or `WSHandlerResponse<Handler>` when a positional message handler is given.
- */
-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>, {
-  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']]>>;
-}>, Ephemeral, Volatile>;
 declare class Elysia<const in out BasePath extends string = '', const in out Scope extends EventScope = 'local', const in out Singleton extends SingletonBase = DefaultSingleton, const in out Definitions extends DefinitionBase = {
   typebox: {};
   error: [];
@@ -889,7 +873,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'get', Path, Schema, MacroContext, Handle>;
   get<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'get', Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'get', Path, Schema, {}, Handle>;
   /**
    * ### post
    * Register handler for path with method [POST]
@@ -909,7 +893,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'post', Path, Schema, MacroContext, Handle>;
   post<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'post', Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'post', Path, Schema, {}, Handle>;
   /**
    * ### put
    * Register handler for path with method [PUT]
@@ -929,7 +913,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'put', Path, Schema, MacroContext, Handle>;
   put<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'put', Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'put', Path, Schema, {}, Handle>;
   /**
    * ### patch
    * Register handler for path with method [PATCH]
@@ -949,7 +933,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'patch', Path, Schema, MacroContext, Handle>;
   patch<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'patch', Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'patch', Path, Schema, {}, Handle>;
   /**
    * ### delete
    * Register handler for path with method [DELETE]
@@ -969,7 +953,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'delete', Path, Schema, MacroContext, Handle>;
   delete<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'delete', Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'delete', Path, Schema, {}, Handle>;
   /**
    * ### options
    * Register handler for path with method [OPTIONS]
@@ -989,7 +973,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'options', Path, Schema, MacroContext, Handle>;
   options<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'options', Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'options', Path, Schema, {}, Handle>;
   /**
    * ### head
    * Register handler for path with method [HEAD]
@@ -1009,13 +993,13 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'head', Path, Schema, MacroContext, Handle>;
   head<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'head', Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, 'head', Path, Schema, {}, Handle>;
   all<const Path extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', undefined extends Input['params'] ? true : false>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): this;
   all<const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(path: Path, fn: Handle): this;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(path: Path, fn: Handle & Metadata['macro']): this;
   /**
    * ### method
    * Register a handler for `path` with an arbitrary HTTP `method`
@@ -1034,7 +1018,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   }, const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const Handle extends ({} extends MacroContext ? InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> : InlineHandler<NoInfer<Schema>, NoInfer<Decorator>, MacroContext>)>(method: Method, path: Path, hook: LocalHook<Input, Schema & MacroContext, Decorator, Definitions['error'], keyof Metadata['parser']>, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Method, Path, Schema, MacroContext, Handle>;
   method<const Method extends HTTPMethod, const Path extends string, const Schema extends IntersectIfObjectSchema<MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Path>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, '', true>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>>, const Decorator extends Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
-  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>> & Metadata['macro']>(method: Method, path: Path, fn: Handle): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Method, Path, Schema, {}, Handle>;
+  }, const Handle extends InlineHandlerNonMacro<NoInfer<Schema>, NoInfer<Decorator>>>(method: Method, path: Path, fn: Handle & Metadata['macro']): AddRoute<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, Volatile, Method, Path, Schema, {}, Handle>;
   /**
    * ### ws
    * Register a WebSocket route. Mirrors `.get`/`.post` ergonomics:

package/dist/base.js

@@ -585,7 +585,7 @@ var Elysia = class Elysia {
 				const isGlobal = nodeScope === "global";
 				const added = node.added;
 				for (const key in added) {
-					if (key === "schema") {
+					if (key === "schemas") {
 						const schemas = added.schemas;
 						if (!schemas) continue;
 						const target = isGlobal ? globalEvents ??= require_utils.nullObject() : pluginEvents ??= require_utils.nullObject();
@@ -595,6 +595,7 @@ var Elysia = class Elysia {
 						}
 						continue;
 					}
+					if (key === "schema") continue;
 					if (require_utils.eventProperties.has(key)) {
 						const raw = added[key];
 						const fns = Array.isArray(raw) ? raw : [raw];

package/dist/base.mjs

@@ -582,7 +582,7 @@ var Elysia = class Elysia {
 				const isGlobal = nodeScope === "global";
 				const added = node.added;
 				for (const key in added) {
-					if (key === "schema") {
+					if (key === "schemas") {
 						const schemas = added.schemas;
 						if (!schemas) continue;
 						const target = isGlobal ? globalEvents ??= nullObject() : pluginEvents ??= nullObject();
@@ -592,6 +592,7 @@ var Elysia = class Elysia {
 						}
 						continue;
 					}
+					if (key === "schema") continue;
 					if (eventProperties.has(key)) {
 						const raw = added[key];
 						const fns = Array.isArray(raw) ? raw : [raw];

package/dist/compile/aot.d.ts

@@ -19,6 +19,7 @@ interface FrozenValidator {
   c?: FrozenCheckFactory;
   m?: FrozenMirror;
   dm?: FrozenMirror;
+  em?: FrozenMirror;
   /** Merged check + clean (present iff a slot froze BOTH; supersedes `c`/`m`). */
   cm?: FrozenBothFactory;
   /** Union branch checks for the merged mirror (entry-level `m.u`). */
@@ -83,6 +84,7 @@ declare const Source: {
 };
 declare function instantiateFrozenMirror(frozen: FrozenMirror, schema: unknown): (value: unknown) => unknown;
 declare function instantiateFrozenDecodeMirror(frozen: FrozenMirror, schema: unknown): (value: unknown) => unknown;
+declare function instantiateFrozenEncodeMirror(frozen: FrozenMirror, schema: unknown): (value: unknown) => unknown;
 declare function instantiateFrozenBoth(frozen: FrozenValidator, checkSchema: unknown, mirrorSchema: unknown): {
   check?: (value: unknown) => boolean;
   clean?: (value: unknown) => unknown;
@@ -97,7 +99,7 @@ declare function captureMirrorUnions(schema: unknown, truthUnions: any[][]): {
   identifier: string;
   code: string;
 }[][] | undefined;
-declare function captureMirrorCodecs(schema: unknown, truthCodecs: Function[]): boolean;
+declare function captureMirrorCodecs(schema: unknown, truthCodecs: Function[], dir?: 'decode' | 'encode'): boolean;
 interface CapturedMirror {
   source: string;
   hasExternals: boolean;
@@ -120,6 +122,7 @@ interface CapturedValidator {
   hasRef?: boolean;
   mirror?: CapturedMirror;
   decodeMirror?: CapturedMirror;
+  encodeMirror?: CapturedMirror;
 }
 declare function beginValidatorCapture(): void;
 declare function endValidatorCapture(): CapturedValidator[];
@@ -156,14 +159,21 @@ declare function captureDecodeMirror(v: {
   slot: ValidatorSlot;
   mirror: CapturedMirror;
 }): void;
+declare function captureEncodeMirror(v: {
+  method: string;
+  path: string;
+  slot: ValidatorSlot;
+  mirror: CapturedMirror;
+}): void;
 declare const Capture: {
   readonly validator: typeof captureValidator;
   readonly handler: typeof captureHandler;
   readonly mirror: typeof captureMirror;
   readonly mirrorDecode: typeof captureDecodeMirror;
+  readonly mirrorEncode: typeof captureEncodeMirror;
   readonly mirrorUnions: typeof captureMirrorUnions;
   readonly mirrorCodecs: typeof captureMirrorCodecs;
   readonly isCapturing: () => boolean;
 };
 //#endregion
-export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenMirror, reconstructCheck };
+export { Capture, CapturedHandler, CapturedMirror, CapturedValidator, CheckBuildResult, Compiled, FrozenBothFactory, FrozenCheckFactory, FrozenHandler, FrozenMirror, FrozenMirrorFactory, FrozenValidator, HandlerManifest, Source, ValidatorManifest, ValidatorSlot, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck };

package/dist/compile/aot.js

@@ -148,15 +148,14 @@ function collectMirrorUnions(schema, out = []) {
 	}
 	return out;
 }
-const CODEC = "~codec";
-function collectMirrorCodecs(schema, out = []) {
+function collectMirrorCodecs(schema, out = [], dir = "decode") {
 	if (!schema || typeof schema !== "object") return out;
-	const codec = schema[CODEC];
-	if (codec && typeof codec.decode === "function" && out.indexOf(codec.decode) === -1) out.push(codec.decode);
-	if (schema.type === "object" && schema.properties) for (const key in schema.properties) collectMirrorCodecs(schema.properties[key], out);
-	else if (schema.type === "array" && schema.items) if (Array.isArray(schema.items)) for (const it of schema.items) collectMirrorCodecs(it, out);
-	else collectMirrorCodecs(schema.items, out);
-	else if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectMirrorCodecs(b, out);
+	const codec = schema["~codec"];
+	if (codec && typeof codec[dir] === "function" && out.indexOf(codec[dir]) === -1) out.push(codec[dir]);
+	if (schema.type === "object" && schema.properties) for (const key in schema.properties) collectMirrorCodecs(schema.properties[key], out, dir);
+	else if (schema.type === "array" && schema.items) if (Array.isArray(schema.items)) for (const it of schema.items) collectMirrorCodecs(it, out, dir);
+	else collectMirrorCodecs(schema.items, out, dir);
+	else if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectMirrorCodecs(b, out, dir);
 	return out;
 }
 function buildUnions(u, schema) {
@@ -172,6 +171,11 @@ function instantiateFrozenDecodeMirror(frozen, schema) {
 	if (frozen.u) d.unions = buildUnions(frozen.u, schema);
 	return frozen.s(d);
 }
+function instantiateFrozenEncodeMirror(frozen, schema) {
+	const d = { codecs: collectMirrorCodecs(schema, [], "encode") };
+	if (frozen.u) d.unions = buildUnions(frozen.u, schema);
+	return frozen.s(d);
+}
 const EMPTY_EXTERNALS = [];
 function instantiateFrozenBoth(frozen, checkSchema, mirrorSchema) {
 	return frozen.cm(frozen.e ? collectExternals(checkSchema) : EMPTY_EXTERNALS, frozen.u ? { unions: buildUnions(frozen.u, mirrorSchema) } : void 0);
@@ -202,8 +206,8 @@ function captureMirrorUnions(schema, truthUnions) {
 	}
 	return u;
 }
-function captureMirrorCodecs(schema, truthCodecs) {
-	const codecs = collectMirrorCodecs(schema);
+function captureMirrorCodecs(schema, truthCodecs, dir = "decode") {
+	const codecs = collectMirrorCodecs(schema, [], dir);
 	if (codecs.length !== truthCodecs.length) return false;
 	for (let i = 0; i < codecs.length; i++) if (codecs[i] !== truthCodecs[i]) return false;
 	return true;
@@ -261,12 +265,17 @@ function captureDecodeMirror(v) {
 	const e = captureEntry(v);
 	if (e) e.decodeMirror = v.mirror;
 }
+function captureEncodeMirror(v) {
+	const e = captureEntry(v);
+	if (e) e.encodeMirror = v.mirror;
+}
 const isValidatorCapturing = () => capture !== void 0 || require_universal_env.env.ELYSIA_AOT_BUILD === "1";
 const Capture = {
 	validator: captureValidator,
 	handler: captureHandler,
 	mirror: captureMirror,
 	mirrorDecode: captureDecodeMirror,
+	mirrorEncode: captureEncodeMirror,
 	mirrorUnions: captureMirrorUnions,
 	mirrorCodecs: captureMirrorCodecs,
 	isCapturing: isValidatorCapturing
@@ -283,5 +292,6 @@ exports.endValidatorCapture = endValidatorCapture;
 exports.externalsMatch = externalsMatch;
 exports.instantiateFrozenBoth = instantiateFrozenBoth;
 exports.instantiateFrozenDecodeMirror = instantiateFrozenDecodeMirror;
+exports.instantiateFrozenEncodeMirror = instantiateFrozenEncodeMirror;
 exports.instantiateFrozenMirror = instantiateFrozenMirror;
 exports.reconstructCheck = reconstructCheck;

package/dist/compile/aot.mjs

@@ -147,15 +147,14 @@ function collectMirrorUnions(schema, out = []) {
 	}
 	return out;
 }
-const CODEC = "~codec";
-function collectMirrorCodecs(schema, out = []) {
+function collectMirrorCodecs(schema, out = [], dir = "decode") {
 	if (!schema || typeof schema !== "object") return out;
-	const codec = schema[CODEC];
-	if (codec && typeof codec.decode === "function" && out.indexOf(codec.decode) === -1) out.push(codec.decode);
-	if (schema.type === "object" && schema.properties) for (const key in schema.properties) collectMirrorCodecs(schema.properties[key], out);
-	else if (schema.type === "array" && schema.items) if (Array.isArray(schema.items)) for (const it of schema.items) collectMirrorCodecs(it, out);
-	else collectMirrorCodecs(schema.items, out);
-	else if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectMirrorCodecs(b, out);
+	const codec = schema["~codec"];
+	if (codec && typeof codec[dir] === "function" && out.indexOf(codec[dir]) === -1) out.push(codec[dir]);
+	if (schema.type === "object" && schema.properties) for (const key in schema.properties) collectMirrorCodecs(schema.properties[key], out, dir);
+	else if (schema.type === "array" && schema.items) if (Array.isArray(schema.items)) for (const it of schema.items) collectMirrorCodecs(it, out, dir);
+	else collectMirrorCodecs(schema.items, out, dir);
+	else if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectMirrorCodecs(b, out, dir);
 	return out;
 }
 function buildUnions(u, schema) {
@@ -171,6 +170,11 @@ function instantiateFrozenDecodeMirror(frozen, schema) {
 	if (frozen.u) d.unions = buildUnions(frozen.u, schema);
 	return frozen.s(d);
 }
+function instantiateFrozenEncodeMirror(frozen, schema) {
+	const d = { codecs: collectMirrorCodecs(schema, [], "encode") };
+	if (frozen.u) d.unions = buildUnions(frozen.u, schema);
+	return frozen.s(d);
+}
 const EMPTY_EXTERNALS = [];
 function instantiateFrozenBoth(frozen, checkSchema, mirrorSchema) {
 	return frozen.cm(frozen.e ? collectExternals(checkSchema) : EMPTY_EXTERNALS, frozen.u ? { unions: buildUnions(frozen.u, mirrorSchema) } : void 0);
@@ -201,8 +205,8 @@ function captureMirrorUnions(schema, truthUnions) {
 	}
 	return u;
 }
-function captureMirrorCodecs(schema, truthCodecs) {
-	const codecs = collectMirrorCodecs(schema);
+function captureMirrorCodecs(schema, truthCodecs, dir = "decode") {
+	const codecs = collectMirrorCodecs(schema, [], dir);
 	if (codecs.length !== truthCodecs.length) return false;
 	for (let i = 0; i < codecs.length; i++) if (codecs[i] !== truthCodecs[i]) return false;
 	return true;
@@ -260,16 +264,21 @@ function captureDecodeMirror(v) {
 	const e = captureEntry(v);
 	if (e) e.decodeMirror = v.mirror;
 }
+function captureEncodeMirror(v) {
+	const e = captureEntry(v);
+	if (e) e.encodeMirror = v.mirror;
+}
 const isValidatorCapturing = () => capture !== void 0 || env.ELYSIA_AOT_BUILD === "1";
 const Capture = {
 	validator: captureValidator,
 	handler: captureHandler,
 	mirror: captureMirror,
 	mirrorDecode: captureDecodeMirror,
+	mirrorEncode: captureEncodeMirror,
 	mirrorUnions: captureMirrorUnions,
 	mirrorCodecs: captureMirrorCodecs,
 	isCapturing: isValidatorCapturing
 };
 
 //#endregion
-export { Capture, Compiled, Source, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenMirror, reconstructCheck };
+export { Capture, Compiled, Source, beginValidatorCapture, collectExternals, endHandlerCapture, endValidatorCapture, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenEncodeMirror, instantiateFrozenMirror, reconstructCheck };

package/dist/compile/handler/index.js

@@ -97,15 +97,13 @@ function parse(adapter, parsers, bodyVali, hasHeaders, link, report) {
 }
 const isAsyncValidator = (vali) => vali?.isAsync ?? true;
 function applyHook(localHook, appHook, rootHook) {
-	if (!localHook) {
-		if (rootHook) return require_utils.mergeHook(require_utils.cloneHook(appHook ?? require_utils.nullObject()), rootHook, true, true);
-		return appHook;
+	let hook;
+	if (localHook && appHook) hook = require_utils.mergeHook(require_utils.cloneHook(localHook), appHook, true);
+	else {
+		const base = localHook ?? appHook;
+		if (!rootHook) return base;
+		hook = require_utils.cloneHook(base ?? require_utils.nullObject());
 	}
-	if (!appHook) {
-		if (rootHook) return require_utils.mergeHook(require_utils.cloneHook(localHook), rootHook, true, true);
-		return localHook;
-	}
-	const hook = require_utils.mergeHook(require_utils.cloneHook(localHook), appHook, true);
 	if (rootHook) require_utils.mergeHook(hook, rootHook, true, true);
 	return hook;
 }
@@ -216,6 +214,9 @@ function buildNativeStaticResponse([, , handler, instance, localHook, appHook, i
 	if (mapped instanceof Response) return mapped;
 	if (mapped instanceof Promise) return mapped;
 }
+function toArray(name, hook) {
+	if (typeof hook[name] === "function") hook[name] = [hook[name]];
+}
 function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain], root, precomputedStatic) {
 	const adapter = root["~config"]?.adapter ?? require_adapter_constants.defaultAdapter;
 	if (root["~ext"]?.macro) {
@@ -246,11 +247,13 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 	}
 	if (hook) {
 		promoteDerive(hook);
-		for (const key in hook) {
-			if (!require_utils.eventProperties.has(key)) continue;
-			const v = hook[key];
-			if (typeof v === "function") hook[key] = [v];
-		}
+		toArray("parse", hook);
+		toArray("transform", hook);
+		toArray("beforeHandle", hook);
+		toArray("afterHandle", hook);
+		toArray("mapResponse", hook);
+		toArray("afterResponse", hook);
+		toArray("error", hook);
 	}
 	const method = require_utils.mapMethodBack(_method);
 	const vali = hook ? new require_validator_route.RouteValidator(hook, {
@@ -359,8 +362,9 @@ function compileHandler([_method, path, handler, instance, localHook, appHook, i
 	const responseValiAsync = !!(vali?.response && Object.values(vali.response).find(isAsyncValidator));
 	const handlerIsAsync = isHandleFunction && require_compile_utils.isAsyncFunction(handler);
 	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator);
+	const responseValiForcesAsync = hasResponseValidator && isHandleFunction && !handlerIsAsync && require_compile_utils.mayReturnPromise(handler);
 	const afterResponseForcesAsync = hasAfterResponse && (require_compile_utils.isAsyncLifecycle(hook?.afterResponse) || hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
-	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || afterResponseForcesAsync || hasTrace || hasCookieSign || responseValiAsync || hook && (!!require_compile_utils.isAsyncLifecycle(hook?.afterHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.beforeHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.transform) || !!require_compile_utils.isAsyncLifecycle(hook?.mapResponse) || !!require_compile_utils.isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
+	const isAsync = hasBody || handlerIsAsync || errorHookForcesAsync || responseValiForcesAsync || afterResponseForcesAsync || hasTrace || hasCookieSign || responseValiAsync || hook && (!!require_compile_utils.isAsyncLifecycle(hook?.afterHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.beforeHandle) || !!require_compile_utils.isAsyncLifecycle(hook?.transform) || !!require_compile_utils.isAsyncLifecycle(hook?.mapResponse) || !!require_compile_utils.isAsyncLifecycle(hook?.error) || bodyValiIsAsync || headersValiIsAsync || paramsValiIsAsync || queryValiIsAsync || cookieValidIsAsync);
 	const callHandlerSyncOnAsync = isAsync && isHandleFunction && !handlerIsAsync;
 	const syncErrorHook = hasErrorHook && !isAsync && !hasTrace;
 	const syncAfterResponse = hasAfterResponse && !isAsync && !hasTrace && !hasErrorHook;
@@ -543,11 +547,13 @@ return tee(_r,${teeCount}).then((_s)=>_fin2(c,_s[0],_s[1]))\n}\nreturn _fin2(c,_
 				const awaitStr = responseValiAsync ? "await " : "";
 				code += `if(_r instanceof es){
 const _vr=va.response[_r.code]
-if(_vr)_r.response=${awaitStr}_vr.EncodeFrom(_r.response,'response')\n}else if(!(_r instanceof Response)&&typeof _r?.next!=='function'){\nconst _vr=va.response[c.set.status??200]\nif(_vr)_r=${awaitStr}_vr.EncodeFrom(_r,'response')\n}\n`;
+if(_vr)_r.response=${awaitStr}_vr.EncodeFrom(_r.response,'response')\n}else if(!(_r instanceof Response)&&!(_r instanceof ReadableStream)&&typeof _r?.next!=='function'){\nconst _vr=va.response[c.set.status??200]\nif(_vr)_r=${awaitStr}_vr.EncodeFrom(_r,'response')\n}\n`;
 			}
 			code += schedule;
 			code += signPrefix;
-			code += `return ${hasSet ? `${map}(_r,c.set,c.request)` : `${map}(_r,c.request)`}\n`;
+			const finalMap = hasSet ? `${map}(_r,c.set,c.request)` : `${map}(_r,c.request)`;
+			if (syncErrorHook) code += `if(_r instanceof Promise)return ${finalMap}.catch((_e)=>_ce(_e,c))\n`;
+			code += `return ${finalMap}\n`;
 		}
 	} else if (isHandleFunction) {
 		if (!isAsync) link(require_handler_utils.forwardError, "fe");