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

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;
@@ -79,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…). */
@@ -89,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

@@ -18,106 +18,19 @@
  * Multi-process : un profil vit sur le worker qui a traité l'appel (fetch même
  * origine par requestId). Agrégat cluster = Redis (P13).
  */
-/** 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;
-    /** 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 { ProfiledResolver } from "./FrameProfile.js";
+import type { ProtocolName } from "../../interfaces/IContext.js";
+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;
     userIdentifier?: string | null | undefined;
-    type?: string | undefined;
+    type?: ProtocolName | undefined;
     scheme?: string | undefined;
     method?: string | null | undefined;
     url?: string | undefined;
@@ -134,15 +47,12 @@ 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;
+    /**
+     * 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`.
@@ -168,10 +78,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()`.
@@ -183,11 +133,29 @@ export declare class Profiler {
     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, connection?: string): 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}.
      */
-    recent(limit?: number): ProfileSummary[];
+    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,132 @@
+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.
+ *
+ * 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 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/…` :
+ * 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. 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.
+ */
+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;
+/**
+ * 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é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;

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

@@ -3,12 +3,19 @@ import { resolvePortPolicy } from "nodefony";
 import type { PortPolicy } from "nodefony";
 export { resolvePortPolicy };
 export type { PortPolicy };
-/** Serveur écoutable (surface minimale commune `http`/`https`/`http2`). */
+/**
+ * Serveur écoutable (surface minimale commune `http`/`https`/`http2`).
+ *
+ * Les écouteurs sont typés événement par événement : c'est la forme que les
+ * surcharges de Node acceptent telle quelle, sans conversion chez l'appelant.
+ */
 export interface Listenable {
     listen(port: number, host?: string): unknown;
     address(): AddressInfo | string | null;
-    once(event: string, listener: (...args: never[]) => void): unknown;
-    removeListener(event: string, listener: (...args: never[]) => void): unknown;
+    once(event: "error", listener: (error: NodeJS.ErrnoException) => void): unknown;
+    once(event: "listening", listener: () => void): unknown;
+    removeListener(event: "error", listener: (error: NodeJS.ErrnoException) => void): unknown;
+    removeListener(event: "listening", listener: () => void): unknown;
 }
 /** Nombre de ports essayés après le désiré, en `auto`. */
 export declare const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
@@ -34,18 +41,35 @@ export interface ServersPortConfig {
     https?: {
         port?: number | undefined;
     } | false;
+    h2c?: {
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+    };
     portPolicy?: PortPolicy;
     portRetryAttempts?: number;
 }
+/** Serveur dont `buildBindPlan` compose le plan. */
+export type BoundServer = "http" | "https" | "h2c";
+/**
+ * Serveur actif qui convoite le MÊME port que h2c, ou `null`.
+ *
+ * Un port partagé avec h2c n'est pas un conflit à contourner : sur ce port, le
+ * client HTTP/1.1 et le proxy h2c se marchent dessus, et le repli `auto` ferait
+ * glisser l'un des deux là où personne ne l'attend. Le boot le refuse.
+ *
+ * @param servers - `kernel.options.servers`.
+ * @returns `"http"` ou `"https"` en conflit, sinon `null` (h2c inactif, port 0).
+ */
+export declare function h2cPortConflict(servers: ServersPortConfig | undefined): "http" | "https" | null;
 /**
  * Compose le plan de bind d'un serveur depuis la config du kernel — source UNIQUE
- * (les deux serveurs l'appellent ; la politique n'est décidée qu'ici).
+ * (les serveurs l'appellent ; la politique n'est décidée qu'ici).
  *
  * @param which - le serveur qu'on borne.
  * @param servers - `kernel.options.servers`.
  * @param environment - `kernel.environment` (arbitre le défaut de la politique).
  */
-export declare function buildBindPlan(which: "http" | "https", servers: ServersPortConfig | undefined, environment: string | undefined): BindPlan;
+export declare function buildBindPlan(which: BoundServer, servers: ServersPortConfig | undefined, environment: string | undefined): BindPlan;
 /**
  * Sonde « un serveur répond-il déjà ici ? ».
  *