elysia 2.0.0-exp.60 → 2.0.0-exp.62

package/dist/adapter/utils.d.ts

@@ -1,6 +1,6 @@
 import { BaseCookie } from "../cookie/types.js";
-import { StatusMap } from "../constants.js";
 import { ElysiaFile } from "../universal/file.js";
+import { StatusMap } from "../constants.js";
 import { HTTPHeaders } from "../types.js";
 import { Context } from "../context.js";
 //#region src/adapter/utils.d.ts

package/dist/adapter/web-standard/handler.js

@@ -21,20 +21,24 @@ function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, r
 	});
 	return require_adapter_utils.handleFile(file.value, set, request);
 }
+function responseTag(response) {
+	if (response == null) return;
+	return Object.getPrototypeOf(response)?.constructor?.name;
+}
 function mapResponseWithSet(response, set, request, owned) {
 	require_adapter_utils.handleSet(set);
 	const headers = set.headers;
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String":
 			if (!require_universal_constants.isBun && !headers["content-type"]) require_adapter_utils.materializeSetHeaders(set)["content-type"] = "text/plain";
 			return new Response(response, set);
 		case "Array": return Response.json(response, set);
+		case "ElysiaForm": return new Response(require_utils.formToFormData(response), set);
 		case "Object":
-			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response), set);
 			if (typeof response?.next === "function") return handleStream(response, set, request, void 0, owned);
 			return Response.json(response, set);
 		case "Number":
-		case "Boolean": return new Response(response.toString(), set);
+		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString(), set);
 		case "ElysiaFile": return handleElysiaFile(response, set, request);
 		case "File":
 		case "Blob": return require_adapter_utils.handleFile(response, set, request);
@@ -66,14 +70,13 @@ function mapResponse(response, set, request, owned) {
 }
 const textHeaders = require_universal_constants.isBun ? void 0 : textPlainInit;
 function mapCompactResponse(response, request, owned) {
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
-		case "Object":
-			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response));
-			return Response.json(response);
+		case "ElysiaForm": return new Response(require_utils.formToFormData(response));
+		case "Object": return Response.json(response);
 		case "Number":
-		case "Boolean": return new Response(response.toString());
+		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString());
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
 		case "File":
 		case "Blob": return require_adapter_utils.handleFile(response, void 0, request);
@@ -126,11 +129,12 @@ function mapFallback(response, set, request, owned = false) {
 		headers: response.headers ? { ...response.headers } : {}
 	}, request, owned);
 	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, void 0, request);
+	if (require_utils.isElysiaForm(response)) return new Response(require_utils.formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
 	if (Array.isArray(response)) return Response.json(response);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
-	if (response?.constructor?.name === "Cookie" && response.jar) return new Response(response.value, set);
+	if (responseTag(response) === "Cookie") return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);
 }
 const handleResponse = require_adapter_utils.createResponseHandler({

package/dist/adapter/web-standard/handler.mjs

@@ -1,6 +1,6 @@
 import { isBun } from "../../universal/constants.mjs";
 import { ElysiaFile, mime } from "../../universal/file.mjs";
-import { formToFormData, isNotEmpty, nullObject } from "../../utils.mjs";
+import { formToFormData, isElysiaForm, isNotEmpty, nullObject } from "../../utils.mjs";
 import { ElysiaStatus, PROBLEM_JSON, internalServerErrorBody } from "../../error.mjs";
 import { defaultHeaders } from "../default-headers.mjs";
 import { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders } from "../utils.mjs";
@@ -20,20 +20,24 @@ function handleElysiaFile(file, set = { headers: nullObject() }, request) {
 	});
 	return handleFile(file.value, set, request);
 }
+function responseTag(response) {
+	if (response == null) return;
+	return Object.getPrototypeOf(response)?.constructor?.name;
+}
 function mapResponseWithSet(response, set, request, owned) {
 	handleSet(set);
 	const headers = set.headers;
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String":
 			if (!isBun && !headers["content-type"]) materializeSetHeaders(set)["content-type"] = "text/plain";
 			return new Response(response, set);
 		case "Array": return Response.json(response, set);
+		case "ElysiaForm": return new Response(formToFormData(response), set);
 		case "Object":
-			if (response["~ely-form"]) return new Response(formToFormData(response), set);
 			if (typeof response?.next === "function") return handleStream(response, set, request, void 0, owned);
 			return Response.json(response, set);
 		case "Number":
-		case "Boolean": return new Response(response.toString(), set);
+		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString(), set);
 		case "ElysiaFile": return handleElysiaFile(response, set, request);
 		case "File":
 		case "Blob": return handleFile(response, set, request);
@@ -65,14 +69,13 @@ function mapResponse(response, set, request, owned) {
 }
 const textHeaders = isBun ? void 0 : textPlainInit;
 function mapCompactResponse(response, request, owned) {
-	switch (response?.constructor?.name) {
+	switch (responseTag(response)) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
-		case "Object":
-			if (response["~ely-form"]) return new Response(formToFormData(response));
-			return Response.json(response);
+		case "ElysiaForm": return new Response(formToFormData(response));
+		case "Object": return Response.json(response);
 		case "Number":
-		case "Boolean": return new Response(response.toString());
+		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString());
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
 		case "File":
 		case "Blob": return handleFile(response, void 0, request);
@@ -125,11 +128,12 @@ function mapFallback(response, set, request, owned = false) {
 		headers: response.headers ? { ...response.headers } : {}
 	}, request, owned);
 	if (response instanceof ElysiaFile) return handleElysiaFile(response, void 0, request);
+	if (isElysiaForm(response)) return new Response(formToFormData(response), set);
 	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
 	if (Array.isArray(response)) return Response.json(response);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
-	if (response?.constructor?.name === "Cookie" && response.jar) return new Response(response.value, set);
+	if (responseTag(response) === "Cookie") return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);
 }
 const handleResponse = createResponseHandler({

package/dist/base.d.ts

@@ -1,8 +1,8 @@
-import { ElysiaStatus } from "./error.js";
 import { TraceCapability, TraceHandler } from "./trace.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
-import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
 import { ChainNode } from "./utils.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GlobalHookReturn, GracefulHandler, GuardHookSingleton, GuardLocalHook, HTTPMethod, HistoryEntry, HookContextSchema, HookContextSingleton, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, LocalHookReturn, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PluginHookReturn, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, ScopedHookReturn, ScopedMapDeriveReturn, SingletonBase, StaticMapAliases, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { ElysiaStatus } from "./error.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { AnySchema } from "./type/types.js";
 import { AotFingerprint, CompilerSession, ProgramId } from "./compile/aot.js";
@@ -391,7 +391,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    * them with `.use()` instead.
    */
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    schema: 'standalone';
+    schema: 'merge';
   }): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, {
     derive: Volatile['derive'] & MacroContext['resolve'];
     schema: Volatile['schema'];
@@ -407,7 +407,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     error: Volatile['error'];
   }>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    schema: 'standalone';
+    schema: 'merge';
   }, run: (group: Elysia<BasePath, Scope, {
     decorator: Singleton['decorator'];
     store: Singleton['store'];
@@ -433,7 +433,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: Metadata['response'] & MacroContext['response'] & ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle>;
   }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'local', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    schema: 'standalone';
+    schema: 'merge';
   }): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, Ephemeral, {
     derive: Volatile['derive'] & MacroContext['resolve'];
     schema: Volatile['schema'];
@@ -449,7 +449,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     error: Volatile['error'];
   }>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'plugin', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    schema: 'standalone';
+    schema: 'merge';
   }): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, {
     derive: Ephemeral['derive'] & MacroContext['resolve'];
     schema: Ephemeral['schema'];
@@ -465,7 +465,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     error: Ephemeral['error'];
   }, Volatile>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>>(scope: 'global', hook: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    schema: 'standalone';
+    schema: 'merge';
   }): Elysia<BasePath, Scope, {
     decorator: Singleton['decorator'];
     store: Singleton['store'];
@@ -499,7 +499,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     response: Metadata['response'];
   }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
   group<const Prefix extends string, const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Prefix>>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>>>, const NewElysia extends AnyElysia>(prefix: Prefix, schema: GuardLocalHook<Input, Schema & MacroContext, GuardHookSingleton<Singleton, Ephemeral, Volatile, MacroContext>, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    schema: 'standalone';
+    schema: 'merge';
   }, run: (group: Elysia<JoinPath<BasePath, Prefix>, Scope, {
     decorator: Singleton['decorator'];
     store: Singleton['store'];
@@ -559,7 +559,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'];
     response: Metadata['response'];
   }, Routes, Ephemeral, Volatile>;
-  '~applyMacro'(input: Partial<AnyLocalHook>, toApply?: Partial<AnyLocalHook>, iteration?: number, seen?: Set<string | Partial<any>>): Partial<AnyLocalHook>;
+  '~applyMacro'(input: Partial<AnyLocalHook>, toApply?: Partial<AnyLocalHook>, iteration?: number, seen?: Set<string | Partial<any>>, insertions?: Map<string, number>): Partial<AnyLocalHook>;
   /**
    * Merge a plugin instance
    */
@@ -869,6 +869,21 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   get fetch(): (request: Request, ...rest: any[]) => MaybePromise<Response>;
   get handle(): (url: string | Request, options?: RequestInit) => Promise<Response>;
   listen(options: string | number | Partial<Serve>, callback?: ListenCallback): this;
+  /**
+   * Add a higher order function over Elysia.fetch
+   *
+   * @example
+   * ```ts
+   * const ctx = new AsyncLocalStorage<{ counter: number }>()
+   *
+   * new Elysia()
+   *	.wrap(
+   *		(fetch) => (request) =>
+   *			ctx.run({ counter: 0 }, () => fetch(request))
+   *	)
+   *	.get('/', () => ctx.getStore())
+   * ```
+   */
   wrap<T extends (...params: any) => MaybePromise<Response> = (request: Request, ...rest: any[]) => MaybePromise<Response>>(callback: WrapFn<T>): this;
   /**
    * ### cleanup | Life cycle event

package/dist/base.js

@@ -502,7 +502,7 @@ var Elysia = class Elysia {
 		require_utils.invalidateMacroEpoch();
 		return this;
 	}
-	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set()) {
+	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set(), insertions = /* @__PURE__ */ new Map()) {
 		if (iteration >= 16) return input;
 		const macro = this["~ext"]?.macro;
 		if (!macro) return input;
@@ -547,14 +547,14 @@ var Elysia = class Elysia {
 					continue;
 				}
 				if (k in macro) {
-					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen);
+					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen, insertions);
 					delete input[key];
 					continue;
 				}
 				if (k === "schema") {
 					const incoming = Array.isArray(v) ? v : [v];
 					if (!input.schemas) input.schemas = [];
-					require_utils.coalesceStandaloneSchemas(input.schemas, incoming);
+					require_utils.coalesceSchemas(input.schemas, incoming);
 					delete input[key];
 					continue;
 				}
@@ -564,23 +564,24 @@ var Elysia = class Elysia {
 						continue;
 					}
 					input.schemas ??= [];
-					require_utils.coalesceStandaloneSchemas(input.schemas, [{ [k]: v }]);
+					require_utils.coalesceSchemas(input.schemas, [{ [k]: v }]);
 					delete input[key];
 					continue;
 				}
-				if (k in input) {
-					if (require_utils.eventProperties.has(k) || k === "derive") {
-						const macroFns = Array.isArray(v) ? v : [v];
-						const existing = Array.isArray(input[k]) ? input[k] : [input[k]];
-						const merged = [];
-						const seen = /* @__PURE__ */ new Set();
-						for (const fn of macroFns) if (!existing.includes(fn) && !seen.has(fn)) {
-							seen.add(fn);
-							merged.push(fn);
-						}
-						for (const fn of existing) if (!seen.has(fn)) merged.push(fn);
-						input[k] = merged;
-					} else if (Array.isArray(input[k])) {
+				if (require_utils.eventProperties.has(k) || k === "derive") {
+					const incoming = Array.isArray(v) ? v : [v];
+					const existing = k in input ? Array.isArray(input[k]) ? input[k] : [input[k]] : [];
+					const added = [];
+					for (const fn of incoming) if (!existing.includes(fn) && !added.includes(fn)) added.push(fn);
+					const at = insertions.get(k) ?? 0;
+					input[k] = [
+						...existing.slice(0, at),
+						...added,
+						...existing.slice(at)
+					];
+					insertions.set(k, at + added.length);
+				} else if (k in input) {
+					if (Array.isArray(input[k])) {
 						if (Array.isArray(v)) {
 							for (const item of v) if (!input[k].some((e) => e === item)) input[k].unshift(item);
 						} else if (!input[k].some((item) => item === v)) input[k].unshift(v);
@@ -1511,6 +1512,21 @@ var Elysia = class Elysia {
 		if (!require_compile_aot.Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}
+	/**
+	* Add a higher order function over Elysia.fetch
+	*
+	* @example
+	* ```ts
+	* const ctx = new AsyncLocalStorage<{ counter: number }>()
+	*
+	* new Elysia()
+	*	.wrap(
+	*		(fetch) => (request) =>
+	*			ctx.run({ counter: 0 }, () => fetch(request))
+	*	)
+	*	.get('/', () => ctx.getStore())
+	* ```
+	*/
 	wrap(callback) {
 		this.#assertMutable("wrap");
 		if (this.#fetchFn && !this.#pending) console.warn("[Elysia] .wrap() was called after the fetch handler was built");

package/dist/base.mjs

@@ -1,5 +1,5 @@
 import { isBun } from "./universal/constants.mjs";
-import { clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed } from "./utils.mjs";
+import { clonePlainDecorators, clonePlainDeep, coalesceSchemas, createErrorEventHandler, eventProperties, fnOrigin, fnv1a, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isEmpty, isNotEmpty, isRecordNumber, joinPath, macroOrigin, mapDeriveEntry, mergeDeep, mergeResponse, nullObject, pushField, schemaProperties, serializeMacroSeed } from "./utils.mjs";
 import { Ref } from "./type/bridge.mjs";
 import { isProduction } from "./universal/is-production.mjs";
 import { Capture, Compiled, beginCompilerSession, createAotFingerprint, createProgramId, endCompilerSession } from "./compile/aot.mjs";
@@ -499,7 +499,7 @@ var Elysia = class Elysia {
 		invalidateMacroEpoch();
 		return this;
 	}
-	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set()) {
+	"~applyMacro"(input, toApply = input, iteration = 0, seen = /* @__PURE__ */ new Set(), insertions = /* @__PURE__ */ new Map()) {
 		if (iteration >= 16) return input;
 		const macro = this["~ext"]?.macro;
 		if (!macro) return input;
@@ -544,14 +544,14 @@ var Elysia = class Elysia {
 					continue;
 				}
 				if (k in macro) {
-					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen);
+					this["~applyMacro"](input, { [k]: v }, iteration + 1, seen, insertions);
 					delete input[key];
 					continue;
 				}
 				if (k === "schema") {
 					const incoming = Array.isArray(v) ? v : [v];
 					if (!input.schemas) input.schemas = [];
-					coalesceStandaloneSchemas(input.schemas, incoming);
+					coalesceSchemas(input.schemas, incoming);
 					delete input[key];
 					continue;
 				}
@@ -561,23 +561,24 @@ var Elysia = class Elysia {
 						continue;
 					}
 					input.schemas ??= [];
-					coalesceStandaloneSchemas(input.schemas, [{ [k]: v }]);
+					coalesceSchemas(input.schemas, [{ [k]: v }]);
 					delete input[key];
 					continue;
 				}
-				if (k in input) {
-					if (eventProperties.has(k) || k === "derive") {
-						const macroFns = Array.isArray(v) ? v : [v];
-						const existing = Array.isArray(input[k]) ? input[k] : [input[k]];
-						const merged = [];
-						const seen = /* @__PURE__ */ new Set();
-						for (const fn of macroFns) if (!existing.includes(fn) && !seen.has(fn)) {
-							seen.add(fn);
-							merged.push(fn);
-						}
-						for (const fn of existing) if (!seen.has(fn)) merged.push(fn);
-						input[k] = merged;
-					} else if (Array.isArray(input[k])) {
+				if (eventProperties.has(k) || k === "derive") {
+					const incoming = Array.isArray(v) ? v : [v];
+					const existing = k in input ? Array.isArray(input[k]) ? input[k] : [input[k]] : [];
+					const added = [];
+					for (const fn of incoming) if (!existing.includes(fn) && !added.includes(fn)) added.push(fn);
+					const at = insertions.get(k) ?? 0;
+					input[k] = [
+						...existing.slice(0, at),
+						...added,
+						...existing.slice(at)
+					];
+					insertions.set(k, at + added.length);
+				} else if (k in input) {
+					if (Array.isArray(input[k])) {
 						if (Array.isArray(v)) {
 							for (const item of v) if (!input[k].some((e) => e === item)) input[k].unshift(item);
 						} else if (!input[k].some((item) => item === v)) input[k].unshift(v);
@@ -1508,6 +1509,21 @@ var Elysia = class Elysia {
 		if (!Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}
+	/**
+	* Add a higher order function over Elysia.fetch
+	*
+	* @example
+	* ```ts
+	* const ctx = new AsyncLocalStorage<{ counter: number }>()
+	*
+	* new Elysia()
+	*	.wrap(
+	*		(fetch) => (request) =>
+	*			ctx.run({ counter: 0 }, () => fetch(request))
+	*	)
+	*	.get('/', () => ctx.getStore())
+	* ```
+	*/
 	wrap(callback) {
 		this.#assertMutable("wrap");
 		if (this.#fetchFn && !this.#pending) console.warn("[Elysia] .wrap() was called after the fetch handler was built");

package/dist/compile/aot-capture.js

@@ -282,7 +282,7 @@ function captureBridgeFree(aot, slot, rawSchema) {
 			path: aot.path,
 			slot
 		}, { bridgeFree });
-		if (bridgeFree && !require_compile_handler_frozen_validator.isCompactDiagnosable(coerced)) warnCompactErrorLoss(aot, slot);
+		if (bridgeFree && !require_compile_handler_frozen_validator.isCompactWalkable(coerced)) warnCompactErrorLoss(aot, slot);
 	}
 }
 function beginValidatorCapture() {

package/dist/compile/aot-capture.mjs

@@ -2,7 +2,7 @@ import { nullObject } from "../utils.mjs";
 import { env } from "../universal/env.mjs";
 import { Capture, CompilerState, aotActivationError, captureImpl, setCaptureImpl } from "./aot.mjs";
 import { isAsyncPredicate } from "../type/elysia/file-type.mjs";
-import { isCapturedBridgeFree, isCompactDiagnosable } from "./handler/frozen-validator.mjs";
+import { isCapturedBridgeFree, isCompactWalkable } from "./handler/frozen-validator.mjs";
 import { buildCoercedFromPlan, captureCoercePlan } from "../type/coerce.mjs";
 import { applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, canonical, createMergerFromSource, setDefaultProbeImpl, verifyPreallocatableDefault } from "../type/validator/default-precompute.mjs";
 import { collectExternals } from "./aot-reconstruct.mjs";
@@ -280,7 +280,7 @@ function captureBridgeFree(aot, slot, rawSchema) {
 			path: aot.path,
 			slot
 		}, { bridgeFree });
-		if (bridgeFree && !isCompactDiagnosable(coerced)) warnCompactErrorLoss(aot, slot);
+		if (bridgeFree && !isCompactWalkable(coerced)) warnCompactErrorLoss(aot, slot);
 	}
 }
 function beginValidatorCapture() {

package/dist/compile/handler/descriptor.d.ts

@@ -1,6 +1,6 @@
 import { TraceEvent } from "../../trace.js";
-import { AnyLocalHook, MaybeArray } from "../../types.js";
 import { CompactBeforeHandlePrefix } from "../../utils.js";
+import { AnyLocalHook, MaybeArray } from "../../types.js";
 import { CompiledCookieConfig } from "../../cookie/config.js";
 import { AnyElysia } from "../../base.js";
 import { ElysiaAdapter } from "../../adapter/index.js";

package/dist/compile/handler/descriptor.js

@@ -97,9 +97,9 @@ function describeRoute(input) {
 	if (hook && typeof hook.parse === "function") hook.parse = [hook.parse];
 	const parseLength = Array.isArray(hook?.parse) ? hook.parse.length : 0;
 	const parseFirst = Array.isArray(hook?.parse) ? hook.parse[0] : hook?.parse;
-	const hasStandaloneBody = !!hook?.schemas?.some((s) => s?.body);
+	const hasMergeBody = !!hook?.schemas?.some((s) => s?.body);
 	const bodylessMethod = method === "GET" || method === "HEAD";
-	const hasBody = !!hook?.body || hasStandaloneBody || !bodylessMethod && (parseLength > 0 || inference.body) && parseFirst !== "none";
+	const hasBody = !!hook?.body || hasMergeBody || !bodylessMethod && (parseLength > 0 || inference.body) && parseFirst !== "none";
 	const bodyValiIsAsync = hasBody && (isAsyncValidator(vali?.body) || mayReturnPromiseValidator(vali?.body));
 	const headersValiIsAsync = vali?.headers && (isAsyncValidator(vali?.headers) || mayReturnPromiseValidator(vali?.headers));
 	const paramsValiIsAsync = vali?.params && (isAsyncValidator(vali?.params) || mayReturnPromiseValidator(vali?.params));
@@ -113,7 +113,8 @@ function describeRoute(input) {
 	const asyncCookieSign = hasCookieSign && !syncCookieSign;
 	const lazyCookieVerify = syncCookieSign && cookieConfig?.verify === "lazy" && !vali?.cookie;
 	const hasErrorHook = !!hook?.error?.length;
-	const hasAfterResponse = !!hook?.afterResponse?.length;
+	const hasStaticAfterResponse = !!hook?.afterResponse?.length;
+	const hasAfterResponse = hasStaticAfterResponse || !!inference.afterResponse;
 	const hasBeforeHandle = !!beforeHandlePrefix?.length || !!hook?.beforeHandle?.length;
 	const hasAfterHandle = !!hook?.afterHandle?.length;
 	const hasMapResponse = !!hook?.mapResponse?.length;
@@ -137,7 +138,7 @@ function describeRoute(input) {
 	}
 	const handlerIsAsync = isHandleFunction && require_compile_utils.isAsyncFunction(handler);
 	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || require_compile_utils.isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error, false));
-	const afterResponseForcesAsync = hasAfterResponse && (require_compile_utils.isAsyncLifecycle(hook?.afterResponse) || hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
+	const afterResponseForcesAsync = hasStaticAfterResponse && require_compile_utils.isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
 	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && (require_compile_utils.mayReturnPromise(handler) || mayReturnIdentifier(handler));
 	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && (require_compile_utils.mayReturnPromise(handler) || mayReturnIdentifier(handler));
 	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle, true) || lifecycleMayReturnPromise(hook.transform, false) || lifecycleMayReturnPromise(hook.afterHandle, true) || lifecycleMayReturnPromise(hook.mapResponse, true));

package/dist/compile/handler/descriptor.mjs

@@ -96,9 +96,9 @@ function describeRoute(input) {
 	if (hook && typeof hook.parse === "function") hook.parse = [hook.parse];
 	const parseLength = Array.isArray(hook?.parse) ? hook.parse.length : 0;
 	const parseFirst = Array.isArray(hook?.parse) ? hook.parse[0] : hook?.parse;
-	const hasStandaloneBody = !!hook?.schemas?.some((s) => s?.body);
+	const hasMergeBody = !!hook?.schemas?.some((s) => s?.body);
 	const bodylessMethod = method === "GET" || method === "HEAD";
-	const hasBody = !!hook?.body || hasStandaloneBody || !bodylessMethod && (parseLength > 0 || inference.body) && parseFirst !== "none";
+	const hasBody = !!hook?.body || hasMergeBody || !bodylessMethod && (parseLength > 0 || inference.body) && parseFirst !== "none";
 	const bodyValiIsAsync = hasBody && (isAsyncValidator(vali?.body) || mayReturnPromiseValidator(vali?.body));
 	const headersValiIsAsync = vali?.headers && (isAsyncValidator(vali?.headers) || mayReturnPromiseValidator(vali?.headers));
 	const paramsValiIsAsync = vali?.params && (isAsyncValidator(vali?.params) || mayReturnPromiseValidator(vali?.params));
@@ -112,7 +112,8 @@ function describeRoute(input) {
 	const asyncCookieSign = hasCookieSign && !syncCookieSign;
 	const lazyCookieVerify = syncCookieSign && cookieConfig?.verify === "lazy" && !vali?.cookie;
 	const hasErrorHook = !!hook?.error?.length;
-	const hasAfterResponse = !!hook?.afterResponse?.length;
+	const hasStaticAfterResponse = !!hook?.afterResponse?.length;
+	const hasAfterResponse = hasStaticAfterResponse || !!inference.afterResponse;
 	const hasBeforeHandle = !!beforeHandlePrefix?.length || !!hook?.beforeHandle?.length;
 	const hasAfterHandle = !!hook?.afterHandle?.length;
 	const hasMapResponse = !!hook?.mapResponse?.length;
@@ -136,7 +137,7 @@ function describeRoute(input) {
 	}
 	const handlerIsAsync = isHandleFunction && isAsyncFunction(handler);
 	const errorHookForcesAsync = hasErrorHook && (hasAfterHandle || hasMapResponse || hasResponseValidator || isAsyncLifecycle(hook?.error) || lifecycleMayReturnPromise(hook?.error, false));
-	const afterResponseForcesAsync = hasAfterResponse && (isAsyncLifecycle(hook?.afterResponse) || hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
+	const afterResponseForcesAsync = hasStaticAfterResponse && isAsyncLifecycle(hook?.afterResponse) || hasAfterResponse && (hasAfterHandle || hasMapResponse || hasResponseValidator || hasErrorHook);
 	const traceForcesAsync = (traceHandleOn || phaseOn("error") || phaseOn("afterResponse")) && isHandleFunction && !handlerIsAsync && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
 	const handlerResultObserved = isHandleFunction && !handlerIsAsync && (hasResponseValidator || hasAfterHandle || hasMapResponse) && (mayReturnPromise(handler) || mayReturnIdentifier(handler));
 	const lifecycleForcesAsync = !!hook && ((beforeHandlePrefix ? compactPrefixForcesAsync(beforeHandlePrefix) : false) || lifecycleMayReturnPromise(hook.beforeHandle, true) || lifecycleMayReturnPromise(hook.transform, false) || lifecycleMayReturnPromise(hook.afterHandle, true) || lifecycleMayReturnPromise(hook.mapResponse, true));

package/dist/compile/handler/frozen-validator.d.ts

@@ -11,6 +11,7 @@ interface SlotCheckClean {
   decode?: (value: unknown) => unknown;
 }
 declare function isCompactDiagnosable(schema: any): boolean;
+declare function isCompactWalkable(schema: any): boolean;
 declare class FrozenSlotValidator {
   #private;
   isAsync: boolean;
@@ -32,8 +33,8 @@ interface FrozenRouteValidatorShape {
   response?: Record<number, FrozenSlotValidator>;
 }
 declare const isStandardSchema: (schema: unknown) => schema is object & Record<"~standard", unknown>;
-declare function standaloneAllStandard(schemas: Array<Record<string, unknown>> | undefined): boolean;
+declare function mergeSchemasAllStandard(schemas: Array<Record<string, unknown>> | undefined): boolean;
 declare function buildFrozenRouteValidator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): FrozenRouteValidatorShape | undefined;
 declare function isCapturedBridgeFree(c: CapturedValidator, schema: unknown, coerced?: unknown): boolean;
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isStandardSchema, standaloneAllStandard };
+export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isStandardSchema, mergeSchemasAllStandard };

package/dist/compile/handler/frozen-validator.js

@@ -55,17 +55,30 @@ const typeError = (schema, instancePath, schemaPath) => ({
 **/
 function walkCompactError(schema, value, instancePath, schemaPath) {
 	if (!schema || typeof schema !== "object") return;
+	const elyTyp = schema["~elyTyp"];
+	if (schema.anyOf && (elyTyp === require_type_constants.ELYSIA_TYPES.ObjectString || elyTyp === require_type_constants.ELYSIA_TYPES.ArrayString)) {
+		let decoded = value;
+		if (typeof value === "string") try {
+			decoded = JSON.parse(value);
+		} catch {
+			return;
+		}
+		else if (value === void 0) return;
+		return walkCompactError(schema.anyOf[0], decoded, instancePath, `${schemaPath}/anyOf/0`);
+	}
 	const type = schema.type;
 	if (type === "object") {
 		if (typeof value !== "object" || value === null || Array.isArray(value)) return typeError(schema, instancePath, schemaPath);
 		const required = schema.required;
 		if (Array.isArray(required)) {
-			for (const key of required) if (!(key in value)) return {
+			let missing;
+			for (const key of required) if (!(key in value)) (missing ??= []).push(key);
+			if (missing) return {
 				keyword: "required",
 				schemaPath,
 				instancePath,
-				params: { requiredProperties: [key] },
-				message: `must have required properties ${key}`
+				params: { requiredProperties: missing },
+				message: `must have required properties ${missing.join(", ")}`
 			};
 		}
 		const properties = schema.properties;
@@ -121,6 +134,22 @@ function isCompactDiagnosable(schema) {
 	if (type === "array") return isCompactDiagnosable(schema.items);
 	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
 }
+function isCompactWalkable(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	const elyTyp = schema["~elyTyp"];
+	if (schema.anyOf && (elyTyp === require_type_constants.ELYSIA_TYPES.ObjectString || elyTyp === require_type_constants.ELYSIA_TYPES.ArrayString)) return isCompactWalkable(schema.anyOf[0]);
+	if (schema.anyOf || schema.oneOf || schema.allOf) return false;
+	const type = schema.type;
+	if (type === "object") {
+		const properties = schema.properties;
+		if (properties) {
+			for (const key in properties) if (!isCompactWalkable(properties[key])) return false;
+		}
+		return true;
+	}
+	if (type === "array") return isCompactWalkable(schema.items);
+	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
+}
 var FrozenSlotValidator = class {
 	#check;
 	#clean;
@@ -224,7 +253,7 @@ const REQUEST_SLOTS = [
 	"cookie"
 ];
 const isStandardSchema = (schema) => schema != null && typeof schema === "object" && "~standard" in schema;
-function standaloneAllStandard(schemas) {
+function mergeSchemasAllStandard(schemas) {
 	if (!schemas || schemas.length === 0) return true;
 	for (const entry of schemas) for (const key in entry) {
 		const value = entry[key];
@@ -315,5 +344,6 @@ exports.buildFrozenRouteValidator = buildFrozenRouteValidator;
 exports.isBridgeNotInitialized = isBridgeNotInitialized;
 exports.isCapturedBridgeFree = isCapturedBridgeFree;
 exports.isCompactDiagnosable = isCompactDiagnosable;
+exports.isCompactWalkable = isCompactWalkable;
 exports.isStandardSchema = isStandardSchema;
-exports.standaloneAllStandard = standaloneAllStandard;
+exports.mergeSchemasAllStandard = mergeSchemasAllStandard;