elysia 2.0.0-exp.60 → 2.0.0-exp.61

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

@@ -34,7 +34,7 @@ function mapResponseWithSet(response, set, request, owned) {
 			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);
@@ -73,7 +73,7 @@ function mapCompactResponse(response, request, owned) {
 			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response));
 			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);

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

@@ -33,7 +33,7 @@ function mapResponseWithSet(response, set, request, owned) {
 			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);
@@ -72,7 +72,7 @@ function mapCompactResponse(response, request, owned) {
 			if (response["~ely-form"]) return new Response(formToFormData(response));
 			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);

package/dist/base.d.ts

@@ -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'];

package/dist/base.js

@@ -554,7 +554,7 @@ var Elysia = class Elysia {
 				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,7 +564,7 @@ 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;
 				}

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";
@@ -551,7 +551,7 @@ var Elysia = class Elysia {
 				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,7 +561,7 @@ var Elysia = class Elysia {
 						continue;
 					}
 					input.schemas ??= [];
-					coalesceStandaloneSchemas(input.schemas, [{ [k]: v }]);
+					coalesceSchemas(input.schemas, [{ [k]: v }]);
 					delete input[key];
 					continue;
 				}

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

@@ -32,8 +32,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, isStandardSchema, mergeSchemasAllStandard };

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

@@ -224,7 +224,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];
@@ -316,4 +316,4 @@ exports.isBridgeNotInitialized = isBridgeNotInitialized;
 exports.isCapturedBridgeFree = isCapturedBridgeFree;
 exports.isCompactDiagnosable = isCompactDiagnosable;
 exports.isStandardSchema = isStandardSchema;
-exports.standaloneAllStandard = standaloneAllStandard;
+exports.mergeSchemasAllStandard = mergeSchemasAllStandard;

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

@@ -223,7 +223,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];
@@ -310,4 +310,4 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 }
 
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isStandardSchema, standaloneAllStandard };
+export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isStandardSchema, mergeSchemasAllStandard };

package/dist/compile/handler/jit.js

@@ -158,6 +158,8 @@ const createInlineHandlerWithDefaultHeaders = (map, h) => ((c) => {
 });
 function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapter, isHandleFunction, isStaticResponse, isPromiseHandler, state }) {
 	const { vali, inference, cookieConfig, beforeHandlePrefix, traceHandlers, tracePhases, hasAnyPhase, traceHandleOn, descriptor: { async: isAsync, responseMode, hasBody, bodyValiIsAsync, headersValiIsAsync, paramsValiIsAsync, queryValiIsAsync, cookieValiIsAsync: cookieValidIsAsync, responseValiAsync, hasCookieSign, syncCookieSign, asyncCookieSign, lazyCookieVerify, hasErrorHook, hasAfterResponse, hasBeforeHandle, hasAfterHandle, hasMapResponse, hasResponseValidator, hasTrace, traceCount, hasLifecycleHook, callHandlerSyncOnAsync, syncErrorHook, syncAfterResponse } } = state;
+	const hasStaticAfterResponse = !!hook?.afterResponse?.length;
+	const hasDynamicAfterResponse = !!inference.afterResponse;
 	const seenKeys = new Set(["rt", "fre"]);
 	const paramValues = [errorRoot, require_handler_utils.finalizeRouteError];
 	const aliasKeys = [];
@@ -350,7 +352,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	if (isStaticResponse || isPromiseHandler) link(require_compile_handler_utils.cloneResponse, "cr");
 	const handleInstruction = isHandleFunction ? "h(c)" : isStaticResponse ? "cr(h)" : isPromiseHandler ? "h.then(cr)" : "h";
 	const mapReturn = hasSet ? `rm(${handleInstruction},c.set,c.request,true)\n` : `rc(${handleInstruction},c.request,true)\n`;
-	if (hasAfterResponse) link(hook.afterResponse, "ar");
+	if (hasStaticAfterResponse) link(hook.afterResponse, "ar");
 	const drainTraceStream = traceHandleOn ? `let _ser\nif(_trs){try{for await(const v of _trs){}}catch(_te){_ser=_te}}\n` : "";
 	const resolveHandlePostDrain = traceHandleOn ? (() => {
 		let s = "";
@@ -358,7 +360,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		return s;
 	})() : "";
 	const traceNeedsSchedule = traceHandleOn || phaseOn("afterResponse");
-	const scheduleAfterResponse = hasAfterResponse || traceNeedsSchedule ? "c._arf=true\nqueueMicrotask(async()=>{if(_stl){try{for await(const v of _stl){}}catch{}}\n" + drainTraceStream + resolveHandlePostDrain + beginTrace("afterResponse", hook?.afterResponse?.length ?? 0) + (hasAfterResponse ? require_compile_handler_utils.mapAfterResponse(hook.afterResponse, [buildReport("afterResponse")]) : "") + endTrace("afterResponse") + `})\n` : "";
+	const scheduleAfterResponse = hasAfterResponse || traceNeedsSchedule ? "c._arf=true\nqueueMicrotask(async()=>{if(_stl){try{for await(const v of _stl){}}catch{}}\n" + drainTraceStream + resolveHandlePostDrain + beginTrace("afterResponse", hook?.afterResponse?.length ?? 0) + (hasStaticAfterResponse ? require_compile_handler_utils.mapAfterResponse(hook.afterResponse, [buildReport("afterResponse")]) : "") + (hasDynamicAfterResponse ? `if(c['~afterResponse'])for(let i=0;i<c['~afterResponse'].length;i++){try{await c['~afterResponse'][i](c)}catch{}}\n` : "") + endTrace("afterResponse") + `})\n` : "";
 	const dedupSchedule = !!scheduleAfterResponse && (hasErrorHook || hasTrace) && !syncAfterResponse && !syncErrorHook;
 	const scheduleDecl = dedupSchedule ? `function _sc(){\n${scheduleAfterResponse}}\n` : "";
 	const schedule = dedupSchedule ? `_sc()\n` : scheduleAfterResponse;

package/dist/compile/handler/jit.mjs

@@ -157,6 +157,8 @@ const createInlineHandlerWithDefaultHeaders = (map, h) => ((c) => {
 });
 function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapter, isHandleFunction, isStaticResponse, isPromiseHandler, state }) {
 	const { vali, inference, cookieConfig, beforeHandlePrefix, traceHandlers, tracePhases, hasAnyPhase, traceHandleOn, descriptor: { async: isAsync, responseMode, hasBody, bodyValiIsAsync, headersValiIsAsync, paramsValiIsAsync, queryValiIsAsync, cookieValiIsAsync: cookieValidIsAsync, responseValiAsync, hasCookieSign, syncCookieSign, asyncCookieSign, lazyCookieVerify, hasErrorHook, hasAfterResponse, hasBeforeHandle, hasAfterHandle, hasMapResponse, hasResponseValidator, hasTrace, traceCount, hasLifecycleHook, callHandlerSyncOnAsync, syncErrorHook, syncAfterResponse } } = state;
+	const hasStaticAfterResponse = !!hook?.afterResponse?.length;
+	const hasDynamicAfterResponse = !!inference.afterResponse;
 	const seenKeys = new Set(["rt", "fre"]);
 	const paramValues = [errorRoot, finalizeRouteError];
 	const aliasKeys = [];
@@ -349,7 +351,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 	if (isStaticResponse || isPromiseHandler) link(cloneResponse, "cr");
 	const handleInstruction = isHandleFunction ? "h(c)" : isStaticResponse ? "cr(h)" : isPromiseHandler ? "h.then(cr)" : "h";
 	const mapReturn = hasSet ? `rm(${handleInstruction},c.set,c.request,true)\n` : `rc(${handleInstruction},c.request,true)\n`;
-	if (hasAfterResponse) link(hook.afterResponse, "ar");
+	if (hasStaticAfterResponse) link(hook.afterResponse, "ar");
 	const drainTraceStream = traceHandleOn ? `let _ser\nif(_trs){try{for await(const v of _trs){}}catch(_te){_ser=_te}}\n` : "";
 	const resolveHandlePostDrain = traceHandleOn ? (() => {
 		let s = "";
@@ -357,7 +359,7 @@ function compileHandlerJit({ method, path, handler, root, errorRoot, hook, adapt
 		return s;
 	})() : "";
 	const traceNeedsSchedule = traceHandleOn || phaseOn("afterResponse");
-	const scheduleAfterResponse = hasAfterResponse || traceNeedsSchedule ? "c._arf=true\nqueueMicrotask(async()=>{if(_stl){try{for await(const v of _stl){}}catch{}}\n" + drainTraceStream + resolveHandlePostDrain + beginTrace("afterResponse", hook?.afterResponse?.length ?? 0) + (hasAfterResponse ? mapAfterResponse(hook.afterResponse, [buildReport("afterResponse")]) : "") + endTrace("afterResponse") + `})\n` : "";
+	const scheduleAfterResponse = hasAfterResponse || traceNeedsSchedule ? "c._arf=true\nqueueMicrotask(async()=>{if(_stl){try{for await(const v of _stl){}}catch{}}\n" + drainTraceStream + resolveHandlePostDrain + beginTrace("afterResponse", hook?.afterResponse?.length ?? 0) + (hasStaticAfterResponse ? mapAfterResponse(hook.afterResponse, [buildReport("afterResponse")]) : "") + (hasDynamicAfterResponse ? `if(c['~afterResponse'])for(let i=0;i<c['~afterResponse'].length;i++){try{await c['~afterResponse'][i](c)}catch{}}\n` : "") + endTrace("afterResponse") + `})\n` : "";
 	const dedupSchedule = !!scheduleAfterResponse && (hasErrorHook || hasTrace) && !syncAfterResponse && !syncErrorHook;
 	const scheduleDecl = dedupSchedule ? `function _sc(){\n${scheduleAfterResponse}}\n` : "";
 	const schedule = dedupSchedule ? `_sc()\n` : scheduleAfterResponse;

package/dist/compile/handler/utils.js

@@ -62,6 +62,7 @@ function replaceDeriveContext(context, derivative) {
 	Object.assign(next, derivative);
 	next.request = context.request;
 	next["~sig"] = context["~sig"];
+	next["~afterResponse"] = context["~afterResponse"];
 	next.store = context.store;
 	next.set = context.set;
 	next.body = context.body;

package/dist/compile/handler/utils.mjs

@@ -61,6 +61,7 @@ function replaceDeriveContext(context, derivative) {
 	Object.assign(next, derivative);
 	next.request = context.request;
 	next["~sig"] = context["~sig"];
+	next["~afterResponse"] = context["~afterResponse"];
 	next.store = context.store;
 	next.set = context.set;
 	next.body = context.body;

package/dist/context.d.ts

@@ -3,7 +3,7 @@ import { Cookie } from "./cookie/cookie.js";
 import { StatusMap } from "./constants.js";
 import { SelectiveStatus, status } from "./error.js";
 import { Server } from "./universal/server.js";
-import { DefaultSingleton, HTTPHeaders, InputSchema, Prettify, ResolvePath, RouteSchema, SingletonBase } from "./types.js";
+import { AfterResponseHandler, DefaultSingleton, HTTPHeaders, InputSchema, MaybePromise, Prettify, ResolvePath, RouteSchema, SingletonBase } from "./types.js";
 import { redirect } from "./utils.js";
 import { AnyElysia } from "./base.js";
 
@@ -25,6 +25,10 @@ interface ContextBase<in out Route extends RouteSchema, in out Singleton extends
     cookie?: Record<string, BaseCookie>;
   };
   status: {} extends Route['response'] ? typeof status : SelectiveStatus<Route['response']>;
+  /**
+   * Append a callback to run after the response is sent
+   */
+  defer(fn: AfterResponseHandler<Route, Singleton>): MaybePromise<void>;
   /**
    * Path extracted from incoming URL
    *

package/dist/context.js

@@ -8,12 +8,22 @@ const require_adapter_default_headers = require('./adapter/default-headers.js');
 let contextCache = /* @__PURE__ */ new WeakMap();
 let sharedEmptyDecorator = null;
 let sharedEmptyContext = null;
+const defer = {
+	configurable: true,
+	get() {
+		const queue = this["~afterResponse"] ??= [];
+		const append = (fn) => queue.push(fn);
+		Object.defineProperty(this, "defer", { value: append });
+		return append;
+	}
+};
 function buildEmptyDecorator() {
 	class Decorator {}
 	Object.assign(Decorator.prototype, {
 		status: require_error.status,
 		redirect: require_utils.redirect
 	});
+	Object.defineProperty(Decorator.prototype, "defer", defer);
 	return Decorator;
 }
 function createBaseContext(app) {
@@ -28,6 +38,7 @@ function createBaseContext(app) {
 		status: require_error.status,
 		redirect: require_utils.redirect
 	});
+	Object.defineProperty(Decorator.prototype, "defer", defer);
 	return Decorator;
 }
 function clearContextCache() {

package/dist/context.mjs

@@ -7,12 +7,22 @@ import { defaultHeaders } from "./adapter/default-headers.mjs";
 let contextCache = /* @__PURE__ */ new WeakMap();
 let sharedEmptyDecorator = null;
 let sharedEmptyContext = null;
+const defer = {
+	configurable: true,
+	get() {
+		const queue = this["~afterResponse"] ??= [];
+		const append = (fn) => queue.push(fn);
+		Object.defineProperty(this, "defer", { value: append });
+		return append;
+	}
+};
 function buildEmptyDecorator() {
 	class Decorator {}
 	Object.assign(Decorator.prototype, {
 		status,
 		redirect
 	});
+	Object.defineProperty(Decorator.prototype, "defer", defer);
 	return Decorator;
 }
 function createBaseContext(app) {
@@ -27,6 +37,7 @@ function createBaseContext(app) {
 		status,
 		redirect
 	});
+	Object.defineProperty(Decorator.prototype, "defer", defer);
 	return Decorator;
 }
 function clearContextCache() {

package/dist/handler/fetch.js

@@ -15,7 +15,8 @@ deuri = require_runtime.__toESM(deuri);
 //#region src/handler/fetch.ts
 function extractPath(url, context, pathStart) {
 	const s = url.indexOf("/", pathStart);
-	return context.path = url.substring(s, (context.qi = url.indexOf("?", s)) === -1 ? url.length : context.qi);
+	const q = context.qi = url.indexOf("?", s);
+	return context.path = q === -1 ? url.slice(s) : url.substring(s, q);
 }
 function notFound(context) {
 	const set = context.set;
@@ -162,18 +163,23 @@ function createFetchHandler(app) {
 	const traceAfterResponsePhase = hasTrace && (tracePhases === null || tracePhases.has("afterResponse"));
 	const tracerFactories = hasTrace ? traceHandlers.map((fn) => traceProvider.createTracer(fn)) : void 0;
 	const afterResponses = hook?.afterResponse;
-	const afterResponse = afterResponses?.length || traceAfterResponsePhase ? (context, status) => {
+	const afterResponse = (context, status) => {
 		if (context._arf) return;
+		const queue = context["~afterResponse"];
+		if (!afterResponses?.length && !traceAfterResponsePhase && !queue?.length) return;
 		context._arf = true;
 		if (status !== void 0) context.set.status = status;
 		queueMicrotask(async () => {
-			if (afterResponses) {
-				require_adapter_utils.materializeSetHeaders(context.set);
-				for (let i = 0; i < afterResponses.length; i++) try {
-					await afterResponses[i](context);
-				} catch (e) {
-					console.error(e);
-				}
+			if (afterResponses?.length || queue?.length) require_adapter_utils.materializeSetHeaders(context.set);
+			if (afterResponses) for (let i = 0; i < afterResponses.length; i++) try {
+				await afterResponses[i](context);
+			} catch (e) {
+				console.error(e);
+			}
+			if (queue) for (let i = 0; i < queue.length; i++) try {
+				await queue[i](context);
+			} catch (e) {
+				console.error(e);
 			}
 			if (traceAfterResponsePhase) {
 				let cache = context.trace;
@@ -198,7 +204,7 @@ function createFetchHandler(app) {
 				}
 			}
 		});
-	} : void 0;
+	};
 	app["~finalizeError"] = (context, error) => finalizeError(context, handleError, afterResponse, error);
 	if (traceRequestPhase) {
 		const onRequests = hook?.request ?? [];

package/dist/handler/fetch.mjs

@@ -12,7 +12,8 @@ import decodeComponent from "deuri";
 //#region src/handler/fetch.ts
 function extractPath(url, context, pathStart) {
 	const s = url.indexOf("/", pathStart);
-	return context.path = url.substring(s, (context.qi = url.indexOf("?", s)) === -1 ? url.length : context.qi);
+	const q = context.qi = url.indexOf("?", s);
+	return context.path = q === -1 ? url.slice(s) : url.substring(s, q);
 }
 function notFound(context) {
 	const set = context.set;
@@ -159,18 +160,23 @@ function createFetchHandler(app) {
 	const traceAfterResponsePhase = hasTrace && (tracePhases === null || tracePhases.has("afterResponse"));
 	const tracerFactories = hasTrace ? traceHandlers.map((fn) => traceProvider.createTracer(fn)) : void 0;
 	const afterResponses = hook?.afterResponse;
-	const afterResponse = afterResponses?.length || traceAfterResponsePhase ? (context, status) => {
+	const afterResponse = (context, status) => {
 		if (context._arf) return;
+		const queue = context["~afterResponse"];
+		if (!afterResponses?.length && !traceAfterResponsePhase && !queue?.length) return;
 		context._arf = true;
 		if (status !== void 0) context.set.status = status;
 		queueMicrotask(async () => {
-			if (afterResponses) {
-				materializeSetHeaders(context.set);
-				for (let i = 0; i < afterResponses.length; i++) try {
-					await afterResponses[i](context);
-				} catch (e) {
-					console.error(e);
-				}
+			if (afterResponses?.length || queue?.length) materializeSetHeaders(context.set);
+			if (afterResponses) for (let i = 0; i < afterResponses.length; i++) try {
+				await afterResponses[i](context);
+			} catch (e) {
+				console.error(e);
+			}
+			if (queue) for (let i = 0; i < queue.length; i++) try {
+				await queue[i](context);
+			} catch (e) {
+				console.error(e);
 			}
 			if (traceAfterResponsePhase) {
 				let cache = context.trace;
@@ -195,7 +201,7 @@ function createFetchHandler(app) {
 				}
 			}
 		});
-	} : void 0;
+	};
 	app["~finalizeError"] = (context, error) => finalizeError(context, handleError, afterResponse, error);
 	if (traceRequestPhase) {
 		const onRequests = hook?.request ?? [];

package/dist/package.js

@@ -1,6 +1,6 @@
 
 //#region package.json
-var version = "2.0.0-exp.60";
+var version = "2.0.0-exp.61";
 
 //#endregion
 Object.defineProperty(exports, 'version', {

package/dist/package.mjs

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "2.0.0-exp.60";
+var version = "2.0.0-exp.61";
 
 //#endregion
 export { version };

package/dist/plugin/aot/core.js

@@ -444,9 +444,9 @@ async function generateCompiledArtifacts(file, options) {
 				routeHasTypeBoxDirectSlot = true;
 				expectedSlots++;
 			}
-			const standalone = hooks.schemas;
-			if (Array.isArray(standalone) && standalone.length > 0) {
-				if (routeHasTypeBoxDirectSlot || !require_compile_handler_frozen_validator.standaloneAllStandard(standalone)) routesForbidSeal = true;
+			const mergeSchemas = hooks.schemas;
+			if (Array.isArray(mergeSchemas) && mergeSchemas.length > 0) {
+				if (routeHasTypeBoxDirectSlot || !require_compile_handler_frozen_validator.mergeSchemasAllStandard(mergeSchemas)) routesForbidSeal = true;
 			}
 		}
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;

package/dist/plugin/aot/core.mjs

@@ -1,4 +1,4 @@
-import { isStandardSchema, standaloneAllStandard } from "../../compile/handler/frozen-validator.mjs";
+import { isStandardSchema, mergeSchemasAllStandard } from "../../compile/handler/frozen-validator.mjs";
 import { composeRouteHook } from "../../compile/handler/index.mjs";
 import { captureArtifacts, compileToSource, replayStubbability } from "./source.mjs";
 import { createRequire } from "node:module";
@@ -442,9 +442,9 @@ async function generateCompiledArtifacts(file, options) {
 				routeHasTypeBoxDirectSlot = true;
 				expectedSlots++;
 			}
-			const standalone = hooks.schemas;
-			if (Array.isArray(standalone) && standalone.length > 0) {
-				if (routeHasTypeBoxDirectSlot || !standaloneAllStandard(standalone)) routesForbidSeal = true;
+			const mergeSchemas = hooks.schemas;
+			if (Array.isArray(mergeSchemas) && mergeSchemas.length > 0) {
+				if (routeHasTypeBoxDirectSlot || !mergeSchemasAllStandard(mergeSchemas)) routesForbidSeal = true;
 			}
 		}
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;

package/dist/sucrose.d.ts

@@ -9,6 +9,7 @@ declare namespace Sucrose {
     cookie: boolean;
     set: boolean;
     route: boolean;
+    afterResponse?: boolean;
   }
   type LifeCycle = Partial<Partial<AppHook>>;
 }
@@ -67,14 +68,7 @@ declare function retrieveRootparameters(parameter: string): {
 declare function findAlias(type: string, body: string, seen?: Set<string>): string[];
 declare function removeDefaultParameter(parameter: string): string;
 declare function clearSucroseCache(delay?: number | null): void;
-declare const mergeInference: (a: Sucrose.Inference, b: Sucrose.Inference) => {
-  body: boolean;
-  cookie: boolean;
-  headers: boolean;
-  query: boolean;
-  set: boolean;
-  route: boolean;
-};
+declare const mergeInference: (a: Sucrose.Inference, b: Sucrose.Inference) => Sucrose.Inference;
 declare function sucrose(handler: Handler | undefined, lifeCycle: Sucrose.LifeCycle | undefined): Sucrose.Inference;
 //#endregion
 export { Sucrose, bracketPairRange, bracketPairRangeReverse, clearSucroseCache, findAlias, mergeInference, removeColonAlias, removeDefaultParameter, retrieveRootparameters, separateFunction, sucrose };

package/dist/sucrose.js

@@ -272,6 +272,7 @@ function removeDefaultParameter(parameter) {
 }
 function markAllAccessed(i) {
 	i.query = i.headers = i.body = i.cookie = i.set = i.route = true;
+	i.afterResponse = true;
 }
 const DEFAULT_CACHE_LIMIT = 1024;
 const globalSourceCache = /* @__PURE__ */ new Map();
@@ -305,7 +306,8 @@ const mergeInference = (a, b) => ({
 	headers: a.headers || b.headers,
 	query: a.query || b.query,
 	set: a.set || b.set,
-	route: a.route || b.route
+	route: a.route || b.route,
+	...a.afterResponse || b.afterResponse ? { afterResponse: true } : {}
 });
 const defaultSucrose = () => ({
 	query: false,
@@ -563,6 +565,7 @@ const channel = (value) => {
 		case "cookie":
 		case "set":
 		case "route": return value;
+		case "defer": return "afterResponse";
 	}
 };
 function computedDestructuringChannel(tokens, index) {
@@ -731,7 +734,7 @@ function inferFunction(source) {
 			const key = property?.k === "s" && channel(property.value);
 			if (key && tokens[next + 2]?.value === "]") inference[key] = true;
 			else markAllAccessed(inference);
-			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route) break;
+			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route && inference.afterResponse) break;
 			continue;
 		}
 		if (tokens[i - 1]?.value === "=" && (tokens[i - 2]?.k === "i" || tokens[i - 2]?.value === "}")) continue;
@@ -790,7 +793,7 @@ function sucrose(handler, lifeCycle) {
 				inference = mergeInference(inference, inferred);
 				merged = true;
 			} else inference = inferred;
-			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route) break;
+			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route && inference.afterResponse) break;
 		}
 	} finally {
 		events.length = 0;

package/dist/sucrose.mjs

@@ -271,6 +271,7 @@ function removeDefaultParameter(parameter) {
 }
 function markAllAccessed(i) {
 	i.query = i.headers = i.body = i.cookie = i.set = i.route = true;
+	i.afterResponse = true;
 }
 const DEFAULT_CACHE_LIMIT = 1024;
 const globalSourceCache = /* @__PURE__ */ new Map();
@@ -304,7 +305,8 @@ const mergeInference = (a, b) => ({
 	headers: a.headers || b.headers,
 	query: a.query || b.query,
 	set: a.set || b.set,
-	route: a.route || b.route
+	route: a.route || b.route,
+	...a.afterResponse || b.afterResponse ? { afterResponse: true } : {}
 });
 const defaultSucrose = () => ({
 	query: false,
@@ -562,6 +564,7 @@ const channel = (value) => {
 		case "cookie":
 		case "set":
 		case "route": return value;
+		case "defer": return "afterResponse";
 	}
 };
 function computedDestructuringChannel(tokens, index) {
@@ -730,7 +733,7 @@ function inferFunction(source) {
 			const key = property?.k === "s" && channel(property.value);
 			if (key && tokens[next + 2]?.value === "]") inference[key] = true;
 			else markAllAccessed(inference);
-			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route) break;
+			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route && inference.afterResponse) break;
 			continue;
 		}
 		if (tokens[i - 1]?.value === "=" && (tokens[i - 2]?.k === "i" || tokens[i - 2]?.value === "}")) continue;
@@ -789,7 +792,7 @@ function sucrose(handler, lifeCycle) {
 				inference = mergeInference(inference, inferred);
 				merged = true;
 			} else inference = inferred;
-			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route) break;
+			if (inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.route && inference.afterResponse) break;
 		}
 	} finally {
 		events.length = 0;

package/dist/type/constants.d.ts

@@ -17,7 +17,7 @@ declare const ELYSIA_TYPES: {
   readonly NoValidate: 15;
 };
 type ELYSIA_TYPES = typeof ELYSIA_TYPES;
-declare const primitiveElysiaTypes: Set<6 | 1 | 2 | 3 | 10 | 11 | 13 | 14>;
+declare const primitiveElysiaTypes: Set<1 | 2 | 6 | 3 | 10 | 11 | 13 | 14>;
 declare const noEnumerable: {
   readonly enumerable: false;
 };

package/dist/types.d.ts

@@ -187,7 +187,7 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
 type IsTuple<T> = T extends readonly any[] ? number extends T['length'] ? false : true : false;
 type Replace<Original, Target, With> = IsAny<Target> extends true ? Original : Original extends Record<string, unknown> ? { [K in keyof Original]: Original[K] extends Target ? With : Original[K] } : Original extends Target ? With : Original;
 type EventScope = 'global' | 'local' | 'plugin';
-type GuardSchemaType = 'override' | 'standalone';
+type GuardSchemaType = 'override' | 'merge';
 type ElysiaFormData<T extends Record<keyof any, unknown>> = FormData & {
   ['~ely-form']: Replace<T, Blob | ElysiaFile, File> extends infer A ? { [key in keyof A]: IsTuple<A[key]> extends true ? A[key][number] extends Blob | ElysiaFile ? File[] : A[key] : A[key] } : T;
 };
@@ -287,7 +287,7 @@ type LocalHook<Input extends BaseMacro, Schema extends RouteSchemaWithResolvedMa
   tags?: DocumentDecoration['tags'];
 } & (Input extends any ? Input : Prettify<Input>);
 type AnyLocalHook = LocalHook<any, any, any, any, any>;
-type GuardLocalHook<Input extends BaseMacro | undefined, Schema extends RouteSchema, Singleton extends SingletonBase, Parser extends keyof any, BeforeHandle extends MaybeArray<OptionalHandler<any, any>>, AfterHandle extends MaybeArray<AfterHandler<any, any>>, ErrorHandle extends MaybeArray<ErrorHandler<any, any, any>>, GuardType extends GuardSchemaType = 'standalone'> = (Input extends any ? Input : Prettify<Input>) & {
+type GuardLocalHook<Input extends BaseMacro | undefined, Schema extends RouteSchema, Singleton extends SingletonBase, Parser extends keyof any, BeforeHandle extends MaybeArray<OptionalHandler<any, any>>, AfterHandle extends MaybeArray<AfterHandler<any, any>>, ErrorHandle extends MaybeArray<ErrorHandler<any, any, any>>, GuardType extends GuardSchemaType = 'merge'> = (Input extends any ? Input : Prettify<Input>) & {
   /**
    * @default 'override'
    * @since 1.3.0

package/dist/utils.d.ts

@@ -156,7 +156,7 @@ declare const eventProperties: Set<string>;
 declare function hookToGuard(a: Partial<AppHook & Macro> & {
   schema?: GuardSchemaType;
 }): Partial<AppHook & Macro>;
-declare function coalesceStandaloneSchemas(existing: any[], incoming: any[]): void;
+declare function coalesceSchemas(existing: any[], incoming: any[]): void;
 declare function mergeHook(a: Partial<AppHook>, b: Partial<AppHook> | undefined, reverse?: boolean, dedup?: boolean): Partial<AppHook>;
 declare const createErrorEventHandler: (fn: EventFn<"error">, error: Error) => (context: Context) => unknown;
 declare function mergeDeep<A extends Record<string, any>, B extends Record<string, any>>(target: A, source: B, skipKeys?: string[], override?: boolean, mergeArray?: boolean, seen?: WeakSet<object>, cloneAdopt?: {
@@ -177,4 +177,4 @@ declare namespace prefix {
 }
 declare function serializeMacroSeed(_key: string, value: unknown): unknown;
 //#endregion
-export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };
+export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };

package/dist/utils.js

@@ -455,7 +455,7 @@ const eventProperties = new Set([
 	"error"
 ]);
 function hookToGuard(a) {
-	if (a.schema !== "standalone") return a;
+	if (a.schema !== "merge") return a;
 	if (a.body || a.headers || a.params || a.query || a.cookie || a.response) {
 		a.schemas ??= [];
 		const schema = Object.create(null);
@@ -487,7 +487,7 @@ function hookToGuard(a) {
 	}
 	return a;
 }
-function coalesceStandaloneSchemas(existing, incoming) {
+function coalesceSchemas(existing, incoming) {
 	for (const entry of incoming) {
 		if (!entry || typeof entry !== "object") continue;
 		let merged = false;
@@ -690,7 +690,7 @@ exports.clearFlattenChainMemo = clearFlattenChainMemo;
 exports.cloneHook = cloneHook;
 exports.clonePlainDecorators = clonePlainDecorators;
 exports.clonePlainDeep = clonePlainDeep;
-exports.coalesceStandaloneSchemas = coalesceStandaloneSchemas;
+exports.coalesceSchemas = coalesceSchemas;
 exports.compactBeforeHandleConflicts = compactBeforeHandleConflicts;
 exports.compactBeforeHandlePrefix = compactBeforeHandlePrefix;
 exports.constantTimeEqual = constantTimeEqual;

package/dist/utils.mjs

@@ -454,7 +454,7 @@ const eventProperties = new Set([
 	"error"
 ]);
 function hookToGuard(a) {
-	if (a.schema !== "standalone") return a;
+	if (a.schema !== "merge") return a;
 	if (a.body || a.headers || a.params || a.query || a.cookie || a.response) {
 		a.schemas ??= [];
 		const schema = Object.create(null);
@@ -486,7 +486,7 @@ function hookToGuard(a) {
 	}
 	return a;
 }
-function coalesceStandaloneSchemas(existing, incoming) {
+function coalesceSchemas(existing, incoming) {
 	for (const entry of incoming) {
 		if (!entry || typeof entry !== "object") continue;
 		let merged = false;
@@ -684,4 +684,4 @@ function serializeMacroSeed(_key, value) {
 }
 
 //#endregion
-export { bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceStandaloneSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };
+export { bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };

package/dist/validator/route.js

@@ -5,7 +5,7 @@ const require_validator_index = require('./index.js');
 
 //#region src/validator/route.ts
 const isTb = (schema) => "~kind" in schema;
-function pickStandalone(schemas, key) {
+function pickMerge(schemas, key) {
 	if (!schemas) return;
 	const result = [];
 	for (let i = 0; i < schemas.length; i++) {
@@ -26,23 +26,23 @@ const SLOTS = [
 var RouteValidator = class {
 	constructor(route, options) {
 		if (!route) return;
-		const standaloneSchemas = options?.schemas;
+		const mergeSchemas = options?.schemas;
 		for (const [slot, coerce] of SLOTS) {
-			const standalone = pickStandalone(standaloneSchemas, slot);
-			if (!route[slot] && !standalone?.length) continue;
-			const reference = require_validator_index.Validator.reference(route[slot] ?? standalone[0], options?.models);
-			const coerces = isTb(reference) ? coerce(reference) : standalone?.find(isTb) ? coerce(standalone.find(isTb)) : void 0;
+			const merge = pickMerge(mergeSchemas, slot);
+			if (!route[slot] && !merge?.length) continue;
+			const reference = require_validator_index.Validator.reference(route[slot] ?? merge[0], options?.models);
+			const coerces = isTb(reference) ? coerce(reference) : merge?.find(isTb) ? coerce(merge.find(isTb)) : void 0;
 			this[slot] = require_validator_index.Validator.create(route[slot], {
 				...options,
 				slot,
-				schemas: standalone,
+				schemas: merge,
 				coerces
 			});
 		}
-		const responseStandalone = pickStandalone(standaloneSchemas, "response");
+		const responseMerge = pickMerge(mergeSchemas, "response");
 		this.response = require_validator_index.Validator.response(route.response, {
 			...options,
-			schemas: responseStandalone
+			schemas: responseMerge
 		});
 	}
 };

package/dist/validator/route.mjs

@@ -4,7 +4,7 @@ import { Validator } from "./index.mjs";
 
 //#region src/validator/route.ts
 const isTb = (schema) => "~kind" in schema;
-function pickStandalone(schemas, key) {
+function pickMerge(schemas, key) {
 	if (!schemas) return;
 	const result = [];
 	for (let i = 0; i < schemas.length; i++) {
@@ -25,23 +25,23 @@ const SLOTS = [
 var RouteValidator = class {
 	constructor(route, options) {
 		if (!route) return;
-		const standaloneSchemas = options?.schemas;
+		const mergeSchemas = options?.schemas;
 		for (const [slot, coerce] of SLOTS) {
-			const standalone = pickStandalone(standaloneSchemas, slot);
-			if (!route[slot] && !standalone?.length) continue;
-			const reference = Validator.reference(route[slot] ?? standalone[0], options?.models);
-			const coerces = isTb(reference) ? coerce(reference) : standalone?.find(isTb) ? coerce(standalone.find(isTb)) : void 0;
+			const merge = pickMerge(mergeSchemas, slot);
+			if (!route[slot] && !merge?.length) continue;
+			const reference = Validator.reference(route[slot] ?? merge[0], options?.models);
+			const coerces = isTb(reference) ? coerce(reference) : merge?.find(isTb) ? coerce(merge.find(isTb)) : void 0;
 			this[slot] = Validator.create(route[slot], {
 				...options,
 				slot,
-				schemas: standalone,
+				schemas: merge,
 				coerces
 			});
 		}
-		const responseStandalone = pickStandalone(standaloneSchemas, "response");
+		const responseMerge = pickMerge(mergeSchemas, "response");
 		this.response = Validator.response(route.response, {
 			...options,
-			schemas: responseStandalone
+			schemas: responseMerge
 		});
 	}
 };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "2.0.0-exp.60",
+	"version": "2.0.0-exp.61",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",