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

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

@@ -1,18 +1,99 @@
-import type pkg from "node-forge";
 import { Service, Module } from "nodefony";
+import { type KeyObject } from "node:crypto";
+import { type ICertificateAttribute } from "./x509.js";
 /**
- * Type-valeur du backend node-forge runtime (objet `.pki`/`.md`). L'import type
- * `pkg` sert pour les namespaces de types (`pkg.pki.Certificate`) ; `ForgeModule`
- * pour la valeur chargée dynamiquement (node-forge est un module `export =`).
+ * Accès à la liste d'ancres TLS par défaut du processus — injectable pour
+ * éprouver la décision sans toucher la confiance du processus de test.
  */
-type ForgeModule = typeof import("node-forge");
+export interface ITlsTrustStore {
+    getCACertificates?: (type?: "default") => string[];
+    setDefaultCACertificates?: (certs: ReadonlyArray<string>) => void;
+}
+/** Issue de {@link addDefaultCaCertificate}, CONSTATÉE à l'exécution. */
+export type CaTrustVerdict = "added" | "present" | "unsupported";
+/**
+ * Ajoute une autorité aux ancres TLS par défaut du processus (requêtes sortantes
+ * `fetch`, `https`, `tls.connect`), sans en retirer aucune.
+ *
+ * C'est l'équivalent en cours d'exécution de `NODE_EXTRA_CA_CERTS`, qui n'est lu
+ * qu'au lancement du processus — trop tôt pour une CA que le boot vient de
+ * générer, et que seul un script de banc posait. La capacité se CONSTATE
+ * (`tls.setDefaultCACertificates` n'existe qu'à partir de Node 24.5), elle ne se
+ * déduit pas d'un numéro de version. Idempotent : une autorité déjà présente
+ * n'est pas ajoutée deux fois.
+ *
+ * @param pem - autorité au format PEM.
+ * @param store - accès aux ancres ; `node:tls` par défaut.
+ * @returns `added`, `present` (déjà de confiance), ou `unsupported`.
+ */
+export declare function addDefaultCaCertificate(pem: string, store?: ITlsTrustStore): CaTrustVerdict;
+/**
+ * Découpe un fichier PEM en ses certificats — une chaîne d'entreprise est
+ * souvent livrée en un seul fichier (racine + intermédiaires).
+ *
+ * Chaque certificat est ajouté SÉPARÉMENT : c'est ce qui rend l'ajout
+ * idempotent certificat par certificat, la liste par défaut du processus
+ * n'étant faite que de certificats isolés.
+ *
+ * @param pem - contenu d'un fichier PEM (un ou plusieurs certificats)
+ * @returns les certificats, dans l'ordre du fichier ; vide s'il n'y en a aucun
+ */
+export declare function splitPemCertificates(pem: string): string[];
+/** Bilan de {@link trustCaFile}. */
+export interface ICaFileTrust {
+    /** Fichier lu, chemin absolu. */
+    readonly file: string;
+    /** Certificats ajoutés aux ancres du processus. */
+    readonly added: number;
+    /** Certificats déjà de confiance. */
+    readonly present: number;
+}
+/**
+ * Ajoute les autorités d'un fichier PEM aux ancres TLS du processus
+ * (`certificates.extraCaFiles`) — l'équivalent, porté par l'APPLICATION, de
+ * `NODE_EXTRA_CA_CERTS`.
+ *
+ * `NODE_EXTRA_CA_CERTS` n'est lu qu'au lancement de Node, et se pose dans la
+ * syntaxe du shell — `VAR=… npm run dev` n'existe pas sous Windows. Une autorité
+ * d'entreprise (Keycloak interne, proxy sortant qui ré-signe) se déclare donc
+ * dans la configuration, et sert à TOUTES les requêtes sortantes du processus :
+ * découverte OpenID, point de jeton, jeu de clés, appels d'administration.
+ *
+ * @param file - chemin du fichier, absolu ou relatif à `root`
+ * @param root - racine de l'application
+ * @param store - accès aux ancres ; `node:tls` par défaut
+ * @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>;
+/**
+ * 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}).
+ *
+ * @param files - `certificates.extraCaFiles`
+ * @param root - racine de l'application
+ * @param log - journal du module
+ * @throws BootConfigurationError - cf {@link trustCaFile}
+ */
+export declare function trustOutboundAuthorities(files: readonly string[], root: string, log: (message: string, severity: "INFO") => void): Promise<void>;
+/** Paire de clés RSA du certificat auto-signé. */
+export interface IRsaKeyPair {
+    privateKey: KeyObject;
+    publicKey: KeyObject;
+}
 /** Algorithmes de hachage de signature autorisés (SHA-1 banni). */
 export type CertHash = "sha256" | "sha384" | "sha512";
 /** Stratégie de fourniture du certificat exposée en configuration. */
 export type CertStrategyConfig = "auto" | "mkcert" | "selfsigned" | "explicit";
 /**
- * Options de génération du certificat AUTO-SIGNÉ (node-forge, JavaScript pur —
- * aucun binaire externe n'est invoqué).
+ * Options de génération du certificat AUTO-SIGNÉ (`node:crypto` — aucun
+ * binaire externe ni aucune dépendance tierce).
  *
  * ⚠️ Portée : ces réglages ne valent QUE pour la stratégie `selfsigned`. Sous
  * `mkcert` (le défaut en développement) ils sont ignorés — mkcert ne reçoit que
@@ -29,7 +110,7 @@ export interface SelfSignedOptions {
     /** Recul de `notBefore` (minutes) — tolérance au décalage d'horloge client. */
     backdateMinutes: number;
     /** Attributs du sujet/issuer (commonName, organizationName…). */
-    attrs: pkg.pki.CertificateField[];
+    attrs: ICertificateAttribute[];
 }
 /** Options de génération du certificat TLS en mode développement. */
 export interface CertificateDevOptions {
@@ -37,7 +118,7 @@ export interface CertificateDevOptions {
      * Préférer `mkcert` (CA locale ajoutée au trust store système) pour générer
      * le certificat de dev. Donne un HTTPS sans erreur navigateur — indispensable
      * pour les sous-ressources cross-origin (Vite) et le WSS du HMR.
-     * Si `mkcert` est absent, on retombe sur un auto-signé node-forge (non trusté).
+     * Si `mkcert` est absent, on retombe sur un auto-signé (non trusté).
      * Ignoré hors `development`.
      */
     useMkcert: boolean;
@@ -96,36 +177,26 @@ export interface CertificateInfo {
  *
  * Trois stratégies : `explicit` (certificat fourni en config — le cas de
  * PRODUCTION), `mkcert` (CA locale trustée, confort de dev) et `selfsigned`
- * (auto-signé node-forge, secours). La génération est réservée au
+ * (auto-signé, secours). La génération est réservée au
  * DÉVELOPPEMENT : en production sans certificat fourni, le service crie un
  * avertissement (Nodefony n'est pas une autorité de certification).
  *
  * Conformité (génération auto-signée) : signature SHA-256 (jamais SHA-1,
  * RFC 5280 / CA-B Forum), numéro de série aléatoire 128 bits unique
- * (RFC 5280 §4.1.2.2), SAN qui fait foi (RFC 6125), `notBefore` reculé,
+ * (RFC 5280 §4.1.2.2), SAN qui fait foi (RFC 9525), `notBefore` reculé,
  * clé privée écrite en `0600`.
  */
 declare class Certificate extends Service {
     module: Module;
     files: filesCertType[];
-    keysPair: pkg.pki.rsa.KeyPair | null;
-    certForge: pkg.pki.Certificate | null;
+    keysPair: IRsaKeyPair | null;
     ca: Buffer | string | null;
     key: Buffer | string | null;
     cert: Buffer | string | null;
     fullchainPem: Buffer | string | null;
     publicKeyPem: Buffer | string | null;
-    rootCertPem: Buffer | string | null;
-    intermediateCertPem: Buffer | string | null;
     /** CAROOT résolu de mkcert (null tant que non détecté / indisponible). */
     private mkcertCaRoot;
-    /**
-     * Backend crypto node-forge, chargé PARESSEUSEMENT. La génération de
-     * certificat est un confort de DÉVELOPPEMENT : en production avec un
-     * certificat fourni (`strategy: "explicit"`), cette grosse dépendance n'est
-     * jamais importée (règle perf-mémoire — pas de dep chargée « au cas où »).
-     */
-    private forge;
     path: string;
     serverPath: string;
     caPath: string;
@@ -138,14 +209,6 @@ declare class Certificate extends Service {
     private get certOptions();
     /** Vrai en environnement de développement (mkcert réservé à ce mode). */
     private isDev;
-    /**
-     * Charge node-forge à la demande (idempotent) — uniquement sur le chemin de
-     * GÉNÉRATION (selfsigned / mkcert / inspection). Le chemin `explicit` (prod)
-     * ne l'appelle jamais.
-     */
-    loadForge(): Promise<ForgeModule>;
-    /** Accès au backend forge déjà chargé (lève si `loadForge` n'a pas été appelé). */
-    private get forgeLib();
     /**
      * Fabrique-t-on un certificat au démarrage ?
      *
@@ -182,20 +245,32 @@ declare class Certificate extends Service {
     /**
      * Génère (ou recharge) le certificat serveur selon la stratégie résolue :
      * `explicit` (fourni en config / prod), `mkcert` (dev, CA trustée) ou
-     * `selfsigned` (auto-signé node-forge, secours). Régénère automatiquement si
+     * `selfsigned` (auto-signé, secours). Régénère automatiquement si
      * le certificat présent sur disque n'est pas adéquat pour la stratégie active
      * (expiré, SHA-1, SAN incomplet).
      *
      * @param force - forcer la régénération même si un certificat valide existe
      */
     generateServerCertificates(force?: boolean): Promise<this>;
+    /**
+     * En développement, fait confiance à la CA que Nodefony vient de générer ou de
+     * relire, pour les requêtes SORTANTES du processus.
+     *
+     * Sans elle, un service du décor qui sert le certificat de l'application
+     * (Keycloak, l'auto-vérification d'un jeton MCP) est injoignable depuis
+     * `nodefony development` — `fetch failed` / `SELF_SIGNED_CERT_IN_CHAIN` — alors
+     * que `curl -k` répond : la confiance n'existait que sous le script de banc.
+     * Réservé au DÉVELOPPEMENT et aux certificats que Nodefony fabrique : un
+     * certificat `explicit` (production) n'élargit jamais la confiance du processus.
+     */
+    private trustDevelopmentAuthority;
     /**
      * Résout la stratégie effective à partir de `certificates.strategy` :
      * - `explicit` : `key` + `cert` fournis (prod, Let's Encrypt…). Forcé →
      *   erreur si absents.
      * - `mkcert` : dev + binaire mkcert + CA locale présents. Forcé hors dev →
      *   retombe sur `selfsigned` avec avertissement.
-     * - `selfsigned` : auto-signé node-forge (fallback). En PRODUCTION, crie un
+     * - `selfsigned` : auto-signé (fallback). En PRODUCTION, crie un
      *   avertissement : la génération n'est pas le rôle d'un serveur de prod.
      */
     private resolveStrategy;
@@ -209,7 +284,7 @@ declare class Certificate extends Service {
     /**
      * SAN effectif : config explicite si fournie, sinon dérivé du kernel
      * (localhost + domain en DNS ; loopback en IP). Une IP littérale (ex. domain
-     * `127.0.0.1` en dev) est classée en `ip`, pas en `dns` (RFC 6125).
+     * `127.0.0.1` en dev) est classée en `ip`, pas en `dns` (RFC 9525).
      */
     private derivedSan;
     /** Hostnames DNS couverts par le SAN. */
@@ -233,7 +308,7 @@ declare class Certificate extends Service {
      * @returns false si absent, illisible ou inadéquat → déclenche la régénération.
      */
     private isCertAdequate;
-    /** Le SAN présent couvre-t-il tous les noms DNS requis (RFC 6125) ? */
+    /** Le SAN présent couvre-t-il tous les noms DNS requis (RFC 9525) ? */
     private sanCovers;
     /** Charge un certificat fourni en config (chemin fichier ou Buffer). */
     private loadExplicitCert;
@@ -248,30 +323,31 @@ declare class Certificate extends Service {
      * par mkcert passe aussi par ici). Échec silencieux hors POSIX.
      */
     private restrictPrivateKey;
-    generateKeys(): pkg.pki.rsa.KeyPair;
+    /** Génère la paire RSA (taille configurée) hors de la boucle d'événements. */
+    generateKeys(): Promise<IRsaKeyPair>;
+    /** Clé privée en PEM PKCS#1 (`BEGIN RSA PRIVATE KEY`). */
     generatePrivateKeyPem(): Buffer;
+    /** Clé publique en PEM SPKI (`BEGIN PUBLIC KEY`). */
     generatePublickeyPem(): Buffer;
-    generateCertPem(): Buffer;
-    createCertificate(): pkg.pki.Certificate;
-    /** subjectAltName de l'auto-signé : DNS + IP (config explicite sinon dérivé). */
-    private altNames;
-    setExtension(): void;
     /**
-     * Signe le certificat avec le hachage configuré (SHA-256 par défaut).
-     * SHA-1 est INTERDIT (collision SHAttered 2017, CA/Browser Forum depuis 2016) :
-     * `node-forge` signe en SHA-1 par défaut si on ne passe pas de digest → on en
-     * passe toujours un.
+     * Fabrique et signe le certificat auto-signé avec la paire courante.
+     *
+     * Série aléatoire unique (RFC 5280 §4.1.2.2), `notBefore` reculé (décalage
+     * d'horloge du client), SAN DNS + IP (config explicite sinon dérivé), signé
+     * avec le hachage configuré — jamais SHA-1 (collision SHAttered 2017,
+     * CA/Browser Forum depuis 2016).
+     *
+     * @returns le certificat en PEM
+     * @throws Si la paire de clés n'a pas été générée
      */
-    sign(): void;
+    createCertificate(): Promise<Buffer>;
     /**
      * Résumé introspectable du certificat serveur courant — réutilisé par la
      * commande CLI `certificates` et un futur endpoint d'admin Studio (parité
-     * CLI ↔ Web). Parse le certificat chargé (charge node-forge à la demande).
+     * CLI ↔ Web).
      */
     describe(): Promise<CertificateInfo>;
-    /** Nom lisible de l'OID d'algorithme de signature. */
-    private oidName;
-    /** Digest node-forge correspondant au hachage configuré (jamais SHA-1). */
-    private digestFor;
+    /** Hachage configuré, ramené à SHA-256 s'il sort du contrat (jamais SHA-1). */
+    private allowedHash;
 }
 export default Certificate;

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

@@ -69,7 +69,7 @@ export declare function schemaMismatchOf(error: unknown): SchemaMismatchConfiden
  *   reason: error.message
  *
  * Stateless singleton — zero per-request allocation. Override via
- * `httpKernel.setErrorRenderer(custom)` for prod hardening or RFC 7807.
+ * `httpKernel.setErrorRenderer(custom)` for prod hardening or RFC 9457.
  */
 declare class DefaultErrorRenderer implements IErrorRenderer {
     renderHttp(error: Error, context: IHttpContext): IErrorHttpResult;

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

@@ -7,13 +7,14 @@ 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 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 HttpContext from "../src/context/http/HttpContext.js";
 import Context, { HTTPMethod, WebSocketState } from "../src/context/Context.js";
@@ -25,9 +26,21 @@ 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";
@@ -81,13 +94,28 @@ 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;
@@ -196,6 +224,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 +348,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;
@@ -527,5 +571,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/server-websocket-secure.d.ts

@@ -7,6 +7,7 @@ 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;

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

@@ -7,6 +7,7 @@ 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;