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

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

@@ -11,11 +11,13 @@ import type { IncomingHttpHeaders, IncomingMessage } from "node:http";
 import Ws from "ws";
 import httpServer from "../service/servers/server-http.js";
 import httpsServer from "../service/servers/server-https.js";
+import h2cServer from "../service/servers/server-h2c.js";
 import websocketServer from "../service/servers/server-websocket.js";
 import websocketSecureServer from "../service/servers/server-websocket-secure.js";
 import Statics from "./servers/server-static.js";
 import type ReverseProxy from "./reverse-proxy.js";
 import WebsocketContext from "../src/context/websocket/WebsocketContext.js";
+import type { IUpgradeAdmission } from "../src/servers/upgradeDispatch.js";
 import HttpContext from "../src/context/http/HttpContext.js";
 import Context, { HTTPMethod, WebSocketState } from "../src/context/Context.js";
 import Certicates from "./certificates.js";
@@ -42,9 +44,8 @@ export type httpRequest = http.IncomingMessage | http2.Http2ServerRequest;
 export type httpResponse = http.ServerResponse | http2.Http2ServerResponse;
 export { responseEnded } from "../src/context/responseEnded.js";
 export type ContextType = WebsocketContext | HttpContext | Context;
-export type ServerType = "http" | "https" | "http2" | "http3" | "websocket" | "websocket-secure";
-export type responseTimeoutType = "http" | "https" | "http2" | "http3";
-export type SchemeType = "http" | "https" | "ws" | "wss";
+export type { ServerType, SchemeType } from "../interfaces/IContext.js";
+import type { ServerType, SchemeType } from "../interfaces/IContext.js";
 export interface WsMetaData {
     type?: "message" | "handshake" | undefined;
     state?: WebSocketState | undefined;
@@ -119,8 +120,6 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     responseTimeout: {
         http: number;
         https: number;
-        http2: number;
-        http3: number;
     };
     closeTimeOutWs: {
         ws: number;
@@ -383,7 +382,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      *   pipeline.
      */
     private dispatchHttpRequest;
-    initServers(): Promise<(httpServer | httpsServer | websocketServer | websocketSecureServer)[]>;
+    initServers(): Promise<(httpServer | httpsServer | h2cServer | websocketServer | websocketSecureServer)[]>;
     /**
      * Publie les ports EFFECTIFS du runtime (state file), une fois l'écoute établie.
      *
@@ -542,7 +541,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @throws (rejet) le refus du pare-feu, après `onAuthFailure`.
      */
     private runFirewall;
-    createWebsocketContext(scope: Scope, req: IncomingMessage, ws: Ws, type: ServerType): WebsocketContext;
+    createWebsocketContext(scope: Scope, req: IncomingMessage, ws: Ws | null, type: ServerType): WebsocketContext;
     /**
      * Teardown d'une connexion WS à sa fermeture : signal d'abandon, hooks
      * post-réponse, persistance de la session, puis libération du scope.
@@ -550,10 +549,47 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * écouteur d'événement synchrone, qui n'attend rien).
      */
     private finishWebsocket;
-    onWebsocketRequest(ws: Ws, req: IncomingMessage, type: ServerType): Promise<unknown>;
-    handleWebsocket(scope: Scope, ws: Ws, req: IncomingMessage, type: ServerType): Promise<unknown>;
+    /**
+     * Point d'entrée d'un upgrade vers une route WebSocket de Nodefony, appelé
+     * par le répartiteur d'upgrade AVANT le `101` (#596) : rien ne s'ouvre tant
+     * que le pipeline n'a pas dit oui.
+     *
+     * Les bornes par IP passent en premier, avant tout scope, ALS ou pipeline
+     * (symétrie avec le 429 HTTP et avec le proxy inverse) : le vrai vecteur DoS
+     * est d'accumuler des sockets ouvertes. La place est rendue à la fermeture du
+     * socket du client — même règle que pour un tunnel relayé.
+     *
+     * @param req - requête d'upgrade
+     * @param admission - le verdict à rendre : accepter (`101`) ou refuser (HTTP)
+     * @param type - serveur qui a reçu l'upgrade
+     * @returns la promesse du traitement de la connexion
+     */
+    onWebsocketUpgrade(req: IncomingMessage, admission: IUpgradeAdmission, type: ServerType): Promise<unknown>;
+    /**
+     * Pipeline d'un handshake WebSocket, dans la bulle ALS de la connexion :
+     * jugement (`onConnect`), pare-feu, gardes de l'action — PUIS seulement
+     * l'acceptation, la socket et l'action de handshake. Tout refus antérieur à
+     * l'acceptation part en statut HTTP (`onError` → `refuseHandshake`).
+     *
+     * @param scope - scope DI de la connexion
+     * @param req - requête d'upgrade
+     * @param admission - le verdict à rendre
+     * @param type - serveur qui a reçu l'upgrade
+     * @returns ce que rend l'action de handshake
+     */
+    handleWebsocket(scope: Scope, req: IncomingMessage, admission: IUpgradeAdmission, type: ServerType): Promise<unknown>;
     private releaseOrphanWsScope;
-    onConnect(context: WebsocketContext | null, error?: unknown): Promise<Ws | number>;
+    /**
+     * Juge un handshake WebSocket AVANT son acceptation : hôte, origine,
+     * `beforeResolve`, contrôleur (protocole négocié), session. N'ouvre rien —
+     * l'acceptation n'a lieu qu'après le pare-feu et les gardes de l'action
+     * (cf {@link handleWebsocket}).
+     *
+     * @param context - contexte du handshake, encore sans socket
+     * @param error - erreur levée à la construction du contexte, relancée telle quelle
+     * @throws la première erreur du jugement — rendue en statut HTTP par `onError`
+     */
+    onConnect(context: WebsocketContext | null, error?: unknown): Promise<void>;
     checkValidDomain(context: ContextType): number;
     isValidDomain(context: ContextType): boolean;
     /**

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

@@ -12,3 +12,19 @@ import type { Duplex } from "node:stream";
  * @param socket - flux client brut (l'event `clientError` fournit un `Duplex`).
  */
 export declare function handleClientError(error: NodeJS.ErrnoException, socket: Duplex): void;
+/**
+ * Gère l'event `sessionError` d'un serveur HTTP/2 (h2c ou TLS) : un pair PARTI
+ * se tait, toute autre erreur est rapportée.
+ *
+ * Une session réinitialisée par le pair n'a rien à diagnostiquer. C'est la
+ * signature d'une sonde de port — `nodefony status`, `doctor`, le superviseur
+ * de développement, la sonde `tcpSocket` d'un orchestrateur — qui se connecte
+ * puis ferme sans lire le `SETTINGS` que le serveur envoie dès l'ouverture : le
+ * système ferme alors par un RST plutôt qu'un FIN, et Node lève `ECONNRESET`.
+ * La rapporter imprimait une pile entière par sonde. La règle « client parti »
+ * est celle des frames WebSocket ({@link isPeerGoneError}), pas une copie.
+ *
+ * @param error - erreur de session émise par `node:http2`
+ * @param report - rapporte une erreur réelle, à la sévérité choisie par le serveur
+ */
+export declare function handleSessionError(error: Error, report: (error: Error) => void): void;

package/dist/types/nodefony/service/servers/server-h2c.d.ts

@@ -0,0 +1,51 @@
+import { Service, type Module, FamilyType } from "nodefony";
+import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
+import http2 from "node:http2";
+import { AddressInfo } from "node:net";
+import { type IDrainTerminator } from "./serverShutdown.js";
+import type { IHttpConfig } from "../../config/config.js";
+import type { DefaultOptionsService } from "nodefony";
+/**
+ * Serveur HTTP/2 en clair (h2c, connaissance préalable — RFC 9113 §3.3), sur un
+ * port DÉDIÉ (`servers.h2c`, 5153 par défaut), pour un proxy inverse qui parle
+ * HTTP/2 à ses amonts.
+ *
+ * Il partage le chemin HTTP/2 du 5152 — même `onHttpRequest`, mêmes limites
+ * anti-DoS (`http2ServerLimits`), même drain par GOAWAY — sans TLS : `serverType`
+ * vaut `"http"`, le schéma vient du transport ou d'un proxy de confiance, jamais
+ * du pseudo-en-tête `:scheme`. Le protocole du saut (`"h2c"`) se constate sur la
+ * requête (`transport.ts#alpnProtocolOf`).
+ *
+ * Hors de son périmètre, délibérément : HTTP/1.1 (refusé par la préface HTTP/2 —
+ * sondes et clients HTTP/1.1 restent sur le port HTTP), WebSocket (aucun CONNECT
+ * étendu, RFC 8441 : un proxy route `Upgrade: websocket` vers le port HTTP) et la
+ * bascule `Upgrade: h2c` (retirée par RFC 9113 §3.1).
+ */
+declare class ServerH2c extends Service {
+    private readonly httpKernel;
+    options: IHttpConfig["http"] & DefaultOptionsService;
+    module: Module<IHttpConfig>;
+    server: http2.Http2Server | null;
+    httpTerminator: IDrainTerminator | null;
+    port: number;
+    protocol: ProtocolType;
+    ready: boolean;
+    type: ServerType;
+    domain: string | null;
+    scheme: SchemeType;
+    address: string | null;
+    family: FamilyType | null;
+    active: boolean;
+    infos: AddressInfo | null;
+    constructor(module: Module<IHttpConfig>, httpKernel: HttpKernel);
+    /**
+     * Crée et met en écoute le serveur h2c.
+     *
+     * @returns le serveur à l'écoute
+     * @throws BootConfigurationError si `servers.h2c.port` est celui du serveur
+     *   HTTP ou HTTPS — un port partagé n'est pas un conflit à contourner
+     */
+    createServer(): Promise<http2.Http2Server>;
+    showBanner(): void;
+}
+export default ServerH2c;

package/dist/types/nodefony/service/servers/server-http.d.ts

@@ -1,9 +1,9 @@
-import { Service, Module, FamilyType } from "nodefony";
+import { Service, type Module, FamilyType } from "nodefony";
 import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
 import http from "node:http";
 import http2 from "node:http2";
 import { AddressInfo } from "node:net";
-import { HttpTerminator } from "./serverShutdown.js";
+import { type IDrainTerminator } from "./serverShutdown.js";
 import type { IHttpConfig } from "../../config/config.js";
 import type { DefaultOptionsService } from "nodefony";
 declare class ServerHttp extends Service {
@@ -11,7 +11,7 @@ declare class ServerHttp extends Service {
     options: IHttpConfig["http"] & DefaultOptionsService;
     module: Module;
     server: http.Server | http2.Http2Server | null;
-    httpTerminator: HttpTerminator | null;
+    httpTerminator: IDrainTerminator | null;
     port: number;
     protocol: ProtocolType;
     ready: boolean;

package/dist/types/nodefony/service/servers/server-https.d.ts

@@ -1,15 +1,15 @@
-import { Service, Module, FamilyType } from "nodefony";
+import { Service, type Module, FamilyType } from "nodefony";
 import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
 import https from "node:https";
 import http2 from "node:http2";
-import { HttpTerminator } from "./serverShutdown.js";
+import { type IDrainTerminator } from "./serverShutdown.js";
 import { AddressInfo } from "node:net";
 import type { IHttpConfig } from "../../config/config.js";
 import type { DefaultOptionsService } from "nodefony";
 declare class ServerHttps extends Service {
     private readonly httpKernel;
     options: IHttpConfig["https"] & DefaultOptionsService;
-    httpTerminator: HttpTerminator | null;
+    httpTerminator: IDrainTerminator | null;
     module: Module;
     server: https.Server | http2.Http2SecureServer | null;
     port: number;
@@ -23,7 +23,7 @@ declare class ServerHttps extends Service {
     active: boolean;
     infos: AddressInfo | null;
     constructor(module: Module, httpKernel: HttpKernel);
-    terminator(): HttpTerminator;
+    terminator(): IDrainTerminator;
     setPort(): number;
     createServer(): Promise<https.Server | http2.Http2SecureServer>;
     createServerH2(): Promise<http2.Http2SecureServer>;

package/dist/types/nodefony/service/servers/server-websocket-secure.d.ts

@@ -1,10 +1,9 @@
-import Ws, { WebSocketServer } from "ws";
+import { WebSocketServer } from "ws";
 import { Service, Module, FamilyType } from "nodefony";
 import type { DefaultOptionsService } from "nodefony";
 import type { IHttpConfig } from "../../config/config.js";
 import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
 import { AddressInfo } from "node:net";
-import type { IncomingMessage } from "node:http";
 import httpsServers from "./server-https.js";
 declare class WebsocketSecure extends Service {
     #private;
@@ -26,7 +25,6 @@ declare class WebsocketSecure extends Service {
     constructor(module: Module, httpKernel: HttpKernel);
     setPort(): number;
     createServer(serverHttps: httpsServers): Promise<WebSocketServer>;
-    onConnection(ws: Ws, req: IncomingMessage): void;
     terminate(): Promise<boolean>;
     showBanner(): void;
 }

package/dist/types/nodefony/service/servers/server-websocket.d.ts

@@ -1,10 +1,9 @@
-import Ws, { WebSocketServer } from "ws";
+import { WebSocketServer } from "ws";
 import { Service, Module, FamilyType } from "nodefony";
 import type { DefaultOptionsService } from "nodefony";
 import type { IHttpConfig } from "../../config/config.js";
 import HttpKernel, { ProtocolType, ServerType, SchemeType } from "../http-kernel.js";
 import { AddressInfo } from "node:net";
-import type { IncomingMessage } from "node:http";
 import httpServer from "./server-http.js";
 declare class Websocket extends Service {
     #private;
@@ -26,7 +25,6 @@ declare class Websocket extends Service {
     constructor(module: Module, httpKernel: HttpKernel);
     setPort(): number;
     createServer(serverHttp: httpServer): Promise<WebSocketServer>;
-    onConnection(ws: Ws, req: IncomingMessage): void;
     terminate(): Promise<boolean>;
     showBanner(): void;
 }

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

@@ -1,27 +1,41 @@
-import { HttpTerminator } from "http-terminator";
 import type { Server as HttpServer } from "node:http";
 import type { Server as HttpsServer } from "node:https";
-import type { Http2SecureServer } from "node:http2";
+import type { Http2SecureServer, Http2Server } from "node:http2";
+/** Serveur que `createDrainTerminator` sait drainer. */
+export type DrainableServer = HttpServer | HttpsServer | Http2Server | Http2SecureServer;
+/** Arrêt gracieux d'un serveur, rendu par `createDrainTerminator`. */
+export interface IDrainTerminator {
+    /**
+     * Draine puis ferme le serveur ; idempotent (le deuxième appel rend la même promesse).
+     *
+     * @returns une promesse résolue quand toutes les connexions sont fermées
+     */
+    terminate(): Promise<void>;
+}
 /**
- * Fabrique le terminator de drain graceful d'un serveur HTTP/HTTPS/HTTP2.
+ * Fabrique l'arrêt gracieux d'un serveur HTTP/1.1, HTTPS, HTTP/2 sur TLS ou h2c.
  *
- * Au `terminate()` (shutdown SIGTERM/docker stop) : les requêtes in-flight se
- * terminent (header `connection: close` injecté sur les réponses en cours), les
- * sockets idle sont fermées immédiatement, et tout ce qui reste après
- * `shutdownTimeout` ms est détruit de force. Le terminator appelle lui-même
- * `server.close()` — ne pas le rappeler derrière.
+ * Au `terminate()` (SIGTERM, `docker stop`), le serveur cesse d'accepter, puis :
+ * - **HTTP/2** : chaque session reçoit un GOAWAY (`session.close()`) — les flux
+ *   en vol se terminent, les nouveaux sont refusés, et le client sait qu'il doit
+ *   rouvrir ailleurs au lieu de constater une coupure ;
+ * - **HTTP/1.1** : la réponse en vol part avec `Connection: close`, la socket
+ *   inactive est fermée tout de suite, une requête qui arrive encore sur une
+ *   socket gardée ouverte reçoit aussi `Connection: close`.
+ *
+ * Ce qui reste après `shutdownTimeout` ms est détruit. `server.close()` est
+ * appelé ici : ne pas le rappeler derrière.
  *
  * ⚠️ Les sockets WebSocket upgradées (sans réponse HTTP en cours) sont détruites
- * SANS frame Close par le terminator → les serveurs WS doivent fermer leurs
- * clients (close 1001) AVANT ce drain. Garanti par l'ordre des listeners
- * `onTerminate` : WS/WSS s'attachent en `prependOnceListener`, les serveurs
- * HTTP en `once`.
+ * SANS frame Close → les serveurs WS doivent fermer leurs clients (close 1001)
+ * AVANT ce drain. Garanti par l'ordre des listeners `onTerminate` : WS/WSS
+ * s'attachent en `prependOnceListener`, les serveurs HTTP en `once`.
  *
- * @param server - serveur Node à drainer (créé, pas forcément listening)
+ * @param server - serveur Node à drainer, créé AVANT son `listen` (le suivi des
+ *   connexions commence ici)
  * @param shutdownTimeout - délai de drain en ms avant destruction forcée
- * @returns le terminator à invoquer au shutdown
+ * @returns l'arrêt à invoquer au shutdown
  */
-export declare function createDrainTerminator(server: HttpServer | HttpsServer | Http2SecureServer, shutdownTimeout?: number): HttpTerminator;
+export declare function createDrainTerminator(server: DrainableServer, shutdownTimeout?: number): IDrainTerminator;
 /** Drain par défaut (ms) — même valeur que le défaut Zod `servers.*.shutdownTimeout`. */
 export declare const DEFAULT_SHUTDOWN_TIMEOUT = 5000;
-export type { HttpTerminator };

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

@@ -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";
@@ -50,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;
@@ -128,7 +137,7 @@ declare class Context extends Service implements IContextInterface {
     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
@@ -183,8 +192,8 @@ declare class Context extends Service implements IContextInterface {
     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/http/HttpContext.d.ts

@@ -53,7 +53,7 @@ declare class HttpContext extends Context implements IHttpContextInterface {
     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

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

@@ -50,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/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/transport.d.ts

@@ -0,0 +1,53 @@
+import type { AlpnProtocol, ProtocolName, ServerType } from "../../interfaces/IContext.js";
+/**
+ * Famille du protocole traité par un contexte, déduite du serveur qui l'a
+ * reçu. Règle UNIQUE : `Context` la pose à la construction.
+ *
+ * @param serverType - identité du serveur (`http`, `https`, `ws`, `wss`)
+ * @returns `"websocket"` pour `ws`/`wss`, `"http"` sinon
+ */
+export declare function protocolNameOf(serverType: ServerType): ProtocolName;
+/**
+ * Ce que la détection lit d'une requête Node, et rien d'autre : `http.IncomingMessage`
+ * (HTTP/1.1) et `http2.Http2ServerRequest` (h2, h2c) le satisfont par leur forme, sans
+ * transtypage — et une doublure de test s'écrit en littéral.
+ */
+export interface IAlpnSource {
+    readonly httpVersionMajor: number;
+    readonly stream?: {
+        readonly session?: {
+            readonly alpnProtocol?: string | undefined;
+        } | undefined;
+    } | undefined;
+}
+/**
+ * Protocole du saut qui a porté cette requête jusqu'au processus, au sens du
+ * registre IANA des identifiants ALPN. Règle UNIQUE : `HttpContext` la lit pour
+ * choisir ses classes de requête et de réponse.
+ *
+ * La valeur se CONSTATE sur la requête, elle ne se déduit pas du serveur : un
+ * même serveur TLS reçoit HTTP/1.1 et h2 (`allowHTTP1`). Pour h2, c'est la
+ * session de Node qui tranche — `Http2Session.alpnProtocol` vaut `"h2c"` sur
+ * une session en clair, l'ALPN négocié (`"h2"`) sur une session TLS.
+ *
+ * @param request - la requête Node reçue par le serveur
+ * @returns `"http/1.1"`, `"h2"` ou `"h2c"`
+ */
+export declare function alpnProtocolOf(request: IAlpnSource): AlpnProtocol;
+/**
+ * Autorité (hôte et port) d'une requête, HTTP/1.1 comme HTTP/2. Règle UNIQUE
+ * des lecteurs du serveur.
+ *
+ * `:authority` d'abord, puis `Host` (RFC 9113 §8.3.1). Le repli n'est pas un
+ * confort : un intermédiaire qui convertit une requête HTTP/1.1 de forme origine
+ * (`GET /chemin`) en HTTP/2 ne DOIT PAS fabriquer `:authority` — il garde
+ * `Host`. C'est ce que fait HAProxy `proto h2` vers un port h2c : sans ce repli,
+ * l'hôte est introuvable et la requête part en 421.
+ *
+ * @param headers - en-têtes de la requête Node (`IncomingMessage` ou `Http2ServerRequest`).
+ * @returns l'autorité, ou `undefined` si la requête n'en porte aucune.
+ */
+export declare function requestAuthority(headers: {
+    host?: string | undefined;
+    ":authority"?: string | undefined;
+}): string | undefined;