alepha 0.13.3 → 0.13.5

package/dist/core/index.d.ts

@@ -8,7 +8,7 @@ import { TLocalizedValidationError } from "typebox/error";
 import { Readable } from "node:stream";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
 
-//#region src/core/constants/KIND.d.ts
+//#region ../../src/core/constants/KIND.d.ts
 /**
  * Used for identifying primitives.
  *
@@ -16,7 +16,7 @@ import { ReadableStream as ReadableStream$1 } from "node:stream/web";
  */
 declare const KIND: unique symbol;
 //#endregion
-//#region src/core/constants/MODULE.d.ts
+//#region ../../src/core/constants/MODULE.d.ts
 /**
  * Used for identifying modules.
  *
@@ -24,7 +24,7 @@ declare const KIND: unique symbol;
  */
 declare const MODULE: unique symbol;
 //#endregion
-//#region src/core/interfaces/Service.d.ts
+//#region ../../src/core/interfaces/Service.d.ts
 /**
  * In Alepha, a service is a class that can be instantiated or an abstract class. Nothing more, nothing less...
  */
@@ -72,7 +72,7 @@ interface ServiceSubstitution<T extends object = any> {
 type ServiceEntry<T extends object = any> = Service<T> | ServiceSubstitution<T>;
 declare function isClass(func: any): func is InstantiableClass;
 //#endregion
-//#region src/core/helpers/primitive.d.ts
+//#region ../../src/core/helpers/primitive.d.ts
 interface PrimitiveArgs<T extends object = {}> {
   options: T;
   alepha: Alepha;
@@ -106,7 +106,7 @@ declare const createPrimitive: <TPrimitive extends Primitive>(primitive: Instant
   [MODULE]?: Service;
 }, options: TPrimitive["options"]) => TPrimitive;
 //#endregion
-//#region src/core/interfaces/Async.d.ts
+//#region ../../src/core/interfaces/Async.d.ts
 /**
  * Represents a value that can be either a value or a promise of value.
  */
@@ -120,7 +120,7 @@ type AsyncFn = (...args: any[]) => Async<any>;
  */
 type MaybePromise<T> = T extends Promise<any> ? T : Promise<T>;
 //#endregion
-//#region src/core/interfaces/LoggerInterface.d.ts
+//#region ../../src/core/interfaces/LoggerInterface.d.ts
 type LogLevel = "ERROR" | "WARN" | "INFO" | "DEBUG" | "TRACE" | "SILENT";
 interface LoggerInterface {
   trace(message: string, data?: unknown): void;
@@ -130,170 +130,7 @@ interface LoggerInterface {
   error(message: string, data?: unknown): void;
 }
 //#endregion
-//#region src/core/primitives/$inject.d.ts
-/**
- * Get the instance of the specified type from the context.
- *
- * ```ts
- * class A { }
- * class B {
- *   a = $inject(A);
- * }
- * ```
- */
-declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions<T>) => T;
-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"
-   */
-  lifetime?: "transient" | "singleton" | "scoped";
-  /**
-   * Constructor arguments to pass when creating a new instance.
-   */
-  args?: ConstructorParameters<InstantiableClass<T>>;
-  /**
-   * Parent that requested the instance.
-   *
-   * @internal
-   */
-  parent?: Service | null;
-}
-//#endregion
-//#region src/core/primitives/$module.d.ts
-/**
- * Wrap Services and Primitives into a Module.
- *
- * - A module is just a Service with some extra {@link Module}.
- * - You must attach a `name` to it.
- * - Name must follow the pattern: `project.module.submodule`. (e.g. `myapp.users.auth`).
- *
- * @example
- * ```ts
- * import { $module } from "alepha";
- * import { MyService } from "./MyService.ts";
- *
- * // export MyService, so it can be used everywhere (optional)
- * export * from "./MyService.ts";
- *
- * export default $module({
- *  name: "my.project.module",
- *  // MyService will have a module context "my.project.module"
- *  services: [MyService],
- * });
- * ```
- *
- * ### Why Modules?
- *
- * #### Logging
- *
- * By default, AlephaLogger will log the module name in the logs.
- * This helps to identify where the logs are coming from.
- *
- * You can also set different log levels for different modules.
- * It means you can set 'some.very.specific.module' to 'debug' and keep the rest of the application to 'info'.
- *
- * #### Modulith
- *
- * Force to structure your application in modules, even if it's a single deployable unit.
- * It helps to keep a clean architecture and avoid monolithic applications.
- *
- * A strict mode flag will probably come to enforce module boundaries.
- * -> Throwing errors when a service from another module is injected.
- * But it's not implemented yet.
- *
- * ### When not to use Modules?
- *
- * Small applications does not need modules. It's better to keep it simple.
- * Modules are more useful when the application grows and needs to be structured.
- * If we speak with number of `$actions`, a module should be used when you have more than 30 actions in a single module.
- * Meaning that if you have 100 actions, you should have at least 3 modules.
- */
-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: 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.
-   */
-  services?: Array<Service>;
-  /**
-   * 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.
-   */
-  register?: (alepha: Alepha) => void;
-}
-/**
- * Base class for all modules.
- */
-declare abstract class Module {
-  abstract readonly options: ModulePrimitiveOptions;
-  abstract register(alepha: Alepha): void;
-  static NAME_REGEX: RegExp;
-  /**
-   * 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.
-   */
-  static of(ctor: Service): Service<Module> | undefined;
-}
-/**
- * Helper type to add Module metadata to a Service.
- */
-type WithModule<T extends object = any> = T & {
-  [MODULE]?: Service;
-};
-//#endregion
-//#region src/core/providers/AlsProvider.d.ts
-type AsyncLocalStorageData = any;
-declare class AlsProvider {
-  static create: () => AsyncLocalStorage<AsyncLocalStorageData> | undefined;
-  als?: AsyncLocalStorage<AsyncLocalStorageData>;
-  constructor();
-  createContextId(): string;
-  run<R>(callback: () => R, data?: Record<string, any>): R;
-  exists(): boolean;
-  get<T>(key: string): T | undefined;
-  set<T>(key: string, value: T): void;
-}
-//#endregion
-//#region src/core/providers/Json.d.ts
-/**
- * Mimics the JSON global object with stringify and parse methods.
- *
- * Used across the codebase via dependency injection.
- */
-declare class Json {
-  stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
-  parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
-}
-//#endregion
-//#region src/core/errors/AlephaError.d.ts
+//#region ../../src/core/errors/AlephaError.d.ts
 /**
  * Default error class for Alepha.
  */
@@ -301,7 +138,7 @@ declare class AlephaError extends Error {
   name: string;
 }
 //#endregion
-//#region src/core/errors/TypeBoxError.d.ts
+//#region ../../src/core/errors/TypeBoxError.d.ts
 declare class TypeBoxError extends AlephaError {
   name: string;
   readonly cause: TLocalizedValidationError;
@@ -315,7 +152,7 @@ interface TypeBoxErrorParams {
   requiredProperties?: string[];
 }
 //#endregion
-//#region src/core/helpers/FileLike.d.ts
+//#region ../../src/core/helpers/FileLike.d.ts
 interface FileLike {
   /**
    * Filename.
@@ -378,7 +215,7 @@ declare const isFileLike: (value: any) => value is FileLike;
 type StreamLike = ReadableStream | ReadableStream$1 | Readable | NodeJS.ReadableStream;
 type TStream = TUnsafe$1<StreamLike>;
 //#endregion
-//#region src/core/providers/TypeProvider.d.ts
+//#region ../../src/core/providers/TypeProvider.d.ts
 declare const isUUID: typeof TypeBoxFormat.IsUuid;
 declare const isEmail: typeof TypeBoxFormat.IsEmail;
 declare const isURL: typeof TypeBoxFormat.IsUrl;
@@ -492,8 +329,8 @@ declare class TypeProvider {
    * ```
    */
   readonly schema: TypeGuard;
-  extend<T extends TSchema$1[], U$1 extends TProperties$1>(schema: [...T], properties: U$1, options?: TSchemaOptions): TInterface<T, U$1>;
-  extend<T extends TObject$1, U$1 extends TProperties$1>(schema: T, properties: U$1, options?: TSchemaOptions): TInterface<[T], U$1>;
+  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>;
   pick<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TPick$1<T, TKeysToIndexer$1<Indexer>>;
   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>;
@@ -675,7 +512,226 @@ interface TTextOptions extends TStringOptions$1 {
 }
 declare const t: TypeProvider;
 //#endregion
-//#region src/core/providers/SchemaCodec.d.ts
+//#region ../../src/core/primitives/$atom.d.ts
+/**
+ * Define an atom for state management.
+ *
+ * Atom lets you define a piece of state with a name, schema, and default value.
+ *
+ * By default, Alepha state is just a simple key-value store.
+ * Using atoms allows you to have type safety, validation, and default values for your state.
+ *
+ * You control how state is structured and validated.
+ *
+ * Features:
+ * - Set a schema for validation
+ * - Set a default value for initial state
+ * - Rules, like read-only, custom validation, etc.
+ * - Automatic getter access in services with {@link $use}
+ * - SSR support (server state automatically serialized and hydrated on client)
+ * - React integration (useAtom hook for automatic component re-renders)
+ * - Middleware
+ * - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
+ * - State migrations (version upgrades when schema changes)
+ * - Documentation generation & devtools integration
+ *
+ * Common use cases:
+ * - user preferences
+ * - feature flags
+ * - configuration options
+ * - session data
+ *
+ * Atom must contain only serializable data.
+ * Avoid storing complex objects like class instances, functions, or DOM elements.
+ * If you need to store complex data, consider using identifiers or references instead.
+ */
+declare const $atom: {
+  <T extends TObject<TProperties$2> | TArray$1, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
+  [KIND]: string;
+};
+type AtomOptions<T extends TAtomObject, N extends string> = {
+  name: N;
+  schema: T;
+  description?: string;
+} & (T extends TOptionalAdd<T> ? {
+  default?: Static<T>;
+} : {
+  default: Static<T>;
+});
+declare class Atom<T extends TAtomObject = TObject, N extends string = string> {
+  readonly options: AtomOptions<T, N>;
+  get schema(): T;
+  get key(): N;
+  constructor(options: AtomOptions<T, N>);
+}
+type TProperties$2 = any;
+type TAtomObject = TObject<any> | TArray$1;
+type AtomStatic<T extends TAtomObject> = T extends TOptionalAdd<T> ? Static<T> | undefined : Static<T>;
+//#endregion
+//#region ../../src/core/primitives/$inject.d.ts
+/**
+ * Get the instance of the specified type from the context.
+ *
+ * ```ts
+ * class A { }
+ * class B {
+ *   a = $inject(A);
+ * }
+ * ```
+ */
+declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions<T>) => T;
+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"
+   */
+  lifetime?: "transient" | "singleton" | "scoped";
+  /**
+   * Constructor arguments to pass when creating a new instance.
+   */
+  args?: ConstructorParameters<InstantiableClass<T>>;
+  /**
+   * Parent that requested the instance.
+   *
+   * @internal
+   */
+  parent?: Service | null;
+}
+//#endregion
+//#region ../../src/core/primitives/$module.d.ts
+/**
+ * Wrap Services and Primitives into a Module.
+ *
+ * - A module is just a Service with some extra {@link Module}.
+ * - You must attach a `name` to it.
+ * - Name must follow the pattern: `project.module.submodule`. (e.g. `myapp.users.auth`).
+ *
+ * @example
+ * ```ts
+ * import { $module } from "alepha";
+ * import { MyService } from "./MyService.ts";
+ *
+ * // export MyService, so it can be used everywhere (optional)
+ * export * from "./MyService.ts";
+ *
+ * export default $module({
+ *  name: "my.project.module",
+ *  // MyService will have a module context "my.project.module"
+ *  services: [MyService],
+ * });
+ * ```
+ *
+ * ### Why Modules?
+ *
+ * #### Logging
+ *
+ * By default, AlephaLogger will log the module name in the logs.
+ * This helps to identify where the logs are coming from.
+ *
+ * You can also set different log levels for different modules.
+ * It means you can set 'some.very.specific.module' to 'debug' and keep the rest of the application to 'info'.
+ *
+ * #### Modulith
+ *
+ * Force to structure your application in modules, even if it's a single deployable unit.
+ * It helps to keep a clean architecture and avoid monolithic applications.
+ *
+ * A strict mode flag will probably come to enforce module boundaries.
+ * -> Throwing errors when a service from another module is injected.
+ * But it's not implemented yet.
+ *
+ * ### When not to use Modules?
+ *
+ * Small applications does not need modules. It's better to keep it simple.
+ * Modules are more useful when the application grows and needs to be structured.
+ * If we speak with number of `$actions`, a module should be used when you have more than 30 actions in a single module.
+ * Meaning that if you have 100 actions, you should have at least 3 modules.
+ */
+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: 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.
+   */
+  services?: Array<Service>;
+  /**
+   * 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.
+   */
+  register?: (alepha: Alepha) => void;
+}
+/**
+ * Base class for all modules.
+ */
+declare abstract class Module {
+  abstract readonly options: ModulePrimitiveOptions;
+  abstract register(alepha: Alepha): void;
+  static NAME_REGEX: RegExp;
+  /**
+   * 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.
+   */
+  static of(ctor: Service): Service<Module> | undefined;
+}
+/**
+ * Helper type to add Module metadata to a Service.
+ */
+type WithModule<T extends object = any> = T & {
+  [MODULE]?: Service;
+};
+//#endregion
+//#region ../../src/core/providers/AlsProvider.d.ts
+type AsyncLocalStorageData = any;
+declare class AlsProvider {
+  static create: () => AsyncLocalStorage<AsyncLocalStorageData> | undefined;
+  als?: AsyncLocalStorage<AsyncLocalStorageData>;
+  constructor();
+  createContextId(): string;
+  run<R>(callback: () => R, data?: Record<string, any>): R;
+  exists(): boolean;
+  get<T>(key: string): T | undefined;
+  set<T>(key: string, value: T): void;
+}
+//#endregion
+//#region ../../src/core/providers/Json.d.ts
+/**
+ * Mimics the JSON global object with stringify and parse methods.
+ *
+ * Used across the codebase via dependency injection.
+ */
+declare class Json {
+  stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+  parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
+}
+//#endregion
+//#region ../../src/core/providers/SchemaCodec.d.ts
 declare abstract class SchemaCodec {
   /**
    * Encode the value to a string format.
@@ -691,7 +747,7 @@ declare abstract class SchemaCodec {
   abstract decode<T>(schema: TSchema, value: unknown): T;
 }
 //#endregion
-//#region src/core/providers/JsonSchemaCodec.d.ts
+//#region ../../src/core/providers/JsonSchemaCodec.d.ts
 declare class JsonSchemaCodec extends SchemaCodec {
   protected readonly json: Json;
   protected readonly encoder: TextEncoder;
@@ -701,7 +757,7 @@ declare class JsonSchemaCodec extends SchemaCodec {
   decode<T>(schema: TSchema$1, value: unknown): T;
 }
 //#endregion
-//#region src/core/providers/SchemaValidator.d.ts
+//#region ../../src/core/providers/SchemaValidator.d.ts
 declare class SchemaValidator {
   protected cache: Map<TSchema$1, Validator<TypeBox.TProperties, TSchema$1, unknown, unknown>>;
   /**
@@ -729,7 +785,7 @@ interface ValidateOptions {
   deleteUndefined?: boolean;
 }
 //#endregion
-//#region src/core/providers/CodecManager.d.ts
+//#region ../../src/core/providers/CodecManager.d.ts
 type Encoding = "object" | "string" | "binary";
 interface EncodeOptions<T extends Encoding = Encoding> {
   /**
@@ -805,7 +861,7 @@ declare class CodecManager {
   validate<T extends TSchema$1>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
 }
 //#endregion
-//#region src/core/providers/EventManager.d.ts
+//#region ../../src/core/providers/EventManager.d.ts
 declare class EventManager {
   protected logFn?: () => LoggerInterface | undefined;
   /**
@@ -844,63 +900,7 @@ declare class EventManager {
   }): Promise<void>;
 }
 //#endregion
-//#region src/core/primitives/$atom.d.ts
-/**
- * Define an atom for state management.
- *
- * Atom lets you define a piece of state with a name, schema, and default value.
- *
- * By default, Alepha state is just a simple key-value store.
- * Using atoms allows you to have type safety, validation, and default values for your state.
- *
- * You control how state is structured and validated.
- *
- * Features:
- * - Set a schema for validation
- * - Set a default value for initial state
- * - Rules, like read-only, custom validation, etc.
- * - Automatic getter access in services with {@link $use}
- * - SSR support (server state automatically serialized and hydrated on client)
- * - React integration (useAtom hook for automatic component re-renders)
- * - Middleware
- * - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
- * - State migrations (version upgrades when schema changes)
- * - Documentation generation & devtools integration
- *
- * Common use cases:
- * - user preferences
- * - feature flags
- * - configuration options
- * - session data
- *
- * Atom must contain only serializable data.
- * Avoid storing complex objects like class instances, functions, or DOM elements.
- * If you need to store complex data, consider using identifiers or references instead.
- */
-declare const $atom: {
-  <T extends TObject<TProperties$2> | TArray$1, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
-  [KIND]: string;
-};
-type AtomOptions<T extends TAtomObject, N extends string> = {
-  name: N;
-  schema: T;
-  description?: string;
-} & (T extends TOptionalAdd<T> ? {
-  default?: Static<T>;
-} : {
-  default: Static<T>;
-});
-declare class Atom<T extends TAtomObject = TObject, N extends string = string> {
-  readonly options: AtomOptions<T, N>;
-  get schema(): T;
-  get key(): N;
-  constructor(options: AtomOptions<T, N>);
-}
-type TProperties$2 = any;
-type TAtomObject = TObject<any> | TArray$1;
-type AtomStatic<T extends TAtomObject> = T extends TOptionalAdd<T> ? Static<T> | undefined : Static<T>;
-//#endregion
-//#region src/core/providers/StateManager.d.ts
+//#region ../../src/core/providers/StateManager.d.ts
 interface AtomWithValue {
   atom: Atom;
   value: unknown;
@@ -952,7 +952,7 @@ declare class StateManager<State$1 extends object = State> {
 }
 type OnlyArray<T extends object> = { [K in keyof T]: NonNullable<T[K]> extends Array<any> ? K : never };
 //#endregion
-//#region src/core/Alepha.d.ts
+//#region ../../src/core/Alepha.d.ts
 /**
  * Core container of the Alepha framework.
  *
@@ -1176,6 +1176,8 @@ declare class Alepha {
    */
   get env(): Readonly<Env>;
   constructor(init?: 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.
    *
@@ -1471,7 +1473,7 @@ interface Hooks {
   };
 }
 //#endregion
-//#region src/core/interfaces/Run.d.ts
+//#region ../../src/core/interfaces/Run.d.ts
 interface RunOptions {
   /**
    * Environment variables to be used by the application.
@@ -1498,7 +1500,7 @@ interface RunOptions {
   cluster?: boolean;
 }
 //#endregion
-//#region src/core/constants/OPTIONS.d.ts
+//#region ../../src/core/constants/OPTIONS.d.ts
 /**
  * Used for primitives options.
  *
@@ -1506,31 +1508,31 @@ interface RunOptions {
  */
 declare const OPTIONS: unique symbol;
 //#endregion
-//#region src/core/errors/AppNotStartedError.d.ts
+//#region ../../src/core/errors/AppNotStartedError.d.ts
 declare class AppNotStartedError extends AlephaError {
   readonly name = "AppNotStartedError";
   constructor();
 }
 //#endregion
-//#region src/core/errors/CircularDependencyError.d.ts
+//#region ../../src/core/errors/CircularDependencyError.d.ts
 declare class CircularDependencyError extends AlephaError {
   readonly name = "CircularDependencyError";
   constructor(provider: string, parents?: string[]);
 }
 //#endregion
-//#region src/core/errors/ContainerLockedError.d.ts
+//#region ../../src/core/errors/ContainerLockedError.d.ts
 declare class ContainerLockedError extends AlephaError {
   readonly name = "ContainerLockedError";
   constructor(message?: string);
 }
 //#endregion
-//#region src/core/errors/TooLateSubstitutionError.d.ts
+//#region ../../src/core/errors/TooLateSubstitutionError.d.ts
 declare class TooLateSubstitutionError extends AlephaError {
   readonly name = "TooLateSubstitutionError";
   constructor(original: string, substitution: string);
 }
 //#endregion
-//#region src/core/schemas/pageSchema.d.ts
+//#region ../../src/core/schemas/pageSchema.d.ts
 declare const pageMetadataSchema: TObject<{
   number: TInteger;
   size: TInteger;
@@ -1623,7 +1625,7 @@ declare module "alepha" {
   }
 }
 //#endregion
-//#region src/core/helpers/createPagination.d.ts
+//#region ../../src/core/helpers/createPagination.d.ts
 /**
  * Create a pagination object from an array of entities.
  *
@@ -1673,7 +1675,7 @@ declare function createPagination<T>(entities: T[], limit?: number, offset?: num
   direction: "asc" | "desc";
 }>): Page<T>;
 //#endregion
-//#region src/core/interfaces/Pagination.d.ts
+//#region ../../src/core/interfaces/Pagination.d.ts
 /**
  * Generic pagination request parameters.
  *
@@ -1728,7 +1730,7 @@ interface SortField {
   direction: SortDirection;
 }
 //#endregion
-//#region src/core/primitives/$context.d.ts
+//#region ../../src/core/primitives/$context.d.ts
 /**
  * Get Alepha instance and current service from the current context.
  *
@@ -1773,7 +1775,7 @@ interface ContextPrimitive {
   module?: Service;
 }
 //#endregion
-//#region src/core/primitives/$env.d.ts
+//#region ../../src/core/primitives/$env.d.ts
 /**
  * Get typed values from environment variables.
  *
@@ -1802,7 +1804,7 @@ interface ContextPrimitive {
  */
 declare const $env: <T extends TObject$1>(type: T) => Static$1<T>;
 //#endregion
-//#region src/core/primitives/$hook.d.ts
+//#region ../../src/core/primitives/$hook.d.ts
 /**
  * Registers a new hook.
  *
@@ -1873,7 +1875,7 @@ declare class HookPrimitive<T extends keyof Hooks> extends Primitive<HookOptions
   protected onInit(): void;
 }
 //#endregion
-//#region src/core/primitives/$use.d.ts
+//#region ../../src/core/primitives/$use.d.ts
 /**
  * Subscribes to an atom's state and returns its current value for use in components.
  *
@@ -1898,7 +1900,7 @@ declare class HookPrimitive<T extends keyof Hooks> extends Primitive<HookOptions
  */
 declare const $use: <T extends TObject, N extends string>(atom: Atom<T, N>) => Readonly<Static<T>>;
 //#endregion
-//#region src/core/schemas/pageQuerySchema.d.ts
+//#region ../../src/core/schemas/pageQuerySchema.d.ts
 declare const pageQuerySchema: TObject<{
   page: TOptional<TInteger>;
   size: TOptional<TInteger>;
@@ -1906,7 +1908,7 @@ declare const pageQuerySchema: TObject<{
 }>;
 type PageQuery = Static<typeof pageQuerySchema>;
 //#endregion
-//#region src/core/index.d.ts
+//#region ../../src/core/index.d.ts
 /**
  * Run Alepha application, trigger start lifecycle.
  *