alepha 0.10.6 → 0.11.0

package/react/auth.d.ts

@@ -4,11 +4,11 @@ import * as _alepha_server_cookies0 from "alepha/server/cookies";
 import { Cookies, ServerCookiesProvider } from "alepha/server/cookies";
 import { DateTimeProvider } from "alepha/datetime";
 import { AccessTokenResponse, RealmDescriptor, SecurityProvider, UserAccount, UserAccountToken } from "alepha/security";
-import { Configuration } from "openid-client";
 import * as _alepha_logger0 from "alepha/logger";
 import * as _alepha_server0 from "alepha/server";
 import { HttpClient } from "alepha/server";
 import { HttpVirtualClient, ServerLinksProvider } from "alepha/server/links";
+import { Configuration } from "openid-client";
 import * as typebox143 from "typebox";
 
 //#region src/schemas/tokensSchema.d.ts

package/react/form.d.ts

@@ -6,13 +6,20 @@ import * as _alepha_logger0 from "alepha/logger";
 //#region src/services/FormModel.d.ts
 declare class FormModel<T extends TObject> {
   readonly id: string;
-  protected readonly options: FormCtrlOptions<T>;
+  readonly options: FormCtrlOptions<T>;
   protected readonly log: _alepha_logger0.Logger;
   protected readonly alepha: Alepha;
   protected readonly values: Record<string, any>;
   input: SchemaToInput<T>;
   constructor(id: string, options: FormCtrlOptions<T>);
-  readonly onSubmit: (event: FormEventLike) => Promise<void>;
+  get currentValues(): Record<string, any>;
+  get props(): {
+    noValidate: boolean;
+    onSubmit: (values: FormEventLike) => Promise<void>;
+    onReset: (event: FormEventLike) => Promise<void>;
+  };
+  protected readonly reset: (event: FormEventLike) => Promise<void>;
+  protected readonly submit: (event: FormEventLike) => Promise<void>;
   protected parseValuesFromFormElement<T extends TObject>(options: FormCtrlOptions<T>, store: Record<string, any>): Record<string, any>;
   protected getValueFromInputObject<T extends TObject>(options: FormCtrlOptions<T>, values: Record<string, any>, key: string, value: FormDataEntryValue): void;
   protected createProxyFromSchema<T extends TObject>(options: FormCtrlOptions<T>, schema: TSchema, context: {
@@ -126,17 +133,16 @@ declare const FormState: <T extends TObject>(props: {
 declare const useForm: <T extends TObject>(options: FormCtrlOptions<T>) => FormModel<T>;
 //#endregion
 //#region src/hooks/useFormState.d.ts
-interface UseFormStateReturn<T extends TObject> {
+interface UseFormStateReturn {
   loading: boolean;
   dirty: boolean;
-  values?: T;
+  values?: Record<string, any>;
   error?: Error;
 }
-type FormStateEvent = "change" | "submit" | "error";
-declare const useFormState: <T extends TObject>(target: FormModel<T> | {
+declare const useFormState: <T extends TObject, Keys extends keyof UseFormStateReturn>(target: FormModel<T> | {
   form: FormModel<T>;
   path: string;
-}, events?: FormStateEvent[]) => UseFormStateReturn<T>;
+}, _events?: Keys[]) => Pick<UseFormStateReturn, Keys>;
 //#endregion
 //#region src/index.d.ts
 declare module "alepha" {
@@ -145,11 +151,16 @@ declare module "alepha" {
       id: string;
       path: string;
     };
+    "form:reset": {
+      id: string;
+      values: Record<string, any>;
+    };
     "form:submit:begin": {
       id: string;
     };
     "form:submit:success": {
       id: string;
+      values: Record<string, any>;
     };
     "form:submit:error": {
       id: string;
@@ -173,5 +184,5 @@ declare module "alepha" {
  */
 declare const AlephaReactForm: _alepha_core0.Service<_alepha_core0.Module<{}>>;
 //#endregion
-export { AlephaReactForm, FormCtrlOptions, FormEventLike, FormModel, FormState, FormStateEvent, InputField, InputHTMLAttributesLike, SchemaToInput, UseFormStateReturn, useForm, useFormState };
+export { AlephaReactForm, FormCtrlOptions, FormEventLike, FormModel, FormState, InputField, InputHTMLAttributesLike, SchemaToInput, UseFormStateReturn, useForm, useFormState };
 //# sourceMappingURL=index.d.ts.map

package/react/i18n.d.ts

@@ -8,8 +8,8 @@ import * as typebox0 from "typebox";
 /**
  * Hook to access the i18n service.
  */
-declare const useI18n: <S extends object, K extends keyof ServiceDictionary<S>>() => I18nProvider<S, K> & {
-  tr(key: keyof ServiceDictionary<S>[K] | string, options?: {
+declare const useI18n: <S extends object, K$1 extends keyof ServiceDictionary<S>>() => I18nProvider<S, K$1> & {
+  tr(key: keyof ServiceDictionary<S>[K$1] | string, options?: {
     args?: string[];
     default?: string;
   }): string;
@@ -17,7 +17,7 @@ declare const useI18n: <S extends object, K extends keyof ServiceDictionary<S>>(
 type ServiceDictionary<T extends object> = { [K in keyof T]: T[K] extends DictionaryDescriptor<infer U> ? U : never };
 //#endregion
 //#region src/providers/I18nProvider.d.ts
-declare class I18nProvider<S extends object, K extends keyof ServiceDictionary<S>> {
+declare class I18nProvider<S extends object, K$1 extends keyof ServiceDictionary<S>> {
   protected logger: _alepha_logger0.Logger;
   protected alepha: Alepha;
   protected cookie: _alepha_server_cookies0.AbstractCookieDescriptor<typebox0.TString>;
@@ -30,6 +30,9 @@ declare class I18nProvider<S extends object, K extends keyof ServiceDictionary<S
   options: {
     fallbackLang: string;
   };
+  dateFormat: {
+    format: (value: Date) => string;
+  };
   numberFormat: {
     format: (value: number) => string;
   };
@@ -37,11 +40,11 @@ declare class I18nProvider<S extends object, K extends keyof ServiceDictionary<S
   protected readonly onRender: _alepha_core1.HookDescriptor<"server:onRequest">;
   protected readonly onStart: _alepha_core1.HookDescriptor<"start">;
   protected createFormatters(): void;
-  setLang(lang: string): Promise<void>;
+  setLang: (lang: string) => Promise<void>;
   protected readonly mutate: _alepha_core1.HookDescriptor<"state:mutate">;
   get lang(): string;
   translate: (key: string, args?: string[]) => string;
-  readonly tr: (key: keyof ServiceDictionary<S>[K] | string, options?: {
+  readonly tr: (key: keyof ServiceDictionary<S>[K$1] | string, options?: {
     args?: string[];
     default?: string;
   }) => string;

package/react.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core14 from "alepha";
-import { Alepha, Async, Descriptor, Hooks, KIND, Service, State, Static, TObject, TSchema } from "alepha";
+import { Alepha, Async, Configurable, Descriptor, Hooks, KIND, Service, State, Static, TObject, TSchema } from "alepha";
 import { RequestConfigSchema, ServerHandler, ServerProvider, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "alepha/server";
 import { ServerRouteCache } from "alepha/server/cache";
 import { ClientScope, HttpVirtualClient, LinkProvider, VirtualAction } from "alepha/server/links";
@@ -7,7 +7,7 @@ import * as _alepha_logger1 from "alepha/logger";
 import * as react0 from "react";
 import React, { AnchorHTMLAttributes, CSSProperties, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { ServerStaticProvider } from "alepha/server/static";
+import { ServeDescriptorOptions, ServerStaticProvider } from "alepha/server/static";
 import { DateTimeProvider } from "alepha/datetime";
 import { Route, RouterProvider } from "alepha/router";
 
@@ -813,14 +813,16 @@ declare module "alepha" {
     "react.server.ssr"?: boolean;
   }
 }
-declare class ReactServerProvider {
+interface ReactServerProviderOptions {
+  /**
+   * Override default options for the static file server.
+   * > Static file server is only created in non-serverless production mode.
+   */
+  static?: Partial<Omit<ServeDescriptorOptions, "root">>;
+}
+declare class ReactServerProvider implements Configurable {
   protected readonly log: _alepha_logger1.Logger;
   protected readonly alepha: Alepha;
-  protected readonly pageApi: ReactPageProvider;
-  protected readonly serverProvider: ServerProvider;
-  protected readonly serverStaticProvider: ServerStaticProvider;
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  protected readonly serverTimingProvider: ServerTimingProvider;
   protected readonly env: {
     REACT_SSR_ENABLED?: boolean | undefined;
     REACT_SERVER_TEMPLATE?: string | undefined;
@@ -828,13 +830,31 @@ declare class ReactServerProvider {
     REACT_SERVER_PREFIX: string;
     REACT_ROOT_ID: string;
   };
+  protected readonly pageApi: ReactPageProvider;
+  protected readonly serverProvider: ServerProvider;
+  protected readonly serverStaticProvider: ServerStaticProvider;
+  protected readonly serverRouterProvider: ServerRouterProvider;
+  protected readonly serverTimingProvider: ServerTimingProvider;
   protected readonly ROOT_DIV_REGEX: RegExp;
   protected preprocessedTemplate: PreprocessedTemplate | null;
+  options: ReactServerProviderOptions;
+  /**
+   * Configure the React server provider.
+   */
   readonly onConfigure: _alepha_core14.HookDescriptor<"configure">;
   get template(): string;
   protected registerPages(templateLoader: TemplateLoader): Promise<void>;
+  /**
+   * Get the public directory path where static files are located.
+   */
   protected getPublicDirectory(): string;
+  /**
+   * Configure the static file server to serve files from the given root directory.
+   */
   protected configureStaticServer(root: string): Promise<void>;
+  /**
+   * Configure Vite for SSR.
+   */
   protected configureVite(ssrEnabled: boolean): Promise<void>;
   /**
    * For testing purposes, creates a render function that can be used.
@@ -871,7 +891,7 @@ declare module "alepha" {
       html: string;
     };
     "react:browser:render": {
-      root: HTMLDivElement;
+      root: HTMLElement;
       element: ReactNode;
       state: ReactRouterState;
       hydration?: ReactHydrationState;
@@ -905,5 +925,5 @@ declare module "alepha" {
  */
 declare const AlephaReact: _alepha_core14.Service<_alepha_core14.Module<{}>>;
 //#endregion
-export { $page, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, 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, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, VirtualRouter, isPageRoute, ssrSchemaLoading, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState, useSchema, useStore };
+export { $page, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, 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, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, VirtualRouter, isPageRoute, ssrSchemaLoading, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState, useSchema, useStore };
 //# sourceMappingURL=index.d.ts.map

package/scheduler.d.ts

@@ -3,9 +3,19 @@ import { Alepha, Async, Descriptor, KIND, Static } from "alepha";
 import * as _alepha_lock0 from "alepha/lock";
 import { DateTime, DateTimeProvider, DurationLike } from "alepha/datetime";
 import * as _alepha_logger0 from "alepha/logger";
-import { Cron } from "cron-schedule";
 import * as dayjs0 from "dayjs";
+import { Cron } from "cron-schedule";
 
+//#region src/constants/CRON.d.ts
+declare const CRON: {
+  EVERY_MINUTE: string;
+  EVERY_5_MINUTES: string;
+  EVERY_15_MINUTES: string;
+  EVERY_30_MINUTES: string;
+  EVERY_HOUR: string;
+  EVERY_DAY_AT_MIDNIGHT: string;
+};
+//#endregion
 //#region src/providers/CronProvider.d.ts
 declare class CronProvider {
   protected readonly dt: DateTimeProvider;
@@ -131,5 +141,5 @@ declare module "alepha" {
  */
 declare const AlephaScheduler: _alepha_core4.Service<_alepha_core4.Module<{}>>;
 //#endregion
-export { $scheduler, AlephaScheduler, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerHandlerArguments };
+export { $scheduler, AlephaScheduler, CRON, CronJob, CronProvider, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerHandlerArguments };
 //# sourceMappingURL=index.d.ts.map

package/server/cache.d.ts

@@ -11,20 +11,12 @@ declare module "alepha/server" {
   interface ServerRoute {
     /**
      * Enable caching for this route.
-     * If set to true, a default cache configuration will be applied (5 minutes TTL).
-     * If a DurationLike is provided, it will be used as the TTL for the cache.
+     * - If true: enables both store and etag
+     * - If object: fine-grained control over store, etag, and cache-control headers
      *
      * @default false
      */
     cache?: ServerRouteCache;
-    /**
-     * Enable ETag support for this route.
-     * If set to true, the server will generate and manage ETags automatically.
-     * If a string is provided, it will be used as a static ETag value.
-     *
-     * @default false
-     */
-    etag?: boolean | string;
   }
   interface ActionDescriptor<TConfig extends RequestConfigSchema> {
     invalidate: () => Promise<void>;
@@ -42,9 +34,92 @@ declare class ServerCacheProvider {
   protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
   protected readonly onSend: _alepha_core1.HookDescriptor<"server:onSend">;
   protected readonly onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
+  buildCacheControlHeader(cache?: ServerRouteCache): string | undefined;
+  protected durationToSeconds(duration: number | DurationLike): number;
+  protected shouldStore(cache?: ServerRouteCache): boolean;
+  protected shouldUseEtag(cache?: ServerRouteCache): boolean;
   protected createCacheKey(route: ServerRoute, config?: ServerRequest): string;
 }
-type ServerRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
+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;
+  };
+};
 interface RouteCacheEntry {
   contentType?: string;
   body: any;

package/server/health.d.ts

@@ -2,11 +2,12 @@ import * as _alepha_core0 from "alepha";
 import { Alepha } from "alepha";
 import * as _alepha_server0 from "alepha/server";
 import { DateTimeProvider } from "alepha/datetime";
-import * as typebox0 from "typebox";
+import * as typebox5 from "typebox";
+import * as dayjs0 from "dayjs";
 
 //#region src/providers/ServerHealthProvider.d.ts
 /**
- * Register `/health` endpoint.
+ * Register `/health` & `/healthz` endpoint.
  *
  * - Provides basic health information about the server.
  */
@@ -14,15 +15,37 @@ declare class ServerHealthProvider {
   protected readonly time: DateTimeProvider;
   protected readonly alepha: Alepha;
   readonly health: _alepha_server0.RouteDescriptor<{
-    response: typebox0.TObject<{
-      message: typebox0.TString;
-      uptime: typebox0.TNumber;
-      date: typebox0.TString;
-      ready: typebox0.TBoolean;
+    response: typebox5.TObject<{
+      message: typebox5.TString;
+      uptime: typebox5.TNumber;
+      date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
+      ready: typebox5.TBoolean;
     }>;
   }>;
+  readonly healthz: _alepha_server0.RouteDescriptor<{
+    response: typebox5.TObject<{
+      message: typebox5.TString;
+      uptime: typebox5.TNumber;
+      date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
+      ready: typebox5.TBoolean;
+    }>;
+  }>;
+  protected healthCheck(): {
+    message: string;
+    uptime: number;
+    date: dayjs0.Dayjs;
+    ready: boolean;
+  };
 }
 //#endregion
+//#region src/schemas/healthSchema.d.ts
+declare const healthSchema: typebox5.TObject<{
+  message: typebox5.TString;
+  uptime: typebox5.TNumber;
+  date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
+  ready: typebox5.TBoolean;
+}>;
+//#endregion
 //#region src/index.d.ts
 /**
  * Plugin for Alepha Server that provides health-check endpoints.
@@ -32,5 +55,5 @@ declare class ServerHealthProvider {
  */
 declare const AlephaServerHealth: _alepha_core0.Service<_alepha_core0.Module<{}>>;
 //#endregion
-export { AlephaServerHealth, ServerHealthProvider };
+export { AlephaServerHealth, ServerHealthProvider, healthSchema };
 //# sourceMappingURL=index.d.ts.map

package/server/multipart.d.ts

@@ -1,8 +1,8 @@
 import * as _alepha_core0 from "alepha";
 import { Alepha, FileLike, HookDescriptor } from "alepha";
 import { ServerRoute } from "alepha/server";
-import { BusboyConfig } from "@fastify/busboy";
 import { IncomingMessage } from "node:http";
+import { BusboyConfig } from "@fastify/busboy";
 
 //#region src/providers/ServerMultipartProvider.d.ts
 declare class ServerMultipartProvider {
@@ -10,7 +10,7 @@ declare class ServerMultipartProvider {
   readonly onRequest: HookDescriptor<"server:onRequest">;
   readonly onSend: HookDescriptor<"server:onResponse">;
   handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
-    body: Record<string, any>;
+    body: Record<string, unknown>;
     cleanup: () => Promise<void>;
   }>;
   parseMultipart(req: IncomingMessage, config?: Omit<BusboyConfig, "headers">): Promise<MultipartResult>;

package/server/swagger.d.ts

@@ -1,7 +1,7 @@
 import "alepha/server/security";
 import * as _alepha_core1 from "alepha";
 import { Alepha, Descriptor, KIND, TObject } from "alepha";
-import { ActionDescriptor, RequestConfigSchema, ServerRouterProvider } from "alepha/server";
+import { ActionDescriptor, RequestConfigSchema, ServerProvider, ServerRouterProvider } from "alepha/server";
 import * as _alepha_logger0 from "alepha/logger";
 import { ServerStaticProvider } from "alepha/server/static";
 import { OpenAPIV3 } from "openapi-types";
@@ -99,9 +99,13 @@ declare class SwaggerDescriptor extends Descriptor<SwaggerDescriptorOptions> {}
 declare class ServerSwaggerProvider {
   protected readonly serverStaticProvider: ServerStaticProvider;
   protected readonly serverRouterProvider: ServerRouterProvider;
+  protected readonly serverProvider: ServerProvider;
   protected readonly alepha: Alepha;
   protected readonly log: _alepha_logger0.Logger;
   json?: OpenAPIV3.Document;
+  options: {
+    excludeKeys: string[];
+  };
   protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
   createSwagger(options: SwaggerDescriptorOptions): Promise<OpenAPIV3.Document | undefined>;
   protected configureOpenApi(actions: ActionDescriptor<RequestConfigSchema>[], doc: SwaggerDescriptorOptions): OpenAPIV3.Document;
@@ -114,6 +118,7 @@ declare class ServerSwaggerProvider {
   } | undefined;
   protected configureSwaggerApi(prefix: string, json: OpenAPIV3.Document): void;
   protected configureSwaggerUi(prefix: string, options: SwaggerDescriptorOptions): Promise<void>;
+  removePrivateFields<T extends Record<string, any>>(obj: T, excludeList: string[]): T;
 }
 //#endregion
 //#region src/index.d.ts

package/server.d.ts

@@ -1,6 +1,6 @@
-import * as _alepha_core1 from "alepha";
+import * as _alepha_core11 from "alepha";
 import { Alepha, AlephaError, Async, Descriptor, FileLike, KIND, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import * as _alepha_logger0 from "alepha/logger";
+import * as _alepha_logger3 from "alepha/logger";
 import { Readable } from "node:stream";
 import { ReadableStream } from "node:stream/web";
 import { Route, RouterProvider } from "alepha/router";
@@ -153,6 +153,10 @@ interface ServerRawRequest {
       req: IncomingMessage;
       res: ServerResponse$1;
     };
+    web?: {
+      req: Request;
+      res?: Response;
+    };
   };
 }
 //#endregion
@@ -161,6 +165,12 @@ declare abstract class ServerProvider {
   protected readonly alepha: Alepha;
   abstract get hostname(): string;
   protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
+  protected createRouterRequest(req: {
+    method?: string;
+    url?: string;
+    headers?: Record<string, string | string[] | undefined>;
+  }, params?: Record<string, string>): ServerRawRequest;
+  protected getProtocol(headers: Record<string, string>): "http" | "https";
 }
 //#endregion
 //#region src/services/ServerRequestParser.d.ts
@@ -176,13 +186,14 @@ declare class ServerRequestParser {
 //#region src/providers/ServerTimingProvider.d.ts
 type TimingMap = Record<string, [number, number]>;
 declare class ServerTimingProvider {
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly alepha: Alepha;
   options: {
+    prefix: string;
     disabled: boolean;
   };
-  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
-  readonly onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
+  readonly onRequest: _alepha_core11.HookDescriptor<"server:onRequest">;
+  readonly onResponse: _alepha_core11.HookDescriptor<"server:onResponse">;
   protected get handlerName(): string;
   beginTiming(name: string): void;
   endTiming(name: string): void;
@@ -222,14 +233,12 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
 //#endregion
 //#region src/services/HttpClient.d.ts
 declare class HttpClient {
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly alepha: Alepha;
   readonly cache: _alepha_cache0.CacheDescriptorFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
   fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
-  fetch<T>(url: string, request?: RequestInit,
-  // standard options
-  options?: FetchOptions): Promise<FetchResponse<T>>;
+  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>;
@@ -246,7 +255,7 @@ declare class HttpClient {
     };
   }, args?: ServerRequestConfigEntry): string;
 }
-interface FetchOptions {
+interface FetchOptions<T extends TSchema = TSchema> {
   /**
    * Key to identify the request in the pending requests.
    */
@@ -254,12 +263,15 @@ interface FetchOptions {
   /**
    * The schema to validate the response against.
    */
-  schema?: TSchema;
+  schema?: {
+    response?: T;
+  };
   /**
    * Built-in cache options.
    */
-  cache?: boolean | number | DurationLike;
+  localCache?: boolean | number | DurationLike;
 }
+type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
 interface FetchResponse<T = any> {
   data: T;
   status: number;
@@ -541,7 +553,7 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends O
   handler: ServerActionHandler<TConfig>;
 }
 declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
   };
@@ -713,9 +725,9 @@ declare const okSchema: typebox0.TObject<{
 type Ok = Static<typeof okSchema>;
 //#endregion
 //#region src/providers/NodeHttpServerProvider.d.ts
-declare const envSchema: _alepha_core1.TObject<{
-  SERVER_PORT: _alepha_core1.TInteger;
-  SERVER_HOST: _alepha_core1.TString;
+declare const envSchema: _alepha_core11.TObject<{
+  SERVER_PORT: _alepha_core11.TInteger;
+  SERVER_HOST: _alepha_core11.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -723,31 +735,29 @@ declare module "alepha" {
 declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly env: {
     SERVER_PORT: number;
     SERVER_HOST: string;
   };
   protected readonly router: ServerRouterProvider;
   protected readonly server: http0.Server<typeof IncomingMessage, typeof ServerResponse$1>;
-  protected readonly onNodeRequest: _alepha_core1.HookDescriptor<"node:request">;
+  protected readonly onNodeRequest: _alepha_core11.HookDescriptor<"node:request">;
   handle(req: IncomingMessage, res: ServerResponse$1): Promise<void>;
-  createRouterRequest(req: IncomingMessage, res: ServerResponse$1, params?: Record<string, string>): ServerRawRequest;
-  getProtocol(req: IncomingMessage): "http" | "https";
   get hostname(): string;
-  readonly start: _alepha_core1.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
+  readonly start: _alepha_core11.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core11.HookDescriptor<"stop">;
   protected listen(): Promise<void>;
   protected close(): Promise<void>;
 }
 //#endregion
 //#region src/providers/ServerLoggerProvider.d.ts
 declare class ServerLoggerProvider {
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
-  readonly onError: _alepha_core1.HookDescriptor<"server:onError">;
-  readonly onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
+  readonly onRequest: _alepha_core11.HookDescriptor<"server:onRequest">;
+  readonly onError: _alepha_core11.HookDescriptor<"server:onError">;
+  readonly onResponse: _alepha_core11.HookDescriptor<"server:onResponse">;
 }
 //#endregion
 //#region src/providers/ServerNotReadyProvider.d.ts
@@ -760,7 +770,7 @@ declare class ServerLoggerProvider {
  */
 declare class ServerNotReadyProvider {
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  readonly onRequest: _alepha_core11.HookDescriptor<"server:onRequest">;
 }
 //#endregion
 //#region src/index.d.ts
@@ -815,6 +825,10 @@ declare module "alepha" {
       req: IncomingMessage;
       res: ServerResponse$1;
     };
+    "web:request": {
+      req: Request;
+      res?: Response;
+    };
   }
 }
 /**
@@ -828,7 +842,7 @@ declare module "alepha" {
  * @see {@link $action}
  * @module alepha.server
  */
-declare const AlephaServer: _alepha_core1.Service<_alepha_core1.Module<{}>>;
+declare const AlephaServer: _alepha_core11.Service<_alepha_core11.Module<{}>>;
 //#endregion
-export { $action, $route, ActionDescriptor, ActionDescriptorFn, ActionDescriptorOptions, AlephaServer, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, ValidationError, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
+export { $action, $route, ActionDescriptor, ActionDescriptorFn, ActionDescriptorOptions, AlephaServer, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, RequestInitWithOptions, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, ValidationError, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
 //# sourceMappingURL=index.d.ts.map