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

package/dist/types/nodefony/service/http-kernel.d.ts

@@ -134,6 +134,8 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     private errorRenderer;
     private requestLogger;
     private profiler;
+    /** `timing.tooling` : profiler aussi l'outillage (lu une fois, à onReady). */
+    private profileTooling;
     private _trustProxyChecker;
     private _wsOriginPolicy;
     private rateLimiter;
@@ -186,6 +188,32 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * tel quel plutôt que d'inventer un état.
      */
     get rateLimitStore(): IRateLimitStore | null;
+    /**
+     * Cette requête — ou cette frame du pont — se profile-t-elle ? Jamais sans
+     * profileur (production). L'outillage (console, profileur, journaux, Vite :
+     * `isProfiledUrl`, sur la règle `isConsolePath` du cœur) seulement sous
+     * `timing.tooling` — on ne
+     * mesure pas la façon dont on mesure : ni tampon SQL, ni instantané, ni place
+     * dans les anneaux du profileur.
+     *
+     * @param url - URL ou chemin de la requête
+     * @returns `true` quand le profil doit être pris
+     */
+    shouldProfile(url: string): boolean;
+    /**
+     * En développement, signale une action qui a rendu une valeur que le
+     * Resolver ne sait pas envoyer (`null`, `undefined`, instance de classe)
+     * et n'a rien envoyé elle-même : la requête attend son délai d'expiration.
+     * Le message nomme l'action, ce qu'elle a rendu et le geste qui convient
+     * (`unsentResponseWarning`).
+     *
+     * Appelé au timeout, AVANT que le 504/408 parte — après, `sended` est vrai et
+     * plus rien ne se signalerait — et au démontage, pour un client parti avant.
+     * Gratuit en production : rien n'est lu au-delà de `waitAsync`.
+     *
+     * @param context - le contexte HTTP de la requête
+     */
+    warnUnsentResponse(context: HttpContext): void;
     private configureRateLimit;
     /**
      * (Re)configure le backstop OPT-IN de connexions WS concurrentes par IP (F6c)
@@ -474,6 +502,18 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @returns le contexte servi, ou sa promesse.
      */
     handleHttp(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): MaybePromise<HttpContext>;
+    /**
+     * Sert un contexte HTTP fraîchement créé : le crochet `onCreateContext`
+     * s'il a des écouteurs, puis le pipeline.
+     *
+     * Hot path : `fireAsync` est une fonction async → 1 Promise + 1 microtask
+     * MÊME à 0 listener. En prod sans @nodefony/security ces seams
+     * (onCreateContext/beforeResolve/afterAuth) n'ont aucun listener → garde
+     * `listenerCount` (O(1), 0 alloc) pour ne RIEN planifier.
+     *
+     * @returns le contexte servi, ou sa promesse
+     */
+    private dispatchHttpContext;
     /**
      * Traceparent, tampon du profileur, puis le pipeline dans la bulle ALS de la
      * requête (`RequestContext.run`).
@@ -578,6 +618,16 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @returns ce que rend l'action de handshake
      */
     handleWebsocket(scope: Scope, req: IncomingMessage, admission: IUpgradeAdmission, type: ServerType): Promise<unknown>;
+    /**
+     * Fin du canal `nodefony.http.request` pour un handshake interrompu par une
+     * exception — sans effet si un refus l'a déjà publiée (`refuseHandshake`).
+     * Le statut est un fait, pas une déduction : une socket rattachée dit que
+     * le `101` est parti ; sinon c'est le `500` du filet qui a été rendu.
+     *
+     * @param context - le contexte du handshake, `null` s'il n'a pu être construit
+     * @param error - l'exception qui a interrompu le pipeline
+     */
+    private closeFailedWebsocketTrace;
     private releaseOrphanWsScope;
     /**
      * Juge un handshake WebSocket AVANT son acceptation : hôte, origine,

package/dist/types/nodefony/src/context/Context.d.ts

@@ -97,6 +97,12 @@ declare class Context extends Service implements IContextInterface {
     crossDomain: boolean;
     router: IRequestRouter | null;
     resolver: IRouteResolver | null;
+    /**
+     * Module qui signe les lignes de CETTE requête : la ligne d'accès et les
+     * lignes du contrôleur. `null` = le module de la route (sans route : le
+     * journal du noyau). Un contrôleur le change : `this.context.logModule = "billing"`.
+     */
+    logModule: string | null;
     /**
      * Intent de session de la route courante (posé par le Resolver depuis
      * `@UseSession` / paramètre `@Session`). Pilote le point d'activation unique
@@ -128,6 +134,9 @@ declare class Context extends Service implements IContextInterface {
     securityTrace: ISecurityTrace | null;
     private readonly _timingEnabled;
     private readonly _timingVerbose;
+    private readonly _clockEnabled;
+    private readonly _clockStartMs;
+    private _durationMs;
     readonly phases: PhaseTiming[];
     private _phaseIndex;
     private _afterResponseFns;
@@ -161,6 +170,21 @@ declare class Context extends Service implements IContextInterface {
     get timingEnabled(): boolean;
     phaseStart(name: PhaseName): void;
     phaseEnd(name: PhaseName): void;
+    /**
+     * Arrête l'horloge de la requête et rend sa durée, en millisecondes.
+     *
+     * La durée court de la construction du contexte au PREMIER appel : le
+     * démontage HTTP (`close` de la réponse, dernier octet remis — la mesure
+     * d'OpenTelemetry et du `$request_time` de nginx), la ligne d'accès pour un
+     * handshake WebSocket. Les appels suivants rendent la même valeur : journal
+     * d'accès, profiler et trace verbose lisent UNE durée, jamais trois.
+     *
+     * Active par défaut dans tous les environnements, production comprise :
+     * seul `timing.enabled: false` la coupe (cf `resolveTimingMode`).
+     *
+     * @returns la durée, ou `null` si `timing.enabled` vaut `false`
+     */
+    stopClock(): number | null;
     onAfterResponse(fn: AfterResponseHandler): void;
     /**
      * Exécute les hooks `onAfterResponse`, une seule fois, dans l'ordre
@@ -176,7 +200,7 @@ declare class Context extends Service implements IContextInterface {
     private runAfterResponseHooks;
     get signal(): AbortSignal;
     _abortIfPending(reason?: string): void;
-    log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;
+    log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message, moduleName?: string): Pdu;
     /**
      * Confie au contexte le magasin `RequestContext` de son unité de travail
      * (requête HTTP, connexion WebSocket), pour qu'il le VIDE à son nettoyage.

package/dist/types/nodefony/src/context/http/HttpContext.d.ts

@@ -1,6 +1,7 @@
 import { ServerType, SchemeType } from "../../../service/http-kernel.js";
+import HttpError from "../../errors/httpError.js";
 import Context, { HTTPMethod } from "../Context.js";
-import { Container, Scope } from "nodefony";
+import { Container, Scope, nodefonyError } from "nodefony";
 import type { MaybePromise } from "nodefony";
 import HttpRequest from "./Request.js";
 import HttpResponse from "./Response.js";
@@ -50,6 +51,11 @@ declare class HttpContext extends Context implements IHttpContextInterface {
     private activeSocket;
     isRedirect: boolean;
     sended: boolean;
+    /**
+     * Requête relayée par le proxy inverse : la politique de ligne d'accès de
+     * son montage. `null` = servie par l'application (cas de toute requête).
+     */
+    relayAccessLog: "all" | "errors" | null;
     request: HttpRequestType;
     response: HttpRsponseType;
     uploadService: uploadService | null;
@@ -84,6 +90,14 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      */
     handle(): MaybePromise<this>;
     setTimeout(): void;
+    /**
+     * Ligne d'accès — pour une requête RELAYÉE, avec le statut que l'amont a
+     * réellement rendu (le relais écrit la réponse brute, pas celle du
+     * contexte) ; un montage `accessLog: "errors"` ne l'écrit qu'en échec.
+     *
+     * @param httpError - l'erreur de la requête, s'il y en a une
+     */
+    logRequest(httpError?: Error | HttpError | nodefonyError | null): import("nodefony").Pdu | undefined;
     /**
      * Nettoie le contexte, et le DÉTACHE de sa socket h1 : la connexion
      * persistante survit à la requête, et l'entrée de `socketActiveContext`

package/dist/types/nodefony/src/context/http2/Response.d.ts

@@ -51,6 +51,18 @@ declare class Http2Response extends HttpResponse {
      * @throws de façon SYNCHRONE ce que lève la fin du flux.
      */
     end(chunk?: string | Buffer, encoding?: BufferEncoding): MaybePromise<http.ServerResponse | http2.ServerHttp2Stream>;
+    /**
+     * Termine la réponse de compatibilité d'un HEAD, dont Node a clos le flux de
+     * lui-même au `respond()`.
+     *
+     * Sans ce geste, `Http2ServerResponse` n'émet ni `finish` ni `close` : le
+     * démontage de la requête, branché sur ce `close` (ligne d'accès, profil,
+     * hooks d'après-réponse, libération du scope DI), n'a jamais lieu. Les statuts
+     * que Node termine aussi d'office (204, 205, 304) émettent leur `close` seuls,
+     * et un flux détruit (client parti) aussi : ils ne sont pas touchés. Hors du
+     * chemin servi — appelé seulement quand le flux est déjà clos.
+     */
+    private settleHeadResponse;
     getStatusMessage(code?: number | string): string;
     getStatus(): {
         code: number;

package/dist/types/nodefony/src/context/requestTrace.d.ts

@@ -0,0 +1,64 @@
+import type { IRequestTrace, RequestTraceProtocol } from "../../interfaces/IRequestTrace.js";
+import type Context from "./Context.js";
+/**
+ * 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`.
+ */
+export declare const REQUEST_TRACE_CHANNEL = "nodefony.http.request";
+/**
+ * Le message tel que Nodefony le remplit au fil de la requête : la vue
+ * modifiable d'{@link IRequestTrace}, qui reste en lecture seule pour
+ * l'abonné.
+ */
+export type RequestTraceRecord = {
+    -readonly [K in keyof IRequestTrace]: IRequestTrace[K];
+};
+/**
+ * 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é
+ */
+export declare function hasRequestTraceSubscribers(): boolean;
+/**
+ * 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`
+ */
+export declare function openRequestTrace(context: Context, protocol: RequestTraceProtocol): RequestTraceRecord;
+/**
+ * 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
+ */
+export declare function runTraced<ThisArg, Args extends unknown[], Result>(trace: RequestTraceRecord, fn: (this: ThisArg, ...args: Args) => Result, thisArg: ThisArg, ...args: Args): Result;
+/**
+ * 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
+ */
+export declare function closeRequestTrace(context: Context, statusCode: number | null, error: unknown): void;

package/dist/types/nodefony/src/context/timingMode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Ce que le chronométrage mesure sur une requête :
+ *
+ * - `"off"` — rien : ni horloge, ni phases ; la ligne d'accès sort sans durée ;
+ * - `"clock"` — la durée seule : une lecture d'horloge à l'entrée, une à la fin ;
+ * - `"phases"` — la durée ET le détail par phase (resolve, firewall, action…).
+ */
+export type TimingMode = "off" | "clock" | "phases";
+/**
+ * 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é
+ */
+export declare function resolveTimingMode(enabled: unknown, environment: string | undefined): TimingMode;

package/dist/types/nodefony/src/context/unsentResponse.d.ts

@@ -0,0 +1,16 @@
+import type { IRouteResolver } from "../../interfaces/IRouting.js";
+/**
+ * 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.
+ */
+export declare function unsentResponseWarning(resolver: IRouteResolver | null | undefined, url: string): string;

package/dist/types/nodefony/src/context/websocket/WebsocketContext.d.ts

@@ -87,7 +87,7 @@ declare class WebsocketContext extends Context implements IWebsocketContextInter
     query: Record<string, string>;
     wsPath: string;
     constructor(scope: Scope, req: IncomingMessage, ws: Ws | null, serverType: ServerType);
-    log(pci: unknown, severity?: Severity, msgid?: Msgid, msg?: Message): import("nodefony").Pdu;
+    log(pci: unknown, severity?: Severity, msgid?: Msgid, msg?: Message, moduleName?: string): import("nodefony").Pdu;
     logRequest(httpError?: Error | HttpError | nodefonyError | null, acceptedProtocol?: string | null): import("nodefony").Pdu | undefined;
     /**
      * Rattache la socket que le handshake vient d'ouvrir (`101` envoyé) : le

package/dist/types/nodefony/src/profiler/FrameProfile.d.ts

@@ -80,6 +80,12 @@ export declare class FrameProfile {
      * invocation, il redevient exact, et le SQL se replace dans le waterfall.
      */
     readonly profilerQueries: IProfilerQuery[] | null;
+    /**
+     * 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(): boolean;
     /** Resolver de la frame — porte route / controller / action. */
     resolver: ProfiledResolver | null;
     /** Statut HTTP-équivalent de l'invocation (200, 403, 404…). */
@@ -90,7 +96,16 @@ export declare class FrameProfile {
         message: string;
     } | null;
     private readonly timing;
+    private readonly clockStartMs;
+    private durationMs;
     constructor(init: FrameProfileInit);
+    /**
+     * 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(): number | null;
     /**
      * 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

package/dist/types/nodefony/src/profiler/Profiler.d.ts

@@ -20,106 +20,12 @@
  */
 import type { ProfiledResolver } from "./FrameProfile.js";
 import type { ProtocolName } from "../../interfaces/IContext.js";
-/** Une phase du pipeline, projetée pour le transport (durée résolue). */
-export interface ProfilePhase {
-    name: string;
-    /** Début relatif `performance.now()` (ms) — sert au calcul du waterfall. */
-    startMs: number;
-    /** Durée en ms, `null` si la phase ne s'est pas terminée (erreur). */
-    durationMs: number | null;
-}
-/**
- * Une requête SQL/NoSQL exécutée pendant la requête HTTP (SEAM ORM — futur).
- *
- * Non collecté aujourd'hui : quand `@nodefony/orm-core` arrivera, les adapters
- * pousseront leurs requêtes dans un buffer per-request dev-only (via l'ALS
- * `RequestContext.getRequestId()`, déjà en place) que `collect()` lira ici.
- * Le champ `queries` reste donc `undefined` tant qu'aucun ORM ne pushe → 0 coût.
- */
-export interface ProfileQuery {
-    /** Requête (SQL ou commande NoSQL), tronquée si volumineuse. */
-    sql: string;
-    /** Début relatif (`performance.now()`) — même horloge que les phases. */
-    startMs?: number | undefined;
-    /** Durée d'exécution en ms. */
-    durationMs: number;
-    /** Lignes affectées/retournées, si connu. */
-    rows?: number | undefined;
-    /** Connecteur émetteur (`drizzle`, `mongoose`…). */
-    connector?: string | undefined;
-}
-/**
- * Traversée du firewall par cette requête — **ce qui était possible** (la zone :
- * son nom, si elle est protégée, quels authenticators elle accepte) croisé avec
- * **ce qui s'est passé** (quel maillon a résolu l'identité, l'issue, le motif
- * d'un refus).
- *
- * Sans cela, une requête qui PASSE est invisible côté sécurité : le chemin de
- * succès n'émet aucun événement d'audit (choix délibéré — le volume nominal
- * n'est pas un signal). `undefined` hors zone firewall.
- */
-export interface ProfileSecurity {
-    /** Nom de la zone traversée. */
-    zone: string | null;
-    /** La zone exige-t-elle une identité (`security: true`) ? */
-    protected: boolean;
-    /** Chaîne d'authenticators : `first` = le premier qui supporte, `all` = MFA. */
-    mode: string | null;
-    /** Authenticators que la zone accepte (ce qui était POSSIBLE). */
-    candidates: string[];
-    /** Authenticator qui a RÉELLEMENT résolu l'identité. */
-    authenticator: string | null;
-    /** `granted` · `anonymous` · `denied` · `failure` · `throttled` · `bypass` · `public`. */
-    outcome: string | null;
-    /** Motif du refus (`no_credentials`, `invalid_credentials`…). */
-    reason: string | null;
-    /** Rôles du token résolu (l'axe autorisation). */
-    roles: string[] | null;
-}
-/** Profil complet d'une requête (HTTP ou message WS), exposé par `get`. */
-export interface ProfileEntry {
-    requestId: string;
-    /**
-     * Numéro d'ordre de collecte, croissant sur la vie du profileur. Un profil
-     * réinséré (identifiant réutilisé) reçoit un numéro neuf.
-     */
-    seq: number;
-    /** Horodatage de la collecte (`Date.now()`), pour le tri client. */
-    ts: number;
-    kind: "http" | "ws";
-    method: string | null;
-    url: string;
-    scheme: string;
-    status: number | null;
-    /** Durée totale serveur (ms), dérivée des phases. */
-    durationMs: number | null;
-    route: string | null;
-    controller: string | null;
-    action: string | null;
-    remoteAddress: string | null;
-    /** Identité (username) si le firewall l'a injectée, sinon `null`. */
-    user: string | null;
-    /** `traceparent` W3C Trace Context (P2.7) — corrélation distribuée RFC-propre. */
-    traceparent: string | null;
-    error: string | null;
-    phases: ProfilePhase[];
-    /** Requêtes ORM (SEAM futur — `undefined` tant qu'aucun adapter ne pushe). */
-    queries?: ProfileQuery[] | undefined;
-    /** Traversée du firewall — `undefined` si la requête n'a croisé aucune zone. */
-    security?: ProfileSecurity | undefined;
-}
-/** Résumé léger d'un profil pour la liste `recent` (sans les phases). */
-export interface ProfileSummary {
-    requestId: string;
-    ts: number;
-    kind: "http" | "ws";
-    method: string | null;
-    url: string;
-    status: number | null;
-    durationMs: number | null;
-    route: string | null;
-    error: string | null;
-}
+import type { IProfileEntry, IProfilePhase, IProfileQuery, IProfileSecurity, IProfileSummary } from "nodefony";
+export type ProfilePhase = IProfilePhase;
+export type ProfileQuery = IProfileQuery;
+export type ProfileSecurity = IProfileSecurity;
+export type ProfileEntry = IProfileEntry;
+export type ProfileSummary = IProfileSummary;
 /** Forme structurelle minimale lue sur un `Context` (lecture défensive). */
 interface ProfilableContext {
     requestId?: string | undefined;
@@ -142,6 +48,11 @@ interface ProfilableContext {
         durationMs?: number | undefined;
     }> | undefined;
     resolver?: ProfiledResolver | null | undefined;
+    /**
+     * Arrête l'horloge de la requête et rend sa durée (ms) — la même que le
+     * journal d'accès (`IContext.stopClock`). `null` si `timing.enabled` vaut `false`.
+     */
+    stopClock(): number | null;
     /**
      * Buffer de requêtes ORM rempli pendant la requête (dev-only). Même tableau
      * que la payload ALS — les adapters ORM y poussent via `RequestContext`.
@@ -222,8 +133,12 @@ export declare class Profiler implements IProfilerReader {
     get(requestId: string): ProfileEntry | undefined;
     /**
      * 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?: number): ProfileSummary[];
+    recent(limit?: number, connection?: string): ProfileSummary[];
     /** Dernier numéro d'ordre attribué : le point de départ d'une lecture suivie. */
     get cursor(): number;
     /**

package/dist/types/nodefony/src/profiler/aggregate.d.ts

@@ -1,4 +1,6 @@
 import type { ProfileEntry } from "./Profiler.js";
+import type { IStatusBreakdown, IPhaseTotal, IRouteStats, INPlusOne, ISqlShapeStats, IErrorSample, IProfileReport } from "nodefony";
+export type { IStatusBreakdown, IPhaseTotal, IRouteStats, INPlusOne, ISqlShapeStats, IErrorSample, IProfileReport, };
 /**
  * Agrégation des profils de requêtes — règle PURE, sans horloge ni I/O.
  *
@@ -21,7 +23,14 @@ export declare const ROUTE_SAMPLE_CAP = 256;
 export declare const SQL_SHAPE_CAP = 200;
 /** Exemples d'erreurs retenus (statut ≥ 500 ou exception). */
 export declare 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.
+ */
 export declare const TOOLING_URL_PREFIX = "/nodefony/";
 /**
  * Provenance d'un profil : l'application, l'outillage (`/nodefony/…` :
@@ -30,8 +39,10 @@ export declare const TOOLING_URL_PREFIX = "/nodefony/";
  */
 export type ProfileLane = "app" | "tooling" | "asset";
 /**
- * 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.
@@ -44,113 +55,19 @@ export declare function profileLane(url: string): ProfileLane;
  * @param url - URL du profil, absolue ou chemin.
  */
 export declare function isToolingUrl(url: string): boolean;
+/**
+ * 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
+ */
+export declare function isProfiledUrl(url: string, tooling: boolean): boolean;
 /** Groupe des requêtes qu'aucune route n'a servies (404, statique, sondes). */
 export declare const NO_ROUTE = "(aucune route)";
 /** Pseudo-phase : le temps de l'action hors phases imbriquées et hors SQL. */
 export declare const ACTION_SELF_PHASE = "action.self";
-/** Répartition des statuts HTTP d'une route. */
-export interface IStatusBreakdown {
-    s2xx: number;
-    s3xx: number;
-    s4xx: number;
-    s5xx: number;
-    /** Dont 401 : la route exige une authentification que la requête n'avait pas. */
-    unauthorized: number;
-    /** Dont 403 : authentifiée, mais refusée. */
-    forbidden: number;
-}
-/** Temps cumulé d'une phase sur les requêtes d'une route. */
-export interface IPhaseTotal {
-    totalMs: number;
-    /** Requêtes où la phase est apparue et s'est terminée. */
-    count: number;
-}
-/** Statistiques d'une route sur la fenêtre agrégée. */
-export interface IRouteStats {
-    route: string;
-    kind: "http" | "ws";
-    controller: string | null;
-    action: string | null;
-    count: number;
-    /** Requêtes sans durée mesurée (mesure des phases désactivée, erreur précoce). */
-    untimed: number;
-    /**
-     * Requêtes SERVIES et chronométrées (statut < 400, sans exception) : la
-     * population de tout ce qui se dit « par requête » ci-dessous. Refus et
-     * erreurs se lisent dans `status` et `errors`.
-     */
-    served: number;
-    /** Percentiles et maximum, sur les requêtes servies. */
-    p50Ms: number | null;
-    p95Ms: number | null;
-    maxMs: number | null;
-    status: IStatusBreakdown;
-    /** Requêtes en erreur : statut ≥ 500 ou exception levée. */
-    errors: number;
-    /**
-     * Requêtes SQL/NoSQL des requêtes servies : total, maximum dans une
-     * requête, temps CUMULÉ (des requêtes parallèles s'y additionnent).
-     */
-    queries: {
-        total: number;
-        perRequestMax: number;
-        totalMs: number;
-    };
-    /** Temps par phase des requêtes servies, `action.self` compris. */
-    phases: Record<string, IPhaseTotal>;
-}
-/** Un N+1 : la même forme SQL répétée dans une requête. */
-export interface INPlusOne {
-    route: string;
-    controller: string | null;
-    action: string | null;
-    shape: string;
-    /** Plus grand nombre de répétitions vu dans une requête. */
-    maxRepeats: number;
-    /** Requêtes touchées. */
-    requests: number;
-    /** Temps cumulé de ces répétitions. */
-    totalMs: number;
-    /** Une requête touchée, pour aller voir son profil complet. */
-    sampleRequestId: string;
-}
-/** Une forme SQL et son coût sur la fenêtre. */
-export interface ISqlShapeStats {
-    shape: string;
-    connector: string | null;
-    count: number;
-    totalMs: number;
-    maxMs: number;
-    /** Routes qui l'ont émise (au plus cinq). */
-    routes: string[];
-}
-/** Un exemple d'erreur, de quoi la retrouver dans le journal. */
-export interface IErrorSample {
-    route: string;
-    status: number | null;
-    error: string | null;
-    requestId: string;
-}
-/** Le rapport agrégé. */
-export interface IProfileReport {
-    /** Requêtes agrégées (hors outillage filtré). */
-    requests: number;
-    http: number;
-    ws: number;
-    /** Requêtes de l'outillage écartées (`/nodefony/…`, `/_vite/…`). */
-    filteredTooling: number;
-    /** Requêtes sans durée mesurée. */
-    untimed: number;
-    /** Triées par p95 décroissant. */
-    routes: IRouteStats[];
-    /** Triés par temps cumulé décroissant. */
-    nPlusOne: INPlusOne[];
-    /** Les dix formes SQL les plus coûteuses (temps cumulé décroissant). */
-    slowQueries: ISqlShapeStats[];
-    /** Formes SQL distinctes vues au-delà de la capacité, comptées sans détail. */
-    sqlShapesDropped: number;
-    errors: IErrorSample[];
-}
 /** Réglages d'une agrégation. */
 export interface IProfileAggregatorOptions {
     /** Répétitions à partir desquelles une forme SQL est un N+1. */