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

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

@@ -1,3 +1,4 @@
+import type { OutgoingHttpHeaders } from "node:http";
 import Cookie from "../../cookies/cookie.js";
 import { Message, Msgid, Pci, Severity } from "nodefony";
 import WebsocketContext from "./WebsocketContext.js";
@@ -44,8 +45,23 @@ declare class WebsocketResponse {
     };
     clean(): void;
     setEncoding(encoding: BufferEncoding): BufferEncoding;
-    setHeader(): boolean;
-    setHeaders(): boolean;
+    /**
+     * 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: Record<string, string | number> | 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: string, value: number | string | readonly string[]): boolean;
+    setHeaders(obj: OutgoingHttpHeaders): boolean;
     addCookie(cookie: Cookie): void;
     setCookies(): void;
     setCookie(_cookie: Cookie): void;

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

@@ -4,21 +4,21 @@ import { Severity, Msgid, Message, nodefonyError, Scope } from "nodefony";
 import Ws from "ws";
 import type { IncomingMessage } from "node:http";
 import WebsocketResponse from "./Response.js";
+import type { IUpgradeAdmission } from "../../servers/upgradeDispatch.js";
 import { URL } from "node:url";
 import { HTTPMethod } from "../Context.js";
 import HttpError from "../../errors/httpError.js";
 import { FrameProfile } from "../../profiler/FrameProfile.js";
-import type { PhaseName } from "../../../interfaces/IContext.js";
+import type { PhaseName, IWebsocketContext } from "../../../interfaces/IContext.js";
 import { ProxyType } from "../http/HttpContext.js";
 import { type ResolvedProxy } from "../forwarded.js";
 export interface IWsRequestExtension {
     url: URL;
     query: Record<string, string>;
-    queryGet: Record<string, string>;
     path: string;
 }
 export type WsIncomingMessage = IncomingMessage & IWsRequestExtension;
-import type { IWebsocketContext as IWebsocketContextInterface } from "../../../interfaces/IContext.js";
+import type { IWebsocketContext as IWebsocketContextInterface, IWebsocketConnectionState } from "../../../interfaces/IContext.js";
 /**
  * Coerce un code (applicatif / HTTP / WS) en code de fermeture WebSocket VALIDE
  * et conforme RFC 6455 §7.4, en PRÉFÉRANT les codes standard §7.4.1 quand le
@@ -36,7 +36,36 @@ import type { IWebsocketContext as IWebsocketContextInterface } from "../../../i
  * @returns un code de fermeture WS valide.
  */
 export declare function toWsCloseCode(code: number | undefined | null): number;
-export default class WebsocketContext extends Context implements IWebsocketContextInterface {
+/**
+ * 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
+ */
+export declare function toHandshakeStatus(code: number | undefined | null): number;
+/**
+ * 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
+ */
+export declare function handshakeRefusalStatus(context: IWebsocketContext, error: Error): number | null;
+interface WebsocketContext extends IWebsocketConnectionState {
+}
+export { WebsocketContext as default };
+declare class WebsocketContext extends Context implements IWebsocketContextInterface {
     #private;
     request: WsIncomingMessage | null;
     response: WebsocketResponse | null;
@@ -45,16 +74,37 @@ export default class WebsocketContext extends Context implements IWebsocketConte
     rejected: boolean;
     teardownWired: boolean;
     connection: Ws | 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: IUpgradeAdmission | null;
     origin: string;
     proxy: ProxyType | null;
     forwarded: ResolvedProxy | null;
     wsUrl: URL | null;
-    queryGet: Record<string, string>;
-    queryRequest: Record<string, string>;
+    query: Record<string, string>;
     wsPath: string;
-    constructor(scope: Scope, req: IncomingMessage, ws: Ws, type: ServerType);
+    constructor(scope: Scope, req: IncomingMessage, ws: Ws | null, serverType: ServerType);
     log(pci: unknown, severity?: Severity, msgid?: Msgid, msg?: Message): 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
+     * contexte a été construit et jugé AVANT, sans elle.
+     *
+     * @param ws - la socket acceptée
+     */
+    acceptConnection(ws: Ws): void;
+    /**
+     * 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: number): boolean;
     connect(): Promise<Ws>;
     handle(data?: unknown[]): Promise<this>;
     render(chunk: unknown, encoding?: BufferEncoding): Promise<WebsocketResponse>;

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

@@ -0,0 +1,15 @@
+import type { ContextType } from "../../../service/http-kernel.js";
+import type WebsocketContext from "./WebsocketContext.js";
+/**
+ * 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`).
+ */
+export declare function isWebsocketContext(context: ContextType): context is WebsocketContext;

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

@@ -1,5 +1,6 @@
 import type { IProfilerQuery } from "nodefony";
-import type { ISecurityTrace, PhaseName, PhaseTiming } from "../../interfaces/IContext.js";
+import type { ISecurityTrace, PhaseName, PhaseTiming, ProtocolName } from "../../interfaces/IContext.js";
+import type { IResolvedRoute, IRouteResolver } from "../../interfaces/IRouting.js";
 /**
  * Zone firewall capturée sur le contexte (`SecuredArea`, lue en structurel :
  * `@nodefony/http` ne peut pas importer `@nodefony/security`).
@@ -10,22 +11,22 @@ export interface ProfiledArea {
     mode?: string;
     authenticators?: readonly string[];
 }
-/** Ce que le Profiler lit d'un Resolver (route/controller/action). */
+/**
+ * Ce que le Profiler lit d'un Resolver (route/controller/action) — dérivé de
+ * {@link IRouteResolver}, en lecture seule : tout résolveur du contrat s'y range
+ * sans conversion, et les deux types ne peuvent plus diverger.
+ */
 export interface ProfiledResolver {
-    route?: {
-        name?: string;
-    } | null;
-    controller?: {
-        name?: string;
-    } | null;
-    actionName?: string;
+    readonly route?: Pick<IResolvedRoute, "name"> | null | undefined;
+    readonly controller?: IRouteResolver["controller"];
+    readonly actionName?: string | undefined;
 }
 /** Descripteur d'ouverture d'une invocation (ce que le pont connaît d'entrée). */
 export interface FrameProfileInit {
     /** Identifiant du profil — `<requestId de la connexion>.<n° de frame>`. */
     requestId: string;
-    /** Type de transport du contexte porteur (`websocket` / `websocket-secure`). */
-    type: string;
+    /** Famille du contexte porteur (`context.type` : `websocket`). */
+    type: ProtocolName;
     scheme: string;
     /** Méthode LOGIQUE de l'invocation (`GET`, `POST`…), pas le transport. */
     method: string;
@@ -63,7 +64,7 @@ export interface FrameProfileInit {
  */
 export declare class FrameProfile {
     readonly requestId: string;
-    readonly type: string;
+    readonly type: ProtocolName;
     readonly scheme: string;
     readonly method: string;
     readonly url: string;

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

@@ -18,6 +18,8 @@
  * Multi-process : un profil vit sur le worker qui a traité l'appel (fetch même
  * origine par requestId). Agrégat cluster = Redis (P13).
  */
+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;
@@ -77,6 +79,11 @@ export interface ProfileSecurity {
 /** 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";
@@ -117,7 +124,7 @@ export interface ProfileSummary {
 interface ProfilableContext {
     requestId?: string | undefined;
     userIdentifier?: string | null | undefined;
-    type?: string | undefined;
+    type?: ProtocolName | undefined;
     scheme?: string | undefined;
     method?: string | null | undefined;
     url?: string | undefined;
@@ -134,15 +141,7 @@ interface ProfilableContext {
         startMs: number;
         durationMs?: number | undefined;
     }> | undefined;
-    resolver?: {
-        route?: {
-            name?: string | undefined;
-        } | null;
-        controller?: {
-            name?: string | undefined;
-        } | null | undefined;
-        actionName?: string | undefined;
-    } | null | undefined;
+    resolver?: ProfiledResolver | null | undefined;
     /**
      * 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`.
@@ -168,10 +167,50 @@ interface ProfilableContext {
         roles: string[] | null;
     } | null | undefined;
 }
-export declare class Profiler {
-    private readonly _buf;
-    private readonly _cap;
-    constructor(cap?: number);
+/** Les profils collectés depuis un curseur. */
+export interface IProfileBatch {
+    /** Profils de numéro supérieur au curseur, du plus ancien au plus récent. */
+    entries: ProfileEntry[];
+    /** Curseur à repasser au prochain appel : le dernier numéro attribué. */
+    cursor: number;
+    /**
+     * Profils collectés depuis le curseur mais disparus avant d'être lus —
+     * évincés par le tampon, ou écrasés par un identifiant réutilisé. Exact.
+     */
+    lost: number;
+}
+/**
+ * Ce qu'un lecteur extérieur (outil de l'agent de code, banc) attend du
+ * profileur : suivre les profils au fil de l'eau, ou en retrouver un par son
+ * identifiant. Contrat structurel — on le résout par NOM dans le conteneur
+ * (`"profiler"`), sans dépendre de la classe.
+ */
+export interface IProfilerReader {
+    /** Curseur courant : le passer à {@link since} pour ne lire que la suite. */
+    readonly cursor: number;
+    /** Profils collectés depuis `cursor`, et le compte de ceux qui ont été perdus. */
+    since(cursor: number): IProfileBatch;
+    /** Profil complet d'une requête, ou `undefined` si évincé/inconnu. */
+    get(requestId: string): ProfileEntry | undefined;
+}
+/**
+ * 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.
+ */
+export declare class Profiler implements IProfilerReader {
+    #private;
+    private readonly _lanes;
+    private readonly _caps;
+    /** Dernier numéro d'ordre attribué (0 = aucun profil collecté). */
+    private _seq;
+    /**
+     * @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?: number, sideCap?: number);
     /**
      * Snapshot un `Context` en fin de requête. Tolérant aux champs absents
      * (handshake WS, erreur précoce). À appeler AVANT `context.clean()`.
@@ -185,9 +224,23 @@ export declare class Profiler {
      * Résumés des requêtes les plus récentes (récent → ancien), capés à `limit`.
      */
     recent(limit?: number): ProfileSummary[];
+    /** Dernier numéro d'ordre attribué : le point de départ d'une lecture suivie. */
+    get cursor(): number;
+    /**
+     * 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: number): IProfileBatch;
     /** Nombre de profils en mémoire. */
     get size(): number;
-    /** Vide le ring buffer. */
+    /** Vide les anneaux. */
     clear(): void;
 }
 export default Profiler;

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

@@ -0,0 +1,215 @@
+import type { ProfileEntry } from "./Profiler.js";
+/**
+ * Agrégation des profils de requêtes — règle PURE, sans horloge ni I/O.
+ *
+ * Une seule implémentation pour tout ce qui résume le profileur : l'outil MCP
+ * qui observe l'application (`nodefony_observe`), celui qui tire lui-même des
+ * requêtes sur une route, et demain la console d'administration. Elle est
+ * bornée par construction : un échantillon de durées par route, un nombre
+ * maximal de formes SQL retenues, quelques exemples d'erreurs — observer une
+ * application chargée ne fait jamais grossir la mémoire avec la fenêtre.
+ */
+/**
+ * Répétitions d'une même forme SQL, dans UNE requête, à partir desquelles on
+ * signale un N+1. En dessous, ce sont des boucles courtes légitimes (quelques
+ * lectures de configuration, une pagination) qu'on signalerait à tort.
+ */
+export declare const N_PLUS_ONE_MIN_REPEATS = 5;
+/** Durées retenues par route pour les percentiles (échantillonnage au-delà). */
+export declare const ROUTE_SAMPLE_CAP = 256;
+/** Formes SQL distinctes retenues ; les suivantes ne sont plus que comptées. */
+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). */
+export declare const TOOLING_URL_PREFIX = "/nodefony/";
+/**
+ * Provenance d'un profil : l'application, l'outillage (`/nodefony/…` :
+ * console, API d'administration, porte MCP), ou un asset relayé sous un
+ * préfixe de module (`/_vite/`).
+ */
+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.
+ *
+ * @param url - URL du profil, absolue ou chemin.
+ * @returns la provenance du profil.
+ */
+export declare function profileLane(url: string): ProfileLane;
+/**
+ * Le profil vient-il de l'outillage (routes `/nodefony/…` ou assets relayés)
+ * plutôt que de l'application.
+ *
+ * @param url - URL du profil, absolue ou chemin.
+ */
+export declare function isToolingUrl(url: string): 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. */
+    nPlusOneMinRepeats?: number | undefined;
+    /** Agréger aussi les requêtes de l'outillage (`/nodefony/…`, `/_vite/…`). */
+    includeTooling?: boolean | undefined;
+    /** Source d'aléa de l'échantillonnage — injectée par les tests. */
+    random?: (() => number) | undefined;
+}
+/** Accumulateur : on lui donne les profils un à un, il rend le rapport. */
+export interface IProfileAggregator {
+    /** Ajoute un profil ; `false` s'il a été écarté (outillage). */
+    add(entry: ProfileEntry): boolean;
+    /** Le rapport à cet instant ; l'accumulateur continue d'accepter des profils. */
+    result(): IProfileReport;
+}
+/**
+ * Réduit une requête SQL (ou le descripteur d'une commande NoSQL) à sa FORME :
+ * valeurs remplacées par `?`, listes de valeurs repliées, blancs compactés.
+ *
+ * Deux requêtes qui ne diffèrent que par leurs valeurs ont la même forme — c'est
+ * ce qui permet de reconnaître un N+1. Et aucune valeur ne survit : la forme
+ * peut sortir dans un rapport sans emporter une donnée personnelle.
+ *
+ * @param sql - le texte tel que l'adaptateur l'a poussé au profileur.
+ * @returns la forme normalisée.
+ */
+export declare function sqlShape(sql: string): string;
+/**
+ * Une requête en ERREUR du serveur : statut ≥ 500, ou exception levée sans
+ * verdict client. Règle unique — le rapport, ses exemples et la lecture de leurs
+ * journaux en dépendent.
+ *
+ * Un statut 4xx n'en est JAMAIS une, même porteur d'une exception : un refus
+ * 401/403 (l'authentification lève une `AuthenticationError`) ou une ressource
+ * absente est le verdict rendu au client, compté à part — le lister parmi les
+ * erreurs ferait chercher une panne là où il manque une identité.
+ *
+ * @param entry - le profil (seuls statut et erreur sont lus).
+ */
+export declare function isFailedProfile(entry: Pick<ProfileEntry, "status" | "error">): boolean;
+/**
+ * Le chemin d'une URL de profil. Le profileur enregistre l'URL ABSOLUE
+ * (`http://hôte:port/chemin`) : un filtre écrit sur le chemin ne mordrait
+ * jamais dessus. Sans `URL` à construire — appelée sur chaque profil lu.
+ */
+export declare function urlPath(url: string): string;
+/**
+ * Crée un accumulateur de profils.
+ *
+ * @param options - seuil N+1, prise en compte de l'outillage, aléa injecté.
+ * @returns l'accumulateur ; son `result()` peut être appelé à tout moment.
+ */
+export declare function createProfileAggregator(options?: IProfileAggregatorOptions): IProfileAggregator;
+/**
+ * Agrège une liste de profils en une fois.
+ *
+ * @param entries - les profils, dans n'importe quel ordre.
+ * @param options - mêmes réglages que {@link createProfileAggregator}.
+ * @returns le rapport.
+ */
+export declare function aggregateProfiles(entries: Iterable<ProfileEntry>, options?: IProfileAggregatorOptions): IProfileReport;

package/dist/types/nodefony/src/proxy/forward.d.ts

@@ -140,8 +140,20 @@ export declare function forwardRequest(req: ProxiedRequest, res: ProxiedResponse
  * @returns la tête complète, CRLF final compris
  */
 export declare function rawHead(status: string, rawHeaders: readonly string[], skip?: ReadonlySet<string> | null, extra?: readonly string[]): string;
-/** Réponse brute minimale sur un socket d'upgrade, puis fermeture. */
-export declare function refuseUpgrade(socket: Duplex, status: number, reason: string): void;
+/**
+ * Réponse brute minimale sur un socket d'upgrade, puis fermeture.
+ *
+ * Les en-têtes passent par la validation de `node:http` : un nom ou une valeur
+ * invalide — un saut de ligne surtout, qui forgerait un en-tête de plus — est
+ * OMIS, jamais écrit. `Connection` et `Content-Length` sont posés ici et ne se
+ * remplacent pas.
+ *
+ * @param socket - socket du client, encore en attente de sa réponse
+ * @param status - statut HTTP du refus
+ * @param reason - phrase de raison
+ * @param headers - en-têtes du refus (`WWW-Authenticate`, `Retry-After`…)
+ */
+export declare function refuseUpgrade(socket: Duplex, status: number, reason: string, headers?: Readonly<Record<string, string | number>> | null): void;
 /**
  * Relaie un upgrade WebSocket DÉJÀ validé (méthode, `Upgrade`, clé, version,
  * `Origin` — cf `ReverseProxy.handleUpgrade`) : rejoue le handshake vers

package/dist/types/nodefony/src/proxy/generateProxyConfig.d.ts

@@ -42,6 +42,12 @@ export interface ProxyIntrospection {
     httpPort: number;
     /** Port HTTPS/2 du backend (re-encrypt). */
     httpsPort: number;
+    /**
+     * Port h2c du backend (`servers.h2c`), ou `null` s'il n'est pas activé. Le
+     * générateur haproxy y envoie le trafic en HTTP/2 (`proto h2`) ; nginx, qui
+     * ne parle pas HTTP/2 à ses amonts, l'ignore.
+     */
+    h2cPort?: number | null;
     /** Dossiers statiques servis à la racine `/` (ordre = priorité). */
     staticRoots: string[];
     /** Montages statiques préfixés (servis tels quels). */
@@ -71,6 +77,16 @@ export interface ProxyIntrospection {
      * saines.
      */
     keepaliveIntervalMs: number;
+    /**
+     * Chemin de la sonde de disponibilité (`health.readinessPath`), ou `null`
+     * si les sondes sont désactivées.
+     *
+     * HAProxy la sonde (`option httpchk`) au lieu d'un simple contrôle de
+     * connexion : un exemplaire qui draine garde son port ouvert, mais `/readyz`
+     * répond déjà `503` — c'est ce qui le retire du répartiteur AVANT qu'il
+     * cesse d'accepter. Un contrôle TCP le garderait jusqu'à la fermeture du port.
+     */
+    readinessPath?: string | null;
     /**
      * Terminaison TLS au frontal, ou `null` pour n'écouter qu'en clair.
      *

package/dist/types/nodefony/src/proxy/rules.d.ts

@@ -78,6 +78,9 @@ export declare function isAmbiguousPath(url: string): boolean;
  * un tel handshake est relayé : un `Upgrade` quelconque (`h2c`…) raccordé
  * octet pour octet ouvrirait un tunnel que rien n'inspecte.
  *
+ * Appelé à CHAQUE handshake (proxy inverse et routes de Nodefony) : aucune
+ * allocation — des expressions testées, jamais de découpe de chaîne.
+ *
  * @param method - méthode de la requête
  * @param headers - en-têtes reçus
  * @returns la raison du refus, ou `null` si le handshake est conforme

package/dist/types/nodefony/src/servers/http2Limits.d.ts

@@ -0,0 +1,37 @@
+import type { Http2SecureServer, Http2Server, ServerOptions } from "node:http2";
+import type { IHttpConfig } from "../../config/config.js";
+/**
+ * Limites anti-DoS d'un serveur HTTP/2, lues dans la section `http2` du module :
+ * `maxSessionMemory` (amplification mémoire) et `maxConcurrentStreams` dans les
+ * SETTINGS (CVE-2023-44487, Rapid Reset). Règle UNIQUE des serveurs HTTP/2 — TLS
+ * (5152) comme h2c — : une limite oubliée sur l'un d'eux en ferait la porte de
+ * l'attaque.
+ *
+ * Une limite absente garde le défaut de Node (aucune régression).
+ *
+ * @param limits - `module.options.http2`.
+ * @returns les options à fusionner dans celles de `createServer`/`createSecureServer`.
+ */
+export declare function http2ServerLimits(limits: Partial<IHttpConfig["http2"]> | undefined): Pick<ServerOptions, "maxSessionMemory" | "settings">;
+/**
+ * Borne l'inactivité des sessions d'un serveur HTTP/2 — TLS (5152) comme h2c —
+ * et contourne un défaut de Node qui garde chaque session fermée en vie jusqu'à
+ * l'échéance de ce délai.
+ *
+ * Le défaut (Node 24, 26) : `closeSession` (`internal/http2/core`) marque la
+ * session détruite PUIS appelle `session.setTimeout(0)` ; or `setStreamTimeout`
+ * sort aussitôt sur un objet détruit. Le minuteur n'est jamais désarmé et retient
+ * la session (~2,4 Ko) pendant `timeoutMs` : sous un flux de connexions neuves,
+ * connexions/s × délai × 2,4 Ko. Signalé à Node : https://github.com/nodejs/node/issues/66885
+ *
+ * Le contournement : désarmer à la réception du GOAWAY, AVANT la destruction —
+ * c'est ainsi que ferment un proxy et un client Node, même par `destroy()`. Rien
+ * n'est retiré à la protection : Node n'agit déjà plus à l'échéance sur une
+ * session fermée (`sessionOnTimeout` sort sur `closed`). Une coupure TCP sans
+ * GOAWAY garde la rétention, bornée au délai.
+ *
+ * @param server - le serveur HTTP/2.
+ * @param timeoutMs - délai d'inactivité ; 0 ou absent le laisse désactivé.
+ * @param onTimeout - appelé à l'échéance (événement `timeout` du serveur).
+ */
+export declare function setHttp2SessionTimeout(server: Http2Server | Http2SecureServer, timeoutMs: number | undefined, onTimeout: () => void): void;

package/dist/types/nodefony/src/servers/kernelServers.d.ts

@@ -10,6 +10,15 @@ import type { ServersConfig } from "nodefony";
  * @returns la section typée, ou `undefined` si elle est absente ou n'est pas un objet.
  */
 export declare function asServersConfig(servers: unknown): ServersConfig | undefined;
+/**
+ * Le serveur h2c démarre-t-il ? Seul un `enabled: true` EXPLICITE l'allume : la
+ * section existe toujours (défauts), un port seul ne vaut pas activation.
+ *
+ * @param entry - `servers.h2c`.
+ */
+export declare function isH2cEnabled(entry: {
+    enabled?: boolean | undefined;
+} | undefined): boolean;
 /**
  * Port DEMANDÉ pour un serveur (`servers.<type>.port`), ou `undefined` si le
  * serveur est désactivé, absent, ou sans port numérique.
@@ -17,4 +26,4 @@ export declare function asServersConfig(servers: unknown): ServersConfig | undef
  * @param servers - section `servers` déjà rétrécie ({@link asServersConfig}).
  * @param type - le serveur visé.
  */
-export declare function configuredServerPort(servers: ServersConfig | undefined, type: "http" | "https"): number | undefined;
+export declare function configuredServerPort(servers: ServersConfig | undefined, type: "http" | "https" | "h2c"): number | undefined;