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

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);
 	}
 };
 /**
@@ -122,18 +205,13 @@ function readSecurity(ctx) {
 /**
 * Identité de la requête.
 *
-* `context.user` n'est PAS la source de vérité en zone firewall : le token
-* résolu vit dans l'ALS (`RequestContext`), qui n'est plus lisible au teardown
-* où `collect()` s'exécute. Sans le repli sur la trace, une requête pleinement
-* authentifiée (rôles compris) s'afficherait « anonyme ».
+* Le jeton résolu vit dans l'ALS, qui n'est plus lisible au teardown où
+* `collect()` s'exécute : le pare-feu pose donc l'identifiant de l'appelant
+* authentifié sur `context.userIdentifier` (même source que le journal
+* d'audit). La trace du pare-feu prend le relais pour l'anonyme d'une zone
+* `anonymous`, qu'elle nomme.
 */
 function readUser(ctx) {
-	const u = ctx.user;
-	if (u && typeof u === "object") {
-		const username = u.username;
-		if (typeof username === "string") return username;
-	}
-	return ctx.securityTrace?.user ?? null;
+	return ctx.userIdentifier ?? ctx.securityTrace?.user ?? null;
 }
-//#endregion
 export { Profiler, Profiler as default };