elysia 2.0.0-exp.14 → 2.0.0-exp.16

package/dist/adapter/utils.d.ts

@@ -2,7 +2,6 @@ import { StatusMap } from "../constants.js";
 import { BaseCookie } from "../cookie/types.js";
 import { HTTPHeaders } from "../types.js";
 import { Context } from "../context.js";
-
 //#region src/adapter/utils.d.ts
 declare function handleFile(response: File | Blob, set?: Context['set'], request?: Request): Response;
 declare function parseSetCookies(headers: Headers, setCookie: string[]): Headers;

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, GracefulHandler, GuardLocalHook, HTTPMethod, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, Macro, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GracefulHandler, GuardLocalHook, HTTPMethod, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { AnySchema } from "./type/types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
 import { WSHandlerResponse, WSLocalHook, WSMessageHandler } from "./ws/types.js";
@@ -685,7 +685,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    *     .get('/', ({ user }) => user, { auth: true, role: 'admin' })
    * ```
    */
-  macro<const Body, const Headers, const Query, const Params, const Cookie, 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>(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, {
     schema: Metadata['schema'];

package/dist/index.d.ts

@@ -1,7 +1,11 @@
 import { StatusMap, StatusMapBack } from "./constants.js";
-import { ElysiaError, ElysiaStatus, InternalServerError, InvalidCookieSignature, NotFound, ParseError, ValidationError, status, validationDetail } from "./error.js";
+import { ElysiaError, ElysiaStatus, InternalServerError, InvalidCookieSignature, NotFound, ParseError, SelectiveStatus, ValidationError, status, validationDetail } from "./error.js";
+import { BaseCookie, CookieOptions } from "./cookie/types.js";
+import { Cookie } from "./cookie/cookie.js";
 import { ElysiaFile, file } from "./universal/file.js";
-import { TraceEvent, TraceHandler, TraceListener, TraceProcess, TraceStream } from "./trace.js";
+import { env } from "./universal/env.js";
+import { Server } from "./universal/server.js";
+import { HTTPHeaders, SSEPayload, UnwrapSchema } from "./types.js";
 import { AnySchema, BaseSchema, StandardJSONSchemaV1Like, StandardSchemaV1Like } from "./type/types.js";
 import { FileTypeDetector, fileType, setFileTypeDetector } from "./type/elysia/file-type.js";
 import { setupTypebox } from "./type/compat.js";
@@ -9,9 +13,7 @@ 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 { SSEPayload } from "./types.js";
-import { form, redirect, sse } from "./utils.js";
+import { form, prefix, redirect, sse } from "./utils.js";
 import { Context, ErrorContext, createBaseContext, createContext } from "./context.js";
 import { Elysia } from "./base.js";
-export { type AnySchema, type BaseSchema, Compiled, type Context, Elysia, Elysia as default, ElysiaError, ElysiaFile, ElysiaStatus, type ErrorContext, type FileTypeDetector, InternalServerError, InvalidCookieSignature, Capture as Manifest, MultiValidator, NotFound, ParseError, type SSEPayload, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, StandardValidator, StatusMap, StatusMapBack, type TraceEvent, type TraceHandler, type TraceListener, type TraceProcess, type TraceStream, TypeBoxValidator, TypeSystem, ValidationError, Validator, createBaseContext, createContext, env, file, fileType, form, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };
+export { type AnySchema, type BaseCookie, type BaseSchema, Compiled, type Context, type Cookie, type CookieOptions, Elysia, Elysia as default, ElysiaError, ElysiaFile, ElysiaStatus, type ErrorContext, type FileTypeDetector, type HTTPHeaders, InternalServerError, InvalidCookieSignature, Capture as Manifest, MultiValidator, NotFound, ParseError, type SSEPayload, type SelectiveStatus, type Server, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, StandardValidator, StatusMap, StatusMapBack, TypeBoxValidator, TypeSystem, type UnwrapSchema, ValidationError, Validator, createBaseContext, createContext, env, file, fileType, form, prefix, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };

package/dist/index.js

@@ -49,6 +49,7 @@ exports.env = require_universal_env.env;
 exports.file = require_universal_file.file;
 exports.fileType = require_type_elysia_file_type.fileType;
 exports.form = require_utils.form;
+exports.prefix = require_utils.prefix;
 exports.redirect = require_utils.redirect;
 exports.setFileTypeDetector = require_type_elysia_file_type.setFileTypeDetector;
 exports.setupTypebox = require_type_compat.setupTypebox;

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { StatusMap, StatusMapBack } from "./constants.mjs";
 import { ElysiaFile, file } from "./universal/file.mjs";
-import { form, redirect, sse } from "./utils.mjs";
+import { form, prefix, redirect, sse } from "./utils.mjs";
 import { env } from "./universal/env.mjs";
 import { ElysiaError, ElysiaStatus, InternalServerError, InvalidCookieSignature, NotFound, ParseError, ValidationError, status, validationDetail } from "./error.mjs";
 import { createBaseContext, createContext } from "./context.mjs";
@@ -16,4 +16,4 @@ import { TypeSystem, t } from "./type/index.mjs";
 var src_default = Elysia;
 
 //#endregion
-export { Compiled, Elysia, ElysiaError, ElysiaFile, ElysiaStatus, InternalServerError, InvalidCookieSignature, Capture as Manifest, MultiValidator, NotFound, ParseError, StandardValidator, StatusMap, StatusMapBack, TypeBoxValidator, TypeSystem, ValidationError, Validator, createBaseContext, createContext, src_default as default, env, file, fileType, form, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };
+export { Compiled, Elysia, ElysiaError, ElysiaFile, ElysiaStatus, InternalServerError, InvalidCookieSignature, Capture as Manifest, MultiValidator, NotFound, ParseError, StandardValidator, StatusMap, StatusMapBack, TypeBoxValidator, TypeSystem, ValidationError, Validator, createBaseContext, createContext, src_default as default, env, file, fileType, form, prefix, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };

package/dist/plugin/bun.d.ts

@@ -17,7 +17,17 @@ import { BunPlugin } from "bun";
  *   outdir: 'dist',
  *   plugins: [aot('src/index.ts')]
  * })
+ *
+ * process.exit(0)
  * ```
+ *
+ * The plugin imports your entry to capture the compiled app, running its
+ * top-level code. `.listen()` is auto-skipped during build (gated on
+ * `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+ * `setInterval`, a queue consumer — keeps the process alive after the bundle
+ * is written. End the build script with `process.exit(0)` (the bundle is
+ * already on disk), or gate the side effect with
+ * `if (!process.env.ELYSIA_AOT_BUILD)`.
  */
 declare const aot: (entry: string, options?: ElysiaAotOptions) => BunPlugin;
 //#endregion

package/dist/plugin/bun.js

@@ -28,7 +28,17 @@ const realPath = (path) => {
 *   outdir: 'dist',
 *   plugins: [aot('src/index.ts')]
 * })
+*
+* process.exit(0)
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — keeps the process alive after the bundle
+* is written. End the build script with `process.exit(0)` (the bundle is
+* already on disk), or gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => ({
 	name: "elysia-aot",

package/dist/plugin/bun.mjs

@@ -26,7 +26,17 @@ const realPath = (path) => {
 *   outdir: 'dist',
 *   plugins: [aot('src/index.ts')]
 * })
+*
+* process.exit(0)
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — keeps the process alive after the bundle
+* is written. End the build script with `process.exit(0)` (the bundle is
+* already on disk), or gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => ({
 	name: "elysia-aot",

package/dist/plugin/esbuild.d.ts

@@ -16,7 +16,17 @@ import { ElysiaAotOptions } from "./core.js";
  *   outfile: 'dist/index.js',
  *   plugins: [elysiaAot('src/index.ts')]
  * })
+ *
+ * process.exit(0)
  * ```
+ *
+ * The plugin imports your entry to capture the compiled app, running its
+ * top-level code. `.listen()` is auto-skipped during build (gated on
+ * `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+ * `setInterval`, a queue consumer — keeps the process alive after the bundle
+ * is written. End the build script with `process.exit(0)` (the bundle is
+ * already on disk), or gate the side effect with
+ * `if (!process.env.ELYSIA_AOT_BUILD)`.
  */
 declare const aot: (entry: string, options?: ElysiaAotOptions) => {
   name: string;

package/dist/plugin/esbuild.js

@@ -30,7 +30,17 @@ const realPath = (path) => {
 *   outfile: 'dist/index.js',
 *   plugins: [elysiaAot('src/index.ts')]
 * })
+*
+* process.exit(0)
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — keeps the process alive after the bundle
+* is written. End the build script with `process.exit(0)` (the bundle is
+* already on disk), or gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => ({
 	name: "elysia-aot",

package/dist/plugin/esbuild.mjs

@@ -28,7 +28,17 @@ const realPath = (path) => {
 *   outfile: 'dist/index.js',
 *   plugins: [elysiaAot('src/index.ts')]
 * })
+*
+* process.exit(0)
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — keeps the process alive after the bundle
+* is written. End the build script with `process.exit(0)` (the bundle is
+* already on disk), or gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => ({
 	name: "elysia-aot",

package/dist/plugin/vite.d.ts

@@ -23,6 +23,13 @@ interface ElysiaAotVitePlugin {
  *   plugins: [aot('src/index.ts')]
  * })
  * ```
+ *
+ * The plugin imports your entry to capture the compiled app, running its
+ * top-level code. `.listen()` is auto-skipped during build (gated on
+ * `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+ * `setInterval`, a queue consumer — can keep the build process alive after
+ * the bundle is written. Gate the side effect with
+ * `if (!process.env.ELYSIA_AOT_BUILD)`.
  */
 declare const aot: (entry: string, options?: ElysiaAotOptions) => ElysiaAotVitePlugin;
 //#endregion

package/dist/plugin/vite.js

@@ -18,6 +18,13 @@ const VIRTUAL = "\0elysia/compiled";
 *   plugins: [aot('src/index.ts')]
 * })
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — can keep the build process alive after
+* the bundle is written. Gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => {
 	const entryPath = require_plugin_core.resolveEntry(entry);

package/dist/plugin/vite.mjs

@@ -17,6 +17,13 @@ const VIRTUAL = "\0elysia/compiled";
 *   plugins: [aot('src/index.ts')]
 * })
 * ```
+*
+* The plugin imports your entry to capture the compiled app, running its
+* top-level code. `.listen()` is auto-skipped during build (gated on
+* `ELYSIA_AOT_BUILD`), but any other import-time handle — a DB pool,
+* `setInterval`, a queue consumer — can keep the build process alive after
+* the bundle is written. Gate the side effect with
+* `if (!process.env.ELYSIA_AOT_BUILD)`.
 */
 const aot = (entry, options) => {
 	const entryPath = resolveEntry(entry);

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/validator/index.d.ts

@@ -1,6 +1,6 @@
+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";

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 { TraceEvent, TraceListener } from "./trace.js";
-import { CookieOptions } from "./cookie/types.js";
-import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { Serve } from "./universal/server.js";
 import { ElysiaAdapter } from "./adapter/index.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 { 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
@@ -742,6 +742,18 @@ type MacroDefSchema<K, MBody, MHeaders, MQuery, MParams, MCookie> = {
   cookie: AsMacroSchemaField<K extends keyof MCookie ? MCookie[K] : undefined>;
   response: undefined;
 };
+/**
+ * Upper bound for a macro definition's schema channel (`body`/`headers`/…):
+ * a registered model name or an inline schema.
+ *
+ * Used as the `const Body extends …` constraint on `.macro()`. It does not
+ * restrict (valid inputs already satisfy it) — it stops `Body[K]` from being a
+ * bare `unknown`, which is what lets the `| Name` in the field surface model
+ * names to autocomplete (a `unknown | Name` union collapses to `unknown`).
+ * `const` still narrows `Body[K]` to the typed literal for `UnwrapRoute`.
+ */
+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>> };
 /**
  * Parameter type of the object-form `.macro({ name: definition })`
  *
@@ -754,17 +766,7 @@ type MacroDefSchema<K, MBody, MHeaders, MQuery, MParams, MCookie> = {
  * 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> = { [K in keyof Body]: MaybeValueOrVoidFunction<{
-  body?: Body[K];
-}> } & { [K in keyof Headers]: MaybeValueOrVoidFunction<{
-  headers?: Headers[K];
-}> } & { [K in keyof Query]: MaybeValueOrVoidFunction<{
-  query?: Query[K];
-}> } & { [K in keyof Params]: MaybeValueOrVoidFunction<{
-  params?: Params[K];
-}> } & { [K in keyof Cookie]: MaybeValueOrVoidFunction<{
-  cookie?: Cookie[K];
-}> } & { [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> = 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 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 ? {
@@ -883,4 +885,4 @@ type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton ext
   subscribe: CreateWSEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Response, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>>;
 }>, Ephemeral, Volatile>;
 //#endregion
-export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GracefulHandler, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, Handler, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InlineSchemaResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, IsUnknown, JoinPath, LocalHook, Macro, MacroProperty, MacroPropertyKey, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, RouteBase, RouteSchema, SSEPayload, SingletonBase, type StandardSchemaV1Like, TraceHandler, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WrapFn };
+export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GracefulHandler, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, Handler, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InlineSchemaResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, IsUnknown, JoinPath, LocalHook, Macro, MacroProperty, MacroPropertyKey, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, RouteBase, RouteSchema, SSEPayload, SingletonBase, type StandardSchemaV1Like, TraceHandler, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WrapFn };

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
@@ -137,5 +137,9 @@ declare function pushField<K extends keyof any>(target: Record<K, unknown>, key:
 declare const requestId: any;
 declare function replaceUrlPath(url: string, path: string): string;
 declare function clonePlainDecorators<T extends Record<string, unknown>>(source: T, seen?: WeakMap<object, any>): T;
+declare function prefix<T extends string, Models extends Record<string, AnySchema>>(prefix: T, models: Models): { [k in keyof Models as `${T}.${k & string}`]: Models[k] };
+declare namespace prefix {
+  var capitalize: <T extends string, Models extends Record<string, AnySchema>>(prefix: T, models: Models) => { [k in keyof Models as `${T}.${Capitalize<k & string>}`]: Models[k] };
+}
 //#endregion
-export { ChainNode, cloneHook, clonePlainDecorators, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, hookToGuard, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, pushField, redirect, replaceUrlPath, requestId, schemaProperties, sse };
+export { ChainNode, cloneHook, clonePlainDecorators, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, hookToGuard, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, sse };

package/dist/utils.js

@@ -445,6 +445,17 @@ function clonePlainDecorators(source, seen = /* @__PURE__ */ new WeakMap()) {
 	}
 	return out;
 }
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function prefix(prefix, models) {
+	const prefixed = nullObject();
+	for (const key in models) prefixed[`${prefix}.${key}`] = models[key];
+	return prefixed;
+}
+prefix.capitalize = function prefixModelsCapitalize(prefix, models) {
+	const prefixed = nullObject();
+	for (const key in models) prefixed[`${prefix}.${capitalize(key)}`] = models[key];
+	return prefixed;
+};
 
 //#endregion
 exports.cloneHook = cloneHook;
@@ -475,6 +486,7 @@ exports.mergeDeep = mergeDeep;
 exports.mergeHook = mergeHook;
 exports.mergeResponse = mergeResponse;
 exports.nullObject = nullObject;
+exports.prefix = prefix;
 exports.pushField = pushField;
 exports.redirect = redirect;
 exports.replaceUrlPath = replaceUrlPath;

package/dist/utils.mjs

@@ -444,6 +444,17 @@ function clonePlainDecorators(source, seen = /* @__PURE__ */ new WeakMap()) {
 	}
 	return out;
 }
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function prefix(prefix, models) {
+	const prefixed = nullObject();
+	for (const key in models) prefixed[`${prefix}.${key}`] = models[key];
+	return prefixed;
+}
+prefix.capitalize = function prefixModelsCapitalize(prefix, models) {
+	const prefixed = nullObject();
+	for (const key in models) prefixed[`${prefix}.${capitalize(key)}`] = models[key];
+	return prefixed;
+};
 
 //#endregion
-export { cloneHook, clonePlainDecorators, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, hookToGuard, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, pushField, redirect, replaceUrlPath, requestId, schemaProperties, sse };
+export { cloneHook, clonePlainDecorators, coalesceStandaloneSchemas, constantTimeEqual, createErrorEventHandler, dedupedMergeArray, eventProperties, flattenChain, flattenChainMemo, fnOrigin, fnv1a, form, formToFormData, getLoosePath, hookToGuard, isBlob, isDownwardScope, isEmpty, isLocalScope, isNotEmpty, isRecordNumber, joinPath, mapMethodBack, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, sse };

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.14",
+	"version": "2.0.0-exp.16",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",