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

package/dist/nodefony/src/servers/upgradeDispatch.js

@@ -0,0 +1,49 @@
+import { refuseUpgrade } from "../proxy/forward.js";
+import { STATUS_CODES } from "node:http";
+//#region nodefony/src/servers/upgradeDispatch.ts
+/**
+* Pose l'UNIQUE écouteur `upgrade` d'un serveur : le proxy inverse d'abord,
+* puis le serveur WebSocket de Nodefony.
+*
+* Pourquoi un seul écouteur : `ws` attaché par son option `server` prend TOUS
+* les upgrades et répond `400` à ceux qu'il ne reconnaît pas. Un second
+* écouteur, même posé avant, ne l'empêcherait pas de répondre sur un socket
+* déjà relayé. Le serveur `ws` est donc créé en `noServer`, et c'est ici que
+* l'upgrade lui est confié — avec ses propres contrôles intacts (`path`,
+* `verifyClient`, `maxPayload`…), que `handleUpgrade` applique.
+*
+* Entre les deux, `refusal` tranche ce qui doit être refusé AVANT le `101`
+* (RFC 6455 §4.2.2) : un chemin sans route WebSocket reçoit un statut HTTP,
+* jamais une ouverture suivie d'une fermeture.
+*
+* Sans montage, le coût par connexion est une lecture de champ.
+*
+* @param server - serveur HTTP(S) qui reçoit les upgrades
+* @param wss - serveur WebSocket de Nodefony (`noServer: true`)
+* @param relay - proxy inverse, lu à chaque upgrade (il peut naître après)
+* @param refusal - statut HTTP qui refuse l'upgrade, `null` pour l'admettre
+*   (cf `HttpKernel.websocketUpgradeRefusal`)
+* @returns la fonction qui retire l'écouteur — à appeler à l'arrêt
+*/
+function attachUpgradeDispatch(server, wss, relay, refusal) {
+	const onUpgrade = (req, socket, head) => {
+		const proxy = relay();
+		if (proxy !== null && proxy.mounts !== null) {
+			if (proxy.handleUpgrade(req, socket, head)) return;
+		}
+		const status = refusal(req);
+		if (status !== null) {
+			refuseUpgrade(socket, status, STATUS_CODES[status] ?? "Refused");
+			return;
+		}
+		wss.handleUpgrade(req, socket, head, (ws) => {
+			wss.emit("connection", ws, req);
+		});
+	};
+	server.on("upgrade", onUpgrade);
+	return () => {
+		server.removeListener("upgrade", onUpgrade);
+	};
+}
+//#endregion
+export { attachUpgradeDispatch };

package/dist/nodefony/src/session/session.js

@@ -9,6 +9,20 @@ const defaultSessionOptions = {
 };
 /** Taille de l'identifiant opaque (octets CSPRNG → base64url, 43 chars). */
 const SESSION_ID_BYTES = 32;
+/** Un sac de session relu du storage : objet, ni `null` ni tableau. */
+function isBag(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Une date relue du storage : `Date` d'un store mémoire, chaîne ou nombre d'un
+* store sérialisé. Toute autre forme → `undefined` (la valeur courante reste).
+* Convertie UNE fois à la lecture : `created`/`updated` sont alors toujours des
+* `Date`, et les contrôles du chemin chaud lisent `getTime()` sans allouer.
+*/
+function toDate(v) {
+	if (v instanceof Date) return v;
+	return typeof v === "string" || typeof v === "number" ? new Date(v) : void 0;
+}
 /**
 * Session serveur Nodefony — état persistant lié à une identité, indexé par un
 * identifiant **opaque** (porté par le cookie) dans un {@link ISessionStorage}
@@ -157,16 +171,19 @@ var Session = class {
 	* `onSaveSession`.
 	*
 	* @param user - principal authentifié (string) lié au blob ; défaut courant.
+	*   Fourni, il DEVIENT le principal de la session : une sauvegarde suivante,
+	*   dans la même requête, le garde sans qu'on le lui redonne.
 	*/
 	async save(user) {
+		if (user !== void 0) this.user = user;
 		if (this.readOnly) {
 			if (this.mutated) this.log(`READONLY SESSION mutated — write skipped : ${this.name}`, "WARNING");
 			return this;
 		}
 		if (!this.mutated) return this;
 		const stored = await this.storage.write(this.id, this.serialize(user));
-		this.created = stored.createdAt ?? this.created;
-		this.updated = stored.updatedAt ?? this.updated;
+		this.created = toDate(stored.createdAt) ?? this.created;
+		this.updated = toDate(stored.updatedAt) ?? this.updated;
 		this.mutated = false;
 		this.saved = true;
 		if (this.context) await this.context.fireAsync("onSaveSession", this);
@@ -234,15 +251,14 @@ var Session = class {
 		}
 		const now = Date.now();
 		if (this.options.absoluteTimeoutS && this.created) {
-			if (now - new Date(this.created).getTime() > this.options.absoluteTimeoutS * 1e3) {
+			if (!(now - this.created.getTime() <= this.options.absoluteTimeoutS * 1e3)) {
 				this.log(`SESSION EXPIRED (absolute) ==> ${this.name} : ${this.id}`, "WARNING");
 				return false;
 			}
 		}
 		const idleS = this.options.idleTimeoutS;
 		if (idleS && idleS > 0 && this.updated) {
-			const lastUsed = new Date(this.updated).getTime();
-			if (lastUsed && lastUsed + idleS * 1e3 < now) {
+			if (!(this.updated.getTime() + idleS * 1e3 >= now)) {
 				this.log(`SESSION EXPIRED (idle) ==> ${this.name} : ${this.id}`, "WARNING");
 				return false;
 			}
@@ -270,7 +286,7 @@ var Session = class {
 		if (typeof storage.touch !== "function") return;
 		if (!this.updated) return;
 		const now = Date.now();
-		const lastUsed = new Date(this.updated).getTime();
+		const lastUsed = this.updated.getTime();
 		if (lastUsed && now - lastUsed < idleS * 1e3 / 2) return;
 		await storage.touch(this.id, idleS);
 		this.updated = new Date(now);
@@ -356,12 +372,12 @@ var Session = class {
 	}
 	deSerialize(serialized) {
 		const data = serialized;
-		if (data.Attributes) for (const k in data.Attributes) this.attributesBag[k] = data.Attributes[k];
-		if (data.metaBag) for (const k in data.metaBag) this.metaBagStore[k] = data.metaBag[k];
-		if (data.flashBag) for (const k in data.flashBag) this.flashBag[k] = data.flashBag[k];
-		this.created = data.createdAt ?? this.created;
-		this.updated = data.updatedAt ?? this.updated;
-		if (data.user) this.user = data.user;
+		if (isBag(data.Attributes)) for (const k in data.Attributes) this.attributesBag[k] = data.Attributes[k];
+		if (isBag(data.metaBag)) for (const k in data.metaBag) this.metaBagStore[k] = data.metaBag[k];
+		if (isBag(data.flashBag)) for (const k in data.flashBag) this.flashBag[k] = data.flashBag[k];
+		this.created = toDate(data.createdAt) ?? this.created;
+		this.updated = toDate(data.updatedAt) ?? this.updated;
+		if (typeof data.user === "string" && data.user) this.user = data.user;
 	}
 	/** Réinitialise les trois sacs (attributs, métas, flash) — état vide. */
 	clear() {

package/dist/types/index.d.ts

@@ -76,10 +76,15 @@ export type { DomainPattern, ITrustedHostsConfig, } from "./nodefony/src/context
 export { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
 export type { IRateLimitStore, IRateLimitOptions, RateLimitVerdict, } from "./nodefony/src/rateLimit/IRateLimitStore.js";
 export { Context, Session, SessionsService, HttpError, HttpKernel, Response, Http2Response, Response as HttpResponse, wsResponse, wsResponse as WebsocketResponse, Cookie, HttpContext, WebsocketContext, HttpRequest, Http2Request, DefaultErrorRenderer, DefaultRequestLogger, JsonAuditLogger, PrettyRequestLogger, Profiler, };
+export { SseStream, openSseStream, acceptsEventStream, SSE_HEARTBEAT_MS, } from "./nodefony/src/context/http/SseStream.js";
+export type { ISseStreamOptions, ISseSendOptions, } from "./nodefony/src/context/http/SseStream.js";
 export { schemaMismatchOf, type SchemaMismatchConfidence, } from "./nodefony/service/error-renderer.js";
 export type { ProfileEntry, ProfileSummary, ProfilePhase, ProfileQuery, ProfileSecurity, } from "./nodefony/src/profiler/Profiler.js";
 export { FrameProfile } from "./nodefony/src/profiler/FrameProfile.js";
 export type { FrameProfileInit, ProfiledArea, ProfiledResolver, } from "./nodefony/src/profiler/FrameProfile.js";
+export { default as ReverseProxy } from "./nodefony/service/reverse-proxy.js";
+export { parseProxyOrigin, normalizePrefix, proxyMountProblems, } from "./nodefony/src/proxy/rules.js";
+export type { IProxyMount, IProxyMountOptions, ProxyTarget, } from "./nodefony/interfaces/IReverseProxy.js";
 export { resolveUiDelivery, PrebuiltUi, } from "./nodefony/src/assets/prebuiltUi.js";
 export type { UiDeliveryMode, UiDeliveryResolved, IUiDeliveryResolution, IUiDeliveryOptions, IPrebuiltUiOptions, } from "./nodefony/src/assets/prebuiltUi.js";
 export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType, WebSocketStateType, CookiesMap, ISecurityTrace, SecurityOutcome, } from "./nodefony/interfaces/IContext.js";

package/dist/types/nodefony/config/config.d.ts

@@ -67,6 +67,7 @@ export declare const httpConfigSchema: z.ZodObject<{
         key: z.ZodDefault<z.ZodString>;
         cert: z.ZodDefault<z.ZodString>;
         privateKeyMode: z.ZodDefault<z.ZodNumber>;
+        extraCaFiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
         san: z.ZodDefault<z.ZodObject<{
             dns: z.ZodDefault<z.ZodArray<z.ZodString>>;
             ip: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -184,6 +185,21 @@ export declare const httpConfigSchema: z.ZodObject<{
         readinessPath: z.ZodDefault<z.ZodString>;
         shutdownDelay: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>>;
+    proxy: z.ZodDefault<z.ZodObject<{
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        connectTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxSockets: z.ZodDefault<z.ZodNumber>;
+        mounts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            target: z.ZodString;
+            methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            websocket: z.ZodDefault<z.ZodBoolean>;
+            stripPrefix: z.ZodDefault<z.ZodBoolean>;
+            preserveHost: z.ZodDefault<z.ZodBoolean>;
+            stripHeaders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            secure: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
     wsMaxConnectionsPerIp: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strict>;
 /** Type de sortie (config normalisée + défauts appliqués). */

package/dist/types/nodefony/interfaces/IContext.d.ts

@@ -86,6 +86,8 @@ export interface IContext {
     cookieSession: ICookie | null | undefined;
     cookies: CookiesMap;
     user: unknown;
+    /** Identifiant de l'appelant authentifié (pare-feu), lisible au démontage. */
+    userIdentifier: string | null;
     error: Error | null | undefined;
     metaData: object;
     readonly phases: PhaseTiming[];

package/dist/types/nodefony/interfaces/IErrorRenderer.d.ts

@@ -46,7 +46,7 @@ export interface IErrorWebsocketResult {
  *
  * Override via `httpKernel.setErrorRenderer(custom)` to customise:
  *   - hide stack traces in prod
- *   - emit RFC 7807 problem+json
+ *   - emit RFC 9457 problem+json
  *   - inject auth challenge headers
  */
 export interface IErrorRenderer {

package/dist/types/nodefony/interfaces/IReverseProxy.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Origine d'un amont relayé : `scheme://hôte[:port]`, sans chemin.
+ *
+ * Une fonction quand l'origine n'est connue qu'à l'exécution (un serveur
+ * enfant qui choisit son port au démarrage) : elle est rappelée à chaque
+ * requête, et `undefined` signifie « l'amont n'est pas prêt » — la requête
+ * reçoit `503` (`Retry-After: 1`), l'upgrade WebSocket `503` avant tout `101` :
+ * le préfixe appartient à l'amont, le routage n'a rien à y répondre.
+ */
+export type ProxyTarget = string | (() => string | undefined);
+/**
+ * Réglages d'un montage du proxy inverse (`ReverseProxy.mount`).
+ *
+ * Les défauts sont ceux d'un relais sans surprise : toutes les méthodes, le
+ * chemin transmis tel quel, l'en-tête `Host` réécrit sur la cible, aucun
+ * en-tête retiré au-delà des en-têtes de connexion, certificat de la cible
+ * vérifié.
+ */
+export interface IProxyMountOptions {
+    /** Origine de l'amont (cf {@link ProxyTarget}). */
+    target: ProxyTarget;
+    /**
+     * Méthodes relayées (majuscules). Une autre méthode n'est PAS relayée : la
+     * requête poursuit jusqu'au routage. Absent = toutes.
+     */
+    methods?: readonly string[] | undefined;
+    /**
+     * Relaie aussi l'upgrade WebSocket du préfixe. Sans ce drapeau, un upgrade
+     * sur le préfixe reste au serveur WebSocket de Nodefony.
+     */
+    websocket?: boolean | undefined;
+    /**
+     * Retire le préfixe avant de transmettre le chemin (`/svc/a` → `/a`).
+     * Défaut `false` : l'amont reçoit le chemin complet — c'est le cas d'un
+     * serveur qui connaît déjà son préfixe (Vite et son `base`).
+     */
+    stripPrefix?: boolean | undefined;
+    /**
+     * Garde l'en-tête `Host` du client au lieu de le réécrire sur la cible.
+     * Défaut `false` : un amont qui filtre les noms d'hôte (Vite et son
+     * `allowedHosts`) reçoit le sien, et le nom d'origine part dans
+     * `X-Forwarded-Host`.
+     */
+    preserveHost?: boolean | undefined;
+    /**
+     * En-têtes de requête à ne pas transmettre (insensible à la casse) — ce
+     * dont l'amont n'a pas l'usage ne doit pas lui parvenir (`cookie`,
+     * `authorization` vers un serveur de sources, par exemple).
+     */
+    stripHeaders?: readonly string[] | undefined;
+    /**
+     * Délai d'inactivité de l'échange avec l'amont, en ms. Dépassé avant la
+     * réponse : 504. Absent = `proxy.timeoutMs` de la configuration (30 s par
+     * défaut). Ne s'applique pas à un WebSocket établi.
+     */
+    timeoutMs?: number | undefined;
+    /**
+     * Vérifie le certificat d'une cible `https:`. Défaut `true` — `false` n'est
+     * ACCEPTÉ que vers la boucle locale (refus au montage sinon).
+     */
+    secure?: boolean | undefined;
+}
+/** Un montage tel que le proxy le garde : préfixe normalisé + réglages. */
+export interface IProxyMount extends IProxyMountOptions {
+    /** Préfixe d'URL normalisé (`/` en tête et en fin). */
+    readonly prefix: string;
+}

package/dist/types/nodefony/interfaces/IRouting.d.ts

@@ -75,6 +75,22 @@ export interface IRequestRouter {
      * @returns le résolveur (`resolve === true` si une route a matché)
      */
     resolve(context: ContextType, cleanPathOverride?: string, methodOverride?: string): IRouteResolver;
+    /**
+     * Dit si au moins une route déclare le transport `WEBSOCKET` pour ce chemin.
+     *
+     * Lu AVANT le `101` : une socket vers un chemin sans route se refuse par un
+     * statut HTTP (RFC 6455 §4.2.2), jamais par une ouverture suivie d'une
+     * fermeture — un client qui sonde par une ouverture conclurait que le
+     * serveur l'a acceptée. La réponse est un SUR-ENSEMBLE de ce que
+     * {@link IRequestRouter.resolve} acceptera : l'hôte (`@Domain`), le
+     * sous-protocole et les exigences de variables ne sont pas jugés ici, ils
+     * restent des fermetures après ouverture — refuser à tort coûterait une
+     * connexion légitime.
+     *
+     * @param pathname - chemin de l'URL d'upgrade (WHATWG), barres finales comprises
+     * @returns `false` si aucune route WebSocket ne peut répondre à ce chemin
+     */
+    servesWebsocket(pathname: string): boolean;
     /**
      * Instance partagée d'un controller `scope: "singleton"`, créée une seule fois.
      *

package/dist/types/nodefony/interfaces/ISecurity.d.ts

@@ -42,4 +42,10 @@ export interface IFirewallGate {
     handleCors(context: ContextType): number | undefined;
     /** Pose les en-têtes de sécurité (CSP, HSTS…) de la réponse. */
     applySecurityHeaders(context: ContextType): void;
+    /**
+     * Le revalidateur de l'identité authentifiée de la requête courante, pour une
+     * connexion longue qui la gardera (flux SSE) : la même règle que les sockets
+     * WebSocket. `null` pour un anonyme — rien à révoquer.
+     */
+    currentRevalidator?(): ((nowMs?: number) => Promise<boolean>) | null;
 }

package/dist/types/nodefony/interfaces/index.d.ts

@@ -7,3 +7,4 @@ export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType,
 export type { IHttpKernel } from "./IHttpKernel.js";
 export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./IRouting.js";
 export type { ISecurityZone, IFirewallGate } from "./ISecurity.js";
+export type { IProxyMount, IProxyMountOptions, ProxyTarget, } from "./IReverseProxy.js";

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

@@ -17,7 +17,8 @@ import type { IHttpContext, IWebsocketContext, PhaseTiming } from "../interfaces
 export interface AuditLogEntry {
     ts: string;
     requestId: string;
-    userId: string | null;
+    /** Identifiant de l'appelant authentifié (`context.userIdentifier`), `null` sinon. */
+    userIdentifier: string | null;
     type: "http" | "ws";
     scheme: string;
     method: string | null;

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

@@ -1,6 +1,87 @@
 import { Service, Module } from "nodefony";
 import { type KeyObject } from "node:crypto";
 import { type ICertificateAttribute } from "./x509.js";
+/**
+ * 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.
+ */
+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;
@@ -102,7 +183,7 @@ export interface CertificateInfo {
  *
  * 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 {
@@ -114,8 +195,6 @@ declare class Certificate extends Service {
     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;
     path: string;
@@ -173,6 +252,18 @@ declare class Certificate extends Service {
      * @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é →
@@ -193,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. */
@@ -217,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;

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;