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

package/dist/nodefony/src/context/requestTrace.js

@@ -0,0 +1,104 @@
+import diagnosticsChannel from "node:diagnostics_channel";
+// nodefony/src/context/requestTrace.ts
+/**
+* Nom du `TracingChannel` qui encadre chaque requête HTTP et chaque handshake
+* WebSocket — forme `module.fonction` recommandée par la documentation de
+* `node:diagnostics_channel` ; les sous-canaux sont
+* `tracing:nodefony.http.request:start`, `:end`, `:asyncStart`, `:asyncEnd`,
+* `:error`.
+*/
+const REQUEST_TRACE_CHANNEL = "nodefony.http.request";
+const tracing = diagnosticsChannel.tracingChannel(REQUEST_TRACE_CHANNEL);
+const startChannel = tracing.start;
+const endChannel = tracing.end;
+const asyncStartChannel = tracing.asyncStart;
+const asyncEndChannel = tracing.asyncEnd;
+const errorChannel = tracing.error;
+/**
+* Dit si quelqu'un écoute le canal — LA garde du chemin chaud : ~1,6 ns
+* mesurées, aucune allocation. Lue une seule fois, au début de la requête :
+* un abonné arrivé ensuite ne voit que les requêtes suivantes (règle des
+* `TracingChannel`, qui interdit une fin sans début).
+*
+* @returns `true` si au moins un sous-canal a un abonné
+*/
+function hasRequestTraceSubscribers() {
+	return tracing.hasSubscribers;
+}
+/**
+* Crée le message de la requête et le range sur son contexte. À n'appeler
+* que sous {@link hasRequestTraceSubscribers} : c'est la seule allocation
+* du canal, et elle n'a lieu que si quelqu'un écoute.
+*
+* @param context - le contexte qui vient d'être construit
+* @param protocol - requête HTTP ou handshake WebSocket
+* @returns le message, de forme fixe, dont les champs de résultat valent `null`
+*/
+function openRequestTrace(context, protocol) {
+	const trace = {
+		requestId: context.requestId,
+		protocol,
+		method: context.method,
+		scheme: context.scheme,
+		url: context.url,
+		route: null,
+		routePath: null,
+		module: null,
+		statusCode: null,
+		durationMs: null,
+		error: null
+	};
+	context.requestTrace = trace;
+	return trace;
+}
+/**
+* Exécute la partie synchrone du traitement sous `start.runStores` puis
+* publie `end` — la séquence de `TracingChannel.tracePromise`. Les stores
+* liés au canal (`bindStore`, ce que fait un agent APM) restent actifs pour
+* toute la suite asynchrone de la requête.
+*
+* @param trace - le message de la requête
+* @param fn - la fonction qui sert la requête
+* @param thisArg - le receveur de `fn`
+* @param args - les arguments de `fn`
+* @returns ce que rend `fn` — un contexte ou sa promesse
+*/
+function runTraced(trace, fn, thisArg, ...args) {
+	try {
+		return startChannel.runStores(trace, fn, thisArg, ...args);
+	} finally {
+		endChannel.publish(trace);
+	}
+}
+/**
+* Termine la trace de la requête : remplit les champs de résultat puis
+* publie `error` (s'il y a une exception), `asyncStart` et `asyncEnd`.
+* Idempotent — le premier appel gagne, les suivants ne font rien : un
+* handshake WebSocket a plusieurs sorties, une seule publie la fin.
+*
+* La durée est celle de l'horloge unique du contexte (`stopClock`), la même
+* que celle de la ligne d'accès : le canal n'en mesure aucune.
+*
+* @param context - le contexte de la requête
+* @param statusCode - le statut rendu au client, `null` s'il n'y en a pas eu
+* @param error - l'exception attrapée par le pipeline, `null` ou `undefined` sinon
+*/
+function closeRequestTrace(context, statusCode, error) {
+	const trace = context.requestTrace;
+	if (trace === null) return;
+	context.requestTrace = null;
+	const route = context.resolver?.route ?? null;
+	trace.route = route?.name ?? null;
+	const path = route?.path;
+	trace.routePath = path === void 0 ? null : path === "" ? "/" : path;
+	trace.module = context.logModule ?? route?.module?.name ?? null;
+	trace.statusCode = statusCode;
+	trace.durationMs = context.stopClock();
+	if (error !== null && error !== void 0) {
+		trace.error = error;
+		errorChannel.publish(trace);
+	}
+	asyncStartChannel.publish(trace);
+	asyncEndChannel.publish(trace);
+}
+export { REQUEST_TRACE_CHANNEL, closeRequestTrace, hasRequestTraceSubscribers, openRequestTrace, runTraced };

package/dist/nodefony/src/context/timingMode.js

@@ -0,0 +1,21 @@
+// nodefony/src/context/timingMode.ts
+/**
+* Résout le mode de chronométrage d'une requête depuis `timing.enabled` et
+* l'environnement — la SEULE règle, appelée par le constructeur du `Context`.
+*
+* Défaut (`null`, pas d'avis) : la durée partout, les phases hors production.
+* La durée coûte deux lectures d'horloge, l'équivalent de quelques pourcents
+* de la ligne d'accès qu'elle complète ; les phases coûtent une lecture par
+* phase, un tableau et un index par requête — réservées au développement, ou
+* à un diagnostic à chaud (`true`). `false` coupe tout, durée comprise.
+*
+* @param enabled - valeur de `timing.enabled` (`true`, `false`, `null`)
+* @param environment - environnement normalisé du noyau (`"production"`…)
+* @returns le mode de la requête — une chaîne littérale, rien d'alloué
+*/
+function resolveTimingMode(enabled, environment) {
+	if (enabled === false) return "off";
+	if (enabled === true) return "phases";
+	return environment === "production" ? "clock" : "phases";
+}
+export { resolveTimingMode };

package/dist/nodefony/src/context/unsentResponse.js

@@ -0,0 +1,30 @@
+// nodefony/src/context/unsentResponse.ts
+/**
+* Rédige l'avertissement de développement d'une requête restée sans réponse :
+* l'action a rendu une valeur que le framework ne sait pas envoyer, et la
+* requête a attendu son délai d'expiration.
+*
+* Le message nomme l'action fautive, ce qu'elle a rendu, et le geste qui
+* convient à ce cas — `null` est presque toujours une entité absente, qui
+* appelle un 404.
+*
+* @param resolver - le resolver de la requête (route, controller, action,
+*   valeur non rendue), `null` si aucune route n'a été résolue.
+* @param url - l'URL de la requête, repli quand aucune route n'est connue.
+* @returns le texte de l'avertissement.
+*/
+function unsentResponseWarning(resolver, url) {
+	const controller = resolver?.controller?.name;
+	const actionName = resolver?.actionName;
+	const action = controller && actionName ? `${controller}.${actionName}` : null;
+	const route = resolver?.route?.name ?? null;
+	const where = action ? `L'action ${action}${route ? ` (route ${route})` : ""}` : `L'action de ${route ?? url}`;
+	const returned = resolver?.unrendered ?? null;
+	const consequence = "et n'a rien envoyé : la requête a attendu son délai d'expiration.";
+	if (returned === "null") return `${where} a rendu null ${consequence} Pour le framework, null veut dire « l'action répond elle-même ». Entité absente → lever HttpError(…, 404) ; sinon rendre la valeur, ou envoyer la réponse soi-même.`;
+	if (returned === "undefined") return `${where} n'a rien rendu ${consequence} Un « return » oublié ? Rendre la valeur (objet, chaîne, nombre, booléen, Buffer : envoyés automatiquement), ou envoyer la réponse soi-même.`;
+	if (returned?.startsWith("une instance de")) return `${where} a rendu ${returned}, qui ne s'envoie pas telle quelle, ${consequence} Rendre un objet simple (sa forme JSON), ou envoyer la réponse soi-même.`;
+	if (returned !== null) return `${where} a rendu une valeur de type ${returned} ${consequence} Rendre un objet, une chaîne, un nombre, un booléen ou un Buffer, ou envoyer la réponse soi-même.`;
+	return `${where} n'a rien envoyé : la requête a attendu son délai d'expiration. Rendre la valeur, ou envoyer la réponse soi-même.`;
+}
+export { unsentResponseWarning };

package/dist/nodefony/src/context/websocket/WebsocketContext.js

@@ -1,4 +1,5 @@
 import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
+import { closeRequestTrace } from "../requestTrace.js";
 import Context from "../Context.js";
 import { toWsCloseReason } from "./wsCloseReason.js";
 import WebsocketResponse from "./Response.js";
@@ -6,7 +7,7 @@ import { sanitizeRequestId } from "../requestId.js";
 import { FrameProfile } from "../../profiler/FrameProfile.js";
 import { formatWsLogContent } from "./wsLogContent.js";
 import { parseWebsocketUrl } from "./websocketUrl.js";
-import { RequestContext, logColor } from "nodefony";
+import { RequestContext, frameRequestId, logColor } from "nodefony";
 import { AsyncResource } from "node:async_hooks";
 import url, { URL } from "node:url";
 import Ws from "ws";
@@ -173,16 +174,16 @@ var WebsocketContext = class extends Context {
 			this.log(`PROXY WEBSOCKET REQUEST ${fwd.fromStandard ? "Forwarded (RFC 7239)" : "x-forwarded"} VIA : ${this.proxy.proxyVia}`, "DEBUG");
 		}
 	}
-	log(pci, severity, msgid, msg) {
+	log(pci, severity, msgid, msg, moduleName) {
 		if (!msgid) msgid = "WEBSOCKET CONTEXT";
-		return super.log(pci, severity, msgid, msg);
+		return super.log(pci, severity, msgid, msg, moduleName);
 	}
 	logRequest(httpError, acceptedProtocol) {
 		try {
 			const logger = this.httpKernel?.getRequestLogger();
 			if (!logger) return;
 			const entry = logger.renderWebsocket(this, httpError ?? null, acceptedProtocol ?? null);
-			const pdu = this.log(entry.text, entry.severity, entry.msgid);
+			const pdu = this.log(entry.text, entry.severity, entry.msgid, void 0, this.logModule ?? this.resolver?.route?.module?.name);
 			pdu.requestId ??= this.requestId;
 			return pdu;
 		} catch {
@@ -215,6 +216,7 @@ var WebsocketContext = class extends Context {
 		this.rejected = true;
 		this.webSocketState = "error";
 		admission.refuse(status, this.response?.handshakeHeaders ?? null);
+		if (this.requestTrace !== null) closeRequestTrace(this, status, this.error);
 		return true;
 	}
 	async connect() {
@@ -228,6 +230,7 @@ var WebsocketContext = class extends Context {
 		this.requestEnded = true;
 		this.connection.on("message", AsyncResource.bind(this.handleMessage.bind(this)));
 		this.logRequest(null, this.acceptedProtocol ?? null);
+		if (this.requestTrace !== null) closeRequestTrace(this, 101, null);
 		this.webSocketState = "connected";
 		return this.connection;
 	}
@@ -337,10 +340,11 @@ var WebsocketContext = class extends Context {
 	*          zéro allocation dans ce cas.
 	*/
 	beginFrame(method, framePath) {
-		if (!this.profiling && !this.timingEnabled) return null;
+		const profiled = this.profiling && this.httpKernel?.shouldProfile(framePath) === true;
+		if (!profiled && !this.timingEnabled) return null;
 		this.#frameSeq += 1;
 		return new FrameProfile({
-			requestId: `${this.requestId}.${this.#frameSeq}`,
+			requestId: frameRequestId(this.requestId, this.#frameSeq),
 			type: this.type,
 			scheme: this.scheme,
 			method,
@@ -350,7 +354,7 @@ var WebsocketContext = class extends Context {
 			security: this.security ?? null,
 			securityTrace: this.securityTrace,
 			timing: this.timingEnabled,
-			queries: this.profiling
+			queries: profiled
 		});
 	}
 	/**
@@ -358,7 +362,7 @@ var WebsocketContext = class extends Context {
 	* Profiler (no-op hors dev, ou si aucun profil n'a été ouvert).
 	*/
 	collectFrame(frame) {
-		if (frame === null || !this.profiling) return;
+		if (frame === null || !frame.profiled) return;
 		this.get("profiler")?.collect(frame);
 	}
 	/**

package/dist/nodefony/src/profiler/FrameProfile.js

@@ -37,12 +37,22 @@ var FrameProfile = class {
 	* invocation, il redevient exact, et le SQL se replace dans le waterfall.
 	*/
 	profilerQueries;
+	/**
+	* Ce profil sera-t-il gardé par le Profiler ? Faux quand seul le timing
+	* l'a ouvert (chemin d'outillage) : son id ne désigne alors aucun profil
+	* lisible, et ne doit pas être annoncé au client.
+	*/
+	get profiled() {
+		return this.profilerQueries !== null;
+	}
 	/** Resolver de la frame — porte route / controller / action. */
 	resolver = null;
 	/** Statut HTTP-équivalent de l'invocation (200, 403, 404…). */
 	response = null;
 	error = null;
 	timing;
+	clockStartMs;
+	durationMs = null;
 	constructor(init) {
 		this.requestId = init.requestId;
 		this.type = init.type;
@@ -54,9 +64,20 @@ var FrameProfile = class {
 		this.security = init.security;
 		this.securityTrace = init.securityTrace;
 		this.timing = init.timing;
+		this.clockStartMs = init.timing ? performance.now() : 0;
 		this.profilerQueries = init.queries ? [] : null;
 	}
 	/**
+	* Arrête l'horloge de la frame (au premier appel) et rend sa durée en ms ;
+	* `null` si le timing est éteint. Contrat de `IContext.stopClock`.
+	*
+	* @returns la durée de l'invocation, ou `null`
+	*/
+	stopClock() {
+		if (!this.timing) return null;
+		return this.durationMs ??= performance.now() - this.clockStartMs;
+	}
+	/**
 	* Ouvre une phase. Contrairement au `Context`, l'index est un **scan arrière**
 	* (pas de `Map<nom, index>`) : une frame porte une poignée de phases, et une
 	* phase peut être ré-entrante (une action qui en déclenche une autre) — la
@@ -88,6 +109,7 @@ var FrameProfile = class {
 	* @param error - l'erreur qui a interrompu la frame, le cas échéant.
 	*/
 	finish(status, error) {
+		this.stopClock();
 		this.response = { statusCode: status };
 		if (error !== void 0 && error !== null) this.error = { message: thrownMessage(error) };
 	}

package/dist/nodefony/src/profiler/Profiler.js

@@ -1,24 +1,9 @@
 import { profileLane } from "./aggregate.js";
+import { frameIndexOf } from "nodefony";
 // nodefony/src/profiler/Profiler.ts
-/**
-* Durée totale = (fin de la dernière phase) − (début de la 1ère).
-*
-* Une phase encore OUVERTE à la collecte (action interrompue par le départ du
-* client : flux SSE, outil MCP annulé) court jusqu'à la collecte — la compter
-* pour zéro publiait 0,3 ms pour un appel coupé à 3 s.
-*/
-function totalDuration(phases) {
-	if (phases.length === 0) return null;
-	const first = phases.at(0);
-	if (first === void 0 || typeof first.startMs !== "number") return null;
-	let end = first.startMs;
-	let now = null;
-	for (const p of phases) {
-		const e = p.durationMs === void 0 ? now ??= performance.now() : p.startMs + p.durationMs;
-		if (e > end) end = e;
-	}
-	const d = end - first.startMs;
-	return d >= 0 ? Math.round(d * 1e3) / 1e3 : null;
+/** Arrondit une durée à la microseconde (affichage du Suivi). */
+function roundMicro(ms) {
+	return ms === null ? null : Math.round(ms * 1e3) / 1e3;
 }
 /** Capacité par défaut du ring buffer (assez pour une session de debug). */
 const DEFAULT_CAP = 500;
@@ -77,7 +62,7 @@ var Profiler = class {
 			url: ctx.url ?? "",
 			scheme: ctx.scheme ?? "",
 			status: ctx.response?.statusCode ?? (ctx.error ? 500 : null),
-			durationMs: totalDuration(phases),
+			durationMs: roundMicro(ctx.stopClock()),
 			route: ctx.resolver?.route?.name ?? null,
 			controller: ctx.resolver?.controller?.name ?? null,
 			action: ctx.resolver?.actionName ?? null,
@@ -112,12 +97,17 @@ var Profiler = class {
 	}
 	/**
 	* Résumés des requêtes les plus récentes (récent → ancien), capés à `limit`.
+	*
+	* @param limit - nombre maximal de résumés
+	* @param connection - le requestId d'une connexion WebSocket : ses SEULES
+	*   frames du pont (`<connection>.<n>`, règle `frameIndexOf` du cœur)
 	*/
-	recent(limit = 60) {
+	recent(limit = 60, connection) {
 		const out = [];
 		const entries = this.#collectAfter(0).reverse();
 		for (const e of entries) {
 			if (out.length >= limit) break;
+			if (connection && frameIndexOf(e.requestId, connection) === null) continue;
 			out.push({
 				requestId: e.requestId,
 				ts: e.ts,

package/dist/nodefony/src/profiler/aggregate.js

@@ -1,4 +1,5 @@
 import { MODULE_PROXY_PREFIXES } from "../proxy/rules.js";
+import { isConsolePath } from "nodefony";
 // nodefony/src/profiler/aggregate.ts
 /**
 * Agrégation des profils de requêtes — règle PURE, sans horloge ni I/O.
@@ -22,20 +23,28 @@ const ROUTE_SAMPLE_CAP = 256;
 const SQL_SHAPE_CAP = 200;
 /** Exemples d'erreurs retenus (statut ≥ 500 ou exception). */
 const ERROR_SAMPLE_CAP = 10;
-/** Préfixe des routes de l'outillage (console, API d'administration, porte MCP). */
+/**
+* Préfixe de l'espace réservé au framework.
+*
+* @deprecated Ne dit pas ce qui est de l'outillage : une connexion
+*   d'utilisateur (`/nodefony/security/api/auth/…`) ou une route d'application
+*   (`/nodefony/test/index`) passent sous ce préfixe. La règle est
+*   `isConsolePath` (`nodefony`), que `profileLane` appelle.
+*/
 const TOOLING_URL_PREFIX = "/nodefony/";
 /**
-* Range un profil par provenance, d'après son URL. Seule règle du partage —
-* les anneaux du profileur et le filtre de l'agrégation la lisent tous deux.
+* Range un profil par provenance, d'après son URL. L'outillage est reconnu par
+* la règle du cœur, `isConsolePath` — la même que les Journaux, la barre de
+* débogage et le Studio : une connexion d'utilisateur reste de l'application.
+* Les anneaux du profileur et le filtre de l'agrégation la lisent tous deux.
 *
 * @param url - URL du profil, absolue ou chemin.
 * @returns la provenance du profil.
 */
 function profileLane(url) {
 	const path = urlPath(url);
-	if (path.startsWith("/nodefony/")) return "tooling";
 	for (const prefix of MODULE_PROXY_PREFIXES) if (path.startsWith(prefix)) return "asset";
-	return "app";
+	return isConsolePath(path) ? "tooling" : "app";
 }
 /**
 * Le profil vient-il de l'outillage (routes `/nodefony/…` ou assets relayés)
@@ -46,6 +55,17 @@ function profileLane(url) {
 function isToolingUrl(url) {
 	return profileLane(url) !== "app";
 }
+/**
+* Une requête de cette URL se profile-t-elle ? L'application toujours ;
+* l'outillage et les assets relayés seulement sur demande (`timing.tooling`)
+* — on ne mesure pas la façon dont on mesure.
+*
+* @param url - URL ou chemin de la requête (ou de la frame du pont)
+* @param tooling - profiler aussi l'outillage
+*/
+function isProfiledUrl(url, tooling) {
+	return tooling || profileLane(url) === "app";
+}
 /** Groupe des requêtes qu'aucune route n'a servies (404, statique, sondes). */
 const NO_ROUTE = "(aucune route)";
 /** Pseudo-phase : le temps de l'action hors phases imbriquées et hors SQL. */
@@ -419,4 +439,4 @@ function aggregateProfiles(entries, options = {}) {
 	for (const entry of entries) aggregator.add(entry);
 	return aggregator.result();
 }
-export { ACTION_SELF_PHASE, ERROR_SAMPLE_CAP, NO_ROUTE, N_PLUS_ONE_MIN_REPEATS, ROUTE_SAMPLE_CAP, SQL_SHAPE_CAP, TOOLING_URL_PREFIX, aggregateProfiles, createProfileAggregator, isFailedProfile, isToolingUrl, profileLane, sqlShape, urlPath };
+export { ACTION_SELF_PHASE, ERROR_SAMPLE_CAP, NO_ROUTE, N_PLUS_ONE_MIN_REPEATS, ROUTE_SAMPLE_CAP, SQL_SHAPE_CAP, TOOLING_URL_PREFIX, aggregateProfiles, createProfileAggregator, isFailedProfile, isProfiledUrl, isToolingUrl, profileLane, sqlShape, urlPath };

package/dist/types/index.d.ts

@@ -72,6 +72,8 @@ 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";

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

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

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).
      *

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

@@ -7,4 +7,5 @@ export type { IContext, IHttpContext, IWebsocketContext, ServerType, ProtocolNam
 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";

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

@@ -10,6 +10,9 @@ import type { Profiler } from "../src/profiler/Profiler.js";
  *
  * Endpoints :
  *  - `GET /nodefony/profiler/api/recent`  → derniers profils (résumés, récent → ancien)
+ *    `?connection=<requestId>` : les seules frames de cette socket WebSocket
+ *  - `GET /nodefony/profiler/api/summary` → les profils de l'anneau agrégés par
+ *    route (percentiles, phases, formes SQL, N+1, erreurs — `aggregateProfiles`)
  *  - `GET /nodefony/profiler/api/{id}`    → profil complet (phases) d'un requestId
  *  - `DELETE /nodefony/profiler/api/recent` → vide le ring buffer
  *

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

@@ -1,6 +1,7 @@
 import type { Severity } from "nodefony";
 import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
-import type { IHttpContext, IWebsocketContext, PhaseTiming } from "../interfaces/IContext.js";
+import type { IContext, IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+declare const statusOf: (context: IContext) => number | null;
 /**
  * Canonical audit log entry — 1 JSON PDU per request (P3.1).
  *
@@ -52,15 +53,6 @@ export interface AuditErrorEntry {
     /** Recursive — capped to depth 5 to avoid pathological cycles. */
     cause?: AuditErrorEntry;
 }
-/**
- * Durée totale de la requête, de la première phase (`startMs`) à maintenant.
- * `null` si le chronométrage est coupé (aucune phase enregistrée). Partagée
- * par le journal d'audit et le journal lisible — une seule définition.
- *
- * @param phases - phases chronométrées du contexte
- * @returns durée en millisecondes, ou `null`
- */
-declare function computeDurationMs(phases: PhaseTiming[]): number | null;
 /**
  * Severity derived from HTTP status code — RFC 9110 categories.
  * 1xx/2xx/3xx → INFO ; 4xx → WARNING ; 5xx → ERROR.
@@ -145,4 +137,4 @@ declare class JsonAuditLogger implements IRequestLogger {
     private serializeError;
 }
 export default JsonAuditLogger;
-export { computeDurationMs, severityFromStatus };
+export { severityFromStatus, statusOf };