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

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

@@ -1,25 +1,7 @@
-import { isPortListening } from "nodefony";
+import { isPortListening, resolvePortPolicy } from "nodefony";
 //#region nodefony/src/servers/portBinder.ts
 /** Nombre de ports essayés après le désiré, en `auto`. */
 const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
-/**
-* Politique de port effective.
-*
-* Le défaut dépend de l'environnement, et ce n'est pas de la coquetterie :
-* - **production** → `strict`. Le port y est un contrat (service k8s, ingress,
-*   sonde de santé). Un bind silencieux ailleurs donnerait un pod déclaré sain
-*   que personne n'atteint : une panne invisible, le pire des deux mondes.
-* - **test** → `strict`. Un port occupé veut dire « un serveur est resté debout » ;
-*   le banc doit s'arrêter, pas viser à côté (il taperait le serveur du voisin).
-* - **développement** → `auto`. Ici un port pris n'est qu'une nuisance.
-*
-* @param environment - `kernel.environment` (normalisé `development`/`production`/`test`).
-* @param explicit - `servers.portPolicy` s'il est configuré (il gagne toujours).
-*/
-function resolvePortPolicy(environment, explicit) {
-	if (explicit === "auto" || explicit === "strict") return explicit;
-	return environment === "development" ? "auto" : "strict";
-}
 /** Port configuré d'un serveur, ou `0` (désactivé / non précisé → choix noyau). */
 function configuredPort(entry) {
 	if (!entry) return 0;
@@ -106,6 +88,8 @@ function portConflictError(port, host) {
 	error.code = "EADDRINUSE";
 	return error;
 }
+/** Plus grand numéro de port TCP (RFC 793) : au-delà, `listen` lève un `RangeError`. */
+const MAX_PORT = 65535;
 /** Prochain candidat : incrémente, en sautant ce que les autres serveurs veulent. */
 function nextCandidate(from, reserved) {
 	let port = from + 1;
@@ -176,10 +160,13 @@ async function bindWithFallback(server, host, plan, probe = isPortListening) {
 			address: server.address(),
 			shiftedFrom: candidate === plan.desired ? null : plan.desired
 		};
-		if (!conflict && !isPortUnavailable(failure.code, candidate)) throw failure;
+		const code = failure.code;
+		if (!conflict && !isPortUnavailable(typeof code === "string" ? code : void 0, candidate)) throw failure;
 		if (plan.desired === 0 || used >= plan.attempts) throw failure;
 		used += 1;
-		candidate = nextCandidate(candidate, plan.reserved);
+		const next = nextCandidate(candidate, plan.reserved);
+		if (next > MAX_PORT) throw failure;
+		candidate = next;
 	}
 }
 //#endregion

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

@@ -57,8 +57,9 @@ var Session = class {
 	constructor(name, options, manager) {
 		this.options = extend({}, defaultSessionOptions, options);
 		this.manager = manager;
-		this.storage = this.manager.storage;
-		if (!this.storage) this.status = "disabled";
+		const storage = this.manager.storage;
+		this.storage = storage;
+		if (!storage) this.status = "disabled";
 		this.setName(name);
 		this.strategy = this.manager.sessionStrategy;
 	}
@@ -195,7 +196,7 @@ var Session = class {
 		return true;
 	}
 	setCookieSession(leftTime, options = {}) {
-		if (this.context && this.context.response) {
+		if (this.context?.response) {
 			const settings = extend({}, this.options.cookie, options);
 			if (leftTime) settings.maxAge = leftTime;
 			const cookie = new Cookie(this.context.getSessionCookieName(), this.id, settings);
@@ -207,7 +208,7 @@ var Session = class {
 		return null;
 	}
 	deleteCookieSession() {
-		if (this.context && this.context.response) {
+		if (this.context?.response) {
 			let cookie = this.cookieSession;
 			if (cookie) cookie.expires = /* @__PURE__ */ new Date(0);
 			else cookie = new Cookie(this.context.getSessionCookieName(), "", { expires: /* @__PURE__ */ new Date(0) });
@@ -219,11 +220,17 @@ var Session = class {
 		return this.cookieSession;
 	}
 	isValidSession(_data, context) {
-		if (this.options.refererCheck) try {
-			return this.checkSecureReferer(context);
-		} catch {
-			this.log(`SESSION REFERER MISMATCH ==> ${this.name} : ${this.id}`, "WARNING");
-			return false;
+		if (this.options.refererCheck) {
+			let sameHost = false;
+			try {
+				sameHost = this.checkSecureReferer(context);
+			} catch {
+				sameHost = false;
+			}
+			if (!sameHost) {
+				this.log(`SESSION REFERER MISMATCH ==> ${this.name} : ${this.id}`, "WARNING");
+				return false;
+			}
 		}
 		const now = Date.now();
 		if (this.options.absoluteTimeoutS && this.created) {
@@ -347,7 +354,8 @@ var Session = class {
 			user: user ?? this.user ?? ""
 		};
 	}
-	deSerialize(data) {
+	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];

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

@@ -1,3 +1,4 @@
+import { thrownMessage } from "../errors/thrownMessage.js";
 //#region nodefony/src/session/sessionStoreFailure.ts
 /**
 * Reconnaît une table de session absente, quel que soit le dialecte.
@@ -18,7 +19,7 @@ function looksLikeMissingTable(text) {
 * @returns le statut, le corps à servir, et la ligne de journal.
 */
 function describeSessionStoreFailure(error) {
-	const cause = error instanceof Error ? error.message : String(error ?? "cause inconnue");
+	const cause = error === null || error === void 0 ? "cause inconnue" : thrownMessage(error);
 	return {
 		statusCode: 500,
 		body: "Internal Server Error — session store unavailable",

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

@@ -82,14 +82,29 @@ var RevocationGuardStorage = class {
 	constructor(inner) {
 		this.inner = inner;
 		this.sortableFields = inner.sortableFields;
-		if (typeof inner.listAll === "function") this.listAll = (filter) => inner.listAll(filter);
-		if (typeof inner.listPage === "function") this.listPage = (query) => inner.listPage(query);
-		if (typeof inner.countSessions === "function") this.countSessions = (query) => inner.countSessions(query);
-		if (typeof inner.countDistinctUsers === "function") this.countDistinctUsers = (query) => inner.countDistinctUsers(query);
-		if (typeof inner.touch === "function") this.touch = (id, idleSeconds) => {
-			if (this.#isRevoked(id)) return Promise.resolve();
-			return inner.touch(id, idleSeconds);
-		};
+		if (typeof inner.listAll === "function") {
+			const src = inner;
+			this.listAll = (filter) => src.listAll(filter);
+		}
+		if (typeof inner.listPage === "function") {
+			const src = inner;
+			this.listPage = (query) => src.listPage(query);
+		}
+		if (typeof inner.countSessions === "function") {
+			const src = inner;
+			this.countSessions = (query) => src.countSessions(query);
+		}
+		if (typeof inner.countDistinctUsers === "function") {
+			const src = inner;
+			this.countDistinctUsers = (query) => src.countDistinctUsers(query);
+		}
+		if (typeof inner.touch === "function") {
+			const src = inner;
+			this.touch = (id, idleSeconds) => {
+				if (this.#isRevoked(id)) return Promise.resolve();
+				return src.touch(id, idleSeconds);
+			};
+		}
 	}
 	read(id) {
 		return this.inner.read(id);
@@ -117,7 +132,7 @@ var RevocationGuardStorage = class {
 	#revoke(id) {
 		const now = Date.now();
 		this.#purgeExpired(now);
-		if (this.#tombstones === null) this.#tombstones = /* @__PURE__ */ new Map();
+		this.#tombstones ??= /* @__PURE__ */ new Map();
 		this.#tombstones.set(id, now + TOMBSTONE_TTL_MS);
 	}
 	#isRevoked(id) {

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 import { Kernel, Module } from "nodefony";
+import { type IHttpOverlay } from "./nodefony/config/config.js";
 import type { IHttpConfig, IHttpConfigInput } from "./nodefony/interfaces/IHttpConfig.js";
 import { Profiler } from "./nodefony/src/profiler/Profiler.js";
 import HttpKernel from "./nodefony/service/http-kernel.js";
@@ -22,8 +23,21 @@ declare module "nodefony" {
     interface NodefonyModuleConfig {
         "@nodefony/http": IHttpConfigInput;
     }
+    interface NodefonyModuleOverlay {
+        "@nodefony/http": IHttpOverlay;
+    }
 }
 declare class Http extends Module<IHttpConfig> {
+    overlaySchema: import("zod").ZodObject<{
+        maxBodySize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+        upload: import("zod").ZodOptional<import("zod").ZodObject<{
+            maxFileSize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxTotalFileSize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxFiles: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxFields: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxFieldsSize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>;
     constructor(kernel: Kernel);
     /**
      * Expose le JSON Schema de la config http (dérivé du schéma Zod, flags `meta()`
@@ -75,6 +89,8 @@ export { SESSION_SORTABLE_FIELDS, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_S
 export type { IHttpRequest, IHttp2Request, IWsRequest, HTTPMethodType, } from "./nodefony/interfaces/IRequest.js";
 export type { IHttpResponse, IWebsocketResponse, } from "./nodefony/interfaces/IResponse.js";
 export type { IHttpKernel } from "./nodefony/interfaces/IHttpKernel.js";
+export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./nodefony/interfaces/IRouting.js";
+export type { ISecurityZone, IFirewallGate, } from "./nodefony/interfaces/ISecurity.js";
 export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, } from "./nodefony/interfaces/IUpload.js";
 export type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult, } from "./nodefony/interfaces/IErrorRenderer.js";
 export type { IRequestLogger, IRequestLogEntry, } from "./nodefony/interfaces/IRequestLogger.js";

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

@@ -189,6 +189,28 @@ export declare const httpConfigSchema: z.ZodObject<{
 export type IHttpConfig = z.infer<typeof httpConfigSchema>;
 /** Type d'entrée (toutes sections omissibles — défauts du schéma). */
 export type IHttpConfigInput = z.input<typeof httpConfigSchema>;
+/**
+ * LISTE BLANCHE des clés qu'une requête peut surcharger pour elle seule
+ * (`overlayConfig("@nodefony/http", …)`, #494) : les quotas de corps et
+ * d'envoi, lus au MOMENT de lire le corps (`Request.readBodyLimits`) — un
+ * calque posé avant la lecture du corps (écouteur `onRequestScope`, organisation
+ * reconnue à son nom d'hôte) les voit. Tout le reste est refusé : en-têtes de
+ * sécurité, pare-feu, `trustProxy`, sessions, limites de débit, certificats —
+ * et `queryString`, lu au constructeur de la requête, avant tout calque.
+ * Chaque champ réutilise celui du schéma (mêmes bornes) sans son défaut.
+ */
+export declare const httpOverlaySchema: z.ZodObject<{
+    maxBodySize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+    upload: z.ZodOptional<z.ZodObject<{
+        maxFileSize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxTotalFileSize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxFiles: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxFields: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxFieldsSize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Calque accepté par `overlayConfig("@nodefony/http", …)`. */
+export type IHttpOverlay = z.input<typeof httpOverlaySchema>;
 /**
  * Défauts du module, matérialisés depuis le schéma (source unique). Toujours
  * valides par construction ; passés au `super(..., config)` du Module class.

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

@@ -1,4 +1,5 @@
 import type { URL } from "node:url";
+import type { MaybePromise } from "nodefony";
 import type { ICookie } from "./ICookie.js";
 import type { ISession } from "./ISession.js";
 import type { HTTPMethodType } from "./IRequest.js";
@@ -10,8 +11,8 @@ export type PhaseName = "parse" | "resolve" | "firewall" | "initialize" | "actio
 export interface PhaseTiming {
     name: PhaseName;
     startMs: number;
-    endMs?: number;
-    durationMs?: number;
+    endMs?: number | undefined;
+    durationMs?: number | undefined;
 }
 /** Issue de la traversée d'une zone firewall. */
 export type SecurityOutcome = 
@@ -110,9 +111,25 @@ export interface IContext {
 export interface IHttpContext extends IContext {
     proxy: object | null;
     isRedirect: boolean;
-    handle(): Promise<object>;
-    render(chunk: unknown, encoding?: BufferEncoding, status?: string | number, headers?: Record<string, string | number>): Promise<object>;
-    send(chunk?: unknown, encoding?: BufferEncoding): Promise<object>;
+    /**
+     * Sert la requête — synchrone quand l'action et son rendu le sont.
+     *
+     * @returns le résultat du rendu, ou sa promesse dès qu'une étape attend.
+     */
+    handle(): MaybePromise<object>;
+    /**
+     * Sérialise puis envoie — synchrone quand l'envoi l'est.
+     *
+     * @returns la réponse, ou sa promesse dès qu'une étape attend.
+     */
+    render(chunk: unknown, encoding?: BufferEncoding, status?: string | number, headers?: Record<string, string | number>): MaybePromise<object>;
+    /**
+     * Envoie la réponse — synchrone sans session à sauver, sans hook `onSend`,
+     * pour une réponse unique.
+     *
+     * @returns la réponse, ou sa promesse dès qu'une étape attend.
+     */
+    send(chunk?: unknown, encoding?: BufferEncoding): MaybePromise<object>;
     end(): Promise<object>;
     redirect(url: string, status?: number | string, headers?: Record<string, string | number>): unknown;
     getHostName(): string | undefined;
@@ -121,8 +138,8 @@ export interface IHttpContext extends IContext {
     getUserAgent(): string | undefined;
 }
 export interface IWebsocketContext extends IContext {
-    acceptedProtocol?: string;
-    connection: unknown | null;
+    acceptedProtocol?: string | undefined;
+    connection: unknown;
     rejected: boolean;
     port: number | string;
     wsUrl: URL | null;

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

@@ -1,15 +1,15 @@
 export type SameSiteType = "Strict" | "Lax" | "None";
 export type PriorityType = "High" | "Medium" | "Low" | undefined;
 export interface ICookieOptions {
-    maxAge?: number;
-    path?: string;
-    domain?: string;
-    secure?: boolean;
-    expires?: Date | string | number;
-    sameSite?: SameSiteType;
-    httpOnly?: boolean;
-    signed?: boolean;
-    secret?: string;
+    maxAge?: number | undefined;
+    path?: string | undefined;
+    domain?: string | undefined;
+    secure?: boolean | undefined;
+    expires?: Date | string | number | undefined;
+    sameSite?: SameSiteType | undefined;
+    httpOnly?: boolean | undefined;
+    signed?: boolean | undefined;
+    secret?: string | undefined;
     priority?: PriorityType;
 }
 export interface IWsCookie {
@@ -26,16 +26,16 @@ export interface ICookie {
     name: string;
     value: unknown;
     options: ICookieOptions;
-    signed?: boolean;
-    originalMaxAge?: number;
-    expires?: Date;
-    maxAge?: number;
-    path?: string;
+    signed?: boolean | undefined;
+    originalMaxAge?: number | undefined;
+    expires?: Date | undefined;
+    maxAge?: number | undefined;
+    path?: string | undefined;
     domain?: string | undefined;
-    httpOnly?: boolean;
-    secure?: boolean;
-    sameSite?: SameSiteType;
-    priority?: string;
+    httpOnly?: boolean | undefined;
+    secure?: boolean | undefined;
+    sameSite?: SameSiteType | undefined;
+    priority?: string | undefined;
     setValue(value: unknown): unknown;
     toString(): string;
     serialize(): string;

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

@@ -1,9 +1,15 @@
+import type { IServerKernel, MaybePromise } from "nodefony";
 import type { ServerType } from "./IContext.js";
-export interface IHttpKernel {
+export interface IHttpKernel extends IServerKernel {
     domain: string;
-    httpPort?: number;
-    httpsPort?: number;
-    handle(request: unknown, response: unknown, type: ServerType): Promise<unknown>;
+    httpPort?: number | undefined;
+    httpsPort?: number | undefined;
+    /**
+     * Pipeline public d'une requête (appelé par les serveurs HTTP/HTTPS).
+     *
+     * @returns le contexte servi, ou sa promesse dès qu'une étape attend.
+     */
+    handle(request: unknown, response: unknown, type: ServerType): MaybePromise<unknown>;
     handleFrontController(context: object, checkFirewall?: boolean): Promise<unknown>;
     onError(error: unknown, context?: object, extraHeaders?: object): Promise<object>;
     isValidDomain(context: object): boolean;

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

@@ -31,7 +31,7 @@ export interface IHttpResponse extends IResponse {
     setCookie(cookie: ICookie): void;
 }
 export interface IWebsocketResponse extends IResponse {
-    connection: unknown | null;
+    connection: unknown;
     webSocketVersion?: number;
     setConnection(connection: unknown): unknown;
     broadcast(data: Buffer | string): void;

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

@@ -0,0 +1,87 @@
+import type { MaybePromise } from "nodefony";
+import type { ContextType } from "../service/http-kernel.js";
+/**
+ * Ce que le pipeline HTTP/WS lit d'une route résolue — et rien de plus.
+ *
+ * Le routage vit dans `@nodefony/framework`, qui dépend de `@nodefony/http` :
+ * `http` ne peut donc pas nommer ses classes sans recréer un cycle. C'est le
+ * LECTEUR qui définit le contrat ; `Route` (framework) le satisfait par
+ * structure, et le typecheck de `framework` garantit l'alignement.
+ */
+export interface IResolvedRoute {
+    /** Nom de la route (journalisation, diagnostic). */
+    readonly name: string;
+    /** Corps laissé en flux (`@Body({ stream: true })`) : le parse est sauté. */
+    readonly bodyStream?: boolean | undefined;
+}
+/**
+ * Ce que le pipeline HTTP/WS attend du résolveur d'une requête, posé sur
+ * `context.resolver` par le routeur.
+ *
+ * Implémenté par `Resolver` (`@nodefony/framework`), qui l'étend de ses propres
+ * membres — un code de `framework` qui a besoin de la classe entière la tient
+ * de son routeur, pas de ce contrat.
+ */
+export interface IRouteResolver {
+    /** Route matchée, `null` tant qu'aucune ne l'est. */
+    readonly route: IResolvedRoute | null;
+    /** `true` si une route a matché la requête. */
+    resolve: boolean;
+    /** Erreur levée pendant la résolution, relue par le pipeline. */
+    exception?: Error | null | undefined;
+    /** Classe du controller résolu — seul son nom est lu (erreurs, journal). */
+    readonly controller?: {
+        readonly name: string;
+    } | null | undefined;
+    /** Nom de l'action résolue. */
+    actionName?: string | undefined;
+    /**
+     * Rejoue le match d'une route sur un contexte (WS : handshake puis frames).
+     *
+     * @param route - la route à matcher, lue sur {@link IRouteResolver.route}
+     * @param context - le contexte courant
+     * @param cleanPath - chemin imposé (pont WS-RPC), sinon l'URL du contexte
+     */
+    match(route: IResolvedRoute, context: ContextType, cleanPath?: string): unknown;
+    /**
+     * Instancie le controller résolu — le pipeline ne fait que le transmettre.
+     *
+     * @param context - le contexte de la requête
+     * @returns l'instance du controller — directement quand elle existe déjà ou
+     *   se construit sans rien attendre, sinon la promesse de sa création
+     */
+    newController(context?: ContextType): MaybePromise<object>;
+    /**
+     * Exécute l'action résolue, puis rend sa valeur sur le transport.
+     *
+     * @param data - arguments supplémentaires de l'action
+     * @param reload - rejouer depuis l'instance en cache (forward)
+     * @returns le résultat du rendu — synchrone quand ni l'action ni le rendu
+     *   n'attendent, sinon sa promesse
+     */
+    callController(data?: unknown[], reload?: boolean): MaybePromise<unknown>;
+}
+/**
+ * Ce que le pipeline HTTP/WS attend du service `router` — implémenté par
+ * `Router` (`@nodefony/framework`).
+ */
+export interface IRequestRouter {
+    /**
+     * Résout la route d'un contexte.
+     *
+     * @param context - le contexte HTTP/WS courant
+     * @param cleanPathOverride - chemin porté par un message (pont WS-RPC)
+     * @param methodOverride - méthode logique exigée en plus du transport WS
+     * @returns le résolveur (`resolve === true` si une route a matché)
+     */
+    resolve(context: ContextType, cleanPathOverride?: string, methodOverride?: string): IRouteResolver;
+    /**
+     * Instance partagée d'un controller `scope: "singleton"`, créée une seule fois.
+     *
+     * @param ctor - la classe du controller (clé du cache)
+     * @param create - fabrique exécutée au premier appel
+     * @returns l'instance partagée une fois créée ; la promesse de sa création
+     *   tant qu'elle est en cours
+     */
+    getSingletonController<T extends object>(ctor: new (...args: never[]) => T, create: () => MaybePromise<T>): MaybePromise<T>;
+}

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

@@ -0,0 +1,45 @@
+import type { ContextType } from "../service/http-kernel.js";
+/**
+ * Ce que le pipeline HTTP/WS — et le résolveur de framework — lit de la zone de sécurité posée sur
+ * `context.security` — et rien de plus.
+ *
+ * Le pare-feu vit dans `@nodefony/security`, qui dépend de `@nodefony/http` :
+ * `http` ne peut donc pas nommer ses classes sans recréer un cycle. C'est le
+ * LECTEUR qui définit le contrat ; `ISecuredArea` (security) l'étend, et le
+ * typecheck de `security` garantit l'alignement.
+ */
+export interface ISecurityZone {
+    /** Nom de la zone (journalisation, profiler). */
+    readonly name: string;
+    /** `true` si la zone exige une authentification. */
+    readonly security: boolean;
+    /** Zone sans session : aucune session n'est ouverte ni lue. */
+    readonly stateless: boolean;
+    /** Stratégie des authenticators : le premier qui répond, ou tous. */
+    readonly mode: "first" | "all";
+    /** Noms des authenticators candidats, dans l'ordre. */
+    readonly authenticators: readonly string[];
+    /**
+     * Rôles exigés par la zone, en OU (un seul suffit) ; `null` = aucune exigence
+     * de rôle. Lu par le résolveur de `@nodefony/framework` pour l'autorisation.
+     */
+    readonly roles: readonly string[] | null;
+}
+/**
+ * Ce que le noyau HTTP appelle du pare-feu, service `firewall` du conteneur.
+ *
+ * Implémenté par `Firewall` (`@nodefony/security`), dont `IFirewall` étend ce
+ * contrat de ses propres membres (CSP, authenticators, description).
+ */
+export interface IFirewallGate {
+    /** Match rapide de zone : pose `context.security`, `true` si une zone capture. */
+    isSecure(context: ContextType): boolean;
+    /** Authentifie la requête d'une zone protégée ; rejette si elle est refusée. */
+    handleSecurity(context: ContextType): Promise<ContextType>;
+    /** Refuse une requête qui ne présente pas le jeton CSRF attendu. */
+    enforceCsrf(context: ContextType): void;
+    /** Répond au preflight CORS ; `204` quand la réponse est déjà envoyée. */
+    handleCors(context: ContextType): number | undefined;
+    /** Pose les en-têtes de sécurité (CSP, HSTS…) de la réponse. */
+    applySecurityHeaders(context: ContextType): void;
+}

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

@@ -13,7 +13,7 @@ export type MetaBagType = Record<string, unknown>;
  * - `readOnly` : la session est lue/reprise mais **jamais persistée** (0 write storage).
  */
 export interface SessionIntent {
-    readOnly?: boolean;
+    readOnly?: boolean | undefined;
 }
 /**
  * Données de session **sérialisées** échangées avec un {@link ISessionStorage}
@@ -25,8 +25,8 @@ export interface ISerializedSession {
     metaBag: Record<string, unknown>;
     flashBag: Record<string, unknown>;
     user: string;
-    createdAt?: Date;
-    updatedAt?: Date;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
 }
 /**
  * Projection **redactée** d'une session pour l'ADMINISTRATION (data plane Studio,
@@ -100,7 +100,7 @@ export interface ISessionListFilter {
     /** Restreint aux sessions d'un utilisateur (pour « déconnecter partout »). */
     user?: string;
     /** Slot multi-tenant — non scopé aujourd'hui (réserve coût-0). */
-    tenantId?: string | null;
+    tenantId?: string | null | undefined;
 }
 /**
  * Requête d'énumération **paginée** des sessions — le {@link IPageQuery} standard
@@ -253,10 +253,10 @@ export interface ISession {
     cookieSession: ICookie | null | undefined;
     flashBag: FlashBagType;
     strategy: SessionStrategyType;
-    created?: Date;
-    updated?: Date;
-    user?: string;
-    lifetime?: number;
+    created?: Date | undefined;
+    updated?: Date | undefined;
+    user?: string | undefined;
+    lifetime?: number | undefined;
     storage: ISessionStorage;
     start(context: unknown): Promise<ISession>;
     save(user?: string): Promise<ISession>;

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

@@ -28,21 +28,21 @@ export interface IParsedUploadFile {
  */
 export interface IUploadOptions {
     /** Répertoire de dépôt des fichiers temporaires. */
-    uploadDir?: string;
+    uploadDir?: string | undefined;
     /** Taille max d'UN fichier (octets) — `limits.fileSize` busboy. */
-    maxFileSize?: number;
+    maxFileSize?: number | undefined;
     /** Taille max CUMULÉE des fichiers d'une requête (octets) — appliquée par Nodefony. */
-    maxTotalFileSize?: number;
+    maxTotalFileSize?: number | undefined;
     /** Nombre max de fichiers — `limits.files` busboy. */
-    maxFiles?: number;
+    maxFiles?: number | undefined;
     /** Nombre max de champs texte — `limits.fields` busboy. */
-    maxFields?: number;
+    maxFields?: number | undefined;
     /** Taille max d'un champ texte (octets) — `limits.fieldSize` busboy. */
-    maxFieldsSize?: number;
+    maxFieldsSize?: number | undefined;
     /** Hash calculé pendant le stream (défaut `false` = aucun). */
-    hashAlgorithm?: false | "sha1" | "md5" | "sha256";
+    hashAlgorithm?: false | "sha1" | "md5" | "sha256" | undefined;
     /** Encodage par défaut des parts texte. */
-    encoding?: string;
+    encoding?: string | undefined;
 }
 export interface IUploadedFile {
     filename: string;
@@ -60,7 +60,7 @@ export interface IUploadedFile {
     getPrettySize(): string;
 }
 export interface IUploadService {
-    path?: string | unknown;
+    path?: unknown;
     /** Construit un `UploadedFile` en async (stat non bloquant). */
     createUploadFile(file: unknown, name: string): Promise<IUploadedFile>;
 }

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

@@ -5,3 +5,5 @@ export type { IRequest, IHttpRequest, IHttp2Request, IWsRequest, HTTPMethodType,
 export type { IResponse, IHttpResponse, IWebsocketResponse } from "./IResponse.js";
 export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType, WebSocketStateType, CookiesMap, } from "./IContext.js";
 export type { IHttpKernel } from "./IHttpKernel.js";
+export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./IRouting.js";
+export type { ISecurityZone, IFirewallGate } from "./ISecurity.js";