@nodefony/http 10.0.0-beta.2 → 10.0.0-beta.4

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

@@ -7,14 +7,17 @@ import type { IRateLimitStore } from "../src/rateLimit/IRateLimitStore.js";
 import { type ITrustedHostsConfig } from "../src/context/domainMatcher.js";
 import http from "node:http";
 import http2 from "node:http2";
-import type { IncomingMessage } from "node:http";
+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";
@@ -25,13 +28,24 @@ import type { IErrorRenderer } from "../interfaces/IErrorRenderer.js";
 import type { IRequestLogger } from "../interfaces/IRequestLogger.js";
 import type { DefaultOptionsService } from "nodefony";
 import type { IHttpConfig } from "../config/config.js";
+/**
+ * Config interne (shape déclarée par `config/config.ts`). Locale au module —
+ * pas exportée tant que la surface publique n'a pas vocation à être étendue.
+ */
+/** Ce qu'il faut d'une requête pour en compter la connexion par IP. */
+export interface IConnectionRequest {
+    readonly headers: IncomingHttpHeaders;
+    readonly socket: {
+        readonly remoteAddress?: string | undefined;
+    };
+}
 export type ProtocolType = "1.1" | "2.0" | "3.0";
 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;
@@ -81,18 +95,31 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     cert: string;
     ca: string;
     serverStatic: Statics | null;
+    /**
+     * Proxy inverse (`reverse-proxy`) — lu à chaque requête avant le routage ;
+     * `mounts === null` tant que personne n'a monté de préfixe.
+     */
+    reverseProxy: ReverseProxy | null;
     domain: string;
     trustedHosts?: ITrustedHostsConfig | undefined;
-    domainCheck: boolean;
+    /**
+     * Contrôle de domaine actif (`domainCheck` de la config d'application) —
+     * lu à la source, pour le HTTP comme pour le handshake WebSocket.
+     */
+    get domainCheck(): boolean;
     regAlias: RegExp[];
     module: Module;
-    httpsPort?: number | undefined;
-    httpPort?: number | undefined;
+    /**
+     * Port du serveur HTTPS effectivement lié, `undefined` s'il est inactif —
+     * lu sur le serveur, jamais recopié (lu par `HttpContext.redirectHttps`).
+     */
+    get httpsPort(): number | undefined;
+    /** Port du serveur HTTP effectivement lié, `undefined` s'il est inactif. */
+    get httpPort(): number | undefined;
+    private boundPort;
     responseTimeout: {
         http: number;
         https: number;
-        http2: number;
-        http3: number;
     };
     closeTimeOutWs: {
         ws: number;
@@ -196,6 +223,22 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @returns la politique mémoïsée (0 alloc après le 1er handshake).
      */
     private getWsOriginPolicy;
+    /**
+     * L'`Origin` d'un handshake WebSocket est-elle acceptée ? Règle UNIQUE,
+     * interrogeable SANS contexte : le serveur WebSocket de Nodefony
+     * ({@link checkWebsocketOrigin}) et le proxy inverse, qui relaie un upgrade
+     * avant qu'aucun contexte n'existe, décident par elle.
+     *
+     * Same-origin (nom de l'`Origin` = nom servi, port ignoré), loopback toléré
+     * en development, allowlist `allowedOrigins` ; sans `Origin` (client
+     * non-navigateur) → acceptée. Doctrine complète : {@link checkWebsocketOrigin}.
+     *
+     * @param origin - valeur brute de l'en-tête `Origin`
+     * @param hostname - nom d'hôte servi, sans port (`Context.domain`)
+     * @param secure - handshake reçu en TLS (politique `websocketSecure`)
+     * @returns `true` si le handshake peut se poursuivre
+     */
+    isWebsocketOriginAllowed(origin: string | undefined, hostname: string, secure: boolean): boolean;
     /**
      * B4 — Validation d'`Origin` au handshake WebSocket (anti-CSWSH, OWASP
      * WSTG-CLNT-10). Les navigateurs n'appliquent PAS CORS aux WebSockets : sans
@@ -304,7 +347,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      */
     /**
      * Override the default error renderer — e.g. to hide stack traces in prod
-     * or emit RFC 7807 problem+json. Stateless singleton expected.
+     * or emit RFC 9457 problem+json. Stateless singleton expected.
      */
     setErrorRenderer(renderer: IErrorRenderer): void;
     getErrorRenderer(): IErrorRenderer;
@@ -339,7 +382,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.
      *
@@ -498,7 +541,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.
@@ -506,10 +549,47 @@ 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>;
     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;
     /**
@@ -527,5 +607,67 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      *   couvre ce nom.
      */
     isTrustedHostname(hostname: string): boolean;
+    /**
+     * Refus d'un upgrade WebSocket AVANT le `101`, par un statut HTTP
+     * (RFC 6455 §4.2.2) — appelé par le répartiteur d'upgrade, après le proxy
+     * inverse et avant le serveur `ws`.
+     *
+     * Pourquoi avant : accepter puis fermer fait croire au client que le serveur
+     * a répondu. Le client Vite sonde « le serveur est-il revenu ? » en ouvrant
+     * une socket ; une ouverture suivie d'une fermeture `4004` lui faisait
+     * recharger la page avant que Vite soit prêt — page blanche.
+     *
+     * Ne juge que l'existence d'une route WebSocket pour le chemin
+     * ({@link IRequestRouter.servesWebsocket}) : hôte, origine, sous-protocole,
+     * quotas et pare-feu restent jugés après l'ouverture, comme avant. Un refus
+     * compte au limiteur de débit comme une requête HTTP refusée — sans quoi un
+     * flot d'upgrades vers des chemins inexistants y échapperait.
+     *
+     * @param req - requête d'upgrade
+     * @returns le statut du refus — `404` chemin sans route WebSocket, `400` URL
+     *   inanalysable, `429` débit dépassé, `503` routeur pas encore posé (boot) —
+     *   ou `null` si l'upgrade est admis
+     */
+    websocketUpgradeRefusal(req: IncomingMessage): 400 | 404 | 429 | 503 | null;
+    /**
+     * Bornes par IP d'un upgrade WebSocket : débit de handshakes (le MÊME
+     * compteur que les requêtes HTTP — un upgrade EST un GET) puis connexions
+     * simultanées (`wsMaxConnectionsPerIp`). Seule implémentation, appelée par
+     * le serveur WebSocket de Nodefony ET par le proxy inverse pour un upgrade
+     * qu'il relaie : un tunnel relayé n'échappe pas aux quotas d'une connexion
+     * servie.
+     *
+     * L'IP est résolue comme en HTTP (RFC 7239 + `trustProxy`), et seulement si
+     * un limiteur est armé — 0 coût quand tout est désactivé (défaut). Aucun log
+     * par refus : sous un flood, il serait lui-même un amplificateur.
+     *
+     * @param req - requête d'upgrade
+     * @param connection - ce dont la fermeture libère la place comptée (le `ws`
+     *   accepté, ou le socket du client pour un tunnel relayé)
+     * @returns `null` si l'upgrade est admis — sa place est alors rendue à la
+     *   fermeture de `connection` —, sinon la raison du refus
+     */
+    websocketQuotaRefusal(req: IncomingMessage, connection: {
+        once(event: "close", listener: () => void): unknown;
+    }): "rate limit" | "too many connections" | null;
+    /**
+     * Prend une place de connexion LONGUE pour l'IP de la requête — le plafond
+     * `wsMaxConnectionsPerIp`, partagé par les sockets WebSocket ET les flux SSE :
+     * un seul budget par IP, sinon N sockets plus N flux doubleraient le plafond.
+     * Le débit n'est pas recompté ici : la requête qui ouvre un flux l'a déjà été
+     * à l'entrée du pipeline.
+     *
+     * @param req - la requête qui ouvre le flux (en-têtes + socket du pair)
+     * @param connection - ce dont la fermeture rend la place (la réponse)
+     * @returns `true` si la place est prise — ou si aucun plafond n'est armé
+     */
+    acquireConnectionSlot(req: IConnectionRequest, connection: {
+        once(event: "close", listener: () => void): unknown;
+    }): boolean;
+    /**
+     * Re-valide tous les flux SSE et ferme ceux dont l'identité est morte.
+     * Publique pour qu'un banc la déclenche sans attendre le tick.
+     */
+    revalidateStreams(): Promise<void>;
 }
 export default HttpKernel;

package/dist/types/nodefony/service/reverse-proxy.d.ts

@@ -0,0 +1,156 @@
+import http from "node:http";
+import type { Duplex } from "node:stream";
+import { Service, Module } from "nodefony";
+import type { IProxyMount, IProxyMountOptions } from "../interfaces/IReverseProxy.js";
+import { type ProxiedRequest, type ProxiedResponse } from "../src/proxy/forward.js";
+/** Un montage tel que le service le garde : la dernière cible analysée y est mise en cache. */
+interface IMountRecord extends IProxyMount {
+    /** D'où vient le montage : la configuration de l'application, ou un module. */
+    readonly source: "config" | "module";
+    /** Dernière origine rendue par `target`, et son analyse. */
+    lastOrigin: string | undefined;
+    lastUrl: URL | undefined;
+    /** Pool de connexions vers l'amont, créé au premier relais (scheme de la cible). */
+    agent: http.Agent | null;
+    /** Tunnels WebSocket ouverts vers l'amont — bornés par `maxSockets`, hors pool. */
+    tunnels: number;
+}
+/**
+ * Proxy inverse de Nodefony : relaie un préfixe d'URL vers un autre serveur
+ * HTTP — requêtes ET, sur demande, upgrades WebSocket — sur la MÊME origine
+ * que la page. Le client ne voit qu'un serveur, un certificat ; l'amont peut
+ * rester sur la boucle locale.
+ *
+ * Deux sources de montages, mêmes règles (`src/proxy/rules.ts`) : la section
+ * `proxy.mounts` de la configuration, lue à la construction, et
+ * {@link ReverseProxy.mount}, appelé par un module (`@nodefony/frontend` y
+ * relaie `/_vite/<famille>/` vers ses serveurs Vite de développement). Un
+ * module se résout ce service par NOM (`container.get("reverse-proxy")`) :
+ * il n'a pas à importer `@nodefony/http`.
+ *
+ * Consulté AVANT le routage : une route attrape-tout de l'application ne peut
+ * pas avaler un préfixe relayé. Sans montage, le pipeline ne paie qu'une
+ * lecture de champ (`mounts === null`) — c'est le cas de toute application
+ * qui ne s'en sert pas.
+ *
+ * Règles communes à tout montage : en-têtes de connexion jamais transmis
+ * (RFC 9110 §7.6.1), `X-Forwarded-For/-Proto/-Host` et `Via` posés par le
+ * proxy, Host hors `trustedHosts` jamais relayé (même barrière, même 421 que
+ * toute requête), amont injoignable → 502, amont muet → 504, boucle → 508.
+ */
+declare class ReverseProxy extends Service {
+    #private;
+    module: Module;
+    /**
+     * Montages actifs, du préfixe le PLUS LONG au plus court : le premier qui
+     * couvre une URL est le plus spécifique. `null` tant qu'il n'y en a aucun.
+     */
+    mounts: IMountRecord[] | null;
+    /** Délai d'inactivité appliqué aux montages qui n'en fixent pas (`proxy.timeoutMs`). */
+    readonly defaultTimeoutMs: number;
+    /** Délai d'établissement de la connexion amont (`proxy.connectTimeoutMs`). */
+    readonly connectTimeoutMs: number;
+    /** Connexions simultanées par amont (`proxy.maxSockets`) : pool ET tunnels WebSocket. */
+    readonly maxSockets: number;
+    /**
+     * Nom de CE processus dans `Via` (RFC 9110 §7.6.3) : tiré au hasard au
+     * démarrage, il ne dit rien de la machine et distingue deux instances —
+     * un message qui le porte déjà est une boucle (508).
+     */
+    readonly pseudonym: string;
+    constructor(module: Module);
+    /**
+     * Relaie un préfixe d'URL vers un amont. Idempotent pour un même module :
+     * un même préfixe est remplacé. Un module qui recouvre un préfixe de la
+     * CONFIGURATION le remplace aussi, mais le dit — l'auteur de l'application
+     * doit pouvoir lire pourquoi son montage ne sert plus.
+     *
+     * @param prefix - préfixe d'URL (normalisé : `/` en tête et en fin)
+     * @param options - cible et réglages du montage
+     * @throws Error qui nomme chaque refus (préfixe `/` ou réservé, cible qui
+     *   n'est pas une origine http(s) nue, `secure: false` hors boucle locale…)
+     */
+    mount(prefix: string, options: IProxyMountOptions): void;
+    /**
+     * Retire un montage. Le dernier retiré rend `mounts` à `null` : le pipeline
+     * cesse alors de le consulter.
+     *
+     * @param prefix - préfixe tel que monté (normalisé de la même façon)
+     */
+    unmount(prefix: string): void;
+    /**
+     * Ferme tous les pools (arrêt du noyau). Les montages restent déclarés ; un
+     * relais encore en vol part ensuite sur une connexion à usage unique.
+     */
+    closeAll(): void;
+    /**
+     * Montage le plus spécifique qui couvre une URL, s'il y en a un.
+     *
+     * @param url - cible brute de la requête (chemin + requête)
+     * @returns le montage au préfixe le plus long qui couvre l'URL
+     */
+    match(url: string | undefined): IProxyMount | undefined;
+    /**
+     * Origine courante d'un montage, analysée — mise en cache tant que la cible
+     * rend la même chaîne.
+     *
+     * @returns l'URL de l'amont, ou `undefined` si rien n'est relayable
+     */
+    private targetOf;
+    /**
+     * Pool de connexions d'un montage, créé au premier relais et recréé si la
+     * cible change de scheme.
+     *
+     * Un `Agent` DÉDIÉ, jamais l'agent global : sous `NODE_USE_ENV_PROXY`, cas
+     * courant d'un poste d'entreprise, l'agent global envoie tout vers
+     * `HTTP_PROXY` — un amont sur la boucle locale serait demandé au proxy de
+     * l'entreprise. Un agent construit ici n'a pas de `proxyEnv` : il va droit
+     * à la cible. Keep-alive borné (`maxSockets`), `lifo` : le socket le plus
+     * récent, le moins susceptible d'avoir été fermé par l'amont.
+     */
+    private agentFor;
+    /** Réglages de relais d'un montage. */
+    private relayFor;
+    /** Règles du noyau HTTP (résolues par nom), `undefined` hors serveur. */
+    private rules;
+    /** Ce que le proxy annonce à l'amont sur le client. */
+    private fromOf;
+    /**
+     * Relaie une requête HTTP si un montage la couvre — méthode comprise. Cible
+     * pas encore connue → `503` + `Retry-After`, sans aller jusqu'au routage.
+     *
+     * L'appelant a déjà tranché la barrière d'hôte : c'est le pipeline HTTP, qui
+     * la calcule pour toute requête (`Context.validDomain`). Un chemin ambigu
+     * sous un préfixe monté rend 400, sans contacter l'amont.
+     *
+     * ⚠️ Un préfixe monté est servi AVANT le pare-feu, la CSRF et les en-têtes
+     * de sécurité applicatifs : c'est une surface publique pour qui atteint
+     * Nodefony. L'amont porte sa propre politique d'accès.
+     *
+     * @param req - requête du client
+     * @param res - réponse au client
+     * @param scheme - scheme par lequel le client est arrivé
+     * @returns la promesse de fin d'échange, ou `undefined` si la requête n'est
+     *   pas relayée (hors préfixe ou méthode non relayée : elle suit alors son
+     *   chemin normal)
+     */
+    forward(req: ProxiedRequest, res: ProxiedResponse, scheme: string): Promise<void> | undefined;
+    /**
+     * Relaie un upgrade WebSocket si un montage `websocket` couvre son URL.
+     * Appelé par le répartiteur d'`upgrade` des serveurs WebSocket, AVANT le
+     * serveur WebSocket de Nodefony.
+     *
+     * Contrôles, dans l'ordre, chacun avec la réponse que rendrait le serveur
+     * WebSocket de Nodefony : cible pas encore connue → 503 ; `Host` hors `trustedHosts` (si `domainCheck`) →
+     * 421 ; chemin ambigu ou handshake non conforme (RFC 6455 §4.2.1 — seul
+     * `Upgrade: websocket` est relayé, jamais un tunnel `h2c`) → 400 ;
+     * `Origin` refusée par la MÊME règle que le serveur WebSocket (anti-CSWSH,
+     * RFC 6455 §10.2) → 403 ; `maxSockets` tunnels déjà ouverts vers l'amont →
+     * 503 ; quotas par IP du noyau (débit de handshakes, connexions
+     * simultanées) → 429. Le socket est alors consommé.
+     *
+     * @returns `true` si le proxy a pris le socket en charge
+     */
+    handleUpgrade(req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
+}
+export default ReverseProxy;

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,12 +1,12 @@
-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;
     private readonly httpKernel;
     options: IHttpConfig["websocketSecure"] & DefaultOptionsService;
     module: Module;
@@ -25,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,12 +1,12 @@
-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;
     private readonly httpKernel;
     options: IHttpConfig["websocket"] & DefaultOptionsService;
     module: Module;
@@ -25,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 };