@alepha/react 0.12.0 → 0.12.1

package/dist/core/index.d.cts

@@ -1,17 +1,1053 @@
-import * as alepha7 from "alepha";
-import { Alepha, Async, Atom, Descriptor, Hook, Hooks, KIND, Service, State, Static, TAtomObject, TObject, TSchema } from "alepha";
-import { RequestConfigSchema, ServerHandler, ServerProvider, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "alepha/server";
-import * as react0 from "react";
+import * as alepha139 from "alepha";
+import { Alepha, AlephaError, Async, Atom, Descriptor, FileLike, Hook, Hooks, InstantiableClass, KIND, LogLevel, LoggerInterface, Service, State, Static, StreamLike, TArray, TAtomObject, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
+import { 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 * as react1 from "react";
 import React, { AnchorHTMLAttributes, CSSProperties, DependencyList, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
-import { ServerRouteCache } from "alepha/server/cache";
-import * as alepha_logger0 from "alepha/logger";
-import * as typebox0 from "typebox";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import { ClientScope, HttpVirtualClient, LinkProvider, VirtualAction } from "alepha/server/links";
-import { Route, RouterProvider } from "alepha/router";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { ServerStaticProvider } from "alepha/server/static";
 
+//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
+declare const logEntrySchema: alepha139.TObject<{
+  level: alepha139.TUnsafe<"TRACE" | "SILENT" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+  message: alepha139.TString;
+  service: alepha139.TString;
+  module: alepha139.TString;
+  context: alepha139.TOptional<alepha139.TString>;
+  app: alepha139.TOptional<alepha139.TString>;
+  data: alepha139.TOptional<alepha139.TAny>;
+  timestamp: alepha139.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: alepha139.HookDescriptor<"start">;
+  protected readonly onStop: alepha139.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: alepha139.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: alepha139.TOptional<alepha139.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: alepha139.TOptional<alepha139.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>;
+  };
+  param?: {
+    route?: T$1;
+    name: string;
+    children: {
+      [key: string]: Tree<T$1>;
+    };
+  };
+  wildcard?: {
+    route: T$1;
+  };
+}
+//#endregion
+//#region ../alepha/src/server/helpers/ServerReply.d.ts
+/**
+ * Helper for building server replies.
+ */
+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;
+}
+//#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";
+}
+/**
+ * Simple User-Agent parser to detect OS, browser, and device type.
+ * This parser is not exhaustive and may not cover all edge cases.
+ *
+ * Use result for non
+ */
+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> {
+  /**
+   * 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;
+}
+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;
+}
+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: alepha139.HookDescriptor<"server:onRequest">;
+  readonly onResponse: alepha139.HookDescriptor<"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
+/**
+ * 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;
+  /**
+   * Get all registered routes, optionally filtered by a pattern.
+   *
+   * Pattern accept simple wildcard '*' at the end.
+   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact 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[];
+    };
+    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 ../alepha/src/server/providers/ServerProvider.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.
+ */
+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: alepha139.HookDescriptor<"node:request">;
+  /**
+   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
+   */
+  protected readonly onWebRequest: alepha139.HookDescriptor<"web:request">;
+  /**
+   * Handle Node.js HTTP request event.
+   *
+   * Technically, we just convert Node.js request to Web Standard Request.
+   */
+  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
+  /**
+   * Handle Web (Fetch API) request event.
+   */
+  handleWebRequest(ev: WebRequestEvent): Promise<void>;
+  /**
+   * Helper for Vite development mode to let Vite handle (or not) 404.
+   */
+  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
+}
+//#endregion
+//#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 {
+  /**
+   * 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>;
+  /**
+   * 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.
+   */
+  abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
+  /**
+   * 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.
+   */
+  abstract del(name: string, ...keys: string[]): Promise<void>;
+  abstract has(name: string, key: string): Promise<boolean>;
+  abstract keys(name: string, filter?: string): Promise<string[]>;
+  /**
+   * Remove all keys from all cache names.
+   */
+  abstract clear(): Promise<void>;
+}
+//#endregion
+//#region ../alepha/src/cache/descriptors/$cache.d.ts
+interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]> {
+  /**
+   * 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.
+   */
+  name?: string;
+  /**
+   * Function which returns cached data.
+   */
+  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";
+  /**
+   * The time-to-live for the cache in seconds.
+   * Set 0 to skip expiration.
+   *
+   * @default 300 (5 minutes).
+   */
+  ttl?: DurationLike;
+  /**
+   * If the cache is disabled.
+   */
+  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;
+}
+interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
+  /**
+   * Run the cache descriptor 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: 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> {
+  /**
+   * Key to identify the request in the pending requests.
+   */
+  key?: string;
+  /**
+   * The schema to validate the response against.
+   */
+  schema?: {
+    response?: T$1;
+  };
+  /**
+   * Built-in cache options.
+   */
+  localCache?: boolean | number | DurationLike;
+}
+type RequestInitWithOptions<T$1 extends TSchema = TSchema> = RequestInit & FetchOptions<T$1>;
+interface FetchResponse<T$1 = any> {
+  data: T$1;
+  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/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;
+  /**
+   * Pathname of the route. If not provided, property key is used.
+   */
+  path?: string;
+  /**
+   * 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.)
+   */
+  method?: RouteMethod;
+  /**
+   * 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.
+   */
+  schema?: TConfig;
+  /**
+   * A short description of the action. Used for documentation purposes.
+   */
+  description?: string;
+  /**
+   * 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!
+   */
+  disabled?: boolean;
+  /**
+   * Main route handler. This is where the route logic is implemented.
+   */
+  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;
+  /**
+   * Returns the name of the action.
+   */
+  get name(): string;
+  /**
+   * Returns the group of the action. (e.g. "orders", "admin", etc.)
+   */
+  get group(): string;
+  /**
+   * Returns the HTTP method of the action.
+   */
+  get method(): RouteMethod;
+  /**
+   * Returns the path of the action.
+   *
+   * 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.
+   */
+  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  /**
+   * Works like `run`, but always fetches (http request) the route.
+   */
+  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 {
+  /**
+   * 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: alepha139.TObject<{
+  error: alepha139.TString;
+  status: alepha139.TInteger;
+  message: alepha139.TString;
+  details: alepha139.TOptional<alepha139.TString>;
+  requestId: alepha139.TOptional<alepha139.TString>;
+  cause: alepha139.TOptional<alepha139.TObject<{
+    name: alepha139.TString;
+    message: alepha139.TString;
+  }>>;
+}>;
+type ErrorSchema = Static<typeof errorSchema>;
+//#endregion
+//#region ../alepha/src/server/errors/HttpError.d.ts
+declare class HttpError extends AlephaError {
+  name: string;
+  static is: (error: unknown, status?: number) => error is HttpErrorLike;
+  static toJSON(error: HttpError): ErrorSchema;
+  readonly error: string;
+  readonly status: number;
+  readonly requestId?: string;
+  readonly details?: string;
+  readonly reason?: {
+    name: string;
+    message: string;
+  };
+  constructor(options: Partial<ErrorSchema>, cause?: unknown);
+}
+interface HttpErrorLike extends Error {
+  status: number;
+}
+//#endregion
+//#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
+declare const envSchema$5: alepha139.TObject<{
+  SERVER_PORT: alepha139.TInteger;
+  SERVER_HOST: alepha139.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$5>> {}
+}
+//#endregion
+//#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
+declare const envSchema$4: alepha139.TObject<{
+  SERVER_PORT: alepha139.TInteger;
+  SERVER_HOST: alepha139.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$4>> {}
+}
+//#endregion
+//#region ../alepha/src/server/index.d.ts
+declare module "alepha" {
+  interface State {
+    "alepha.node.server"?: Server;
+  }
+  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;
+    };
+    "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>;
+  }
+}
+type ServerRouteCache =
+/**
+ * If true, enables caching with:
+ * - store: true
+ * - etag: true
+ */
+boolean
+/**
+ * Object configuration for fine-grained cache control.
+ *
+ * If empty, no caching will be applied.
+ */ | {
+  /**
+   * 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.
+   *
+   * @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.
+   */
+  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;
@@ -41,14 +1077,14 @@ declare class Redirection extends Error {
 }
 //#endregion
 //#region src/core/providers/ReactPageProvider.d.ts
-declare const envSchema$2: alepha7.TObject<{
-  REACT_STRICT_MODE: alepha7.TBoolean;
+declare const envSchema$3: alepha139.TObject<{
+  REACT_STRICT_MODE: alepha139.TBoolean;
 }>;
 declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$2>> {}
+  interface Env extends Partial<Static<typeof envSchema$3>> {}
 }
 declare class ReactPageProvider {
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: Logger;
   protected readonly env: {
     REACT_STRICT_MODE: boolean;
   };
@@ -85,7 +1121,7 @@ declare class ReactPageProvider {
   }, params?: Record<string, any>): string;
   compile(path: string, params?: Record<string, string>): string;
   protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
-  protected readonly configure: alepha7.HookDescriptor<"configure">;
+  protected readonly configure: alepha139.HookDescriptor<"configure">;
   protected map(pages: Array<PageDescriptor>, target: PageDescriptor): PageRouteEntry;
   add(entry: PageRouteEntry): void;
   protected createMatch(page: PageRoute): string;
@@ -220,7 +1256,7 @@ declare class ReactPageService {
  * const userProfile = $page({
  *   path: "/users/:id",
  *   schema: {
- *     params: t.object({ id: t.int() }),
+ *     params: t.object({ id: t.integer() }),
  *     query: t.object({ tab: t.optional(t.text()) })
  *   },
  *   resolve: async ({ params }) => {
@@ -494,23 +1530,265 @@ type CssAnimation = {
   timing?: string;
 };
 //#endregion
+//#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
+declare const userAccountInfoSchema: alepha139.TObject<{
+  id: alepha139.TString;
+  name: alepha139.TOptional<alepha139.TString>;
+  email: alepha139.TOptional<alepha139.TString>;
+  username: alepha139.TOptional<alepha139.TString>;
+  picture: alepha139.TOptional<alepha139.TString>;
+  sessionId: alepha139.TOptional<alepha139.TString>;
+  organizations: alepha139.TOptional<alepha139.TArray<alepha139.TString>>;
+  roles: alepha139.TOptional<alepha139.TArray<alepha139.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 {
+  /**
+   * Access token for the user.
+   */
+  token?: string;
+  /**
+   * Realm name of the user.
+   */
+  realm?: string;
+  /**
+   * Is user dedicated to his own resources for this scope ?
+   * Mostly, Admin is false and Customer is true.
+   */
+  ownership?: string | boolean;
+}
+//#endregion
+//#region ../alepha/src/security/providers/SecurityProvider.d.ts
+declare const envSchema$2: alepha139.TObject<{
+  APP_SECRET: alepha139.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;
+}
+//#endregion
+//#region ../alepha/src/server-security/providers/ServerSecurityProvider.d.ts
+type ServerRouteSecure = {
+  realm?: string;
+  basic?: BasicAuthOptions;
+};
+//#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";
+  }
+}
+/**
+ * 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
+ */
+//#endregion
+//#region ../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
+declare const apiLinkSchema: alepha139.TObject<{
+  name: alepha139.TString;
+  group: alepha139.TOptional<alepha139.TString>;
+  path: alepha139.TString;
+  method: alepha139.TOptional<alepha139.TString>;
+  requestBodyType: alepha139.TOptional<alepha139.TString>;
+  service: alepha139.TOptional<alepha139.TString>;
+}>;
+declare const apiLinksResponseSchema: alepha139.TObject<{
+  prefix: alepha139.TOptional<alepha139.TString>;
+  links: alepha139.TArray<alepha139.TObject<{
+    name: alepha139.TString;
+    group: alepha139.TOptional<alepha139.TString>;
+    path: alepha139.TString;
+    method: alepha139.TOptional<alepha139.TString>;
+    requestBodyType: alepha139.TOptional<alepha139.TString>;
+    service: alepha139.TOptional<alepha139.TString>;
+  }>>;
+}>;
+type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
+type ApiLink = Static<typeof apiLinkSchema>;
+//#endregion
+//#region ../alepha/src/server-links/providers/LinkProvider.d.ts
+/**
+ * Browser, SSR friendly, service to handle links.
+ */
+declare class LinkProvider {
+  static path: {
+    apiLinks: string;
+    apiSchema: string;
+  };
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly httpClient: HttpClient;
+  protected serverLinks: Array<HttpClientLink>;
+  /**
+   * Get applicative links registered on the server.
+   * This does not include lazy-loaded remote links.
+   */
+  getServerLinks(): HttpClientLink[];
+  /**
+   * Register a new link for the application.
+   */
+  registerLink(link: HttpClientLink): void;
+  get links(): HttpClientLink[];
+  /**
+   * Force browser to refresh links from the server.
+   */
+  fetchLinks(): Promise<HttpClientLink[]>;
+  /**
+   * Create a virtual client that can be used to call actions.
+   *
+   * Use js Proxy under the hood.
+   */
+  client<T$1 extends object>(scope?: ClientScope): HttpVirtualClient<T$1>;
+  /**
+   * Check if a link with the given name exists.
+   * @param name
+   */
+  can(name: string): boolean;
+  /**
+   * Resolve a link by its name and call it.
+   * - If link is local, it will call the local handler.
+   * - If link is remote, it will make a fetch request to the remote server.
+   */
+  follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
+  protected createVirtualAction<T$1 extends RequestConfigSchema>(name: string, scope?: ClientScope): VirtualAction<T$1>;
+  protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
+  protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
+}
+interface HttpClientLink extends ApiLink {
+  secured?: boolean | ServerRouteSecure;
+  prefix?: string;
+  host?: string;
+  service?: string;
+  schema?: RequestConfigSchema;
+  handler?: (request: ServerRequest, options: ClientRequestOptions) => Async<ServerResponseBody>;
+}
+interface ClientScope {
+  group?: string;
+  service?: string;
+  hostname?: string;
+}
+type HttpVirtualClient<T$1> = { [K in keyof T$1 as T$1[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T$1[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
+interface VirtualAction<T$1 extends RequestConfigSchema> extends Pick<ActionDescriptor<T$1>, "name" | "run" | "fetch"> {
+  (config?: ClientRequestEntry<T$1>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T$1>>;
+  can: () => boolean;
+}
+//#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;
+  }
+}
+/**
+ * Provides server-side link management and remote capabilities for client-server interactions.
+ *
+ * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
+ * facilitating seamless API endpoint management and client-server communication. It integrates with server
+ * security features to ensure safe and controlled access to resources.
+ *
+ * @see {@link $remote}
+ * @see {@link $client}
+ * @module alepha.server.links
+ */
+//#endregion
 //#region src/core/providers/ReactBrowserRouterProvider.d.ts
 interface BrowserRoute extends Route {
   page: PageRoute;
 }
 declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: Logger;
   protected readonly alepha: Alepha;
   protected readonly pageApi: ReactPageProvider;
   add(entry: PageRouteEntry): void;
-  protected readonly configure: alepha7.HookDescriptor<"configure">;
+  protected readonly configure: alepha139.HookDescriptor<"configure">;
   transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
   root(state: ReactRouterState): ReactNode;
 }
 //#endregion
 //#region src/core/providers/ReactBrowserProvider.d.ts
-declare const envSchema$1: alepha7.TObject<{
-  REACT_ROOT_ID: alepha7.TString;
+declare const envSchema$1: alepha139.TObject<{
+  REACT_ROOT_ID: alepha139.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
@@ -518,8 +1796,8 @@ declare module "alepha" {
 /**
  * React browser renderer configuration atom
  */
-declare const reactBrowserOptions: alepha7.Atom<alepha7.TObject<{
-  scrollRestoration: typebox0.TUnsafe<"top" | "manual">;
+declare const reactBrowserOptions: alepha139.Atom<alepha139.TObject<{
+  scrollRestoration: alepha139.TUnsafe<"top" | "manual">;
 }>, "alepha.react.browser.options">;
 type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
 declare module "alepha" {
@@ -531,7 +1809,7 @@ declare class ReactBrowserProvider {
   protected readonly env: {
     REACT_ROOT_ID: string;
   };
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: Logger;
   protected readonly client: LinkProvider;
   protected readonly alepha: Alepha;
   protected readonly router: ReactBrowserRouterProvider;
@@ -567,8 +1845,8 @@ declare class ReactBrowserProvider {
    * Get embedded layers from the server.
    */
   protected getHydrationState(): ReactHydrationState | undefined;
-  protected readonly onTransitionEnd: alepha7.HookDescriptor<"react:transition:end">;
-  readonly ready: alepha7.HookDescriptor<"ready">;
+  protected readonly onTransitionEnd: alepha139.HookDescriptor<"react:transition:end">;
+  readonly ready: alepha139.HookDescriptor<"ready">;
 }
 interface RouterGoOptions {
   replace?: boolean;
@@ -578,97 +1856,22 @@ interface RouterGoOptions {
   meta?: Record<string, any>;
   /**
    * Recreate the whole page, ignoring the current state.
-   */
-  force?: boolean;
-}
-type ReactHydrationState = {
-  layers?: Array<PreviousLayerData>;
-} & {
-  [key: string]: any;
-};
-interface RouterRenderOptions {
-  url?: string;
-  previous?: PreviousLayerData[];
-  meta?: Record<string, any>;
-}
-//#endregion
-//#region src/core/components/ErrorBoundary.d.ts
-/**
- * Props for the ErrorBoundary component.
- */
-interface ErrorBoundaryProps {
-  /**
-   * Fallback React node to render when an error is caught.
-   * If not provided, a default error message will be shown.
-   */
-  fallback: (error: Error) => ReactNode;
-  /**
-   * Optional callback that receives the error and error info.
-   * Use this to log errors to a monitoring service.
-   */
-  onError?: (error: Error, info: ErrorInfo) => void;
-}
-/**
- * State of the ErrorBoundary component.
- */
-interface ErrorBoundaryState {
-  error?: Error;
-}
-/**
- * A reusable error boundary for catching rendering errors
- * in any part of the React component tree.
- */
-declare class ErrorBoundary extends React.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
-  constructor(props: ErrorBoundaryProps);
-  /**
-   * Update state so the next render shows the fallback UI.
-   */
-  static getDerivedStateFromError(error: Error): ErrorBoundaryState;
-  /**
-   * Lifecycle method called when an error is caught.
-   * You can log the error or perform side effects here.
-   */
-  componentDidCatch(error: Error, info: ErrorInfo): void;
-  render(): ReactNode;
-}
-//#endregion
-//#region src/core/components/ErrorViewer.d.ts
-interface ErrorViewerProps {
-  error: Error;
-  alepha: Alepha;
-}
-declare const ErrorViewer: ({
-  error,
-  alepha
-}: ErrorViewerProps) => react_jsx_runtime0.JSX.Element;
-//#endregion
-//#region src/core/components/Link.d.ts
-interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-  href: string;
+   */
+  force?: boolean;
 }
-declare const Link: (props: LinkProps) => react_jsx_runtime0.JSX.Element;
-//#endregion
-//#region src/core/components/NestedView.d.ts
-interface NestedViewProps {
-  children?: ReactNode;
-  errorBoundary?: false | ((error: Error) => ReactNode);
+type ReactHydrationState = {
+  layers?: Array<PreviousLayerData>;
+} & {
+  [key: string]: any;
+};
+interface RouterRenderOptions {
+  url?: string;
+  previous?: PreviousLayerData[];
+  meta?: Record<string, any>;
 }
-declare const _default: react0.MemoExoticComponent<(props: NestedViewProps) => react_jsx_runtime0.JSX.Element>;
-//#endregion
-//#region src/core/components/NotFound.d.ts
-declare function NotFoundPage(props: {
-  style?: CSSProperties;
-}): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/core/contexts/AlephaContext.d.ts
-declare const AlephaContext: react0.Context<Alepha | undefined>;
-//#endregion
-//#region src/core/contexts/RouterLayerContext.d.ts
-interface RouterLayerContextValue {
-  index: number;
-  path: string;
-}
-declare const RouterLayerContext: react0.Context<RouterLayerContextValue | undefined>;
+declare const AlephaContext: react1.Context<Alepha | undefined>;
 //#endregion
 //#region src/core/hooks/useAction.d.ts
 /**
@@ -900,18 +2103,6 @@ interface UseActionReturn<Args extends any[], Result> {
   cancel: () => void;
 }
 //#endregion
-//#region src/core/hooks/useActive.d.ts
-interface UseActiveOptions {
-  href: string;
-  startWith?: boolean;
-}
-declare const useActive: (args: string | UseActiveOptions) => UseActiveHook;
-interface UseActiveHook {
-  isActive: boolean;
-  anchorProps: AnchorProps;
-  isPending: boolean;
-}
-//#endregion
 //#region src/core/hooks/useAlepha.d.ts
 /**
  * Main Alepha hook.
@@ -969,6 +2160,113 @@ type UseEvents = { [T in keyof Hooks]?: Hook<T> | ((payload: Hooks[T]) => Async<
  */
 declare const useInject: <T$1 extends object>(service: Service<T$1>) => T$1;
 //#endregion
+//#region src/core/hooks/useSchema.d.ts
+declare const useSchema: <TConfig extends RequestConfigSchema>(action: VirtualAction<TConfig>) => UseSchemaReturn<TConfig>;
+type UseSchemaReturn<TConfig extends RequestConfigSchema> = TConfig & {
+  loading: boolean;
+};
+/**
+ * Get an action schema during server-side rendering (SSR) or client-side rendering (CSR).
+ */
+declare const ssrSchemaLoading: (alepha: Alepha, name: string) => RequestConfigSchema | {
+  loading: boolean;
+};
+//#endregion
+//#region src/core/hooks/useStore.d.ts
+/**
+ * Hook to access and mutate the Alepha state.
+ */
+declare function useStore<T$1 extends TAtomObject>(target: Atom<T$1>, defaultValue?: Static<T$1>): UseStoreReturn<Static<T$1>>;
+declare function useStore<Key extends keyof State>(target: Key, defaultValue?: State[Key]): UseStoreReturn<State[Key]>;
+type UseStoreReturn<T$1> = [T$1, (value: T$1) => void];
+//#endregion
+//#region src/core/components/ErrorBoundary.d.ts
+/**
+ * Props for the ErrorBoundary component.
+ */
+interface ErrorBoundaryProps {
+  /**
+   * Fallback React node to render when an error is caught.
+   * If not provided, a default error message will be shown.
+   */
+  fallback: (error: Error) => ReactNode;
+  /**
+   * Optional callback that receives the error and error info.
+   * Use this to log errors to a monitoring service.
+   */
+  onError?: (error: Error, info: ErrorInfo) => void;
+}
+/**
+ * State of the ErrorBoundary component.
+ */
+interface ErrorBoundaryState {
+  error?: Error;
+}
+/**
+ * A reusable error boundary for catching rendering errors
+ * in any part of the React component tree.
+ */
+declare class ErrorBoundary extends React.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
+  constructor(props: ErrorBoundaryProps);
+  /**
+   * Update state so the next render shows the fallback UI.
+   */
+  static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+  /**
+   * Lifecycle method called when an error is caught.
+   * You can log the error or perform side effects here.
+   */
+  componentDidCatch(error: Error, info: ErrorInfo): void;
+  render(): ReactNode;
+}
+//#endregion
+//#region src/core/components/ErrorViewer.d.ts
+interface ErrorViewerProps {
+  error: Error;
+  alepha: Alepha;
+}
+declare const ErrorViewer: ({
+  error,
+  alepha
+}: ErrorViewerProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/core/components/Link.d.ts
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+  href: string;
+}
+declare const Link: (props: LinkProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/core/components/NestedView.d.ts
+interface NestedViewProps {
+  children?: ReactNode;
+  errorBoundary?: false | ((error: Error) => ReactNode);
+}
+declare const _default: react1.MemoExoticComponent<(props: NestedViewProps) => react_jsx_runtime0.JSX.Element>;
+//#endregion
+//#region src/core/components/NotFound.d.ts
+declare function NotFoundPage(props: {
+  style?: CSSProperties;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/core/contexts/RouterLayerContext.d.ts
+interface RouterLayerContextValue {
+  index: number;
+  path: string;
+}
+declare const RouterLayerContext: react1.Context<RouterLayerContextValue | undefined>;
+//#endregion
+//#region src/core/hooks/useActive.d.ts
+interface UseActiveOptions {
+  href: string;
+  startWith?: boolean;
+}
+declare const useActive: (args: string | UseActiveOptions) => UseActiveHook;
+interface UseActiveHook {
+  isActive: boolean;
+  anchorProps: AnchorProps;
+  isPending: boolean;
+}
+//#endregion
 //#region src/core/hooks/useQueryParams.d.ts
 /**
  * Not well tested. Use with caution.
@@ -991,7 +2289,7 @@ declare class ReactRouter<T$1 extends object> {
   isActive(href: string, options?: {
     startWith?: boolean;
   }): boolean;
-  path(name: keyof VirtualRouter<T$1>, config?: {
+  path(name: keyof VirtualRouter<T$1> | string, config?: {
     params?: Record<string, any>;
     query?: Record<string, any>;
   }): string;
@@ -1048,31 +2346,233 @@ declare const useRouter: <T$1 extends object = any>() => ReactRouter<T$1>;
 //#region src/core/hooks/useRouterState.d.ts
 declare const useRouterState: () => ReactRouterState;
 //#endregion
-//#region src/core/hooks/useSchema.d.ts
-declare const useSchema: <TConfig extends RequestConfigSchema>(action: VirtualAction<TConfig>) => UseSchemaReturn<TConfig>;
-type UseSchemaReturn<TConfig extends RequestConfigSchema> = TConfig & {
-  loading: boolean;
-};
-/**
- * Get an action schema during server-side rendering (SSR) or client-side rendering (CSR).
- */
-declare const ssrSchemaLoading: (alepha: Alepha, name: string) => RequestConfigSchema | {
-  loading: boolean;
-};
+//#region ../alepha/src/server-static/descriptors/$serve.d.ts
+interface ServeDescriptorOptions {
+  /**
+   * Prefix for the served path.
+   *
+   * @default "/"
+   */
+  path?: string;
+  /**
+   * Path to the directory to serve.
+   *
+   * @default process.cwd()
+   */
+  root?: string;
+  /**
+   * If true, descriptor will be ignored.
+   *
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
+   *
+   * @default true
+   */
+  ignoreDotEnvFiles?: boolean;
+  /**
+   * Whether to use the index.html file when the path is a directory.
+   *
+   * @default true
+   */
+  indexFallback?: boolean;
+  /**
+   * Force all requests "not found" to be served with the index.html file.
+   * This is useful for single-page applications (SPAs) that use client-side only routing.
+   */
+  historyApiFallback?: boolean;
+  /**
+   * Optional name of the descriptor.
+   * This is used for logging and debugging purposes.
+   *
+   * @default Key name.
+   */
+  name?: string;
+  /**
+   * Whether to use cache control headers.
+   *
+   * @default {}
+   */
+  cacheControl?: Partial<CacheControlOptions> | false;
+}
+interface CacheControlOptions {
+  /**
+   * Whether to use cache control headers.
+   *
+   * @default [.js, .css]
+   */
+  fileTypes: string[];
+  /**
+   * The maximum age of the cache in seconds.
+   *
+   * @default 60 * 60 * 24 * 2 // 2 days
+   */
+  maxAge: DurationLike;
+  /**
+   * Whether to use immutable cache control headers.
+   *
+   * @default true
+   */
+  immutable: boolean;
+}
 //#endregion
-//#region src/core/hooks/useStore.d.ts
+//#region ../alepha/src/file/services/FileDetector.d.ts
+interface FileTypeResult {
+  /**
+   * The detected MIME type
+   */
+  mimeType: string;
+  /**
+   * The detected file extension
+   */
+  extension: string;
+  /**
+   * Whether the file type was verified by magic bytes
+   */
+  verified: boolean;
+  /**
+   * The stream (potentially wrapped to allow re-reading)
+   */
+  stream: Readable;
+}
 /**
- * Hook to access and mutate the Alepha state.
+ * Service for detecting file types and getting content types.
+ *
+ * @example
+ * ```typescript
+ * const detector = alepha.inject(FileDetector);
+ *
+ * // Get content type from filename
+ * const mimeType = detector.getContentType("image.png"); // "image/png"
+ *
+ * // Detect file type by magic bytes
+ * const stream = createReadStream('image.png');
+ * const result = await detector.detectFileType(stream, 'image.png');
+ * console.log(result.mimeType); // 'image/png'
+ * console.log(result.verified); // true if magic bytes match
+ * ```
  */
-declare function useStore<T$1 extends TAtomObject>(target: Atom<T$1>, defaultValue?: Static<T$1>): UseStoreReturn<Static<T$1>>;
-declare function useStore<Key extends keyof State>(target: Key, defaultValue?: State[Key]): UseStoreReturn<State[Key]>;
-type UseStoreReturn<T$1> = [T$1, (value: T$1) => void];
+declare class FileDetector {
+  /**
+   * Magic byte signatures for common file formats.
+   * Each signature is represented as an array of bytes or null (wildcard).
+   */
+  protected static readonly MAGIC_BYTES: Record<string, {
+    signature: (number | null)[];
+    mimeType: string;
+  }[]>;
+  /**
+   * All possible format signatures for checking against actual file content
+   */
+  protected static readonly ALL_SIGNATURES: {
+    signature: (number | null)[];
+    mimeType: string;
+    ext: string;
+  }[];
+  /**
+   * MIME type map for file extensions.
+   *
+   * Can be used to get the content type of file based on its extension.
+   * Feel free to add more mime types in your project!
+   */
+  static readonly mimeMap: Record<string, string>;
+  /**
+   * Reverse MIME type map for looking up extensions from MIME types.
+   * Prefers shorter, more common extensions when multiple exist.
+   */
+  protected static readonly reverseMimeMap: Record<string, string>;
+  /**
+   * Returns the file extension for a given MIME type.
+   *
+   * @param mimeType - The MIME type to look up
+   * @returns The file extension (without dot), or "bin" if not found
+   *
+   * @example
+   * ```typescript
+   * const detector = alepha.inject(FileDetector);
+   * const ext = detector.getExtensionFromMimeType("image/png"); // "png"
+   * const ext2 = detector.getExtensionFromMimeType("application/octet-stream"); // "bin"
+   * ```
+   */
+  getExtensionFromMimeType(mimeType: string): string;
+  /**
+   * Returns the content type of file based on its filename.
+   *
+   * @param filename - The filename to check
+   * @returns The MIME type
+   *
+   * @example
+   * ```typescript
+   * const detector = alepha.inject(FileDetector);
+   * const mimeType = detector.getContentType("image.png"); // "image/png"
+   * ```
+   */
+  getContentType(filename: string): string;
+  /**
+   * Detects the file type by checking magic bytes against the stream content.
+   *
+   * @param stream - The readable stream to check
+   * @param filename - The filename (used to get the extension)
+   * @returns File type information including MIME type, extension, and verification status
+   *
+   * @example
+   * ```typescript
+   * const detector = alepha.inject(FileDetector);
+   * const stream = createReadStream('image.png');
+   * const result = await detector.detectFileType(stream, 'image.png');
+   * console.log(result.mimeType); // 'image/png'
+   * console.log(result.verified); // true if magic bytes match
+   * ```
+   */
+  detectFileType(stream: Readable, filename: string): Promise<FileTypeResult>;
+  /**
+   * Reads all bytes from a stream and returns the first N bytes along with a new stream containing all data.
+   * This approach reads the entire stream upfront to avoid complex async handling issues.
+   *
+   * @protected
+   */
+  protected peekBytes(stream: Readable, numBytes: number): Promise<{
+    buffer: Buffer;
+    stream: Readable;
+  }>;
+  /**
+   * Checks if a buffer matches a magic byte signature.
+   *
+   * @protected
+   */
+  protected matchesSignature(buffer: Buffer, signature: (number | null)[]): boolean;
+}
+//#endregion
+//#region ../alepha/src/server-static/providers/ServerStaticProvider.d.ts
+declare class ServerStaticProvider {
+  protected readonly alepha: Alepha;
+  protected readonly routerProvider: ServerRouterProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly fileDetector: FileDetector;
+  protected readonly log: Logger;
+  protected readonly directories: ServeDirectory[];
+  protected readonly configure: alepha139.HookDescriptor<"configure">;
+  createStaticServer(options: ServeDescriptorOptions): Promise<void>;
+  createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
+  protected getCacheFileTypes(): string[];
+  protected getCacheControl(filename: string, options: ServeDescriptorOptions): {
+    maxAge: number;
+    immutable: boolean;
+  } | undefined;
+  getAllFiles(dir: string, ignoreDotEnvFiles?: boolean): Promise<string[]>;
+}
+interface ServeDirectory {
+  options: ServeDescriptorOptions;
+  files: string[];
+}
 //#endregion
 //#region src/core/providers/ReactServerProvider.d.ts
-declare const envSchema: alepha7.TObject<{
-  REACT_SSR_ENABLED: alepha7.TOptional<alepha7.TBoolean>;
-  REACT_ROOT_ID: alepha7.TString;
-  REACT_SERVER_TEMPLATE: alepha7.TOptional<alepha7.TString>;
+declare const envSchema: alepha139.TObject<{
+  REACT_SSR_ENABLED: alepha139.TOptional<alepha139.TBoolean>;
+  REACT_ROOT_ID: alepha139.TString;
+  REACT_SERVER_TEMPLATE: alepha139.TOptional<alepha139.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -1083,11 +2583,11 @@ declare module "alepha" {
 /**
  * React server provider configuration atom
  */
-declare const reactServerOptions: alepha7.Atom<alepha7.TObject<{
-  publicDir: alepha7.TString;
-  staticServer: alepha7.TObject<{
-    disabled: alepha7.TBoolean;
-    path: alepha7.TString;
+declare const reactServerOptions: alepha139.Atom<alepha139.TObject<{
+  publicDir: alepha139.TString;
+  staticServer: alepha139.TObject<{
+    disabled: alepha139.TBoolean;
+    path: alepha139.TString;
   }>;
 }>, "alepha.react.server.options">;
 type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
@@ -1097,7 +2597,7 @@ declare module "alepha" {
   }
 }
 declare class ReactServerProvider {
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: Logger;
   protected readonly alepha: Alepha;
   protected readonly env: {
     REACT_SSR_ENABLED?: boolean | undefined;
@@ -1121,7 +2621,7 @@ declare class ReactServerProvider {
   /**
    * Configure the React server provider.
    */
-  readonly onConfigure: alepha7.HookDescriptor<"configure">;
+  readonly onConfigure: alepha139.HookDescriptor<"configure">;
   get template(): string;
   protected registerPages(templateLoader: TemplateLoader): Promise<void>;
   /**
@@ -1257,7 +2757,7 @@ declare module "alepha" {
  * @see {@link $page}
  * @module alepha.react
  */
-declare const AlephaReact: alepha7.Service<alepha7.Module>;
+declare const AlephaReact: alepha139.Service<alepha139.Module>;
 //#endregion
 export { $page, ActionContext, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, type LinkProps, _default as NestedView, NotFoundPage as NotFound, PageAnimation, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActionOptions, UseActionReturn, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, UseStoreReturn, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, ssrSchemaLoading, useAction, useActive, useAlepha, useClient, useEvents, useInject, useQueryParams, useRouter, useRouterState, useSchema, useStore };
 //# sourceMappingURL=index.d.cts.map