@nodefony/http 10.0.0-alpha.9 → 10.0.0-beta.2

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

@@ -1,18 +1,18 @@
-import type pkg from "node-forge";
 import { Service, Module } from "nodefony";
-/**
- * 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 =`).
- */
-type ForgeModule = typeof import("node-forge");
+import { type KeyObject } from "node:crypto";
+import { type ICertificateAttribute } from "./x509.js";
+/** 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 +29,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 +37,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;
@@ -56,19 +56,19 @@ export interface CertificateOptions {
      * est un confort de DÉVELOPPEMENT — en production, fournir un vrai certificat
      * (Let's Encrypt, ingress, reverse-proxy) : Nodefony n'est pas une CA.
      */
-    strategy?: CertStrategyConfig;
+    strategy?: CertStrategyConfig | undefined;
     selfSigned: SelfSignedOptions;
     dev: CertificateDevOptions;
-    san?: CertificateSanOptions;
+    san?: CertificateSanOptions | undefined;
     /** Permissions POSIX de la clé privée écrite (0600 = owner-only). */
-    privateKeyMode?: number;
-    path?: string;
-    keyPath?: string;
-    certPath?: string;
-    caPath?: string;
-    key?: string | Buffer;
-    cert?: string | Buffer;
-    ca?: string | Buffer;
+    privateKeyMode?: number | undefined;
+    path?: string | undefined;
+    keyPath?: string | undefined;
+    certPath?: string | undefined;
+    caPath?: string | undefined;
+    key?: string | Buffer | undefined;
+    cert?: string | Buffer | undefined;
+    ca?: string | Buffer | undefined;
 }
 interface filesCertType {
     path: string;
@@ -96,7 +96,7 @@ 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).
  *
@@ -108,8 +108,7 @@ export interface CertificateInfo {
 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;
@@ -119,13 +118,6 @@ declare class Certificate extends Service {
     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 +130,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,7 +166,7 @@ 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).
      *
@@ -195,7 +179,7 @@ declare class Certificate extends Service {
      *   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;
@@ -248,30 +232,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/http-kernel.d.ts

@@ -1,6 +1,6 @@
 import { Service, Module, Scope, EnvironmentType, DebugType, nodefonyError } from "nodefony";
-import type { Resolver, Router } from "@nodefony/framework";
-import type { Controller } from "@nodefony/framework";
+import type { MaybePromise } from "nodefony";
+import type { IRouteResolver, IRequestRouter } from "../interfaces/IRouting.js";
 import HttpError from "../src/errors/httpError.js";
 import { type TrustProxyChecker } from "../src/context/trustProxy.js";
 import type { IRateLimitStore } from "../src/rateLimit/IRateLimitStore.js";
@@ -20,9 +20,11 @@ import Context, { HTTPMethod, WebSocketState } from "../src/context/Context.js";
 import Certicates from "./certificates.js";
 import SessionsService from "./sessions/sessions-service.js";
 import Session from "../src/session/session.js";
-import { Firewall } from "@nodefony/security";
+import type { IFirewallGate } from "../interfaces/ISecurity.js";
 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";
 export type ProtocolType = "1.1" | "2.0" | "3.0";
 export type httpRequest = http.IncomingMessage | http2.Http2ServerRequest;
 export type httpResponse = http.ServerResponse | http2.Http2ServerResponse;
@@ -31,11 +33,11 @@ export type ServerType = "http" | "https" | "http2" | "http3" | "websocket" | "w
 export type responseTimeoutType = "http" | "https" | "http2" | "http3";
 export type SchemeType = "http" | "https" | "ws" | "wss";
 export interface WsMetaData {
-    type?: "message" | "handshake";
-    state?: WebSocketState;
-    messageType?: "utf8" | "binary";
-    protocol?: string | null;
-    id?: string;
+    type?: "message" | "handshake" | undefined;
+    state?: WebSocketState | undefined;
+    messageType?: "utf8" | "binary" | undefined;
+    protocol?: string | null | undefined;
+    id?: string | undefined;
 }
 /**
  * Vue minimale d'une route exposée dans l'enveloppe `nodefony.route` (frame WS
@@ -46,32 +48,33 @@ export interface WsMetaData {
  */
 export interface RouteMetaData {
     name: string;
-    path?: string;
+    path?: string | undefined;
     variablesMap: Record<string, unknown>;
 }
 export interface MetaData {
-    name?: string;
-    version?: string;
-    url?: URL | string;
-    environment?: EnvironmentType;
-    debug?: DebugType;
-    token?: string;
-    method?: HTTPMethod;
-    scheme?: SchemeType;
-    requestId?: string;
-    websocket?: WsMetaData;
-    route?: RouteMetaData;
+    name?: string | undefined;
+    version?: string | undefined;
+    url?: URL | string | undefined;
+    environment?: EnvironmentType | undefined;
+    debug?: DebugType | undefined;
+    token?: string | undefined;
+    method?: HTTPMethod | undefined;
+    scheme?: SchemeType | undefined;
+    requestId?: string | undefined;
+    websocket?: WsMetaData | undefined;
+    route?: RouteMetaData | undefined;
 }
 export interface Data {
-    error?: Error;
+    error?: Error | undefined;
     nodefony: MetaData;
     message?: unknown;
-    code?: number;
+    code?: number | undefined;
     result: unknown;
 }
 import type { IHttpKernel as IHttpKernelInterface } from "../interfaces/IHttpKernel.js";
 declare class HttpKernel extends Service implements IHttpKernelInterface {
     #private;
+    options: IHttpConfig & DefaultOptionsService;
     certificates: unknown;
     serviceCerticats: Certicates | null;
     key: string;
@@ -79,12 +82,12 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     ca: string;
     serverStatic: Statics | null;
     domain: string;
-    trustedHosts?: ITrustedHostsConfig;
+    trustedHosts?: ITrustedHostsConfig | undefined;
     domainCheck: boolean;
     regAlias: RegExp[];
     module: Module;
-    httpsPort?: number;
-    httpPort?: number;
+    httpsPort?: number | undefined;
+    httpPort?: number | undefined;
     responseTimeout: {
         http: number;
         https: number;
@@ -98,9 +101,9 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     private secContentTypeOptions;
     private secFrameOptions;
     private secHsts;
-    sessionService?: SessionsService | null;
-    router?: Router | null;
-    firewall?: Firewall | null;
+    sessionService?: SessionsService | null | undefined;
+    router?: IRequestRouter | null | undefined;
+    firewall?: IFirewallGate | null | undefined;
     private errorRenderer;
     private requestLogger;
     private profiler;
@@ -225,7 +228,17 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * gagne toujours sur la config (idempotent — last setter wins).
      */
     private applyRequestLoggerFromConfig;
-    handle(request: httpRequest, response: httpResponse | null, type: ServerType): Promise<HttpContext>;
+    /**
+     * Ouvre le scope `request` de la requête et la confie au pipeline HTTP.
+     *
+     * Pas `async` : rien n'y est attendu — la fonction rend directement ce que
+     * rend le pipeline, sans l'envelopper dans une promesse (#505).
+     *
+     * @returns le contexte servi, ou sa promesse (celle de {@link handleHttp}).
+     * @throws de façon synchrone si le scope `request` n'est pas déclaré — faute
+     *   de configuration ; l'appelant ({@link onHttpRequest}) l'absorbe.
+     */
+    handle(request: httpRequest, response: httpResponse | null, type: ServerType): MaybePromise<HttpContext>;
     /**
      * Arme le contexte pour l'exécution : zone firewall (`context.secure`) et
      * résolveur de route — **sans instancier le controller**.
@@ -237,13 +250,16 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * elle, exécute du code utilisateur (`initialize()`) et résout des dépendances
      * DI : elle n'a rien à faire avant que la requête soit autorisée.
      *
+     * Synchrone : le match est un calcul pur, rien n'y est attendu (#505).
+     *
      * @param checkFirewall - calcule `context.secure` (zone protégée) ; laissé à
      *   `false` par un appelant qui l'a déjà tranché.
+     * @returns le résolveur de la route, posé sur `context.resolver`.
      * @throws HttpError 404 quand aucune route ne matche, ou l'exception portée
-     *   par le résolveur (405…) — inchangé, et toujours avant le firewall : une
-     *   route inexistante ne devient pas un 401.
+     *   par le résolveur (405…) — de façon SYNCHRONE, et toujours avant le
+     *   firewall : une route inexistante ne devient pas un 401.
      */
-    prepareFrontController(context: ContextType, checkFirewall?: boolean): Promise<Resolver>;
+    prepareFrontController(context: ContextType, checkFirewall?: boolean): IRouteResolver;
     /**
      * {@link prepareFrontController} + instanciation immédiate du controller
      * (DI + hook `initialize()`).
@@ -254,7 +270,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      *   est trop tard. Le HTTP, lui, arme la route ici et laisse
      *   `Resolver.executeAction` créer l'instance une fois la requête autorisée.
      */
-    handleFrontController(context: ContextType, checkFirewall?: boolean): Promise<Controller>;
+    handleFrontController(context: ContextType, checkFirewall?: boolean): Promise<object>;
     /**
      * Handles errors by setting appropriate response codes and messages.
      *
@@ -300,7 +316,29 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     getRequestLogger(): IRequestLogger;
     onError(error: Error | HttpError | nodefonyError, context?: ContextType, _extraHeaders?: Record<string, unknown> | object): Promise<HttpContext | WebsocketContext>;
     compileAlias(): RegExp[];
-    onHttpRequest(request: httpRequest, response: httpResponse, type: ServerType): Promise<unknown>;
+    /**
+     * Point d'entrée d'une requête HTTP, appelé par les serveurs depuis leur
+     * écouteur `request`.
+     *
+     * Ne lève et ne rejette JAMAIS : dans un écouteur d'événement, une exception
+     * deviendrait une erreur non capturée du processus. Ce qui échappe au
+     * pipeline a déjà été traité — rendu au client par `onError`, qui journalise
+     * en CRITIC l'échec de son propre rendu avant de le relever. C'était le
+     * `.catch` vide des serveurs ; il vit désormais ici, une seule fois.
+     *
+     * @returns `undefined` quand la requête est servie sans pipeline (sonde de
+     *   santé, 429) ; sinon la promesse de la fin du pipeline — elle ne rejette
+     *   pas, et personne n'est tenu de l'attendre.
+     */
+    onHttpRequest(request: httpRequest, response: httpResponse, type: ServerType): Promise<void> | undefined;
+    /**
+     * Le travail d'{@link onHttpRequest} : en-têtes de transport, sondes de
+     * santé, rate-limit, hook `onServerRequest`, puis le pipeline.
+     *
+     * @returns `undefined` quand la requête est servie ici ; sinon la promesse du
+     *   pipeline.
+     */
+    private dispatchHttpRequest;
     initServers(): Promise<(httpServer | httpsServer | websocketServer | websocketSecureServer)[]>;
     /**
      * Publie les ports EFFECTIFS du runtime (state file), une fois l'écoute établie.
@@ -342,24 +380,136 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * session (lazy). Remplace l'ancien `sessionAutoStart` global « démarre sur
      * toutes les routes » (le moteur du ×23).
      *
+     * Le contrat de retour suit ce qui est réellement attendu : `null` tout de
+     * suite quand aucune session n'est à ouvrir (le cas nominal — ni intent, ni
+     * cookie), la promesse de la session seulement quand le store est interrogé
+     * (#505).
+     *
      * @param context - contexte HTTP/HTTP2/WS courant.
-     * @returns la session active, ou `null` si la requête n'en requiert aucune.
+     * @returns `null` si la requête n'en requiert aucune ; sinon la promesse de
+     *   la session active.
      */
-    startSession(context: WebsocketContext | HttpContext): Promise<Session | null>;
+    startSession(context: WebsocketContext | HttpContext): MaybePromise<Session | null>;
     /**
-     * Teardown post-réponse — fire-and-forget depuis le `once("close")` posé par
-     * `createHttpContext` (un seul fire possible : once auto-détaché). Loggue la
-     * requête, draine les hooks afterResponse/onFinish, libère le scope DI.
+     * Teardown post-réponse — fire-and-forget depuis l'écouteur `close` posé par
+     * `createHttpContext`. Loggue la requête, draine les hooks
+     * afterResponse/onFinish, libère le scope DI.
+     *
+     * Synchrone dans le cas nominal — aucun hook `onAfterResponse`, aucun écouteur
+     * `onFinish` : rien n'y est attendu (#505). Ne lève et ne rejette jamais —
+     * l'appelant est un écouteur d'événement : une faute est journalisée, et le
+     * scope TOUJOURS libéré.
+     *
+     * @returns `undefined` quand le démontage est terminé ; sinon la promesse de
+     *   sa fin, qui ne rejette pas.
      */
     private teardownHttp;
+    /**
+     * Suite ASYNCHRONE du démontage, quand il y a des hooks à attendre :
+     * `onAfterResponse` puis `onFinish`, avant de libérer le contexte. Ne rejette
+     * jamais (cf {@link teardownHttp}).
+     */
+    private finishTeardownHttp;
+    /** Fin d'un contexte HTTP : marqué fini, scope DI libéré, contexte nettoyé. */
+    private releaseHttpContext;
+    /**
+     * R2 — le démontage est fire-and-forget : un throw (hook onFinish /
+     * afterResponse) serait une erreur non capturée du processus. On journalise,
+     * et on GARANTIT la libération du scope DI (sinon le scope `request` fuit à
+     * chaque hook qui lève).
+     */
+    private failTeardownHttp;
     createHttpContext(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): HttpContext;
-    handleHttp(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): Promise<HttpContext>;
-    onRequestEnd(context: HttpContext, error?: Error | null | undefined): Promise<HttpContext | number>;
+    /**
+     * Crée le contexte HTTP de la requête et la sert dans sa bulle ALS ; toute
+     * erreur — synchrone ou rejet — passe par {@link onError}.
+     *
+     * Pas `async` : un GET servi par une action synchrone traverse le pipeline
+     * sans une seule promesse (#505). Une promesse seulement quand une étape
+     * attend, ou quand l'erreur est rendue (`onError`).
+     *
+     * @returns le contexte servi, ou sa promesse.
+     */
+    handleHttp(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): MaybePromise<HttpContext>;
+    /**
+     * Traceparent, tampon du profileur, puis le pipeline dans la bulle ALS de la
+     * requête (`RequestContext.run`).
+     */
+    private serveHttpContext;
+    /**
+     * Chemin d'erreur de {@link handleHttp} : libère le scope d'un contexte qui
+     * n'a pas pu se construire, puis rend l'erreur au client (`onError`).
+     */
+    private failHttp;
+    /**
+     * Le trajet d'une requête HTTP DANS la bulle ALS : CORS, calque de
+     * configuration, route, en-têtes de sécurité, repli statique, corps, gardes,
+     * action.
+     *
+     * Chaque étape rend sa valeur, ou une promesse quand elle attend réellement
+     * (préflight à terminer, hook asynchrone, fichier statique, corps à lire,
+     * session, pare-feu, action asynchrone) — et la suite ne s'enchaîne par
+     * `then` que dans ce cas. Un `await` sur une valeur déjà connue suspendait le
+     * pipeline pour rien : ~50 évènements asynchrones par GET (#505).
+     *
+     * @returns le contexte servi, ou la promesse de ce contexte.
+     * @throws l'erreur d'une étape synchrone — {@link handleHttp} la traite comme
+     *   un rejet (même `catch`, même `onError`).
+     */
+    private runHttpPipeline;
+    /**
+     * Route, en-têtes de sécurité applicatifs, repli statique — puis le corps.
+     * N'attend que le repli statique, et seulement quand aucune route ne matche.
+     */
+    private routeHttpRequest;
+    /**
+     * Le corps — lu seulement s'il y en a un à lire —, puis les gardes
+     * ({@link onRequestEnd}) et l'action. Chacun n'est attendu que s'il attend.
+     */
+    private serveHttpRequest;
+    /**
+     * Les gardes d'une requête HTTP, corps lu : en-têtes de scheme, domaine, hook
+     * `beforeResolve`, armement de la route, CSRF, session, pare-feu — dans cet
+     * ordre.
+     *
+     * Synchrone tant qu'aucune garde n'attend (#505) : le hook `beforeResolve`
+     * n'est attendu que s'il a un écouteur, la session que si la requête en
+     * ouvre une, le pare-feu que sur une zone protégée ou à accès contrôlé.
+     *
+     * @param context - le contexte de la requête.
+     * @param error - une erreur survenue en amont : relevée telle quelle.
+     * @returns le contexte une fois les gardes passées, ou la promesse de ce
+     *   contexte quand une garde attend.
+     * @throws de façon SYNCHRONE l'erreur reçue, l'exception du résolveur (404,
+     *   405…) et le refus CSRF ; un refus du pare-feu ou de session rompt la
+     *   promesse rendue.
+     */
+    onRequestEnd(context: HttpContext, error?: Error | null): MaybePromise<HttpContext>;
+    /**
+     * Suite d'{@link onRequestEnd} : armement de la route, CSRF, session, puis
+     * pare-feu. Synchrone tant que ni la session ni le pare-feu n'attendent.
+     */
+    private armAndGuard;
+    /**
+     * Le pare-feu d'une requête en zone protégée : `handleSecurity`, puis les
+     * hooks `afterAuth` (succès) ou `onAuthFailure` (refus, relevé ensuite).
+     *
+     * @returns la promesse du contexte autorisé.
+     * @throws (rejet) le refus du pare-feu, après `onAuthFailure`.
+     */
+    private runFirewall;
     createWebsocketContext(scope: Scope, req: IncomingMessage, ws: Ws, 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.
+     * Ne rejette jamais : toute erreur est journalisée (l'appelant est un
+     * é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>;
     private releaseOrphanWsScope;
-    onConnect(context: WebsocketContext, error?: null | undefined | unknown): Promise<Ws | number>;
+    onConnect(context: WebsocketContext | null, error?: unknown): Promise<Ws | number>;
     checkValidDomain(context: ContextType): number;
     isValidDomain(context: ContextType): boolean;
     /**

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

@@ -4,8 +4,11 @@ import http from "node:http";
 import http2 from "node:http2";
 import { AddressInfo } from "node:net";
 import { HttpTerminator } from "./serverShutdown.js";
+import type { IHttpConfig } from "../../config/config.js";
+import type { DefaultOptionsService } from "nodefony";
 declare class ServerHttp extends Service {
-    private httpKernel;
+    private readonly httpKernel;
+    options: IHttpConfig["http"] & DefaultOptionsService;
     module: Module;
     server: http.Server | http2.Http2Server | null;
     httpTerminator: HttpTerminator | null;

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

@@ -4,8 +4,11 @@ import https from "node:https";
 import http2 from "node:http2";
 import { HttpTerminator } 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 httpKernel;
+    private readonly httpKernel;
+    options: IHttpConfig["https"] & DefaultOptionsService;
     httpTerminator: HttpTerminator | null;
     module: Module;
     server: https.Server | http2.Http2SecureServer | null;

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

@@ -1,11 +1,14 @@
 import Ws, { 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 httpKernel;
+    private readonly httpKernel;
+    options: IHttpConfig["websocketSecure"] & DefaultOptionsService;
     module: Module;
     ready: boolean;
     server: WebSocketServer | null;

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

@@ -1,11 +1,14 @@
 import Ws, { 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 httpKernel;
+    private readonly httpKernel;
+    options: IHttpConfig["websocket"] & DefaultOptionsService;
     module: Module;
     ready: boolean;
     server: WebSocketServer | null;

package/dist/types/nodefony/service/sessions/sessions-service.d.ts

@@ -3,6 +3,8 @@ import type { IPage } from "nodefony";
 import type { ISessionStorage, ISessionSummary, ISessionRecord, ISessionListQuery } from "../../interfaces/ISession.js";
 import HttpKernel, { ContextType } from "../http-kernel.js";
 import Session, { OptionsSessionType } from "../../src/session/session.js";
+import type { IHttpConfig } from "../../config/config.js";
+import type { DefaultOptionsService } from "nodefony";
 import Certificate from "../../service/certificates.js";
 import type { ISessionCounts } from "../../src/session/storage/sessionFilters.js";
 export type sessionStrategyType = "none" | "migrate" | "invalidate";
@@ -25,6 +27,7 @@ export declare function computeSessionRef(secret: Buffer, id: string): string;
  * testée isolément).
  */
 export declare function toSessionSummary(rec: ISessionRecord, ref: string, currentRef?: string | null): ISessionSummary;
+export type ISessionServiceOptions = IHttpConfig["session"] & DefaultOptionsService;
 declare class SessionsService extends Service {
     httpKernel: HttpKernel;
     /**
@@ -48,12 +51,13 @@ declare class SessionsService extends Service {
     static getStorage(name: string): SessionStorageCtor | undefined;
     /** Noms des handlers de session enregistrés. */
     static storageHandlers(): string[];
+    options: ISessionServiceOptions;
     sessionStrategy: sessionStrategyType;
     storage: ISessionStorage | null;
     module: Module;
     defaultSessionName: string;
-    secret?: Buffer;
-    iv?: Buffer;
+    secret?: Buffer | undefined;
+    iv?: Buffer | undefined;
     certificates: Certificate | null;
     private gcScheduler;
     constructor(module: Module, httpKernel: HttpKernel);

package/dist/types/nodefony/service/upload/upload-service.d.ts

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import type { IParsedUploadFile } from "../../interfaces/IUpload.js";
 export declare class upload extends Service {
     httpKernel: HttpKernel;
-    path?: string | fs.PathLike;
+    path?: string | fs.PathLike | undefined;
     module: Module;
     constructor(module: Module, httpKernel: HttpKernel);
     /**