@nodefony/http 10.0.0-alpha.8 → 10.0.0-beta.1

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;
 }

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

@@ -0,0 +1,12 @@
+/**
+ * Message lisible d'une valeur LEVÉE (`catch`, rejet) dont on ignore le type.
+ *
+ * Même rendu que `String(value)` pour une `Error` (son `message`) et pour les
+ * primitives ; un objet quelconque rend son étiquette (`[object Object]`) sans
+ * appeler un `toString` arbitraire ni sérialiser son contenu — ce texte peut
+ * finir dans une réponse ou un journal, il ne doit rien divulguer.
+ *
+ * @param value - la valeur levée.
+ * @returns un texte court, jamais vide pour une valeur définie.
+ */
+export declare function thrownMessage(value: unknown): string;

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

@@ -38,13 +38,13 @@ export interface ProfileQuery {
     /** Requête (SQL ou commande NoSQL), tronquée si volumineuse. */
     sql: string;
     /** Début relatif (`performance.now()`) — même horloge que les phases. */
-    startMs?: number;
+    startMs?: number | undefined;
     /** Durée d'exécution en ms. */
     durationMs: number;
     /** Lignes affectées/retournées, si connu. */
-    rows?: number;
+    rows?: number | undefined;
     /** Connecteur émetteur (`drizzle`, `mongoose`…). */
-    connector?: string;
+    connector?: string | undefined;
 }
 /**
  * Traversée du firewall par cette requête — **ce qui était possible** (la zone :
@@ -97,9 +97,9 @@ export interface ProfileEntry {
     error: string | null;
     phases: ProfilePhase[];
     /** Requêtes ORM (SEAM futur — `undefined` tant qu'aucun adapter ne pushe). */
-    queries?: ProfileQuery[];
+    queries?: ProfileQuery[] | undefined;
     /** Traversée du firewall — `undefined` si la requête n'a croisé aucune zone. */
-    security?: ProfileSecurity;
+    security?: ProfileSecurity | undefined;
 }
 /** Résumé léger d'un profil pour la liste `recent` (sans les phases). */
 export interface ProfileSummary {
@@ -115,49 +115,49 @@ export interface ProfileSummary {
 }
 /** Forme structurelle minimale lue sur un `Context` (lecture défensive). */
 interface ProfilableContext {
-    requestId?: string;
-    type?: string;
-    scheme?: string;
-    method?: string | null;
-    url?: string;
-    remoteAddress?: string | null;
-    traceparent?: string | null;
+    requestId?: string | undefined;
+    type?: string | undefined;
+    scheme?: string | undefined;
+    method?: string | null | undefined;
+    url?: string | undefined;
+    remoteAddress?: string | null | undefined;
+    traceparent?: string | null | undefined;
     error?: {
         message?: string;
-    } | null;
+    } | null | undefined;
     response?: {
         statusCode?: number;
-    } | null;
+    } | null | undefined;
     phases?: ReadonlyArray<{
         name: string;
         startMs: number;
-        durationMs?: number;
-    }>;
+        durationMs?: number | undefined;
+    }> | undefined;
     resolver?: {
         route?: {
-            name?: string;
+            name?: string | undefined;
         } | null;
         controller?: {
-            name?: string;
-        } | null;
-        actionName?: string;
-    } | null;
+            name?: string | undefined;
+        } | null | undefined;
+        actionName?: string | undefined;
+    } | null | undefined;
     /**
      * Buffer de requêtes ORM rempli pendant la requête (dev-only). Même tableau
      * que la payload ALS — les adapters ORM y poussent via `RequestContext`.
      * `null`/absent hors profiling.
      */
-    profilerQueries?: ProfileQuery[] | null;
+    profilerQueries?: ProfileQuery[] | null | undefined;
     /**
      * Zone firewall capturée (`SecuredArea`, posée par `Firewall.isSecure`). Lue
      * en structurel : `@nodefony/http` ne peut pas importer `@nodefony/security`.
      */
     security?: {
-        name?: string;
-        security?: boolean;
-        mode?: string;
-        authenticators?: readonly string[];
-    } | null;
+        name?: string | undefined;
+        security?: boolean | undefined;
+        mode?: string | undefined;
+        authenticators?: readonly string[] | undefined;
+    } | null | undefined;
     /** Décision du firewall sur cette requête (dev-only, cf `ISecurityTrace`). */
     securityTrace?: {
         authenticator: string | null;
@@ -165,7 +165,7 @@ interface ProfilableContext {
         reason: string | null;
         user: string | null;
         roles: string[] | null;
-    } | null;
+    } | null | undefined;
 }
 export declare class Profiler {
     private readonly _buf;

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

@@ -0,0 +1,20 @@
+import type { ServersConfig } from "nodefony";
+/**
+ * Rétrécit la section `servers` de la configuration du kernel (lue dans le sac
+ * de config non typé du cœur) en {@link ServersConfig}, sans propager `any`.
+ *
+ * Seule lecture de `kernel.options.servers` dans `@nodefony/http` : les serveurs
+ * et le `HttpKernel` passent tous par ici.
+ *
+ * @param servers - la valeur brute de `kernel.options.servers`.
+ * @returns la section typée, ou `undefined` si elle est absente ou n'est pas un objet.
+ */
+export declare function asServersConfig(servers: unknown): ServersConfig | undefined;
+/**
+ * Port DEMANDÉ pour un serveur (`servers.<type>.port`), ou `undefined` si le
+ * serveur est désactivé, absent, ou sans port numérique.
+ *
+ * @param servers - section `servers` déjà rétrécie ({@link asServersConfig}).
+ * @param type - le serveur visé.
+ */
+export declare function configuredServerPort(servers: ServersConfig | undefined, type: "http" | "https"): number | undefined;