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

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,11 +7,11 @@ 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 Ws from "ws";
+import { RequestContext, frameRequestId, logColor } from "nodefony";
 import { AsyncResource } from "node:async_hooks";
 import url, { URL } from "node:url";
-//#region nodefony/src/context/websocket/WebsocketContext.ts
+import Ws from "ws";
+// nodefony/src/context/websocket/WebsocketContext.ts
 /**
 * Appelle l'action résolue et rend TOUJOURS une promesse.
 *
@@ -54,6 +55,51 @@ function toWsCloseCode(code) {
 	return 1011;
 }
 /**
+* Statut HTTP d'un handshake REFUSÉ avant le `101` (RFC 6455 §4.2.2) — la
+* réciproque de {@link toWsCloseCode} : une erreur levée pendant la décision
+* porte un code HTTP (pare-feu, garde) ou, par héritage, un code de fermeture
+* WS (origine `1008`, protocole `1002`, introuvable `4004`) ; le client qui
+* lit le statut doit y reconnaître le même sens.
+*
+* @param code - code porté par l'erreur
+* @returns un statut HTTP 4xx/5xx
+*/
+function toHandshakeStatus(code) {
+	if (typeof code !== "number" || !Number.isInteger(code)) return 500;
+	if (code >= 400 && code <= 599) return code;
+	switch (code) {
+		case 1002:
+		case 1003:
+		case 1007: return 400;
+		case 1008:
+		case 4003: return 403;
+		case 4001: return 401;
+		case 1009: return 413;
+		case 1013: return 503;
+		case 4004: return 404;
+		default: return 500;
+	}
+}
+/**
+* Statut HTTP que reçoit le client d'un handshake refusé — ou `null` si la
+* connexion était déjà acceptée.
+*
+* La ligne de journal d'un refus s'écrit AVANT `refuseHandshake` : sans ce
+* calcul, elle affichait le code de fermeture par défaut (`1000`) en ERROR,
+* pour un `400` que le client reçoit. Même conversion que le refus
+* ({@link toHandshakeStatus}), donc même chiffre. Chemin d'ERREUR seulement :
+* 1 comparaison et 1 `typeof`, aucune allocation.
+*
+* @param context - le contexte WS de la ligne
+* @param error - l'erreur qui a interrompu le handshake
+* @returns le statut HTTP du refus, ou `null` après l'acceptation
+*/
+function handshakeRefusalStatus(context, error) {
+	if (context.webSocketState !== "handshake") return null;
+	const code = error.code;
+	return toHandshakeStatus(typeof code === "number" ? code : void 0);
+}
+/**
 * Drapeau « logger le CONTENU des messages WS » — résolu **une seule fois** au
 * premier message (kernel présent). `true` hors production : le Suivi de requête
 * (Studio) affiche alors les frames RECEIVE/SEND/BROADCAST. En prod → `false` →
@@ -68,16 +114,21 @@ var WebsocketContext = class extends Context {
 	rejected = false;
 	teardownWired = false;
 	connection = null;
+	/**
+	* Le verdict du handshake encore à rendre : posé par le noyau tant que le
+	* pipeline décide (pare-feu, garde de l'action), `null` dès que la socket
+	* est acceptée ou refusée. Tant qu'il est là, AUCUN `101` n'est parti.
+	*/
+	admission = null;
 	origin;
 	proxy = null;
 	forwarded = null;
 	wsUrl = null;
-	queryGet = {};
-	queryRequest = {};
+	query = {};
 	wsPath = "";
 	#frameSeq = 0;
-	constructor(scope, req, ws, type) {
-		super(scope, type);
+	constructor(scope, req, ws, serverType) {
+		super(scope, serverType);
 		this.webSocketState = "handshake";
 		this.request = req;
 		this.connection = ws;
@@ -89,18 +140,16 @@ var WebsocketContext = class extends Context {
 		if (checker && checker.isTrusted(socketAddress) && hasForwardingHeaders(req.headers)) this.forwarded = resolveForwarded(req.headers, socketAddress, checker);
 		this.remoteAddress = this.getRemoteAddress();
 		this.acceptedProtocol = req.headers["sec-websocket-protocol"];
-		this.scheme = type === "websocket-secure" ? "wss" : "ws";
+		this.scheme = serverType === "wss" ? "wss" : "ws";
 		const incomingId = sanitizeRequestId(req.headers["x-request-id"]);
 		if (incomingId) this.requestId = incomingId;
 		this.wsUrl = parseWebsocketUrl(this.scheme, req.headers.host, req.url);
-		this.queryGet = Object.fromEntries(this.wsUrl.searchParams.entries());
-		this.queryRequest = { ...this.queryGet };
+		this.query = Object.fromEntries(this.wsUrl.searchParams.entries());
 		this.wsPath = this.wsUrl.pathname + this.wsUrl.search;
 		this.url = url.format(this.wsUrl);
-		this.port = parseInt(this.wsUrl.port, 10) || (type === "websocket-secure" ? 443 : 80);
+		this.port = parseInt(this.wsUrl.port, 10) || (serverType === "wss" ? 443 : 80);
 		this.request.url = this.wsUrl;
-		this.request.queryGet = this.queryGet;
-		this.request.query = this.queryRequest;
+		this.request.query = this.query;
 		this.request.path = this.wsPath;
 		try {
 			this.originUrl = new URL(this.origin);
@@ -125,22 +174,51 @@ 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 {
 			return;
 		}
 	}
+	/**
+	* Rattache la socket que le handshake vient d'ouvrir (`101` envoyé) : le
+	* contexte a été construit et jugé AVANT, sans elle.
+	*
+	* @param ws - la socket acceptée
+	*/
+	acceptConnection(ws) {
+		this.admission = null;
+		this.connection = ws;
+		this.response?.setConnection(ws);
+	}
+	/**
+	* Refuse le handshake par un statut HTTP, avant tout `101` (RFC 6455
+	* §4.2.2) — avec les en-têtes posés pendant la décision (`WWW-Authenticate`
+	* du pare-feu, `Retry-After`).
+	*
+	* @param status - statut HTTP du refus
+	* @returns `false` si le verdict était déjà rendu (rien n'est écrit)
+	*/
+	refuseHandshake(status) {
+		const admission = this.admission;
+		if (admission === null) return false;
+		this.admission = null;
+		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() {
 		if (!this.response || !this.request || !this.connection) throw new Error("Nodefony Websocket Bad request/response/connection");
 		if (this.rejected) throw new Error("Nodefony Websocket rejected");
@@ -152,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;
 	}
@@ -261,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,
@@ -274,7 +354,7 @@ var WebsocketContext = class extends Context {
 			security: this.security ?? null,
 			securityTrace: this.securityTrace,
 			timing: this.timingEnabled,
-			queries: this.profiling
+			queries: profiled
 		});
 	}
 	/**
@@ -282,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);
 	}
 	/**
@@ -337,12 +417,12 @@ var WebsocketContext = class extends Context {
 	}
 	onClose(code, reason) {
 		const description = reason.toString();
-		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("Description")} : ${description}`, "INFO", `${this.type} ${logColor.magenta(code)} CLOSE ${this.method}`);
+		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("Description")} : ${description}`, "INFO", `${this.serverType} ${logColor.magenta(code)} CLOSE ${this.method}`);
 		if (this.connection?.readyState !== Ws.CLOSED) {
 			try {
 				this.response?.drop(code, description);
 			} catch (e) {
-				this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${e.message}`, "ERROR", `${this.type} CLOSE ${logColor.red(this.method ?? "")}`);
+				this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${e.message}`, "ERROR", `${this.serverType} CLOSE ${logColor.red(this.method ?? "")}`);
 			}
 			this.fire("onClose", code, description, this.connection);
 		} else this.fire("onClose", code, description, this.connection);
@@ -359,7 +439,7 @@ var WebsocketContext = class extends Context {
 	*/
 	onConnectionError(error) {
 		this.webSocketState = "error";
-		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${error.message}`, "ERROR", `${this.type} ${logColor.red("SOCKET ERROR")} ${this.method}`);
+		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${error.message}`, "ERROR", `${this.serverType} ${logColor.red("SOCKET ERROR")} ${this.method}`);
 		this.fire("onError", error, this);
 	}
 	setScheme() {
@@ -417,5 +497,4 @@ var WebsocketContext = class extends Context {
 		this.rejected = true;
 	}
 };
-//#endregion
-export { WebsocketContext as default, toWsCloseCode };
+export { WebsocketContext as default, handshakeRefusalStatus, toHandshakeStatus, toWsCloseCode };

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

@@ -0,0 +1,17 @@
+// nodefony/src/context/websocket/isWebsocketContext.ts
+/**
+* Dit si un contexte sert une connexion WebSocket — la garde qui rétrécit
+* `ContextType` à `WebsocketContext` sans conversion.
+*
+* Elle lit la famille (`type`) posée à la construction du contexte, jamais
+* `instanceof` : deux copies installées de `@nodefony/http` font échouer
+* `instanceof` en silence, quand ce champ dit vrai pour les deux. Deux
+* Une comparaison de chaînes, aucune allocation.
+*
+* @param context - le contexte à éprouver.
+* @returns `true` si le contexte traite une connexion WebSocket (`ws` ou `wss`).
+*/
+function isWebsocketContext(context) {
+	return context.type === "websocket";
+}
+export { isWebsocketContext };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/websocket/websocketUrl.ts
+// nodefony/src/context/websocket/websocketUrl.ts
 /**
 * URL d'une requête d'upgrade WebSocket, telle que le pipeline la lit.
 *
@@ -17,5 +17,4 @@
 function parseWebsocketUrl(scheme, host, rawUrl) {
 	return new URL(`${scheme}://${host ?? "localhost"}${rawUrl ?? "/"}`);
 }
-//#endregion
 export { parseWebsocketUrl };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/websocket/wsBackpressure.ts
+// nodefony/src/context/websocket/wsBackpressure.ts
 /**
 * Relit le seuil + la politique depuis les options du `WebSocketServer`.
 *
@@ -52,5 +52,4 @@ const decideSend = (ws, max, policy, closeAfterDrops = 0) => {
 	}
 	return "drop";
 };
-//#endregion
 export { decideSend, readBackpressureOptions };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/websocket/wsCloseReason.ts
+// nodefony/src/context/websocket/wsCloseReason.ts
 /**
 * Taille maximale, en octets UTF-8, de la raison d'une trame Close (RFC 6455
 * §5.5 : charge d'une trame de contrôle ≤ 125 octets, dont 2 pour le code).
@@ -37,5 +37,4 @@ function toWsCloseReason(reason) {
 	}
 	return reason.slice(0, end) + ELLIPSIS;
 }
-//#endregion
 export { MAX_WS_CLOSE_REASON_BYTES, toWsCloseReason };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/websocket/wsLogContent.ts
+// nodefony/src/context/websocket/wsLogContent.ts
 /**
 * Formatage **pur** (0 état, 0 dépendance) du CONTENU d'un message WebSocket pour
 * le log de trace (Suivi de requête Studio). Séparé de `WebsocketContext` pour
@@ -64,5 +64,4 @@ function formatWsLogContent(data, cap = WS_LOG_CONTENT_CAP) {
 	if (typeof s !== "string") return String(data);
 	return s.length > cap ? `${s.slice(0, cap)}…` : s;
 }
-//#endregion
 export { WS_LOG_CONTENT_CAP, binaryByteLength, formatWsLogContent };

package/dist/nodefony/src/cookies/cookie.js

@@ -2,7 +2,7 @@ import { extend } from "nodefony";
 import crypto from "node:crypto";
 import { parseCookie } from "cookie";
 import MS from "ms";
-//#region nodefony/src/cookies/cookie.ts
+// nodefony/src/cookies/cookie.ts
 const encode = encodeURIComponent;
 const decode = decodeURIComponent;
 const cookieDefaultSettings = {
@@ -20,11 +20,9 @@ function parser(strToParse) {
 }
 function cookiesParser(context) {
 	let cookies = null;
-	let co = null;
+	let co;
 	switch (context.type) {
 		case "http":
-		case "https":
-		case "http2":
 			if (context.request.request.headers.cookie) cookies = context.request.request.headers.cookie;
 			if (cookies) {
 				const obj = parser(cookies);
@@ -35,8 +33,7 @@ function cookiesParser(context) {
 				if (context.response) context.request.request.cookies = context.response.cookies;
 			}
 			break;
-		case "websocket":
-		case "websocket-secure": {
+		case "websocket": {
 			const cookieHeader = context.request?.headers.cookie;
 			if (cookieHeader) {
 				const parsed = parser(cookieHeader);
@@ -254,5 +251,4 @@ var Cookie = class Cookie {
 		return obj;
 	}
 };
-//#endregion
 export { cookiesParser, Cookie as default, parser };

package/dist/nodefony/src/errors/httpError.js

@@ -1,5 +1,5 @@
 import { clc, nodefonyError } from "nodefony";
-//#region nodefony/src/errors/httpError.ts
+// nodefony/src/errors/httpError.ts
 const exclude = {
 	context: true,
 	resolver: true,
@@ -65,5 +65,4 @@ var HttpError = class extends nodefonyError {
 	}
 };
 Object.defineProperty(HttpError.prototype, "toJSON", jsonHttpError);
-//#endregion
 export { HttpError as default };

package/dist/nodefony/src/errors/thrownMessage.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/errors/thrownMessage.ts
+// nodefony/src/errors/thrownMessage.ts
 /**
 * Message lisible d'une valeur LEVÉE (`catch`, rejet) dont on ignore le type.
 *
@@ -23,5 +23,4 @@ function thrownMessage(value) {
 		case "function": return value === null ? "null" : Object.prototype.toString.call(value);
 	}
 }
-//#endregion
 export { thrownMessage };

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

@@ -1,5 +1,5 @@
 import { thrownMessage } from "../errors/thrownMessage.js";
-//#region nodefony/src/profiler/FrameProfile.ts
+// nodefony/src/profiler/FrameProfile.ts
 /**
 * Profil d'**une invocation** du pont RPC (une frame `api.request`), et non de
 * la connexion qui la porte.
@@ -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,9 +109,9 @@ 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) };
 	}
 };
-//#endregion
 export { FrameProfile, FrameProfile as default };

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

@@ -1,24 +1,47 @@
-//#region nodefony/src/profiler/Profiler.ts
-/** Durée totale = (fin de la dernière phase terminée) − (début de la 1ère). */
-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;
-	for (const p of phases) {
-		const e = p.startMs + (p.durationMs ?? 0);
-		if (e > end) end = e;
-	}
-	const d = end - first.startMs;
-	return d >= 0 ? Math.round(d * 1e3) / 1e3 : null;
+import { profileLane } from "./aggregate.js";
+import { frameIndexOf } from "nodefony";
+// nodefony/src/profiler/Profiler.ts
+/** 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;
+/**
+* Capacité par défaut des deux anneaux annexes : l'OUTILLAGE (console, API
+* d'administration, porte MCP) et les ASSETS relayés de Vite. Un chargement
+* de la console relaie à lui seul quelques centaines de modules : dans un
+* tampon commun, il chassait en quelques secondes les profils de
+* l'application, puis ceux des appels de la console elle-même.
+*/
+const DEFAULT_SIDE_CAP = 100;
+/**
+* Collecteur des profils de requête, en un anneau par provenance
+* ({@link profileLane}) : l'application, l'outillage, les assets relayés.
+* Chacun évince ses propres profils — ouvrir la console ne chasse plus celui
+* qu'on y consulte.
+*/
 var Profiler = class {
-	_buf = /* @__PURE__ */ new Map();
-	_cap;
-	constructor(cap = DEFAULT_CAP) {
-		this._cap = cap > 0 ? cap : DEFAULT_CAP;
+	_lanes = {
+		app: /* @__PURE__ */ new Map(),
+		tooling: /* @__PURE__ */ new Map(),
+		asset: /* @__PURE__ */ new Map()
+	};
+	_caps;
+	/** Dernier numéro d'ordre attribué (0 = aucun profil collecté). */
+	_seq = 0;
+	/**
+	* @param cap - capacité de l'anneau de l'application.
+	* @param sideCap - capacité de chacun des anneaux de l'outillage et des
+	*          assets relayés.
+	*/
+	constructor(cap = DEFAULT_CAP, sideCap = DEFAULT_SIDE_CAP) {
+		const side = sideCap > 0 ? sideCap : DEFAULT_SIDE_CAP;
+		this._caps = {
+			app: cap > 0 ? cap : DEFAULT_CAP,
+			tooling: side,
+			asset: side
+		};
 	}
 	/**
 	* Snapshot un `Context` en fin de requête. Tolérant aux champs absents
@@ -32,13 +55,14 @@ var Profiler = class {
 		const phases = ctx.phases ?? [];
 		const entry = {
 			requestId,
+			seq: ++this._seq,
 			ts: Date.now(),
-			kind: ctx.type === "websocket" || ctx.type === "websocket-secure" ? "ws" : "http",
+			kind: ctx.type === "websocket" ? "ws" : "http",
 			method: ctx.method ?? null,
 			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,
@@ -54,25 +78,36 @@ var Profiler = class {
 			queries: ctx.profilerQueries && ctx.profilerQueries.length > 0 ? ctx.profilerQueries : void 0,
 			security: readSecurity(ctx)
 		};
-		this._buf.delete(requestId);
-		this._buf.set(requestId, entry);
-		if (this._buf.size > this._cap) {
-			const oldest = this._buf.keys().next().value;
-			if (oldest !== void 0) this._buf.delete(oldest);
+		const { app, tooling, asset } = this._lanes;
+		app.delete(requestId);
+		tooling.delete(requestId);
+		asset.delete(requestId);
+		const lane = profileLane(entry.url);
+		const buf = this._lanes[lane];
+		buf.set(requestId, entry);
+		if (buf.size > this._caps[lane]) {
+			const oldest = buf.keys().next().value;
+			if (oldest !== void 0) buf.delete(oldest);
 		}
 	}
 	/** Profil complet d'une requête, ou `undefined` si évincé/inconnu. */
 	get(requestId) {
-		return this._buf.get(requestId);
+		const { app, tooling, asset } = this._lanes;
+		return app.get(requestId) ?? tooling.get(requestId) ?? asset.get(requestId);
 	}
 	/**
 	* 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._buf.values()];
-		for (const e of entries.reverse()) {
+		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,
@@ -87,13 +122,51 @@ var Profiler = class {
 		}
 		return out;
 	}
+	/** Dernier numéro d'ordre attribué : le point de départ d'une lecture suivie. */
+	get cursor() {
+		return this._seq;
+	}
+	/**
+	* Profils collectés après `cursor`, tous anneaux confondus, dans l'ordre
+	* des numéros.
+	*
+	* Les pertes se comptent sans estimation : chaque numéro attribué est un
+	* profil collecté, donc ce qui manque entre le curseur et le dernier numéro
+	* a disparu avant d'être lu. Un curseur venu d'ailleurs (supérieur au
+	* dernier numéro) repart de zéro.
+	*
+	* @param cursor - le `cursor` rendu par l'appel précédent, ou {@link cursor}.
+	*/
+	since(cursor) {
+		const from = cursor >= 0 && cursor <= this._seq ? cursor : 0;
+		const entries = this.#collectAfter(from);
+		return {
+			entries,
+			cursor: this._seq,
+			lost: this._seq - from - entries.length
+		};
+	}
 	/** Nombre de profils en mémoire. */
 	get size() {
-		return this._buf.size;
+		const { app, tooling, asset } = this._lanes;
+		return app.size + tooling.size + asset.size;
 	}
-	/** Vide le ring buffer. */
+	/** Vide les anneaux. */
 	clear() {
-		this._buf.clear();
+		const { app, tooling, asset } = this._lanes;
+		app.clear();
+		tooling.clear();
+		asset.clear();
+	}
+	/**
+	* Profils de numéro supérieur à `from`, tous anneaux confondus, du plus
+	* ancien au plus récent. Lecture à la demande (console, outil de l'agent) :
+	* jamais sur le chemin d'une requête.
+	*/
+	#collectAfter(from) {
+		const out = [];
+		for (const lane of Object.values(this._lanes)) for (const e of lane.values()) if (e.seq > from) out.push(e);
+		return out.sort((a, b) => a.seq - b.seq);
 	}
 };
 /**
@@ -131,5 +204,4 @@ function readSecurity(ctx) {
 function readUser(ctx) {
 	return ctx.userIdentifier ?? ctx.securityTrace?.user ?? null;
 }
-//#endregion
 export { Profiler, Profiler as default };