@alepha/react 0.13.0 → 0.13.2

package/dist/head/index.d.ts

@@ -1,1780 +1,1044 @@
-import * as alepha84 from "alepha";
-import { Alepha, AlephaError, Async, Atom, Descriptor, FileLike, InstantiableClass, KIND, LogLevel, LoggerInterface, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import React, { FC, ReactNode } from "react";
-import "react/jsx-runtime";
+import { PageConfigSchema, PageRoute, ReactRouterState, TPropsDefault, TPropsParentDefault } from "@alepha/react";
+import * as alepha30 from "alepha";
+import { Alepha, AlephaError, Async, FileLike, InstantiableClass, KIND, LogLevel, LoggerInterface, Primitive, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
 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: alepha84.TObject<{
-  level: alepha84.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-  message: alepha84.TString;
-  service: alepha84.TString;
-  module: alepha84.TString;
-  context: alepha84.TOptional<alepha84.TString>;
-  app: alepha84.TOptional<alepha84.TString>;
-  data: alepha84.TOptional<alepha84.TAny>;
-  timestamp: alepha84.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: alepha84.HookDescriptor<"start">;
-  protected readonly onStop: alepha84.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;
-}
-//#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: alepha84.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: alepha84.TOptional<alepha84.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: alepha84.TOptional<alepha84.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/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;
-  protected tree: Tree<T$1>;
-  protected cache: Map<string, RouteMatch<T$1>>;
-  match(path: string): RouteMatch<T$1>;
-  protected test(path: string): void;
-  protected push(route: T$1): void;
-  protected createRouteMatch(path: string): RouteMatch<T$1>;
-  protected mapParams(match: RouteMatch<T$1>): RouteMatch<T$1>;
-  protected createParts(path: string): string[];
-}
-interface RouteMatch<T$1 extends Route> {
-  route?: T$1;
-  params?: Record<string, string>;
-}
-interface Route {
-  path: string;
-  /**
-   * Rename a param in the route.
-   * This is automatically filled when you have scenarios like:
-   * `/customers/:id` and `/customers/:userId/payments`
-   *
-   * In this case, `:id` will be renamed to `:userId` in the second route.
-   */
-  mapParams?: Record<string, string>;
-}
-interface Tree<T$1 extends Route> {
-  route?: T$1;
-  children: {
-    [key: string]: Tree<T$1>;
+//#region src/head/interfaces/Head.d.ts
+interface Head extends SimpleHead {
+  description?: string;
+  keywords?: string[];
+  author?: string;
+  robots?: string;
+  themeColor?: string;
+  viewport?: string | {
+    width?: string;
+    height?: string;
+    initialScale?: string;
+    maximumScale?: string;
+    userScalable?: "no" | "yes" | "0" | "1";
+    interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
   };
-  param?: {
-    route?: T$1;
-    name: string;
-    children: {
-      [key: string]: Tree<T$1>;
-    };
+  og?: {
+    title?: string;
+    description?: string;
+    image?: string;
+    url?: string;
+    type?: string;
   };
-  wildcard?: {
-    route: T$1;
+  twitter?: {
+    card?: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    site?: string;
   };
 }
+interface SimpleHead {
+  title?: string;
+  titleSeparator?: string;
+  htmlAttributes?: Record<string, string>;
+  bodyAttributes?: Record<string, string>;
+  meta?: Array<{
+    name: string;
+    content: string;
+  }>;
+}
 //#endregion
-//#region ../alepha/src/server/helpers/ServerReply.d.ts
+//#region src/head/providers/HeadProvider.d.ts
+declare class HeadProvider {
+  global?: Head | (() => Head);
+  protected getGlobalHead(): Head | undefined;
+  fillHead(state: ReactRouterState): void;
+  protected fillHeadByPage(page: PageRoute, state: ReactRouterState, props: Record<string, any>): void;
+}
+//#endregion
+//#region src/head/primitives/$head.d.ts
 /**
- * Helper for building server replies.
+ * Set global `<head>` options for the application.
  */
-declare class ServerReply {
-  headers: Record<string, string> & {
-    "set-cookie"?: string[];
-  };
-  status?: number;
-  body?: any;
-  /**
-   * Redirect to a given URL with optional status code (default 302).
-   */
-  redirect(url: string, status?: number): void;
-  /**
-   * Set the response status code.
-   */
-  setStatus(status: number): this;
-  /**
-   * Set a response header.
-   */
-  setHeader(name: string, value: string): this;
-  /**
-   * Set the response body.
-   */
-  setBody(body: any): this;
+declare const $head: {
+  (options: HeadPrimitiveOptions): HeadPrimitive;
+  [KIND]: typeof HeadPrimitive;
+};
+type HeadPrimitiveOptions = Head | (() => Head);
+declare class HeadPrimitive extends Primitive<HeadPrimitiveOptions> {
+  protected readonly provider: HeadProvider;
+  protected onInit(): void;
 }
 //#endregion
-//#region ../alepha/src/server/services/UserAgentParser.d.ts
-interface UserAgentInfo {
-  os: "Windows" | "Android" | "Ubuntu" | "MacOS" | "iOS" | "Linux" | "FreeBSD" | "OpenBSD" | "ChromeOS" | "BlackBerry" | "Symbian" | "Windows Phone";
-  browser: "Chrome" | "Firefox" | "Safari" | "Edge" | "Opera" | "Internet Explorer" | "Brave" | "Vivaldi" | "Samsung Browser" | "UC Browser" | "Yandex";
-  device: "MOBILE" | "DESKTOP" | "TABLET";
-}
+//#region src/head/hooks/useHead.d.ts
 /**
- * Simple User-Agent parser to detect OS, browser, and device type.
- * This parser is not exhaustive and may not cover all edge cases.
+ * ```tsx
+ * const App = () => {
+ *   const [head, setHead] = useHead({
+ *     // will set the document title on the first render
+ *     title: "My App",
+ *   });
  *
- * Use result for non
+ *   return (
+ *     // This will update the document title when the button is clicked
+ *     <button onClick={() => setHead({ title: "Change Title" })}>
+ *       Change Title {head.title}
+ *     </button>
+ *   );
+ * }
+ * ```
  */
-declare class UserAgentParser {
-  parse(userAgent?: string): UserAgentInfo;
-}
+declare const useHead: (options?: UseHeadOptions) => UseHeadReturn;
+type UseHeadOptions = Head | ((previous?: Head) => Head);
+type UseHeadReturn = [Head, (head?: Head | ((previous?: Head) => Head)) => void];
 //#endregion
-//#region ../alepha/src/server/interfaces/ServerRequest.d.ts
-type TRequestBody = TObject | TString | TArray | TRecord | TStream;
-type TResponseBody = TObject | TString | TRecord | TFile | TArray | TStream | TVoid;
-interface RequestConfigSchema {
-  body?: TRequestBody;
-  params?: TObject;
-  query?: TObject;
-  headers?: TObject;
-  response?: TResponseBody;
-}
-interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-  body: TConfig["body"] extends TRequestBody ? Static<TConfig["body"]> : any;
-  headers: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
-  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : Record<string, string>;
-  query: TConfig["query"] extends TObject ? Static<TConfig["query"]> : Record<string, any>;
-}
-type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
-interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
-  /**
-   * HTTP method used for this request.
-   */
-  method: RouteMethod;
-  /**
-   * Full request URL.
-   */
-  url: URL;
-  /**
-   * Unique request ID assigned to this request.
-   */
-  requestId: string;
-  /**
-   * Client IP address.
-   * Will parse `X-Forwarded-For` header if present.
-   */
-  ip?: string;
-  /**
-   * Value of the `Host` header sent by the client.
-   */
-  host?: string;
-  /**
-   * Browser user agent information.
-   * Information are not guaranteed to be accurate. Use with caution.
-   *
-   * @see {@link UserAgentParser}
-   */
-  userAgent: UserAgentInfo;
-  /**
-   * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
-   */
-  metadata: Record<string, any>;
-  /**
-   * Reply object to be used to send response.
-   */
-  reply: ServerReply;
-  /**
-   * The raw underlying request object (Web Request).
-   */
-  raw: ServerRawRequest;
-}
-interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
-  /**
-   * Handler function for this route.
-   */
-  handler: ServerHandler<TConfig>;
-  /**
-   * HTTP method for this route.
-   */
-  method?: RouteMethod;
-  /**
-   * Request/response schema for this route.
-   *
-   * Request schema contains:
-   * - body, for POST/PUT/PATCH requests
-   * - params, for URL parameters (e.g. /user/:id)
-   * - query, for URL query parameters (e.g. /user?id=123)
-   * - headers, for HTTP headers
-   *
-   * Response schema contains:
-   * - response
-   *
-   * Response schema is used to validate and serialize the response sent by the handler.
-   */
-  schema?: TConfig;
-  /**
-   * @see ServerLoggerProvider
-   */
-  silent?: boolean;
+//#region ../alepha/src/server/schemas/errorSchema.d.ts
+declare const errorSchema: alepha30.TObject<{
+  error: alepha30.TString;
+  status: alepha30.TInteger;
+  message: alepha30.TString;
+  details: alepha30.TOptional<alepha30.TString>;
+  requestId: alepha30.TOptional<alepha30.TString>;
+  cause: alepha30.TOptional<alepha30.TObject<{
+    name: alepha30.TString;
+    message: alepha30.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);
 }
-type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
-type ResponseKind = "json" | "text" | "void" | "file" | "any";
-type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
-type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
-interface ServerResponse$1 {
-  body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
-  headers: Record<string, string>;
+interface HttpErrorLike extends Error {
   status: number;
 }
-type ServerRouteRequestHandler = (request: ServerRequestData) => Promise<ServerResponse$1>;
-interface ServerRouteMatcher extends Route {
-  handler: ServerRouteRequestHandler;
-}
-interface ServerRequestData {
-  method: RouteMethod;
-  url: URL;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-  params: Record<string, string>;
-  raw: ServerRawRequest;
-}
-interface ServerRawRequest {
-  node?: NodeRequestEvent;
-  web?: WebRequestEvent;
-}
-interface NodeRequestEvent {
-  req: IncomingMessage;
-  res: ServerResponse;
-}
-interface WebRequestEvent {
-  req: Request;
-  res?: Response;
-}
 //#endregion
-//#region ../alepha/src/server/services/ServerRequestParser.d.ts
-declare class ServerRequestParser {
-  protected readonly alepha: Alepha;
-  protected readonly userAgentParser: UserAgentParser;
-  createServerRequest(rawRequest: ServerRequestData): ServerRequest;
-  getRequestId(request: ServerRequestData): string | undefined;
-  getRequestUserAgent(request: ServerRequestData): UserAgentInfo;
-  getRequestIp(request: ServerRequestData): string | undefined;
-}
-//#endregion
-//#region ../alepha/src/server/providers/ServerTimingProvider.d.ts
-type TimingMap = Record<string, [number, number]>;
-declare class ServerTimingProvider {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  options: {
-    prefix: string;
-    disabled: boolean;
-  };
-  readonly onRequest: alepha84.HookDescriptor<"server:onRequest">;
-  readonly onResponse: alepha84.HookDescriptor<"server:onResponse">;
-  protected get handlerName(): string;
-  beginTiming(name: string): void;
-  endTiming(name: string): void;
-  protected setDuration(name: string, timing: TimingMap): void;
+//#region ../alepha/src/router/providers/RouterProvider.d.ts
+declare abstract class RouterProvider<T extends Route = Route> {
+  protected routePathRegex: RegExp;
+  protected tree: Tree<T>;
+  protected cache: Map<string, RouteMatch<T>>;
+  match(path: string): RouteMatch<T>;
+  protected test(path: string): void;
+  protected push(route: T): void;
+  protected createRouteMatch(path: string): RouteMatch<T>;
+  protected mapParams(match: RouteMatch<T>): RouteMatch<T>;
+  protected createParts(path: string): string[];
 }
-//#endregion
-//#region ../alepha/src/server/providers/ServerRouterProvider.d.ts
-/**
- * Main router for all routes on the server side.
- *
- * - $route => generic route
- * - $action => action route (for API calls)
- * - $page => React route (for SSR)
- */
-declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  protected readonly routes: ServerRoute[];
-  protected readonly serverTimingProvider: ServerTimingProvider;
-  protected readonly serverRequestParser: ServerRequestParser;
+interface RouteMatch<T extends Route> {
+  route?: T;
+  params?: Record<string, string>;
+}
+interface Route {
+  path: string;
   /**
-   * Get all registered routes, optionally filtered by a pattern.
+   * Rename a param in the route.
+   * This is automatically filled when you have scenarios like:
+   * `/customers/:id` and `/customers/:userId/payments`
    *
-   * Pattern accept simple wildcard '*' at the end.
-   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
+   * In this case, `:id` will be renamed to `:userId` in the second route.
    */
-  getRoutes(pattern?: string): ServerRoute[];
-  createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
-  protected getContextId(headers: Record<string, string>): string;
-  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
-    status: number;
-    headers: Record<string, string> & {
-      "set-cookie"?: string[];
+  mapParams?: Record<string, string>;
+}
+interface Tree<T extends Route> {
+  route?: T;
+  children: {
+    [key: string]: Tree<T>;
+  };
+  param?: {
+    route?: T;
+    name: string;
+    children: {
+      [key: string]: Tree<T>;
     };
-    body: any;
-  }>;
-  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
-  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
-  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
-  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
-  validateRequest(route: {
-    schema?: RequestConfigSchema;
-  }, request: ServerRequestConfig): void;
+  };
+  wildcard?: {
+    route: T;
+  };
 }
 //#endregion
-//#region ../alepha/src/server/providers/ServerProvider.d.ts
+//#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
 /**
- * Base server provider to handle incoming requests and route them.
- *
- * This is the default implementation for serverless environments.
- *
- * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
+ * Helper for building server replies.
  */
-declare class ServerProvider {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly router: ServerRouterProvider;
-  protected readonly internalServerErrorMessage = "Internal Server Error";
-  get hostname(): string;
-  /**
-   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
-   */
-  protected readonly onNodeRequest: alepha84.HookDescriptor<"node:request">;
+declare class ServerReply {
+  headers: Record<string, string> & {
+    "set-cookie"?: string[];
+  };
+  status?: number;
+  body?: any;
   /**
-   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
+   * Redirect to a given URL with optional status code (default 302).
    */
-  protected readonly onWebRequest: alepha84.HookDescriptor<"web:request">;
+  redirect(url: string, status?: number): void;
   /**
-   * Handle Node.js HTTP request event.
-   *
-   * Technically, we just convert Node.js request to Web Standard Request.
+   * Set the response status code.
    */
-  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
+  setStatus(status: number): this;
   /**
-   * Handle Web (Fetch API) request event.
+   * Set a response header.
    */
-  handleWebRequest(ev: WebRequestEvent): Promise<void>;
+  setHeader(name: string, value: string): this;
   /**
-   * Helper for Vite development mode to let Vite handle (or not) 404.
+   * Set the response body.
    */
-  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
+  setBody(body: any): this;
 }
 //#endregion
-//#region ../alepha/src/cache/providers/CacheProvider.d.ts
+//#region ../alepha/src/server/services/UserAgentParser.d.ts
+interface UserAgentInfo {
+  os: "Windows" | "Android" | "Ubuntu" | "MacOS" | "iOS" | "Linux" | "FreeBSD" | "OpenBSD" | "ChromeOS" | "BlackBerry" | "Symbian" | "Windows Phone";
+  browser: "Chrome" | "Firefox" | "Safari" | "Edge" | "Opera" | "Internet Explorer" | "Brave" | "Vivaldi" | "Samsung Browser" | "UC Browser" | "Yandex";
+  device: "MOBILE" | "DESKTOP" | "TABLET";
+}
 /**
- * Cache provider interface.
+ * Simple User-Agent parser to detect OS, browser, and device type.
+ * This parser is not exhaustive and may not cover all edge cases.
  *
- * All methods are asynchronous and return promises.
- * Values are stored as Uint8Array.
+ * Use result for non
  */
-declare abstract class CacheProvider {
-  /**
-   * Get the value of a key.
-   *
-   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-   * @param key The key of the value to get.
-   *
-   * @return The value of the key, or undefined if the key does not exist.
-   */
-  abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
+declare class UserAgentParser {
+  parse(userAgent?: string): UserAgentInfo;
+}
+//#endregion
+//#region ../alepha/src/server/interfaces/ServerRequest.d.ts
+type TRequestBody = TObject | TString | TArray | TRecord | TStream;
+type TResponseBody = TObject | TString | TRecord | TFile | TArray | TStream | TVoid;
+interface RequestConfigSchema {
+  body?: TRequestBody;
+  params?: TObject;
+  query?: TObject;
+  headers?: TObject;
+  response?: TResponseBody;
+}
+interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
+  body: TConfig["body"] extends TRequestBody ? Static<TConfig["body"]> : any;
+  headers: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : Record<string, string>;
+  query: TConfig["query"] extends TObject ? Static<TConfig["query"]> : Record<string, any>;
+}
+type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
+interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
   /**
-   * Set the string value of a key.
-   *
-   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-   * @param key The key of the value to set.
-   * @param value The value to set.
-   * @param ttl The time-to-live of the key, in milliseconds.
-   *
-   * @return The value of the key.
+   * HTTP method used for this request.
    */
-  abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
+  method: RouteMethod;
   /**
-   * Remove the specified keys.
-   *
-   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-   * @param keys The keys to delete.
+   * Full request URL.
    */
-  abstract del(name: string, ...keys: string[]): Promise<void>;
-  abstract has(name: string, key: string): Promise<boolean>;
-  abstract keys(name: string, filter?: string): Promise<string[]>;
+  url: URL;
   /**
-   * Remove all keys from all cache names.
+   * Unique request ID assigned to this request.
    */
-  abstract clear(): Promise<void>;
-}
-//#endregion
-//#region ../alepha/src/cache/descriptors/$cache.d.ts
-interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]> {
+  requestId: string;
   /**
-   * The cache name. This is useful for invalidating multiple caches at once.
-   *
-   * Store key as `cache:$name:$key`.
-   *
-   * @default Name of the key of the class.
+   * Client IP address.
+   * Will parse `X-Forwarded-For` header if present.
    */
-  name?: string;
+  ip?: string;
   /**
-   * Function which returns cached data.
+   * Value of the `Host` header sent by the client.
    */
-  handler?: (...args: TParameter) => TReturn;
+  host?: string;
   /**
-   * The key generator for the cache.
-   * If not provided, the arguments will be json.stringify().
+   * Browser user agent information.
+   * Information are not guaranteed to be accurate. Use with caution.
+   *
+   * @see {@link UserAgentParser}
    */
-  key?: (...args: TParameter) => string;
+  userAgent: UserAgentInfo;
   /**
-   * The store provider for the cache.
-   * If not provided, the default store provider will be used.
+   * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
    */
-  provider?: InstantiableClass<CacheProvider> | "memory";
+  metadata: Record<string, any>;
   /**
-   * The time-to-live for the cache in seconds.
-   * Set 0 to skip expiration.
-   *
-   * @default 300 (5 minutes).
+   * Reply object to be used to send response.
    */
-  ttl?: DurationLike;
+  reply: ServerReply;
   /**
-   * If the cache is disabled.
+   * The raw underlying request object (Web Request).
    */
-  disabled?: boolean;
-}
-declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn, TParameter>> {
-  protected readonly env: {
-    CACHE_ENABLED: boolean;
-    CACHE_DEFAULT_TTL: number;
-  };
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly provider: CacheProvider;
-  protected encoder: TextEncoder;
-  protected decoder: TextDecoder;
-  protected codes: {
-    BINARY: number;
-    JSON: number;
-    STRING: number;
-  };
-  get container(): string;
-  run(...args: TParameter): Promise<TReturn>;
-  key(...args: TParameter): string;
-  invalidate(...keys: string[]): Promise<void>;
-  set(key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
-  get(key: string): Promise<TReturn | undefined>;
-  protected serialize<TReturn>(value: TReturn): Uint8Array;
-  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
-  protected $provider(): CacheProvider;
+  raw: ServerRawRequest;
 }
-interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
+interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
   /**
-   * Run the cache descriptor with the provided arguments.
+   * Handler function for this route.
    */
-  (...args: TParameter): Promise<TReturn>;
-}
-//#endregion
-//#region ../alepha/src/server/services/HttpClient.d.ts
-declare class HttpClient {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  readonly cache: CacheDescriptorFn<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>>>;
-  protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
-  protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
-  protected responseData(response: Response, options: FetchOptions): Promise<any>;
-  protected isMaybeFile(response: Response): boolean;
-  protected createFileLike(response: Response, defaultFileName?: string): FileLike;
-  pathVariables(url: string, action: {
-    schema?: {
-      params?: TObject;
-    };
-  }, args?: ServerRequestConfigEntry): string;
-  queryParams(url: string, action: {
-    schema?: {
-      query?: TObject;
-    };
-  }, args?: ServerRequestConfigEntry): string;
-}
-interface FetchOptions<T$1 extends TSchema = TSchema> {
+  handler: ServerHandler<TConfig>;
   /**
-   * Key to identify the request in the pending requests.
+   * HTTP method for this route.
    */
-  key?: string;
+  method?: RouteMethod;
   /**
-   * The schema to validate the response against.
+   * Request/response schema for this route.
+   *
+   * Request schema contains:
+   * - body, for POST/PUT/PATCH requests
+   * - params, for URL parameters (e.g. /user/:id)
+   * - query, for URL query parameters (e.g. /user?id=123)
+   * - headers, for HTTP headers
+   *
+   * Response schema contains:
+   * - response
+   *
+   * Response schema is used to validate and serialize the response sent by the handler.
    */
-  schema?: {
-    response?: T$1;
-  };
+  schema?: TConfig;
   /**
-   * Built-in cache options.
+   * @see ServerLoggerProvider
    */
-  localCache?: boolean | number | DurationLike;
+  silent?: boolean;
 }
-type RequestInitWithOptions<T$1 extends TSchema = TSchema> = RequestInit & FetchOptions<T$1>;
-interface FetchResponse<T$1 = any> {
-  data: T$1;
+type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
+type ResponseKind = "json" | "text" | "void" | "file" | "any";
+type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
+type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+interface ServerResponse$1 {
+  body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
+  headers: Record<string, string>;
   status: number;
-  statusText: string;
-  headers: Headers;
-  raw?: Response;
 }
-type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
-interface HttpClientCache {
-  data: any;
-  etag?: string;
+type ServerRouteRequestHandler = (request: ServerRequestData) => Promise<ServerResponse$1>;
+interface ServerRouteMatcher extends Route {
+  handler: ServerRouteRequestHandler;
 }
-interface FetchActionArgs {
-  action: HttpAction;
-  host?: string;
-  config?: ServerRequestConfigEntry;
-  options?: ClientRequestOptions;
+interface ServerRequestData {
+  method: RouteMethod;
+  url: URL;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  params: Record<string, string>;
+  raw: ServerRawRequest;
 }
-interface HttpAction {
-  method?: string;
-  prefix?: string;
-  path: string;
-  requestBodyType?: string;
-  schema?: {
-    params?: TObject;
-    query?: TObject;
-    body?: TRequestBody;
-    response?: TResponseBody;
-  };
+interface ServerRawRequest {
+  node?: NodeRequestEvent;
+  web?: WebRequestEvent;
+}
+interface NodeRequestEvent {
+  req: IncomingMessage;
+  res: ServerResponse;
+}
+interface WebRequestEvent {
+  req: Request;
+  res?: Response;
 }
 //#endregion
-//#region ../alepha/src/server/descriptors/$action.d.ts
-interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
-  /**
-   * Name of the action.
-   *
-   * - It will be used to generate the route path if `path` is not provided.
-   * - It will be used to generate the permission name if `security` is enabled.
-   */
-  name?: string;
-  /**
-   * Group actions together.
-   *
-   * - If not provided, the service name containing the route will be used.
-   * - It will be used as Tag for documentation purposes.
-   * - It will be used for permission name generation if `security` is enabled.
-   *
-   * @example
-   * ```ts
-   * // group = "MyController"
-   * class MyController {
-   * 	hello = $action({ handler: () => "Hello World" });
-   * }
-   *
-   * // group = "users"
-   * class MyOtherController {
-   *   group = "users";
-   *   a1 = $action({ handler: () => "Action 1", group: this.group });
-   *   a2 = $action({ handler: () => "Action 2", group: this.group });
-   * }
-   * ```
-   */
-  group?: string;
+//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
+declare const logEntrySchema: alepha30.TObject<{
+  level: alepha30.TUnsafe<"TRACE" | "SILENT" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+  message: alepha30.TString;
+  service: alepha30.TString;
+  module: alepha30.TString;
+  context: alepha30.TOptional<alepha30.TString>;
+  app: alepha30.TOptional<alepha30.TString>;
+  data: alepha30.TOptional<alepha30.TAny>;
+  timestamp: alepha30.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: alepha30.HookPrimitive<"start">;
+  protected readonly onStop: alepha30.HookPrimitive<"stop">;
+  setLocale(locale: string): void;
+  isDateTime(value: unknown): value is DateTime;
   /**
-   * Pathname of the route. If not provided, property key is used.
+   * Create a new UTC DateTime instance.
    */
-  path?: string;
+  utc(date: string | number | Date | Dayjs | null | undefined): DateTime;
   /**
-   * The route method.
-   *
-   * - If not provided, it will be set to "GET" by default.
-   * - If not provider and a body is provided, it will be set to "POST".
-   *
-   * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
+   * Create a new DateTime instance.
    */
-  method?: RouteMethod;
+  of(date: string | number | Date | Dayjs | null | undefined): DateTime;
   /**
-   * The config schema of the route.
-   * - body: The request body schema.
-   * - params: Path variables schema.
-   * - query: The request query-params schema.
-   * - response: The response schema.
+   * Get the current date as a string.
    */
-  schema?: TConfig;
+  toISOString(date?: Date | string | DateTime): string;
   /**
-   * A short description of the action. Used for documentation purposes.
+   * Get the current date.
    */
-  description?: string;
+  now(): DateTime;
   /**
-   * Disable the route. Useful with env variables do disable one specific route.
-   * Route won't be available in the API but can still be called locally!
+   * Get the current date as a string.
+   *
+   * This is much faster than `DateTimeProvider.now().toISOString()` as it avoids creating a DateTime instance.
    */
-  disabled?: boolean;
+  nowISOString(): string;
   /**
-   * Main route handler. This is where the route logic is implemented.
+   * Get the current date as milliseconds since epoch.
+   *
+   * This is much faster than `DateTimeProvider.now().valueOf()` as it avoids creating a DateTime instance.
    */
-  handler: ServerActionHandler<TConfig>;
-}
-declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
-  protected readonly log: Logger;
-  protected readonly env: {
-    SERVER_API_PREFIX: string;
-  };
-  protected readonly httpClient: HttpClient;
-  protected readonly serverProvider: ServerProvider;
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  protected onInit(): void;
-  get prefix(): string;
-  get route(): ServerRoute;
+  nowMillis(): number;
   /**
-   * Returns the name of the action.
+   * Get the current date as a string.
+   *
+   * @protected
    */
-  get name(): string;
+  protected getCurrentDate(): DateTime;
   /**
-   * Returns the group of the action. (e.g. "orders", "admin", etc.)
+   * Create a new Duration instance.
    */
-  get group(): string;
+  duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
+  isDurationLike(value: unknown): value is DurationLike;
   /**
-   * Returns the HTTP method of the action.
+   * Return a promise that resolves after the next tick.
+   * It uses `setTimeout` with 0 ms delay.
    */
-  get method(): RouteMethod;
+  tick(): Promise<void>;
   /**
-   * Returns the path of the action.
+   * Wait for a certain duration.
    *
-   * Path is prefixed by `/api` by default.
-   */
-  get path(): string;
-  get schema(): TConfig | undefined;
-  getBodyContentType(): string | undefined;
-  /**
-   * Call the action handler directly.
-   * There is no HTTP layer involved.
+   * You can clear the timeout by using the `AbortSignal` API.
+   * Aborted signal will resolve the promise immediately, it does not reject it.
    */
-  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  wait(duration: DurationLike, options?: {
+    signal?: AbortSignal;
+    now?: number;
+  }): Promise<void>;
+  createInterval(run: () => unknown, duration: DurationLike, start?: boolean): Interval;
   /**
-   * Works like `run`, but always fetches (http request) the route.
+   * Run a callback after a certain duration.
    */
-  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
-}
-type ClientRequestEntry<TConfig extends RequestConfigSchema, T$1 = ClientRequestEntryContainer<TConfig>> = { [K in keyof T$1 as T$1[K] extends undefined ? never : K]: T$1[K] };
-type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
-  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
-  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
-  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
-  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
-};
-interface ClientRequestOptions extends FetchOptions {
+  createTimeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
+  clearTimeout(timeout: Timeout): void;
+  clearInterval(interval: Interval): void;
   /**
-   * Standard request fetch options.
-   */
-  request?: RequestInit;
-}
-type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
-/**
- * Specific handler for server actions.
- */
-type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
-/**
- * Server Action Request Interface
- *
- * Can be extended with module augmentation to add custom properties (like `user` in Server Security).
- *
- * This is NOT Server Request, but a specific type for actions.
- */
-interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
-//#endregion
-//#region ../alepha/src/server/schemas/errorSchema.d.ts
-declare const errorSchema: alepha84.TObject<{
-  error: alepha84.TString;
-  status: alepha84.TInteger;
-  message: alepha84.TString;
-  details: alepha84.TOptional<alepha84.TString>;
-  requestId: alepha84.TOptional<alepha84.TString>;
-  cause: alepha84.TOptional<alepha84.TObject<{
-    name: alepha84.TString;
-    message: alepha84.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);
+   * Run a function with a deadline.
+   */
+  deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
+  /**
+   * 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 HttpErrorLike extends Error {
-  status: number;
+interface Interval {
+  timer?: any;
+  duration: number;
+  run: () => unknown;
+}
+interface Timeout {
+  now: number;
+  timer?: any;
+  duration: number;
+  callback: () => void;
+  clear: () => void;
 }
 //#endregion
-//#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
-declare const envSchema$5: alepha84.TObject<{
-  SERVER_PORT: alepha84.TInteger;
-  SERVER_HOST: alepha84.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$5>> {}
+//#region ../alepha/src/logger/providers/LogDestinationProvider.d.ts
+declare abstract class LogDestinationProvider {
+  abstract write(message: string, entry: LogEntry): void;
 }
 //#endregion
-//#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema$4: alepha84.TObject<{
-  SERVER_PORT: alepha84.TInteger;
-  SERVER_HOST: alepha84.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$4>> {}
+//#region ../alepha/src/logger/providers/LogFormatterProvider.d.ts
+declare abstract class LogFormatterProvider {
+  abstract format(entry: LogEntry): string;
 }
 //#endregion
-//#region ../alepha/src/server/index.d.ts
+//#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$2: alepha30.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: alepha30.TOptional<alepha30.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: alepha30.TOptional<alepha30.TUnsafe<"json" | "pretty" | "raw">>;
+}>;
 declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$2>> {}
   interface State {
-    "alepha.node.server"?: Server;
+    /**
+     * Current log level for the application or specific modules.
+     */
+    "alepha.logger.level"?: string;
   }
   interface Hooks {
-    "action:onRequest": {
-      action: ActionDescriptor<RequestConfigSchema>;
-      request: ServerRequest;
-      options: ClientRequestOptions;
-    };
-    "action:onResponse": {
-      action: ActionDescriptor<RequestConfigSchema>;
-      request: ServerRequest;
-      options: ClientRequestOptions;
-      response: any;
-    };
-    "server:onRequest": {
-      route: ServerRoute;
-      request: ServerRequest;
-    };
-    "server:onError": {
-      route: ServerRoute;
-      request: ServerRequest;
-      error: Error;
-    };
-    "server:onSend": {
-      route: ServerRoute;
-      request: ServerRequest;
-    };
-    "server:onResponse": {
-      route: ServerRoute;
-      request: ServerRequest;
-      response: ServerResponse$1;
-    };
-    "client:onRequest": {
-      route: HttpAction;
-      config: ServerRequestConfigEntry;
-      options: ClientRequestOptions;
-      headers: Record<string, string>;
-      request: RequestInit;
-    };
-    "client:beforeFetch": {
-      url: string;
-      options: FetchOptions;
-      request: RequestInit;
-    };
-    "client:onError": {
-      route?: HttpAction;
-      error: HttpError;
+    log: {
+      message?: string;
+      entry: LogEntry;
     };
-    "node:request": NodeRequestEvent;
-    "web:request": WebRequestEvent;
   }
 }
 //#endregion
-//#region ../alepha/src/server-cache/providers/ServerCacheProvider.d.ts
-declare module "alepha/server" {
-  interface ServerRoute {
-    /**
-     * Enable caching for this route.
-     * - If true: enables both store and etag
-     * - If object: fine-grained control over store, etag, and cache-control headers
-     *
-     * @default false
-     */
-    cache?: ServerRouteCache;
-  }
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
-    invalidate: () => Promise<void>;
-  }
+//#region ../alepha/src/server/services/ServerRequestParser.d.ts
+declare class ServerRequestParser {
+  protected readonly alepha: Alepha;
+  protected readonly userAgentParser: UserAgentParser;
+  createServerRequest(rawRequest: ServerRequestData): ServerRequest;
+  getRequestId(request: ServerRequestData): string | undefined;
+  getRequestUserAgent(request: ServerRequestData): UserAgentInfo;
+  getRequestIp(request: ServerRequestData): string | undefined;
 }
-type ServerRouteCache =
-/**
- * If true, enables caching with:
- * - store: true
- * - etag: true
- */
-boolean
+//#endregion
+//#region ../alepha/src/server/providers/ServerTimingProvider.d.ts
+type TimingMap = Record<string, [number, number]>;
+declare class ServerTimingProvider {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  options: {
+    prefix: string;
+    disabled: boolean;
+  };
+  readonly onRequest: alepha30.HookPrimitive<"server:onRequest">;
+  readonly onResponse: alepha30.HookPrimitive<"server:onResponse">;
+  protected get handlerName(): string;
+  beginTiming(name: string): void;
+  endTiming(name: string): void;
+  protected setDuration(name: string, timing: TimingMap): void;
+}
+//#endregion
+//#region ../alepha/src/server/providers/ServerRouterProvider.d.ts
 /**
- * Object configuration for fine-grained cache control.
+ * Main router for all routes on the server side.
  *
- * If empty, no caching will be applied.
- */ | {
+ * - $route => generic route
+ * - $action => action route (for API calls)
+ * - $page => React route (for SSR)
+ */
+declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly routes: ServerRoute[];
+  protected readonly serverTimingProvider: ServerTimingProvider;
+  protected readonly serverRequestParser: ServerRequestParser;
   /**
-   * 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.
+   * Get all registered routes, optionally filtered by a pattern.
    *
-   * @default false
-   */
-  store?: true | DurationLike | CacheDescriptorOptions;
-  /**
-   * If true, enables ETag support for the cached responses.
-   */
-  etag?: true;
-  /**
-   * - If true, sets Cache-Control to "public, max-age=300" (5 minutes).
-   * - If string, sets Cache-Control to the provided value directly.
-   * - If object, configures Cache-Control directives.
+   * Pattern accept simple wildcard '*' at the end.
+   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
    */
-  control?: true
-  /**
-   * If string, sets Cache-Control to the provided value directly.
-   */ | string
-  /**
-   * If object, configures Cache-Control directives.
-   */ | {
-    /**
-     * Indicates that the response may be cached by any cache.
-     */
-    public?: boolean;
-    /**
-     * Indicates that the response is intended for a single user and must not be stored by a shared cache.
-     */
-    private?: boolean;
-    /**
-     * Forces caches to submit the request to the origin server for validation before releasing a cached copy.
-     */
-    noCache?: boolean;
-    /**
-     * Instructs caches not to store the response.
-     */
-    noStore?: boolean;
-    /**
-     * Maximum amount of time a resource is considered fresh.
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     *
-     * @example 300 // 5 minutes in seconds
-     * @example { minutes: 5 } // 5 minutes
-     * @example { hours: 1 } // 1 hour
-     */
-    maxAge?: number | DurationLike;
-    /**
-     * Overrides max-age for shared caches (e.g., CDNs).
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     */
-    sMaxAge?: number | DurationLike;
-    /**
-     * Indicates that once a resource becomes stale, caches must not use it without successful validation.
-     */
-    mustRevalidate?: boolean;
-    /**
-     * Similar to must-revalidate, but only for shared caches.
-     */
-    proxyRevalidate?: boolean;
-    /**
-     * Indicates that the response can be stored but must be revalidated before each use.
-     */
-    immutable?: boolean;
-  };
-};
-//#endregion
-//#region src/core/components/ClientOnly.d.ts
-interface ClientOnlyProps {
-  fallback?: ReactNode;
-  disabled?: boolean;
+  getRoutes(pattern?: string): ServerRoute[];
+  createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
+  protected getContextId(headers: Record<string, string>): string;
+  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
+    status: number;
+    headers: Record<string, string> & {
+      "set-cookie"?: string[];
+    };
+    body: any;
+  }>;
+  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
+  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
+  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
+  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
+  validateRequest(route: {
+    schema?: RequestConfigSchema;
+  }, request: ServerRequestConfig): void;
 }
 //#endregion
-//#region src/core/errors/Redirection.d.ts
+//#region ../alepha/src/server/providers/ServerProvider.d.ts
 /**
- * Used for Redirection during the page loading.
+ * Base server provider to handle incoming requests and route them.
  *
- * Depends on the context, it can be thrown or just returned.
+ * This is the default implementation for serverless environments.
+ *
+ * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
  */
-declare class Redirection extends Error {
-  readonly redirect: string;
-  constructor(redirect: string);
-}
-//#endregion
-//#region src/core/providers/ReactPageProvider.d.ts
-declare const envSchema$3: alepha84.TObject<{
-  REACT_STRICT_MODE: alepha84.TBoolean;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$3>> {}
-}
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
-  children?: PageRouteEntry[];
-}
-interface PageRoute extends PageRouteEntry {
-  type: "page";
-  name: string;
-  parent?: PageRoute;
-  match: string;
-}
-interface Layer {
-  config?: {
-    query?: Record<string, any>;
-    params?: Record<string, any>;
-    context?: Record<string, any>;
-  };
-  name: string;
-  props?: Record<string, any>;
-  error?: Error;
-  part?: string;
-  element: ReactNode;
-  index: number;
-  path: string;
-  route?: PageRoute;
-  cache?: boolean;
-}
-type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
-interface ReactRouterState {
-  /**
-   * Stack of layers for the current page.
-   */
-  layers: Array<Layer>;
+declare class ServerProvider {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly router: ServerRouterProvider;
+  protected readonly internalServerErrorMessage = "Internal Server Error";
+  get hostname(): string;
   /**
-   * URL of the current page.
+   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
    */
-  url: URL;
+  protected readonly onNodeRequest: alepha30.HookPrimitive<"node:request">;
   /**
-   * Error handler for the current page.
+   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
    */
-  onError: ErrorHandler;
+  protected readonly onWebRequest: alepha30.HookPrimitive<"web:request">;
   /**
-   * Params extracted from the URL for the current page.
+   * Handle Node.js HTTP request event.
+   *
+   * Technically, we just convert Node.js request to Web Standard Request.
    */
-  params: Record<string, any>;
+  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
   /**
-   * Query parameters extracted from the URL for the current page.
+   * Handle Web (Fetch API) request event.
    */
-  query: Record<string, string>;
+  handleWebRequest(ev: WebRequestEvent): Promise<void>;
   /**
-   * Optional meta information associated with the current page.
+   * Helper for Vite development mode to let Vite handle (or not) 404.
    */
-  meta: Record<string, any>;
-}
-//#endregion
-//#region src/core/services/ReactPageService.d.ts
-declare class ReactPageService {
-  fetch(pathname: string, options?: PageDescriptorRenderOptions): Promise<{
-    html: string;
-    response: Response;
-  }>;
-  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
 }
 //#endregion
-//#region src/core/descriptors/$page.d.ts
-interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+//#region ../alepha/src/cache/providers/CacheProvider.d.ts
+/**
+ * Cache provider interface.
+ *
+ * All methods are asynchronous and return promises.
+ * Values are stored as Uint8Array.
+ */
+declare abstract class CacheProvider {
   /**
-   * Identifier name for the page. Must be unique.
+   * Get the value of a key.
    *
-   * @default Descriptor key
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to get.
+   *
+   * @return The value of the key, or undefined if the key does not exist.
    */
-  name?: string;
+  abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
   /**
-   * Add a pathname to the page.
+   * Set the string value of a key.
    *
-   * Pathname can contain parameters, like `/post/:slug`.
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to set.
+   * @param value The value to set.
+   * @param ttl The time-to-live of the key, in milliseconds.
    *
-   * @default ""
+   * @return The value of the key.
    */
-  path?: string;
+  abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
   /**
-   * Add an input schema to define:
-   * - `params`: parameters from the pathname.
-   * - `query`: query parameters from the URL.
+   * Remove the specified keys.
+   *
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param keys The keys to delete.
    */
-  schema?: TConfig;
+  abstract del(name: string, ...keys: string[]): Promise<void>;
+  abstract has(name: string, key: string): Promise<boolean>;
+  abstract keys(name: string, filter?: string): Promise<string[]>;
   /**
-   * Load data before rendering the page.
-   *
-   * This function receives
-   * - the request context and
-   * - the parent props (if page has a parent)
-   *
-   * In SSR, the returned data will be serialized and sent to the client, then reused during the client-side hydration.
+   * Remove all keys from all cache names.
+   */
+  abstract clear(): Promise<void>;
+}
+//#endregion
+//#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.
    *
-   * Resolve can be stopped by throwing an error, which will be handled by the `errorHandler` function.
-   * It's common to throw a `NotFoundError` to display a 404 page.
+   * Store key as `cache:$name:$key`.
    *
-   * RedirectError can be thrown to redirect the user to another page.
+   * @default Name of the key of the class.
    */
-  resolve?: (context: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
+  name?: string;
   /**
-   * The component to render when the page is loaded.
-   *
-   * If `lazy` is defined, this will be ignored.
-   * Prefer using `lazy` to improve the initial loading time.
+   * Function which returns cached data.
    */
-  component?: FC<TProps & TPropsParent>;
+  handler?: (...args: TParameter) => TReturn;
+  /**
+   * The key generator for the cache.
+   * If not provided, the arguments will be json.stringify().
+   */
+  key?: (...args: TParameter) => string;
+  /**
+   * The store provider for the cache.
+   * If not provided, the default store provider will be used.
+   */
+  provider?: InstantiableClass<CacheProvider> | "memory";
   /**
-   * Lazy load the component when the page is loaded.
+   * The time-to-live for the cache in seconds.
+   * Set 0 to skip expiration.
    *
-   * It's recommended to use this for components to improve the initial loading time
-   * and enable code-splitting.
+   * @default 300 (5 minutes).
    */
-  lazy?: () => Promise<{
-    default: FC<TProps & TPropsParent>;
-  }>;
+  ttl?: DurationLike;
+  /**
+   * If the cache is disabled.
+   */
+  disabled?: boolean;
+}
+declare class CachePrimitive<TReturn = any, TParameter extends any[] = any[]> extends Primitive<CachePrimitiveOptions<TReturn, TParameter>> {
+  protected readonly env: {
+    CACHE_ENABLED: boolean;
+    CACHE_DEFAULT_TTL: number;
+  };
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly provider: CacheProvider;
+  protected encoder: TextEncoder;
+  protected decoder: TextDecoder;
+  protected codes: {
+    BINARY: number;
+    JSON: number;
+    STRING: number;
+  };
+  get container(): string;
+  run(...args: TParameter): Promise<TReturn>;
+  key(...args: TParameter): string;
+  invalidate(...keys: string[]): Promise<void>;
+  set(key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
+  get(key: string): Promise<TReturn | undefined>;
+  protected serialize<TReturn>(value: TReturn): Uint8Array;
+  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
+  protected $provider(): CacheProvider;
+}
+interface CachePrimitiveFn<TReturn = any, TParameter extends any[] = any[]> extends CachePrimitive<TReturn, TParameter> {
+  /**
+   * Run the cache primitive with the provided arguments.
+   */
+  (...args: TParameter): Promise<TReturn>;
+}
+//#endregion
+//#region ../alepha/src/server/services/HttpClient.d.ts
+declare class HttpClient {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  readonly cache: CachePrimitiveFn<HttpClientCache, any[]>;
+  protected readonly pendingRequests: HttpClientPendingRequests;
+  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
+  fetch<T extends TSchema>(url: string, request?: RequestInitWithOptions<T>): Promise<FetchResponse<Static<T>>>;
+  protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
+  protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
+  protected responseData(response: Response, options: FetchOptions): Promise<any>;
+  protected isMaybeFile(response: Response): boolean;
+  protected createFileLike(response: Response, defaultFileName?: string): FileLike;
+  pathVariables(url: string, action: {
+    schema?: {
+      params?: TObject;
+    };
+  }, args?: ServerRequestConfigEntry): string;
+  queryParams(url: string, action: {
+    schema?: {
+      query?: TObject;
+    };
+  }, args?: ServerRequestConfigEntry): string;
+}
+interface FetchOptions<T extends TSchema = TSchema> {
+  /**
+   * Key to identify the request in the pending requests.
+   */
+  key?: string;
   /**
-   * Attach child pages to create nested routes.
-   * This will make the page a parent route.
+   * The schema to validate the response against.
    */
-  children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
+  schema?: {
+    response?: T;
+  };
   /**
-   * Define a parent page for nested routing.
+   * Built-in cache options.
    */
-  parent?: PageDescriptor<PageConfigSchema, TPropsParent, any>;
-  can?: () => boolean;
+  localCache?: boolean | number | DurationLike;
+}
+type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
+interface FetchResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  raw?: Response;
+}
+type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
+interface HttpClientCache {
+  data: any;
+  etag?: string;
+}
+interface FetchActionArgs {
+  action: HttpAction;
+  host?: string;
+  config?: ServerRequestConfigEntry;
+  options?: ClientRequestOptions;
+}
+interface HttpAction {
+  method?: string;
+  prefix?: string;
+  path: string;
+  requestBodyType?: string;
+  schema?: {
+    params?: TObject;
+    query?: TObject;
+    body?: TRequestBody;
+    response?: TResponseBody;
+  };
+}
+//#endregion
+//#region ../alepha/src/server/primitives/$action.d.ts
+interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
-   * Catch any error from the `resolve` function or during `rendering`.
+   * Name of the action.
    *
-   * Expected to return one of the following:
-   * - a ReactNode to render an error page
-   * - a Redirection to redirect the user
-   * - undefined to let the error propagate
+   * - It will be used to generate the route path if `path` is not provided.
+   * - It will be used to generate the permission name if `security` is enabled.
+   */
+  name?: string;
+  /**
+   * Group actions together.
    *
-   * If not defined, the error will be thrown and handled by the server or client error handler.
-   * If a leaf $page does not define an error handler, the error can be caught by parent pages.
+   * - If not provided, the service name containing the route will be used.
+   * - It will be used as Tag for documentation purposes.
+   * - It will be used for permission name generation if `security` is enabled.
    *
-   * @example Catch a 404 from API and render a custom not found component:
+   * @example
    * ```ts
-   * resolve: async ({ params, query }) => {
-   *    api.fetch("/api/resource", { params, query });
-   * },
-   * errorHandler: (error, context) => {
-   *   if (HttpError.is(error, 404)) {
-   *     return <ResourceNotFound />;
-   *   }
+   * // group = "MyController"
+   * class MyController {
+   * 	hello = $action({ handler: () => "Hello World" });
    * }
-   * ```
    *
-   * @example Catch an 401 error and redirect the user to the login page:
-   * ```ts
-   * resolve: async ({ params, query }) => {
-   *   // but the user is not authenticated
-   *   api.fetch("/api/resource", { params, query });
-   * },
-   * errorHandler: (error, context) => {
-   *   if (HttpError.is(error, 401)) {
-   *     // throwing a Redirection is also valid!
-   *     return new Redirection("/login");
-   *   }
+   * // group = "users"
+   * class MyOtherController {
+   *   group = "users";
+   *   a1 = $action({ handler: () => "Action 1", group: this.group });
+   *   a2 = $action({ handler: () => "Action 2", group: this.group });
    * }
    * ```
    */
-  errorHandler?: ErrorHandler;
+  group?: string;
+  /**
+   * Pathname of the route. If not provided, property key is used.
+   */
+  path?: string;
   /**
-   * If true, the page will be considered as a static page, immutable and cacheable.
-   * Replace boolean by an object to define static entries. (e.g. list of params/query)
+   * The route method.
    *
-   * Browser-side: it only works with `alepha/vite`, which can pre-render the page at build time.
+   * - If not provided, it will be set to "GET" by default.
+   * - If not provider and a body is provided, it will be set to "POST".
    *
-   * Server-side: It will act as timeless cached page. You can use `cache` to configure the cache behavior.
+   * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
    */
-  static?: boolean | {
-    entries?: Array<Partial<PageRequestConfig<TConfig>>>;
-  };
-  cache?: ServerRouteCache;
+  method?: RouteMethod;
   /**
-   * If true, force the page to be rendered only on the client-side (browser).
-   * It uses the `<ClientOnly/>` component to render the page.
+   * The config schema of the route.
+   * - body: The request body schema.
+   * - params: Path variables schema.
+   * - query: The request query-params schema.
+   * - response: The response schema.
    */
-  client?: boolean | ClientOnlyProps;
+  schema?: TConfig;
   /**
-   * Called before the server response is sent to the client. (server only)
+   * A short description of the action. Used for documentation purposes.
    */
-  onServerResponse?: (request: ServerRequest) => unknown;
+  description?: string;
   /**
-   * Called when user leaves the page. (browser only)
+   * Disable the route. Useful with env variables do disable one specific route.
+   * Route won't be available in the API but can still be called locally!
    */
-  onLeave?: () => void;
+  disabled?: boolean;
   /**
-   * @experimental
-   *
-   * Add a css animation when the page is loaded or unloaded.
-   * It uses CSS animations, so you need to define the keyframes in your CSS.
-   *
-   * @example Simple animation name
-   * ```ts
-   * animation: "fadeIn"
-   * ```
-   *
-   * CSS example:
-   * ```css
-   * @keyframes fadeIn {
-   *  from { opacity: 0; }
-   *  to { opacity: 1; }
-   * }
-   * ```
-   *
-   * @example Detailed animation
-   * ```ts
-   * animation: {
-   *   enter: { name: "fadeIn", duration: 300 },
-   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
-   * }
-   * ```
-   *
-   * @example Only exit animation
-   * ```ts
-   * animation: {
-   *   exit: "fadeOut"
-   * }
-   * ```
-   *
-   * @example With custom timing function
-   * ```ts
-   * animation: {
-   *   enter: { name: "fadeIn", duration: 300, timing: "cubic-bezier(0.4, 0, 0.2, 1)" },
-   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
-   * }
-   * ```
+   * Main route handler. This is where the route logic is implemented.
    */
-  animation?: PageAnimation;
+  handler: ServerActionHandler<TConfig>;
 }
-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>> {
-  protected readonly reactPageService: ReactPageService;
+declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primitive<ActionPrimitiveOptions<TConfig>> {
+  protected readonly log: Logger;
+  protected readonly env: {
+    SERVER_API_PREFIX: string;
+  };
+  protected readonly httpClient: HttpClient;
+  protected readonly serverProvider: ServerProvider;
+  protected readonly serverRouterProvider: ServerRouterProvider;
   protected onInit(): void;
-  get name(): string;
+  get prefix(): string;
+  get route(): ServerRoute;
   /**
-   * For testing or build purposes.
-   *
-   * 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.
+   * Returns the name of the action.
    */
-  render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
-  fetch(options?: PageDescriptorRenderOptions): Promise<{
-    html: string;
-    response: Response;
-  }>;
-  match(url: string): boolean;
-  pathname(config: any): string;
-}
-interface PageConfigSchema {
-  query?: TSchema;
-  params?: TSchema;
-}
-type TPropsDefault = any;
-type TPropsParentDefault = {};
-interface PageDescriptorRenderOptions {
-  params?: Record<string, string>;
-  query?: Record<string, string>;
+  get name(): string;
+  /**
+   * Returns the group of the action. (e.g. "orders", "admin", etc.)
+   */
+  get group(): string;
   /**
-   * If true, the HTML layout will be included in the response.
-   * If false, only the page content will be returned.
-   *
-   * @default true
+   * Returns the HTTP method of the action.
    */
-  html?: boolean;
-  hydration?: boolean;
-}
-interface PageDescriptorRenderResult {
-  html: string;
-  state: ReactRouterState;
-  redirect?: string;
-}
-interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
-  params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : Record<string, string>;
-  query: TConfig["query"] extends TSchema ? Static<TConfig["query"]> : Record<string, string>;
-}
-type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & Omit<ReactRouterState, "layers" | "onError">;
-type PageAnimation = PageAnimationObject | ((state: ReactRouterState) => PageAnimationObject | undefined);
-type PageAnimationObject = CssAnimationName | {
-  enter?: CssAnimation | CssAnimationName;
-  exit?: CssAnimation | CssAnimationName;
-};
-type CssAnimationName = string;
-type CssAnimation = {
-  name: string;
-  duration?: number;
-  timing?: string;
-};
-//#endregion
-//#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
-declare const userAccountInfoSchema: alepha84.TObject<{
-  id: alepha84.TString;
-  name: alepha84.TOptional<alepha84.TString>;
-  email: alepha84.TOptional<alepha84.TString>;
-  username: alepha84.TOptional<alepha84.TString>;
-  picture: alepha84.TOptional<alepha84.TString>;
-  sessionId: alepha84.TOptional<alepha84.TString>;
-  organizations: alepha84.TOptional<alepha84.TArray<alepha84.TString>>;
-  roles: alepha84.TOptional<alepha84.TArray<alepha84.TString>>;
-}>;
-type UserAccount = Static<typeof userAccountInfoSchema>;
-//#endregion
-//#region ../alepha/src/security/interfaces/UserAccountToken.d.ts
-/**
- * Add contextual metadata to a user account info.
- * E.g. UserAccountToken is a UserAccountInfo during a request.
- */
-interface UserAccountToken extends UserAccount {
+  get method(): RouteMethod;
   /**
-   * Access token for the user.
+   * Returns the path of the action.
+   *
+   * Path is prefixed by `/api` by default.
    */
-  token?: string;
+  get path(): string;
+  get schema(): TConfig | undefined;
+  getBodyContentType(): string | undefined;
   /**
-   * Realm name of the user.
+   * Call the action handler directly.
+   * There is no HTTP layer involved.
    */
-  realm?: string;
+  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
   /**
-   * Is user dedicated to his own resources for this scope ?
-   * Mostly, Admin is false and Customer is true.
+   * Works like `run`, but always fetches (http request) the route.
    */
-  ownership?: string | boolean;
-}
-//#endregion
-//#region ../alepha/src/security/providers/SecurityProvider.d.ts
-declare const envSchema$2: alepha84.TObject<{
-  APP_SECRET: alepha84.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$2>> {}
-}
-//#endregion
-//#region ../alepha/src/security/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    "security:user:created": {
-      realm: string;
-      user: UserAccount;
-    };
-  }
-}
-/**
- * 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`
- * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
- * integration with various authentication providers and user management systems.
- *
- * @see {@link $realm}
- * @see {@link $role}
- * @see {@link $permission}
- * @module alepha.security
- */
-//#endregion
-//#region ../alepha/src/server-security/providers/ServerBasicAuthProvider.d.ts
-interface BasicAuthOptions {
-  username: string;
-  password: string;
+  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
 }
-//#endregion
-//#region ../alepha/src/server-security/providers/ServerSecurityProvider.d.ts
-type ServerRouteSecure = {
-  realm?: string;
-  basic?: BasicAuthOptions;
+type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
+type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
+  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
+  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
+  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
 };
-//#endregion
-//#region ../alepha/src/server-security/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * Real (or fake) user account, used for internal actions.
-     *
-     * If you define this, you assume that all actions are executed by this user by default.
-     * > To force a different user, you need to pass it explicitly in the options.
-     */
-    "alepha.server.security.system.user"?: UserAccountToken;
-    /**
-     * The authenticated user account attached to the server request state.
-     *
-     * @internal
-     */
-    "alepha.server.request.user"?: UserAccount;
-  }
-}
-declare module "alepha/server" {
-  interface ServerRequest<TConfig> {
-    user?: UserAccountToken;
-  }
-  interface ServerActionRequest<TConfig> {
-    user: UserAccountToken;
-  }
-  interface ServerRoute {
-    /**
-     * If true, the route will be protected by the security provider.
-     * All actions are secure by default, but you can disable it for specific actions.
-     */
-    secure?: boolean | ServerRouteSecure;
-  }
-  interface ClientRequestOptions extends FetchOptions {
-    /**
-     * Forward user from the previous request.
-     * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
-     * If "context", use the user from the current context (e.g. request).
-     *
-     * @default "system" if provided, else "context" if available.
-     */
-    user?: UserAccountToken | "system" | "context";
-  }
+interface ClientRequestOptions extends FetchOptions {
+  /**
+   * Standard request fetch options.
+   */
+  request?: RequestInit;
 }
+type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
 /**
- * Plugin for Alepha Server that provides security features. Based on the Alepha Security module.
- *
- * By default, all $action will be guarded by a permission check.
- *
- * @see {@link ServerSecurityProvider}
- * @module alepha.server.security
+ * Specific handler for server actions.
  */
-//#endregion
-//#region ../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinksResponseSchema: alepha84.TObject<{
-  prefix: alepha84.TOptional<alepha84.TString>;
-  links: alepha84.TArray<alepha84.TObject<{
-    name: alepha84.TString;
-    group: alepha84.TOptional<alepha84.TString>;
-    path: alepha84.TString;
-    method: alepha84.TOptional<alepha84.TString>;
-    requestBodyType: alepha84.TOptional<alepha84.TString>;
-    service: alepha84.TOptional<alepha84.TString>;
-  }>>;
-}>;
-type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
-//#endregion
-//#region ../alepha/src/server-links/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * API links attached to the server request state.
-     *
-     * @see {@link ApiLinksResponse}
-     * @internal
-     */
-    "alepha.server.request.apiLinks"?: ApiLinksResponse;
-  }
-}
+type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
 /**
- * Provides server-side link management and remote capabilities for client-server interactions.
+ * Server Action Request Interface
  *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
- * facilitating seamless API endpoint management and client-server communication. It integrates with server
- * security features to ensure safe and controlled access to resources.
+ * Can be extended with module augmentation to add custom properties (like `user` in Server Security).
  *
- * @see {@link $remote}
- * @see {@link $client}
- * @module alepha.server.links
+ * This is NOT Server Request, but a specific type for actions.
  */
+interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
 //#endregion
-//#region src/core/providers/ReactBrowserProvider.d.ts
-declare const envSchema$1: alepha84.TObject<{
-  REACT_ROOT_ID: alepha84.TString;
+//#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
+declare const envSchema$1: alepha30.TObject<{
+  SERVER_PORT: alepha30.TInteger;
+  SERVER_HOST: alepha30.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
-/**
- * React browser renderer configuration atom
- */
-declare const reactBrowserOptions: alepha84.Atom<alepha84.TObject<{
-  scrollRestoration: alepha84.TUnsafe<"top" | "manual">;
-}>, "alepha.react.browser.options">;
-type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [reactBrowserOptions.key]: ReactBrowserRendererOptions;
-  }
-}
-type ReactHydrationState = {
-  layers?: Array<PreviousLayerData>;
-} & {
-  [key: string]: any;
-};
 //#endregion
-//#region src/core/providers/ReactServerProvider.d.ts
-declare const envSchema: alepha84.TObject<{
-  REACT_SSR_ENABLED: alepha84.TOptional<alepha84.TBoolean>;
-  REACT_ROOT_ID: alepha84.TString;
-  REACT_SERVER_TEMPLATE: alepha84.TOptional<alepha84.TString>;
+//#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
+declare const envSchema: alepha30.TObject<{
+  SERVER_PORT: alepha30.TInteger;
+  SERVER_HOST: alepha30.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
-  interface State {
-    "alepha.react.server.ssr"?: boolean;
-  }
-}
-/**
- * React server provider configuration atom
- */
-declare const reactServerOptions: alepha84.Atom<alepha84.TObject<{
-  publicDir: alepha84.TString;
-  staticServer: alepha84.TObject<{
-    disabled: alepha84.TBoolean;
-    path: alepha84.TString;
-  }>;
-}>, "alepha.react.server.options">;
-type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [reactServerOptions.key]: ReactServerProviderOptions;
-  }
 }
 //#endregion
-//#region src/core/index.d.ts
+//#region ../alepha/src/server/index.d.ts
 declare module "alepha" {
   interface State {
-    "alepha.react.router.state"?: ReactRouterState;
+    "alepha.node.server"?: Server;
   }
   interface Hooks {
-    /**
-     * Fires when the React application is starting to be rendered on the server.
-     */
-    "react:server:render:begin": {
-      request?: ServerRequest;
-      state: ReactRouterState;
-    };
-    /**
-     * Fires when the React application has been rendered on the server.
-     */
-    "react:server:render:end": {
-      request?: ServerRequest;
-      state: ReactRouterState;
-      html: string;
-    };
-    /**
-     * Fires when the React application is being rendered on the browser.
-     */
-    "react:browser:render": {
-      root: HTMLElement;
-      element: ReactNode;
-      state: ReactRouterState;
-      hydration?: ReactHydrationState;
+    "action:onRequest": {
+      action: ActionPrimitive<RequestConfigSchema>;
+      request: ServerRequest;
+      options: ClientRequestOptions;
     };
-    /**
-     * Fires when a user action is starting.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:begin": {
-      type: string;
-      id?: string;
+    "action:onResponse": {
+      action: ActionPrimitive<RequestConfigSchema>;
+      request: ServerRequest;
+      options: ClientRequestOptions;
+      response: any;
     };
-    /**
-     * Fires when a user action has succeeded.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:success": {
-      type: string;
-      id?: string;
+    "server:onRequest": {
+      route: ServerRoute;
+      request: ServerRequest;
     };
-    /**
-     * Fires when a user action has failed.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:error": {
-      type: string;
-      id?: string;
+    "server:onError": {
+      route: ServerRoute;
+      request: ServerRequest;
       error: Error;
     };
-    /**
-     * Fires when a user action has completed, regardless of success or failure.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:end": {
-      type: string;
-      id?: string;
+    "server:onSend": {
+      route: ServerRoute;
+      request: ServerRequest;
     };
-    /**
-     * Fires when a route transition is starting.
-     */
-    "react:transition:begin": {
-      previous: ReactRouterState;
-      state: ReactRouterState;
-      animation?: PageAnimation;
+    "server:onResponse": {
+      route: ServerRoute;
+      request: ServerRequest;
+      response: ServerResponse$1;
     };
-    /**
-     * Fires when a route transition has succeeded.
-     */
-    "react:transition:success": {
-      state: ReactRouterState;
+    "client:onRequest": {
+      route: HttpAction;
+      config: ServerRequestConfigEntry;
+      options: ClientRequestOptions;
+      headers: Record<string, string>;
+      request: RequestInit;
     };
-    /**
-     * Fires when a route transition has failed.
-     */
-    "react:transition:error": {
-      state: ReactRouterState;
-      error: Error;
+    "client:beforeFetch": {
+      url: string;
+      options: FetchOptions;
+      request: RequestInit;
     };
-    /**
-     * Fires when a route transition has completed, regardless of success or failure.
-     */
-    "react:transition:end": {
-      state: ReactRouterState;
+    "client:onError": {
+      route?: HttpAction;
+      error: HttpError;
     };
+    "node:request": NodeRequestEvent;
+    "web:request": WebRequestEvent;
   }
 }
-/**
- * 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.
- * 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
- */
-//#endregion
-//#region src/head/interfaces/Head.d.ts
-interface Head extends SimpleHead {
-  description?: string;
-  keywords?: string[];
-  author?: string;
-  robots?: string;
-  themeColor?: string;
-  viewport?: string | {
-    width?: string;
-    height?: string;
-    initialScale?: string;
-    maximumScale?: string;
-    userScalable?: "no" | "yes" | "0" | "1";
-    interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
-  };
-  og?: {
-    title?: string;
-    description?: string;
-    image?: string;
-    url?: string;
-    type?: string;
-  };
-  twitter?: {
-    card?: string;
-    title?: string;
-    description?: string;
-    image?: string;
-    site?: string;
-  };
-}
-interface SimpleHead {
-  title?: string;
-  titleSeparator?: string;
-  htmlAttributes?: Record<string, string>;
-  bodyAttributes?: Record<string, string>;
-  meta?: Array<{
-    name: string;
-    content: string;
-  }>;
-}
-//#endregion
-//#region src/head/providers/HeadProvider.d.ts
-declare class HeadProvider {
-  global?: Head | (() => Head);
-  protected getGlobalHead(): Head | undefined;
-  fillHead(state: ReactRouterState): void;
-  protected fillHeadByPage(page: PageRoute, state: ReactRouterState, props: Record<string, any>): void;
-}
-//#endregion
-//#region src/head/descriptors/$head.d.ts
-/**
- * Set global `<head>` options for the application.
- */
-declare const $head: {
-  (options: HeadDescriptorOptions): HeadDescriptor;
-  [KIND]: typeof HeadDescriptor;
-};
-type HeadDescriptorOptions = Head | (() => Head);
-declare class HeadDescriptor extends Descriptor<HeadDescriptorOptions> {
-  protected readonly provider: HeadProvider;
-  protected onInit(): void;
-}
-//#endregion
-//#region src/head/hooks/useHead.d.ts
-/**
- * ```tsx
- * const App = () => {
- *   const [head, setHead] = useHead({
- *     // will set the document title on the first render
- *     title: "My App",
- *   });
- *
- *   return (
- *     // This will update the document title when the button is clicked
- *     <button onClick={() => setHead({ title: "Change Title" })}>
- *       Change Title {head.title}
- *     </button>
- *   );
- * }
- * ```
- */
-declare const useHead: (options?: UseHeadOptions) => UseHeadReturn;
-type UseHeadOptions = Head | ((previous?: Head) => Head);
-type UseHeadReturn = [Head, (head?: Head | ((previous?: Head) => Head)) => void];
 //#endregion
 //#region src/head/providers/ServerHeadProvider.d.ts
 declare class ServerHeadProvider {
   protected readonly headProvider: HeadProvider;
   protected readonly serverTimingProvider: ServerTimingProvider;
-  protected readonly onServerRenderEnd: alepha84.HookDescriptor<"react:server:render:end">;
+  protected readonly onServerRenderEnd: alepha30.HookPrimitive<"react:server:render:end">;
   renderHead(template: string, head: SimpleHead): string;
   protected mergeAttributes(existing: string, attrs: Record<string, string>): string;
   protected parseAttributes(attrStr: string): Record<string, string>;
@@ -1783,7 +1047,7 @@ declare class ServerHeadProvider {
 //#endregion
 //#region src/head/index.d.ts
 declare module "@alepha/react" {
-  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> {
     head?: Head | ((props: TProps, previous?: Head) => Head);
   }
   interface ReactRouterState {
@@ -1796,7 +1060,7 @@ declare module "@alepha/react" {
  * @see {@link ServerHeadProvider}
  * @module alepha.react.head
  */
-declare const AlephaReactHead: alepha84.Service<alepha84.Module>;
+declare const AlephaReactHead: alepha30.Service<alepha30.Module>;
 //#endregion
-export { $head, AlephaReactHead, Head, HeadDescriptor, HeadDescriptorOptions, ServerHeadProvider, SimpleHead, UseHeadOptions, UseHeadReturn, useHead };
+export { $head, AlephaReactHead, Head, HeadPrimitive, HeadPrimitiveOptions, ServerHeadProvider, SimpleHead, UseHeadOptions, UseHeadReturn, useHead };
 //# sourceMappingURL=index.d.ts.map