alepha 0.14.3 → 0.15.0

package/dist/core/index.d.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { Validator } from "typebox/compile";
 import * as typebox0 from "typebox";
 import { Static as Static$1, StaticDecode, StaticDecode as Static, StaticEncode, StaticEncode as StaticEncode$1, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TInterface, TKeysToIndexer, TKeysToIndexer as TKeysToIndexer$1, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOmit, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPartial, TPick, TPick as TPick$1, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TUnsafe as TUnsafe$1, TVoid, Type } from "typebox";
 import Format from "typebox/format";
 import * as Value from "typebox/value";
+import { Validator } from "typebox/compile";
 import { TLocalizedValidationError } from "typebox/error";
 import { Readable } from "node:stream";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
@@ -45,19 +45,19 @@ type AbstractClass<T extends object = any> = abstract new (...args: any[]) => T;
  */
 interface ServiceSubstitution<T extends object = any> {
   /**
-   * Every time someone asks for this class, it will be provided with the 'use' class.
-   */
+       * Every time someone asks for this class, it will be provided with the 'use' class.
+       */
   provide: Service<T>;
   /**
-   * Service to use instead of the 'provide' service.
-   *
-   * Syntax is inspired by Angular's DI system.
-   */
+       * Service to use instead of the 'provide' service.
+       *
+       * Syntax is inspired by Angular's DI system.
+       */
   use: Service<T>;
   /**
-   * If true, if the service already exists -> just ignore the substitution and do not throw an error.
-   * Mostly used for plugins to enforce a substitution without throwing an error.
-   */
+       * If true, if the service already exists -> just ignore the substitution and do not throw an error.
+       * Mostly used for plugins to enforce a substitution without throwing an error.
+       */
   optional?: boolean;
 }
 /**
@@ -90,8 +90,8 @@ declare abstract class Primitive<T extends object = {}> {
   readonly config: PrimitiveConfig;
   constructor(args: PrimitiveArgs<T>);
   /**
-   * Called automatically by Alepha after the primitive is created.
-   */
+       * Called automatically by Alepha after the primitive is created.
+       */
   protected onInit(): void;
 }
 type PrimitiveFactory<TPrimitive extends Primitive = Primitive> = {
@@ -155,55 +155,55 @@ interface TypeBoxErrorParams {
 //#region ../../src/core/helpers/FileLike.d.ts
 interface FileLike {
   /**
-   * Filename.
-   * @default "file"
-   */
+       * Filename.
+       * @default "file"
+       */
   name: string;
   /**
-   * Mandatory MIME type of the file.
-   * @default "application/octet-stream"
-   */
+       * Mandatory MIME type of the file.
+       * @default "application/octet-stream"
+       */
   type: string;
   /**
-   * Size of the file in bytes.
-   *
-   * Always 0 for streams, as the size is not known until the stream is fully read.
-   *
-   * @default 0
-   */
+       * Size of the file in bytes.
+       *
+       * Always 0 for streams, as the size is not known until the stream is fully read.
+       *
+       * @default 0
+       */
   size: number;
   /**
-   * Last modified timestamp in milliseconds since epoch.
-   *
-   * Always the current timestamp for streams, as the last modified time is not known.
-   * We use this field to ensure compatibility with File API.
-   *
-   * @default Date.now()
-   */
+       * Last modified timestamp in milliseconds since epoch.
+       *
+       * Always the current timestamp for streams, as the last modified time is not known.
+       * We use this field to ensure compatibility with File API.
+       *
+       * @default Date.now()
+       */
   lastModified: number;
   /**
-   * Returns a ReadableStream or Node.js Readable stream of the file content.
-   *
-   * For streams, this is the original stream.
-   */
+       * Returns a ReadableStream or Node.js Readable stream of the file content.
+       *
+       * For streams, this is the original stream.
+       */
   stream(): StreamLike;
   /**
-   * Returns the file content as an ArrayBuffer.
-   *
-   * For streams, this reads the entire stream into memory.
-   */
+       * Returns the file content as an ArrayBuffer.
+       *
+       * For streams, this reads the entire stream into memory.
+       */
   arrayBuffer(): Promise<ArrayBuffer>;
   /**
-   * Returns the file content as a string.
-   *
-   * For streams, this reads the entire stream into memory and converts it to a string.
-   */
+       * Returns the file content as a string.
+       *
+       * For streams, this reads the entire stream into memory and converts it to a string.
+       */
   text(): Promise<string>;
   /**
-   * Optional file path, if the file is stored on disk.
-   *
-   * This is not from the File API, but rather a custom field to indicate where the file is stored.
-   */
+       * Optional file path, if the file is stored on disk.
+       *
+       * This is not from the File API, but rather a custom field to indicate where the file is stored.
+       */
   filepath?: string;
 }
 /**
@@ -259,47 +259,47 @@ declare class TypeProvider {
   static setLocale(locale: string): void;
   static isValidBigInt(value: string | number): boolean;
   /**
-   * Default maximum length for strings.
-   *
-   * It can be set to a larger value:
-   * ```ts
-   * TypeProvider.DEFAULT_STRING_MAX_LENGTH = 1000000;
-   * TypeProvider.DEFAULT_STRING_MAX_LENGTH = undefined; // no limit (not recommended)
-   * ```
-   */
+       * Default maximum length for strings.
+       *
+       * It can be set to a larger value:
+       * ```ts
+       * TypeProvider.DEFAULT_STRING_MAX_LENGTH = 1000000;
+       * TypeProvider.DEFAULT_STRING_MAX_LENGTH = undefined; // no limit (not recommended)
+       * ```
+       */
   static DEFAULT_STRING_MAX_LENGTH: number | undefined;
   /**
-   * Maximum length for short strings, such as names or titles.
-   */
+       * Maximum length for short strings, such as names or titles.
+       */
   static DEFAULT_SHORT_STRING_MAX_LENGTH: number | undefined;
   /**
-   * Maximum length for long strings, such as descriptions or comments.
-   * It can be overridden in the string options.
-   *
-   * It can be set to a larger value:
-   * ```ts
-   * TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH = 2048;
-   * ```
-   */
+       * Maximum length for long strings, such as descriptions or comments.
+       * It can be overridden in the string options.
+       *
+       * It can be set to a larger value:
+       * ```ts
+       * TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH = 2048;
+       * ```
+       */
   static DEFAULT_LONG_STRING_MAX_LENGTH: number | undefined;
   /**
-   * Maximum length for rich strings, such as HTML or Markdown.
-   * This is a large value to accommodate rich text content.
-   * > It's also the maximum length of PG's TEXT type.
-   *
-   * It can be overridden in the string options.
-   *
-   * It can be set to a larger value:
-   * ```ts
-   * TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH = 1000000;
-   * ```
-   */
+       * Maximum length for rich strings, such as HTML or Markdown.
+       * This is a large value to accommodate rich text content.
+       * > It's also the maximum length of PG's TEXT type.
+       *
+       * It can be overridden in the string options.
+       *
+       * It can be set to a larger value:
+       * ```ts
+       * TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH = 1000000;
+       * ```
+       */
   static DEFAULT_RICH_STRING_MAX_LENGTH: number | undefined;
   /**
-   * Maximum number of items in an array.
-   * This is a default value to prevent excessive memory usage.
-   * It can be overridden in the array options.
-   */
+       * Maximum number of items in an array.
+       * This is a default value to prevent excessive memory usage.
+       * It can be overridden in the array options.
+       */
   static DEFAULT_ARRAY_MAX_ITEMS: number;
   raw: typeof Type;
   any: typeof Type.Any;
@@ -312,16 +312,16 @@ declare class TypeProvider {
   const: typeof Type.Literal;
   options: typeof Type.Options;
   /**
-   * Type guards to check the type of schema.
-   * This is not a runtime type check, but a compile-time type guard.
-   *
-   * @example
-   * ```ts
-   * if (t.schema.isString(schema)) {
-   *   // schema is TString
-   * }
-   * ```
-   */
+       * Type guards to check the type of schema.
+       * This is not a runtime type check, but a compile-time type guard.
+       *
+       * @example
+       * ```ts
+       * if (t.schema.isString(schema)) {
+       *   // schema is TString
+       * }
+       * ```
+       */
   readonly schema: TypeGuard;
   extend<T extends TSchema$1[], U extends TProperties$1>(schema: [...T], properties: U, options?: TSchemaOptions): TInterface<T, U>;
   extend<T extends TObject$1, U extends TProperties$1>(schema: T, properties: U, options?: TSchemaOptions): TInterface<[T], U>;
@@ -329,76 +329,76 @@ declare class TypeProvider {
   omit<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TOmit<T, TKeysToIndexer$1<Indexer>>;
   partial<T extends TSchema$1>(schema: T, options?: TSchemaOptions): TPartial<T>;
   /**
-   * Create a schema for an object.
-   * By default, additional properties are not allowed.
-   *
-   * @example
-   * ```ts
-   * const userSchema = t.object({
-   *   id: t.integer(),
-   *   name: t.string(),
-   * });
-   * ```
-   */
+       * Create a schema for an object.
+       * By default, additional properties are not allowed.
+       *
+       * @example
+       * ```ts
+       * const userSchema = t.object({
+       *   id: t.integer(),
+       *   name: t.string(),
+       * });
+       * ```
+       */
   object<T extends TProperties$1>(properties: T, options?: TObjectOptions$1): TObject$1<T>;
   /**
-   * Create a schema for an array.
-   * By default, the maximum number of items is limited to prevent excessive memory usage.
-   *
-   * @see TypeProvider.DEFAULT_ARRAY_MAX_ITEMS
-   */
+       * Create a schema for an array.
+       * By default, the maximum number of items is limited to prevent excessive memory usage.
+       *
+       * @see TypeProvider.DEFAULT_ARRAY_MAX_ITEMS
+       */
   array<T extends TSchema$1>(schema: T, options?: TArrayOptions): TArray$1<T>;
   /**
-   * Create a schema for a string.
-   * For db or input fields, consider using `t.text()` instead, which has length limits.
-   *
-   * If you need a string with specific format (e.g. email, uuid), consider using the corresponding method (e.g. `t.email()`, `t.uuid()`).
-   */
+       * Create a schema for a string.
+       * For db or input fields, consider using `t.text()` instead, which has length limits.
+       *
+       * If you need a string with specific format (e.g. email, uuid), consider using the corresponding method (e.g. `t.email()`, `t.uuid()`).
+       */
   string(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for a string with length limits.
-   * For internal strings without length limits, consider using `t.string()` instead.
-   *
-   * Default size is "regular", which has a max length of 255 characters.
-   */
+       * Create a schema for a string with length limits.
+       * For internal strings without length limits, consider using `t.string()` instead.
+       *
+       * Default size is "regular", which has a max length of 255 characters.
+       */
   text(options?: TTextOptions): TString$1;
   /**
-   * Create a schema for a JSON object.
-   * This is a record with string keys and any values.
-   */
+       * Create a schema for a JSON object.
+       * This is a record with string keys and any values.
+       */
   json<T = any>(options?: TSchemaOptions): TRecord$1<string, TAny$1>;
   /**
-   * Create a schema for a boolean.
-   */
+       * Create a schema for a boolean.
+       */
   boolean(options?: TSchemaOptions): TBoolean$1;
   /**
-   * Create a schema for a number.
-   */
+       * Create a schema for a number.
+       */
   number(options?: TNumberOptions$1): TNumber$1;
   /**
-   * Create a schema for an integer.
-   */
+       * Create a schema for an integer.
+       */
   integer(options?: TNumberOptions$1): TInteger$1;
   int32(options?: TNumberOptions$1): TInteger$1;
   /**
-   * Mimic a signed 64-bit integer.
-   *
-   * This is NOT a true int64, as JavaScript cannot represent all int64 values.
-   * It is a number that is an integer and between -9007199254740991 and 9007199254740991.
-   * Use `t.bigint()` for true int64 values represented as strings.
-   */
+       * Mimic a signed 64-bit integer.
+       *
+       * This is NOT a true int64, as JavaScript cannot represent all int64 values.
+       * It is a number that is an integer and between -9007199254740991 and 9007199254740991.
+       * Use `t.bigint()` for true int64 values represented as strings.
+       */
   int64(options?: TNumberOptions$1): TNumber$1;
   /**
-   * Make a schema optional.
-   */
+       * Make a schema optional.
+       */
   optional<T extends TSchema$1>(schema: T): TOptionalAdd$1<T>;
   /**
-   * Make a schema nullable.
-   */
+       * Make a schema nullable.
+       */
   nullable<T extends TSchema$1>(schema: T, options?: TObjectOptions$1): TUnion$1<[TNull$1, T]>;
   /**
-   * Create a schema that maps all properties of an object schema to nullable.
-   */
+       * Create a schema that maps all properties of an object schema to nullable.
+       */
   nullify: <T extends TSchema$1>(schema: T, options?: TObjectOptions$1) => typebox0.TMappedInstantiate<{}, {
     callstack: [];
   }, Type.TIdentifier<"K">, typebox0.TKeyOfInstantiate<{}, {
@@ -407,65 +407,65 @@ declare class TypeProvider {
     callstack: [];
   }, T, Type.TRef<"K">>, TNull$1]>>;
   /**
-   * Create a schema for a string enum.
-   */
+       * Create a schema for a string enum.
+       */
   enum<T extends string[]>(values: [...T], options?: TTextOptions): TUnsafe$1<T[number]>;
   /**
-   * Create a schema for a bigint represented as a string.
-   * This is a string that validates bigint format (e.g. "123456789").
-   */
+       * Create a schema for a bigint represented as a string.
+       * This is a string that validates bigint format (e.g. "123456789").
+       */
   bigint(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for a URL represented as a string.
-   */
+       * Create a schema for a URL represented as a string.
+       */
   url(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for binary data represented as a base64 string.
-   */
+       * Create a schema for binary data represented as a base64 string.
+       */
   binary(options: TStringOptions$1): TString$1;
   /**
-   * Create a schema for uuid.
-   */
+       * Create a schema for uuid.
+       */
   uuid(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for a file-like object.
-   *
-   * File like mimics the File API in browsers, but is adapted to work in Node.js as well.
-   *
-   * Implementation of file-like objects is handled by "alepha/file" package.
-   */
+       * Create a schema for a file-like object.
+       *
+       * File like mimics the File API in browsers, but is adapted to work in Node.js as well.
+       *
+       * Implementation of file-like objects is handled by "alepha/file" package.
+       */
   file(options?: {
     maxSize?: number;
   }): TFile;
   /**
-   * @experimental
-   */
+       * @experimental
+       */
   stream(): TStream;
   email(options?: TStringOptions$1): TString$1;
   e164(options?: TStringOptions$1): TString$1;
   bcp47(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for short text, such as names or titles.
-   * Default max length is 64 characters.
-   */
+       * Create a schema for short text, such as names or titles.
+       * Default max length is 64 characters.
+       */
   shortText(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for long text, such as descriptions or comments.
-   * Default max length is 1024 characters.
-   */
+       * Create a schema for long text, such as descriptions or comments.
+       * Default max length is 1024 characters.
+       */
   longText(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for rich text, such as HTML or Markdown.
-   * Default max length is 65535 characters.
-   */
+       * Create a schema for rich text, such as HTML or Markdown.
+       * Default max length is 65535 characters.
+       */
   richText(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for a string enum e.g. LIKE_THIS.
-   */
+       * Create a schema for a string enum e.g. LIKE_THIS.
+       */
   snakeCase: (options?: TStringOptions$1) => TString$1;
   /**
-   * Create a schema for an object with a value and label.
-   */
+       * Create a schema for an object with a value and label.
+       */
   valueLabel: (options?: TObjectOptions$1) => TObject$1<{
     value: TString$1;
     label: TString$1;
@@ -479,29 +479,29 @@ declare class TypeProvider {
 type TextLength = "short" | "regular" | "long" | "rich";
 interface TTextOptions extends TStringOptions$1 {
   /**
-   * Predefined size of the text.
-   *
-   * - `short` - short text, such as names or titles. Default max length is 64 characters.
-   * - `regular` - regular text, such as single-line input. Default max length is 255 characters.
-   * - `long` - long text, such as descriptions or comments. Default max length is 1024 characters.
-   * - `rich` - rich text, such as HTML or Markdown. Default max length is 65535 characters.
-   *
-   * You can override the default max length by specifying `maxLength` in the options.
-   *
-   * @default "regular"
-   */
+       * Predefined size of the text.
+       *
+       * - `short` - short text, such as names or titles. Default max length is 64 characters.
+       * - `regular` - regular text, such as single-line input. Default max length is 255 characters.
+       * - `long` - long text, such as descriptions or comments. Default max length is 1024 characters.
+       * - `rich` - rich text, such as HTML or Markdown. Default max length is 65535 characters.
+       *
+       * You can override the default max length by specifying `maxLength` in the options.
+       *
+       * @default "regular"
+       */
   size?: TextLength;
   /**
-   * Trim whitespace from both ends of the string.
-   *
-   * @default true
-   */
+       * Trim whitespace from both ends of the string.
+       *
+       * @default true
+       */
   trim?: boolean;
   /**
-   * Convert the string to lowercase.
-   *
-   * @default false
-   */
+       * Convert the string to lowercase.
+       *
+       * @default false
+       */
   lowercase?: boolean;
 }
 declare const t: TypeProvider;
@@ -577,25 +577,25 @@ declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions
 declare class InjectPrimitive extends Primitive {}
 interface InjectOptions<T extends object = any> {
   /**
-   * - 'transient' → Always a new instance on every inject. Zero caching.
-   * - 'singleton' → One instance per Alepha runtime (per-thread). Never disposed until Alepha shuts down. (default)
-   * - 'scoped' → One instance per AsyncLocalStorage context.
-   *   - A new scope is created when Alepha handles a request, a scheduled job, a queue worker task...
-   *   - You can also start a manual scope via alepha.context.run(() => { ... }).
-   *   - When the scope ends, the scoped registry is discarded.
-   *
-   * @default "singleton"
-   */
+       * - 'transient' → Always a new instance on every inject. Zero caching.
+       * - 'singleton' → One instance per Alepha runtime (per-thread). Never disposed until Alepha shuts down. (default)
+       * - 'scoped' → One instance per AsyncLocalStorage context.
+       *   - A new scope is created when Alepha handles a request, a scheduled job, a queue worker task...
+       *   - You can also start a manual scope via alepha.context.run(() => { ... }).
+       *   - When the scope ends, the scoped registry is discarded.
+       *
+       * @default "singleton"
+       */
   lifetime?: "transient" | "singleton" | "scoped";
   /**
-   * Constructor arguments to pass when creating a new instance.
-   */
+       * Constructor arguments to pass when creating a new instance.
+       */
   args?: ConstructorParameters<InstantiableClass<T>>;
   /**
-   * Parent that requested the instance.
-   *
-   * @internal
-   */
+       * Parent that requested the instance.
+       *
+       * @internal
+       */
   parent?: Service | null;
 }
 //#endregion
@@ -651,29 +651,29 @@ interface InjectOptions<T extends object = any> {
 declare const $module: <T extends object = {}>(options: ModulePrimitiveOptions) => Service<Module>;
 interface ModulePrimitiveOptions {
   /**
-   * Name of the module.
-   *
-   * It should be in the format of `project.module.submodule`.
-   */
+       * Name of the module.
+       *
+       * It should be in the format of `project.module.submodule`.
+       */
   name: string;
   /**
-   * List all services related to this module.
-   *
-   * If you don't declare 'register' function, all services will be registered automatically.
-   * If you declare 'register' function, you must handle the registration of ALL services manually.
-   */
+       * List all services related to this module.
+       *
+       * If you don't declare 'register' function, all services will be registered automatically.
+       * If you declare 'register' function, you must handle the registration of ALL services manually.
+       */
   services?: Array<Service>;
   /**
-   * List of $primitives to register in the module.
-   */
+       * List of $primitives to register in the module.
+       */
   primitives?: Array<PrimitiveFactoryLike>;
   /**
-   * By default, module will register ALL services.
-   * You can override this behavior by providing a register function.
-   * It's useful when you want to register services conditionally or in a specific order.
-   *
-   * Again, if you declare 'register', you must handle the registration of ALL services manually.
-   */
+       * By default, module will register ALL services.
+       * You can override this behavior by providing a register function.
+       * It's useful when you want to register services conditionally or in a specific order.
+       *
+       * Again, if you declare 'register', you must handle the registration of ALL services manually.
+       */
   register?: (alepha: Alepha) => void;
 }
 /**
@@ -684,14 +684,14 @@ declare abstract class Module {
   abstract register(alepha: Alepha): void;
   static NAME_REGEX: RegExp;
   /**
-   * Check if a Service is a Module.
-   */
+       * Check if a Service is a Module.
+       */
   static is(ctor: Service): boolean;
   /**
-   * Get the Module of a Service.
-   *
-   * Returns undefined if the Service is not part of a Module.
-   */
+       * Get the Module of a Service.
+       *
+       * Returns undefined if the Service is not part of a Module.
+       */
   static of(ctor: Service): Service<Module> | undefined;
 }
 /**
@@ -728,16 +728,16 @@ declare class Json {
 //#region ../../src/core/providers/SchemaCodec.d.ts
 declare abstract class SchemaCodec {
   /**
-   * Encode the value to a string format.
-   */
+       * Encode the value to a string format.
+       */
   abstract encodeToString<T extends TSchema>(schema: T, value: Static<T>): string;
   /**
-   * Encode the value to a binary format.
-   */
+       * Encode the value to a binary format.
+       */
   abstract encodeToBinary<T extends TSchema>(schema: T, value: Static<T>): Uint8Array;
   /**
-   * Decode string, binary, or other formats to the schema type.
-   */
+       * Decode string, binary, or other formats to the schema type.
+       */
   abstract decode<T>(schema: TSchema, value: unknown): T;
 }
 //#endregion
@@ -751,6 +751,61 @@ declare class JsonSchemaCodec extends SchemaCodec {
   decode<T>(schema: TSchema$1, value: unknown): T;
 }
 //#endregion
+//#region ../../src/core/providers/KeylessJsonSchemaCodec.d.ts
+interface KeylessCodec<T = any> {
+  encode: (value: T) => string;
+  decode: (str: string) => T;
+}
+/**
+ * KeylessJsonSchemaCodec provides schema-driven JSON encoding without keys.
+ *
+ * It uses the schema to determine field order, allowing the encoded output
+ * to be a simple JSON array instead of an object with keys.
+ *
+ * Performance characteristics:
+ * - Encode: 0.94-1.53x vs JSON.stringify (faster for complex objects)
+ * - Decode: 1.76-2.00x vs JSON.parse
+ * - Size: 50-56% smaller than JSON
+ */
+declare class KeylessJsonSchemaCodec extends SchemaCodec {
+  protected readonly cache: Map<TSchema$1, KeylessCodec<any>>;
+  protected readonly encoder: TextEncoder;
+  protected readonly decoder: TextDecoder;
+  protected varCounter: number;
+  /**
+       * Encode value to a keyless JSON string.
+       */
+  encodeToString<T extends TSchema$1>(schema: T, value: Static<T>): string;
+  /**
+       * Encode value to binary (UTF-8 encoded keyless JSON).
+       */
+  encodeToBinary<T extends TSchema$1>(schema: T, value: Static<T>): Uint8Array;
+  /**
+       * Decode keyless JSON string or binary to value.
+       */
+  decode<T>(schema: TSchema$1, value: unknown): T;
+  /**
+       * Get a compiled codec for the given schema.
+       * Codecs are cached for reuse.
+       */
+  protected getCodec<T>(schema: TSchema$1): KeylessCodec<T>;
+  protected nextVar(): string;
+  protected compile(schema: TSchema$1): KeylessCodec;
+  protected genEnc(schema: TSchema$1, ve: string): string;
+  protected genDec(schema: TSchema$1): {
+    code: string;
+    result: string;
+  };
+  protected genDecFromValue(schema: TSchema$1, expr: string): string;
+  protected isEnum(schema: TSchema$1): boolean;
+  protected isNullable(schema: TSchema$1): boolean;
+  protected unwrap(schema: TSchema$1): TSchema$1;
+  /**
+       * Reconstruct an object from a parsed array (for when input is already parsed).
+       */
+  protected reconstructObject(schema: TSchema$1, arr: any[]): any;
+}
+//#endregion
 //#region ../../src/core/primitives/$hook.d.ts
 /**
  * Registers a new hook.
@@ -797,24 +852,24 @@ declare const $hook: {
 };
 interface HookOptions<T extends keyof Hooks> {
   /**
-   * The name of the hook. "configure", "start", "ready", "stop", ...
-   */
+       * The name of the hook. "configure", "start", "ready", "stop", ...
+       */
   on: T;
   /**
-   * The handler to run when the hook is triggered.
-   */
+       * The handler to run when the hook is triggered.
+       */
   handler: (args: Hooks[T]) => Async<any>;
   /**
-   * Force the hook to run first or last on the list of hooks.
-   */
+       * Force the hook to run first or last on the list of hooks.
+       */
   priority?: "first" | "last";
   /**
-   * Empty placeholder, not implemented yet. :-)
-   */
+       * Empty placeholder, not implemented yet. :-)
+       */
   before?: object | Array<object>;
   /**
-   * Empty placeholder, not implemented yet. :-)
-   */
+       * Empty placeholder, not implemented yet. :-)
+       */
   after?: object | Array<object>;
 }
 declare class HookPrimitive<T extends keyof Hooks> extends Primitive<HookOptions<T>> {
@@ -827,22 +882,22 @@ declare class SchemaValidator {
   protected cache: Map<TSchema$1, Validator<typebox0.TProperties, TSchema$1, unknown, unknown>>;
   protected useEval: boolean;
   /**
-   * Validate the value against the provided schema.
-   *
-   * Validation create a new value by applying some preprocessing. (e.g., trimming text)
-   */
+       * Validate the value against the provided schema.
+       *
+       * Validation create a new value by applying some preprocessing. (e.g., trimming text)
+       */
   validate<T extends TSchema$1>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
   protected getValidator<T extends TSchema$1>(schema: T): Validator<{}, T>;
   /**
-   * Preprocess the value based on the schema before validation.
-   *
-   * - If the value is `null` and the schema does not allow `null`, it converts it to `undefined`.
-   * - If the value is a string and the schema has a `~options.trim` flag, it trims whitespace from the string.
-   */
+       * Preprocess the value based on the schema before validation.
+       *
+       * - If the value is `null` and the schema does not allow `null`, it converts it to `undefined`.
+       * - If the value is a string and the schema has a `~options.trim` flag, it trims whitespace from the string.
+       */
   beforeParse(schema: any, value: any, options: ValidateOptions): any;
   /**
-   * Used by `beforeParse` to determine if a schema allows null values.
-   */
+       * Used by `beforeParse` to determine if a schema allows null values.
+       */
   protected isSchemaNullable: (schema: any) => boolean;
   protected onConfigure: HookPrimitive<"configure">;
   protected canEval(): boolean;
@@ -857,35 +912,35 @@ interface ValidateOptions {
 type Encoding = "object" | "string" | "binary";
 interface EncodeOptions<T extends Encoding = Encoding> {
   /**
-   * The output encoding format:
-   * - 'string': Returns JSON string
-   * - 'binary': Returns Uint8Array (for protobuf, msgpack, etc.)
-   *
-   * @default "string"
-   */
+       * The output encoding format:
+       * - 'string': Returns JSON string
+       * - 'binary': Returns Uint8Array (for protobuf, msgpack, etc.)
+       *
+       * @default "string"
+       */
   as?: T;
   /**
-   * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
-   *
-   * @default "json"
-   */
+       * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
+       *
+       * @default "json"
+       */
   encoder?: string;
   /**
-   * Validation options to apply before encoding.
-   */
+       * Validation options to apply before encoding.
+       */
   validation?: ValidateOptions | false;
 }
 type EncodeResult<T extends TSchema$1, E extends Encoding> = E extends "string" ? string : E extends "binary" ? Uint8Array : StaticEncode$1<T>;
 interface DecodeOptions {
   /**
-   * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
-   *
-   * @default "json"
-   */
+       * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
+       *
+       * @default "json"
+       */
   encoder?: string;
   /**
-   * Validation options to apply before encoding.
-   */
+       * Validation options to apply before encoding.
+       */
   validation?: ValidateOptions | false;
 }
 /**
@@ -895,76 +950,115 @@ interface DecodeOptions {
 declare class CodecManager {
   protected readonly codecs: Map<string, SchemaCodec>;
   protected readonly jsonCodec: JsonSchemaCodec;
+  protected readonly keylessCodec: KeylessJsonSchemaCodec;
   protected readonly schemaValidator: SchemaValidator;
   default: string;
   constructor();
   /**
-   * Register a new codec format.
-   *
-   * @param name - The name of the codec (e.g., 'json', 'protobuf')
-   * @param codec - The codec implementation
-   */
-  register(name: string, codec: SchemaCodec): void;
-  /**
-   * Get a specific codec by name.
-   *
-   * @param name - The name of the codec
-   * @returns The codec instance
-   * @throws {AlephaError} If the codec is not found
-   */
+       * Register a new codec format.
+       */
+  register(opts: CodecRegisterOptions): void;
+  /**
+       * Get a specific codec by name.
+       *
+       * @param name - The name of the codec
+       * @returns The codec instance
+       * @throws {AlephaError} If the codec is not found
+       */
   getCodec(name: string): SchemaCodec;
   /**
-   * Encode data using the specified codec and output format.
-   */
+       * Encode data using the specified codec and output format.
+       */
   encode<T extends TSchema$1, E extends Encoding = "object">(schema: T, value: unknown, options?: EncodeOptions<E>): EncodeResult<T, E>;
   /**
-   * Decode data using the specified codec.
-   */
+       * Decode data using the specified codec.
+       */
   decode<T extends TSchema$1>(schema: T, data: any, options?: DecodeOptions): Static<T>;
   /**
-   * Validate decoded data against the schema.
-   *
-   * This is automatically called before encoding or after decoding.
-   */
+       * Validate decoded data against the schema.
+       *
+       * This is automatically called before encoding or after decoding.
+       */
   validate<T extends TSchema$1>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
 }
+interface CodecRegisterOptions {
+  name: string;
+  codec: SchemaCodec;
+  default?: boolean;
+}
 //#endregion
 //#region ../../src/core/providers/EventManager.d.ts
+/**
+ * Compiled event executor - optimized for hot paths.
+ * Returns void for sync-only chains, Promise<void> for chains with async hooks.
+ */
+type CompiledEventExecutor<T> = (payload: T) => void | Promise<void>;
+/**
+ * Options for compiled event executors.
+ */
+interface CompileOptions {
+  /**
+       * If true, errors will be caught and logged instead of throwing.
+       * @default false
+       */
+  catch?: boolean;
+}
 declare class EventManager {
   logFn?: () => LoggerInterface | undefined;
   /**
-   * List of events that can be triggered. Powered by $hook().
-   */
+       * List of events that can be triggered. Powered by $hook().
+       */
   protected events: Record<string, Array<Hook>>;
   constructor(logFn?: () => LoggerInterface | undefined);
   protected get log(): LoggerInterface | undefined;
   clear(): void;
   /**
-   * Registers a hook for the specified event.
-   */
+       * Registers a hook for the specified event.
+       */
   on<T extends keyof Hooks>(event: T, hookOrFunc: Hook<T> | ((payload: Hooks[T]) => Async<void>)): () => void;
   /**
-   * Emits the specified event with the given payload.
-   */
+       * Compiles an event into an optimized executor function.
+       *
+       * Call this after all hooks are registered (e.g., after Alepha.start()).
+       * The returned function checks each hook's return value and awaits promises.
+       * Returns undefined if all hooks are sync, or a Promise if any hook returns one.
+       *
+       * @example
+       * ```ts
+       * // At startup (after hooks are registered)
+       * const onRequest = alepha.events.compile("server:onRequest", { catch: true });
+       *
+       * // In hot path - only await if promise returned
+       * const result = onRequest({ request, route });
+       * if (result) await result;
+       * ```
+       */
+  compile<T extends keyof Hooks>(event: T, options?: CompileOptions): CompiledEventExecutor<Hooks[T]>;
+  /**
+       * Emits the specified event with the given payload.
+       *
+       * For hot paths (like HTTP request handling), use compile() instead
+       * to get an optimized executor.
+       */
   emit<T extends keyof Hooks>(func: T, payload: Hooks[T], options?: {
     /**
-     * If true, the hooks will be executed in reverse order.
-     * This is useful for "stop" hooks that should be executed in reverse order.
-     *
-     * @default false
-     */
+             * If true, the hooks will be executed in reverse order.
+             * This is useful for "stop" hooks that should be executed in reverse order.
+             *
+             * @default false
+             */
     reverse?: boolean;
     /**
-     * If true, the hooks will be logged with their execution time.
-     *
-     * @default false
-     */
+             * If true, the hooks will be logged with their execution time.
+             *
+             * @default false
+             */
     log?: boolean;
     /**
-     * If true, errors will be caught and logged instead of throwing.
-     *
-     * @default false
-     */
+             * If true, errors will be caught and logged instead of throwing.
+             *
+             * @default false
+             */
     catch?: boolean;
   }): Promise<void>;
 }
@@ -984,39 +1078,39 @@ declare class StateManager<State$1 extends object = State> {
   getAtoms(context?: boolean): Array<AtomWithValue>;
   register(atom: Atom<any>): this;
   /**
-   * Get a value from the state with proper typing
-   */
+       * Get a value from the state with proper typing
+       */
   get<T extends TAtomObject>(target: Atom<T>): Static<T>;
   get<Key extends keyof State$1>(target: Key): State$1[Key] | undefined;
   /**
-   * Set a value in the state
-   */
+       * Set a value in the state
+       */
   set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>, options?: SetStateOptions): this;
   set<Key extends keyof State$1>(target: Key, value: State$1[Key] | undefined, options?: SetStateOptions): this;
   /**
-   * Mutate a value in the state.
-   */
+       * Mutate a value in the state.
+       */
   mut<T extends TObject$1>(target: Atom<T>, mutator: (current: Static<T>) => Static<T>): this;
   mut<Key extends keyof State$1>(target: Key, mutator: (current: State$1[Key] | undefined) => State$1[Key] | undefined): this;
   /**
-   * Check if a key exists in the state
-   */
+       * Check if a key exists in the state
+       */
   has<Key extends keyof State$1>(key: Key): boolean;
   /**
-   * Delete a key from the state (set to undefined)
-   */
+       * Delete a key from the state (set to undefined)
+       */
   del<Key extends keyof State$1>(key: Key): this;
   /**
-   * Push a value to an array in the state
-   */
+       * Push a value to an array in the state
+       */
   push<Key extends keyof OnlyArray<State$1>>(key: Key, ...value: Array<NonNullable<State$1[Key]> extends Array<infer U> ? U : never>): this;
   /**
-   * Clear all state
-   */
+       * Clear all state
+       */
   clear(): this;
   /**
-   * Get all keys that exist in the state
-   */
+       * Get all keys that exist in the state
+       */
   keys(): (keyof State$1)[];
 }
 type OnlyArray<T extends object> = { [K in keyof T]: NonNullable<T[K]> extends Array<any> ? K : never };
@@ -1151,273 +1245,274 @@ interface SetStateOptions {
  */
 declare class Alepha {
   /**
-   * Creates a new instance of the Alepha container with some helpers:
-   *
-   * - merges `process.env` with the provided state.env when available.
-   * - populates the test hooks for Vitest or Jest environments when available.
-   *
-   * If you are not interested about these helpers, you can use the constructor directly.
-   */
+       * Creates a new instance of the Alepha container with some helpers:
+       *
+       * - merges `process.env` with the provided state.env when available.
+       * - populates the test hooks for Vitest or Jest environments when available.
+       *
+       * If you are not interested about these helpers, you can use the constructor directly.
+       */
   static create(state?: Partial<State>): Alepha;
   /**
-   * Flag indicating whether the App won't accept any further changes.
-   * Pass to true when #start() is called.
-   */
+       * Flag indicating whether the App won't accept any further changes.
+       * Pass to true when #start() is called.
+       */
   protected locked: boolean;
   /**
-   * True if the App has been configured.
-   */
+       * True if the App has been configured.
+       */
   protected configured: boolean;
   /**
-   * True if the App has started.
-   */
+       * True if the App has started.
+       */
   protected started: boolean;
   /**
-   * True if the App is ready.
-   */
+       * True if the App is ready.
+       */
   protected ready: boolean;
   /**
-   * A promise that resolves when the App has started.
-   */
+       * A promise that resolves when the App has started.
+       */
   protected starting?: PromiseWithResolvers<this>;
   /**
-   * During the instantiation process, we keep a list of pending instantiations.
-   * > It allows us to detect circular dependencies.
-   */
+       * During the instantiation process, we keep a list of pending instantiations.
+       * > It allows us to detect circular dependencies.
+       */
   protected pendingInstantiations: Service[];
   /**
-   * Cache for environment variables.
-   * > It allows us to avoid parsing the same schema multiple times.
-   */
+       * Cache for environment variables.
+       * > It allows us to avoid parsing the same schema multiple times.
+       */
   protected cacheEnv: Map<TSchema, any>;
   /**
-   * List of modules that are registered in the container.
-   *
-   * Modules are used to group services and provide a way to register them in the container.
-   */
+       * List of modules that are registered in the container.
+       *
+       * Modules are used to group services and provide a way to register them in the container.
+       */
   protected modules: Array<Module>;
   /**
-   * List of service substitutions.
-   *
-   * Services registered here will be replaced by the specified service when injected.
-   */
+       * List of service substitutions.
+       *
+       * Services registered here will be replaced by the specified service when injected.
+       */
   protected substitutions: Map<Service, {
     use: Service;
   }>;
   /**
-   * Registry of primitives.
-   */
+       * Registry of primitives.
+       */
   protected primitiveRegistry: Map<Service<Primitive<{}>>, Primitive<{}>[]>;
   /**
-   *  List of all services + how they are provided.
-   */
+       *  List of all services + how they are provided.
+       */
   protected registry: Map<Service, ServiceDefinition>;
   /**
-   * Node.js feature that allows to store context across asynchronous calls.
-   *
-   * This is used for logging, tracing, and other context-related features.
-   *
-   * Mocked for browser environments.
-   */
+       * Node.js feature that allows to store context across asynchronous calls.
+       *
+       * This is used for logging, tracing, and other context-related features.
+       *
+       * Mocked for browser environments.
+       */
   context: AlsProvider;
   /**
-   * Event manager to handle lifecycle events and custom events.
-   */
+       * Event manager to handle lifecycle events and custom events.
+       */
   events: EventManager;
   /**
-   * State manager to store arbitrary values.
-   */
+       * State manager to store arbitrary values.
+       */
   store: StateManager<State>;
   /**
-   * Codec manager for encoding and decoding data with different formats.
-   *
-   * Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
-   */
+       * Codec manager for encoding and decoding data with different formats.
+       *
+       * Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
+       */
   codec: CodecManager;
   /**
-   * Get logger instance.
-   */
+       * Get logger instance.
+       */
   get log(): LoggerInterface | undefined;
   /**
-   * The environment variables for the App.
-   */
+       * The environment variables for the App.
+       */
   get env(): Readonly<Env>;
   constructor(state?: Partial<State>);
   set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>): this;
   set<Key extends keyof State>(target: Key, value: State[Key] | undefined): this;
   /**
-   * True when start() is called.
-   *
-   * -> No more services can be added, it's over, bye!
-   */
+       * True when start() is called.
+       *
+       * -> No more services can be added, it's over, bye!
+       */
   isLocked(): boolean;
   /**
-   * Returns whether the App is configured.
-   *
-   * It means that Alepha#configure() has been called.
-   *
-   * > By default, configure() is called automatically when start() is called, but you can also call it manually.
-   */
+       * Returns whether the App is configured.
+       *
+       * It means that Alepha#configure() has been called.
+       *
+       * > By default, configure() is called automatically when start() is called, but you can also call it manually.
+       */
   isConfigured(): boolean;
   /**
-   * Returns whether the App has started.
-   *
-   * It means that #start() has been called but maybe not all services are ready.
-   */
+       * Returns whether the App has started.
+       *
+       * It means that #start() has been called but maybe not all services are ready.
+       */
   isStarted(): boolean;
   /**
-   * True if the App is ready. It means that Alepha is started AND ready() hook has beed called.
-   */
+       * True if the App is ready. It means that Alepha is started AND ready() hook has beed called.
+       */
   isReady(): boolean;
   /**
-   * True if the App is running in a Continuous Integration environment.
-   */
+       * True if the App is running in a Continuous Integration environment.
+       */
   isCI(): boolean;
   /**
-   * True if the App is running in a browser environment.
-   */
+       * True if the App is running in a browser environment.
+       */
   isBrowser(): boolean;
   /**
-   * Returns whether the App is running in Vite dev mode.
-   */
+       * Returns whether the App is running in Vite dev mode.
+       */
   isViteDev(): boolean;
   isBun(): boolean;
   /**
-   * Returns whether the App is running in a serverless environment.
-   */
+       * Returns whether the App is running in a serverless environment.
+       */
   isServerless(): boolean;
   /**
-   * Returns whether the App is in test mode. (Running in a test environment)
-   *
-   * > This is automatically set when running tests with Jest or Vitest.
-   */
+       * Returns whether the App is in test mode. (Running in a test environment)
+       *
+       * > This is automatically set when running tests with Jest or Vitest.
+       */
   isTest(): boolean;
   /**
-   * Returns whether the App is in production mode. (Running in a production environment)
-   *
-   * > This is automatically set by Vite or Vercel. However, you have to set it manually when running Docker apps.
-   */
+       * Returns whether the App is in production mode. (Running in a production environment)
+       *
+       * > This is automatically set by Vite or Vercel. However, you have to set it manually when running Docker apps.
+       */
   isProduction(): boolean;
   /**
-   * Starts the App.
-   *
-   * - Lock any further changes to the container.
-   * - Run "configure" hook for all services. Primitives will be processed.
-   * - Run "start" hook for all services. Providers will connect/listen/...
-   * - Run "ready" hook for all services. This is the point where the App is ready to serve requests.
-   *
-   * @return A promise that resolves when the App has started.
-   */
+       * Starts the App.
+       *
+       * - Lock any further changes to the container.
+       * - Run "configure" hook for all services. Primitives will be processed.
+       * - Run "start" hook for all services. Providers will connect/listen/...
+       * - Run "ready" hook for all services. This is the point where the App is ready to serve requests.
+       *
+       * @return A promise that resolves when the App has started.
+       */
   start(): Promise<this>;
   /**
-   * Stops the App.
-   *
-   * - Run "stop" hook for all services.
-   *
-   * Stop will NOT reset the container.
-   * Stop will NOT unlock the container.
-   *
-   * > Stop is used to gracefully shut down the application, nothing more. There is no "restart".
-   *
-   * @return A promise that resolves when the App has stopped.
-   */
+       * Stops the App.
+       *
+       * - Run "stop" hook for all services.
+       *
+       * Stop will NOT reset the container.
+       * Stop will NOT unlock the container.
+       *
+       * > Stop is used to gracefully shut down the application, nothing more. There is no "restart".
+       *
+       * @return A promise that resolves when the App has stopped.
+       */
   stop(): Promise<void>;
   /**
-   * Check if entry is registered in the container.
-   */
+       * Check if entry is registered in the container.
+       */
   has(entry: ServiceEntry, opts?: {
     /**
-     * Check if the entry is registered in the pending instantiation stack.
-     *
-     * @default true
-     */
+             * Check if the entry is registered in the pending instantiation stack.
+             *
+             * @default true
+             */
     inStack?: boolean;
     /**
-     * Check if the entry is registered in the container registry.
-     *
-     * @default true
-     */
+             * Check if the entry is registered in the container registry.
+             *
+             * @default true
+             */
     inRegistry?: boolean;
     /**
-     * Check if the entry is registered in the substitutions.
-     *
-     * @default true
-     */
+             * Check if the entry is registered in the substitutions.
+             *
+             * @default true
+             */
     inSubstitutions?: boolean;
     /**
-     * Where to look for registered services.
-     *
-     * @default this.registry
-     */
+             * Where to look for registered services.
+             *
+             * @default this.registry
+             */
     registry?: Map<Service, ServiceDefinition>;
   }): boolean;
   /**
-   * Registers the specified service in the container.
-   *
-   * - If the service is ALREADY registered, the method does nothing.
-   * - If the service is NOT registered, a new instance is created and registered.
-   *
-   * Method is chainable, so you can register multiple services in a single call.
-   *
-   * > ServiceEntry allows to provide a service **substitution** feature.
-   *
-   * @example
-   * ```ts
-   * class A { value = "a"; }
-   * class B { value = "b"; }
-   * class M { a = $inject(A); }
-   *
-   * Alepha.create().with({ provide: A, use: B }).get(M).a.value; // "b"
-   * ```
-   *
-   * > **Substitution** is an advanced feature that allows you to replace a service with another service.
-   * > It's useful for testing or for providing different implementations of a service.
-   * > If you are interested in configuring a service, use Alepha#configure() instead.
-   *
-   * @param serviceEntry - The service to register in the container.
-   * @return Current instance of Alepha.
-   */
+       * Registers the specified service in the container.
+       *
+       * - If the service is ALREADY registered, the method does nothing.
+       * - If the service is NOT registered, a new instance is created and registered.
+       *
+       * Method is chainable, so you can register multiple services in a single call.
+       *
+       * > ServiceEntry allows to provide a service **substitution** feature.
+       *
+       * @example
+       * ```ts
+       * class A { value = "a"; }
+       * class B { value = "b"; }
+       * class M { a = $inject(A); }
+       *
+       * Alepha.create().with({ provide: A, use: B }).get(M).a.value; // "b"
+       * ```
+       *
+       * > **Substitution** is an advanced feature that allows you to replace a service with another service.
+       * > It's useful for testing or for providing different implementations of a service.
+       * > If you are interested in configuring a service, use Alepha#configure() instead.
+       *
+       * @param serviceEntry - The service to register in the container.
+       * @return Current instance of Alepha.
+       */
   with<T extends object>(serviceEntry: ServiceEntry<T> | {
     default: ServiceEntry<T>;
   }): this;
   /**
-   * Get an instance of the specified service from the container.
-   *
-   * @see {@link InjectOptions} for the available options.
-   */
+       * Get an instance of the specified service from the container.
+       *
+       * @see {@link InjectOptions} for the available options.
+       */
   inject<T extends object>(service: Service<T> | string, opts?: InjectOptions<T>): T;
   /**
-   * Applies environment variables to the provided schema and state object.
-   *
-   * It replaces also all templated $ENV inside string values.
-   *
-   * @param schema - The schema object to apply environment variables to.
-   * @return The schema object with environment variables applied.
-   */
+       * Applies environment variables to the provided schema and state object.
+       *
+       * It replaces also all templated $ENV inside string values.
+       *
+       * @param schema - The schema object to apply environment variables to.
+       * @return The schema object with environment variables applied.
+       */
   parseEnv<T extends TObject$1>(schema: T): Static$1<T>;
   /**
-   * Get all environment variable schemas and their parsed values.
-   *
-   * This is useful for DevTools to display all expected environment variables.
-   */
+       * Get all environment variable schemas and their parsed values.
+       *
+       * This is useful for DevTools to display all expected environment variables.
+       */
   getEnvSchemas(): Array<{
     schema: TSchema;
     values: Record<string, any>;
   }>;
   /**
-   * Dump the current dependency graph of the App.
-   *
-   * This method returns a record where the keys are the names of the services.
-   */
+       * Dump the current dependency graph of the App.
+       *
+       * This method returns a record where the keys are the names of the services.
+       */
   graph(): Record<string, {
     from: string[];
     as?: string[];
     module?: string;
   }>;
+  dump(): AlephaDump;
   services<T extends object>(base: Service<T>): Array<T>;
   /**
-   * Get all primitives of the specified type.
-   */
+       * Get all primitives of the specified type.
+       */
   primitives<TPrimitive extends Primitive>(factory: {
     [KIND]: InstantiableClass<TPrimitive>;
   } | string): Array<TPrimitive>;
@@ -1429,150 +1524,164 @@ interface Hook<T extends keyof Hooks = any> {
   priority?: "first" | "last";
   callback: (payload: Hooks[T]) => Async<void>;
 }
+interface AlephaDump {
+  env: Record<string, AlephaDumpEnvVariable>;
+  providers: Record<string, {
+    from: string[];
+    as?: string[];
+    module?: string;
+  }>;
+}
+interface AlephaDumpEnvVariable {
+  description: string;
+  default?: string;
+  required?: boolean;
+  enum?: Array<string>;
+}
 /**
  * This is how we store services in the Alepha container.
  */
 interface ServiceDefinition<T extends object = any> {
   /**
-   * The instance of the class or type definition.
-   * Mostly used for caching / singleton but can be used for other purposes like forcing the instance.
-   */
+       * The instance of the class or type definition.
+       * Mostly used for caching / singleton but can be used for other purposes like forcing the instance.
+       */
   instance: T;
   /**
-   * List of classes which use this class.
-   */
+       * List of classes which use this class.
+       */
   parents: Array<Service | null>;
 }
 interface Env {
   [key: string]: string | boolean | number | undefined;
   /**
-   * Optional environment variable that indicates the current environment.
-   */
+       * Optional environment variable that indicates the current environment.
+       */
   NODE_ENV?: string;
   /**
-   * Optional name of the application.
-   */
+       * Optional name of the application.
+       */
   APP_NAME?: string;
   /**
-   * Optional root module name.
-   */
+       * Optional root module name.
+       */
   MODULE_NAME?: string;
 }
 interface State {
   /**
-   * Environment variables for the application.
-   */
+       * Environment variables for the application.
+       */
   env?: Readonly<Env>;
   /**
-   * Logger instance to be used by the Alepha container.
-   *
-   * @internal
-   */
+       * Logger instance to be used by the Alepha container.
+       *
+       * @internal
+       */
   "alepha.logger"?: LoggerInterface;
   /**
-   * If defined, the Alepha container will only register this service and its dependencies.
-   *
-   * @example
-   * ```ts
-   * class MigrateCmd {
-   *   db = $inject(DatabaseProvider);
-   *   alepha = $inject(Alepha);
-   *   env = $env(
-   *     t.object({
-   *       MIGRATE: t.optional(t.boolean()),
-   *     }),
-   *   );
-   *
-   *   constructor() {
-   *     if (this.env.MIGRATE) {
-   *       this.alepha.set("alepha.target", MigrateCmd);
-   *     }
-   *   }
-   *
-   *   ready = $hook({
-   *     on: "ready",
-   *     handler: async () => {
-   *       if (this.env.MIGRATE) {
-   *         await this.db.migrate();
-   *       }
-   *     },
-   *   });
-   * }
-   * ```
-   */
+       * If defined, the Alepha container will only register this service and its dependencies.
+       *
+       * @example
+       * ```ts
+       * class MigrateCmd {
+       *   db = $inject(DatabaseProvider);
+       *   alepha = $inject(Alepha);
+       *   env = $env(
+       *     t.object({
+       *       MIGRATE: t.optional(t.boolean()),
+       *     }),
+       *   );
+       *
+       *   constructor() {
+       *     if (this.env.MIGRATE) {
+       *       this.alepha.set("alepha.target", MigrateCmd);
+       *     }
+       *   }
+       *
+       *   ready = $hook({
+       *     on: "ready",
+       *     handler: async () => {
+       *       if (this.env.MIGRATE) {
+       *         await this.db.migrate();
+       *       }
+       *     },
+       *   });
+       * }
+       * ```
+       */
   "alepha.target"?: Service;
   /**
-   * Bind to Vitest 'beforeAll' hook.
-   * Used for testing purposes.
-   * This is automatically attached if Alepha#create() detects a test environment and global 'beforeAll' is available.
-   */
+       * Bind to Vitest 'beforeAll' hook.
+       * Used for testing purposes.
+       * This is automatically attached if Alepha#create() detects a test environment and global 'beforeAll' is available.
+       */
   "alepha.test.beforeAll"?: (run: any) => any;
   /**
-   * Bind to Vitest 'afterAll' hook.
-   * Used for testing purposes.
-   * This is automatically attached if Alepha#create() detects a test environment and global 'afterAll' is available.
-   */
+       * Bind to Vitest 'afterAll' hook.
+       * Used for testing purposes.
+       * This is automatically attached if Alepha#create() detects a test environment and global 'afterAll' is available.
+       */
   "alepha.test.afterAll"?: (run: any) => any;
   /**
-   * Bind to Vitest 'afterEach' hook.
-   * Used for testing purposes.
-   * This is automatically attached if Alepha#create() detects a test environment and global 'afterEach' is available.
-   */
+       * Bind to Vitest 'afterEach' hook.
+       * Used for testing purposes.
+       * This is automatically attached if Alepha#create() detects a test environment and global 'afterEach' is available.
+       */
   "alepha.test.afterEach"?: (run: any) => any;
   /**
-   * Bind to Vitest 'onTestFinished' hook.
-   * Used for testing purposes.
-   * This is automatically attached if Alepha#create() detects a test environment and global 'onTestFinished' is available.
-   */
+       * Bind to Vitest 'onTestFinished' hook.
+       * Used for testing purposes.
+       * This is automatically attached if Alepha#create() detects a test environment and global 'onTestFinished' is available.
+       */
   "alepha.test.onTestFinished"?: (run: any) => any;
   /**
-   * List of static assets to be copied to the output directory during the build process.
-   *
-   * Used for Alepha-based applications that require static assets.
-   *
-   * See alepha/vite for more details.
-   */
+       * List of static assets to be copied to the output directory during the build process.
+       *
+       * Used for Alepha-based applications that require static assets.
+       *
+       * See alepha/vite for more details.
+       */
   "alepha.build.assets"?: Array<string>;
 }
 interface Hooks {
   /**
-   * Used for testing purposes.
-   */
+       * Used for testing purposes.
+       */
   echo: unknown;
   /**
-   * Triggered during the configuration phase. Before the start phase.
-   */
+       * Triggered during the configuration phase. Before the start phase.
+       */
   configure: Alepha;
   /**
-   * Triggered during the start phase. When `Alepha#start()` is called.
-   */
+       * Triggered during the start phase. When `Alepha#start()` is called.
+       */
   start: Alepha;
   /**
-   * Triggered during the ready phase. After the start phase.
-   */
+       * Triggered during the ready phase. After the start phase.
+       */
   ready: Alepha;
   /**
-   * Triggered during the stop phase.
-   *
-   * - Stop should be called after a SIGINT or SIGTERM signal in order to gracefully shutdown the application. (@see `run()` method)
-   *
-   */
+       * Triggered during the stop phase.
+       *
+       * - Stop should be called after a SIGINT or SIGTERM signal in order to gracefully shutdown the application. (@see `run()` method)
+       *
+       */
   stop: Alepha;
   /**
-   * Triggered when a state value is mutated.
-   */
+       * Triggered when a state value is mutated.
+       */
   "state:mutate": {
     /**
-     * The key of the state that was mutated.
-     */
+             * The key of the state that was mutated.
+             */
     key: keyof State;
     /**
-     * The new value of the state.
-     */
+             * The new value of the state.
+             */
     value: any;
     /**
-     * The previous value of the state.
-     */
+             * The previous value of the state.
+             */
     prevValue: any;
   };
 }
@@ -1687,8 +1796,8 @@ type TPage<T extends TObject | TRecord> = TObject<{
  */
 type Page<T> = {
   /**
-   * Array of items on the current page.
-   */
+       * Array of items on the current page.
+       */
   content: T[];
   page: Static<typeof pageMetadataSchema>;
 };
@@ -1696,12 +1805,11 @@ type PageMetadata = Static<typeof pageMetadataSchema>;
 declare module "alepha" {
   interface TypeProvider {
     /**
-     * Create a schema for a paginated response.
-     */
+             * Create a schema for a paginated response.
+             */
     page<T extends TObject | TRecord>(itemSchema: T): TPage<T>;
   }
-}
-//# sourceMappingURL=pageSchema.d.ts.map
+} //# sourceMappingURL=pageSchema.d.ts.map
 //#endregion
 //#region ../../src/core/helpers/createPagination.d.ts
 /**
@@ -1857,14 +1965,14 @@ declare function jsonSchemaToTypeBox(schema: JsonSchemaObject): TSchema$1;
  */
 interface PageRequest {
   /**
-   * The page number to retrieve (0-indexed).
-   * @default 0
-   */
+       * The page number to retrieve (0-indexed).
+       * @default 0
+       */
   page?: number;
   /**
-   * The number of items per page.
-   * @default 10
-   */
+       * The number of items per page.
+       * @default 10
+       */
   size?: number;
 }
 /**
@@ -1876,13 +1984,13 @@ type SortDirection = "asc" | "desc";
  */
 interface SortField {
   /**
-   * The field/column name to sort by.
-   */
+       * The field/column name to sort by.
+       */
   field: string;
   /**
-   * The sort direction.
-   * @default "asc"
-   */
+       * The sort direction.
+       * @default "asc"
+       */
   direction: SortDirection;
 }
 //#endregion
@@ -1917,17 +2025,17 @@ interface SortField {
 declare const $context: () => ContextPrimitive;
 interface ContextPrimitive {
   /**
-   * Alepha instance.
-   */
+       * Alepha instance.
+       */
   alepha: Alepha;
   /**
-   * Service definition which is creating this primitive.
-   * This is NOT the instance but the service definition.
-   */
+       * Service definition which is creating this primitive.
+       * This is NOT the instance but the service definition.
+       */
   service?: Service;
   /**
-   * Module definition, if any.
-   */
+       * Module definition, if any.
+       */
   module?: Service;
 }
 //#endregion
@@ -1996,27 +2104,27 @@ type PageQuery = Static<typeof pageQuerySchema>;
 //#region ../../src/core/interfaces/Run.d.ts
 interface RunOptions {
   /**
-   * Environment variables to be used by the application.
-   * It will be merged with the current process environment.
-   */
+       * Environment variables to be used by the application.
+       * It will be merged with the current process environment.
+       */
   env?: Env;
   /**
-   * A callback that will be executed before the application starts.
-   */
+       * A callback that will be executed before the application starts.
+       */
   configure?: (alepha: Alepha) => Async<void>;
   /**
-   * A callback that will be executed once the application is ready.
-   * This is useful for initializing resources or starting background tasks.
-   */
+       * A callback that will be executed once the application is ready.
+       * This is useful for initializing resources or starting background tasks.
+       */
   ready?: (alepha: Alepha) => Async<void>;
   /**
-   * If true, the application will .stop() after the ready callback is executed.
-   * Useful for one-time tasks!
-   */
+       * If true, the application will .stop() after the ready callback is executed.
+       * Useful for one-time tasks!
+       */
   once?: boolean;
   /**
-   * If true, the application will run in cluster mode.
-   */
+       * If true, the application will run in cluster mode.
+       */
   cluster?: boolean;
 }
 //#endregion
@@ -2038,5 +2146,5 @@ declare const AlephaCore: Service<Module>;
  */
 declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => Alepha;
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $module, $use, AbstractClass, Alepha, AlephaCore, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomStatic, AtomWithValue, CircularDependencyError, CodecManager, ContainerLockedError, ContextPrimitive, DecodeOptions, EncodeOptions, EncodeResult, Encoding, Env, EventManager, FileLike, Format, Hook, HookOptions, HookPrimitive, Hooks, InjectOptions, InjectPrimitive, InstantiableClass, JsonSchemaCodec, JsonSchemaObject, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModulePrimitiveOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, Primitive, PrimitiveArgs, PrimitiveConfig, PrimitiveFactory, PrimitiveFactoryLike, RunFunction, SchemaCodec, Service, ServiceEntry, ServiceSubstitution, SetStateOptions, SortDirection, SortField, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, TAtomObject, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, TPage, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, Type, TypeBoxError, TypeBoxErrorParams, TypeGuard, TypeProvider, Value, WithModule, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+export { $atom, $context, $env, $hook, $inject, $module, $use, AbstractClass, Alepha, AlephaCore, AlephaDump, AlephaDumpEnvVariable, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomStatic, AtomWithValue, CircularDependencyError, CodecManager, CodecRegisterOptions, CompileOptions, CompiledEventExecutor, ContainerLockedError, ContextPrimitive, DecodeOptions, EncodeOptions, EncodeResult, Encoding, Env, EventManager, FileLike, Format, Hook, HookOptions, HookPrimitive, Hooks, InjectOptions, InjectPrimitive, InstantiableClass, JsonSchemaCodec, JsonSchemaObject, KIND, KeylessCodec, KeylessJsonSchemaCodec, LogLevel, LoggerInterface, MaybePromise, Module, ModulePrimitiveOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, Primitive, PrimitiveArgs, PrimitiveConfig, PrimitiveFactory, PrimitiveFactoryLike, RunFunction, SchemaCodec, Service, ServiceEntry, ServiceSubstitution, SetStateOptions, SortDirection, SortField, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, TAtomObject, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, TPage, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, Type, TypeBoxError, TypeBoxErrorParams, TypeGuard, TypeProvider, Value, WithModule, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
 //# sourceMappingURL=index.d.ts.map