@nodefony/http 10.0.0-alpha.9 → 10.0.0-beta.2

package/dist/types/nodefony/service/x509.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Fabrique et lecture de certificats X.509 par `node:crypto` seul — aucune
+ * dépendance tierce.
+ *
+ * `node:crypto` sait LIRE un certificat (`X509Certificate`) et SIGNER, pas
+ * en FABRIQUER un : ce module encode le `TBSCertificate` en DER (RFC 5280
+ * §4.1), le signe avec `crypto.sign`, puis l'assemble. Seul le sous-ensemble
+ * nécessaire à un certificat serveur auto-signé est couvert. Les fonctions
+ * sont PURES (aucun disque, aucun kernel) : elles s'éprouvent sans décor.
+ *
+ * Pourquoi pas node-forge : sa vérification de signature RSA PKCS#1 v1.5
+ * accepte des signatures forgées (GHSA-86w9-cpqp-85rv), sans aucune version
+ * corrigée. Nous ne vérifions aucune signature, mais `npm audit` signale le
+ * paquet pour tous ceux qui installent `@nodefony/http`.
+ */
+import { type KeyObject } from "node:crypto";
+/** Hachages de signature que le builder sait déclarer. */
+export type X509Hash = "sha1" | "sha256" | "sha384" | "sha512";
+/**
+ * Attribut d'un nom distinctif (sujet / émetteur). Forme reprise de la config
+ * historique : `name` long (`commonName`), `shortName` (`CN`) ou `type` (OID
+ * pointé) — le premier présent fait foi.
+ */
+export interface ICertificateAttribute {
+    name?: string | undefined;
+    shortName?: string | undefined;
+    type?: string | undefined;
+    value?: string | undefined;
+}
+/** Ce qu'il faut pour fabriquer un certificat serveur auto-signé. */
+export interface ISelfSignedSpec {
+    privateKey: KeyObject;
+    publicKey: KeyObject;
+    /** Numéro de série en hexadécimal (entier positif, RFC 5280 §4.1.2.2). */
+    serialHex: string;
+    notBefore: Date;
+    notAfter: Date;
+    /** Sujet ET émetteur (auto-signé). Vide = nom vide, SAN alors critique. */
+    attributes: ICertificateAttribute[];
+    dns: string[];
+    ip: string[];
+    /** `sha1` n'est accepté que pour fabriquer des témoins de test. */
+    hash: X509Hash;
+}
+/** OID de la signature RSA-SHA1, que le service régénère. */
+export declare const SHA1_WITH_RSA_OID: string;
+/** Octets d'une adresse IP pour un SAN `iPAddress` (4 ou 16 octets). */
+export declare function ipAddressBytes(ip: string): Buffer;
+/**
+ * OID de l'algorithme de signature d'un certificat DER (champ
+ * `signatureAlgorithm`, RFC 5280 §4.1.1.2). Lu dans le DER plutôt que par
+ * `X509Certificate.signatureAlgorithmOid`, absent des Node du plancher.
+ *
+ * @param der - certificat encodé DER (`X509Certificate.raw`)
+ * @throws Si le DER n'a pas la forme d'un certificat
+ */
+export declare function signatureAlgorithmOid(der: Buffer): string;
+/** Nom lisible d'un OID de signature (l'OID lui-même s'il est inconnu). */
+export declare function signatureAlgorithmName(oid: string): string;
+/**
+ * Entrées DNS et IP d'un `subjectAltName` tel que le rend
+ * `X509Certificate.subjectAltName` (`DNS:a, IP Address:1.2.3.4`).
+ */
+export declare function parseSubjectAltName(value: string | undefined): {
+    dns: string[];
+    ip: string[];
+};
+/**
+ * Valeur d'un champ d'un nom distinctif tel que le rend
+ * `X509Certificate.subject` / `.issuer` (une ligne `CLÉ=valeur` par champ).
+ */
+export declare function distinguishedNameField(dn: string, key: string): string | null;
+/**
+ * Fabrique un certificat serveur auto-signé et le rend en PEM.
+ *
+ * Contenu : version 3, sujet = émetteur, `basicConstraints` cA=false,
+ * `keyUsage` (digitalSignature, keyEncipherment — critique),
+ * `extKeyUsage` (serverAuth, clientAuth), `subjectAltName` (critique si le
+ * sujet est vide, RFC 5280 §4.2.1.6) et `subjectKeyIdentifier` (SHA-1 de la
+ * clé publique, méthode 1 de RFC 5280 §4.2.1.2).
+ *
+ * @param spec - clés, série, validité, noms et hachage
+ * @returns le certificat encodé PEM
+ * @throws Si un attribut ou une adresse IP est invalide
+ */
+export declare function createSelfSignedCertificate(spec: ISelfSignedSpec): Promise<string>;

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

@@ -1,6 +1,7 @@
 import { Container, Service, Severity, Msgid, Message, Pci, Pdu, KernelEventsType, nodefonyError, Scope } from "nodefony";
 import type { IProfilerQuery } from "nodefony";
-import type { Resolver, Router } from "@nodefony/framework";
+import type { IRouteResolver, IRequestRouter } from "../../interfaces/IRouting.js";
+import type { ISecurityZone } from "../../interfaces/ISecurity.js";
 import { WebSocketServer } from "ws";
 import http2 from "node:http2";
 import http from "node:http";
@@ -16,7 +17,6 @@ import { URL } from "node:url";
 import Session from "../session/session.js";
 import Cookie from "../cookies/cookie.js";
 import HttpError from "../errors/httpError.js";
-import { SecuredArea } from "@nodefony/security";
 /**
  * Bascule runtime du gate des logs d'events lifecycle. Réservé HORS hot path :
  * tests et futur « Audit à chaud » (fenêtre bornée prod→verbeux, auto-revert
@@ -41,7 +41,7 @@ export declare function nextCspNonce(): string;
 declare class Context extends Service implements IContextInterface {
     #private;
     secure: boolean;
-    security?: SecuredArea | null;
+    security?: ISecurityZone | null | undefined;
     cleaned: boolean;
     isControlledAccess: boolean;
     validDomain: boolean;
@@ -52,7 +52,7 @@ declare class Context extends Service implements IContextInterface {
     sessionStarting: boolean;
     domain: string;
     type: ServerType;
-    server?: WebSocketServer | http.Server | https.Server | http2.Http2SecureServer | null;
+    server?: WebSocketServer | http.Server | https.Server | http2.Http2SecureServer | null | undefined;
     httpKernel: HttpKernel | null;
     request: contextRequest | null;
     response: contextResponse | null;
@@ -64,7 +64,7 @@ declare class Context extends Service implements IContextInterface {
     set originUrl(value: URL | undefined | null);
     cookies: Cookies;
     error: Error | HttpError | nodefonyError | null | undefined;
-    sessionService?: SessionsService | null;
+    sessionService?: SessionsService | null | undefined;
     session: Session | null | undefined;
     cookieSession: Cookie | null | undefined;
     user: unknown;
@@ -79,8 +79,8 @@ declare class Context extends Service implements IContextInterface {
      */
     protected resolveIsHtml(): boolean;
     crossDomain: boolean;
-    router: Router | null;
-    resolver: Resolver | null;
+    router: IRequestRouter | null;
+    resolver: IRouteResolver | null;
     /**
      * Intent de session de la route courante (posé par le Resolver depuis
      * `@UseSession` / paramètre `@Session`). Pilote le point d'activation unique
@@ -110,8 +110,8 @@ declare class Context extends Service implements IContextInterface {
     profilerQueries: IProfilerQuery[] | null;
     profiling: boolean;
     securityTrace: ISecurityTrace | null;
-    private _timingEnabled;
-    private _timingVerbose;
+    private readonly _timingEnabled;
+    private readonly _timingVerbose;
     readonly phases: PhaseTiming[];
     private _phaseIndex;
     private _afterResponseFns;
@@ -145,7 +145,18 @@ declare class Context extends Service implements IContextInterface {
     phaseStart(name: PhaseName): void;
     phaseEnd(name: PhaseName): void;
     onAfterResponse(fn: AfterResponseHandler): void;
-    _runAfterResponse(): Promise<void>;
+    /**
+     * Exécute les hooks `onAfterResponse`, une seule fois, dans l'ordre
+     * d'enregistrement ; un hook qui lève est journalisé sans arrêter les suivants.
+     *
+     * @returns `undefined` quand aucun hook n'est enregistré (le cas nominal) ou
+     *   qu'ils ont déjà tourné : rien à attendre, le démontage continue sans
+     *   suspension. Une `Promise` sinon, réglée quand le dernier hook a fini — elle
+     *   ne rejette jamais.
+     */
+    _runAfterResponse(): Promise<void> | undefined;
+    /** Boucle des hooks `onAfterResponse` — séquentielle, erreurs journalisées. */
+    private runAfterResponseHooks;
     get signal(): AbortSignal;
     _abortIfPending(reason?: string): void;
     log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;

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

@@ -32,11 +32,11 @@ export interface ForwardedElement {
 /** Résolution canonique unifiée des en-têtes forwarded. */
 export interface ResolvedProxy {
     /** Scheme effectif côté client (`http` / `https`), ou `undefined` si indéterminé. */
-    proto?: string;
+    proto?: string | undefined;
     /** Host effectif côté client (Host d'origine), ou `undefined` si non fourni. */
-    host?: string;
+    host?: string | undefined;
     /** Chaîne `for` brute (node identifiers, gauche→droite) — pour log/metadata interne. */
-    forwardedFor?: string;
+    forwardedFor?: string | undefined;
     /** IP cliente réelle, résolue from-right (toujours fiable, jamais l'IP forgée). */
     clientIp: string | null;
     /** Le header standard `Forwarded` a-t-il été la source (sinon `X-Forwarded-*`) ? */

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

@@ -1,7 +1,7 @@
 import { ServerType, SchemeType } from "../../../service/http-kernel.js";
 import Context, { HTTPMethod } from "../Context.js";
 import { Container, Scope } from "nodefony";
-import { Csrf } from "@nodefony/security";
+import type { MaybePromise } from "nodefony";
 import HttpRequest from "./Request.js";
 import HttpResponse from "./Response.js";
 import Http2Request from "../http2/Request.js";
@@ -20,28 +20,26 @@ import uploadService from "../../../service/upload/upload-service.js";
  * (logs, prédicat « derrière un proxy »).
  */
 export interface ProxyType {
-    proxyServer?: string;
-    proxyProto?: string;
-    proxyScheme?: SchemeType;
-    proxyPort?: string;
-    proxyFor?: string;
-    proxyHost?: string;
-    proxyUri?: string;
-    proxyRealIp?: string;
-    proxyVia?: string;
+    proxyServer?: string | undefined;
+    proxyProto?: string | undefined;
+    proxyScheme?: SchemeType | undefined;
+    proxyPort?: string | undefined;
+    proxyFor?: string | undefined;
+    proxyHost?: string | undefined;
+    proxyUri?: string | undefined;
+    proxyRealIp?: string | undefined;
+    proxyVia?: string | undefined;
 }
 export type HttpRequestType = Http2Request | HttpRequest;
 export type HttpRsponseType = Http2Response | HttpResponse;
 import type { IHttpContext as IHttpContextInterface } from "../../../interfaces/IContext.js";
 declare class HttpContext extends Context implements IHttpContextInterface {
-    #private;
     proxy: ProxyType | null;
     isRedirect: boolean;
     sended: boolean;
     request: HttpRequestType;
     response: HttpRsponseType;
     uploadService: uploadService | null;
-    csrf?: Csrf;
     constructor(container: Container | Scope, request: http.IncomingMessage | http2.Http2ServerRequest, response: http.ServerResponse | http2.Http2ServerResponse, type: ServerType);
     /**
      * URL d'origine effective, construite À LA DEMANDE (1ʳᵉ lecture, puis
@@ -59,15 +57,74 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      */
     _onTimeout(): void;
     setScheme(): SchemeType;
-    handle(): Promise<this>;
+    /**
+     * Sert la requête : délai de réponse, hooks `onRequest`, puis l'action
+     * résolue et son rendu (`resolver.callController()`).
+     *
+     * Pas `async` : synchrone quand l'action et son rendu le sont, rien n'y est
+     * alors attendu (#505).
+     *
+     * @returns ce que rend `callController()` — le résultat du rendu, pas le
+     *   contexte (comportement historique, conservé) —, ou sa promesse. Sur une
+     *   redirection déjà posée : le contexte, une fois l'envoi fait.
+     * @throws HttpError 404, de façon SYNCHRONE, quand aucune route ne résout.
+     */
+    handle(): MaybePromise<this>;
     setTimeout(): void;
-    render(chunk: unknown, encoding?: BufferEncoding, status?: string | number, headers?: Record<string, string | number>): Promise<Http2Response | HttpResponse>;
+    /**
+     * 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).
+     *
+     * @returns la réponse, ou sa promesse.
+     * @throws de façon SYNCHRONE ce que lèvent la sérialisation ou l'envoi.
+     */
+    render(chunk: unknown, encoding?: BufferEncoding, status?: string | number, headers?: Record<string, string | number>): MaybePromise<Http2Response | HttpResponse>;
     end(): Promise<Http2Response | HttpResponse>;
-    send(chunk?: unknown, encoding?: BufferEncoding): Promise<Http2Response | HttpResponse>;
+    /**
+     * Envoie la réponse : session sauvée, hook `onSend`, en-têtes, corps, puis
+     * fin de la réponse.
+     *
+     * Synchrone dans le cas nominal — aucune session ouverte, aucun écouteur
+     * `onSend`, réponse unique : rien n'y est à attendre (#505). Une promesse
+     * seulement quand une étape attend réellement (écriture du store de session,
+     * hook asynchrone, streaming chunké, flux HTTP/2).
+     *
+     * @param chunk - le corps ; absent, le corps déjà posé sur la réponse.
+     * @param encoding - l'encodage d'un corps texte.
+     * @returns la réponse, ou sa promesse.
+     * @throws de façon SYNCHRONE `Response Already sended` quand la réponse est
+     *   déjà partie, et ce que lève une étape synchrone de l'envoi.
+     */
+    send(chunk?: unknown, encoding?: BufferEncoding): MaybePromise<Http2Response | HttpResponse>;
+    /**
+     * Le travail de {@link send}, journalisé en ERROR quand il échoue — de façon
+     * synchrone ou par rejet, selon l'étape qui échoue.
+     */
+    private doSend;
+    /** Session, puis hook `onSend`, puis en-têtes et corps — chacun attendu seulement s'il attend. */
+    private sendSteps;
+    /** Hook `onSend` (attendu seulement s'il a un écouteur), puis en-têtes et corps. */
+    private emitAndWrite;
+    /** En-têtes, puis corps — ou la seule fin de réponse pour une redirection. */
+    private writeHeadAndBody;
     writeHead(statusCode?: number, headers?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): void;
-    write(chunk: unknown, encoding?: BufferEncoding, _flush?: boolean): Promise<Http2Response | HttpResponse>;
-    flush(chunk: unknown, encoding: BufferEncoding): Promise<HttpResponse>;
-    close(): Promise<Http2Response | HttpResponse>;
+    /**
+     * Écrit le corps, puis termine la requête ({@link close}). Synchrone pour une
+     * réponse unique (#505).
+     *
+     * @returns la réponse, ou sa promesse quand l'écriture attend.
+     */
+    write(chunk: unknown, encoding?: BufferEncoding, _flush?: boolean): MaybePromise<Http2Response | HttpResponse>;
+    flush(chunk: unknown, encoding: BufferEncoding): MaybePromise<HttpResponse>;
+    /**
+     * Termine la requête : hook `onClose`, puis fin de la réponse si l'envoi ne
+     * l'a pas déjà faite. Synchrone sans écouteur `onClose` (#505).
+     *
+     * @returns la réponse, ou sa promesse quand le hook attend.
+     */
+    close(): MaybePromise<Http2Response | HttpResponse>;
+    /** 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;
     redirectHttps(status?: number | string, headers?: Record<string, string | number>): HttpResponse;
     redirectHttp(status?: number | string, headers?: Record<string, string | number>): HttpResponse;

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

@@ -39,7 +39,7 @@ declare class HttpRequest {
     host: string | undefined;
     method: HTTPMethod;
     contentType: string | null;
-    rawContentType: Record<string, string>;
+    rawContentType: Record<string, string | undefined>;
     domain: string;
     remoteAddress: string | null | undefined;
     hostname: string;
@@ -116,7 +116,37 @@ declare class HttpRequest {
      * `body` dans tout le framework, celui de l'écosystème et d'`IAdminRequest`.
      */
     private fireRequestEnd;
-    initialize(): Promise<unknown>;
+    /**
+     * Lit le corps de la requête, s'il y en a un, puis émet `onRequestEnd`.
+     *
+     * Le contrat de retour dit ce qui reste à ATTENDRE :
+     * - `undefined` — la méthode ne porte pas de corps (GET, HEAD, OPTIONS…) et
+     *   aucun écouteur `onRequestEnd` ne rend de promesse : tout est fait, de
+     *   façon SYNCHRONE ;
+     * - une `Promise` — le corps arrive du socket (POST, PUT, PATCH, DELETE), ou
+     *   un écouteur `onRequestEnd` est à attendre. Sa valeur n'est consommée par
+     *   personne : elle ne sert qu'au séquençage.
+     *
+     * L'appelant n'attend donc que ce qui attend vraiment
+     * (`const pending = request.initialize(); if (pending) await pending;`) : un
+     * `await` inconditionnel reportait le pipeline d'une micro-tâche, et la
+     * chaîne de promesses coûtait ~6 évènements asynchrones à un GET qui n'avait
+     * rien à lire (#505).
+     *
+     * Ne lève jamais de façon synchrone : un corps refusé (413) ou illisible rompt
+     * la promesse rendue, comme avant.
+     *
+     * @returns `undefined` quand tout est fait, sinon la promesse à attendre.
+     */
+    initialize(): Promise<unknown> | undefined;
+    /**
+     * Fin d'une requête SANS corps à lire : la marque terminée et émet
+     * `onRequestEnd`. Synchrone — ne rend une promesse que lorsqu'un écouteur
+     * `onRequestEnd` est à attendre, ou quand l'émission lève (celle d'`onError`).
+     *
+     * @returns `undefined` quand tout est fait, sinon la promesse à attendre.
+     */
+    private endWithoutBody;
     /**
      * B1 — Pré-contrôle de taille du corps via l'en-tête `Content-Length` :
      * rejette en 413 (RFC 9110 §15.5.14 « Content Too Large ») AVANT toute lecture
@@ -126,6 +156,13 @@ declare class HttpRequest {
      *
      * @throws {HttpError} 413 si `Content-Length` dépasse `maxBodySize`.
      */
+    /**
+     * Lit le plafond du corps et les limites d'envoi tels que les voit CETTE
+     * requête : la configuration http, surchargée par le calque que la requête a
+     * pu poser avant la lecture du corps (`overlayConfig`, #494). Hors pipeline
+     * (aucun scope ouvert), la configuration du module telle quelle.
+     */
+    private readBodyLimits;
     private enforceBodyLimit;
     parseRequest(): Promise<ParserType | null>;
     /**

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

@@ -2,6 +2,7 @@ import http, { OutgoingHttpHeaders } from "node:http";
 import http2 from "node:http2";
 import HttpContext from "../http/HttpContext.js";
 import { Pci, Pdu, Message, Severity, Msgid } from "nodefony";
+import type { MaybePromise } from "nodefony";
 import Cookie from "../../cookies/cookie.js";
 declare class HttpResponse {
     #private;
@@ -11,10 +12,9 @@ declare class HttpResponse {
     statusMessage: string;
     flushing: boolean;
     encoding: BufferEncoding;
-    body: Buffer | null;
     contentType: string;
     headers: http.OutgoingHttpHeaders;
-    timeout?: number;
+    timeout?: number | undefined;
     cookies: Record<string, Cookie>;
     constructor(response: http.ServerResponse | http2.Http2ServerResponse, context: HttpContext);
     /**
@@ -24,6 +24,20 @@ declare class HttpResponse {
      * l'ancienne pose au constructeur, sans le ping-pong set/remove/re-set.
      */
     protected ensureContentTypeHeader(): void;
+    /**
+     * Corps de la réponse en octets. Un corps posé en texte n'est encodé qu'à la
+     * première lecture de cette propriété — l'envoi, lui, écrit le texte tel quel.
+     */
+    get body(): Buffer | null;
+    set body(value: Buffer | null);
+    /**
+     * Corps tel qu'il part sur le fil : le texte s'il n'a jamais été encodé, sinon
+     * les octets — vide légal si rien n'a été posé (`write(null)` jetterait
+     * ERR_STREAM_NULL_VALUES).
+     */
+    protected get payload(): string | Buffer;
+    /** Encodage à passer avec {@link payload} (ignoré par Node pour des octets). */
+    protected get payloadEncoding(): BufferEncoding;
     clean(): void;
     isHeaderSent(): boolean;
     isHtml(): boolean;
@@ -50,15 +64,41 @@ declare class HttpResponse {
     };
     getStatusCode(): number;
     getStatusMessage(code?: number | string): string;
-    setBody(ele: unknown, encoding?: BufferEncoding | undefined): Buffer;
+    /**
+     * Pose le corps de la réponse : texte gardé tel quel, octets copiés sur leur
+     * seule fenêtre, tout autre valeur sérialisée en JSON.
+     *
+     * @param ele - corps à envoyer.
+     * @param encoding - encodage d'un corps texte (défaut : `this.encoding`).
+     */
+    setBody(ele: unknown, encoding?: BufferEncoding): void;
     setLength(body?: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer): number;
     writeHead(statusCode?: number, headers?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): void;
     addTrailers(headers: http.OutgoingHttpHeaders): void;
-    flush(chunk: unknown, encoding: BufferEncoding): Promise<HttpResponse>;
-    send(chunk?: unknown, encoding?: BufferEncoding, _flush?: boolean): Promise<HttpResponse>;
-    write(chunk?: unknown, encoding?: BufferEncoding): Promise<HttpResponse>;
+    flush(chunk: unknown, encoding: BufferEncoding): MaybePromise<HttpResponse>;
+    /**
+     * Écrit le corps sur le flux et, pour une réponse unique, la termine.
+     *
+     * Synchrone pour une réponse unique ou une redirection : `end(corps)` est un
+     * appel synchrone de Node, rien n'y est à attendre (#505). Une promesse
+     * seulement en streaming chunké (`flush()`), réglée quand le flux accepte
+     * l'écriture suivante (`drain`) — c'est la contre-pression.
+     *
+     * @param chunk - le corps (posé par `setBody`) ; absent, le corps déjà posé.
+     * @param encoding - l'encodage d'un corps texte.
+     * @returns la réponse, ou sa promesse en streaming chunké.
+     * @throws de façon SYNCHRONE quand la réponse Node n'existe plus.
+     */
+    send(chunk?: unknown, encoding?: BufferEncoding, _flush?: boolean): MaybePromise<HttpResponse>;
+    write(chunk?: unknown, encoding?: BufferEncoding): MaybePromise<HttpResponse>;
     writeContinue(): void | undefined;
-    end(chunk?: string | Buffer, encoding?: BufferEncoding): Promise<http.ServerResponse | http2.ServerHttp2Stream>;
+    /**
+     * Termine la réponse Node — un appel synchrone, rien n'y est à attendre (#505).
+     *
+     * @returns le flux terminé (valeur de `ServerResponse.end`).
+     * @throws de façon SYNCHRONE quand la réponse Node n'existe plus.
+     */
+    end(chunk?: string | Buffer, encoding?: BufferEncoding): MaybePromise<http.ServerResponse | http2.ServerHttp2Stream>;
     getHeader(name: string): string | number | string[] | undefined;
     hasHeader(name: string): boolean;
     getHeaders(): http.OutgoingHttpHeaders;

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

@@ -58,7 +58,7 @@ declare class ParserJson extends Parser {
 type AcceptEntry = {
     type: RegExp;
     subtype: RegExp;
-    q?: number;
+    q?: number | undefined;
     [key: string]: RegExp | number | string | undefined;
 };
 declare const acceptParser: (acc?: string) => AcceptEntry[];

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

@@ -1,7 +1,24 @@
 import http2 from "node:http2";
+import type { MaybePromise } from "nodefony";
 import http from "node:http";
 import HttpContext from "../http/HttpContext.js";
 import HttpResponse from "../http/Response.js";
+/**
+ * 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.
+ *
+ * Les clés sont ramenées en MINUSCULES : `getHeaders()` rend `content-type`,
+ * un contrôleur passe `Content-Type` — fusionnées telles quelles, les deux
+ * clés partaient ensemble et `stream.respond()` refusait la réponse
+ * (`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).
+ *
+ * @param statusMessage - message de statut, recopié en `x-status-message`
+ * @param current - en-têtes déjà posés sur la réponse
+ * @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;
 declare class Http2Response extends HttpResponse {
     statusCode: number;
     stream: http2.ServerHttp2Stream | null;
@@ -9,8 +26,21 @@ declare class Http2Response extends HttpResponse {
     constructor(response: http2.Http2ServerResponse, context: HttpContext);
     isHeaderSent(): boolean;
     writeHead(statusCode?: number, headers?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): void;
-    send(chunk?: unknown, encoding?: BufferEncoding, _flush?: boolean): Promise<Http2Response>;
-    end(chunk?: string | Buffer, encoding?: BufferEncoding): Promise<http.ServerResponse | http2.ServerHttp2Stream>;
+    /**
+     * É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).
+     *
+     * @returns la réponse, ou sa promesse.
+     */
+    send(chunk?: unknown, encoding?: BufferEncoding, _flush?: boolean): MaybePromise<Http2Response>;
+    /**
+     * Termine le flux HTTP/2 (ou la réponse de repli) — synchrone (#505).
+     *
+     * @returns le flux terminé.
+     * @throws de façon SYNCHRONE ce que lève la fin du flux.
+     */
+    end(chunk?: string | Buffer, encoding?: BufferEncoding): MaybePromise<http.ServerResponse | http2.ServerHttp2Stream>;
     getStatusMessage(code?: number | string): string;
     getStatus(): {
         code: number;

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

@@ -11,13 +11,13 @@ export type { IWsCookie } from "../../../interfaces/ICookie.js";
  */
 export declare function isPeerGoneError(error: unknown): boolean;
 declare class WebsocketResponse {
-    private context;
+    private readonly context;
     statusCode: number;
     body: Buffer | null;
     encoding: BufferEncoding;
     connection: Ws | null;
     statusMessage: string;
-    webSocketVersion?: number;
+    webSocketVersion?: number | undefined;
     cookies: Record<string, Cookie>;
     constructor(connection: Ws | null, context: WebsocketContext);
     log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): import("nodefony").Pdu | undefined;
@@ -30,8 +30,8 @@ declare class WebsocketResponse {
      */
     private logFirstDrop;
     setBody(ele: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): Buffer<ArrayBufferLike> | null;
-    drop(reasonCode: number, description: string): void;
-    close(reasonCode: number, description: string): void;
+    drop(reasonCode?: number, description?: string): void;
+    close(reasonCode?: number, description?: string): void;
     getStatus(): {
         code: number;
         message: string;

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

@@ -40,7 +40,7 @@ export default class WebsocketContext extends Context implements IWebsocketConte
     #private;
     request: WsIncomingMessage | null;
     response: WebsocketResponse | null;
-    acceptedProtocol?: string;
+    acceptedProtocol?: string | undefined;
     port: number | string;
     rejected: boolean;
     teardownWired: boolean;
@@ -59,7 +59,7 @@ export default class WebsocketContext extends Context implements IWebsocketConte
     handle(data?: unknown[]): Promise<this>;
     render(chunk: unknown, encoding?: BufferEncoding): Promise<WebsocketResponse>;
     send(data?: string | Buffer | null, encoding?: BufferEncoding): Promise<WebsocketResponse>;
-    broadcast(data?: string | Buffer | null, encoding?: BufferEncoding): void | null;
+    broadcast(data?: string | Buffer | null, encoding?: BufferEncoding): null | undefined;
     /**
      * Logge le CONTENU d'un message WS (corrélé `requestId` via l'override `log`),
      * gaté hors prod et borné — le Suivi de requête (Studio) le surface alors par
@@ -121,5 +121,14 @@ export default class WebsocketContext extends Context implements IWebsocketConte
     clean(): void;
     close(reasonCode: number | undefined | null, description: string): void;
     drop(reasonCode: number, description: string): void;
+    /**
+     * Relit `rejected` sans le rétrécissement de TypeScript : après la garde
+     * d'entrée de {@link handle}, le compilateur le croit `false` pour toute la
+     * méthode, alors qu'un écouteur `onRequest` (pare-feu) ou le `match` du
+     * resolver peut avoir rejeté entre-temps.
+     *
+     * @returns `true` si la connexion a été rejetée.
+     */
+    private isRejected;
     reject(code: number | string | undefined, message?: string): void;
 }

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

@@ -0,0 +1,21 @@
+/**
+ * Taille maximale, en octets UTF-8, de la raison d'une trame Close (RFC 6455
+ * §5.5 : charge d'une trame de contrôle ≤ 125 octets, dont 2 pour le code).
+ */
+export declare const MAX_WS_CLOSE_REASON_BYTES = 123;
+/**
+ * Borne la raison d'une fermeture WebSocket à 123 octets UTF-8, coupée sur une
+ * frontière de caractère.
+ *
+ * `ws.close(code, reason)` LÈVE une `RangeError` au-delà de 123 octets, et la
+ * connexion n'est alors PAS fermée : jusqu'en `ws` 8.21 elle restait en
+ * `CLOSING` sans trame Close ni minuterie — hors de portée de toute garde
+ * `readyState === OPEN` et du heartbeat, donc ouverte jusqu'à la mort TCP ;
+ * depuis 8.22 elle reste `OPEN`. Or la raison porte souvent un message
+ * d'erreur, dont rien ne borne la longueur.
+ *
+ * @param reason - raison candidate (message d'erreur, libellé…)
+ * @returns la raison telle quelle si elle tient, sinon tronquée et terminée
+ *          par « … » ; chaîne vide si elle n'est pas une chaîne.
+ */
+export declare function toWsCloseReason(reason: string | undefined | null): string;

package/dist/types/nodefony/src/cookies/cookie.d.ts

@@ -24,17 +24,17 @@ declare function cookiesParser(context: ContextType): void;
 declare class Cookie implements ICookieInterface {
     options: CookieOptionsType;
     name: string;
-    signed?: boolean;
+    signed?: boolean | undefined;
     value: unknown;
-    originalMaxAge?: number;
-    expires?: Date;
-    maxAge?: number;
-    path?: string;
+    originalMaxAge?: number | undefined;
+    expires?: Date | undefined;
+    maxAge?: number | undefined;
+    path?: string | undefined;
     domain: string | undefined;
-    httpOnly?: boolean;
-    secure?: boolean;
-    sameSite?: SameSiteType;
-    priority?: string;
+    httpOnly?: boolean | undefined;
+    secure?: boolean | undefined;
+    sameSite?: SameSiteType | undefined;
+    priority?: string | undefined;
     constructor(cookies: Cookie);
     constructor(name: string, value: unknown, options?: CookieOptionsType);
     clearCookie(): void;

package/dist/types/nodefony/src/errors/httpError.d.ts

@@ -2,13 +2,13 @@ import { nodefonyError as NodefonyError } from "nodefony";
 import { ContextType } from "../../service/http-kernel.js";
 import { HttpRequestType, HttpRsponseType } from "../context/http/HttpContext.js";
 declare class HttpError extends NodefonyError {
-    context?: ContextType;
-    response?: HttpRsponseType;
-    request?: HttpRequestType;
-    url?: string;
-    controller?: string;
-    action?: string;
-    jsonResponse?: string;
+    context?: ContextType | undefined;
+    response?: HttpRsponseType | undefined;
+    request?: HttpRequestType | undefined;
+    url?: string | undefined;
+    controller?: string | undefined;
+    action?: string | undefined;
+    jsonResponse?: string | undefined;
     constructor(message?: unknown, code?: number, context?: ContextType);
     toString(): string;
 }