@nodefony/http 10.0.0-alpha.1

package/dist/types/nodefony/service/http-kernel.d.ts

@@ -0,0 +1,377 @@
+import { Service, Module, Scope, EnvironmentType, DebugType, nodefonyError } from "nodefony";
+import type { Resolver, Router } from "@nodefony/framework";
+import type { Controller } from "@nodefony/framework";
+import HttpError from "../src/errors/httpError.js";
+import { type TrustProxyChecker } from "../src/context/trustProxy.js";
+import type { IRateLimitStore } from "../src/rateLimit/IRateLimitStore.js";
+import { type TrustedHostsConfig } from "../src/context/domainMatcher.js";
+import http from "node:http";
+import http2 from "node:http2";
+import type { IncomingMessage } from "node:http";
+import Ws from "ws";
+import httpServer from "../service/servers/server-http.js";
+import httpsServer from "../service/servers/server-https.js";
+import websocketServer from "../service/servers/server-websocket.js";
+import websocketSecureServer from "../service/servers/server-websocket-secure.js";
+import Statics from "./servers/server-static.js";
+import WebsocketContext from "../src/context/websocket/WebsocketContext.js";
+import HttpContext from "../src/context/http/HttpContext.js";
+import Context, { HTTPMethod, WebSocketState } from "../src/context/Context.js";
+import Certicates from "./certificates.js";
+import SessionsService from "./sessions/sessions-service.js";
+import Session from "../src/session/session.js";
+import { Firewall } from "@nodefony/security";
+import type { IErrorRenderer } from "../interfaces/IErrorRenderer.js";
+import type { IRequestLogger } from "../interfaces/IRequestLogger.js";
+export type ProtocolType = "1.1" | "2.0" | "3.0";
+export type httpRequest = http.IncomingMessage | http2.Http2ServerRequest;
+export type httpResponse = http.ServerResponse | http2.Http2ServerResponse;
+export type ContextType = WebsocketContext | HttpContext | Context;
+export type ServerType = "http" | "https" | "http2" | "http3" | "websocket" | "websocket-secure";
+export type responseTimeoutType = "http" | "https" | "http2" | "http3";
+export type SchemeType = "http" | "https" | "ws" | "wss";
+export interface WsMetaData {
+    type?: "message" | "handshake";
+    state?: WebSocketState;
+    messageType?: "utf8" | "binary";
+    protocol?: string | null;
+    id?: string;
+}
+/**
+ * Vue minimale d'une route exposée dans l'enveloppe `nodefony.route` (frame WS
+ * + réponse JSON). Volontairement découplée de la classe `Route` de
+ * `@nodefony/framework` : on ne diffuse PAS l'instance partagée (statique) —
+ * seulement un snapshot per-requête. Casse aussi l'import valeur runtime
+ * `http → framework` (cycle).
+ */
+export interface RouteMetaData {
+    name: string;
+    path?: string;
+    variablesMap: Record<string, unknown>;
+}
+export interface MetaData {
+    name?: string;
+    version?: string;
+    url?: URL | string;
+    environment?: EnvironmentType;
+    debug?: DebugType;
+    token?: string;
+    method?: HTTPMethod;
+    scheme?: SchemeType;
+    requestId?: string;
+    websocket?: WsMetaData;
+    route?: RouteMetaData;
+}
+export interface Data {
+    error?: Error;
+    nodefony: MetaData;
+    message?: unknown;
+    code?: number;
+    result: unknown;
+}
+import type { IHttpKernel as IHttpKernelInterface } from "../interfaces/IHttpKernel.js";
+declare class HttpKernel extends Service implements IHttpKernelInterface {
+    #private;
+    certificates: unknown;
+    serviceCerticats: Certicates | null;
+    key: string;
+    cert: string;
+    ca: string;
+    serverStatic: Statics | null;
+    domain: string;
+    trustedHosts?: TrustedHostsConfig;
+    domainCheck: boolean;
+    regAlias: RegExp[];
+    module: Module;
+    httpsPort?: number;
+    httpPort?: number;
+    responseTimeout: {
+        http: number;
+        https: number;
+        http2: number;
+        http3: number;
+    };
+    closeTimeOutWs: {
+        ws: number;
+        wss: number;
+    };
+    private secContentTypeOptions;
+    private secFrameOptions;
+    private secHsts;
+    sessionService?: SessionsService | null;
+    router?: Router | null;
+    firewall?: Firewall | null;
+    private errorRenderer;
+    private requestLogger;
+    private profiler;
+    private _trustProxyChecker;
+    private _wsOriginPolicy;
+    private rateLimiter;
+    private rateLimitGc;
+    constructor(module: Module);
+    /**
+     * (Re)calcule les caches dérivés des en-têtes de sécurité depuis `this.options`
+     * — au boot ET à chaque édition live ({@link onConfigChanged}). Lus tels quels
+     * dans `onHttpRequest` (0 alloc/concat par requête).
+     */
+    private computeSecurityHeaderCaches;
+    /**
+     * Ce que ce kernel ÉMET réellement comme en-têtes de sécurité transport.
+     *
+     * Ces trois en-têtes (HSTS, X-Frame-Options, X-Content-Type-Options) sont posés
+     * ici, à l'entrée brute, pour couvrir aussi les statiques et les pages d'erreur
+     * — pas par `@nodefony/security`, dont les clés homonymes sont inertes. Toute
+     * console d'administration doit donc lire CE point, sinon elle affiche une
+     * intention de configuration au lieu de l'état appliqué.
+     *
+     * Lu depuis les caches recalculés au boot ET à chaque édition live
+     * ({@link onConfigChanged}) : la valeur rendue suit la config à chaud.
+     *
+     * @returns les valeurs d'en-tête, `null` quand l'en-tête n'est pas émis.
+     */
+    describeTransportSecurityHeaders(): {
+        strictTransportSecurity: string | null;
+        frameOptions: string | null;
+        contentTypeOptions: string | null;
+    };
+    /**
+     * Hook appelé par le data plane admin APRÈS une édition LIVE de la config
+     * (`PATCH /nodefony/kernel/api/config/http`, dev only). Recompute les valeurs
+     * DÉRIVÉES mises en cache (en-têtes sécurité, checker trust-proxy, trustedHosts) :
+     * sans lui, l'édition d'un champ `runtimeMutable` porté par un cache serait
+     * ignorée. Les champs lus DIRECTEMENT depuis `options` (`headerServer`,
+     * `maxBodySize`) n'en ont pas besoin — l'appel reste idempotent et bon marché.
+     */
+    onConfigChanged(): void;
+    /**
+     * (Re)configure le rate-limit général par IP depuis `options.rateLimit` — au
+     * boot (`onReady`) ET à chaque édition live ({@link onConfigChanged}). Désarme
+     * le GC précédent puis reconstruit compteur + scheduler UNIQUEMENT si
+     * `enabled` ; sinon `rateLimiter` reste `null` → 0 coût sur le hot path.
+     */
+    /**
+     * Compteur de rate-limit actif, ou `null` s'il est désactivé — surface de
+     * LECTURE pour le data plane admin (introspection des IP suivies). `null` est
+     * l'information « fonction désarmée », pas une erreur : l'appelant l'affiche
+     * tel quel plutôt que d'inventer un état.
+     */
+    get rateLimitStore(): IRateLimitStore | null;
+    private configureRateLimit;
+    /**
+     * (Re)configure le backstop OPT-IN de connexions WS concurrentes par IP (F6c)
+     * depuis `options.wsMaxConnectionsPerIp` — au boot ET à l'édition live. `null` (ou
+     * ≤ 0) = désactivé → `#wsConnCounter` reste `null` (0 alloc / 0 tracking, cas
+     * cloud-native par défaut : le cap concurrent est délégué à l'ingress). Reconstruit
+     * un compteur neuf : les sockets déjà ouvertes décrémentent l'ancienne instance
+     * (capturée dans leur closure de fermeture) → pas de dérive sur la nouvelle.
+     */
+    private configureWsConnectionLimit;
+    /**
+     * (Re)configure les probes de santé `/livez` + `/readyz` depuis
+     * `options.health` — au boot (`onReady`) ET à l'édition live. `enabled:false`
+     * → `#healthPaths` reste `null` (0 coût sur le hot path).
+     */
+    private configureHealth;
+    init(): Promise<this>;
+    /**
+     * Checker de confiance reverse-proxy, compilé une seule fois depuis
+     * `options.trustProxy` (lazy — pas de `BlockList` allouée par requête).
+     * Consommé par `HttpRequest`/`HttpContext` pour décider de l'adoption des
+     * en-têtes `X-Forwarded-*`.
+     *
+     * @returns le {@link TrustProxyChecker} partagé.
+     */
+    getTrustProxyChecker(): TrustProxyChecker;
+    /**
+     * Politique d'Origin WS (B4) compilée paresseusement pour un type de serveur
+     * (`websocket` / `websocketSecure`), depuis `options.<type>.allowedOrigins` :
+     *  - `true` → contrôle désactivé (`disabled`) ;
+     *  - `false` (défaut) → same-origin seul (`extra` vide) ;
+     *  - string/liste → Origins cross-origin additionnelles (compilées en RegExp).
+     *
+     * @param cfgKey - `"websocket"` ou `"websocketSecure"`.
+     * @returns la politique mémoïsée (0 alloc après le 1er handshake).
+     */
+    private getWsOriginPolicy;
+    /**
+     * B4 — Validation d'`Origin` au handshake WebSocket (anti-CSWSH, OWASP
+     * WSTG-CLNT-10). Les navigateurs n'appliquent PAS CORS aux WebSockets : sans
+     * ce contrôle, une page tierce peut ouvrir un WS **authentifié par le cookie de
+     * session de la victime** (reprise L1). On exige donc, par défaut, que
+     * l'`Origin` du handshake corresponde au `Host` servi (same-origin), avec
+     * tolérance loopback en development (Studio Vite cross-port) et allowlist
+     * explicite pour les SPA cross-origin (`allowedOrigins`).
+     *
+     * Une requête SANS `Origin` (client non-navigateur) est acceptée : un attaquant
+     * non-navigateur n'a pas besoin de CSWSH, il se connecte directement.
+     *
+     * @param context - contexte WebSocket au handshake (avant `connect()`).
+     * @throws {HttpError} code WS 1008 (Policy Violation) si l'Origin est refusée.
+     */
+    checkWebsocketOrigin(context: WebsocketContext): void;
+    /**
+     * Reads the **kernel-level** syslog config (`kernel.options.log`) and swaps
+     * the request logger accordingly. The decision belongs to syslog (not to
+     * the http module) because EVERY request log flows through syslog, and
+     * the format choice is an operator concern shared across all transports.
+     *
+     * Config lue : `kernel.options.log.requestFormat`
+     *   "auto"    → dev=pretty, production=json, autre=default (DEFAULT)
+     *   "default" → DefaultRequestLogger (legacy verbeux)
+     *   "pretty"  → PrettyRequestLogger (1 ligne colorée, P3.2)
+     *   "json"    → JsonAuditLogger (PDU canonique, P3.1)
+     *
+     * Programmatic override via `setRequestLogger(custom)` reste possible et
+     * gagne toujours sur la config (idempotent — last setter wins).
+     */
+    private applyRequestLoggerFromConfig;
+    handle(request: httpRequest, response: httpResponse | null, type: ServerType): Promise<HttpContext>;
+    /**
+     * Arme le contexte pour l'exécution : zone firewall (`context.secure`) et
+     * résolveur de route — **sans instancier le controller**.
+     *
+     * Séparé de {@link handleFrontController} parce que les deux gestes n'ont pas
+     * le même moment légitime. Le MATCH doit être précoce : il pose
+     * `context.sessionIntent` (depuis `@UseSession`) et `resolver.bypassFirewall`,
+     * que le point session unique et le firewall lisent juste après. L'INSTANCE,
+     * elle, exécute du code utilisateur (`initialize()`) et résout des dépendances
+     * DI : elle n'a rien à faire avant que la requête soit autorisée.
+     *
+     * @param checkFirewall - calcule `context.secure` (zone protégée) ; laissé à
+     *   `false` par un appelant qui l'a déjà tranché.
+     * @throws HttpError 404 quand aucune route ne matche, ou l'exception portée
+     *   par le résolveur (405…) — inchangé, et toujours avant le firewall : une
+     *   route inexistante ne devient pas un 401.
+     */
+    prepareFrontController(context: ContextType, checkFirewall?: boolean): Promise<Resolver>;
+    /**
+     * {@link prepareFrontController} + instanciation immédiate du controller
+     * (DI + hook `initialize()`).
+     *
+     * @remarks Réservé au **WebSocket** : le controller doit exister avant
+     *   `context.connect()`, puisqu'il porte le protocole négocié et peut encore
+     *   toucher la réponse du handshake (cookies, en-têtes) — après l'accept, il
+     *   est trop tard. Le HTTP, lui, arme la route ici et laisse
+     *   `Resolver.executeAction` créer l'instance une fois la requête autorisée.
+     */
+    handleFrontController(context: ContextType, checkFirewall?: boolean): Promise<Controller>;
+    /**
+     * Handles errors by setting appropriate response codes and messages.
+     *
+     * @param error - The error object, which can be of type Error, HttpError, or nodefonyError.
+     * @param context - Optional context parameter, which can be of type ContextType.
+     * @param extraHeaders - Optional additional headers to be included in the response.
+     * @returns A promise that resolves to either HttpContext or WebsocketContext.
+     *
+     * WebSocket error codes and their meanings:
+     *  - code >= 1000 && code <= 2999:
+     *    - 1000: Normal connection closure
+     *    - 1001: Remote peer is going away
+     *    - 1002: Protocol error
+     *    - 1003: Unprocessable input
+     *    - 1004: Reserved
+     *    - 1005: Reason not provided
+     *    - 1006: Abnormal closure, no further detail available
+     *    - 1007: Invalid data received
+     *    - 1008: Policy violation
+     *    - 1009: Message too big
+     *    - 1010: Extension requested by client is required
+     *    - 1011: Internal Server Error
+     *    - 1015: TLS Handshake Failed
+     *  - code >= 3000 && code <= 3999:
+     *    Reserved for use by libraries, frameworks, and applications.
+     *    Should be registered with IANA. Interpretation of these codes is
+     *    undefined by the WebSocket protocol.
+     *  - code >= 4000 && code <= 4999:
+     *    Reserved for private use. Interpretation of these codes is
+     *    undefined by the WebSocket protocol.
+     */
+    /**
+     * Override the default error renderer — e.g. to hide stack traces in prod
+     * or emit RFC 7807 problem+json. Stateless singleton expected.
+     */
+    setErrorRenderer(renderer: IErrorRenderer): void;
+    getErrorRenderer(): IErrorRenderer;
+    /**
+     * Override the default per-request logger — JSON access log, NCSA combined,
+     * pretty single-line formatter, etc. Stateless singleton expected.
+     */
+    setRequestLogger(logger: IRequestLogger): void;
+    getRequestLogger(): IRequestLogger;
+    onError(error: Error | HttpError | nodefonyError, context?: ContextType, _extraHeaders?: Record<string, unknown> | object): Promise<HttpContext | WebsocketContext>;
+    compileAlias(): RegExp[];
+    onHttpRequest(request: httpRequest, response: httpResponse, type: ServerType): Promise<unknown>;
+    initServers(): Promise<(httpServer | httpsServer | websocketServer | websocketSecureServer)[]>;
+    /**
+     * Publie les ports EFFECTIFS du runtime (state file), une fois l'écoute établie.
+     *
+     * C'est le canal qui rend `servers.portPolicy: "auto"` utilisable : `nodefony
+     * status`, `nodefony stop` et la readiness `--detach` sondaient `[5151, 5152]`
+     * **en dur**. Dès qu'un port glisse, cette convention ment — ils sonderaient un
+     * port que personne n'écoute et conclueraient « serveur down » sur un serveur
+     * parfaitement vivant. Ici, la topologie réelle est écrite noir sur blanc.
+     *
+     * Le port DÉSIRÉ est publié à côté du port obtenu : un outil peut ainsi dire
+     * « tu voulais 5151, tu écoutes sur 5153 » sans deviner.
+     *
+     * **Publié dans TOUS les environnements, production comprise.** Le glissement de
+     * port (`auto`) n'est pas la seule façon de sortir de la convention : une app qui
+     * déclare son port (PaaS `PORT`, ingress, `servers.http.port`) écoute ailleurs
+     * que `[5151, 5152]` **en `strict` aussi**. Sans ce canal, `production --detach
+     * --wait` sonderait la convention, ne verrait rien, et group-killerait au bout de
+     * son plafond un serveur qui écoutait parfaitement (faux négatif — même famille
+     * que « une liste de ports sondés est une CONVENTION, pas la topologie »).
+     * L'écriture est best-effort : un `node_modules` en lecture seule (image
+     * conteneur) ne fait jamais tomber un serveur qui, lui, écoute très bien.
+     *
+     * En **cluster**, le pid publié est celui du MASTER, pas du worker qui écrit :
+     * les workers sont recyclés (respawn), et un pid mort fait purger le canal par
+     * {@link readRuntimeState} — `status`/`stop` redeviendraient aveugles alors que
+     * l'app écoute toujours. Le master, lui, est le propriétaire du runtime.
+     */
+    private publishRuntimePorts;
+    /**
+     * Point d'activation UNIQUE de session — symétrique HTTP **et** WS. Ouvre une
+     * session si, et seulement si, la route la déclare (`context.sessionIntent`,
+     * posé par le Resolver depuis `@UseSession` / un paramètre `@Session`) **ou**
+     * si un cookie de session entrant existe déjà (reprise — L1). Sinon : aucune
+     * session (lazy). Remplace l'ancien `sessionAutoStart` global « démarre sur
+     * toutes les routes » (le moteur du ×23).
+     *
+     * @param context - contexte HTTP/HTTP2/WS courant.
+     * @returns la session active, ou `null` si la requête n'en requiert aucune.
+     */
+    startSession(context: WebsocketContext | HttpContext): Promise<Session | null>;
+    /**
+     * Teardown post-réponse — fire-and-forget depuis le `once("close")` posé par
+     * `createHttpContext` (un seul fire possible : once auto-détaché). Loggue la
+     * requête, draine les hooks afterResponse/onFinish, libère le scope DI.
+     */
+    private teardownHttp;
+    createHttpContext(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): HttpContext;
+    handleHttp(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): Promise<HttpContext>;
+    onRequestEnd(context: HttpContext, error?: Error | null | undefined): Promise<HttpContext | number>;
+    createWebsocketContext(scope: Scope, req: IncomingMessage, ws: Ws, type: ServerType): WebsocketContext;
+    onWebsocketRequest(ws: Ws, req: IncomingMessage, type: ServerType): Promise<unknown>;
+    handleWebsocket(scope: Scope, ws: Ws, req: IncomingMessage, type: ServerType): Promise<unknown>;
+    private releaseOrphanWsScope;
+    onConnect(context: WebsocketContext, error?: null | undefined | unknown): Promise<Ws | number>;
+    checkValidDomain(context: ContextType): number;
+    isValidDomain(context: ContextType): boolean;
+    /**
+     * Ce nom d'hôte franchit-il la barrière `trustedHosts` ? Même liste compilée
+     * que `isValidDomain`, mais interrogeable **sans contexte** — un module qui
+     * doit décider si un `Host` reçu est légitime (ex. `@nodefony/frontend`, qui
+     * en dérive l'origine des assets Vite) appelle CETTE méthode plutôt que de
+     * recompiler les motifs de son côté : deux copies divergeraient en silence.
+     *
+     * Résolution par NOM (`container.get("HttpKernel")`) chez l'appelant — aucun
+     * import de `@nodefony/http`, donc aucun cycle.
+     *
+     * @param hostname - nom d'hôte SANS port (`Context.domain`).
+     * @returns `true` si un motif de `trustedHosts` (ou le domaine canonique)
+     *   couvre ce nom.
+     */
+    isTrustedHostname(hostname: string): boolean;
+}
+export default HttpKernel;

package/dist/types/nodefony/service/pretty-request-logger.d.ts

@@ -0,0 +1,25 @@
+import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
+import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+/**
+ * Pretty single-line logger for dev (P3.2) — the biggest gain for humans.
+ *
+ * Format (no padding, ANSI-colored):
+ *   `GET 200 /api/test 12.3ms 127.0.0.1 [a1b2c3d4]`
+ *
+ * - method     : cyan
+ * - status     : green (2xx) / yellow (3xx) / yellow-bold (4xx) / red (5xx)
+ * - url        : default
+ * - duration   : dim
+ * - remote     : dim
+ * - requestId  : magenta-dim, truncated to first 8 chars
+ *
+ * Activate with `httpKernel.setRequestLogger(new PrettyRequestLogger())`.
+ *
+ * Stateless singleton. Allocates a few strings per request (terminal log
+ * path) — zero overhead when not activated.
+ */
+declare class PrettyRequestLogger implements IRequestLogger {
+    renderHttp(context: IHttpContext, error?: Error | null): IRequestLogEntry;
+    renderWebsocket(context: IWebsocketContext, error?: Error | null, acceptedProtocol?: string | null): IRequestLogEntry;
+}
+export default PrettyRequestLogger;

package/dist/types/nodefony/service/request-logger.d.ts

@@ -0,0 +1,18 @@
+import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
+import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+/**
+ * Default Nodefony per-request logger — preserves the legacy colored format.
+ *
+ * HTTP success: `URL : <url> FROM : <remote> ORIGIN : <host> ID : <uuid>`
+ * HTTP error:   adds the error toString (in dev), single-line in prod
+ * WebSocket:    adds `Accept-Protocol : <proto>` on success
+ *
+ * Stateless singleton — zero per-request allocation. Override via
+ * `httpKernel.setRequestLogger(custom)` for JSON access logs (P3.1),
+ * pretty formatter (P3.2), or NCSA combined format (P3.10).
+ */
+declare class DefaultRequestLogger implements IRequestLogger {
+    renderHttp(context: IHttpContext, error?: Error | null): IRequestLogEntry;
+    renderWebsocket(context: IWebsocketContext, error?: Error | null, acceptedProtocol?: string | null): IRequestLogEntry;
+}
+export default DefaultRequestLogger;

package/dist/types/nodefony/service/servers/clientError.d.ts

@@ -0,0 +1,14 @@
+import type { Duplex } from "node:stream";
+/**
+ * Gère l'event `clientError` d'un `http.Server` / `https.Server`.
+ *
+ * ⚠️ Doc Node (`http.Server` event `'clientError'`) : dès qu'un listener
+ * `clientError` est attaché, Node **cesse de fermer le socket automatiquement**
+ * (le défaut aurait répondu `400` + détruit le socket). Sans fermeture
+ * explicite, un socket malformé reste ouvert → fuite de socket/FD = DoS sur
+ * requête mal formée. On répond donc une réponse minimale et on ferme.
+ *
+ * @param error - erreur émise (codes `llhttp` : `HPE_*`, ou `ECONNRESET`…).
+ * @param socket - flux client brut (l'event `clientError` fournit un `Duplex`).
+ */
+export declare function handleClientError(error: NodeJS.ErrnoException, socket: Duplex): void;

package/dist/types/nodefony/service/servers/server-http.d.ts

@@ -0,0 +1,42 @@
+import { Service, Module, FamilyType } from "nodefony";
+import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
+import http from "node:http";
+import http2 from "node:http2";
+import { AddressInfo } from "node:net";
+import { HttpTerminator } from "./serverShutdown.js";
+declare class ServerHttp extends Service {
+    private httpKernel;
+    module: Module;
+    server: http.Server | http2.Http2Server | null;
+    httpTerminator: HttpTerminator | null;
+    port: number;
+    protocol: ProtocolType;
+    ready: boolean;
+    type: ServerType;
+    domain: string;
+    scheme: SchemeType;
+    address: string | null;
+    family: FamilyType | null;
+    active: boolean;
+    infos: AddressInfo | null;
+    constructor(module: Module, httpKernel: HttpKernel);
+    setPort(): number;
+    createServer(): Promise<http.Server | http2.Http2Server>;
+    /**
+     * Handler d'erreur DURABLE — posé une fois le serveur en écoute.
+     *
+     * Il ne traite donc plus `EADDRINUSE` au bind (le binder s'en charge, avec ou
+     * sans repli) : il couvre les erreurs de la VIE du serveur.
+     */
+    private attachErrorHandler;
+    /**
+     * Le bind a échoué pour de bon — soit `portPolicy: "strict"`, soit tous les
+     * ports de repli étaient pris, soit une erreur qui n'est pas un conflit de port.
+     *
+     * Reste FATAL (contrat inchangé) : un serveur qui n'écoute pas ne doit jamais
+     * laisser le process traîner en se croyant démarré.
+     */
+    private reportBindError;
+    showBanner(): void;
+}
+export default ServerHttp;

package/dist/types/nodefony/service/servers/server-https.d.ts

@@ -0,0 +1,41 @@
+import { Service, Module, FamilyType } from "nodefony";
+import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
+import https from "node:https";
+import http2 from "node:http2";
+import { HttpTerminator } from "./serverShutdown.js";
+import { AddressInfo } from "node:net";
+declare class ServerHttps extends Service {
+    private httpKernel;
+    httpTerminator: HttpTerminator | null;
+    module: Module;
+    server: https.Server | http2.Http2SecureServer | null;
+    port: number;
+    protocol: ProtocolType;
+    ready: boolean;
+    type: ServerType;
+    domain: string;
+    scheme: SchemeType;
+    address: string | null;
+    family: FamilyType | null;
+    active: boolean;
+    infos: AddressInfo | null;
+    constructor(module: Module, httpKernel: HttpKernel);
+    terminator(): HttpTerminator;
+    setPort(): number;
+    createServer(): Promise<https.Server | http2.Http2SecureServer>;
+    createServerH2(): Promise<http2.Http2SecureServer>;
+    /**
+     * Écoute selon `servers.portPolicy`, commune aux deux branches TLS (HTTP/1.1 et
+     * HTTP/2) — leur seule différence est le type du serveur, pas la politique.
+     *
+     * Pose le handler d'erreur durable une fois en écoute (donc APRÈS les éventuels
+     * `EADDRINUSE` de repli, qui ne sont pas des pannes).
+     */
+    private listenWithPolicy;
+    /** Erreurs de la VIE du serveur (le bind est déjà passé — cf server-http.ts). */
+    private attachErrorHandler;
+    /** Bind définitivement impossible → FATAL (contrat inchangé). */
+    private reportBindError;
+    showBanner(): void;
+}
+export default ServerHttps;

package/dist/types/nodefony/service/servers/server-static.d.ts

@@ -0,0 +1,62 @@
+import serveStatic from "serve-static";
+import http from "node:http";
+import http2 from "node:http2";
+import { Service, Module } from "nodefony";
+type serveStaticType = serveStatic.RequestHandler<http.ServerResponse>;
+type ServersStatic = Record<string, serveStaticType>;
+/** Un dossier monté sous un préfixe public (`/_assets/x/` → dir). */
+type StaticMount = {
+    prefix: string;
+    server: serveStaticType;
+    dir: string;
+};
+declare class Statics extends Service {
+    module: Module;
+    servers: ServersStatic;
+    /** Montages préfixés (prod frontend). Lazy : `[]` rempli à `addMount`. */
+    mounts: StaticMount[];
+    /**
+     * Serveur statique config-driven actif. `false` (config `statics.enabled`) =
+     * aucun montage `web`/`assets`, 0 listener — quand un reverse-proxy/CDN sert
+     * les statiques. Ne gate PAS les `addMount()` programmatiques (frontend prod).
+     */
+    enabled: boolean;
+    defaultOptions: serveStatic.ServeStaticOptions;
+    constructor(module: Module);
+    /**
+     * Auto-monte le `public/` de chaque module applicatif sous le préfixe natif
+     * `/<module>/` (basename du nom — `@nodefony/test` → `/test/`). Appelé une fois
+     * à `onReady`. Idempotent via {@link addMount} (un même préfixe est remplacé).
+     *
+     * Exclusions :
+     * - **app root** (`isApp`) — son `public/` est servi à la racine `/` par la
+     *   racine statique `web` (favicon…), sans préfixe.
+     * - **modules frontend-managed** (présents dans `frontend.listEntries()`) —
+     *   leurs assets buildés sont servis sous `/_assets/<name>/` par
+     *   `@nodefony/frontend` ; on ne double-sert pas leur `public/dist`.
+     * - **modules sans `public/`** — rien à monter (http, framework, security…).
+     *
+     * Enregistré dans {@link mounts} quel que soit `enabled` → la carte
+     * préfixe→dossier reste lisible par `proxy:generate` même statiques désactivés
+     * (reverse-proxy/CDN en prod).
+     */
+    mountModulePublics(): void;
+    initStaticFiles(): void;
+    /**
+     * Monte un dossier sous un préfixe public (ex `/_assets/studio/` → outDir).
+     * Le préfixe est normalisé (leading + trailing `/`). Idempotent : un même
+     * préfixe est remplacé. Consommé par `@nodefony/frontend` en prod (assets
+     * Vite buildés) — résolu par nom via le Container, sans import croisé.
+     *
+     * @param prefix préfixe d'URL public
+     * @param dir dossier absolu à servir
+     */
+    addMount(prefix: string, dir: string): void;
+    /** `true` si au moins un montage préfixé est actif (gate du pipeline). */
+    hasMounts(): boolean;
+    addDirectory(Path: string, options: serveStatic.ServeStaticOptions): serveStatic.RequestHandler<http.ServerResponse<http.IncomingMessage>>;
+    getStatic(server: serveStaticType, request: http.IncomingMessage | http2.Http2ServerRequest, response: http.ServerResponse | http2.Http2ServerResponse): Promise<http.ServerResponse | http2.Http2ServerResponse>;
+    getUrl(request: http.IncomingMessage | http2.Http2ServerRequest): string;
+    handle(request: http.IncomingMessage | http2.Http2ServerRequest, response: http.ServerResponse | http2.Http2ServerResponse): Promise<http.ServerResponse | http2.Http2ServerResponse>;
+}
+export default Statics;

package/dist/types/nodefony/service/servers/server-websocket-secure.d.ts

@@ -0,0 +1,29 @@
+import Ws, { WebSocketServer } from "ws";
+import { Service, Module, FamilyType } from "nodefony";
+import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
+import { AddressInfo } from "node:net";
+import type { IncomingMessage } from "node:http";
+import httpsServers from "./server-https.js";
+declare class WebsocketSecure extends Service {
+    private httpKernel;
+    module: Module;
+    ready: boolean;
+    server: WebSocketServer | null;
+    port: number;
+    domain: string;
+    protocol: ProtocolType;
+    family: FamilyType | null;
+    scheme: SchemeType;
+    address: string | null;
+    type: ServerType;
+    infos: AddressInfo | null;
+    /** Timer keep-alive (UN par serveur). `null` si désactivé ou pas démarré. */
+    heartbeatTimer: ReturnType<typeof setInterval> | null;
+    constructor(module: Module, httpKernel: HttpKernel);
+    setPort(): number;
+    createServer(serverHttps: httpsServers): Promise<WebSocketServer>;
+    onConnection(ws: Ws, req: IncomingMessage): void;
+    terminate(): Promise<boolean>;
+    showBanner(): void;
+}
+export default WebsocketSecure;

package/dist/types/nodefony/service/servers/server-websocket.d.ts

@@ -0,0 +1,29 @@
+import Ws, { WebSocketServer } from "ws";
+import { Service, Module, FamilyType } from "nodefony";
+import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
+import { AddressInfo } from "node:net";
+import type { IncomingMessage } from "node:http";
+import httpServer from "./server-http.js";
+declare class Websocket extends Service {
+    private httpKernel;
+    module: Module;
+    ready: boolean;
+    server: WebSocketServer | null;
+    port: number;
+    domain: string;
+    protocol: ProtocolType;
+    family: FamilyType | null;
+    scheme: SchemeType;
+    address: string | null;
+    type: ServerType;
+    infos: AddressInfo | null;
+    /** Timer keep-alive (UN par serveur). `null` si désactivé ou pas démarré. */
+    heartbeatTimer: ReturnType<typeof setInterval> | null;
+    constructor(module: Module, httpKernel: HttpKernel);
+    setPort(): number;
+    createServer(serverHttp: httpServer): Promise<WebSocketServer>;
+    onConnection(ws: Ws, req: IncomingMessage): void;
+    terminate(): Promise<boolean>;
+    showBanner(): void;
+}
+export default Websocket;