@nodefony/http 10.0.0-beta.3 → 10.0.0-beta.5

package/dist/types/nodefony/service/ProfilerAdminApi.d.ts

@@ -10,6 +10,9 @@ import type { Profiler } from "../src/profiler/Profiler.js";
  *
  * Endpoints :
  *  - `GET /nodefony/profiler/api/recent`  → derniers profils (résumés, récent → ancien)
+ *    `?connection=<requestId>` : les seules frames de cette socket WebSocket
+ *  - `GET /nodefony/profiler/api/summary` → les profils de l'anneau agrégés par
+ *    route (percentiles, phases, formes SQL, N+1, erreurs — `aggregateProfiles`)
  *  - `GET /nodefony/profiler/api/{id}`    → profil complet (phases) d'un requestId
  *  - `DELETE /nodefony/profiler/api/recent` → vide le ring buffer
  *

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

@@ -1,6 +1,7 @@
 import type { Severity } from "nodefony";
 import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
-import type { IHttpContext, IWebsocketContext, PhaseTiming } from "../interfaces/IContext.js";
+import type { IContext, IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+declare const statusOf: (context: IContext) => number | null;
 /**
  * Canonical audit log entry — 1 JSON PDU per request (P3.1).
  *
@@ -52,15 +53,6 @@ export interface AuditErrorEntry {
     /** Recursive — capped to depth 5 to avoid pathological cycles. */
     cause?: AuditErrorEntry;
 }
-/**
- * Durée totale de la requête, de la première phase (`startMs`) à maintenant.
- * `null` si le chronométrage est coupé (aucune phase enregistrée). Partagée
- * par le journal d'audit et le journal lisible — une seule définition.
- *
- * @param phases - phases chronométrées du contexte
- * @returns durée en millisecondes, ou `null`
- */
-declare function computeDurationMs(phases: PhaseTiming[]): number | null;
 /**
  * Severity derived from HTTP status code — RFC 9110 categories.
  * 1xx/2xx/3xx → INFO ; 4xx → WARNING ; 5xx → ERROR.
@@ -145,4 +137,4 @@ declare class JsonAuditLogger implements IRequestLogger {
     private serializeError;
 }
 export default JsonAuditLogger;
-export { computeDurationMs, severityFromStatus };
+export { severityFromStatus, statusOf };

package/dist/types/nodefony/service/certificates.d.ts

@@ -61,27 +61,78 @@ export interface ICaFileTrust {
  *
  * @param file - chemin du fichier, absolu ou relatif à `root`
  * @param root - racine de l'application
+ * Chaque refus dit le problème, d'où vient le chemin quand on le sait, puis le
+ * geste qui répare ({@link caFileRemedy}).
+ *
  * @param store - accès aux ancres ; `node:tls` par défaut
+ * @param origin - phrase qui dit d'où vient le chemin (` Valeur venue de …`), insérée dans un refus
  * @returns le bilan de l'ajout
  * @throws BootConfigurationError - fichier illisible, sans certificat, ou Node
  *         incapable d'élargir ses ancres en cours d'exécution
  */
-export declare function trustCaFile(file: string, root: string, store?: ITlsTrustStore): Promise<ICaFileTrust>;
+export declare function trustCaFile(file: string, root: string, store?: ITlsTrustStore, origin?: string): Promise<ICaFileTrust>;
+/**
+ * Le geste qui répare une autorité déclarée qu'on ne peut pas reconnaître.
+ *
+ * Un refus au démarrage qui ne dit que la cause envoie chercher ; celui-ci dit
+ * quoi faire. Pure : éprouvée cause par cause, y compris celles qu'une machine
+ * de test ne sait pas produire (un droit refusé ne l'est pas à `root`, ni
+ * sous Windows).
+ *
+ * @param cause - code système (`ENOENT`, `EACCES`, `EPERM`, `EISDIR`),
+ *   `NOPEM` pour un fichier lu sans certificat, ou tout autre motif
+ * @returns la phrase du geste
+ */
+export declare function caFileRemedy(cause: string): string;
+/**
+ * Dossier où Nodefony range les certificats qu'il fabrique en développement,
+ * relatif au répertoire courant.
+ *
+ * @returns le chemin absolu de `nodefony/config/certificates`
+ */
+export declare function certificatesDirectory(): string;
+/**
+ * Chemin de l'autorité de DÉVELOPPEMENT : le certificat racine que Nodefony
+ * fabrique lui-même pour signer le certificat du serveur local. Généré, jamais
+ * versionné — une seule convention, que le service et la confiance sortante lisent.
+ *
+ * @param directory - dossier des certificats ; {@link certificatesDirectory} par défaut
+ * @returns le chemin absolu du fichier PEM de l'autorité
+ */
+export declare function developmentAuthorityPath(directory?: string): string;
+/** Décor de {@link trustOutboundAuthorities} — injectable pour l'éprouver. */
+export interface IOutboundTrustContext {
+    /** Vrai en développement : seul décor où l'autorité de dev absente est tolérée. */
+    readonly development?: boolean;
+    /** Chemin absolu de l'autorité de développement ; {@link developmentAuthorityPath} par défaut. */
+    readonly developmentAuthority?: string;
+    /** Environnement lu pour nommer la variable d'origine ; `process.env` par défaut. */
+    readonly env?: NodeJS.ProcessEnv;
+    /** Accès aux ancres ; `node:tls` par défaut. */
+    readonly store?: ITlsTrustStore;
+}
 /**
  * Ajoute aux ancres TLS du processus les autorités déclarées
  * (`certificates.extraCaFiles`), au plus tôt : appelé à l'enregistrement du
  * module, avant tout service — toute requête sortante, commande console
  * comprise, les trouve en place.
  *
- * La CA de DÉVELOPPEMENT n'y figure pas : le service de certificats la pose
- * lui-même ({@link Certificate.generateServerCertificates}).
+ * L'autorité de DÉVELOPPEMENT déclarée mais pas encore engendrée est ignorée en
+ * développement, et le journal le dit : elle n'a signé aucun certificat, il n'y
+ * a donc rien à lui faire confiance, et le serveur de développement la pose
+ * lui-même quand il la fabrique ({@link Certificate.generateServerCertificates}).
+ * Rien n'est fabriqué ici : une commande console n'écrit pas de certificat.
+ * Une autre autorité absente, ou n'importe laquelle hors développement, reste
+ * un refus — qui nomme la variable d'origine et le geste qui répare
+ * ({@link caFileRemedy}).
  *
  * @param files - `certificates.extraCaFiles`
  * @param root - racine de l'application
  * @param log - journal du module
+ * @param context - décor (environnement, autorité de dev, ancres)
  * @throws BootConfigurationError - cf {@link trustCaFile}
  */
-export declare function trustOutboundAuthorities(files: readonly string[], root: string, log: (message: string, severity: "INFO") => void): Promise<void>;
+export declare function trustOutboundAuthorities(files: readonly string[], root: string, log: (message: string, severity: "INFO") => void, context?: IOutboundTrustContext): Promise<void>;
 /** Paire de clés RSA du certificat auto-signé. */
 export interface IRsaKeyPair {
     privateKey: KeyObject;

package/dist/types/nodefony/service/error-renderer.d.ts

@@ -1,5 +1,36 @@
 import type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult } from "../interfaces/IErrorRenderer.js";
 import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+/** Champ fautif, tel qu'exposé au client dans le corps JSON (`error.fields`). */
+export interface IValidationField {
+    /** Chemin pointé du champ (`"author.email"`). */
+    field: string;
+    /** Message lisible. */
+    message: string;
+    /** Contrôle qui a échoué (`too_small`…) — utile au client pour réagir finement. */
+    rule?: string | undefined;
+    /**
+     * Partie de l'entrée qui porte le champ (`body`, `query`, `params`,
+     * `headers`) — présente pour une route à schéma, où deux parties peuvent
+     * porter le même nom. `field` reste relatif à sa partie : un formulaire le
+     * relie à son champ de saisie sans rien retirer.
+     */
+    in?: string | undefined;
+}
+/**
+ * Reconnaît une erreur de validation — `ZodError`, ou `SchemaValidationError`
+ * d'une route à schéma — et en extrait les champs fautifs.
+ *
+ * Reconnaissance **structurelle** (`name` + `issues`), pas `instanceof ZodError` :
+ * une application peut embarquer sa propre copie de zod (résolutions npm multiples),
+ * et `instanceof` échouerait alors en silence — la validation retomberait en 500.
+ * Même parti-pris que le duck-typing de `isPromise` dans le framework.
+ *
+ * Ne coûte rien au chemin nominal : ce code ne tourne que sur une erreur déjà levée.
+ *
+ * @param error - erreur remontée par le pipeline.
+ * @returns les champs fautifs, ou `null` si ce n'est pas une erreur de validation.
+ */
+export declare function toValidationFields(error: Error): IValidationField[] | null;
 /**
  * Reconnaît un identifiant MAL FORMÉ refusé par la base, et rend la valeur fautive.
  *

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

@@ -11,11 +11,13 @@ import type { IncomingHttpHeaders, 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 h2cServer from "../service/servers/server-h2c.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 type ReverseProxy from "./reverse-proxy.js";
 import WebsocketContext from "../src/context/websocket/WebsocketContext.js";
+import type { IUpgradeAdmission } from "../src/servers/upgradeDispatch.js";
 import HttpContext from "../src/context/http/HttpContext.js";
 import Context, { HTTPMethod, WebSocketState } from "../src/context/Context.js";
 import Certicates from "./certificates.js";
@@ -42,9 +44,8 @@ export type httpRequest = http.IncomingMessage | http2.Http2ServerRequest;
 export type httpResponse = http.ServerResponse | http2.Http2ServerResponse;
 export { responseEnded } from "../src/context/responseEnded.js";
 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 type { ServerType, SchemeType } from "../interfaces/IContext.js";
+import type { ServerType, SchemeType } from "../interfaces/IContext.js";
 export interface WsMetaData {
     type?: "message" | "handshake" | undefined;
     state?: WebSocketState | undefined;
@@ -119,8 +120,6 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     responseTimeout: {
         http: number;
         https: number;
-        http2: number;
-        http3: number;
     };
     closeTimeOutWs: {
         ws: number;
@@ -135,6 +134,8 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     private errorRenderer;
     private requestLogger;
     private profiler;
+    /** `timing.tooling` : profiler aussi l'outillage (lu une fois, à onReady). */
+    private profileTooling;
     private _trustProxyChecker;
     private _wsOriginPolicy;
     private rateLimiter;
@@ -187,6 +188,32 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * tel quel plutôt que d'inventer un état.
      */
     get rateLimitStore(): IRateLimitStore | null;
+    /**
+     * Cette requête — ou cette frame du pont — se profile-t-elle ? Jamais sans
+     * profileur (production). L'outillage (console, profileur, journaux, Vite :
+     * `isProfiledUrl`, sur la règle `isConsolePath` du cœur) seulement sous
+     * `timing.tooling` — on ne
+     * mesure pas la façon dont on mesure : ni tampon SQL, ni instantané, ni place
+     * dans les anneaux du profileur.
+     *
+     * @param url - URL ou chemin de la requête
+     * @returns `true` quand le profil doit être pris
+     */
+    shouldProfile(url: string): boolean;
+    /**
+     * En développement, signale une action qui a rendu une valeur que le
+     * Resolver ne sait pas envoyer (`null`, `undefined`, instance de classe)
+     * et n'a rien envoyé elle-même : la requête attend son délai d'expiration.
+     * Le message nomme l'action, ce qu'elle a rendu et le geste qui convient
+     * (`unsentResponseWarning`).
+     *
+     * Appelé au timeout, AVANT que le 504/408 parte — après, `sended` est vrai et
+     * plus rien ne se signalerait — et au démontage, pour un client parti avant.
+     * Gratuit en production : rien n'est lu au-delà de `waitAsync`.
+     *
+     * @param context - le contexte HTTP de la requête
+     */
+    warnUnsentResponse(context: HttpContext): void;
     private configureRateLimit;
     /**
      * (Re)configure le backstop OPT-IN de connexions WS concurrentes par IP (F6c)
@@ -383,7 +410,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      *   pipeline.
      */
     private dispatchHttpRequest;
-    initServers(): Promise<(httpServer | httpsServer | websocketServer | websocketSecureServer)[]>;
+    initServers(): Promise<(httpServer | httpsServer | h2cServer | websocketServer | websocketSecureServer)[]>;
     /**
      * Publie les ports EFFECTIFS du runtime (state file), une fois l'écoute établie.
      *
@@ -475,6 +502,18 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @returns le contexte servi, ou sa promesse.
      */
     handleHttp(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): MaybePromise<HttpContext>;
+    /**
+     * Sert un contexte HTTP fraîchement créé : le crochet `onCreateContext`
+     * s'il a des écouteurs, puis le pipeline.
+     *
+     * Hot path : `fireAsync` est une fonction async → 1 Promise + 1 microtask
+     * MÊME à 0 listener. En prod sans @nodefony/security ces seams
+     * (onCreateContext/beforeResolve/afterAuth) n'ont aucun listener → garde
+     * `listenerCount` (O(1), 0 alloc) pour ne RIEN planifier.
+     *
+     * @returns le contexte servi, ou sa promesse
+     */
+    private dispatchHttpContext;
     /**
      * Traceparent, tampon du profileur, puis le pipeline dans la bulle ALS de la
      * requête (`RequestContext.run`).
@@ -542,7 +581,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @throws (rejet) le refus du pare-feu, après `onAuthFailure`.
      */
     private runFirewall;
-    createWebsocketContext(scope: Scope, req: IncomingMessage, ws: Ws, type: ServerType): WebsocketContext;
+    createWebsocketContext(scope: Scope, req: IncomingMessage, ws: Ws | null, type: ServerType): WebsocketContext;
     /**
      * Teardown d'une connexion WS à sa fermeture : signal d'abandon, hooks
      * post-réponse, persistance de la session, puis libération du scope.
@@ -550,10 +589,57 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * écouteur d'événement synchrone, qui n'attend rien).
      */
     private finishWebsocket;
-    onWebsocketRequest(ws: Ws, req: IncomingMessage, type: ServerType): Promise<unknown>;
-    handleWebsocket(scope: Scope, ws: Ws, req: IncomingMessage, type: ServerType): Promise<unknown>;
+    /**
+     * Point d'entrée d'un upgrade vers une route WebSocket de Nodefony, appelé
+     * par le répartiteur d'upgrade AVANT le `101` (#596) : rien ne s'ouvre tant
+     * que le pipeline n'a pas dit oui.
+     *
+     * Les bornes par IP passent en premier, avant tout scope, ALS ou pipeline
+     * (symétrie avec le 429 HTTP et avec le proxy inverse) : le vrai vecteur DoS
+     * est d'accumuler des sockets ouvertes. La place est rendue à la fermeture du
+     * socket du client — même règle que pour un tunnel relayé.
+     *
+     * @param req - requête d'upgrade
+     * @param admission - le verdict à rendre : accepter (`101`) ou refuser (HTTP)
+     * @param type - serveur qui a reçu l'upgrade
+     * @returns la promesse du traitement de la connexion
+     */
+    onWebsocketUpgrade(req: IncomingMessage, admission: IUpgradeAdmission, type: ServerType): Promise<unknown>;
+    /**
+     * Pipeline d'un handshake WebSocket, dans la bulle ALS de la connexion :
+     * jugement (`onConnect`), pare-feu, gardes de l'action — PUIS seulement
+     * l'acceptation, la socket et l'action de handshake. Tout refus antérieur à
+     * l'acceptation part en statut HTTP (`onError` → `refuseHandshake`).
+     *
+     * @param scope - scope DI de la connexion
+     * @param req - requête d'upgrade
+     * @param admission - le verdict à rendre
+     * @param type - serveur qui a reçu l'upgrade
+     * @returns ce que rend l'action de handshake
+     */
+    handleWebsocket(scope: Scope, req: IncomingMessage, admission: IUpgradeAdmission, type: ServerType): Promise<unknown>;
+    /**
+     * Fin du canal `nodefony.http.request` pour un handshake interrompu par une
+     * exception — sans effet si un refus l'a déjà publiée (`refuseHandshake`).
+     * Le statut est un fait, pas une déduction : une socket rattachée dit que
+     * le `101` est parti ; sinon c'est le `500` du filet qui a été rendu.
+     *
+     * @param context - le contexte du handshake, `null` s'il n'a pu être construit
+     * @param error - l'exception qui a interrompu le pipeline
+     */
+    private closeFailedWebsocketTrace;
     private releaseOrphanWsScope;
-    onConnect(context: WebsocketContext | null, error?: unknown): Promise<Ws | number>;
+    /**
+     * Juge un handshake WebSocket AVANT son acceptation : hôte, origine,
+     * `beforeResolve`, contrôleur (protocole négocié), session. N'ouvre rien —
+     * l'acceptation n'a lieu qu'après le pare-feu et les gardes de l'action
+     * (cf {@link handleWebsocket}).
+     *
+     * @param context - contexte du handshake, encore sans socket
+     * @param error - erreur levée à la construction du contexte, relancée telle quelle
+     * @throws la première erreur du jugement — rendue en statut HTTP par `onError`
+     */
+    onConnect(context: WebsocketContext | null, error?: unknown): Promise<void>;
     checkValidDomain(context: ContextType): number;
     isValidDomain(context: ContextType): boolean;
     /**

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

@@ -12,3 +12,19 @@ import type { Duplex } from "node:stream";
  * @param socket - flux client brut (l'event `clientError` fournit un `Duplex`).
  */
 export declare function handleClientError(error: NodeJS.ErrnoException, socket: Duplex): void;
+/**
+ * Gère l'event `sessionError` d'un serveur HTTP/2 (h2c ou TLS) : un pair PARTI
+ * se tait, toute autre erreur est rapportée.
+ *
+ * Une session réinitialisée par le pair n'a rien à diagnostiquer. C'est la
+ * signature d'une sonde de port — `nodefony status`, `doctor`, le superviseur
+ * de développement, la sonde `tcpSocket` d'un orchestrateur — qui se connecte
+ * puis ferme sans lire le `SETTINGS` que le serveur envoie dès l'ouverture : le
+ * système ferme alors par un RST plutôt qu'un FIN, et Node lève `ECONNRESET`.
+ * La rapporter imprimait une pile entière par sonde. La règle « client parti »
+ * est celle des frames WebSocket ({@link isPeerGoneError}), pas une copie.
+ *
+ * @param error - erreur de session émise par `node:http2`
+ * @param report - rapporte une erreur réelle, à la sévérité choisie par le serveur
+ */
+export declare function handleSessionError(error: Error, report: (error: Error) => void): void;

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

@@ -0,0 +1,51 @@
+import { Service, type Module, FamilyType } from "nodefony";
+import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
+import http2 from "node:http2";
+import { AddressInfo } from "node:net";
+import { type IDrainTerminator } from "./serverShutdown.js";
+import type { IHttpConfig } from "../../config/config.js";
+import type { DefaultOptionsService } from "nodefony";
+/**
+ * Serveur HTTP/2 en clair (h2c, connaissance préalable — RFC 9113 §3.3), sur un
+ * port DÉDIÉ (`servers.h2c`, 5153 par défaut), pour un proxy inverse qui parle
+ * HTTP/2 à ses amonts.
+ *
+ * Il partage le chemin HTTP/2 du 5152 — même `onHttpRequest`, mêmes limites
+ * anti-DoS (`http2ServerLimits`), même drain par GOAWAY — sans TLS : `serverType`
+ * vaut `"http"`, le schéma vient du transport ou d'un proxy de confiance, jamais
+ * du pseudo-en-tête `:scheme`. Le protocole du saut (`"h2c"`) se constate sur la
+ * requête (`transport.ts#alpnProtocolOf`).
+ *
+ * Hors de son périmètre, délibérément : HTTP/1.1 (refusé par la préface HTTP/2 —
+ * sondes et clients HTTP/1.1 restent sur le port HTTP), WebSocket (aucun CONNECT
+ * étendu, RFC 8441 : un proxy route `Upgrade: websocket` vers le port HTTP) et la
+ * bascule `Upgrade: h2c` (retirée par RFC 9113 §3.1).
+ */
+declare class ServerH2c extends Service {
+    private readonly httpKernel;
+    options: IHttpConfig["http"] & DefaultOptionsService;
+    module: Module<IHttpConfig>;
+    server: http2.Http2Server | null;
+    httpTerminator: IDrainTerminator | null;
+    port: number;
+    protocol: ProtocolType;
+    ready: boolean;
+    type: ServerType;
+    domain: string | null;
+    scheme: SchemeType;
+    address: string | null;
+    family: FamilyType | null;
+    active: boolean;
+    infos: AddressInfo | null;
+    constructor(module: Module<IHttpConfig>, httpKernel: HttpKernel);
+    /**
+     * Crée et met en écoute le serveur h2c.
+     *
+     * @returns le serveur à l'écoute
+     * @throws BootConfigurationError si `servers.h2c.port` est celui du serveur
+     *   HTTP ou HTTPS — un port partagé n'est pas un conflit à contourner
+     */
+    createServer(): Promise<http2.Http2Server>;
+    showBanner(): void;
+}
+export default ServerH2c;

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

@@ -1,9 +1,9 @@
-import { Service, Module, FamilyType } from "nodefony";
+import { Service, type 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";
+import { type IDrainTerminator } from "./serverShutdown.js";
 import type { IHttpConfig } from "../../config/config.js";
 import type { DefaultOptionsService } from "nodefony";
 declare class ServerHttp extends Service {
@@ -11,7 +11,7 @@ declare class ServerHttp extends Service {
     options: IHttpConfig["http"] & DefaultOptionsService;
     module: Module;
     server: http.Server | http2.Http2Server | null;
-    httpTerminator: HttpTerminator | null;
+    httpTerminator: IDrainTerminator | null;
     port: number;
     protocol: ProtocolType;
     ready: boolean;

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

@@ -1,15 +1,15 @@
-import { Service, Module, FamilyType } from "nodefony";
+import { Service, type 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 { type IDrainTerminator } from "./serverShutdown.js";
 import { AddressInfo } from "node:net";
 import type { IHttpConfig } from "../../config/config.js";
 import type { DefaultOptionsService } from "nodefony";
 declare class ServerHttps extends Service {
     private readonly httpKernel;
     options: IHttpConfig["https"] & DefaultOptionsService;
-    httpTerminator: HttpTerminator | null;
+    httpTerminator: IDrainTerminator | null;
     module: Module;
     server: https.Server | http2.Http2SecureServer | null;
     port: number;
@@ -23,7 +23,7 @@ declare class ServerHttps extends Service {
     active: boolean;
     infos: AddressInfo | null;
     constructor(module: Module, httpKernel: HttpKernel);
-    terminator(): HttpTerminator;
+    terminator(): IDrainTerminator;
     setPort(): number;
     createServer(): Promise<https.Server | http2.Http2SecureServer>;
     createServerH2(): Promise<http2.Http2SecureServer>;

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

@@ -1,10 +1,9 @@
-import Ws, { WebSocketServer } from "ws";
+import { WebSocketServer } from "ws";
 import { Service, Module, FamilyType } from "nodefony";
 import type { DefaultOptionsService } from "nodefony";
 import type { IHttpConfig } from "../../config/config.js";
 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;
@@ -26,7 +25,6 @@ declare class WebsocketSecure extends Service {
     constructor(module: Module, httpKernel: HttpKernel);
     setPort(): number;
     createServer(serverHttps: httpsServers): Promise<WebSocketServer>;
-    onConnection(ws: Ws, req: IncomingMessage): void;
     terminate(): Promise<boolean>;
     showBanner(): void;
 }

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

@@ -1,10 +1,9 @@
-import Ws, { WebSocketServer } from "ws";
+import { WebSocketServer } from "ws";
 import { Service, Module, FamilyType } from "nodefony";
 import type { DefaultOptionsService } from "nodefony";
 import type { IHttpConfig } from "../../config/config.js";
 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;
@@ -26,7 +25,6 @@ declare class Websocket extends Service {
     constructor(module: Module, httpKernel: HttpKernel);
     setPort(): number;
     createServer(serverHttp: httpServer): Promise<WebSocketServer>;
-    onConnection(ws: Ws, req: IncomingMessage): void;
     terminate(): Promise<boolean>;
     showBanner(): void;
 }

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

@@ -1,27 +1,41 @@
-import { HttpTerminator } from "http-terminator";
 import type { Server as HttpServer } from "node:http";
 import type { Server as HttpsServer } from "node:https";
-import type { Http2SecureServer } from "node:http2";
+import type { Http2SecureServer, Http2Server } from "node:http2";
+/** Serveur que `createDrainTerminator` sait drainer. */
+export type DrainableServer = HttpServer | HttpsServer | Http2Server | Http2SecureServer;
+/** Arrêt gracieux d'un serveur, rendu par `createDrainTerminator`. */
+export interface IDrainTerminator {
+    /**
+     * Draine puis ferme le serveur ; idempotent (le deuxième appel rend la même promesse).
+     *
+     * @returns une promesse résolue quand toutes les connexions sont fermées
+     */
+    terminate(): Promise<void>;
+}
 /**
- * Fabrique le terminator de drain graceful d'un serveur HTTP/HTTPS/HTTP2.
+ * Fabrique l'arrêt gracieux d'un serveur HTTP/1.1, HTTPS, HTTP/2 sur TLS ou h2c.
  *
- * Au `terminate()` (shutdown SIGTERM/docker stop) : les requêtes in-flight se
- * terminent (header `connection: close` injecté sur les réponses en cours), les
- * sockets idle sont fermées immédiatement, et tout ce qui reste après
- * `shutdownTimeout` ms est détruit de force. Le terminator appelle lui-même
- * `server.close()` — ne pas le rappeler derrière.
+ * Au `terminate()` (SIGTERM, `docker stop`), le serveur cesse d'accepter, puis :
+ * - **HTTP/2** : chaque session reçoit un GOAWAY (`session.close()`) — les flux
+ *   en vol se terminent, les nouveaux sont refusés, et le client sait qu'il doit
+ *   rouvrir ailleurs au lieu de constater une coupure ;
+ * - **HTTP/1.1** : la réponse en vol part avec `Connection: close`, la socket
+ *   inactive est fermée tout de suite, une requête qui arrive encore sur une
+ *   socket gardée ouverte reçoit aussi `Connection: close`.
+ *
+ * Ce qui reste après `shutdownTimeout` ms est détruit. `server.close()` est
+ * appelé ici : ne pas le rappeler derrière.
  *
  * ⚠️ Les sockets WebSocket upgradées (sans réponse HTTP en cours) sont détruites
- * SANS frame Close par le terminator → les serveurs WS doivent fermer leurs
- * clients (close 1001) AVANT ce drain. Garanti par l'ordre des listeners
- * `onTerminate` : WS/WSS s'attachent en `prependOnceListener`, les serveurs
- * HTTP en `once`.
+ * SANS frame Close → les serveurs WS doivent fermer leurs clients (close 1001)
+ * AVANT ce drain. Garanti par l'ordre des listeners `onTerminate` : WS/WSS
+ * s'attachent en `prependOnceListener`, les serveurs HTTP en `once`.
  *
- * @param server - serveur Node à drainer (créé, pas forcément listening)
+ * @param server - serveur Node à drainer, créé AVANT son `listen` (le suivi des
+ *   connexions commence ici)
  * @param shutdownTimeout - délai de drain en ms avant destruction forcée
- * @returns le terminator à invoquer au shutdown
+ * @returns l'arrêt à invoquer au shutdown
  */
-export declare function createDrainTerminator(server: HttpServer | HttpsServer | Http2SecureServer, shutdownTimeout?: number): HttpTerminator;
+export declare function createDrainTerminator(server: DrainableServer, shutdownTimeout?: number): IDrainTerminator;
 /** Drain par défaut (ms) — même valeur que le défaut Zod `servers.*.shutdownTimeout`. */
 export declare const DEFAULT_SHUTDOWN_TIMEOUT = 5000;
-export type { HttpTerminator };