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

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

@@ -1,6 +1,6 @@
 import type { Severity } from "nodefony";
 import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
-import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+import type { IHttpContext, IWebsocketContext, PhaseTiming } from "../interfaces/IContext.js";
 /**
  * Canonical audit log entry — 1 JSON PDU per request (P3.1).
  *
@@ -32,9 +32,9 @@ export interface AuditLogEntry {
     phases?: {
         name: string;
         durationMs: number | null;
-    }[];
-    error?: AuditErrorEntry;
-    protocol?: string | null;
+    }[] | undefined;
+    error?: AuditErrorEntry | undefined;
+    protocol?: string | null | undefined;
 }
 /**
  * Enriched error description for audit logs (P3.5).
@@ -51,6 +51,15 @@ export interface AuditErrorEntry {
     /** Recursive — capped to depth 5 to avoid pathological cycles. */
     cause?: AuditErrorEntry;
 }
+/**
+ * Durée totale de la requête, de la première phase (`startMs`) à maintenant.
+ * `null` si le chronométrage est coupé (aucune phase enregistrée). Partagée
+ * par le journal d'audit et le journal lisible — une seule définition.
+ *
+ * @param phases - phases chronométrées du contexte
+ * @returns durée en millisecondes, ou `null`
+ */
+declare function computeDurationMs(phases: PhaseTiming[]): number | null;
 /**
  * Severity derived from HTTP status code — RFC 9110 categories.
  * 1xx/2xx/3xx → INFO ; 4xx → WARNING ; 5xx → ERROR.
@@ -127,11 +136,6 @@ declare class JsonAuditLogger implements IRequestLogger {
     shouldSample(context: IHttpContext, error?: Error | null): boolean;
     renderHttp(context: IHttpContext, error?: Error | null): IRequestLogEntry;
     renderWebsocket(context: IWebsocketContext, error?: Error | null, acceptedProtocol?: string | null): IRequestLogEntry;
-    /**
-     * Total request duration computed from the first phase startMs to now.
-     * Returns null if timing is disabled (no phases recorded).
-     */
-    private computeDurationMs;
     /**
      * Serialise an Error (recursively for `cause` chain) into an AuditErrorEntry.
      * Stack is included only when `includeStack === true` (dev default).
@@ -140,4 +144,4 @@ declare class JsonAuditLogger implements IRequestLogger {
     private serializeError;
 }
 export default JsonAuditLogger;
-export { severityFromStatus };
+export { computeDurationMs, severityFromStatus };

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

@@ -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;

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);
     /**

package/dist/types/nodefony/src/context/Context.d.ts

@@ -1,6 +1,7 @@
 import { Container, Service, Severity, Msgid, Message, Pci, Pdu, KernelEventsType, nodefonyError, Scope } from "nodefony";
 import type { IProfilerQuery } from "nodefony";
-import type { Resolver, Router } from "@nodefony/framework";
+import type { IRouteResolver, IRequestRouter } from "../../interfaces/IRouting.js";
+import type { ISecurityZone } from "../../interfaces/ISecurity.js";
 import { WebSocketServer } from "ws";
 import http2 from "node:http2";
 import http from "node:http";
@@ -16,7 +17,6 @@ import { URL } from "node:url";
 import Session from "../session/session.js";
 import Cookie from "../cookies/cookie.js";
 import HttpError from "../errors/httpError.js";
-import { SecuredArea } from "@nodefony/security";
 /**
  * Bascule runtime du gate des logs d'events lifecycle. Réservé HORS hot path :
  * tests et futur « Audit à chaud » (fenêtre bornée prod→verbeux, auto-revert
@@ -41,7 +41,7 @@ export declare function nextCspNonce(): string;
 declare class Context extends Service implements IContextInterface {
     #private;
     secure: boolean;
-    security?: SecuredArea | null;
+    security?: ISecurityZone | null | undefined;
     cleaned: boolean;
     isControlledAccess: boolean;
     validDomain: boolean;
@@ -52,7 +52,7 @@ declare class Context extends Service implements IContextInterface {
     sessionStarting: boolean;
     domain: string;
     type: ServerType;
-    server?: WebSocketServer | http.Server | https.Server | http2.Http2SecureServer | null;
+    server?: WebSocketServer | http.Server | https.Server | http2.Http2SecureServer | null | undefined;
     httpKernel: HttpKernel | null;
     request: contextRequest | null;
     response: contextResponse | null;
@@ -64,7 +64,7 @@ declare class Context extends Service implements IContextInterface {
     set originUrl(value: URL | undefined | null);
     cookies: Cookies;
     error: Error | HttpError | nodefonyError | null | undefined;
-    sessionService?: SessionsService | null;
+    sessionService?: SessionsService | null | undefined;
     session: Session | null | undefined;
     cookieSession: Cookie | null | undefined;
     user: unknown;
@@ -79,8 +79,8 @@ declare class Context extends Service implements IContextInterface {
      */
     protected resolveIsHtml(): boolean;
     crossDomain: boolean;
-    router: Router | null;
-    resolver: Resolver | null;
+    router: IRequestRouter | null;
+    resolver: IRouteResolver | null;
     /**
      * Intent de session de la route courante (posé par le Resolver depuis
      * `@UseSession` / paramètre `@Session`). Pilote le point d'activation unique
@@ -110,8 +110,8 @@ declare class Context extends Service implements IContextInterface {
     profilerQueries: IProfilerQuery[] | null;
     profiling: boolean;
     securityTrace: ISecurityTrace | null;
-    private _timingEnabled;
-    private _timingVerbose;
+    private readonly _timingEnabled;
+    private readonly _timingVerbose;
     readonly phases: PhaseTiming[];
     private _phaseIndex;
     private _afterResponseFns;
@@ -145,7 +145,18 @@ declare class Context extends Service implements IContextInterface {
     phaseStart(name: PhaseName): void;
     phaseEnd(name: PhaseName): void;
     onAfterResponse(fn: AfterResponseHandler): void;
-    _runAfterResponse(): Promise<void>;
+    /**
+     * Exécute les hooks `onAfterResponse`, une seule fois, dans l'ordre
+     * d'enregistrement ; un hook qui lève est journalisé sans arrêter les suivants.
+     *
+     * @returns `undefined` quand aucun hook n'est enregistré (le cas nominal) ou
+     *   qu'ils ont déjà tourné : rien à attendre, le démontage continue sans
+     *   suspension. Une `Promise` sinon, réglée quand le dernier hook a fini — elle
+     *   ne rejette jamais.
+     */
+    _runAfterResponse(): Promise<void> | undefined;
+    /** Boucle des hooks `onAfterResponse` — séquentielle, erreurs journalisées. */
+    private runAfterResponseHooks;
     get signal(): AbortSignal;
     _abortIfPending(reason?: string): void;
     log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;

package/dist/types/nodefony/src/context/forwarded.d.ts

@@ -32,11 +32,11 @@ export interface ForwardedElement {
 /** Résolution canonique unifiée des en-têtes forwarded. */
 export interface ResolvedProxy {
     /** Scheme effectif côté client (`http` / `https`), ou `undefined` si indéterminé. */
-    proto?: string;
+    proto?: string | undefined;
     /** Host effectif côté client (Host d'origine), ou `undefined` si non fourni. */
-    host?: string;
+    host?: string | undefined;
     /** Chaîne `for` brute (node identifiers, gauche→droite) — pour log/metadata interne. */
-    forwardedFor?: string;
+    forwardedFor?: string | undefined;
     /** IP cliente réelle, résolue from-right (toujours fiable, jamais l'IP forgée). */
     clientIp: string | null;
     /** Le header standard `Forwarded` a-t-il été la source (sinon `X-Forwarded-*`) ? */