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

package/dist/types/nodefony/service/servers/wsHeartbeat.d.ts

@@ -13,6 +13,18 @@ export interface IWsHeartbeatOptions {
     /** Délai (ms) accordé pour recevoir le `pong` avant de couper la socket. */
     keepaliveGracePeriod?: number;
 }
+/**
+ * Ce que le tick lit et écrit d'une connexion — la socket `ws` en production.
+ */
+export interface IHeartbeatClient {
+    readonly readyState: number;
+    ping(): void;
+    terminate(): void;
+    /** Dernier signe de vie (date du dernier `pong`, ou de la connexion). */
+    _nfLastPong?: number;
+    /** Date du dernier `ping` émis ; `0` = aucun ping en attente de réponse. */
+    _nfPingedAt?: number;
+}
 /**
  * Arme le suivi keep-alive d'UNE connexion : initialise l'horodatage de vie et
  * attache l'unique listener `pong` qui le rafraîchit.
@@ -24,6 +36,20 @@ export interface IWsHeartbeatOptions {
  * @param ws - la socket fraîchement connectée
  */
 export declare const trackPong: (ws: Ws) => void;
+/**
+ * Un tick du keep-alive : pingue les connexions muettes depuis `interval`, et
+ * coupe celles dont le ping attend sa réponse depuis plus de `grace`.
+ *
+ * Fonction PURE du temps : l'horloge est passée en argument, si bien que la
+ * règle se prouve pas à pas, sans minuteur réel — un banc qui la prouverait à
+ * l'horloge murale confondrait une boucle d'événements chargée avec un zombie.
+ *
+ * @param clients - les connexions du serveur
+ * @param now - l'instant du tick (`performance.now()` en production)
+ * @param interval - délai sans signe de vie avant un ping, ms
+ * @param grace - délai accordé au pong avant de couper, ms
+ */
+export declare const heartbeatTick: (clients: Iterable<IHeartbeatClient>, now: number, interval: number, grace: number) => void;
 /**
  * Démarre le heartbeat keep-alive du serveur : détecte les connexions zombies
  * (half-open — TCP encore ouvert mais le pair a disparu sans frame Close) et les

package/dist/types/nodefony/service/sessions/sessions-service.d.ts

@@ -1,6 +1,6 @@
 import { Service, Module } from "nodefony";
 import type { IPage } from "nodefony";
-import type { ISessionStorage, ISessionSummary, ISessionRecord, ISessionListQuery } from "../../interfaces/ISession.js";
+import type { ISessionStorage, ISerializedSession, ISessionSummary, ISessionRecord, ISessionListFilter, ISessionListQuery } from "../../interfaces/ISession.js";
 import HttpKernel, { ContextType } from "../http-kernel.js";
 import Session, { OptionsSessionType } from "../../src/session/session.js";
 import type { IHttpConfig } from "../../config/config.js";
@@ -191,6 +191,24 @@ declare class SessionsService extends Service {
      * est sûre. Idempotent — `false` si aucun `ref` ne correspond.
      */
     destroyByRef(ref: string, actor?: string | null): Promise<boolean>;
+    /**
+     * Détruit TOUTES les sessions dont le contenu satisfait `match` — la primitive
+     * des révocations groupées (« déconnecter partout », déconnexion demandée par
+     * un fournisseur d'identité). Ni journal ni audit : l'appelant, qui connaît le
+     * motif, les émet.
+     *
+     * @remarks Quand la méthode rend la main, il ne reste AUCUNE session qui
+     * satisfait `match` (au plus `MAX_LOGOUT_PASSES` passages). Une révocation qui
+     * en laisse une seule n'est pas une imprécision, c'est une faille.
+     *
+     * @param filter - restriction poussée au store (`user` : WHERE indexable) ;
+     *   `undefined` parcourt tout le parc.
+     * @param match - prédicat sur la session sérialisée — il doit RE-VÉRIFIER ce
+     *   que `filter` exprime, un store pouvant l'ignorer.
+     * @returns le nombre de sessions détruites.
+     * @throws Error si le store actif ne sait pas énumérer ses sessions.
+     */
+    destroyWhere(filter: ISessionListFilter | undefined, match: (data: ISerializedSession) => boolean): Promise<number>;
     /**
      * « Déconnexion partout » : détruit TOUTES les sessions d'un utilisateur (scan
      * O(N) — pas d'index inverse, acceptable en admin). Renvoie le nombre détruit.

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

@@ -1,5 +1,5 @@
 import { Container, Service, Severity, Msgid, Message, Pci, Pdu, KernelEventsType, nodefonyError, Scope } from "nodefony";
-import type { IProfilerQuery } from "nodefony";
+import type { IProfilerQuery, RequestContextPayload } from "nodefony";
 import type { IRouteResolver, IRequestRouter } from "../../interfaces/IRouting.js";
 import type { ISecurityZone } from "../../interfaces/ISecurity.js";
 import { WebSocketServer } from "ws";
@@ -7,6 +7,7 @@ import http2 from "node:http2";
 import http from "node:http";
 import https from "node:https";
 import HttpKernel, { ServerType, Data, SchemeType } from "../../service/http-kernel.js";
+import type { AlpnProtocol, ProtocolName } from "../../interfaces/IContext.js";
 import HttpResponse from "./http/Response.js";
 import Http2Response from "./http2/Response.js";
 import WebsocketResponse from "./websocket/Response.js";
@@ -43,7 +44,6 @@ declare class Context extends Service implements IContextInterface {
     secure: boolean;
     security?: ISecurityZone | null | undefined;
     cleaned: boolean;
-    isControlledAccess: boolean;
     validDomain: boolean;
     finished: boolean;
     pushAllowed: boolean;
@@ -51,7 +51,15 @@ declare class Context extends Service implements IContextInterface {
     requested: boolean;
     sessionStarting: boolean;
     domain: string;
-    type: ServerType;
+    /** Famille traitée (`network.protocol.name` d'OpenTelemetry) — union ouverte. */
+    type: ProtocolName;
+    /** Serveur qui a reçu la requête — choisit la configuration par serveur. */
+    serverType: ServerType;
+    /**
+     * Protocole du saut local (registre IANA ALPN) — union ouverte. Une connexion
+     * WebSocket naît d'un upgrade HTTP/1.1 ; `HttpContext` le constate sur la requête.
+     */
+    alpnProtocol: AlpnProtocol;
     server?: WebSocketServer | http.Server | https.Server | http2.Http2SecureServer | null | undefined;
     httpKernel: HttpKernel | null;
     request: contextRequest | null;
@@ -68,6 +76,14 @@ declare class Context extends Service implements IContextInterface {
     session: Session | null | undefined;
     cookieSession: Cookie | null | undefined;
     user: unknown;
+    /**
+     * Identifiant de l'appelant AUTHENTIFIÉ, posé par le pare-feu ; `null` hors
+     * zone ou pour un anonyme. Lisible au démontage, hors de la bulle ALS : c'est
+     * ce que lisent le journal d'audit et le profileur. Distinct de `user`, qui
+     * lie la session à son principal de SESSION — y écrire l'identité d'un jeton
+     * rattacherait la session d'un autre compte.
+     */
+    userIdentifier: string | null;
     waitAsync: boolean;
     isJson: boolean;
     protected _isHtml: boolean | null;
@@ -116,11 +132,12 @@ declare class Context extends Service implements IContextInterface {
     private _phaseIndex;
     private _afterResponseFns;
     private _afterResponseFired;
+    private requestStore;
     private _abortController;
     metaData: Data;
     scheme: SchemeType;
     webSocketState: WebSocketState;
-    constructor(container: Container | Scope, type: ServerType);
+    constructor(container: Container | Scope, serverType: ServerType);
     /**
      * Assemble l'enveloppe `metaData` de la requête (`nodefony.*` + `route`
      * snapshot per-requête + overrides appelant). Délègue au builder monomorphe
@@ -160,11 +177,23 @@ declare class Context extends Service implements IContextInterface {
     get signal(): AbortSignal;
     _abortIfPending(reason?: string): void;
     log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;
+    /**
+     * Confie au contexte le magasin `RequestContext` de son unité de travail
+     * (requête HTTP, connexion WebSocket), pour qu'il le VIDE à son nettoyage.
+     *
+     * Un minuteur ou une promesse armé pendant l'unité de travail capture ce
+     * magasin et le garde au-delà de la réponse — avec le contexte, l'identité
+     * et le jeton du pare-feu. Le vidage ({@link RequestContext.release}) n'y
+     * laisse que la corrélation et le scope refermé.
+     *
+     * @param store - le magasin passé à `RequestContext.run`
+     */
+    holdRequestStore(store: RequestContextPayload): void;
     clean(): void;
     /**
      * Log d'un event du cycle de vie — gate boot-time (V2.1) : en production le
-     * Pdu n'est PAS construit (return avant toute allocation). Hors prod, jalon
-     * notable → INFO (EVENT_SEVERITY), event technique → DEBUG.
+     * Pdu n'est PAS construit (return avant toute allocation). Hors prod : DEBUG,
+     * pour le Suivi de requête de Studio — la ligne `req` porte le bilan.
      */
     private logEvent;
     fire(event: KernelEventsType, ...args: unknown[]): boolean;

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

@@ -13,12 +13,22 @@
  * Politique de compilation (sûre, ancrée, ReDoS-free) :
  * - string sans `*` → match EXACT ancré (`^...$`, le `.` est littéral).
  * - string avec `*` → wildcard UN label (`*.example.com` → `^[^.]+\.example\.com$`,
- *   RFC 6125 TLS-wildcard : matche `img.example.com`, pas `a.b.example.com` ni `example.com`).
+ *   RFC 9525 TLS-wildcard : matche `img.example.com`, pas `a.b.example.com` ni `example.com`).
  * - `RegExp` → reprise telle quelle (l'auteur assume l'ancrage).
  *
  * Compilation faite UNE fois (boot / enregistrement de route) ; le test par
  * requête est un simple `RegExp.test` sur une liste pré-compilée (zéro alloc hot-path).
  */
+/**
+ * Nom d'hôte d'une autorité brute (`host[:port]`), sans port — la valeur que
+ * rendrait `URL.hostname` pour une autorité déjà canonique, sans en payer le
+ * parse (`indexOf` + `slice`, #508). Un littéral IPv6 garde ses crochets
+ * (`[::1]:5151` → `[::1]`) : couper au premier `:` le réduirait à `[`.
+ *
+ * @param host - autorité brute (`Host`), éventuellement absente
+ * @returns le nom d'hôte, `""` si l'autorité est absente
+ */
+export declare function hostnameOf(host: string | undefined): string;
 /** Un pattern de domaine : string (exact ou `*`-wildcard) ou `RegExp` (libre). */
 export type DomainPattern = string | RegExp;
 /**

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

@@ -30,17 +30,30 @@ export interface ProxyType {
     proxyRealIp?: string | undefined;
     proxyVia?: string | undefined;
 }
+/**
+ * Même URL (chemin, requête, hôte) sous un autre schéma et un autre port.
+ * `port` absent → port par défaut du schéma (omis de l'URL).
+ *
+ * @param from - URL de la requête.
+ * @param scheme - schéma cible.
+ * @param port - port du serveur cible, s'il est connu.
+ * @returns l'URL absolue de redirection.
+ */
+export declare function switchUrlScheme(from: URL, scheme: "http" | "https", port?: number): string;
 export type HttpRequestType = Http2Request | HttpRequest;
 export type HttpRsponseType = Http2Response | HttpResponse;
 import type { IHttpContext as IHttpContextInterface } from "../../../interfaces/IContext.js";
+import { type ISseStreamOptions, type SseStream } from "./SseStream.js";
 declare class HttpContext extends Context implements IHttpContextInterface {
     proxy: ProxyType | null;
+    /** Socket h1 inscrite dans `socketActiveContext` — retirée par `clean()`. */
+    private activeSocket;
     isRedirect: boolean;
     sended: boolean;
     request: HttpRequestType;
     response: HttpRsponseType;
     uploadService: uploadService | null;
-    constructor(container: Container | Scope, request: http.IncomingMessage | http2.Http2ServerRequest, response: http.ServerResponse | http2.Http2ServerResponse, type: ServerType);
+    constructor(container: Container | Scope, request: http.IncomingMessage | http2.Http2ServerRequest, response: http.ServerResponse | http2.Http2ServerResponse, serverType: ServerType);
     /**
      * URL d'origine effective, construite À LA DEMANDE (1ʳᵉ lecture, puis
      * mémoïsée). `Origin` invalide ou `null` (RFC 6454) → repli sur l'URL de la
@@ -71,6 +84,16 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      */
     handle(): MaybePromise<this>;
     setTimeout(): void;
+    /**
+     * Nettoie le contexte, et le DÉTACHE de sa socket h1 : la connexion
+     * persistante survit à la requête, et l'entrée de `socketActiveContext`
+     * retiendrait sinon tout le contexte jusqu'à sa fermeture. Seule l'entrée qui
+     * pointe encore sur CE contexte est retirée — une requête suivante sur la
+     * même socket a pu la réécrire. Le gestionnaire `timeout` de la socket ne
+     * trouve alors rien et prend le chemin « socket inactive → `destroy()` »,
+     * celui qu'il prenait déjà pour un contexte nettoyé.
+     */
+    clean(): void;
     /**
      * Sérialise la donnée selon son type (JSON, HTML, texte), pose statut et
      * en-têtes, puis l'envoie ({@link send}). Synchrone quand l'envoi l'est (#505).
@@ -115,6 +138,16 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      * @returns la réponse, ou sa promesse quand l'écriture attend.
      */
     write(chunk: unknown, encoding?: BufferEncoding, _flush?: boolean): MaybePromise<Http2Response | HttpResponse>;
+    /**
+     * Répond par un flux d'événements serveur (`text/event-stream`).
+     *
+     * La requête ne se termine qu'à `close()` du flux, ou au départ du client.
+     *
+     * @param options - battement de cœur, délai `retry:` initial.
+     * @returns le flux, ou sa promesse quand une session est à sauver d'abord.
+     * @throws HttpError 500 quand la réponse est déjà partie.
+     */
+    openSse(options?: ISseStreamOptions): SseStream | Promise<SseStream>;
     flush(chunk: unknown, encoding: BufferEncoding): MaybePromise<HttpResponse>;
     /**
      * Termine la requête : hook `onClose`, puis fin de la réponse si l'envoi ne
@@ -126,7 +159,21 @@ declare class HttpContext extends Context implements IHttpContextInterface {
     /** Fin de la réponse, sauf si l'envoi l'a déjà terminée. */
     private endResponse;
     redirect(Url: string, status?: number | string, headers?: Record<string, string | number>): HttpResponse;
+    /**
+     * Redirige vers la même URL en HTTPS, sur le port du serveur HTTPS lié —
+     * ou le port par défaut derrière un proxy, dont le port public est inconnu.
+     *
+     * @param status - code de redirection (défaut de `redirect`).
+     * @param headers - en-têtes ajoutés à la réponse.
+     */
     redirectHttps(status?: number | string, headers?: Record<string, string | number>): HttpResponse;
+    /**
+     * Redirige vers la même URL en HTTP, sur le port du serveur HTTP lié — ou
+     * le port par défaut derrière un proxy.
+     *
+     * @param status - code de redirection (défaut de `redirect`).
+     * @param headers - en-têtes ajoutés à la réponse.
+     */
     redirectHttp(status?: number | string, headers?: Record<string, string | number>): HttpResponse;
     getHostName(): string;
     getRemoteAddress(): string | null;

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

@@ -5,6 +5,7 @@ import { URL } from "node:url";
 import { HTTPMethod, Cookies } from "../Context.js";
 import QS from "qs";
 import { ParserXml, ParserQs, Parser, acceptParser } from "./parser.js";
+import type { RequestBody } from "../../../interfaces/IRequest.js";
 import { UploadedFile } from "../../../service/upload/upload-service.js";
 import type { IParsedUploadFile, IUploadOptions } from "../../../interfaces/IUpload.js";
 import { Pci, Pdu, Message, Severity, Msgid } from "nodefony";
@@ -75,22 +76,24 @@ declare class HttpRequest {
     get url(): URL;
     set url(u: URL);
     parser: ParserType | null;
-    queryPost: Record<string, unknown>;
-    queryGet: Record<string, unknown>;
-    queryFile: UploadedFile[];
-    query: Record<string, unknown>;
     /**
-     * Le CORPS de la requête, parsé — nom universel de l'écosystème (Express,
-     * Fastify, NestJS), alias de {@link queryPost}.
-     *
-     * Ne pas confondre avec {@link query}, qui FUSIONNE la query string et le
-     * corps : `body` ne rend jamais un paramètre d'URL. Le data plane admin
-     * expose déjà cette sémantique (`IAdminRequest.body`) ; ce getter la rend
-     * disponible partout.
+     * Le CORPS de la requête, parsé (JSON, urlencoded, XML, champs multipart) —
+     * nom universel de l'écosystème (Express, Fastify, NestJS) et celui
+     * d'`IAdminRequest.body`. Jamais un paramètre d'URL : ceux-là sont dans
+     * {@link query}, et les deux ne fusionnent pas.
+     */
+    body: RequestBody;
+    /**
+     * Les fichiers reçus dans un corps multipart, déjà écrits dans le répertoire
+     * temporaire — lus par `@UploadedFile()` / `@UploadedFiles()`. Les champs
+     * texte du même corps sont dans {@link body}.
      *
-     * Getter (aucune allocation) : `queryPost` reste la source unique.
+     * Lecture seule : une requête sans upload rend un vide partagé et gelé,
+     * aucune allocation.
      */
-    get body(): Record<string, unknown>;
+    get files(): readonly UploadedFile[];
+    /** Les paramètres d'URL, seuls — jamais un champ du corps ({@link body}). */
+    query: Record<string, unknown>;
     queryStringOptions: (QS.IParseOptions & {
         decoder?: undefined;
     }) | undefined;
@@ -112,7 +115,7 @@ declare class HttpRequest {
      * remplace le `once("onRequestEnd")` du ctor qui allouait 1 onceWrapper +
      * 1 closure à CHAQUE requête.
      *
-     * Il porte le CORPS (`queryPost`), pas la fusion `query` : un seul sens de
+     * Il porte le CORPS (`body`), jamais les paramètres d'URL : un seul sens de
      * `body` dans tout le framework, celui de l'écosystème et d'`IAdminRequest`.
      */
     private fireRequestEnd;
@@ -228,7 +231,9 @@ declare class HttpRequest {
     /**
      * Scheme effectif côté client : `Forwarded`/`X-Forwarded-*` résolu de façon
      * canonique (this.forwarded, gated proxy de confiance) ; sinon le transport
-     * réel. HTTP/2 remplace la lecture du socket par le pseudo-header `:scheme`.
+     * réel. Vaut pour HTTP/2 aussi : le pseudo-en-tête `:scheme` vient du client
+     * (RFC 9113 §8.3.1) et n'est jamais cru — sur h2c, `:scheme: https` ferait
+     * passer une connexion claire pour chiffrée.
      */
     protected resolveScheme(request: http.IncomingMessage | http2.Http2ServerRequest): string;
     getFullUrl(request?: http.IncomingMessage | http2.Http2ServerRequest): string;

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

@@ -22,6 +22,9 @@ declare class HttpResponse {
      * n'a été choisi (ni négociation, ni `render`, ni controller), émet le défaut
      * `this.contentType` (application/octet-stream) — comportement identique à
      * l'ancienne pose au constructeur, sans le ping-pong set/remove/re-set.
+     *
+     * Une réponse SANS corps n'annonce aucun type : `Content-Type` décrit le
+     * contenu (RFC 9110 §8.3), et il n'y en a pas.
      */
     protected ensureContentTypeHeader(): void;
     /**
@@ -47,6 +50,17 @@ declare class HttpResponse {
     deleteCookieByName(name: string): boolean;
     setCookies(): void | http.ServerResponse<http.IncomingMessage>;
     setCookie(cookie: Cookie): void | http.ServerResponse<http.IncomingMessage>;
+    /**
+     * Journalise en DEBUG un cookie posé, sa VALEUR MASQUÉE : nom et attributs
+     * seulement. Le journal de développement se lit par le plan d'administration
+     * — un identifiant de session y entrerait chez quiconque le consulte.
+     * La ligne n'est construite que si DEBUG passe le gate du syslog pour ce
+     * `msgid` (debug ciblé compris) : rien n'est alloué en production.
+     *
+     * @param cookie - le cookie posé.
+     * @param serialized - sa forme `Set-Cookie`, déjà calculée pour l'en-tête.
+     */
+    private logCookie;
     setHeader(name: string, value: number | string | readonly string[]): void | http.ServerResponse<http.IncomingMessage>;
     setHeaders(obj: OutgoingHttpHeaders): OutgoingHttpHeaders;
     setContentType(type?: string, encoding?: BufferEncoding): void | http.ServerResponse<http.IncomingMessage>;

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

@@ -0,0 +1,155 @@
+import type HttpContext from "./HttpContext.js";
+/**
+ * Le flux d'événements serveur (SSE) d'une réponse HTTP — `text/event-stream`.
+ *
+ * SSE n'est pas une méthode : c'est un FORMAT de réponse, choisi à l'exécution
+ * par l'action. La route reste déclarée `GET` ou `POST`, et le même `POST` peut
+ * répondre en JSON ou en flux selon l'en-tête `Accept`.
+ *
+ * Ce que la classe porte, et qu'une action écrite à la main oubliait :
+ * - les en-têtes du flux (`Cache-Control: no-cache, no-transform`,
+ *   `X-Accel-Buffering: no` pour qu'un nginx ne mette pas le flux en tampon) ;
+ * - HTTP/1.1 ET HTTP/2 : en HTTP/1.1 Node découpe le corps en morceaux
+ *   (RFC 9112 §7.1) ; en HTTP/2 l'écriture passe par le FLUX, et aucun
+ *   `Transfer-Encoding` n'est posé (interdit, RFC 9113 §8.2.2) ;
+ * - la fermeture lue sur la RÉPONSE, jamais sur la requête : en HTTP/2,
+ *   `request.on("close")` part dès la fin du corps de la requête — c'est le
+ *   défaut qui avait tué l'ancien flux de la console d'administration ;
+ * - le délai d'inactivité de la requête DÉSARMÉ (un flux n'a pas de fin
+ *   attendue), remplacé par un battement de cœur sur un minuteur `unref` ;
+ * - la contre-pression : un client lent freine l'émetteur qui attend `send()` ;
+ *   un client qui ne lit PLUS est coupé au bout de `stallTimeout` ;
+ * - les gardes des connexions longues, les mêmes que pour une socket
+ *   WebSocket : plafond de connexions par IP (`wsMaxConnectionsPerIp`, un seul
+ *   budget pour les deux transports) et fermeture du flux quand l'identité qui
+ *   l'a ouvert est révoquée (`RevocationWatch`, cœur).
+ *
+ * Norme : WHATWG HTML §9.2 (copie hors ligne
+ * `nodefony-framework-dev/references/rfc/specs/whatwg-sse.md`).
+ */
+/** Options d'ouverture d'un flux. */
+export interface ISseStreamOptions {
+    /**
+     * Période du battement de cœur (commentaire `:`), en ms entre 1 et 2^31-1 —
+     * `false` pour l'éteindre. Défaut : 15 000, la valeur que la norme suggère
+     * contre les proxys qui coupent une connexion muette (§9.2.7).
+     */
+    heartbeat?: number | false | undefined;
+    /** Délai de reconnexion imposé au client (champ `retry:`), en ms. */
+    retry?: number | undefined;
+    /**
+     * Délai maximal pendant lequel une écriture peut rester bloquée — le client
+     * ne lit plus —, en ms entre 1 et 2^31-1 ; au-delà, la connexion est coupée.
+     * Remplace le délai d'inactivité de la requête, désarmé pendant un flux.
+     * `false` pour l'éteindre. Défaut : 30 000.
+     */
+    stallTimeout?: number | false | undefined;
+    /**
+     * Taille maximale d'un événement écrit, en octets (UTF-8). Au-delà, `send()`
+     * lève une `RangeError` au lieu d'écrire. Défaut : 1 Mio.
+     */
+    maxEventBytes?: number | undefined;
+    /**
+     * Durée de vie maximale du flux, en ms entre 1 et 2^31-1 : il est fermé
+     * ensuite, et un `EventSource` se reconnecte — en repassant par le pare-feu.
+     * `false` (défaut) : pas de borne.
+     */
+    maxDuration?: number | false | undefined;
+}
+/** Ce qu'un événement porte en plus de ses données. */
+export interface ISseSendOptions {
+    /** Type de l'événement (champ `event:`) — absent : `message`. */
+    event?: string | undefined;
+    /** Identifiant (champ `id:`) que le client renverra en `Last-Event-ID`. */
+    id?: string | undefined;
+}
+/** Battement de cœur par défaut, en ms (§9.2.7 : « every 15 seconds or so »). */
+export declare const SSE_HEARTBEAT_MS = 15000;
+/** Délai de blocage d'écriture par défaut, en ms. */
+export declare const SSE_STALL_TIMEOUT_MS = 30000;
+/** Taille maximale d'un événement par défaut, en octets (1 Mio). */
+export declare const SSE_MAX_EVENT_BYTES = 1048576;
+/**
+ * Un flux `text/event-stream` ouvert sur une réponse.
+ *
+ * Il s'obtient par {@link openSseStream} (ou `this.renderSse()` dans un
+ * contrôleur), jamais par `new` : l'ouverture écrit les en-têtes, et un flux
+ * sans en-têtes ne se rattrape pas.
+ */
+export declare class SseStream {
+    #private;
+    /** Le flux est-il fermé — par le serveur (`close()`) ou par le client parti ? */
+    get closed(): boolean;
+    /**
+     * Envoie un événement.
+     *
+     * @param data - texte envoyé tel quel, ou valeur sérialisée en JSON ; un
+     *   texte de plusieurs lignes part en autant de champs `data:`.
+     * @param options - type (`event`) et identifiant (`id`) de l'événement.
+     * @returns rien quand l'écriture est acceptée ; une promesse réglée au
+     *   `drain` quand le client lit moins vite qu'on écrit — l'attendre borne la
+     *   mémoire du serveur. Sans effet une fois le flux fermé.
+     * @throws TypeError quand `event` ou `id` contient une fin de ligne.
+     * @throws RangeError quand l'événement dépasse `maxEventBytes`.
+     */
+    send(data: unknown, options?: ISseSendOptions): Promise<void> | undefined;
+    /**
+     * Envoie un commentaire — ignoré par le client, utile pour garder une
+     * connexion vivante ou marquer le flux à la lecture.
+     *
+     * @returns comme {@link send}.
+     */
+    comment(text?: string): Promise<void> | undefined;
+    /**
+     * Impose au client un délai de reconnexion (champ `retry:`).
+     *
+     * @param ms - délai en millisecondes, entier positif.
+     * @returns comme {@link send}.
+     * @throws RangeError quand `ms` n'est pas un entier entre 0 et 2^31-1.
+     */
+    retry(ms: number): Promise<void> | undefined;
+    /**
+     * Appelle `listener` à la fermeture du flux, quelle qu'en soit la cause.
+     *
+     * L'écouteur est lié au contexte asynchrone de la requête au moment de
+     * l'enregistrement : la fermeture par le client part de la SOCKET, hors de
+     * la bulle de la requête, et un `RequestContext.get()` y rendrait `undefined`.
+     * Un flux déjà fermé appelle l'écouteur au tour suivant.
+     */
+    onClose(listener: () => void): void;
+    /**
+     * Ferme le flux et termine la requête. Idempotent.
+     *
+     * @returns la fin de la requête (hooks `onClose` du contexte compris).
+     */
+    close(): Promise<void> | undefined;
+}
+/**
+ * Le client accepte-t-il un flux d'événements ? Lit l'en-tête `Accept`.
+ *
+ * Un même `POST` répond en JSON ou en flux selon ce que demande le client
+ * (porte MCP) : c'est cette fonction qui tranche, et elle seule. Une plage
+ * `q=0` est un REFUS explicite (RFC 9110 §12.4.2) ; `*\/*` ne suffit pas — un
+ * client qui ne nomme pas le flux ne sait pas le lire.
+ *
+ * @param accept - valeur de l'en-tête `Accept`, absente ou multiple.
+ * @returns `true` quand `text/event-stream` est nommé avec un poids non nul.
+ */
+export declare function acceptsEventStream(accept: string | string[] | undefined): boolean;
+/**
+ * Ouvre un flux d'événements sur la réponse d'un contexte HTTP.
+ *
+ * Sauve la session d'abord — ses cookies partent avec les en-têtes, qu'on ne
+ * pourra plus toucher —, puis écrit les en-têtes du flux et désarme le délai
+ * d'inactivité de la requête.
+ *
+ * @param context - le contexte de la requête, pas encore répondu.
+ * @param options - battement de cœur, délai `retry:` initial.
+ * @returns le flux ouvert, ou sa promesse quand une session est à sauver.
+ * @throws HttpError 500 quand la réponse est déjà partie.
+ * @throws HttpError 429 quand l'IP du client a déjà tous ses flux et sockets
+ *   (`wsMaxConnectionsPerIp`) — refusé AVANT d'écrire quoi que ce soit.
+ * @throws RangeError quand un délai n'est ni `false` ni un entier entre 1 et
+ *   2^31-1, ou que `maxEventBytes` n'est pas un entier positif.
+ */
+export declare function openSseStream(context: HttpContext, options?: ISseStreamOptions): SseStream | Promise<SseStream>;

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

@@ -22,6 +22,22 @@ declare class Parser {
     protected ended(): Promise<void>;
     parse(): Promise<this>;
 }
+/**
+ * Corps d'un type que le framework ne décode pas : livré TEL QU'IL EST REÇU,
+ * jamais remplacé par un objet vide qui mentirait.
+ *
+ * - `text/*` → une chaîne, décodée au `charset` du `Content-Type` (UTF-8 par
+ *   défaut) — comme une trame texte RFC 6455 ;
+ * - tout autre type, et un corps sans `Content-Type` (RFC 9110 §8.3 : supposé
+ *   `application/octet-stream`) → les OCTETS : le `Buffer` déjà assemblé dans
+ *   `request.data`, sans copie — donc un `Uint8Array`, le type d'octets que
+ *   la socket livrera aussi (#618). Un même schéma passe par les deux portes.
+ *
+ * Un corps VIDE laisse `body` tel quel : une requête sans charge ne change pas.
+ */
+declare class ParserRaw extends Parser {
+    parse(): Promise<this>;
+}
 declare class ParserQs extends Parser {
     parserOptions: QS.IParseOptions;
     charset: BufferEncoding;
@@ -35,7 +51,7 @@ declare class ParserXml extends Parser {
     parse(): Promise<this>;
 }
 /**
- * Parse un corps `application/json` (ou `*+json`) en objet → `queryPost`
+ * Parse un corps `application/json` (ou `*+json`) en objet → `body`
  * (source lue par le décorateur `@Body`). Reprend le rôle de l'ancien plugin
  * `json` de formidable, supprimé avec le passage à busboy (multipart seul).
  * Lenient : un corps JSON malformé est ignoré (pas de throw — `parse()` est
@@ -62,4 +78,4 @@ type AcceptEntry = {
     [key: string]: RegExp | number | string | undefined;
 };
 declare const acceptParser: (acc?: string) => AcceptEntry[];
-export { Parser, ParserXml, ParserQs, ParserJson, acceptParser };
+export { Parser, ParserRaw, ParserXml, ParserQs, ParserJson, acceptParser };

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

@@ -5,10 +5,10 @@ import { HTTPMethod } from "../Context.js";
 declare class Http2Request extends HttpRequest {
     request: http2.Http2ServerRequest;
     constructor(request: http2.Http2ServerRequest, context: HttpContext);
+    /** `:authority`, sinon `Host` — cf `requestAuthority` (RFC 9113 §8.3.1). */
     getHost(): string | undefined;
     getUserAgent(): string | undefined;
     getMethod(): HTTPMethod;
     getRawTarget(): string | undefined;
-    protected resolveScheme(): string;
 }
 export default Http2Request;

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

@@ -3,6 +3,11 @@ import type { MaybePromise } from "nodefony";
 import http from "node:http";
 import HttpContext from "../http/HttpContext.js";
 import HttpResponse from "../http/Response.js";
+/** Ce que la fusion lit d'une réponse Node : ses en-têtes posés, nom par nom. */
+interface IHeaderSource {
+    getHeaderNames(): string[];
+    getHeader(name: string): http.OutgoingHttpHeader | undefined;
+}
 /**
  * Compose les en-têtes d'une réponse HTTP/2 : ceux posés sur la réponse, puis
  * ceux passés à `writeHead`, qui gagnent.
@@ -13,12 +18,17 @@ import HttpResponse from "../http/Response.js";
  * (`ERR_HTTP2_HEADER_SINGLE_VALUE`), soit une 500 sur tout média servi en
  * HTTP/2. HTTP/2 n'a de toute façon que des noms en minuscules (RFC 9113 §8.2.1).
  *
+ * Les en-têtes posés se lisent nom par nom (`getHeaderNames`, déjà en
+ * minuscules) : `getHeaders()` les recopiait d'abord dans un objet sans
+ * prototype, avant cette fusion — 3,8 µs par réponse pour 12 en-têtes,
+ * contre 1,1 µs en une passe.
+ *
  * @param statusMessage - message de statut, recopié en `x-status-message`
- * @param current - en-têtes déjà posés sur la réponse
+ * @param current - la réponse Node qui porte les en-têtes déjà posés
  * @param extra - en-têtes passés à `writeHead` (objet, ou liste plate clé/valeur)
  * @returns les en-têtes à transmettre à `respond()`
  */
-export declare function mergeResponseHeaders(statusMessage: string, current: http.OutgoingHttpHeaders, extra?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): http.OutgoingHttpHeaders;
+export declare function mergeResponseHeaders(statusMessage: string, current: IHeaderSource, extra?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): http.OutgoingHttpHeaders;
 declare class Http2Response extends HttpResponse {
     statusCode: number;
     stream: http2.ServerHttp2Stream | null;
@@ -27,9 +37,9 @@ declare class Http2Response extends HttpResponse {
     isHeaderSent(): boolean;
     writeHead(statusCode?: number, headers?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): void;
     /**
-     * Écrit le corps sur le flux HTTP/2. Synchrone pour une redirection, un flux
-     * fermé ou le repli HTTP/1 ; une promesse quand le corps est écrit sur le
-     * flux, réglée par le rappel d'écriture (#505).
+     * Écrit le corps sur le flux HTTP/2 et, pour une réponse unique, le termine
+     * d'un seul `end(corps)`. Synchrone, sauf en streaming (`flush()`) : une
+     * promesse réglée par le rappel d'écriture, la contre-pression (#505).
      *
      * @returns la réponse, ou sa promesse.
      */

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

@@ -0,0 +1,20 @@
+import http2 from "node:http2";
+import type http from "node:http";
+/**
+ * La réponse a-t-elle été TERMINÉE par le serveur ? Règle UNIQUE, pour HTTP/1.1
+ * comme pour HTTP/2 — l'écouteur `close` du noyau (client parti → 499) et le
+ * timeout par flux de `HttpContext` l'appellent tous deux.
+ *
+ * Sous HTTP/2, la réponse Nodefony écrit et termine le FLUX
+ * (`stream.respond`/`stream.end`), jamais la réponse de compatibilité : son
+ * `writableEnded` reste à `false` alors que le client a tout reçu. Mais le
+ * flux seul ne suffit pas non plus : un flux ANNULÉ par le pair (RST_STREAM
+ * avant la fin) a LUI AUSSI `writableEnded === true`, Node terminant le côté
+ * écriture en le détruisant. `aborted` sépare la fin posée par le serveur de la
+ * coupure du client — même sémantique que `writableEnded` en HTTP/1.1.
+ *
+ * @param response - la réponse Node de la requête
+ * @returns `true` si le serveur a terminé la réponse (ou son flux HTTP/2) ;
+ *   `false` s'il ne l'a pas terminée, client parti compris
+ */
+export declare function responseEnded(response: http.ServerResponse | http2.Http2ServerResponse): boolean;