elysia 2.0.0-exp.36 → 2.0.0-exp.38

package/dist/base.d.ts

@@ -1,8 +1,8 @@
 import { ElysiaStatus } from "./error.js";
 import { TraceHandler } from "./trace.js";
-import { AnySchema } from "./type/types.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, 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, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { AnySchema } from "./type/types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { WSHandlerResponse, WSLocalHook, WSMessageHandler } from "./ws/types.js";
@@ -523,9 +523,9 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    *     .get('/', ({ user }) => user, { auth: true, role: 'admin' })
    * ```
    */
-  macro<const Body extends MacroSchemaChannel<Definitions>, const Headers extends MacroSchemaChannel<Definitions>, const Query extends MacroSchemaChannel<Definitions>, const Params extends MacroSchemaChannel<Definitions>, const Cookie extends MacroSchemaChannel<Definitions>, const NewMacro>(macro: ObjectMacroDefs<Body, Headers, Query, Params, Cookie, NewMacro, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>, Singleton & {
+  macro<const Body extends MacroSchemaChannel<Definitions>, const Headers extends MacroSchemaChannel<Definitions>, const Query extends MacroSchemaChannel<Definitions>, const Params extends MacroSchemaChannel<Definitions>, const Cookie extends MacroSchemaChannel<Definitions>, const NewMacro, const Refs = {}>(macro: ObjectMacroDefs<Body, Headers, Query, Params, Cookie, NewMacro, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>, Singleton & {
     derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
-  }, Definitions, Metadata['macro']>): Elysia<BasePath, Scope, Singleton, Definitions, {
+  }, Definitions, Metadata['macro'], Metadata['macroFn'], Refs>): Elysia<BasePath, Scope, Singleton, Definitions, {
     schema: Metadata['schema'];
     schemas: Metadata['schemas'];
     macro: Metadata['macro'] & Partial<MacroToProperty<NewMacro>>;

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

@@ -1,5 +1,5 @@
-import { CapturedValidator, FrozenValidator } from "../aot.js";
 import { AnyLocalHook, HTTPMethod } from "../../types.js";
+import { CapturedValidator, FrozenValidator } from "../aot.js";
 import { AnyElysia } from "../../base.js";
 
 //#region src/compile/handler/frozen-validator.d.ts
@@ -23,7 +23,9 @@ interface FrozenRouteValidatorShape {
   cookie?: FrozenSlotValidator;
   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 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 };
+export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isStandardSchema, standaloneAllStandard };

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

@@ -3,6 +3,7 @@ const require_utils = require('../../utils.js');
 const require_type_constants = require('../../type/constants.js');
 const require_error = require('../../error.js');
 const require_compile_aot = require('../aot.js');
+const require_validator_index = require('../../validator/index.js');
 const require_type_validator_clean_safe = require('../../type/validator/clean-safe.js');
 
 //#region src/compile/handler/frozen-validator.ts
@@ -111,6 +112,15 @@ const REQUEST_SLOTS = [
 	"params",
 	"cookie"
 ];
+const isStandardSchema = (schema) => schema != null && typeof schema === "object" && "~standard" in schema;
+function standaloneAllStandard(schemas) {
+	if (!schemas || schemas.length === 0) return true;
+	for (const entry of schemas) for (const key in entry) {
+		const value = entry[key];
+		if (value && !isStandardSchema(value)) return false;
+	}
+	return true;
+}
 function resolveModelRef(schema, root) {
 	if (typeof schema !== "string") return schema;
 	const models = root["~ext"]?.models;
@@ -126,6 +136,10 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 		if (!raw) continue;
 		const schema = resolveModelRef(raw, root);
 		if (!schema) return void 0;
+		if (isStandardSchema(schema)) {
+			out[slot] = new require_validator_index.StandardValidator(schema);
+			continue;
+		}
 		const frozen = require_compile_aot.Compiled.getValidator(method, path, slot);
 		if (!frozen) return void 0;
 		let coerced = schema;
@@ -146,6 +160,10 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 			if (!raw) continue;
 			const schema = resolveModelRef(raw, root);
 			if (!schema) return void 0;
+			if (isStandardSchema(schema)) {
+				responseOut[status] = new require_validator_index.StandardValidator(schema);
+				continue;
+			}
 			const frozen = require_compile_aot.Compiled.getValidator(method, path, `response:${status}`);
 			if (!frozen || !isBridgeFreeComplete(frozen, schema, schema)) return void 0;
 			responseOut[status] = new FrozenSlotValidator(frozen, schema, schema, normalize);
@@ -174,4 +192,6 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 //#endregion
 exports.buildFrozenRouteValidator = buildFrozenRouteValidator;
 exports.isBridgeNotInitialized = isBridgeNotInitialized;
-exports.isCapturedBridgeFree = isCapturedBridgeFree;
+exports.isCapturedBridgeFree = isCapturedBridgeFree;
+exports.isStandardSchema = isStandardSchema;
+exports.standaloneAllStandard = standaloneAllStandard;

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

@@ -2,6 +2,7 @@ import { nullObject } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../../type/constants.mjs";
 import { ValidationError } from "../../error.mjs";
 import { Compiled, EMPTY_EXTERNALS, reconstruct } from "../aot.mjs";
+import { StandardValidator } from "../../validator/index.mjs";
 import { isFullyClosedObject } from "../../type/validator/clean-safe.mjs";
 
 //#region src/compile/handler/frozen-validator.ts
@@ -110,6 +111,15 @@ const REQUEST_SLOTS = [
 	"params",
 	"cookie"
 ];
+const isStandardSchema = (schema) => schema != null && typeof schema === "object" && "~standard" in schema;
+function standaloneAllStandard(schemas) {
+	if (!schemas || schemas.length === 0) return true;
+	for (const entry of schemas) for (const key in entry) {
+		const value = entry[key];
+		if (value && !isStandardSchema(value)) return false;
+	}
+	return true;
+}
 function resolveModelRef(schema, root) {
 	if (typeof schema !== "string") return schema;
 	const models = root["~ext"]?.models;
@@ -125,6 +135,10 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 		if (!raw) continue;
 		const schema = resolveModelRef(raw, root);
 		if (!schema) return void 0;
+		if (isStandardSchema(schema)) {
+			out[slot] = new StandardValidator(schema);
+			continue;
+		}
 		const frozen = Compiled.getValidator(method, path, slot);
 		if (!frozen) return void 0;
 		let coerced = schema;
@@ -145,6 +159,10 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 			if (!raw) continue;
 			const schema = resolveModelRef(raw, root);
 			if (!schema) return void 0;
+			if (isStandardSchema(schema)) {
+				responseOut[status] = new StandardValidator(schema);
+				continue;
+			}
 			const frozen = Compiled.getValidator(method, path, `response:${status}`);
 			if (!frozen || !isBridgeFreeComplete(frozen, schema, schema)) return void 0;
 			responseOut[status] = new FrozenSlotValidator(frozen, schema, schema, normalize);
@@ -171,4 +189,4 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 }
 
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree };
+export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isStandardSchema, standaloneAllStandard };

package/dist/compile/lexer.d.ts

@@ -1,5 +1,5 @@
 //#region src/compile/lexer.d.ts
-declare const isSpace: (ch: string) => ch is "\n" | " " | "\t" | "\r";
+declare const isSpace: (ch: string) => ch is " " | "\n" | "\t" | "\r";
 declare const isIdentChar: (ch: string) => boolean;
 declare const isIdentCharCode: (code: number) => boolean;
 declare function skipString(src: string, start: number): number;

package/dist/index.d.ts

@@ -1,9 +1,12 @@
 import { StatusMap, StatusMapBack } from "./constants.js";
 import { ElysiaError, ElysiaStatus, InternalServerError, NotFound, ParseError, Problem, SelectiveStatus, ValidationError, problem, status, validationDetail } from "./error.js";
-import { ElysiaFile, file } from "./universal/file.js";
 import { BaseCookie, CookieOptions } from "./cookie/types.js";
 import { Cookie } from "./cookie/cookie.js";
 import { InvalidCookie } from "./cookie/error.js";
+import { ElysiaFile, file } from "./universal/file.js";
+import { env } from "./universal/env.js";
+import { Server } from "./universal/server.js";
+import { HTTPHeaders, InputSchema, Macro, MacroToContext, MacroToProperty, RouteSchema, SSEPayload, UnwrapRoute, UnwrapSchema } from "./types.js";
 import { AnySchema, BaseSchema, StandardJSONSchemaV1Like, StandardSchemaV1Like } from "./type/types.js";
 import { TCookieField, TCookieObject } from "./type/elysia/cookie.js";
 import { FileTypeDetector, fileType, setFileTypeDetector } from "./type/elysia/file-type.js";
@@ -13,9 +16,6 @@ import { Capture, Compiled } from "./compile/aot.js";
 import { MultiValidator, StandardValidator, Validator } from "./validator/index.js";
 import { TypeBoxValidator } from "./type/validator/index.js";
 import { TypeSystem, t } from "./type/index.js";
-import { env } from "./universal/env.js";
-import { Server } from "./universal/server.js";
-import { HTTPHeaders, InputSchema, Macro, MacroToContext, MacroToProperty, RouteSchema, SSEPayload, UnwrapRoute, UnwrapSchema } from "./types.js";
 import { form, prefix, redirect, sse } from "./utils.js";
 import { Context, ErrorContext, createBaseContext, createContext } from "./context.js";
 import { AnyElysia, Elysia } from "./base.js";

package/dist/plugin/core.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_compile_handler_frozen_validator = require('../compile/handler/frozen-validator.js');
 const require_compile_handler_index = require('../compile/handler/index.js');
 const require_plugin_source = require('./source.js');
 let node_fs = require("node:fs");
@@ -250,6 +251,14 @@ async function generateCompiledModule(file, options) {
 	return (await generateCompiledArtifacts(file, options)).source;
 }
 const _importedEntries = /* @__PURE__ */ new Set();
+function isStandardResponse(response) {
+	if (response == null || typeof response !== "object") return false;
+	if (require_compile_handler_frozen_validator.isStandardSchema(response)) return true;
+	if ("~kind" in response || "~elyAcl" in response) return false;
+	const entries = Object.values(response);
+	if (entries.length === 0) return false;
+	return entries.every((v) => require_compile_handler_frozen_validator.isStandardSchema(v));
+}
 async function generateCompiledArtifacts(file, options) {
 	const previousAotBuild = process.env.ELYSIA_AOT_BUILD;
 	process.env.ELYSIA_AOT_BUILD = "1";
@@ -299,15 +308,28 @@ async function generateCompiledArtifacts(file, options) {
 			const [, , , instance, hook, appHook, inheritedChain, macroScope] = route;
 			const hooks = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, typedApp, macroScope);
 			if (!hooks) continue;
-			if (Array.isArray(hooks.schemas) && hooks.schemas.length > 0) routesForbidSeal = true;
+			let routeHasTypeBoxDirectSlot = false;
 			for (const slot of [
 				"body",
 				"query",
 				"params",
 				"headers",
-				"cookie",
-				"response"
-			]) if (hooks[slot] !== void 0) expectedSlots++;
+				"cookie"
+			]) {
+				const value = hooks[slot];
+				if (value === void 0) continue;
+				if (require_compile_handler_frozen_validator.isStandardSchema(value)) continue;
+				routeHasTypeBoxDirectSlot = true;
+				expectedSlots++;
+			}
+			if (hooks.response !== void 0 && !isStandardResponse(hooks.response)) {
+				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;
+			}
 		}
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;
 		const frozenSlots = artifacts.validators.length;

package/dist/plugin/core.mjs

@@ -1,3 +1,4 @@
+import { isStandardSchema, standaloneAllStandard } 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";
@@ -248,6 +249,14 @@ async function generateCompiledModule(file, options) {
 	return (await generateCompiledArtifacts(file, options)).source;
 }
 const _importedEntries = /* @__PURE__ */ new Set();
+function isStandardResponse(response) {
+	if (response == null || typeof response !== "object") return false;
+	if (isStandardSchema(response)) return true;
+	if ("~kind" in response || "~elyAcl" in response) return false;
+	const entries = Object.values(response);
+	if (entries.length === 0) return false;
+	return entries.every((v) => isStandardSchema(v));
+}
 async function generateCompiledArtifacts(file, options) {
 	const previousAotBuild = process.env.ELYSIA_AOT_BUILD;
 	process.env.ELYSIA_AOT_BUILD = "1";
@@ -297,15 +306,28 @@ async function generateCompiledArtifacts(file, options) {
 			const [, , , instance, hook, appHook, inheritedChain, macroScope] = route;
 			const hooks = composeRouteHook(instance, hook, appHook, inheritedChain, typedApp, macroScope);
 			if (!hooks) continue;
-			if (Array.isArray(hooks.schemas) && hooks.schemas.length > 0) routesForbidSeal = true;
+			let routeHasTypeBoxDirectSlot = false;
 			for (const slot of [
 				"body",
 				"query",
 				"params",
 				"headers",
-				"cookie",
-				"response"
-			]) if (hooks[slot] !== void 0) expectedSlots++;
+				"cookie"
+			]) {
+				const value = hooks[slot];
+				if (value === void 0) continue;
+				if (isStandardSchema(value)) continue;
+				routeHasTypeBoxDirectSlot = true;
+				expectedSlots++;
+			}
+			if (hooks.response !== void 0 && !isStandardResponse(hooks.response)) {
+				routeHasTypeBoxDirectSlot = true;
+				expectedSlots++;
+			}
+			const standalone = hooks.schemas;
+			if (Array.isArray(standalone) && standalone.length > 0) {
+				if (routeHasTypeBoxDirectSlot || !standaloneAllStandard(standalone)) routesForbidSeal = true;
+			}
 		}
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;
 		const frozenSlots = artifacts.validators.length;

package/dist/type/bridge.d.ts

@@ -1,17 +1,17 @@
-import { Intersect as Intersect$1 } from "./elysia/intersect.js";
+import { Intersect as Intersect$2 } from "./elysia/intersect.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
 import { hasTypes as hasTypes$1 } from "./utils.js";
 import { TypeBoxValidatorCache as TypeBoxValidatorCache$1 } from "./validator/validator-cache.js";
 import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
 import { Compile as Compile$1 } from "typebox/compile";
-import { Clone as Clone$1, Create as Create$1, Decode as Decode$1, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
+import { Clone as Clone$1, Create as Create$1, Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {
   Compile: typeof Compile$1;
   Create: typeof Create$1;
-  Decode: typeof Decode$1;
+  Decode: typeof Decode$2;
   applyCoercions: typeof applyCoercions$1;
   TypeBoxValidator: TypeBoxValidator$1;
   TypeBoxValidatorCache: TypeBoxValidatorCache$1;
@@ -22,14 +22,14 @@ interface TypeboxModule {
   coerceBody: typeof coerceBody$1;
   hasTypes: typeof hasTypes$1;
   HasCodec: typeof HasCodec$1;
-  Intersect: typeof Intersect$1;
+  Intersect: typeof Intersect$2;
   Default: typeof Default$1;
   Ref: typeof Ref$1;
   Clone: typeof Clone$1;
 }
 declare let Compile: typeof Compile$1;
 declare let Create: typeof Create$1;
-declare let Decode: typeof Decode$1;
+declare let Decode: typeof Decode$2;
 declare let applyCoercions: typeof applyCoercions$1;
 declare let TypeBoxValidator: TypeBoxValidator$1;
 type TypeBoxValidator<T extends TSchema = TAny> = TypeBoxValidator$1<T>;
@@ -42,7 +42,7 @@ declare let coerceStringToStructure: typeof coerceStringToStructure$1;
 declare let coerceBody: typeof coerceBody$1;
 declare let hasTypes: typeof hasTypes$1;
 declare let HasCodec: typeof HasCodec$1;
-declare let Intersect: typeof Intersect$1;
+declare let Intersect: typeof Intersect$2;
 declare let Default: typeof Default$1;
 declare let Ref: typeof Ref$1;
 declare let Clone: typeof Clone$1;

package/dist/type/elysia/file-type.d.ts

@@ -1,5 +1,5 @@
-import { FileType, FileUnit } from "../types.js";
 import { MaybeArray, MaybePromise } from "../../types.js";
+import { FileType, FileUnit } from "../types.js";
 
 //#region src/type/elysia/file-type.d.ts
 type FileTypeDetector = (file: File) => MaybePromise<string | {

package/dist/type/types.d.ts

@@ -1,9 +1,9 @@
 import { ELYSIA_TYPES } from "./constants.js";
 import { CookieOptions } from "../cookie/types.js";
 import { MaybeArray } from "../types.js";
+import { Validator } from "typebox/schema";
 import { TObjectOptions, TSchemaOptions } from "typebox";
 import { TLocalizedValidationError } from "typebox/error";
-import { Validator } from "typebox/schema";
 
 //#region src/type/types.d.ts
 type FileUnit = number | `${number}${'k' | 'm'}`;

package/dist/type/validator/index.d.ts

@@ -1,9 +1,9 @@
+import { MaybePromise } from "../../types.js";
 import { Validator as Validator$1, ValidatorOptions } from "../../validator/index.js";
 import { TypeBoxValidatorCache } from "./validator-cache.js";
-import { MaybePromise } from "../../types.js";
 import { Static, StaticDecode, StaticEncode, TAny, TSchema } from "typebox/type";
-import { TLocalizedValidationError } from "typebox/error";
 import { Validator } from "typebox/schema";
+import { TLocalizedValidationError } from "typebox/error";
 
 //#region src/type/validator/index.d.ts
 declare function shallowMergeObjects(members: any[]): TSchema | null;

package/dist/types.d.ts

@@ -1,17 +1,17 @@
 import { MethodMap, StatusMapBack } from "./constants.js";
 import { ElysiaError, ElysiaStatus } from "./error.js";
+import { CookieOptions } from "./cookie/types.js";
 import { ElysiaFile } from "./universal/file.js";
 import { TraceHandler } from "./trace.js";
-import { CookieOptions } from "./cookie/types.js";
-import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { Serve } from "./universal/server.js";
+import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext, PreContext } from "./context.js";
 import { WebSocketHandler } from "./ws/types.js";
 import { AnyElysia, Elysia } from "./base.js";
 import { ElysiaAdapter } from "./adapter/index.js";
-import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
 import { Instruction } from "exact-mirror";
+import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/types.d.ts
@@ -496,7 +496,7 @@ interface PublicRoute {
   websocket?: AnyWSLocalHook;
 }
 type MaybeValueOrVoidFunction<T> = T | ((...a: any) => void | T);
-interface MacroProperty<in out Macro extends BaseMacro = {}, in out TypedRoute extends RouteSchema = {}, in out Singleton extends SingletonBase = DefaultSingleton, Errors extends ErrorDefinition[] = []> {
+type MacroProperty<Macro extends BaseMacro = {}, TypedRoute extends RouteSchema = {}, Singleton extends SingletonBase = DefaultSingleton, Errors extends ErrorDefinition[] = []> = Macro & {
   /**
    * Deduplication similar to Elysia.constructor.seed
    */
@@ -516,7 +516,7 @@ interface MacroProperty<in out Macro extends BaseMacro = {}, in out TypedRoute e
    * @param option
    */
   introspect?(option: Prettify<Macro>): unknown;
-}
+};
 interface Macro<in out Macro extends BaseMacro = {}, in out Input extends BaseMacro = {}, in out TypedRoute extends RouteSchema = {}, in out Singleton extends SingletonBase = DefaultSingleton, Errors extends ErrorDefinition[] = []> {
   [K: keyof any]: MaybeValueOrVoidFunction<Input & MacroProperty<Macro, TypedRoute, Singleton, Errors>>;
 }
@@ -723,6 +723,23 @@ type MacroDefSchema<K, MBody, MHeaders, MQuery, MParams, MCookie> = {
 };
 type MacroSchemaChannel<Definitions extends DefinitionBase> = Record<keyof any, AnySchema | (keyof Definitions['typebox'] & string)>;
 type MacroChannel<Channel, Key extends keyof InputSchema, Definitions extends DefinitionBase> = { [K in keyof Channel]: MaybeValueOrVoidFunction<{ [F in Key]?: Channel[K] | (keyof Definitions['typebox'] & string) } & Record<string, unknown>> };
+/**
+ * Captures the verbatim `.macro()` definition record into a separate first-pass
+ * generic (mirrors {@link MacroChannel}). This lets each definition's enabled
+ * sibling flags (`{ auth: true }`) be read back without reusing the contextually
+ * typed `NewMacro`, which would form the record -> handler-typing inference
+ * cycle documented on {@link ObjectMacroDefs}.
+ */
+type MacroRefChannel<Refs> = { [K in keyof Refs]: MaybeValueOrVoidFunction<{ [M in keyof Refs[K]]?: Refs[K][M] } & Record<string, unknown>> };
+/**
+ * `resolve` (derive) context contributed by the sibling macros a definition
+ * enables via `{ name: true }`. Extracted through `infer` because
+ * {@link MacroToContext} is a mapped type whose `resolve` key cannot be indexed
+ * with a plain `['resolve']` on the generic form.
+ */
+type MacroRefResolve<MacroFn, SelectedMacro, Definitions> = MacroToContext<MacroFn, SelectedMacro, Definitions> extends {
+  resolve: infer Resolve;
+} ? Resolve : {};
 /**
  * Parameter type of the object-form `.macro({ name: definition })`
  *
@@ -735,7 +752,9 @@ type MacroChannel<Channel, Key extends keyof InputSchema, Definitions extends De
  * still flow into `N` (the verbatim definitions, stored in
  * `Metadata['macroFn']` for the consuming route)
  */
-type ObjectMacroDefs<Body, Headers, Query, Params, Cookie, N, AmbientSchema extends RouteSchema, ScopedSchemas extends RouteSchema, Singleton extends SingletonBase, Definitions extends DefinitionBase, MacroNames extends BaseMacro> = MacroChannel<Body, 'body', Definitions> & MacroChannel<Headers, 'headers', Definitions> & MacroChannel<Query, 'query', Definitions> & MacroChannel<Params, 'params', Definitions> & MacroChannel<Cookie, 'cookie', Definitions> & { [K in keyof N]: MaybeValueOrVoidFunction<MacroProperty<MacroNames & InputSchema<keyof Definitions['typebox'] & string>, IntersectIfObjectSchema<MergeSchema<UnwrapMacroSchema<MacroDefSchema<K, Body, Headers, Query, Params, Cookie>, Definitions['typebox']>, AmbientSchema>, ScopedSchemas>, Singleton, Definitions['error']>> } & { [K in keyof N]: N[K] extends ((...a: any[]) => any) ? unknown : string extends keyof N[K] ? unknown : { [P in Exclude<keyof N[K], MacroPropertyKey | InputSchemaKey | keyof MacroNames | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
+type ObjectMacroDefs<Body, Headers, Query, Params, Cookie, N, AmbientSchema extends RouteSchema, ScopedSchemas extends RouteSchema, Singleton extends SingletonBase, Definitions extends DefinitionBase, MacroNames extends BaseMacro, MacroFn = {}, Refs = {}> = MacroChannel<Body, 'body', Definitions> & MacroChannel<Headers, 'headers', Definitions> & MacroChannel<Query, 'query', Definitions> & MacroChannel<Params, 'params', Definitions> & MacroChannel<Cookie, 'cookie', Definitions> & MacroRefChannel<Refs> & { [K in keyof N]: MaybeValueOrVoidFunction<MacroProperty<MacroNames & InputSchema<keyof Definitions['typebox'] & string>, IntersectIfObjectSchema<MergeSchema<UnwrapMacroSchema<MacroDefSchema<K, Body, Headers, Query, Params, Cookie>, Definitions['typebox']>, AmbientSchema>, ScopedSchemas>, Singleton & {
+  derive: Singleton['derive'] & MacroRefResolve<MacroFn, K extends keyof Refs ? Refs[K] : {}, Definitions['typebox']>;
+}, Definitions['error']>> } & { [K in keyof N]: N[K] extends ((...a: any[]) => any) ? unknown : string extends keyof N[K] ? unknown : { [P in Exclude<keyof N[K], MacroPropertyKey | InputSchemaKey | keyof MacroNames | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
 type CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `/${infer Rest}` ? _CreateEden<Rest, Property> : Path extends '' | '/' ? Property : _CreateEden<Path, Property>;
 type _CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `${infer Start}/${infer Rest}` ? { [x in Start]: _CreateEden<Rest, Property> } : Path extends '' ? Property : { [x in Path]: Property };
 type CreateEdenResponse<Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Res extends PossibleResponse, Err extends Error = never> = RouteSchema extends MacroContext ? {

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import { MethodMap } from "./constants.js";
-import { AnySchema, StandardSchemaV1Like } from "./type/types.js";
 import { AnyLocalHook, AppHook, ElysiaFormData, EventFn, EventScope, GuardSchemaType, InputSchema, Macro, MaybeArray, Prettify, SSEPayload } from "./types.js";
+import { AnySchema, StandardSchemaV1Like } from "./type/types.js";
 import { Context } from "./context.js";
 
 //#region src/utils.d.ts

package/dist/validator/index.d.ts

@@ -1,8 +1,8 @@
+import { ElysiaConfig, MaybePromise } from "../types.js";
 import { AnySchema, StandardSchemaV1Like } from "../type/types.js";
 import { CoerceOption } from "../type/coerce.js";
 import { ValidatorSlot } from "../compile/aot.js";
 import { TypeBoxValidator } from "../type/bridge.js";
-import { ElysiaConfig, MaybePromise } from "../types.js";
 import { TSchema } from "typebox/type";
 import { TLocalizedValidationError } from "typebox/error";
 

package/package.json

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