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

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

@@ -4,7 +4,7 @@ import { toWsCloseReason } from "./wsCloseReason.js";
 import { RequestContext } from "nodefony";
 import http from "node:http";
 import Ws from "ws";
-//#region nodefony/src/context/websocket/Response.ts
+// nodefony/src/context/websocket/Response.ts
 /**
 * Codes d'erreur d'écriture « le client est PARTI » : reload de page, onglet
 * fermé, HMR — la socket TCP est morte côté client pendant qu'une frame était
@@ -71,7 +71,11 @@ var WebsocketResponse = class {
 		const payload = data ?? this.body;
 		if (payload == null) throw new Error("no data");
 		return new Promise((resolve, reject) => {
-			if (!this.connection || this.connection.readyState !== Ws.OPEN) return reject(/* @__PURE__ */ new Error("WebSocket not open"));
+			if (!this.connection || this.connection.readyState === Ws.CONNECTING) return reject(/* @__PURE__ */ new Error("WebSocket not open"));
+			if (this.connection.readyState !== Ws.OPEN) {
+				this.log("WS send: client déjà déconnecté — frame perdue", "DEBUG");
+				return resolve(this);
+			}
 			const { max, policy, closeAfterDrops } = readBackpressureOptions(this.context.server);
 			const decision = decideSend(this.connection, max, policy, closeAfterDrops);
 			if (decision !== "send") {
@@ -122,7 +126,7 @@ var WebsocketResponse = class {
 	setBody(ele, encoding) {
 		if (typeof ele === "string") this.body = Buffer.from(ele, encoding ?? this.encoding);
 		else if (ele instanceof ArrayBuffer || ele instanceof SharedArrayBuffer) this.body = Buffer.from(ele);
-		else if ("buffer" in ele && ele.buffer instanceof ArrayBuffer) this.body = Buffer.from(ele.buffer);
+		else if (ArrayBuffer.isView(ele)) this.body = Buffer.from(ele.buffer, ele.byteOffset, ele.byteLength);
 		return this.body;
 	}
 	drop(reasonCode, description) {
@@ -176,14 +180,38 @@ var WebsocketResponse = class {
 	clean() {
 		this.connection = null;
 		this.body = null;
+		this.handshakeHeaders = null;
 	}
 	setEncoding(encoding) {
 		return this.encoding = encoding;
 	}
-	setHeader() {
+	/**
+	* En-têtes de la réponse au handshake, retenus tant que la socket n'est pas
+	* acceptée : ils ne partent que dans un REFUS (`refuseHandshake`) — le `101`
+	* de `ws` ne les porte pas. `null` tant que personne n'en pose (le cas
+	* nominal : aucune allocation).
+	*/
+	handshakeHeaders = null;
+	/**
+	* Retient un en-tête du handshake (cf {@link handshakeHeaders}) ; sans effet
+	* une fois la socket ouverte, où il n'y a plus de réponse HTTP.
+	*
+	* @param name - nom de l'en-tête
+	* @param value - valeur
+	* @returns toujours `true`
+	*/
+	setHeader(name, value) {
+		if (this.connection !== null) return true;
+		this.handshakeHeaders ??= {};
+		this.handshakeHeaders[name] = typeof value === "object" ? value.join(", ") : value;
 		return true;
 	}
-	setHeaders() {
+	setHeaders(obj) {
+		if (this.connection !== null) return true;
+		for (const name of Object.keys(obj)) {
+			const value = obj[name];
+			if (value !== void 0) this.setHeader(name, value);
+		}
 		return true;
 	}
 	addCookie(cookie) {
@@ -193,5 +221,4 @@ var WebsocketResponse = class {
 	setCookies() {}
 	setCookie(_cookie) {}
 };
-//#endregion
 export { WebsocketResponse as default, isPeerGoneError };

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

@@ -7,10 +7,10 @@ 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 { 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 +54,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 +113,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 +139,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);
@@ -141,6 +189,34 @@ var WebsocketContext = class extends Context {
 			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);
+		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");
@@ -337,12 +413,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 +435,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 +493,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.
@@ -92,5 +92,4 @@ var FrameProfile = class {
 		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,12 +1,20 @@
-//#region nodefony/src/profiler/Profiler.ts
-/** Durée totale = (fin de la dernière phase terminée) − (début de la 1ère). */
+import { profileLane } from "./aggregate.js";
+// 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.startMs + (p.durationMs ?? 0);
+		const e = p.durationMs === void 0 ? now ??= performance.now() : p.startMs + p.durationMs;
 		if (e > end) end = e;
 	}
 	const d = end - first.startMs;
@@ -14,11 +22,41 @@ function totalDuration(phases) {
 }
 /** 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,8 +70,9 @@ 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 ?? "",
@@ -54,24 +93,30 @@ 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`.
 	*/
 	recent(limit = 60) {
 		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;
 			out.push({
 				requestId: e.requestId,
@@ -87,13 +132,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 +214,4 @@ function readSecurity(ctx) {
 function readUser(ctx) {
 	return ctx.userIdentifier ?? ctx.securityTrace?.user ?? null;
 }
-//#endregion
 export { Profiler, Profiler as default };