alepha 0.10.6 → 0.10.7

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/cookies.d.ts

@@ -45,9 +45,9 @@ declare const $cookie: {
   <T extends TSchema>(options: CookieDescriptorOptions<T>): AbstractCookieDescriptor<T>;
   [KIND]: typeof CookieDescriptor;
 };
-interface CookieDescriptorOptions<T extends TSchema> {
+interface CookieDescriptorOptions<T$1 extends TSchema> {
   /** The schema for the cookie's value, used for validation and type safety. */
-  schema: T;
+  schema: T$1;
   /** The name of the cookie. */
   name?: string;
   /** The cookie's path. Defaults to "/". */
@@ -69,28 +69,28 @@ interface CookieDescriptorOptions<T extends TSchema> {
   /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
   sign?: boolean;
 }
-interface AbstractCookieDescriptor<T extends TSchema> {
+interface AbstractCookieDescriptor<T$1 extends TSchema> {
   readonly name: string;
-  readonly options: CookieDescriptorOptions<T>;
-  set(value: Static<T>, options?: {
+  readonly options: CookieDescriptorOptions<T$1>;
+  set(value: Static<T$1>, options?: {
     cookies?: Cookies;
     ttl?: DurationLike;
   }): void;
   get(options?: {
     cookies?: Cookies;
-  }): Static<T> | undefined;
+  }): Static<T$1> | undefined;
   del(options?: {
     cookies?: Cookies;
   }): void;
 }
-declare class CookieDescriptor<T extends TSchema> extends Descriptor<CookieDescriptorOptions<T>> implements AbstractCookieDescriptor<T> {
+declare class CookieDescriptor<T$1 extends TSchema> extends Descriptor<CookieDescriptorOptions<T$1>> implements AbstractCookieDescriptor<T$1> {
   protected readonly serverCookiesProvider: ServerCookiesProvider;
-  get schema(): T;
+  get schema(): T$1;
   get name(): string;
   /**
    * Sets the cookie with the given value in the current request's response.
    */
-  set(value: Static<T>, options?: {
+  set(value: Static<T$1>, options?: {
     cookies?: Cookies;
     ttl?: DurationLike;
   }): void;
@@ -99,7 +99,7 @@ declare class CookieDescriptor<T extends TSchema> extends Descriptor<CookieDescr
    */
   get(options?: {
     cookies?: Cookies;
-  }): Static<T> | undefined;
+  }): Static<T$1> | undefined;
   /**
    * Deletes the cookie in the current request's response.
    */

package/server/links.d.ts

@@ -93,9 +93,9 @@ interface ClientScope {
   service?: string;
   hostname?: string;
 }
-type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
-interface VirtualAction<T extends RequestConfigSchema> extends Pick<ActionDescriptor<T>, "name" | "run" | "fetch"> {
-  (config?: ClientRequestEntry<T>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T>>;
+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

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,6 +99,7 @@ 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;

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";
@@ -68,14 +68,14 @@ interface RequestConfigSchema {
   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>;
+interface ServerRequestConfig<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> {
+  body: TConfig$1["body"] extends TRequestBody ? Static<TConfig$1["body"]> : any;
+  headers: TConfig$1["headers"] extends TObject ? Static<TConfig$1["headers"]> : Record<string, string>;
+  params: TConfig$1["params"] extends TObject ? Static<TConfig$1["params"]> : Record<string, string>;
+  query: TConfig$1["query"] extends TObject ? Static<TConfig$1["query"]> : Record<string, any>;
 }
-type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
-interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
+type ServerRequestConfigEntry<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig$1>>;
+interface ServerRequest<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig$1> {
   method: RouteMethod;
   url: URL;
   requestId: string;
@@ -120,19 +120,19 @@ interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchem
     };
   };
 }
-interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
-  handler: ServerHandler<TConfig>;
+interface ServerRoute<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> extends Route {
+  handler: ServerHandler<TConfig$1>;
   method?: RouteMethod;
-  schema?: TConfig;
+  schema?: TConfig$1;
   /**
    * @see ServerLoggerProvider
    */
   silent?: boolean;
 }
-type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
+type ServerResponseBody<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = TConfig$1["response"] extends TResponseBody ? Static<TConfig$1["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>>;
+type ServerHandler<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig$1>) => Async<ServerResponseBody<TConfig$1>>;
 interface ServerResponse {
   body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
   headers: Record<string, string>;
@@ -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,7 +233,7 @@ 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;
@@ -260,8 +271,8 @@ interface FetchOptions {
    */
   cache?: boolean | number | DurationLike;
 }
-interface FetchResponse<T = any> {
-  data: T;
+interface FetchResponse<T$1 = any> {
+  data: T$1;
   status: number;
   statusText: string;
   headers: Headers;
@@ -474,7 +485,7 @@ declare const $action: {
   <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptorFn<TConfig>;
   [KIND]: typeof ActionDescriptor;
 };
-interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
+interface ActionDescriptorOptions<TConfig$1 extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
    * Name of the action.
    *
@@ -525,7 +536,7 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends O
    * - query: The request query-params schema.
    * - response: The response schema.
    */
-  schema?: TConfig;
+  schema?: TConfig$1;
   /**
    * A short description of the action. Used for documentation purposes.
    */
@@ -538,10 +549,10 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends O
   /**
    * Main route handler. This is where the route logic is implemented.
    */
-  handler: ServerActionHandler<TConfig>;
+  handler: ServerActionHandler<TConfig$1>;
 }
-declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
-  protected readonly log: _alepha_logger0.Logger;
+declare class ActionDescriptor<TConfig$1 extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig$1>> {
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
   };
@@ -569,27 +580,27 @@ declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Desc
    * Path is prefixed by `/api` by default.
    */
   get path(): string;
-  get schema(): TConfig | undefined;
+  get schema(): TConfig$1 | undefined;
   getBodyContentType(): string | undefined;
   /**
    * Call the action handler directly.
    * There is no HTTP layer involved.
    */
-  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  run(config?: ClientRequestEntry<TConfig$1>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig$1>>;
   /**
    * Works like `run`, but always fetches (http request) the route.
    */
-  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
+  fetch(config?: ClientRequestEntry<TConfig$1>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig$1>>>;
 }
-interface ActionDescriptorFn<TConfig extends RequestConfigSchema> extends ActionDescriptor<TConfig> {
-  (config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+interface ActionDescriptorFn<TConfig$1 extends RequestConfigSchema> extends ActionDescriptor<TConfig$1> {
+  (config?: ClientRequestEntry<TConfig$1>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig$1>>;
 }
-type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
-type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
-  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
-  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
-  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
-  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
+type ClientRequestEntry<TConfig$1 extends RequestConfigSchema, T$1 = ClientRequestEntryContainer<TConfig$1>> = { [K in keyof T$1 as T$1[K] extends undefined ? never : K]: T$1[K] };
+type ClientRequestEntryContainer<TConfig$1 extends RequestConfigSchema> = {
+  body: TConfig$1["body"] extends TObject ? Static<TConfig$1["body"]> : undefined;
+  params: TConfig$1["params"] extends TObject ? Static<TConfig$1["params"]> : undefined;
+  headers?: TConfig$1["headers"] extends TObject ? Static<TConfig$1["headers"]> : undefined;
+  query?: TConfig$1["query"] extends TObject ? Partial<Static<TConfig$1["query"]>> : undefined;
 };
 interface ClientRequestOptions extends FetchOptions {
   /**
@@ -597,11 +608,11 @@ interface ClientRequestOptions extends FetchOptions {
    */
   request?: RequestInit;
 }
-type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
+type ClientRequestResponse<TConfig$1 extends RequestConfigSchema> = TConfig$1["response"] extends TSchema ? Static<TConfig$1["response"]> : any;
 /**
  * Specific handler for server actions.
  */
-type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+type ServerActionHandler<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig$1>) => Async<ServerResponseBody<TConfig$1>>;
 /**
  * Server Action Request Interface
  *
@@ -609,7 +620,7 @@ type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSche
  *
  * This is NOT Server Request, but a specific type for actions.
  */
-interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
+interface ServerActionRequest<TConfig$1 extends RequestConfigSchema> extends ServerRequest<TConfig$1> {}
 //#endregion
 //#region src/schemas/errorSchema.d.ts
 declare const errorSchema: typebox0.TObject<{
@@ -659,8 +670,8 @@ declare const $route: {
   <TConfig extends RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
   [KIND]: typeof RouteDescriptor;
 };
-interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
-declare class RouteDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<RouteDescriptorOptions<TConfig>> {
+interface RouteDescriptorOptions<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig$1> {}
+declare class RouteDescriptor<TConfig$1 extends RequestConfigSchema> extends Descriptor<RouteDescriptorOptions<TConfig$1>> {
   protected readonly serverRouterProvider: ServerRouterProvider;
   protected onInit(): void;
 }
@@ -713,9 +724,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 +734,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 +769,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 +824,10 @@ declare module "alepha" {
       req: IncomingMessage;
       res: ServerResponse$1;
     };
+    "web:request": {
+      req: Request;
+      res?: Response;
+    };
   }
 }
 /**
@@ -828,7 +841,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 };
 //# sourceMappingURL=index.d.ts.map

package/topic.d.ts

@@ -220,7 +220,7 @@ declare const $topic: {
   <T extends TopicMessageSchema>(options: TopicDescriptorOptions<T>): TopicDescriptor<T>;
   [KIND]: typeof TopicDescriptor;
 };
-interface TopicDescriptorOptions<T extends TopicMessageSchema> {
+interface TopicDescriptorOptions<T$1 extends TopicMessageSchema> {
   /**
    * Unique name identifier for the topic.
    *
@@ -329,7 +329,7 @@ interface TopicDescriptorOptions<T extends TopicMessageSchema> {
    * }
    * ```
    */
-  schema: T;
+  schema: T$1;
   /**
    * Default subscriber handler function that processes messages published to this topic.
    *
@@ -393,32 +393,32 @@ interface TopicDescriptorOptions<T extends TopicMessageSchema> {
    * }
    * ```
    */
-  handler?: TopicHandler<T>;
+  handler?: TopicHandler<T$1>;
 }
-declare class TopicDescriptor<T extends TopicMessageSchema> extends Descriptor<TopicDescriptorOptions<T>> {
+declare class TopicDescriptor<T$1 extends TopicMessageSchema> extends Descriptor<TopicDescriptorOptions<T$1>> {
   protected readonly log: _alepha_logger0.Logger;
   protected readonly dateTimeProvider: DateTimeProvider;
   readonly provider: TopicProvider;
   get name(): string;
-  publish(payload: TopicMessage<T>["payload"]): Promise<void>;
-  subscribe(handler: TopicHandler<T>): Promise<UnSubscribeFn>;
-  wait(options?: TopicWaitOptions<T>): Promise<TopicMessage<T>>;
+  publish(payload: TopicMessage<T$1>["payload"]): Promise<void>;
+  subscribe(handler: TopicHandler<T$1>): Promise<UnSubscribeFn>;
+  wait(options?: TopicWaitOptions<T$1>): Promise<TopicMessage<T$1>>;
   protected $provider(): TopicProvider;
-  protected parseMessage(message: string): TopicMessage<T>;
+  protected parseMessage(message: string): TopicMessage<T$1>;
 }
-interface TopicMessage<T extends TopicMessageSchema> {
-  payload: Static<T["payload"]>;
+interface TopicMessage<T$1 extends TopicMessageSchema> {
+  payload: Static<T$1["payload"]>;
 }
-interface TopicWaitOptions<T extends TopicMessageSchema> {
+interface TopicWaitOptions<T$1 extends TopicMessageSchema> {
   timeout?: DurationLike;
   filter?: (message: {
-    payload: Static<T["payload"]>;
+    payload: Static<T$1["payload"]>;
   }) => boolean;
 }
 interface TopicMessageSchema {
   payload: TSchema;
 }
-type TopicHandler<T extends TopicMessageSchema = TopicMessageSchema> = (message: TopicMessage<T>) => unknown;
+type TopicHandler<T$1 extends TopicMessageSchema = TopicMessageSchema> = (message: TopicMessage<T$1>) => unknown;
 //#endregion
 //#region src/descriptors/$subscriber.d.ts
 /**
@@ -636,7 +636,7 @@ declare const $subscriber: {
   <T extends TopicMessageSchema>(options: SubscriberDescriptorOptions<T>): SubscriberDescriptor<T>;
   [KIND]: typeof SubscriberDescriptor;
 };
-interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
+interface SubscriberDescriptorOptions<T$1 extends TopicMessageSchema> {
   /**
    * The topic descriptor that this subscriber will listen to for messages.
    *
@@ -670,7 +670,7 @@ interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
    * });
    * ```
    */
-  topic: TopicDescriptor<T>;
+  topic: TopicDescriptor<T$1>;
   /**
    * Message handler function that processes individual messages from the topic.
    *
@@ -765,9 +765,9 @@ interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
    * }
    * ```
    */
-  handler: TopicHandler<T>;
+  handler: TopicHandler<T$1>;
 }
-declare class SubscriberDescriptor<T extends TopicMessageSchema> extends Descriptor<SubscriberDescriptorOptions<T>> {}
+declare class SubscriberDescriptor<T$1 extends TopicMessageSchema> extends Descriptor<SubscriberDescriptorOptions<T$1>> {}
 //#endregion
 //#region src/errors/TopicTimeoutError.d.ts
 declare class TopicTimeoutError extends Error {

package/ui.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/ui');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});