elysia 2.0.0-exp.0 → 2.0.0-exp.2

package/dist/_virtual/_rolldown/runtime.js

@@ -32,7 +32,6 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
@@ -41,5 +40,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 
 exports.__exportAll = __exportAll;
-exports.__reExport = __reExport;
 exports.__toESM = __toESM;

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 | unknown[] | ArrayBuffer | 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/bun/router.js

@@ -62,13 +62,13 @@ function createPlainHandler(handler, handleError, Context) {
 }
 function createRouteMap(app) {
 	const Context = createBunContext(app);
+	const handleError = require_handler_error.createErrorHandler(require_utils.flattenChain(app["~hookChain"])?.error, require_adapter_web_standard_index.WebStandardAdapter.response.map, new Response("Not Found", { status: 404 }), app["~config"]?.allowUnsafeValidationDetails);
 	function fetch(request) {
 		return handleError(new Context(request), new require_error.NotFound());
 	}
 	const history = app.history;
 	const length = history?.length ?? 0;
 	if (length === 0) return [{ "/elysia": new Response("hi") }, fetch];
-	const handleError = require_handler_error.createErrorHandler(require_utils.flattenChain(app["~hookChain"])?.error, require_adapter_web_standard_index.WebStandardAdapter.response.map, new Response("Not Found", { status: 404 }), app["~config"]?.allowUnsafeValidationDetails);
 	const routes = require_utils.nullObject();
 	for (let i = 0; i < length; i++) {
 		const route = history[i];

package/dist/adapter/bun/router.mjs

@@ -61,13 +61,13 @@ function createPlainHandler(handler, handleError, Context) {
 }
 function createRouteMap(app) {
 	const Context = createBunContext(app);
+	const handleError = createErrorHandler(flattenChain(app["~hookChain"])?.error, WebStandardAdapter.response.map, new Response("Not Found", { status: 404 }), app["~config"]?.allowUnsafeValidationDetails);
 	function fetch(request) {
 		return handleError(new Context(request), new NotFound());
 	}
 	const history = app.history;
 	const length = history?.length ?? 0;
 	if (length === 0) return [{ "/elysia": new Response("hi") }, fetch];
-	const handleError = createErrorHandler(flattenChain(app["~hookChain"])?.error, WebStandardAdapter.response.map, new Response("Not Found", { status: 404 }), app["~config"]?.allowUnsafeValidationDetails);
 	const routes = nullObject();
 	for (let i = 0; i < length; i++) {
 		const route = history[i];

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 | unknown[] | ArrayBuffer | 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 | unknown[] | ArrayBuffer | 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.d.ts

@@ -12,7 +12,7 @@ declare function responseToSetHeaders(response: Response, set?: Context['set']):
   cookie?: Record<string, BaseCookie>;
 } | {
   headers: any;
-  status: number | "Bad Request" | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
+  status: number | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
 };
 interface CreateHandlerParameter {
   mapResponse(response: unknown, set: Context['set'], request?: Request): Response;

package/dist/adapter/utils.js

@@ -51,7 +51,7 @@ function handleFile(response, set, request) {
 	if (!set && !size) return new Response(response);
 	if (!set) return new Response(response, { headers: defaultHeader });
 	if (set.headers instanceof Headers) {
-		for (const key of Object.keys(defaultHeader)) if (key in set.headers) set.headers.append(key, defaultHeader[key]);
+		for (const key of Object.keys(defaultHeader)) if (!set.headers.has(key)) set.headers.append(key, defaultHeader[key]);
 		if (immutable) {
 			set.headers.delete("content-length");
 			set.headers.delete("accept-ranges");
@@ -96,7 +96,9 @@ function responseToSetHeaders(response, set) {
 		};
 		for (const [key, value] of response.headers.entries()) set.headers[key] = value;
 	}
-	if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
+	if (set.headers instanceof Headers) {
+		if (set.headers.has("content-encoding")) set.headers.delete("content-encoding");
+	} else if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
 	return set;
 }
 const enqueueBinaryChunk = (controller, chunk) => {
@@ -209,7 +211,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

@@ -50,7 +50,7 @@ function handleFile(response, set, request) {
 	if (!set && !size) return new Response(response);
 	if (!set) return new Response(response, { headers: defaultHeader });
 	if (set.headers instanceof Headers) {
-		for (const key of Object.keys(defaultHeader)) if (key in set.headers) set.headers.append(key, defaultHeader[key]);
+		for (const key of Object.keys(defaultHeader)) if (!set.headers.has(key)) set.headers.append(key, defaultHeader[key]);
 		if (immutable) {
 			set.headers.delete("content-length");
 			set.headers.delete("accept-ranges");
@@ -95,7 +95,9 @@ function responseToSetHeaders(response, set) {
 		};
 		for (const [key, value] of response.headers.entries()) set.headers[key] = value;
 	}
-	if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
+	if (set.headers instanceof Headers) {
+		if (set.headers.has("content-encoding")) set.headers.delete("content-encoding");
+	} else if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
 	return set;
 }
 const enqueueBinaryChunk = (controller, chunk) => {
@@ -208,7 +210,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 | unknown[] | ArrayBuffer | 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

@@ -14,6 +14,22 @@ memoirist = require_runtime.__toESM(memoirist);
 
 //#region src/base.ts
 const useNodesBuffer = [];
+const isPlainObject = (v) => {
+	if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+};
+function clonePlainDecorators(source, seen = /* @__PURE__ */ new WeakMap()) {
+	const existing = seen.get(source);
+	if (existing) return existing;
+	const out = require_utils.nullObject();
+	seen.set(source, out);
+	for (const key in source) {
+		const value = source[key];
+		out[key] = isPlainObject(value) ? clonePlainDecorators(value, seen) : value;
+	}
+	return out;
+}
 var Elysia = class Elysia {
 	#hasPlugin = false;
 	#hasGlobal = false;
@@ -31,7 +47,7 @@ var Elysia = class Elysia {
 		}
 	}
 	get history() {
-		if (!this.#history) return void 0;
+		if (!this.#history) return;
 		this.#resolveMacros();
 		return this.#history;
 	}
@@ -47,9 +63,8 @@ var Elysia = class Elysia {
 		if (!this.#history) return [];
 		if (this.#cachedRoutes) return this.#cachedRoutes;
 		this.#resolveMacros();
-		const routes = this.#history.map(([method, path, handler, , hook, appHook]) => {
-			const flatAppHook = require_utils.flattenChain(appHook);
-			const merged = flatAppHook ? hook ? require_utils.mergeHook(require_utils.cloneHook(hook), flatAppHook) : flatAppHook : hook;
+		const routes = this.#history.map(([method, path, handler, instance, hook, appHook, inheritedChain]) => {
+			const merged = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, this);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
 				if (!entry?.response) continue;
 				merged.response = require_utils.mergeResponse(merged.response, entry.response);
@@ -138,7 +153,7 @@ var Elysia = class Elysia {
 	headers(headers) {
 		const ext = this.#ext;
 		if (ext.headers) Object.assign(ext.headers, headers);
-		else ext.headers = headers;
+		else ext.headers = Object.assign(require_utils.nullObject(), headers);
 		return this;
 	}
 	#on(type, fn, scope = this["~config"]?.as) {
@@ -293,7 +308,8 @@ var Elysia = class Elysia {
 		require_utils.hookToGuard(hook);
 		if (hook.derive) {
 			this["~derive"] ??= /* @__PURE__ */ new WeakSet();
-			this["~derive"].add(hook.derive);
+			if (Array.isArray(hook.derive)) for (const fn of hook.derive) this["~derive"].add(fn);
+			else this["~derive"].add(hook.derive);
 		}
 		const trackFn = (fn) => {
 			if (typeof fn !== "function") return;
@@ -355,7 +371,8 @@ var Elysia = class Elysia {
 		if (hook.derive) {
 			const promoted = require_utils.nullObject();
 			for (const key of Object.keys(hook)) {
-				if (!require_utils.eventProperties.has(key)) continue;
+				if (key === "derive" || key === "resolve") continue;
+				if (!require_utils.eventProperties.has(key) && !require_utils.schemaProperties.has(key) && key !== "schema" && key !== "schemas") continue;
 				promoted[key] = hook[key];
 			}
 			const extras = [];
@@ -542,8 +559,11 @@ var Elysia = class Elysia {
 		if (app["~ext"]) {
 			const { decorator, store, headers, models, parser, macro, error, hoc } = app["~ext"];
 			const ext = this["~ext"] ??= require_utils.nullObject();
-			if (decorator) if (ext.decorator) require_utils.mergeDeep(ext.decorator, decorator);
-			else ext.decorator = Object.assign(require_utils.nullObject(), decorator);
+			if (decorator) {
+				const cloned = clonePlainDecorators(decorator);
+				if (ext.decorator) require_utils.mergeDeep(ext.decorator, cloned);
+				else ext.decorator = Object.assign(require_utils.nullObject(), cloned);
+			}
 			if (store) if (ext.store) require_utils.mergeDeep(ext.store, store);
 			else ext.store = Object.assign(require_utils.nullObject(), store);
 			if (headers) if (ext.headers) Object.assign(ext.headers, headers);
@@ -585,7 +605,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 +615,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];
@@ -773,7 +794,7 @@ var Elysia = class Elysia {
 		if (!adapter?.websocket && !require_universal_constants.isBun) throw new Error(`[Elysia] WebSocket is not supported on '${adapter?.name ?? "web-standard"}' adapter.`);
 		let opts;
 		if (handler !== void 0) {
-			opts = optionsOrHandler ?? require_utils.nullObject();
+			opts = Object.assign(require_utils.nullObject(), optionsOrHandler);
 			if (opts.message != null && opts.message !== handler) throw new Error("[Elysia] .ws(): cannot specify 'message' as both positional handler and options.message");
 			opts.message = handler;
 		} else if (typeof optionsOrHandler === "function") {
@@ -891,6 +912,22 @@ var Elysia = class Elysia {
 		}
 		const wrapHeadHandler = Elysia.#wrapHeadHandler;
 		const strict = !!this["~config"]?.strictPath;
+		let explicitPaths;
+		if (!strict) {
+			explicitPaths = /* @__PURE__ */ new Map();
+			for (let i = 0; i < length; i++) {
+				const route = this.#history[i];
+				const m = route[0] === "WS" ? "WS" : require_utils.mapMethodBack(route[0]);
+				const p = route[1];
+				let set = explicitPaths.get(m);
+				if (!set) explicitPaths.set(m, set = /* @__PURE__ */ new Set());
+				set.add(p);
+				if (require_constants.needEncodeRegex.test(p)) {
+					const encoded = encodeURI(p);
+					if (encoded !== p) set.add(encoded);
+				}
+			}
+		}
 		for (let i = 0; i < length; i++) {
 			const route = this.#history[i];
 			const method = require_utils.mapMethodBack(route[0]);
@@ -906,7 +943,7 @@ var Elysia = class Elysia {
 					wsMap[path] = handler;
 					if (!this["~config"]?.strictPath) {
 						const loose = require_utils.getLoosePath(path);
-						if (loose !== path) wsMap[loose] = handler;
+						if (loose !== path && !explicitPaths?.get("WS")?.has(loose)) wsMap[loose] = handler;
 					}
 				}
 				if (options && require_utils.isNotEmpty(options)) {
@@ -932,19 +969,20 @@ var Elysia = class Elysia {
 					(target[path] ??= require_utils.nullObject())[method] = staticResponse;
 					if (!this["~config"]?.strictPath) {
 						const loose = require_utils.getLoosePath(path);
-						(target[loose] ??= require_utils.nullObject())[method] = staticResponse;
+						if (!explicitPaths?.get(method)?.has(loose)) (target[loose] ??= require_utils.nullObject())[method] = staticResponse;
 					}
 				}
 			}
 			const sharedStatic = maybeStatic && staticResponse instanceof Response ? staticResponse : void 0;
 			const autoHead = enableAutoHead && method === "GET" && !explicitHead?.has(path);
-			const registerPattern = (registerMain, registerHead, handler, headHandler) => {
+			const registerPattern = (registerMain, registerHead, handler, headHandler, registerLoose) => {
+				const explicitMain = explicitPaths?.get(method);
 				const add = (p) => {
 					registerMain(p, handler);
 					if (headHandler) registerHead(p, headHandler);
-					if (!strict) {
+					if (registerLoose) {
 						const loose = require_utils.getLoosePath(p);
-						if (loose !== p) {
+						if (loose !== p && !explicitMain?.has(loose)) {
 							registerMain(loose, handler);
 							if (headHandler) registerHead(loose, headHandler);
 						}
@@ -959,7 +997,7 @@ var Elysia = class Elysia {
 			if (require_constants.isDynamicRegex.test(path)) {
 				const router = this["~router"] ??= new memoirist.default();
 				const handler = this.handler(i, precompile, void 0, sharedStatic);
-				registerPattern((p, h) => router.add(method, p, h, false), (p, h) => router.add("HEAD", p, h, false), handler, autoHead ? wrapHeadHandler(handler) : void 0);
+				registerPattern((p, h) => router.add(method, p, h, false), (p, h) => router.add("HEAD", p, h, false), handler, autoHead ? wrapHeadHandler(handler) : void 0, false);
 			} else {
 				const map = methods[method] ??= require_utils.nullObject();
 				const handler = this.handler(i, precompile, route, sharedStatic);
@@ -969,7 +1007,7 @@ var Elysia = class Elysia {
 					map[p] = h;
 				}, (p, h) => {
 					head[p] = h;
-				}, handler, headHandler);
+				}, handler, headHandler, !strict);
 			}
 		}
 	}