alepha 0.10.5 → 0.10.7

package/server/cache.d.ts

@@ -9,8 +9,14 @@ import { RequestConfigSchema, ServerRequest, ServerRoute } from "alepha/server";
 //#region src/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;
-    etag?: string;
   }
   interface ActionDescriptor<TConfig extends RequestConfigSchema> {
     invalidate: () => Promise<void>;
@@ -26,16 +32,94 @@ declare class ServerCacheProvider {
   protected readonly onActionRequest: _alepha_core1.HookDescriptor<"action:onRequest">;
   protected readonly onActionResponse: _alepha_core1.HookDescriptor<"action:onResponse">;
   protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  protected readonly onSend: _alepha_core1.HookDescriptor<"server:onSend">;
   protected readonly onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
-  protected getCacheOptions(cache: ServerRouteCache): {
-    provider?: (_alepha_core1.InstantiableClass<_alepha_cache0.CacheProvider> | "memory") | undefined;
-    name?: string | undefined;
-    ttl?: DurationLike | undefined;
-    disabled?: boolean | undefined;
-  };
+  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

@@ -1,4 +1,4 @@
-import "alepha/server/security";
+import { ServerRouteSecure } from "alepha/server/security";
 import * as _alepha_core2 from "alepha";
 import { Alepha, Descriptor, KIND, Static } from "alepha";
 import * as _alepha_server0 from "alepha/server";
@@ -7,26 +7,26 @@ import * as _alepha_logger0 from "alepha/logger";
 import * as _alepha_retry0 from "alepha/retry";
 import { ProxyDescriptorOptions, ServerProxyProvider } from "alepha/server/proxy";
 import { ServiceAccountDescriptor, UserAccountToken } from "alepha/security";
-import * as typebox0 from "typebox";
+import * as typebox18 from "typebox";
 
 //#region src/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: typebox0.TObject<{
-  name: typebox0.TString;
-  group: typebox0.TOptional<typebox0.TString>;
-  path: typebox0.TString;
-  method: typebox0.TOptional<typebox0.TString>;
-  requestBodyType: typebox0.TOptional<typebox0.TString>;
-  service: typebox0.TOptional<typebox0.TString>;
+declare const apiLinkSchema: typebox18.TObject<{
+  name: typebox18.TString;
+  group: typebox18.TOptional<typebox18.TString>;
+  path: typebox18.TString;
+  method: typebox18.TOptional<typebox18.TString>;
+  requestBodyType: typebox18.TOptional<typebox18.TString>;
+  service: typebox18.TOptional<typebox18.TString>;
 }>;
-declare const apiLinksResponseSchema: typebox0.TObject<{
-  prefix: typebox0.TOptional<typebox0.TString>;
-  links: typebox0.TArray<typebox0.TObject<{
-    name: typebox0.TString;
-    group: typebox0.TOptional<typebox0.TString>;
-    path: typebox0.TString;
-    method: typebox0.TOptional<typebox0.TString>;
-    requestBodyType: typebox0.TOptional<typebox0.TString>;
-    service: typebox0.TOptional<typebox0.TString>;
+declare const apiLinksResponseSchema: typebox18.TObject<{
+  prefix: typebox18.TOptional<typebox18.TString>;
+  links: typebox18.TArray<typebox18.TObject<{
+    name: typebox18.TString;
+    group: typebox18.TOptional<typebox18.TString>;
+    path: typebox18.TString;
+    method: typebox18.TOptional<typebox18.TString>;
+    requestBodyType: typebox18.TOptional<typebox18.TString>;
+    service: typebox18.TOptional<typebox18.TString>;
   }>>;
 }>;
 type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
@@ -81,7 +81,7 @@ declare class LinkProvider {
   protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
 }
 interface HttpClientLink extends ApiLink {
-  secured?: boolean;
+  secured?: boolean | ServerRouteSecure;
   prefix?: string;
   host?: string;
   service?: string;
@@ -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
@@ -257,15 +257,15 @@ declare class ServerLinksProvider {
    * This is based on the user's permissions.
    */
   readonly links: _alepha_server0.RouteDescriptor<{
-    response: typebox0.TObject<{
-      prefix: typebox0.TOptional<typebox0.TString>;
-      links: typebox0.TArray<typebox0.TObject<{
-        name: typebox0.TString;
-        group: typebox0.TOptional<typebox0.TString>;
-        path: typebox0.TString;
-        method: typebox0.TOptional<typebox0.TString>;
-        requestBodyType: typebox0.TOptional<typebox0.TString>;
-        service: typebox0.TOptional<typebox0.TString>;
+    response: typebox18.TObject<{
+      prefix: typebox18.TOptional<typebox18.TString>;
+      links: typebox18.TArray<typebox18.TObject<{
+        name: typebox18.TString;
+        group: typebox18.TOptional<typebox18.TString>;
+        path: typebox18.TString;
+        method: typebox18.TOptional<typebox18.TString>;
+        requestBodyType: typebox18.TOptional<typebox18.TString>;
+        service: typebox18.TOptional<typebox18.TString>;
       }>>;
     }>;
   }>;
@@ -276,10 +276,10 @@ declare class ServerLinksProvider {
    * I mean for 150+ links, you got 50ms of serialization time.
    */
   readonly schema: _alepha_server0.RouteDescriptor<{
-    params: typebox0.TObject<{
-      name: typebox0.TString;
+    params: typebox18.TObject<{
+      name: typebox18.TString;
     }>;
-    response: typebox0.TRecord<string, typebox0.TAny>;
+    response: typebox18.TRecord<string, typebox18.TAny>;
   }>;
   getSchemaByName(name: string, options?: GetApiLinksOptions): Promise<RequestConfigSchema>;
   /**

package/server/security.d.ts

@@ -13,6 +13,7 @@ declare class ServerSecurityProvider {
   protected readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
   protected readonly onActionRequest: _alepha_core1.HookDescriptor<"action:onRequest">;
   protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  protected check(user: UserAccountToken, secure: ServerRouteSecure): void;
   /**
    * Get the user account token for a local action call.
    * There are three possible sources for the user:
@@ -30,11 +31,8 @@ declare class ServerSecurityProvider {
   protected createTestUser(): UserAccountToken;
   protected readonly onClientRequest: _alepha_core1.HookDescriptor<"client:onRequest">;
 }
-type ServerRouteSecure = boolean | {
-  permissions?: string[];
-  roles?: string[];
-  realms?: string[];
-  organizations?: string[];
+type ServerRouteSecure = {
+  realm?: string;
 };
 //#endregion
 //#region src/index.d.ts
@@ -62,7 +60,7 @@ declare module "alepha/server" {
      * 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;
+    secure?: boolean | ServerRouteSecure;
   }
   interface ClientRequestOptions extends FetchOptions {
     /**

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

@@ -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>;
-}
-type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
-interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
+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$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
@@ -179,6 +189,7 @@ declare class ServerTimingProvider {
   protected readonly log: _alepha_logger3.Logger;
   protected readonly alepha: Alepha;
   options: {
+    prefix: string;
     disabled: boolean;
   };
   readonly onRequest: _alepha_core11.HookDescriptor<"server:onRequest">;
@@ -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,9 +549,9 @@ 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>> {
+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;
 }
@@ -732,8 +743,6 @@ declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly server: http0.Server<typeof IncomingMessage, typeof ServerResponse$1>;
   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_core11.HookDescriptor<"start">;
   protected readonly stop: _alepha_core11.HookDescriptor<"stop">;
@@ -815,6 +824,10 @@ declare module "alepha" {
       req: IncomingMessage;
       res: ServerResponse$1;
     };
+    "web:request": {
+      req: Request;
+      res?: Response;
+    };
   }
 }
 /**

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]; }
+	});
+});