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

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/servers/kernelServers.ts
+// nodefony/src/servers/kernelServers.ts
 /**
 * Rétrécit la section `servers` de la configuration du kernel (lue dans le sac
 * de config non typé du cœur) en {@link ServersConfig}, sans propager `any`.
@@ -13,6 +13,15 @@ function asServersConfig(servers) {
 	return servers !== null && typeof servers === "object" ? servers : void 0;
 }
 /**
+* Le serveur h2c démarre-t-il ? Seul un `enabled: true` EXPLICITE l'allume : la
+* section existe toujours (défauts), un port seul ne vaut pas activation.
+*
+* @param entry - `servers.h2c`.
+*/
+function isH2cEnabled(entry) {
+	return entry?.enabled === true;
+}
+/**
 * Port DEMANDÉ pour un serveur (`servers.<type>.port`), ou `undefined` si le
 * serveur est désactivé, absent, ou sans port numérique.
 *
@@ -22,8 +31,8 @@ function asServersConfig(servers) {
 function configuredServerPort(servers, type) {
 	const entry = servers?.[type];
 	if (!entry) return void 0;
+	if (type === "h2c" && !isH2cEnabled(servers.h2c)) return void 0;
 	const port = entry.port;
 	return typeof port === "number" ? port : void 0;
 }
-//#endregion
-export { asServersConfig, configuredServerPort };
+export { asServersConfig, configuredServerPort, isH2cEnabled };

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

@@ -1,6 +1,7 @@
+import { isH2cEnabled } from "./kernelServers.js";
 import { isPortListening, resolvePortPolicy } from "nodefony";
 import cluster from "node:cluster";
-//#region nodefony/src/servers/portBinder.ts
+// nodefony/src/servers/portBinder.ts
 /**
 * **portBinder** — écoute sur le port désiré, ou sur le prochain port libre.
 *
@@ -48,27 +49,58 @@ import cluster from "node:cluster";
 */
 /** Nombre de ports essayés après le désiré, en `auto`. */
 const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
+const BOUND_SERVERS = [
+	"http",
+	"https",
+	"h2c"
+];
 /** Port configuré d'un serveur, ou `0` (désactivé / non précisé → choix noyau). */
-function configuredPort(entry) {
+function configuredPort(servers, which) {
+	if (which === "h2c") {
+		const entry = servers?.h2c;
+		return isH2cEnabled(entry) ? entry?.port ?? 0 : 0;
+	}
+	const entry = servers?.[which];
 	if (!entry) return 0;
 	return entry.port ?? 0;
 }
 /**
+* Serveur actif qui convoite le MÊME port que h2c, ou `null`.
+*
+* Un port partagé avec h2c n'est pas un conflit à contourner : sur ce port, le
+* client HTTP/1.1 et le proxy h2c se marchent dessus, et le repli `auto` ferait
+* glisser l'un des deux là où personne ne l'attend. Le boot le refuse.
+*
+* @param servers - `kernel.options.servers`.
+* @returns `"http"` ou `"https"` en conflit, sinon `null` (h2c inactif, port 0).
+*/
+function h2cPortConflict(servers) {
+	const port = configuredPort(servers, "h2c");
+	if (port === 0) return null;
+	if (configuredPort(servers, "http") === port) return "http";
+	if (configuredPort(servers, "https") === port) return "https";
+	return null;
+}
+/**
 * Compose le plan de bind d'un serveur depuis la config du kernel — source UNIQUE
-* (les deux serveurs l'appellent ; la politique n'est décidée qu'ici).
+* (les serveurs l'appellent ; la politique n'est décidée qu'ici).
 *
 * @param which - le serveur qu'on borne.
 * @param servers - `kernel.options.servers`.
 * @param environment - `kernel.environment` (arbitre le défaut de la politique).
 */
 function buildBindPlan(which, servers, environment) {
-	const desired = configuredPort(servers?.[which]);
-	const other = configuredPort(servers?.[which === "http" ? "https" : "http"]);
-	const policy = resolvePortPolicy(environment, servers?.portPolicy);
+	const desired = configuredPort(servers, which);
+	const reserved = [];
+	for (const other of BOUND_SERVERS) {
+		if (other === which) continue;
+		const port = configuredPort(servers, other);
+		if (port > 0 && port !== desired) reserved.push(port);
+	}
 	return {
 		desired,
-		reserved: other > 0 && other !== desired ? [other] : [],
-		attempts: policy === "auto" ? servers?.portRetryAttempts ?? 20 : 0
+		reserved,
+		attempts: resolvePortPolicy(environment, servers?.portPolicy) === "auto" ? servers?.portRetryAttempts ?? 20 : 0
 	};
 }
 /** Adresses qui désignent « toutes les interfaces » — rien ne s'y connecte. */
@@ -224,5 +256,4 @@ async function bindWithFallback(server, host, plan, probe = isPortListening, sha
 		candidate = next;
 	}
 }
-//#endregion
-export { DEFAULT_PORT_RETRY_ATTEMPTS, bindWithFallback, buildBindPlan, conflictProbeTargets, detectPortConflict, resolvePortPolicy };
+export { DEFAULT_PORT_RETRY_ATTEMPTS, bindWithFallback, buildBindPlan, conflictProbeTargets, detectPortConflict, h2cPortConflict, resolvePortPolicy };

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

@@ -1,6 +1,79 @@
+import { websocketHandshakeProblem } from "../proxy/rules.js";
 import { refuseUpgrade } from "../proxy/forward.js";
 import { STATUS_CODES } from "node:http";
-//#region nodefony/src/servers/upgradeDispatch.ts
+// nodefony/src/servers/upgradeDispatch.ts
+/** Défaut sans noyau : tout upgrade conforme est accepté puis émis en `connection`. */
+function acceptAll(wss) {
+	return (req, admission) => {
+		const accepted = admission.accept();
+		if (accepted instanceof Promise) accepted.then((ws) => {
+			if (ws !== null) wss.emit("connection", ws, req);
+		});
+		else if (accepted !== null) wss.emit("connection", accepted, req);
+	};
+}
+/**
+* Le verdict d'UN upgrade. Pendant que le noyau décide, le socket n'a plus
+* d'écouteur `error` (`node:http` retire les siens à l'émission d'`upgrade`,
+* `ws` ne pose les siens qu'à `handleUpgrade`) : une coupure du client
+* (`ECONNRESET`) y deviendrait une erreur non gérée qui abat le process. D'où
+* l'écouteur de la fenêtre d'attente, retiré quand le verdict tombe.
+*
+* Une classe, pas un objet de fermetures : une allocation par handshake (plus
+* l'écouteur), méthodes partagées par le prototype.
+*/
+var UpgradeAdmission = class {
+	wss;
+	req;
+	socket;
+	head;
+	#accepted = void 0;
+	#settled = false;
+	#onPendingError;
+	constructor(wss, req, socket, head) {
+		this.wss = wss;
+		this.req = req;
+		this.socket = socket;
+		this.head = head;
+		this.#onPendingError = () => socket.destroy();
+		socket.on("error", this.#onPendingError);
+	}
+	#settle() {
+		if (this.#settled) return false;
+		this.#settled = true;
+		this.socket.removeListener("error", this.#onPendingError);
+		return true;
+	}
+	accept() {
+		if (this.#accepted !== void 0) return this.#accepted;
+		if (!this.#settle()) return this.#accepted = null;
+		const { socket } = this;
+		if (socket.destroyed || !socket.writable) {
+			socket.destroy();
+			return this.#accepted = null;
+		}
+		let ws;
+		let late = null;
+		const onClose = () => late?.(null);
+		this.wss.handleUpgrade(this.req, socket, this.head, (accepted) => {
+			if (late === null) {
+				ws = accepted;
+				return;
+			}
+			socket.removeListener("close", onClose);
+			late(accepted);
+		});
+		if (ws !== void 0) return this.#accepted = ws;
+		socket.once("close", onClose);
+		return this.#accepted = new Promise((resolve) => {
+			late = resolve;
+		});
+	}
+	refuse(status, headers) {
+		if (!this.#settle()) return;
+		refuseUpgrade(this.socket, status, STATUS_CODES[status] ?? "Refused", headers);
+	}
+};
 /**
 * Pose l'UNIQUE écouteur `upgrade` d'un serveur : le proxy inverse d'abord,
 * puis le serveur WebSocket de Nodefony.
@@ -14,7 +87,10 @@ import { STATUS_CODES } from "node:http";
 *
 * 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.
+* jamais une ouverture suivie d'une fermeture. Puis la FORME du handshake est
+* contrôlée (`websocketHandshakeProblem`, la règle du proxy inverse) : un
+* handshake malformé reçoit `400` sans jamais atteindre le noyau. Enfin
+* `admit` décide — pare-feu, garde de l'action — et seul son verdict ouvre.
 *
 * Sans montage, le coût par connexion est une lecture de champ.
 *
@@ -23,9 +99,11 @@ import { STATUS_CODES } from "node:http";
 * @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`)
+* @param admit - décide d'un upgrade admis (cf `HttpKernel.onWebsocketUpgrade`) ;
+*   par défaut, tout upgrade conforme est accepté et émis en `connection`
 * @returns la fonction qui retire l'écouteur — à appeler à l'arrêt
 */
-function attachUpgradeDispatch(server, wss, relay, refusal) {
+function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(wss)) {
 	const onUpgrade = (req, socket, head) => {
 		const proxy = relay();
 		if (proxy !== null && proxy.mounts !== null) {
@@ -36,14 +114,15 @@ function attachUpgradeDispatch(server, wss, relay, refusal) {
 			refuseUpgrade(socket, status, STATUS_CODES[status] ?? "Refused");
 			return;
 		}
-		wss.handleUpgrade(req, socket, head, (ws) => {
-			wss.emit("connection", ws, req);
-		});
+		if (websocketHandshakeProblem(req.method, req.headers) !== null) {
+			refuseUpgrade(socket, 400, STATUS_CODES[400] ?? "Bad Request");
+			return;
+		}
+		admit(req, new UpgradeAdmission(wss, req, socket, head));
 	};
 	server.on("upgrade", onUpgrade);
 	return () => {
 		server.removeListener("upgrade", onUpgrade);
 	};
 }
-//#endregion
 export { attachUpgradeDispatch };

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

@@ -1,7 +1,7 @@
 import Cookie from "../cookies/cookie.js";
 import { extend } from "nodefony";
 import { randomBytes } from "node:crypto";
-//#region nodefony/src/session/session.ts
+// nodefony/src/session/session.ts
 const defaultSessionOptions = {
 	name: "nodefony",
 	strictMode: true,
@@ -238,7 +238,7 @@ var Session = class {
 	}
 	isValidSession(_data, context) {
 		if (this.options.refererCheck) {
-			let sameHost = false;
+			let sameHost;
 			try {
 				sameHost = this.checkSecureReferer(context);
 			} catch {
@@ -410,5 +410,4 @@ var Session = class {
 		}
 	}
 };
-//#endregion
 export { Session as default };

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

@@ -1,5 +1,5 @@
 import { thrownMessage } from "../errors/thrownMessage.js";
-//#region nodefony/src/session/sessionStoreFailure.ts
+// nodefony/src/session/sessionStoreFailure.ts
 /**
 * Reconnaît une table de session absente, quel que soit le dialecte.
 *
@@ -26,5 +26,4 @@ function describeSessionStoreFailure(error) {
 		message: `La session n'a pas pu être persistée — la requête est servie en 500 plutôt que laissée sans réponse. Cause : ${cause}.${looksLikeMissingTable(cause) ? " La table de session est probablement absente : appliquer les migrations (`nodefony orm:migrate`) avant de servir, ou choisir un autre stockage (`http.session.store`)." : " Vérifier que le stockage de session déclaré sous `http.session.store` est joignable ; à défaut, appliquer les migrations (`nodefony orm:migrate`)."}`
 	};
 }
-//#endregion
 export { describeSessionStoreFailure };

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

@@ -1,6 +1,6 @@
 import { SESSION_DEFAULT_ORDER, SESSION_SORTABLE_FIELDS } from "./sessionSort.js";
 import { assertPageQuery, compareByOrder, pickOrder } from "nodefony";
-//#region nodefony/src/session/storage/MemorySessionStorage.ts
+// nodefony/src/session/storage/MemorySessionStorage.ts
 /**
 * Store de sessions **en mémoire** (Map process) — implémentation de référence
 * d'{@link ISessionStorage}, pendant `session` des `Memory*Store` de sécurité.
@@ -181,5 +181,4 @@ var MemorySessionStorage = class {
 		return Promise.resolve(users.size);
 	}
 };
-//#endregion
 export { MemorySessionStorage as default };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/session/storage/RevocationGuardStorage.ts
+// nodefony/src/session/storage/RevocationGuardStorage.ts
 /**
 * Durée de vie (ms) d'une pierre tombale de révocation. Couvre la fenêtre
 * pendant laquelle une requête « en vol » — qui avait chargé la session AVANT
@@ -148,5 +148,4 @@ var RevocationGuardStorage = class {
 		if (t.size === 0) this.#tombstones = null;
 	}
 };
-//#endregion
 export { RevocationGuardStorage as default };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/session/storage/sessionFilters.ts
+// nodefony/src/session/storage/sessionFilters.ts
 /**
 * **Le vocabulaire de filtre des sessions**, en noms PUBLICS — celui que la
 * console d'administration écrit dans l'URL (`?user=alice`).
@@ -79,5 +79,4 @@ const SESSION_FACETS = {
 * rouvert du même geste.
 */
 const SESSION_STATS_FILTERS = { user: "string" };
-//#endregion
 export { SESSION_FACETS, SESSION_FILTERS, SESSION_STATS_FILTERS };

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

@@ -1,5 +1,5 @@
 import { renameOrderFields } from "nodefony";
-//#region nodefony/src/session/storage/sessionSort.ts
+// nodefony/src/session/storage/sessionSort.ts
 /**
 * **Le vocabulaire de tri des sessions**, en noms PUBLICS — ceux qu'un client
 * écrit dans l'URL (`?order=updatedAt:DESC`), jamais des noms de colonne.
@@ -49,5 +49,4 @@ const SESSION_COLUMN_ALIASES = { id: "session_id" };
 * `session_id` — {@link SESSION_DEFAULT_ORDER} déjà traduit.
 */
 const SESSION_DEFAULT_ORDER_SQL = renameOrderFields(SESSION_DEFAULT_ORDER, SESSION_COLUMN_ALIASES);
-//#endregion
 export { SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS };

package/dist/types/index.d.ts

@@ -71,6 +71,7 @@ export { defineHttpConfig, httpConfigJsonSchema, } from "./nodefony/config/defin
 export { httpConfigSchema } from "./nodefony/config/config.js";
 export type { IHttpConfig, IHttpConfigInput, } from "./nodefony/interfaces/IHttpConfig.js";
 export { decideSend, readBackpressureOptions, type WsBackpressurePolicy, type WsSendDecision, type IWsBackpressureOptions, type IBackpressureSocket, type IBackpressureTarget, } from "./nodefony/src/context/websocket/wsBackpressure.js";
+export { isWebsocketContext } from "./nodefony/src/context/websocket/isWebsocketContext.js";
 export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed, } from "./nodefony/src/context/domainMatcher.js";
 export type { DomainPattern, ITrustedHostsConfig, } from "./nodefony/src/context/domainMatcher.js";
 export { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
@@ -79,7 +80,10 @@ export { Context, Session, SessionsService, HttpError, HttpKernel, Response, Htt
 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 { toValidationFields, type IValidationField, } from "./nodefony/service/error-renderer.js";
+export type { ProfileEntry, ProfileSummary, ProfilePhase, ProfileQuery, ProfileSecurity, IProfileBatch, IProfilerReader, } from "./nodefony/src/profiler/Profiler.js";
+export { aggregateProfiles, createProfileAggregator, isFailedProfile, sqlShape, N_PLUS_ONE_MIN_REPEATS, ACTION_SELF_PHASE, NO_ROUTE, TOOLING_URL_PREFIX, } from "./nodefony/src/profiler/aggregate.js";
+export type { IProfileAggregator, IProfileAggregatorOptions, IProfileReport, IRouteStats, IStatusBreakdown, IPhaseTotal, INPlusOne, ISqlShapeStats, IErrorSample, } from "./nodefony/src/profiler/aggregate.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";
@@ -87,11 +91,11 @@ export { parseProxyOrigin, normalizePrefix, proxyMountProblems, } from "./nodefo
 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";
+export type { IContext, IHttpContext, IWebsocketContext, IWebsocketConnectionState, ServerType, ProtocolName, AlpnProtocol, SchemeType, WebSocketStateType, CookiesMap, ISecurityTrace, SecurityOutcome, } from "./nodefony/interfaces/IContext.js";
 export type { ICookie, ICookieOptions, IWsCookie, SameSiteType, PriorityType, } from "./nodefony/interfaces/ICookie.js";
 export type { ISession, ISessionStorage, ISerializedSession, ISessionSummary, ISessionRecord, ISessionListFilter, ISessionListQuery, SessionIntent, SessionStatusType, SessionStrategyType, FlashBagType, MetaBagType, } from "./nodefony/interfaces/ISession.js";
 export { SESSION_SORTABLE_FIELDS, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_COLUMN_ALIASES, } from "./nodefony/src/session/storage/sessionSort.js";
-export type { IHttpRequest, IHttp2Request, IWsRequest, HTTPMethodType, } from "./nodefony/interfaces/IRequest.js";
+export type { IHttpRequest, RequestBody, 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";

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

@@ -3,7 +3,35 @@ import type { MaybePromise } from "nodefony";
 import type { ICookie } from "./ICookie.js";
 import type { ISession } from "./ISession.js";
 import type { HTTPMethodType } from "./IRequest.js";
-export type ServerType = "http" | "https" | "http2" | "http3" | "websocket" | "websocket-secure";
+/**
+ * Identité du serveur qui a reçu la requête, nommée par le schéma d'URI qu'il
+ * sert en LOCAL (RFC 9110 §4.2, RFC 6455 §3) : elle choisit la section de
+ * configuration du serveur (`http`, `https`, `websocket`, `websocketSecure`).
+ * Ce n'est PAS un protocole — `https` sert HTTP/1.1 et h2 sur le même port ;
+ * le protocole du saut se lit dans {@link AlpnProtocol}.
+ */
+export type ServerType = "http" | "https" | "ws" | "wss";
+/**
+ * Famille du protocole que le contrôleur traite, nommée comme l'attribut
+ * OpenTelemetry `network.protocol.name`.
+ *
+ * Union OUVERTE : une valeur peut apparaître en version mineure
+ * (`"webtransport"` sur HTTP/3) — pas de `switch` exhaustif sans `default`.
+ */
+export type ProtocolName = "http" | "websocket";
+/**
+ * Protocole du saut qui atteint CE processus, nommé par le registre IANA des
+ * identifiants ALPN — la valeur même que Node expose (`TLSSocket.alpnProtocol`,
+ * `Http2Session.alpnProtocol`, qui vaut `"h2c"` sur une session en clair).
+ *
+ * Union OUVERTE : `"h3"` s'ajoutera en version mineure, sans rupture.
+ */
+export type AlpnProtocol = "http/1.1" | "h2" | "h2c";
+/**
+ * Schéma d'URI vu par le CLIENT (RFC 9110 §4.2, RFC 6455 §3) : derrière un
+ * proxy de confiance, c'est le schéma qu'il a annoncé (`Forwarded`), pas
+ * celui du saut local. Toute décision de sécurité lit ce champ.
+ */
 export type SchemeType = "http" | "https" | "ws" | "wss";
 export type WebSocketStateType = "handshake" | "connected" | "closed" | "error" | "message" | null;
 export type CookiesMap = Record<string, ICookie>;
@@ -67,8 +95,14 @@ export interface IContext {
     csrfProtect: boolean;
     csrfExempt: boolean;
     csrfToken: string | null;
-    type: ServerType;
+    /** Famille traitée : `"http"` ou `"websocket"` (union ouverte). */
+    type: ProtocolName;
+    /** Schéma vu par le client — seul champ que lit une décision de sécurité. */
     scheme: SchemeType;
+    /** Protocole du saut local : `"http/1.1"`, `"h2"`, `"h2c"` (union ouverte). */
+    alpnProtocol: AlpnProtocol;
+    /** Serveur qui a reçu la requête — choisit la configuration par serveur. */
+    serverType: ServerType;
     method: HTTPMethodType | null;
     url: string;
     domain: string;
@@ -139,13 +173,38 @@ export interface IHttpContext extends IContext {
     getHost(): string | undefined;
     getUserAgent(): string | undefined;
 }
-export interface IWebsocketContext extends IContext {
+/**
+ * Ce qu'un module attache à une connexion WebSocket pour toute sa durée — interface
+ * VIDE par construction, qu'un module AUGMENTE par fusion de déclarations.
+ *
+ * `@nodefony/http` ignore les protocoles bâtis au-dessus de la socket (le JSON-RPC
+ * de `@nodefony/realtime`, par exemple) et ne peut pas les importer. Le module qui
+ * en porte un déclare son champ ici : {@link IWebsocketContext} et `WebsocketContext`
+ * le reçoivent typé, sans conversion chez le lecteur et sans rien coûter à
+ * l'exécution — la lecture reste un accès de champ ordinaire.
+ *
+ * Chaque champ se déclare OPTIONNEL : il n'existe qu'une fois posé par son module
+ * (à la poignée de main, en général), et vaut `undefined` avant, comme sur toute
+ * connexion que ce module ne sert pas.
+ *
+ * @example
+ * ```ts
+ * declare module "@nodefony/http" {
+ *   interface IWebsocketConnectionState {
+ *     myProtocol?: IMyProtocolState;
+ *   }
+ * }
+ * ```
+ */
+export interface IWebsocketConnectionState {
+}
+export interface IWebsocketContext extends IContext, IWebsocketConnectionState {
     acceptedProtocol?: string | undefined;
     connection: unknown;
     rejected: boolean;
     port: number | string;
     wsUrl: URL | null;
-    queryGet: Record<string, string>;
+    query: Record<string, string>;
     connect(): Promise<unknown>;
     handle(data?: unknown[]): Promise<object>;
     close(reasonCode: number, description: string): unknown;

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

@@ -8,12 +8,18 @@ export interface IRequest {
     getHeader(name: string): string | string[] | undefined;
     getHeaders(): Record<string, string | string[] | undefined>;
 }
+/**
+ * Le corps DÉCODÉ d'une requête : un objet (JSON, formulaire, champs
+ * multipart, XML), une chaîne (`text/*`), ou des octets (`Uint8Array` — tout
+ * autre type, et un corps sans `Content-Type`). Le même type d'octets que la
+ * socket temps réel : un schéma de route valide l'un comme l'autre.
+ */
+export type RequestBody = Record<string, unknown> | string | Uint8Array;
 export interface IHttpRequest extends IRequest {
     url: URL;
     query: Record<string, unknown>;
-    queryGet: Record<string, unknown>;
-    queryPost: Record<string, unknown>;
-    queryFile: unknown[];
+    body: RequestBody;
+    files: readonly unknown[];
     remoteAddress: string | null | undefined;
     acceptHtml: boolean;
     getRemoteAddress(): string | null | undefined;
@@ -29,7 +35,6 @@ export interface IHttp2Request extends IHttpRequest {
 export interface IWsRequest extends IRequest {
     url: URL;
     query: Record<string, string>;
-    queryGet: Record<string, string>;
     path: string;
     cookies?: Record<string, ICookie>;
 }

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

@@ -60,6 +60,16 @@ export interface IRouteResolver {
      *   n'attendent, sinon sa promesse
      */
     callController(data?: unknown[], reload?: boolean): MaybePromise<unknown>;
+    /**
+     * Juge les gardes de l'action résolue (`@IsGranted`, `@RequireScope`,
+     * step-up, rôle de la zone) SANS l'exécuter — le pipeline WebSocket l'appelle
+     * avant d'accepter le handshake, pour qu'un refus parte en statut HTTP. Un
+     * verdict favorable vaut pour la PROCHAINE exécution, qui ne le rejuge pas.
+     *
+     * @returns `undefined` quand l'action n'est pas gardée ; sinon la promesse du
+     *   verdict, rompue par un refus (401/403)
+     */
+    authorizeAction(): Promise<void> | undefined;
 }
 /**
  * Ce que le pipeline HTTP/WS attend du service `router` — implémenté par

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

@@ -1,9 +1,9 @@
 export type { ICookie, ICookieOptions, IWsCookie, SameSiteType, PriorityType, } from "./ICookie.js";
 export type { ISession, ISessionStorage, ISerializedSession, SessionIntent, SessionStatusType, SessionStrategyType, FlashBagType, MetaBagType, } from "./ISession.js";
 export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, } from "./IUpload.js";
-export type { IRequest, IHttpRequest, IHttp2Request, IWsRequest, HTTPMethodType, } from "./IRequest.js";
+export type { IRequest, IHttpRequest, RequestBody, IHttp2Request, IWsRequest, HTTPMethodType, } from "./IRequest.js";
 export type { IResponse, IHttpResponse, IWebsocketResponse } from "./IResponse.js";
-export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType, WebSocketStateType, CookiesMap, } from "./IContext.js";
+export type { IContext, IHttpContext, IWebsocketContext, ServerType, ProtocolName, AlpnProtocol, 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";

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

@@ -61,27 +61,78 @@ export interface ICaFileTrust {
  *
  * @param file - chemin du fichier, absolu ou relatif à `root`
  * @param root - racine de l'application
+ * Chaque refus dit le problème, d'où vient le chemin quand on le sait, puis le
+ * geste qui répare ({@link caFileRemedy}).
+ *
  * @param store - accès aux ancres ; `node:tls` par défaut
+ * @param origin - phrase qui dit d'où vient le chemin (` Valeur venue de …`), insérée dans un refus
  * @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>;
+export declare function trustCaFile(file: string, root: string, store?: ITlsTrustStore, origin?: string): Promise<ICaFileTrust>;
+/**
+ * Le geste qui répare une autorité déclarée qu'on ne peut pas reconnaître.
+ *
+ * Un refus au démarrage qui ne dit que la cause envoie chercher ; celui-ci dit
+ * quoi faire. Pure : éprouvée cause par cause, y compris celles qu'une machine
+ * de test ne sait pas produire (un droit refusé ne l'est pas à `root`, ni
+ * sous Windows).
+ *
+ * @param cause - code système (`ENOENT`, `EACCES`, `EPERM`, `EISDIR`),
+ *   `NOPEM` pour un fichier lu sans certificat, ou tout autre motif
+ * @returns la phrase du geste
+ */
+export declare function caFileRemedy(cause: string): string;
+/**
+ * Dossier où Nodefony range les certificats qu'il fabrique en développement,
+ * relatif au répertoire courant.
+ *
+ * @returns le chemin absolu de `nodefony/config/certificates`
+ */
+export declare function certificatesDirectory(): string;
+/**
+ * Chemin de l'autorité de DÉVELOPPEMENT : le certificat racine que Nodefony
+ * fabrique lui-même pour signer le certificat du serveur local. Généré, jamais
+ * versionné — une seule convention, que le service et la confiance sortante lisent.
+ *
+ * @param directory - dossier des certificats ; {@link certificatesDirectory} par défaut
+ * @returns le chemin absolu du fichier PEM de l'autorité
+ */
+export declare function developmentAuthorityPath(directory?: string): string;
+/** Décor de {@link trustOutboundAuthorities} — injectable pour l'éprouver. */
+export interface IOutboundTrustContext {
+    /** Vrai en développement : seul décor où l'autorité de dev absente est tolérée. */
+    readonly development?: boolean;
+    /** Chemin absolu de l'autorité de développement ; {@link developmentAuthorityPath} par défaut. */
+    readonly developmentAuthority?: string;
+    /** Environnement lu pour nommer la variable d'origine ; `process.env` par défaut. */
+    readonly env?: NodeJS.ProcessEnv;
+    /** Accès aux ancres ; `node:tls` par défaut. */
+    readonly store?: ITlsTrustStore;
+}
 /**
  * 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}).
+ * L'autorité de DÉVELOPPEMENT déclarée mais pas encore engendrée est ignorée en
+ * développement, et le journal le dit : elle n'a signé aucun certificat, il n'y
+ * a donc rien à lui faire confiance, et le serveur de développement la pose
+ * lui-même quand il la fabrique ({@link Certificate.generateServerCertificates}).
+ * Rien n'est fabriqué ici : une commande console n'écrit pas de certificat.
+ * Une autre autorité absente, ou n'importe laquelle hors développement, reste
+ * un refus — qui nomme la variable d'origine et le geste qui répare
+ * ({@link caFileRemedy}).
  *
  * @param files - `certificates.extraCaFiles`
  * @param root - racine de l'application
  * @param log - journal du module
+ * @param context - décor (environnement, autorité de dev, ancres)
  * @throws BootConfigurationError - cf {@link trustCaFile}
  */
-export declare function trustOutboundAuthorities(files: readonly string[], root: string, log: (message: string, severity: "INFO") => void): Promise<void>;
+export declare function trustOutboundAuthorities(files: readonly string[], root: string, log: (message: string, severity: "INFO") => void, context?: IOutboundTrustContext): Promise<void>;
 /** Paire de clés RSA du certificat auto-signé. */
 export interface IRsaKeyPair {
     privateKey: KeyObject;

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

@@ -1,5 +1,36 @@
 import type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult } from "../interfaces/IErrorRenderer.js";
 import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+/** Champ fautif, tel qu'exposé au client dans le corps JSON (`error.fields`). */
+export interface IValidationField {
+    /** Chemin pointé du champ (`"author.email"`). */
+    field: string;
+    /** Message lisible. */
+    message: string;
+    /** Contrôle qui a échoué (`too_small`…) — utile au client pour réagir finement. */
+    rule?: string | undefined;
+    /**
+     * Partie de l'entrée qui porte le champ (`body`, `query`, `params`,
+     * `headers`) — présente pour une route à schéma, où deux parties peuvent
+     * porter le même nom. `field` reste relatif à sa partie : un formulaire le
+     * relie à son champ de saisie sans rien retirer.
+     */
+    in?: string | undefined;
+}
+/**
+ * Reconnaît une erreur de validation — `ZodError`, ou `SchemaValidationError`
+ * d'une route à schéma — et en extrait les champs fautifs.
+ *
+ * Reconnaissance **structurelle** (`name` + `issues`), pas `instanceof ZodError` :
+ * une application peut embarquer sa propre copie de zod (résolutions npm multiples),
+ * et `instanceof` échouerait alors en silence — la validation retomberait en 500.
+ * Même parti-pris que le duck-typing de `isPromise` dans le framework.
+ *
+ * Ne coûte rien au chemin nominal : ce code ne tourne que sur une erreur déjà levée.
+ *
+ * @param error - erreur remontée par le pipeline.
+ * @returns les champs fautifs, ou `null` si ce n'est pas une erreur de validation.
+ */
+export declare function toValidationFields(error: Error): IValidationField[] | null;
 /**
  * Reconnaît un identifiant MAL FORMÉ refusé par la base, et rend la valeur fautive.
  *