alepha 0.15.0 → 0.15.2

package/dist/server/core/index.d.ts

@@ -1,13 +1,13 @@
 import * as alepha19 from "alepha";
 import { Alepha, AlephaError, Async, CompiledEventExecutor, FileLike, Hooks, KIND, Primitive, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import * as alepha_logger4 from "alepha/logger";
+import * as alepha_logger6 from "alepha/logger";
 import { Readable } from "node:stream";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 import { ReadableStream } from "node:stream/web";
 import { Route, RouterProvider } from "alepha/router";
 import * as alepha_cache0 from "alepha/cache";
-import * as node_http0 from "node:http";
 import { IncomingMessage, Server, ServerResponse as ServerResponse$1 } from "node:http";
+import { Socket } from "node:net";
 
 //#region ../../src/server/core/schemas/errorSchema.d.ts
 declare const errorSchema: alepha19.TObject<{
@@ -59,20 +59,20 @@ declare class ServerReply {
   status?: number;
   body?: any;
   /**
-       * Redirect to a given URL with optional status code (default 301).
-       */
+   * Redirect to a given URL with optional status code (default 301).
+   */
   redirect(url: string, status?: number): void;
   /**
-       * Set the response status code.
-       */
+   * Set the response status code.
+   */
   setStatus(status: number): this;
   /**
-       * Set a response header.
-       */
+   * Set a response header.
+   */
   setHeader(name: string, value: string): this;
   /**
-       * Set the response body.
-       */
+   * Set the response body.
+   */
   setBody(body: any): this;
 }
 //#endregion
@@ -111,73 +111,103 @@ interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfi
 type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
 interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
   /**
-       * HTTP method used for this request.
-       */
+   * HTTP method used for this request.
+   */
   method: RouteMethod;
   /**
-       * Full request URL.
-       */
+   * Full request URL.
+   */
   url: URL;
   /**
-       * Unique request ID assigned to this request.
-       */
+   * Unique request ID assigned to this request.
+   */
   requestId: string;
   /**
-       * Client IP address.
-       * Will parse `X-Forwarded-For` header if present.
-       */
+   * Client IP address.
+   * Uses `X-Forwarded-For` header when `TRUST_PROXY=true`.
+   */
   ip?: string;
   /**
-       * Value of the `Host` header sent by the client.
-       */
+   * 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}
-       */
+   * 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.
-       */
+   * Geolocation information derived from proxy headers.
+   * Available when behind Cloudflare, Vercel, or similar CDNs.
+   */
+  geo: RequestGeo;
+  /**
+   * Whether the request appears to be from a bot/crawler.
+   * Based on user-agent analysis.
+   */
+  isBot: boolean;
+  /**
+   * Whether the request is from a mobile device.
+   * Based on user-agent analysis.
+   */
+  isMobile: boolean;
+  /**
+   * Request protocol (http or https).
+   * Uses `X-Forwarded-Proto` header when behind a proxy.
+   */
+  protocol: "http" | "https";
+  /**
+   * Preferred language from `Accept-Language` header.
+   * Returns the first/most preferred language code (e.g., "en", "fr", "en-US").
+   */
+  language?: string;
+  /**
+   * Parsed referer information.
+   * Undefined if no Referer header or invalid URL.
+   */
+  referer?: RequestReferer;
+  /**
+   * 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 object to be used to send response.
+   */
   reply: ServerReply;
   /**
-       * The raw underlying request object (Web Request).
-       */
+   * The raw underlying request object (Web Request).
+   */
   raw: ServerRawRequest;
 }
 interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
   /**
-       * Handler function for this route.
-       */
+   * Handler function for this route.
+   */
   handler: ServerHandler<TConfig>;
   /**
-       * HTTP method for this route.
-       */
+   * 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.
-       */
+   * 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
-       */
+   * @see ServerLoggerProvider
+   */
   silent?: boolean;
 }
 type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
@@ -213,21 +243,75 @@ interface WebRequestEvent {
   req: Request;
   res?: Response;
 }
+/**
+ * Geolocation information from proxy headers (Cloudflare, Vercel, etc.)
+ */
+interface RequestGeo {
+  /**
+   * ISO 3166-1 alpha-2 country code (e.g., "US", "FR", "JP").
+   */
+  country?: string;
+  /**
+   * City name (e.g., "San Francisco", "Paris").
+   */
+  city?: string;
+  /**
+   * Region/state (e.g., "California", "Île-de-France").
+   */
+  region?: string;
+  /**
+   * Latitude (if available).
+   */
+  latitude?: string;
+  /**
+   * Longitude (if available).
+   */
+  longitude?: string;
+}
+/**
+ * Parsed referer information.
+ */
+interface RequestReferer {
+  /**
+   * Full referer URL.
+   */
+  url: string;
+  /**
+   * Hostname of the referer (e.g., "google.com").
+   */
+  hostname: string;
+  /**
+   * Path of the referer URL.
+   */
+  pathname: string;
+}
 //#endregion
 //#region ../../src/server/core/services/ServerRequestParser.d.ts
 declare class ServerRequestParser {
   protected readonly alepha: Alepha;
   protected readonly userAgentParser: UserAgentParser;
+  protected readonly env: {
+    TRUST_PROXY: boolean;
+  };
   createServerRequest(rawRequest: ServerRequestData): ServerRequest;
   getRequestId(request: ServerRequestData): string | undefined;
   getRequestUserAgent(request: ServerRequestData): UserAgentInfo;
   getRequestIp(request: ServerRequestData): string | undefined;
+  protected getConnectionIp(request: ServerRequestData): string | undefined;
+  getRequestGeo(request: ServerRequestData): RequestGeo;
+  protected static readonly BOT_PATTERNS: RegExp[];
+  getIsBot(request: ServerRequestData): boolean;
+  protected static readonly MOBILE_PATTERNS: RegExp[];
+  getIsMobile(request: ServerRequestData): boolean;
+  getProtocol(request: ServerRequestData): "http" | "https";
+  getLanguage(request: ServerRequestData): string | undefined;
+  getReferer(request: ServerRequestData): RequestReferer | undefined;
 }
 //#endregion
 //#region ../../src/server/core/providers/ServerTimingProvider.d.ts
 type TimingMap = Record<string, [number, number]>;
 declare class ServerTimingProvider {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   options: {
     prefix: string;
@@ -251,7 +335,7 @@ declare class ServerTimingProvider {
  * - $page => React route (for React SSR)
  */
 declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   protected readonly routes: ServerRoute[];
   protected readonly serverTimingProvider: ServerTimingProvider;
@@ -269,39 +353,39 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
   protected readonly processRequestBound: () => Promise<any>;
   protected readonly queryKeysCache: WeakMap<object, string[]>;
   /**
-       * Get cached keys for a query schema, computing them lazily on first access.
-       */
+   * Get cached keys for a query schema, computing them lazily on first access.
+   */
   protected getQuerySchemaKeys(schema: {
     properties: object;
   }): string[];
   /**
-       * Compile event executors for optimal performance.
-       * Called lazily on first request after all hooks are registered.
-       */
+   * Compile event executors for optimal performance.
+   * Called lazily on first request after all hooks are registered.
+   */
   protected compileEvents(): void;
   /**
-       * 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.
-       */
+   * 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[];
   /**
-       * Create a new server route.
-       */
+   * Create a new server route.
+   */
   createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
   /**
-       * Get or generate a context ID from request headers.
-       */
+   * Get or generate a context ID from request headers.
+   */
   protected getContextId(headers: Record<string, string>): string;
   /**
-       * Process an incoming request through the full lifecycle:
-       * - onRequest hooks
-       * - route handler
-       * - onSend hooks
-       * - response serialization
-       * - onResponse hooks
-       */
+   * Process an incoming request through the full lifecycle:
+   * - onRequest hooks
+   * - route handler
+   * - onSend hooks
+   * - response serialization
+   * - onResponse hooks
+   */
   protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
     status: number;
     headers: Record<string, string> & {
@@ -310,24 +394,24 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     body: any;
   }>;
   /**
-       * Run the route handler with request validation and response serialization.
-       */
+   * Run the route handler with request validation and response serialization.
+   */
   protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
   /**
-       * Transform reply body based on response kind and route schema.
-       */
+   * Transform reply body based on response kind and route schema.
+   */
   serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
   /**
-       * Determine response type based on route schema.
-       */
+   * Determine response type based on route schema.
+   */
   protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
   /**
-       * When an error occurs during request processing, this method is called.
-       */
+   * When an error occurs during request processing, this method is called.
+   */
   protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
   /**
-       * Validate incoming request against route schema.
-       */
+   * Validate incoming request against route schema.
+   */
   validateRequest(route: {
     schema?: RequestConfigSchema;
   }, request: ServerRequestConfig): void;
@@ -342,7 +426,7 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
  * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
  */
 declare class ServerProvider {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly router: ServerRouterProvider;
@@ -363,51 +447,47 @@ declare class ServerProvider {
   }>;
   protected readonly urlBaseCache: Map<string, string>;
   /**
-       * Get cached URL base (protocol + host) for a given host header.
-       * Caches the result to avoid repeated string concatenation.
-       */
+   * Get cached URL base (protocol + host) for a given host header.
+   * Caches the result to avoid repeated string concatenation.
+   */
   protected getUrlBase(headers: Record<string, string>): string;
   /**
-       * Parse query string manually - faster than new URL() + URLSearchParams.
-       * Returns empty object if no query string.
-       */
+   * Parse query string manually - faster than new URL() + URLSearchParams.
+   * Returns empty object if no query string.
+   */
   protected parseQueryString(rawUrl: string): Record<string, string>;
   /**
-       * Fast decode - only calls decodeURIComponent if needed.
-       */
+   * Fast decode - only calls decodeURIComponent if needed.
+   */
   protected fastDecode(str: string): string;
-  /**
-       * Extract pathname from URL without creating URL object.
-       */
-  protected getPathname(rawUrl: string): string;
   get hostname(): string;
   /**
-       * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
-       */
+   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
+   */
   protected readonly onNodeRequest: alepha19.HookPrimitive<"node:request">;
   /**
-       * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
-       */
+   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
+   */
   protected readonly onWebRequest: alepha19.HookPrimitive<"web:request">;
   /**
-       * Handle Node.js HTTP request event.
-       *
-       * Optimized to avoid expensive URL parsing when possible.
-       */
+   * Handle Node.js HTTP request event.
+   *
+   * Optimized to avoid expensive URL parsing when possible.
+   */
   handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
   /**
-       * Handle Web (Fetch API) request event.
-       */
+   * Handle Web (Fetch API) request event.
+   */
   handleWebRequest(ev: WebRequestEvent): Promise<void>;
   /**
-       * Helper for Vite development mode to let Vite handle (or not) 404.
-       */
+   * 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 ../../src/server/core/services/HttpClient.d.ts
 declare class HttpClient {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   readonly cache: alepha_cache0.CachePrimitiveFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
@@ -431,18 +511,18 @@ declare class HttpClient {
 }
 interface FetchOptions<T extends TSchema = TSchema> {
   /**
-       * Key to identify the request in the pending requests.
-       */
+   * Key to identify the request in the pending requests.
+   */
   key?: string;
   /**
-       * The schema to validate the response against.
-       */
+   * The schema to validate the response against.
+   */
   schema?: {
     response?: T;
   };
   /**
-       * Built-in cache options.
-       */
+   * Built-in cache options.
+   */
   localCache?: boolean | number | DurationLike;
 }
 type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
@@ -558,72 +638,72 @@ declare const $action: {
 };
 interface ActionPrimitiveOptions<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 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 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.
-       */
+   * 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.)
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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!
-       */
+   * 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.
-       */
+   * Main route handler. This is where the route logic is implemented.
+   */
   handler: ServerActionHandler<TConfig>;
 }
 declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primitive<ActionPrimitiveOptions<TConfig>> {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
   };
@@ -634,33 +714,33 @@ declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primi
   get prefix(): string;
   get route(): ServerRoute;
   /**
-       * Returns the name of the action.
-       */
+   * Returns the name of the action.
+   */
   get name(): string;
   /**
-       * Returns the group of the action. (e.g. "orders", "admin", etc.)
-       */
+   * Returns the group of the action. (e.g. "orders", "admin", etc.)
+   */
   get group(): string;
   /**
-       * Returns the HTTP method of the action.
-       */
+   * Returns the HTTP method of the action.
+   */
   get method(): RouteMethod;
   /**
-       * Returns the path of the action.
-       *
-       * Path is prefixed by `/api` by default.
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * Works like `run`, but always fetches (http request) the route.
+   */
   fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
 }
 interface ActionPrimitiveFn<TConfig extends RequestConfigSchema> extends ActionPrimitive<TConfig> {
@@ -668,16 +748,17 @@ interface ActionPrimitiveFn<TConfig extends RequestConfigSchema> extends ActionP
 }
 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;
+  body: TConfig["body"] extends TRequestBody ? 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;
+  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
+  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : Record<string, string>;
 };
 interface ClientRequestOptions extends FetchOptions {
   /**
-       * Standard request fetch options.
-       */
+   * Standard request fetch options.
+   */
   request?: RequestInit;
+  query?: Record<string, string | number | boolean>;
 }
 type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
 /**
@@ -771,7 +852,7 @@ declare module "alepha" {
 declare class BunHttpServerProvider extends ServerProvider {
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly env: {
     SERVER_PORT: number;
     SERVER_HOST: string;
@@ -796,14 +877,33 @@ declare module "alepha" {
 declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly env: {
     SERVER_PORT: number;
     SERVER_HOST: string;
   };
   protected readonly router: ServerRouterProvider;
+  /**
+   * Track active connections for fast shutdown.
+   */
+  protected readonly connections: Set<Socket>;
+  /**
+   * Get number of active connections.
+   */
+  getConnectionsCount(): number;
+  /**
+   * Server options.
+   */
+  readonly options: {
+    /**
+     * Graceful shutdown timeout in ms.
+     * After this, remaining connections are forcefully closed.
+     * @default 30000
+     */
+    shutdownTimeout: number;
+  };
   get hostname(): string;
-  protected readonly handleRequestError: (res: node_http0.ServerResponse, err: Error) => void;
+  protected readonly handleRequestError: (res: ServerResponse$1, err: Error) => void;
   protected readonly nodeRequestEvent: {
     req: IncomingMessage;
     res: ServerResponse$1;
@@ -814,11 +914,12 @@ declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly stop: alepha19.HookPrimitive<"stop">;
   protected listen(): Promise<void>;
   protected close(): Promise<void>;
+  protected destroyAllConnections(): void;
 }
 //#endregion
 //#region ../../src/server/core/providers/ServerLoggerProvider.d.ts
 declare class ServerLoggerProvider {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   readonly onRequest: alepha19.HookPrimitive<"server:onRequest">;
   readonly onError: alepha19.HookPrimitive<"server:onError">;
@@ -894,17 +995,27 @@ declare module "alepha" {
   }
 }
 /**
- * Provides high-performance HTTP server capabilities with declarative routing and action primitives.
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | backend | epic | stable |
  *
- * The server module enables building REST APIs and web applications using `$route` and `$action` primitives
- * on class properties. It provides automatic request/response handling, schema validation, middleware support,
- * and seamless integration with other Alepha modules for a complete backend solution.
+ * Convention-driven HTTP server with automatic validation and type inference.
+ *
+ * **Features:**
+ * - Type-safe API endpoints with schema validation
+ * - Lower-level HTTP route definitions
+ * - Automatic request/response validation via TypeBox
+ * - Convention-based URL generation (`/api/{ActionName}`)
+ * - Direct invocation (`run()`) or HTTP (`fetch()`)
+ * - Built-in authentication integration
+ * - Multipart file upload handling
+ * - Content-type auto-negotiation (JSON, form-data, text)
+ * - HTTP methods: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
+ * - Error handling: BadRequestError, ValidationError, ForbiddenError, UnauthorizedError, ConflictError, NotFoundError
  *
- * @see {@link $route}
- * @see {@link $action}
  * @module alepha.server
  */
 declare const AlephaServer: alepha19.Service<alepha19.Module>;
 //#endregion
-export { $action, $route, ActionPrimitive, ActionPrimitiveFn, ActionPrimitiveOptions, AlephaServer, BadRequestError, BunHttpServerProvider, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NodeRequestEvent, NotFoundError, Ok, RequestConfigSchema, RequestInitWithOptions, ResponseBodyType, ResponseKind, RouteMethod, RoutePrimitive, RoutePrimitiveOptions, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerRequestData, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, UserAgentInfo, UserAgentParser, ValidationError, WebRequestEvent, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
+export { $action, $route, ActionPrimitive, ActionPrimitiveFn, ActionPrimitiveOptions, AlephaServer, BadRequestError, BunHttpServerProvider, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NodeRequestEvent, NotFoundError, Ok, RequestConfigSchema, RequestGeo, RequestInitWithOptions, RequestReferer, ResponseBodyType, ResponseKind, RouteMethod, RoutePrimitive, RoutePrimitiveOptions, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerRequestData, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, UserAgentInfo, UserAgentParser, ValidationError, WebRequestEvent, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
 //# sourceMappingURL=index.d.ts.map