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

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,9 @@ 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 { REQUEST_TRACE_CHANNEL } from "./nodefony/src/context/requestTrace.js";
+export type { IRequestTrace, RequestTraceProtocol, } from "./nodefony/interfaces/IRequestTrace.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 +82,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 +93,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/config/config.d.ts

@@ -198,6 +198,10 @@ export declare const httpConfigSchema: z.ZodObject<{
             stripHeaders: z.ZodDefault<z.ZodArray<z.ZodString>>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
             secure: z.ZodDefault<z.ZodBoolean>;
+            accessLog: z.ZodDefault<z.ZodEnum<{
+                all: "all";
+                errors: "errors";
+            }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
     wsMaxConnectionsPerIp: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;

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;
@@ -93,6 +127,15 @@ export interface IContext {
     readonly phases: PhaseTiming[];
     phaseStart(name: PhaseName): void;
     phaseEnd(name: PhaseName): void;
+    /**
+     * Arrête l'horloge de la requête (au premier appel) et rend sa durée en ms —
+     * la SEULE durée de requête du framework, mesurée partout par défaut ; `null`
+     * seulement si `timing.enabled` vaut `false`.
+     *
+     * Membre REQUIS : le journal d'accès et le profileur le lisent sans repli.
+     * Une implémentation maison d'`IContext` qui ne mesure rien rend `null`.
+     */
+    stopClock(): number | null;
     profiling: boolean;
     securityTrace: ISecurityTrace | null;
     onAfterResponse(fn: AfterResponseHandler): void;
@@ -139,13 +182,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/IRequestTrace.d.ts

@@ -0,0 +1,56 @@
+import type { SchemeType } from "./IContext.js";
+import type { HTTPMethodType } from "./IRequest.js";
+/**
+ * Nature de l'opération tracée : une requête HTTP, ou le handshake d'une
+ * connexion WebSocket.
+ */
+export type RequestTraceProtocol = "http" | "websocket";
+/**
+ * Message publié sur le `TracingChannel` `nodefony.http.request`, le même
+ * objet de `start` à `asyncEnd` pour une requête donnée.
+ *
+ * Les champs d'identité (`requestId`, `protocol`, `method`, `scheme`, `url`)
+ * sont posés dès `start`. Les champs de résultat (`route`, `routePath`,
+ * `module`, `statusCode`, `durationMs`, `error`) valent `null` jusqu'à la fin
+ * de la requête : un abonné les lit sur `asyncEnd`. Tout est en lecture seule
+ * pour l'abonné — c'est Nodefony qui les remplit.
+ */
+export interface IRequestTrace {
+    /** Identifiant de corrélation de la requête (`X-Request-Id` entrant, sinon généré). */
+    readonly requestId: string;
+    /** `"http"` pour une requête, `"websocket"` pour un handshake. */
+    readonly protocol: RequestTraceProtocol;
+    /** Méthode de la requête (`"WEBSOCKET"` pour un handshake). */
+    readonly method: HTTPMethodType | null;
+    /** Schéma vu par le client, proxy de confiance compris (`url.scheme` d'OpenTelemetry). */
+    readonly scheme: SchemeType;
+    /** URL complète de la requête, chaîne de requête comprise — l'abonné en tire `url.path` et `url.query`. */
+    readonly url: string;
+    /** Nom de la route qui a répondu, `null` sans route (statique, 404). */
+    readonly route: string | null;
+    /**
+     * Gabarit de la route, préfixe compris (`/users/{id}`) : faible cardinalité,
+     * c'est l'attribut `http.route` d'OpenTelemetry. La racine vaut `/`. `null`
+     * sans route.
+     */
+    readonly routePath: string | null;
+    /** Module qui a signé la réponse — le même que celui de la ligne d'accès. */
+    readonly module: string | null;
+    /**
+     * Statut rendu au client : celui de l'amont pour une requête relayée, `101`
+     * pour un handshake accepté, le statut du refus sinon. `null` si le client
+     * est parti avant toute réponse.
+     */
+    readonly statusCode: number | null;
+    /**
+     * Durée de la requête en millisecondes, construction du contexte → dernier
+     * octet remis (fin du handshake en WebSocket). `null` si `timing.enabled`
+     * vaut `false`.
+     */
+    readonly durationMs: number | null;
+    /**
+     * Exception attrapée par le pipeline, `null` sinon. Un statut 4xx rendu
+     * sans exception n'en porte pas ; c'est à l'abonné de classer un statut.
+     */
+    readonly error: unknown;
+}

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

@@ -59,6 +59,14 @@ export interface IProxyMountOptions {
      * ACCEPTÉ que vers la boucle locale (refus au montage sinon).
      */
     secure?: boolean | undefined;
+    /**
+     * Ligne d'accès des requêtes relayées : `"all"` (défaut) les écrit toutes,
+     * `"errors"` seulement celles en échec (statut ≥ 400). Pour un amont qui sert
+     * des centaines de fichiers par page (le relais de Vite) : un fichier bien
+     * servi n'apprend rien, et ses lignes chassaient les autres de la mémoire
+     * du journal.
+     */
+    accessLog?: "all" | "errors" | undefined;
 }
 /** Un montage tel que le proxy le garde : préfixe normalisé + réglages. */
 export interface IProxyMount extends IProxyMountOptions {

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

@@ -11,6 +11,15 @@ import type { ContextType } from "../service/http-kernel.js";
 export interface IResolvedRoute {
     /** Nom de la route (journalisation, diagnostic). */
     readonly name: string;
+    /**
+     * Gabarit de la route, préfixe compris (`/users/{id}`) — faible cardinalité,
+     * publié comme `routePath` sur le canal `nodefony.http.request`.
+     */
+    readonly path?: string | undefined;
+    /** Module propriétaire — il signe la ligne d'accès de la requête. */
+    readonly module?: {
+        readonly name: string;
+    } | undefined;
     /** Corps laissé en flux (`@Body({ stream: true })`) : le parse est sauté. */
     readonly bodyStream?: boolean | undefined;
 }
@@ -35,6 +44,13 @@ export interface IRouteResolver {
     } | null | undefined;
     /** Nom de l'action résolue. */
     actionName?: string | undefined;
+    /**
+     * Ce que l'action a rendu sans que rien ne soit envoyé (`"null"`,
+     * `"undefined"`, `"une instance de Book"`…), `null` sinon. Posé seulement
+     * sur la branche « l'action répond elle-même » : lu au démontage pour dire,
+     * en développement, POURQUOI une requête a attendu son délai d'expiration.
+     */
+    readonly unrendered?: string | null | undefined;
     /**
      * Rejoue le match d'une route sur un contexte (WS : handshake puis frames).
      *
@@ -60,6 +76,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,10 +1,11 @@
 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";
+export type { IRequestTrace, RequestTraceProtocol } from "./IRequestTrace.js";
 export type { IProxyMount, IProxyMountOptions, ProxyTarget, } from "./IReverseProxy.js";