@alepha/react 0.13.1 → 0.13.3

package/dist/core/index.d.ts

@@ -1,217 +1,47 @@
-import * as alepha81 from "alepha";
-import { Alepha, AlephaError, Async, Atom, Descriptor, FileLike, Hook, Hooks, InstantiableClass, KIND, LogLevel, LoggerInterface, Service, State, Static, StreamLike, TArray, TAtomObject, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
+import * as alepha48 from "alepha";
+import { Alepha, AlephaError, Async, Atom, FileLike, Hook, Hooks, InstantiableClass, KIND, LogLevel, LoggerInterface, Primitive, Service, State, Static, StreamLike, TArray, TAtomObject, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
 import * as react0 from "react";
 import React, { AnchorHTMLAttributes, CSSProperties, DependencyList, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { IncomingMessage, Server, ServerResponse } from "node:http";
-import dayjsDuration from "dayjs/plugin/duration.js";
-import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
 import { Readable } from "node:stream";
 import { ReadableStream } from "node:stream/web";
+import dayjsDuration from "dayjs/plugin/duration.js";
+import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
 
-//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
-declare const logEntrySchema: alepha81.TObject<{
-  level: alepha81.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-  message: alepha81.TString;
-  service: alepha81.TString;
-  module: alepha81.TString;
-  context: alepha81.TOptional<alepha81.TString>;
-  app: alepha81.TOptional<alepha81.TString>;
-  data: alepha81.TOptional<alepha81.TAny>;
-  timestamp: alepha81.TNumber;
+//#region ../alepha/src/server/schemas/errorSchema.d.ts
+declare const errorSchema: alepha48.TObject<{
+  error: alepha48.TString;
+  status: alepha48.TInteger;
+  message: alepha48.TString;
+  details: alepha48.TOptional<alepha48.TString>;
+  requestId: alepha48.TOptional<alepha48.TString>;
+  cause: alepha48.TOptional<alepha48.TObject<{
+    name: alepha48.TString;
+    message: alepha48.TString;
+  }>>;
 }>;
-type LogEntry = Static<typeof logEntrySchema>;
-//#endregion
-//#region ../alepha/src/datetime/providers/DateTimeProvider.d.ts
-type DateTime = DayjsApi.Dayjs;
-type Duration = dayjsDuration.Duration;
-type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
-declare class DateTimeProvider {
-  static PLUGINS: Array<PluginFunc<any>>;
-  protected alepha: Alepha;
-  protected ref: DateTime | null;
-  protected readonly timeouts: Timeout[];
-  protected readonly intervals: Interval[];
-  constructor();
-  protected readonly onStart: alepha81.HookDescriptor<"start">;
-  protected readonly onStop: alepha81.HookDescriptor<"stop">;
-  setLocale(locale: string): void;
-  isDateTime(value: unknown): value is DateTime;
-  /**
-   * Create a new UTC DateTime instance.
-   */
-  utc(date: string | number | Date | Dayjs | null | undefined): DateTime;
-  /**
-   * Create a new DateTime instance.
-   */
-  of(date: string | number | Date | Dayjs | null | undefined): DateTime;
-  /**
-   * Get the current date as a string.
-   */
-  toISOString(date?: Date | string | DateTime): string;
-  /**
-   * Get the current date.
-   */
-  now(): DateTime;
-  /**
-   * Get the current date as a string.
-   *
-   * This is much faster than `DateTimeProvider.now().toISOString()` as it avoids creating a DateTime instance.
-   */
-  nowISOString(): string;
-  /**
-   * Get the current date as milliseconds since epoch.
-   *
-   * This is much faster than `DateTimeProvider.now().valueOf()` as it avoids creating a DateTime instance.
-   */
-  nowMillis(): number;
-  /**
-   * Get the current date as a string.
-   *
-   * @protected
-   */
-  protected getCurrentDate(): DateTime;
-  /**
-   * Create a new Duration instance.
-   */
-  duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
-  isDurationLike(value: unknown): value is DurationLike;
-  /**
-   * Return a promise that resolves after the next tick.
-   * It uses `setTimeout` with 0 ms delay.
-   */
-  tick(): Promise<void>;
-  /**
-   * Wait for a certain duration.
-   *
-   * You can clear the timeout by using the `AbortSignal` API.
-   * Aborted signal will resolve the promise immediately, it does not reject it.
-   */
-  wait(duration: DurationLike, options?: {
-    signal?: AbortSignal;
-    now?: number;
-  }): Promise<void>;
-  createInterval(run: () => unknown, duration: DurationLike, start?: boolean): Interval;
-  /**
-   * Run a callback after a certain duration.
-   */
-  createTimeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
-  clearTimeout(timeout: Timeout): void;
-  clearInterval(interval: Interval): void;
-  /**
-   * Run a function with a deadline.
-   */
-  deadline<T$1>(fn: (signal: AbortSignal) => Promise<T$1>, duration: DurationLike): Promise<T$1>;
-  /**
-   * Add time to the current date.
-   */
-  travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
-  /**
-   * Stop the time.
-   */
-  pause(): DateTime;
-  /**
-   * Reset the reference date.
-   */
-  reset(): void;
-}
-interface Interval {
-  timer?: any;
-  duration: number;
-  run: () => unknown;
-}
-interface Timeout {
-  now: number;
-  timer?: any;
-  duration: number;
-  callback: () => void;
-  clear: () => void;
-}
-//#endregion
-//#region ../alepha/src/logger/providers/LogDestinationProvider.d.ts
-declare abstract class LogDestinationProvider {
-  abstract write(message: string, entry: LogEntry): void;
-}
-//#endregion
-//#region ../alepha/src/logger/providers/LogFormatterProvider.d.ts
-declare abstract class LogFormatterProvider {
-  abstract format(entry: LogEntry): string;
-}
+type ErrorSchema = Static<typeof errorSchema>;
 //#endregion
-//#region ../alepha/src/logger/services/Logger.d.ts
-declare class Logger implements LoggerInterface {
-  protected readonly alepha: Alepha;
-  protected readonly formatter: LogFormatterProvider;
-  protected readonly destination: LogDestinationProvider;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly levels: Record<string, number>;
-  protected readonly service: string;
-  protected readonly module: string;
-  protected readonly app?: string;
-  protected appLogLevel: string;
-  protected logLevel: LogLevel;
-  constructor(service: string, module: string);
-  get context(): string | undefined;
-  get level(): string;
-  parseLevel(level: string, app: string): LogLevel;
-  private matchesPattern;
-  asLogLevel(something: string): LogLevel;
-  error(message: string, data?: unknown): void;
-  warn(message: string, data?: unknown): void;
-  info(message: string, data?: unknown): void;
-  debug(message: string, data?: unknown): void;
-  trace(message: string, data?: unknown): void;
-  protected log(level: LogLevel, message: string, data?: unknown): void;
-  protected emit(entry: LogEntry, message?: string): void;
+//#region ../alepha/src/server/errors/HttpError.d.ts
+declare class HttpError extends AlephaError {
+  name: string;
+  static is: (error: unknown, status?: number) => error is HttpErrorLike;
+  static toJSON(error: HttpError): ErrorSchema;
+  readonly error: string;
+  readonly status: number;
+  readonly requestId?: string;
+  readonly details?: string;
+  readonly reason?: {
+    name: string;
+    message: string;
+  };
+  constructor(options: Partial<ErrorSchema>, cause?: unknown);
 }
-//#endregion
-//#region ../alepha/src/logger/index.d.ts
-declare const envSchema$6: alepha81.TObject<{
-  /**
-   * Default log level for the application.
-   *
-   * Default by environment:
-   * - dev = info
-   * - prod = info
-   * - test = error
-   *
-   * Levels are: "trace" | "debug" | "info" | "warn" | "error" | "silent"
-   *
-   * Level can be set for a specific module:
-   *
-   * @example
-   * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
-   * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
-   */
-  LOG_LEVEL: alepha81.TOptional<alepha81.TString>;
-  /**
-   * Built-in log formats.
-   * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
-   * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
-   * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
-   */
-  LOG_FORMAT: alepha81.TOptional<alepha81.TUnsafe<"json" | "pretty" | "raw">>;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$6>> {}
-  interface State {
-    /**
-     * Current log level for the application or specific modules.
-     */
-    "alepha.logger.level"?: string;
-  }
-  interface Hooks {
-    log: {
-      message?: string;
-      entry: LogEntry;
-    };
-  }
+interface HttpErrorLike extends Error {
+  status: number;
 }
 //#endregion
-//#region ../alepha/src/server/constants/routeMethods.d.ts
-declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
-type RouteMethod = (typeof routeMethods)[number];
-//#endregion
 //#region ../alepha/src/router/providers/RouterProvider.d.ts
 declare abstract class RouterProvider<T$1 extends Route = Route> {
   protected routePathRegex: RegExp;
@@ -256,6 +86,10 @@ interface Tree<T$1 extends Route> {
   };
 }
 //#endregion
+//#region ../alepha/src/server/constants/routeMethods.d.ts
+declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
+type RouteMethod = (typeof routeMethods)[number];
+//#endregion
 //#region ../alepha/src/server/helpers/ServerReply.d.ts
 /**
  * Helper for building server replies.
@@ -422,6 +256,205 @@ interface WebRequestEvent {
   res?: Response;
 }
 //#endregion
+//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
+declare const logEntrySchema: alepha48.TObject<{
+  level: alepha48.TUnsafe<"TRACE" | "SILENT" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+  message: alepha48.TString;
+  service: alepha48.TString;
+  module: alepha48.TString;
+  context: alepha48.TOptional<alepha48.TString>;
+  app: alepha48.TOptional<alepha48.TString>;
+  data: alepha48.TOptional<alepha48.TAny>;
+  timestamp: alepha48.TNumber;
+}>;
+type LogEntry = Static<typeof logEntrySchema>;
+//#endregion
+//#region ../alepha/src/datetime/providers/DateTimeProvider.d.ts
+type DateTime = DayjsApi.Dayjs;
+type Duration = dayjsDuration.Duration;
+type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
+declare class DateTimeProvider {
+  static PLUGINS: Array<PluginFunc<any>>;
+  protected alepha: Alepha;
+  protected ref: DateTime | null;
+  protected readonly timeouts: Timeout[];
+  protected readonly intervals: Interval[];
+  constructor();
+  protected readonly onStart: alepha48.HookPrimitive<"start">;
+  protected readonly onStop: alepha48.HookPrimitive<"stop">;
+  setLocale(locale: string): void;
+  isDateTime(value: unknown): value is DateTime;
+  /**
+   * Create a new UTC DateTime instance.
+   */
+  utc(date: string | number | Date | Dayjs | null | undefined): DateTime;
+  /**
+   * Create a new DateTime instance.
+   */
+  of(date: string | number | Date | Dayjs | null | undefined): DateTime;
+  /**
+   * Get the current date as a string.
+   */
+  toISOString(date?: Date | string | DateTime): string;
+  /**
+   * Get the current date.
+   */
+  now(): DateTime;
+  /**
+   * Get the current date as a string.
+   *
+   * This is much faster than `DateTimeProvider.now().toISOString()` as it avoids creating a DateTime instance.
+   */
+  nowISOString(): string;
+  /**
+   * Get the current date as milliseconds since epoch.
+   *
+   * This is much faster than `DateTimeProvider.now().valueOf()` as it avoids creating a DateTime instance.
+   */
+  nowMillis(): number;
+  /**
+   * Get the current date as a string.
+   *
+   * @protected
+   */
+  protected getCurrentDate(): DateTime;
+  /**
+   * Create a new Duration instance.
+   */
+  duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
+  isDurationLike(value: unknown): value is DurationLike;
+  /**
+   * Return a promise that resolves after the next tick.
+   * It uses `setTimeout` with 0 ms delay.
+   */
+  tick(): Promise<void>;
+  /**
+   * Wait for a certain duration.
+   *
+   * You can clear the timeout by using the `AbortSignal` API.
+   * Aborted signal will resolve the promise immediately, it does not reject it.
+   */
+  wait(duration: DurationLike, options?: {
+    signal?: AbortSignal;
+    now?: number;
+  }): Promise<void>;
+  createInterval(run: () => unknown, duration: DurationLike, start?: boolean): Interval;
+  /**
+   * Run a callback after a certain duration.
+   */
+  createTimeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
+  clearTimeout(timeout: Timeout): void;
+  clearInterval(interval: Interval): void;
+  /**
+   * Run a function with a deadline.
+   */
+  deadline<T$1>(fn: (signal: AbortSignal) => Promise<T$1>, duration: DurationLike): Promise<T$1>;
+  /**
+   * Add time to the current date.
+   */
+  travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
+  /**
+   * Stop the time.
+   */
+  pause(): DateTime;
+  /**
+   * Reset the reference date.
+   */
+  reset(): void;
+}
+interface Interval {
+  timer?: any;
+  duration: number;
+  run: () => unknown;
+}
+interface Timeout {
+  now: number;
+  timer?: any;
+  duration: number;
+  callback: () => void;
+  clear: () => void;
+}
+//#endregion
+//#region ../alepha/src/logger/providers/LogDestinationProvider.d.ts
+declare abstract class LogDestinationProvider {
+  abstract write(message: string, entry: LogEntry): void;
+}
+//#endregion
+//#region ../alepha/src/logger/providers/LogFormatterProvider.d.ts
+declare abstract class LogFormatterProvider {
+  abstract format(entry: LogEntry): string;
+}
+//#endregion
+//#region ../alepha/src/logger/services/Logger.d.ts
+declare class Logger implements LoggerInterface {
+  protected readonly alepha: Alepha;
+  protected readonly formatter: LogFormatterProvider;
+  protected readonly destination: LogDestinationProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly levels: Record<string, number>;
+  protected readonly service: string;
+  protected readonly module: string;
+  protected readonly app?: string;
+  protected appLogLevel: string;
+  protected logLevel: LogLevel;
+  constructor(service: string, module: string);
+  get context(): string | undefined;
+  get level(): string;
+  parseLevel(level: string, app: string): LogLevel;
+  private matchesPattern;
+  asLogLevel(something: string): LogLevel;
+  error(message: string, data?: unknown): void;
+  warn(message: string, data?: unknown): void;
+  info(message: string, data?: unknown): void;
+  debug(message: string, data?: unknown): void;
+  trace(message: string, data?: unknown): void;
+  protected log(level: LogLevel, message: string, data?: unknown): void;
+  protected emit(entry: LogEntry, message?: string): void;
+}
+//#endregion
+//#region ../alepha/src/logger/index.d.ts
+declare const envSchema$6: alepha48.TObject<{
+  /**
+   * Default log level for the application.
+   *
+   * Default by environment:
+   * - dev = info
+   * - prod = info
+   * - test = error
+   *
+   * Levels are: "trace" | "debug" | "info" | "warn" | "error" | "silent"
+   *
+   * Level can be set for a specific module:
+   *
+   * @example
+   * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
+   * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
+   */
+  LOG_LEVEL: alepha48.TOptional<alepha48.TString>;
+  /**
+   * Built-in log formats.
+   * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
+   * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
+   * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
+   */
+  LOG_FORMAT: alepha48.TOptional<alepha48.TUnsafe<"json" | "pretty" | "raw">>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$6>> {}
+  interface State {
+    /**
+     * Current log level for the application or specific modules.
+     */
+    "alepha.logger.level"?: string;
+  }
+  interface Hooks {
+    log: {
+      message?: string;
+      entry: LogEntry;
+    };
+  }
+}
+//#endregion
 //#region ../alepha/src/server/services/ServerRequestParser.d.ts
 declare class ServerRequestParser {
   protected readonly alepha: Alepha;
@@ -441,8 +474,8 @@ declare class ServerTimingProvider {
     prefix: string;
     disabled: boolean;
   };
-  readonly onRequest: alepha81.HookDescriptor<"server:onRequest">;
-  readonly onResponse: alepha81.HookDescriptor<"server:onResponse">;
+  readonly onRequest: alepha48.HookPrimitive<"server:onRequest">;
+  readonly onResponse: alepha48.HookPrimitive<"server:onResponse">;
   protected get handlerName(): string;
   beginTiming(name: string): void;
   endTiming(name: string): void;
@@ -506,11 +539,11 @@ declare class ServerProvider {
   /**
    * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
    */
-  protected readonly onNodeRequest: alepha81.HookDescriptor<"node:request">;
+  protected readonly onNodeRequest: alepha48.HookPrimitive<"node:request">;
   /**
    * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
    */
-  protected readonly onWebRequest: alepha81.HookDescriptor<"web:request">;
+  protected readonly onWebRequest: alepha48.HookPrimitive<"web:request">;
   /**
    * Handle Node.js HTTP request event.
    *
@@ -570,8 +603,8 @@ declare abstract class CacheProvider {
   abstract clear(): Promise<void>;
 }
 //#endregion
-//#region ../alepha/src/cache/descriptors/$cache.d.ts
-interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]> {
+//#region ../alepha/src/cache/primitives/$cache.d.ts
+interface CachePrimitiveOptions<TReturn = any, TParameter extends any[] = any[]> {
   /**
    * The cache name. This is useful for invalidating multiple caches at once.
    *
@@ -606,7 +639,7 @@ interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]
    */
   disabled?: boolean;
 }
-declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn, TParameter>> {
+declare class CachePrimitive<TReturn = any, TParameter extends any[] = any[]> extends Primitive<CachePrimitiveOptions<TReturn, TParameter>> {
   protected readonly env: {
     CACHE_ENABLED: boolean;
     CACHE_DEFAULT_TTL: number;
@@ -630,9 +663,9 @@ declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> e
   protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
   protected $provider(): CacheProvider;
 }
-interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
+interface CachePrimitiveFn<TReturn = any, TParameter extends any[] = any[]> extends CachePrimitive<TReturn, TParameter> {
   /**
-   * Run the cache descriptor with the provided arguments.
+   * Run the cache primitive with the provided arguments.
    */
   (...args: TParameter): Promise<TReturn>;
 }
@@ -641,7 +674,7 @@ interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> ext
 declare class HttpClient {
   protected readonly log: Logger;
   protected readonly alepha: Alepha;
-  readonly cache: CacheDescriptorFn<HttpClientCache, any[]>;
+  readonly cache: CachePrimitiveFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
   fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
   fetch<T$1 extends TSchema>(url: string, request?: RequestInitWithOptions<T$1>): Promise<FetchResponse<Static<T$1>>>;
@@ -709,8 +742,8 @@ interface HttpAction {
   };
 }
 //#endregion
-//#region ../alepha/src/server/descriptors/$action.d.ts
-interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
+//#region ../alepha/src/server/primitives/$action.d.ts
+interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
    * Name of the action.
    *
@@ -776,7 +809,7 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends O
    */
   handler: ServerActionHandler<TConfig>;
 }
-declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
+declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primitive<ActionPrimitiveOptions<TConfig>> {
   protected readonly log: Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
@@ -844,52 +877,19 @@ type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSche
  */
 interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
 //#endregion
-//#region ../alepha/src/server/schemas/errorSchema.d.ts
-declare const errorSchema: alepha81.TObject<{
-  error: alepha81.TString;
-  status: alepha81.TInteger;
-  message: alepha81.TString;
-  details: alepha81.TOptional<alepha81.TString>;
-  requestId: alepha81.TOptional<alepha81.TString>;
-  cause: alepha81.TOptional<alepha81.TObject<{
-    name: alepha81.TString;
-    message: alepha81.TString;
-  }>>;
-}>;
-type ErrorSchema = Static<typeof errorSchema>;
-//#endregion
-//#region ../alepha/src/server/errors/HttpError.d.ts
-declare class HttpError extends AlephaError {
-  name: string;
-  static is: (error: unknown, status?: number) => error is HttpErrorLike;
-  static toJSON(error: HttpError): ErrorSchema;
-  readonly error: string;
-  readonly status: number;
-  readonly requestId?: string;
-  readonly details?: string;
-  readonly reason?: {
-    name: string;
-    message: string;
-  };
-  constructor(options: Partial<ErrorSchema>, cause?: unknown);
-}
-interface HttpErrorLike extends Error {
-  status: number;
-}
-//#endregion
 //#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
-declare const envSchema$5: alepha81.TObject<{
-  SERVER_PORT: alepha81.TInteger;
-  SERVER_HOST: alepha81.TString;
+declare const envSchema$5: alepha48.TObject<{
+  SERVER_PORT: alepha48.TInteger;
+  SERVER_HOST: alepha48.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$5>> {}
 }
 //#endregion
 //#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema$4: alepha81.TObject<{
-  SERVER_PORT: alepha81.TInteger;
-  SERVER_HOST: alepha81.TString;
+declare const envSchema$4: alepha48.TObject<{
+  SERVER_PORT: alepha48.TInteger;
+  SERVER_HOST: alepha48.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$4>> {}
@@ -902,12 +902,12 @@ declare module "alepha" {
   }
   interface Hooks {
     "action:onRequest": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
     };
     "action:onResponse": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
       response: any;
@@ -963,7 +963,7 @@ declare module "alepha/server" {
      */
     cache?: ServerRouteCache;
   }
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
+  interface ActionPrimitive<TConfig extends RequestConfigSchema> {
     invalidate: () => Promise<void>;
   }
 }
@@ -982,11 +982,11 @@ boolean
   /**
    * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)
    * If a DurationLike is provided, it will be used as the TTL for the cache.
-   * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.
+   * If CachePrimitiveOptions is provided, it will be used to configure the cache storage.
    *
    * @default false
    */
-  store?: true | DurationLike | CacheDescriptorOptions;
+  store?: true | DurationLike | CachePrimitiveOptions;
   /**
    * If true, enables ETag support for the cached responses.
    */
@@ -1077,8 +1077,8 @@ declare class Redirection extends Error {
 }
 //#endregion
 //#region src/core/providers/ReactPageProvider.d.ts
-declare const envSchema$3: alepha81.TObject<{
-  REACT_STRICT_MODE: alepha81.TBoolean;
+declare const envSchema$3: alepha48.TObject<{
+  REACT_STRICT_MODE: alepha48.TBoolean;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$3>> {}
@@ -1091,7 +1091,7 @@ declare class ReactPageProvider {
   protected readonly alepha: Alepha;
   protected readonly pages: PageRoute[];
   getPages(): PageRoute[];
-  getConcretePages(): PageRoute[];
+  getConcretePages(): ConcretePageRoute[];
   page(name: string): PageRoute;
   pathname(name: string, options?: {
     params?: Record<string, string>;
@@ -1121,17 +1121,25 @@ declare class ReactPageProvider {
   }, params?: Record<string, any>): string;
   compile(path: string, params?: Record<string, string>): string;
   protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
-  protected readonly configure: alepha81.HookDescriptor<"configure">;
-  protected map(pages: Array<PageDescriptor>, target: PageDescriptor): PageRouteEntry;
+  protected readonly configure: alepha48.HookPrimitive<"configure">;
+  protected map(pages: Array<PagePrimitive>, target: PagePrimitive): PageRouteEntry;
   add(entry: PageRouteEntry): void;
   protected createMatch(page: PageRoute): string;
   protected _next: number;
   protected nextId(): string;
 }
 declare const isPageRoute: (it: any) => it is PageRoute;
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
+interface PageRouteEntry extends Omit<PagePrimitiveOptions, "children" | "parent"> {
   children?: PageRouteEntry[];
 }
+interface ConcretePageRoute extends PageRoute {
+  /**
+   * When exported, static routes can be split into multiple pages with different params.
+   * We replace 'name' by the new name for each static entry, and old 'name' becomes 'staticName'.
+   */
+  staticName?: string;
+  params?: Record<string, string>;
+}
 interface PageRoute extends PageRouteEntry {
   type: "page";
   name: string;
@@ -1184,6 +1192,7 @@ interface ReactRouterState {
    * Optional meta information associated with the current page.
    */
   meta: Record<string, any>;
+  name?: string;
 }
 interface RouterStackItem {
   route: PageRoute;
@@ -1202,18 +1211,18 @@ interface CreateLayersResult {
 //#endregion
 //#region src/core/services/ReactPageService.d.ts
 declare class ReactPageService {
-  fetch(pathname: string, options?: PageDescriptorRenderOptions): Promise<{
+  fetch(pathname: string, options?: PagePrimitiveRenderOptions): Promise<{
     html: string;
     response: Response;
   }>;
-  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+  render(name: string, options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
 }
 //#endregion
-//#region src/core/descriptors/$page.d.ts
+//#region src/core/primitives/$page.d.ts
 /**
- * Main descriptor for defining a React route in the application.
+ * Main primitive for defining a React route in the application.
  *
- * The $page descriptor is the core building block for creating type-safe, SSR-enabled React routes.
+ * The $page primitive is the core building block for creating type-safe, SSR-enabled React routes.
  * It provides a declarative way to define pages with powerful features:
  *
  * **Routing & Navigation**
@@ -1299,14 +1308,14 @@ declare class ReactPageService {
  * ```
  */
 declare const $page: {
-  <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
-  [KIND]: typeof PageDescriptor;
+  <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PagePrimitiveOptions<TConfig, TProps, TPropsParent>): PagePrimitive<TConfig, TProps, TPropsParent>;
+  [KIND]: typeof PagePrimitive;
 };
-interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+interface PagePrimitiveOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
   /**
    * Identifier name for the page. Must be unique.
    *
-   * @default Descriptor key
+   * @default Primitive key
    */
   name?: string;
   /**
@@ -1358,11 +1367,11 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
    * Attach child pages to create nested routes.
    * This will make the page a parent route.
    */
-  children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
+  children?: Array<PagePrimitive> | (() => Array<PagePrimitive>);
   /**
    * Define a parent page for nested routing.
    */
-  parent?: PageDescriptor<PageConfigSchema, TPropsParent, any>;
+  parent?: PagePrimitive<PageConfigSchema, TPropsParent, any>;
   can?: () => boolean;
   /**
    * Catch any error from the `resolve` function or during `rendering`.
@@ -1472,7 +1481,7 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
   animation?: PageAnimation;
 }
 type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
-declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Descriptor<PageDescriptorOptions<TConfig, TProps, TPropsParent>> {
+declare class PagePrimitive<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Primitive<PagePrimitiveOptions<TConfig, TProps, TPropsParent>> {
   protected readonly reactPageService: ReactPageService;
   protected onInit(): void;
   get name(): string;
@@ -1482,8 +1491,8 @@ declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema
    * This will render the page (HTML layout included or not) and return the HTML + context.
    * Only valid for server-side rendering, it will throw an error if called on the client-side.
    */
-  render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
-  fetch(options?: PageDescriptorRenderOptions): Promise<{
+  render(options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+  fetch(options?: PagePrimitiveRenderOptions): Promise<{
     html: string;
     response: Response;
   }>;
@@ -1496,7 +1505,7 @@ interface PageConfigSchema {
 }
 type TPropsDefault = any;
 type TPropsParentDefault = {};
-interface PageDescriptorRenderOptions {
+interface PagePrimitiveRenderOptions {
   params?: Record<string, string>;
   query?: Record<string, string>;
   /**
@@ -1508,7 +1517,7 @@ interface PageDescriptorRenderOptions {
   html?: boolean;
   hydration?: boolean;
 }
-interface PageDescriptorRenderResult {
+interface PagePrimitiveRenderResult {
   html: string;
   state: ReactRouterState;
   redirect?: string;
@@ -1531,15 +1540,15 @@ type CssAnimation = {
 };
 //#endregion
 //#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
-declare const userAccountInfoSchema: alepha81.TObject<{
-  id: alepha81.TString;
-  name: alepha81.TOptional<alepha81.TString>;
-  email: alepha81.TOptional<alepha81.TString>;
-  username: alepha81.TOptional<alepha81.TString>;
-  picture: alepha81.TOptional<alepha81.TString>;
-  sessionId: alepha81.TOptional<alepha81.TString>;
-  organizations: alepha81.TOptional<alepha81.TArray<alepha81.TString>>;
-  roles: alepha81.TOptional<alepha81.TArray<alepha81.TString>>;
+declare const userAccountInfoSchema: alepha48.TObject<{
+  id: alepha48.TString;
+  name: alepha48.TOptional<alepha48.TString>;
+  email: alepha48.TOptional<alepha48.TString>;
+  username: alepha48.TOptional<alepha48.TString>;
+  picture: alepha48.TOptional<alepha48.TString>;
+  sessionId: alepha48.TOptional<alepha48.TString>;
+  organizations: alepha48.TOptional<alepha48.TArray<alepha48.TString>>;
+  roles: alepha48.TOptional<alepha48.TArray<alepha48.TString>>;
 }>;
 type UserAccount = Static<typeof userAccountInfoSchema>;
 //#endregion
@@ -1565,8 +1574,8 @@ interface UserAccountToken extends UserAccount {
 }
 //#endregion
 //#region ../alepha/src/security/providers/SecurityProvider.d.ts
-declare const envSchema$2: alepha81.TObject<{
-  APP_SECRET: alepha81.TString;
+declare const envSchema$2: alepha48.TObject<{
+  APP_SECRET: alepha48.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$2>> {}
@@ -1584,7 +1593,7 @@ declare module "alepha" {
 /**
  * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
  *
- * The security module enables building secure applications using descriptors like `$realm`, `$role`, and `$permission`
+ * The security module enables building secure applications using primitives like `$realm`, `$role`, and `$permission`
  * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
  * integration with various authentication providers and user management systems.
  *
@@ -1659,23 +1668,23 @@ declare module "alepha/server" {
  */
 //#endregion
 //#region ../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: alepha81.TObject<{
-  name: alepha81.TString;
-  group: alepha81.TOptional<alepha81.TString>;
-  path: alepha81.TString;
-  method: alepha81.TOptional<alepha81.TString>;
-  requestBodyType: alepha81.TOptional<alepha81.TString>;
-  service: alepha81.TOptional<alepha81.TString>;
+declare const apiLinkSchema: alepha48.TObject<{
+  name: alepha48.TString;
+  group: alepha48.TOptional<alepha48.TString>;
+  path: alepha48.TString;
+  method: alepha48.TOptional<alepha48.TString>;
+  requestBodyType: alepha48.TOptional<alepha48.TString>;
+  service: alepha48.TOptional<alepha48.TString>;
 }>;
-declare const apiLinksResponseSchema: alepha81.TObject<{
-  prefix: alepha81.TOptional<alepha81.TString>;
-  links: alepha81.TArray<alepha81.TObject<{
-    name: alepha81.TString;
-    group: alepha81.TOptional<alepha81.TString>;
-    path: alepha81.TString;
-    method: alepha81.TOptional<alepha81.TString>;
-    requestBodyType: alepha81.TOptional<alepha81.TString>;
-    service: alepha81.TOptional<alepha81.TString>;
+declare const apiLinksResponseSchema: alepha48.TObject<{
+  prefix: alepha48.TOptional<alepha48.TString>;
+  links: alepha48.TArray<alepha48.TObject<{
+    name: alepha48.TString;
+    group: alepha48.TOptional<alepha48.TString>;
+    path: alepha48.TString;
+    method: alepha48.TOptional<alepha48.TString>;
+    requestBodyType: alepha48.TOptional<alepha48.TString>;
+    service: alepha48.TOptional<alepha48.TString>;
   }>>;
 }>;
 type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
@@ -1742,8 +1751,8 @@ interface ClientScope {
   service?: string;
   hostname?: string;
 }
-type HttpVirtualClient<T$1> = { [K in keyof T$1 as T$1[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T$1[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
-interface VirtualAction<T$1 extends RequestConfigSchema> extends Pick<ActionDescriptor<T$1>, "name" | "run" | "fetch"> {
+type HttpVirtualClient<T$1> = { [K in keyof T$1 as T$1[K] extends ActionPrimitive<RequestConfigSchema> ? K : never]: T$1[K] extends ActionPrimitive<infer Schema> ? VirtualAction<Schema> : never };
+interface VirtualAction<T$1 extends RequestConfigSchema> extends Pick<ActionPrimitive<T$1>, "name" | "run" | "fetch"> {
   (config?: ClientRequestEntry<T$1>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T$1>>;
   can: () => boolean;
 }
@@ -1763,7 +1772,7 @@ declare module "alepha" {
 /**
  * Provides server-side link management and remote capabilities for client-server interactions.
  *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
+ * The server-links module enables declarative link definitions using `$remote` and `$client` primitives,
  * facilitating seamless API endpoint management and client-server communication. It integrates with server
  * security features to ensure safe and controlled access to resources.
  *
@@ -1781,14 +1790,14 @@ declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
   protected readonly alepha: Alepha;
   protected readonly pageApi: ReactPageProvider;
   add(entry: PageRouteEntry): void;
-  protected readonly configure: alepha81.HookDescriptor<"configure">;
+  protected readonly configure: alepha48.HookPrimitive<"configure">;
   transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
   root(state: ReactRouterState): ReactNode;
 }
 //#endregion
 //#region src/core/providers/ReactBrowserProvider.d.ts
-declare const envSchema$1: alepha81.TObject<{
-  REACT_ROOT_ID: alepha81.TString;
+declare const envSchema$1: alepha48.TObject<{
+  REACT_ROOT_ID: alepha48.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
@@ -1796,8 +1805,8 @@ declare module "alepha" {
 /**
  * React browser renderer configuration atom
  */
-declare const reactBrowserOptions: alepha81.Atom<alepha81.TObject<{
-  scrollRestoration: alepha81.TUnsafe<"top" | "manual">;
+declare const reactBrowserOptions: alepha48.Atom<alepha48.TObject<{
+  scrollRestoration: alepha48.TUnsafe<"top" | "manual">;
 }>, "alepha.react.browser.options">;
 type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
 declare module "alepha" {
@@ -1845,8 +1854,8 @@ declare class ReactBrowserProvider {
    * Get embedded layers from the server.
    */
   protected getHydrationState(): ReactHydrationState | undefined;
-  protected readonly onTransitionEnd: alepha81.HookDescriptor<"react:transition:end">;
-  readonly ready: alepha81.HookDescriptor<"ready">;
+  protected readonly onTransitionEnd: alepha48.HookPrimitive<"react:transition:end">;
+  readonly ready: alepha48.HookPrimitive<"ready">;
 }
 interface RouterGoOptions {
   replace?: boolean;
@@ -2284,11 +2293,40 @@ declare class ReactRouter<T$1 extends object> {
   protected readonly pageApi: ReactPageProvider;
   get state(): ReactRouterState;
   get pages(): PageRoute[];
-  get concretePages(): PageRoute[];
+  get concretePages(): ConcretePageRoute[];
   get browser(): ReactBrowserProvider | undefined;
   isActive(href: string, options?: {
     startWith?: boolean;
   }): boolean;
+  node(name: keyof VirtualRouter<T$1> | string, config?: {
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+  }): {
+    label: any;
+    href: string;
+    children: undefined;
+    type: "page";
+    name: string;
+    parent?: PageRoute;
+    match: string;
+    path?: string | undefined;
+    schema?: PageConfigSchema | undefined;
+    resolve?: ((context: PageResolve<PageConfigSchema, TPropsParentDefault>) => any) | undefined;
+    component?: react0.FC<any> | undefined;
+    lazy?: (() => Promise<{
+      default: react0.FC<any>;
+    }>) | undefined;
+    can?: (() => boolean) | undefined;
+    errorHandler?: ErrorHandler | undefined;
+    static?: boolean | {
+      entries?: Partial<PageRequestConfig<PageConfigSchema>>[] | undefined;
+    } | undefined;
+    cache?: ServerRouteCache | undefined;
+    client?: (boolean | ClientOnlyProps) | undefined;
+    onServerResponse?: ((request: ServerRequest) => unknown) | undefined;
+    onLeave?: (() => void) | undefined;
+    animation?: PageAnimation | undefined;
+  };
   path(name: keyof VirtualRouter<T$1> | string, config?: {
     params?: Record<string, any>;
     query?: Record<string, any>;
@@ -2324,7 +2362,7 @@ declare class ReactRouter<T$1 extends object> {
     push?: boolean;
   }): void;
 }
-type VirtualRouter<T$1> = { [K in keyof T$1 as T$1[K] extends PageDescriptor ? K : never]: T$1[K] };
+type VirtualRouter<T$1> = { [K in keyof T$1 as T$1[K] extends PagePrimitive ? K : never]: T$1[K] };
 //#endregion
 //#region src/core/hooks/useRouter.d.ts
 /**
@@ -2346,8 +2384,8 @@ declare const useRouter: <T$1 extends object = any>() => ReactRouter<T$1>;
 //#region src/core/hooks/useRouterState.d.ts
 declare const useRouterState: () => ReactRouterState;
 //#endregion
-//#region ../alepha/src/server-static/descriptors/$serve.d.ts
-interface ServeDescriptorOptions {
+//#region ../alepha/src/server-static/primitives/$serve.d.ts
+interface ServePrimitiveOptions {
   /**
    * Prefix for the served path.
    *
@@ -2361,7 +2399,7 @@ interface ServeDescriptorOptions {
    */
   root?: string;
   /**
-   * If true, descriptor will be ignored.
+   * If true, primitive will be ignored.
    *
    * @default false
    */
@@ -2384,7 +2422,7 @@ interface ServeDescriptorOptions {
    */
   historyApiFallback?: boolean;
   /**
-   * Optional name of the descriptor.
+   * Optional name of the primitive.
    * This is used for logging and debugging purposes.
    *
    * @default Key name.
@@ -2553,26 +2591,26 @@ declare class ServerStaticProvider {
   protected readonly fileDetector: FileDetector;
   protected readonly log: Logger;
   protected readonly directories: ServeDirectory[];
-  protected readonly configure: alepha81.HookDescriptor<"configure">;
-  createStaticServer(options: ServeDescriptorOptions): Promise<void>;
-  createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
+  protected readonly configure: alepha48.HookPrimitive<"configure">;
+  createStaticServer(options: ServePrimitiveOptions): Promise<void>;
+  createFileHandler(filepath: string, options: ServePrimitiveOptions): Promise<ServerHandler>;
   protected getCacheFileTypes(): string[];
-  protected getCacheControl(filename: string, options: ServeDescriptorOptions): {
+  protected getCacheControl(filename: string, options: ServePrimitiveOptions): {
     maxAge: number;
     immutable: boolean;
   } | undefined;
   getAllFiles(dir: string, ignoreDotEnvFiles?: boolean): Promise<string[]>;
 }
 interface ServeDirectory {
-  options: ServeDescriptorOptions;
+  options: ServePrimitiveOptions;
   files: string[];
 }
 //#endregion
 //#region src/core/providers/ReactServerProvider.d.ts
-declare const envSchema: alepha81.TObject<{
-  REACT_SSR_ENABLED: alepha81.TOptional<alepha81.TBoolean>;
-  REACT_ROOT_ID: alepha81.TString;
-  REACT_SERVER_TEMPLATE: alepha81.TOptional<alepha81.TString>;
+declare const envSchema: alepha48.TObject<{
+  REACT_SSR_ENABLED: alepha48.TOptional<alepha48.TBoolean>;
+  REACT_ROOT_ID: alepha48.TString;
+  REACT_SERVER_TEMPLATE: alepha48.TOptional<alepha48.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -2583,11 +2621,11 @@ declare module "alepha" {
 /**
  * React server provider configuration atom
  */
-declare const reactServerOptions: alepha81.Atom<alepha81.TObject<{
-  publicDir: alepha81.TString;
-  staticServer: alepha81.TObject<{
-    disabled: alepha81.TBoolean;
-    path: alepha81.TString;
+declare const reactServerOptions: alepha48.Atom<alepha48.TObject<{
+  publicDir: alepha48.TString;
+  staticServer: alepha48.TObject<{
+    disabled: alepha48.TBoolean;
+    path: alepha48.TString;
   }>;
 }>, "alepha.react.server.options">;
 type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
@@ -2621,7 +2659,7 @@ declare class ReactServerProvider {
   /**
    * Configure the React server provider.
    */
-  readonly onConfigure: alepha81.HookDescriptor<"configure">;
+  readonly onConfigure: alepha48.HookPrimitive<"configure">;
   get template(): string;
   protected registerPages(templateLoader: TemplateLoader): Promise<void>;
   /**
@@ -2639,7 +2677,7 @@ declare class ReactServerProvider {
   /**
    * For testing purposes, creates a render function that can be used.
    */
-  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+  render(name: string, options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
   protected createHandler(route: PageRoute, templateLoader: TemplateLoader): ServerHandler;
   renderToHtml(template: string, state: ReactRouterState, hydration?: boolean): string | Redirection;
   protected preprocessTemplate(template: string): PreprocessedTemplate;
@@ -2750,14 +2788,14 @@ declare module "alepha" {
 /**
  * Provides full-stack React development with declarative routing, server-side rendering, and client-side hydration.
  *
- * The React module enables building modern React applications using the `$page` descriptor on class properties.
+ * The React module enables building modern React applications using the `$page` primitive on class properties.
  * It delivers seamless server-side rendering, automatic code splitting, and client-side navigation with full
  * type safety and schema validation for route parameters and data.
  *
  * @see {@link $page}
  * @module alepha.react
  */
-declare const AlephaReact: alepha81.Service<alepha81.Module>;
+declare const AlephaReact: alepha48.Service<alepha48.Module>;
 //#endregion
-export { $page, ActionContext, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, type LinkProps, _default as NestedView, NotFoundPage as NotFound, PageAnimation, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActionOptions, UseActionReturn, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, UseStoreReturn, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, ssrSchemaLoading, useAction, useActive, useAlepha, useClient, useEvents, useInject, useQueryParams, useRouter, useRouterState, useSchema, useStore };
+export { $page, ActionContext, AlephaContext, AlephaReact, AnchorProps, ClientOnly, ConcretePageRoute, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, type LinkProps, _default as NestedView, NotFoundPage as NotFound, PageAnimation, PageConfigSchema, PagePrimitive, PagePrimitiveOptions, PagePrimitiveRenderOptions, PagePrimitiveRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActionOptions, UseActionReturn, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, UseStoreReturn, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, ssrSchemaLoading, useAction, useActive, useAlepha, useClient, useEvents, useInject, useQueryParams, useRouter, useRouterState, useSchema, useStore };
 //# sourceMappingURL=index.d.ts.map