@nodefony/http 10.0.0-alpha.1

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

@@ -0,0 +1,195 @@
+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 { WebSocketServer } from "ws";
+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 HttpResponse from "./http/Response.js";
+import Http2Response from "./http2/Response.js";
+import WebsocketResponse from "./websocket/Response.js";
+import HttpRequest from "./http/Request.js";
+import Http2Request from "./http2/Request.js";
+import SessionsService from "../../service/sessions/sessions-service.js";
+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
+ * serveur) — le canal Studio `nodefony:syslog` retrouve alors les events sans
+ * redémarrage. `null` → re-résolution depuis l'env au prochain event.
+ */
+export declare function setLifecycleEventLogging(value: boolean | null): void;
+export type WebSocketState = "handshake" | "connected" | "closed" | "error" | "message" | null;
+export type contextRequest = HttpRequest | Http2Request | http.IncomingMessage | null;
+export type contextResponse = HttpResponse | Http2Response | WebsocketResponse | null;
+export type HTTPMethod = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE" | "PATCH" | "WEBSOCKET";
+export type Cookies = Record<string, Cookie>;
+import type { IContext as IContextInterface, PhaseTiming, PhaseName, AfterResponseHandler, ISecurityTrace } from "../../interfaces/IContext.js";
+import type { SessionIntent } from "../../interfaces/ISession.js";
+/**
+ * Rend le prochain nonce CSP (16 octets CSPRNG, base64) depuis le pool amorti.
+ *
+ * Exporté UNIQUEMENT pour le banc d'épuisement du pool (unicité à travers
+ * plusieurs refills) — le code produit passe par `context.cspNonce`.
+ */
+export declare function nextCspNonce(): string;
+declare class Context extends Service implements IContextInterface {
+    #private;
+    secure: boolean;
+    security?: SecuredArea | null;
+    cleaned: boolean;
+    isControlledAccess: boolean;
+    validDomain: boolean;
+    finished: boolean;
+    pushAllowed: boolean;
+    requestEnded: boolean;
+    requested: boolean;
+    sessionStarting: boolean;
+    domain: string;
+    type: ServerType;
+    server?: WebSocketServer | http.Server | https.Server | http2.Http2SecureServer | null;
+    httpKernel: HttpKernel | null;
+    request: contextRequest | null;
+    response: contextResponse | null;
+    url: string;
+    method: HTTPMethod | null;
+    remoteAddress: string | undefined | null;
+    protected _originUrl: URL | undefined | null;
+    get originUrl(): URL | undefined | null;
+    set originUrl(value: URL | undefined | null);
+    cookies: Cookies;
+    error: Error | HttpError | nodefonyError | null | undefined;
+    sessionService?: SessionsService | null;
+    session: Session | null | undefined;
+    cookieSession: Cookie | null | undefined;
+    user: unknown;
+    waitAsync: boolean;
+    isJson: boolean;
+    protected _isHtml: boolean | null;
+    get isHtml(): boolean;
+    set isHtml(value: boolean);
+    /**
+     * Défaut paresseux d'{@link isHtml} — overridé par HttpContext (négociation
+     * `Accept`). Base et WS : jamais HTML.
+     */
+    protected resolveIsHtml(): boolean;
+    crossDomain: boolean;
+    router: Router | null;
+    resolver: Resolver | null;
+    /**
+     * Intent de session de la route courante (posé par le Resolver depuis
+     * `@UseSession` / paramètre `@Session`). Pilote le point d'activation unique
+     * (HTTP + WS). `null` = aucune session sauf cookie existant (reprise L1).
+     */
+    sessionIntent: SessionIntent | null;
+    /**
+     * Directives CSP additionnelles de la route courante (`@Csp`), posées par le
+     * Resolver au match. `null` = la route n'en déclare pas (cas courant) → le
+     * firewall compose le CSP standard (0 surcoût). Lu par `applySecurityHeaders`
+     * APRÈS le resolve. Forme `directive → sources` (compatible `CspFragment`).
+     */
+    cspDirectives: Record<string, readonly string[]> | null;
+    /**
+     * CSRF per-route (`@CsrfProtect`/`@CsrfExempt`), posés par le Resolver au match,
+     * lus par `Firewall.enforceCsrf` (post-resolve). `csrfProtect` exige le
+     * synchronizer token sur la mutation ; `csrfExempt` sort la route de la défense
+     * CSRF (auth conservée). `csrfToken` = token émis par le firewall (cookie lisible
+     * + ce champ) sur une requête sûre vers une route protégée, à surfacer côté vue.
+     */
+    csrfProtect: boolean;
+    csrfExempt: boolean;
+    csrfToken: string | null;
+    requestId: string;
+    get cspNonce(): string;
+    traceparent: string | null;
+    profilerQueries: IProfilerQuery[] | null;
+    profiling: boolean;
+    securityTrace: ISecurityTrace | null;
+    private _timingEnabled;
+    private _timingVerbose;
+    readonly phases: PhaseTiming[];
+    private _phaseIndex;
+    private _afterResponseFns;
+    private _afterResponseFired;
+    private _abortController;
+    metaData: Data;
+    scheme: SchemeType;
+    webSocketState: WebSocketState;
+    constructor(container: Container | Scope, type: ServerType);
+    /**
+     * Assemble l'enveloppe `metaData` de la requête (`nodefony.*` + `route`
+     * snapshot per-requête + overrides appelant). Délègue au builder monomorphe
+     * pur {@link buildMetaData} — pas de `extend(true, …)` (deep-clone + dispatch
+     * polymorphe inutiles : `this.metaData` est per-requête, jamais partagé). `this`
+     * satisfait structurellement {@link IMetaDataSource} (kernel/request/scheme/
+     * requestId/resolver) → zéro alloc d'objet intermédiaire.
+     */
+    setMetaData(obj?: Record<string, unknown>): Data;
+    setScheme(): SchemeType;
+    /**
+     * Le timing est-il actif sur CETTE requête ? (dev/test par défaut, opt-out en
+     * production — cf constructeur.)
+     *
+     * Exposé pour que les appelants qui devraient **payer** pour mesurer (un
+     * `try/finally` autour d'une chaîne de promesses = une microtask de plus par
+     * requête) puissent garder leur chemin nominal INTACT quand la mesure est
+     * éteinte : `if (!ctx.timingEnabled) return fastPath()`. Les autres n'ont rien
+     * à tester — {@link phaseStart}/{@link phaseEnd} sont déjà des no-ops.
+     */
+    get timingEnabled(): boolean;
+    phaseStart(name: PhaseName): void;
+    phaseEnd(name: PhaseName): void;
+    onAfterResponse(fn: AfterResponseHandler): void;
+    _runAfterResponse(): Promise<void>;
+    get signal(): AbortSignal;
+    _abortIfPending(reason?: string): void;
+    log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;
+    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.
+     */
+    private logEvent;
+    fire(event: KernelEventsType, ...args: unknown[]): boolean;
+    emit(event: KernelEventsType, ...args: unknown[]): boolean;
+    emitAsync(event: KernelEventsType, ...args: unknown[]): Promise<unknown>;
+    fireAsync(event: KernelEventsType, ...args: unknown[]): Promise<unknown>;
+    logRequest(httpError?: Error | HttpError | nodefonyError | null): Pdu | undefined;
+    /**
+     * P3.7 — Émet au teardown un log DEBUG détaillant la durée de chaque phase du
+     * pipeline (`parse · action · firewall · …` + total). Opt-in via
+     * `kernel.options.timing.verbose`. Triple gate perf-first : `_timingVerbose`
+     * résolu 1× (false en prod/par défaut) → timing actif → phases non vides ;
+     * hors mode verbose, early-return AVANT toute allocation/`toFixed` (coût nul).
+     */
+    logPhasesVerbose(): void;
+    addRequestCookie(cookie: Cookie): Cookie;
+    getRequestCookies(name?: string): Cookies | Cookie | null;
+    setCookie(cookie: Cookie): void | Cookie;
+    getRequest(): contextRequest;
+    getResponse(): contextResponse;
+    isValidDomain(): boolean;
+    saveSession(): Promise<Session | null>;
+    hasSession(): boolean;
+    getCookieSession(name: string): Cookie | null;
+    /**
+     * Nom effectif du cookie de session pour CE transport. Sur TLS (https/wss) on
+     * applique le préfixe **`__Host-`** (RFC 6265bis §4.1.3 / OWASP : recommandé
+     * pour les identifiants de session — impose Secure + Path=/ + interdit Domain,
+     * anti session-fixation cross-subdomain). En clair (http/ws) le préfixe est
+     * omis (le navigateur le rejetterait sans Secure) → dégradation gracieuse,
+     * notamment derrière un proxy qui termine le TLS. Lecture **et** écriture du
+     * cookie passent par ce nom unique → cohérence de la reprise (L1).
+     */
+    getSessionCookieName(): string;
+    parseCookies(): void;
+    setContextJson(_encoding?: BufferEncoding): void;
+    setContextHtml(_encoding?: BufferEncoding): void;
+}
+export default Context;

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

@@ -0,0 +1,67 @@
+/**
+ * Matching de domaine (`Host`) — fonctions PURES, politique UNIQUE partagée par
+ * les deux étages de Nodefony :
+ *
+ * - **`trustedHosts` (kernel, sécu)** : barrière testée AVANT le routing. Quels
+ *   `Host` ce serveur accepte de traiter (anti Host-header injection). Host non
+ *   trusté → 401 (`HttpKernel.checkValidDomain`). Grossier, optionnel (en prod,
+ *   typiquement délégué au reverse-proxy via `trustedHosts: true`).
+ * - **`@Domain` (route, routing)** : restreint une route / un contrôleur à un
+ *   vhost. Source de vérité du « qui sert quoi ». Testé PENDANT le routing
+ *   (`Route.matchHostname`) → 403 si la route ne sert pas ce domaine.
+ *
+ * Politique de compilation (sûre, ancrée, ReDoS-free) :
+ * - string sans `*` → match EXACT ancré (`^...$`, le `.` est littéral).
+ * - string avec `*` → wildcard UN label (`*.example.com` → `^[^.]+\.example\.com$`,
+ *   RFC 6125 TLS-wildcard : matche `img.example.com`, pas `a.b.example.com` ni `example.com`).
+ * - `RegExp` → reprise telle quelle (l'auteur assume l'ancrage).
+ *
+ * Compilation faite UNE fois (boot / enregistrement de route) ; le test par
+ * requête est un simple `RegExp.test` sur une liste pré-compilée (zéro alloc hot-path).
+ */
+/** Un pattern de domaine : string (exact ou `*`-wildcard) ou `RegExp` (libre). */
+export type DomainPattern = string | RegExp;
+/**
+ * Valeur de configuration `http.trustedHosts` (barrière sécu avant routing) :
+ * - `false` / absent : défaut (domaine canonique + loopback en dev).
+ * - `true` : bypass total — tout `Host` passe (déploiement où un reverse-proxy
+ *   filtre déjà le `Host`, cf doctrine cloud-native).
+ * - `string` / `string[]` : patterns additionnels (exact ou `*`-wildcard).
+ */
+export type TrustedHostsConfig = boolean | DomainPattern | DomainPattern[];
+/**
+ * Compile UN pattern de domaine en `RegExp` selon la politique sûre.
+ *
+ * @param pattern - string (exact / `*`-wildcard) ou `RegExp` (reprise telle quelle).
+ * @returns une `RegExp` ancrée (pour les string) ou le `RegExp` fourni.
+ */
+export declare function compileDomainPattern(pattern: DomainPattern): RegExp;
+/**
+ * Compile une liste de patterns. Les string vides sont ignorées (un `^$` ne
+ * sert à rien et masque une coquille de config).
+ *
+ * @param patterns - un pattern ou un tableau de patterns.
+ * @returns liste de `RegExp` à tester contre le `Host` entrant.
+ */
+export declare function compileDomainPatterns(patterns: DomainPattern | DomainPattern[]): RegExp[];
+/**
+ * Construit la liste `RegExp` de la barrière `trustedHosts` (kernel, avant routing).
+ *
+ * Toujours : le domaine canonique (`kernel.domain`). En development : + loopback
+ * (`localhost`/`127.0.0.1`/`[::1]`) pour que l'URL tapée (nom OU IP) passe.
+ * `trustedHosts: true` → bypass total (un seul `/^.*$/`).
+ *
+ * @param domain - domaine canonique du serveur (`kernel.domain`).
+ * @param trusted - config `http.trustedHosts` (optionnelle).
+ * @param isDev - vrai en environnement `development` (ajoute le loopback).
+ * @returns liste de `RegExp` pour {@link isDomainAllowed}.
+ */
+export declare function compileTrustedHosts(domain: string, trusted: TrustedHostsConfig | undefined, isDev: boolean): RegExp[];
+/**
+ * Teste un `Host` entrant contre une liste de `RegExp` pré-compilée.
+ *
+ * @param regAlias - sortie de {@link compileTrustedHosts} ou {@link compileDomainPatterns}.
+ * @param domain - `Host` de la requête (`context.domain`, port déjà strippé).
+ * @returns `true` dès le premier match (court-circuit), `false` sinon.
+ */
+export declare function isDomainAllowed(regAlias: RegExp[], domain: string): boolean;

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

@@ -0,0 +1,95 @@
+import type { TrustProxyChecker } from "./trustProxy.js";
+/**
+ * Parsing et résolution **canonique** des en-têtes de transfert (forwarded),
+ * conforme **RFC 7239** (« Forwarded HTTP Extension ») et compatible avec les
+ * en-têtes `X-Forwarded-*` de-facto (non normalisés).
+ *
+ * Le header standard `Forwarded` est **prioritaire** ; les `X-Forwarded-*`
+ * servent de repli. Une **seule** résolution produit le scheme, le host et l'IP
+ * cliente effectifs (supprime la double source `x-forwarded-proto` /
+ * `x-forwarded-scheme`).
+ *
+ * ⚠️ Toujours appelé en aval d'un contrôle `trustProxy` (RFC 7239 §8.1) : ces
+ * en-têtes ne sont honorés que derrière un reverse-proxy de confiance, sinon ils
+ * sont forgeables (IP/scheme spoofing).
+ */
+/** Sous-ensemble des en-têtes lus (compatible `http`/`http2` IncomingHttpHeaders). */
+export type ForwardedHeaders = Record<string, string | string[] | undefined>;
+/**
+ * Un `forwarded-element` parsé (RFC 7239 §4) : un saut de la chaîne de proxy.
+ * Les paramètres inconnus (extensibilité §5.4) sont ignorés silencieusement.
+ */
+export interface ForwardedElement {
+    /** §5.1 — interface du proxy par laquelle la requête est entrée (node id). */
+    by?: string;
+    /** §5.2 — client à l'origine de la requête (node id, éventuellement obfusqué). */
+    for?: string;
+    /** §5.3 — Host original tel que reçu par le proxy. */
+    host?: string;
+    /** §5.4 — protocole employé par le client (`http` / `https`), normalisé en minuscules. */
+    proto?: string;
+}
+/** 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;
+    /** Host effectif côté client (Host d'origine), ou `undefined` si non fourni. */
+    host?: string;
+    /** Chaîne `for` brute (node identifiers, gauche→droite) — pour log/metadata interne. */
+    forwardedFor?: string;
+    /** 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-*`) ? */
+    fromStandard: boolean;
+}
+/**
+ * Parse le header `Forwarded` (RFC 7239 §4) en liste de `forwarded-element`,
+ * dans l'ordre **gauche→droite** (le plus à gauche = le plus proche du client).
+ *
+ * Grammaire honorée : `Forwarded = 1#forwarded-element`,
+ * `forwarded-element = [ forwarded-pair ] *( ";" [ forwarded-pair ] )`,
+ * `forwarded-pair = token "=" value`, `value = token / quoted-string`.
+ * Les noms de paramètres sont insensibles à la casse (§7.1) → normalisés.
+ *
+ * @param raw - valeur brute du header (string, ou string[] si répété), ou `undefined`.
+ * @returns les éléments parsés, ou `null` si le header est absent/vide.
+ */
+export declare function parseForwarded(raw: string | string[] | undefined): ForwardedElement[] | null;
+/**
+ * Extrait l'**IP nue** d'un node identifier RFC 7239 §6
+ * (`node = nodename [ ":" node-port ]`).
+ *
+ * - IPv6 entre crochets (`[2001:db8::1]`, éventuel `]:port`) → l'IPv6 sans crochets.
+ * - IPv4 (`192.0.2.43`, éventuel `:port`) → l'IPv4 sans le port.
+ * - `unknown` et identifiants obfusqués (`obfnode` commençant par `_`, §6.3) →
+ *   `null` : non comparables à une politique de confiance (barrière from-right).
+ *
+ * @param node - valeur d'un paramètre `for`/`by`, déjà déquotée.
+ * @returns l'IP exploitable, ou `null` si absente/obfusquée/illisible.
+ */
+export declare function forwardedNodeIp(node: string | undefined): string | null;
+/**
+ * Résout, en **une seule passe**, le scheme, le host et l'IP cliente effectifs à
+ * partir des en-têtes forwarded — header standard `Forwarded` (RFC 7239)
+ * **prioritaire**, repli sur les `X-Forwarded-*` de-facto.
+ *
+ * Le scheme/host effectifs sont pris sur l'élément le plus à GAUCHE (côté client) ;
+ * l'IP cliente est résolue **from-right** ({@link resolveFromRight}) en partant du
+ * socket réel, donc non spoofable. La priorité unique `Forwarded.proto` >
+ * `x-forwarded-proto` > `x-forwarded-scheme` supprime l'ancienne double source.
+ *
+ * À n'appeler que derrière un proxy de confiance (RFC 7239 §8.1) : la décision
+ * `isTrusted(socket)` est prise par l'appelant (lazy : pas d'allocation hors proxy).
+ *
+ * @param headers - en-têtes de la requête.
+ * @param socketAddress - `socket.remoteAddress` (connexion TCP réelle).
+ * @param checker - politique de confiance ({@link buildTrustProxy}).
+ * @returns la résolution canonique unifiée.
+ */
+export declare function resolveForwarded(headers: ForwardedHeaders, socketAddress: string | undefined | null, checker: TrustProxyChecker): ResolvedProxy;
+/**
+ * Au moins un en-tête forwarded (standard ou de-facto) est-il présent ? Permet à
+ * l'appelant de n'allouer la résolution que quand c'est utile (hot path : 0 alloc
+ * sur une requête directe sans proxy).
+ */
+export declare function hasForwardingHeaders(headers: ForwardedHeaders): boolean;

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

@@ -0,0 +1,85 @@
+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 HttpRequest from "./Request.js";
+import HttpResponse from "./Response.js";
+import Http2Request from "../http2/Request.js";
+import Http2Response from "../http2/Response.js";
+import http2 from "node:http2";
+import http from "node:http";
+import { URL } from "node:url";
+import uploadService from "../../../service/upload/upload-service.js";
+/**
+ * Métadonnées de topologie de proxy (en-têtes `X-Forwarded-*`), renseignées
+ * seulement derrière un proxy de confiance.
+ *
+ * ⚠️ RFC 7239 §8.2 (Information Leak) — DONNÉES INTERNES : ne JAMAIS recopier
+ * dans une réponse HTTP ni sérialiser en metaData exposée au client (révélerait
+ * la chaîne de proxy et les hôtes/IP internes). Lecture interne uniquement
+ * (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;
+}
+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
+     * mémoïsée). `Origin` invalide ou `null` (RFC 6454) → repli sur l'URL de la
+     * requête, comme le WS — jamais de throw.
+     */
+    get originUrl(): URL | undefined | null;
+    set originUrl(value: URL | undefined | null);
+    /**
+     * Chemin timeout direct — appelé par les handlers socket/stream de
+     * `setTimeout()`. T4 : remplace l'ancien `once("onTimeout")` posé au ctor
+     * (1 onceWrapper node + 1 closure alloués à CHAQUE requête pour un event
+     * qui ne fire presque jamais). L'event `onTimeout` reste émis pour
+     * d'éventuels listeners externes — guard 0-listener : 0 alloc sinon.
+     */
+    _onTimeout(): void;
+    setScheme(): SchemeType;
+    handle(): Promise<this>;
+    setTimeout(): void;
+    render(chunk: unknown, encoding?: BufferEncoding, status?: string | number, headers?: Record<string, string | number>): Promise<Http2Response | HttpResponse>;
+    end(): Promise<Http2Response | HttpResponse>;
+    send(chunk?: unknown, encoding?: BufferEncoding): Promise<Http2Response | HttpResponse>;
+    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>;
+    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;
+    getHostName(): string;
+    getRemoteAddress(): string | null;
+    getHost(): string | undefined;
+    getUserAgent(): string | undefined;
+    getMethod(): HTTPMethod;
+    setContentType(type?: string, encoding?: BufferEncoding): void | http.ServerResponse<http.IncomingMessage>;
+    protected resolveIsHtml(): boolean;
+    setDefaultContentType(): void;
+    setContextJson(encoding?: BufferEncoding): void;
+    setContextHtml(encoding?: BufferEncoding): void;
+}
+export default HttpContext;

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

@@ -0,0 +1,203 @@
+import http from "node:http";
+import http2 from "node:http2";
+import HttpContext from "../http/HttpContext.js";
+import { URL } from "node:url";
+import { HTTPMethod, Cookies } from "../Context.js";
+import QS from "qs";
+import { ParserXml, ParserQs, Parser, acceptParser } from "./parser.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";
+import Session from "../../session/session.js";
+import { type ResolvedProxy } from "../forwarded.js";
+declare class BodyHandled {
+}
+declare module "url" {
+    interface URL {
+        query: QS.ParsedQs;
+    }
+}
+declare module "http" {
+    interface IncomingMessage {
+        body: unknown;
+        session: Session;
+        cookie: Cookies;
+    }
+}
+declare module "http2" {
+    interface Http2ServerRequest {
+        body: unknown;
+        session: Session;
+    }
+}
+type ParserType = ParserXml | ParserQs | Parser | BodyHandled;
+declare class HttpRequest {
+    #private;
+    context: HttpContext;
+    request: http.IncomingMessage | http2.Http2ServerRequest;
+    headers: http.IncomingHttpHeaders;
+    host: string | undefined;
+    method: HTTPMethod;
+    contentType: string | null;
+    rawContentType: Record<string, string>;
+    domain: string;
+    remoteAddress: string | null | undefined;
+    hostname: string;
+    sUrl: string;
+    /**
+     * Scheme effectif côté client (`http` | `https`, ou le proto `Forwarded`
+     * brut derrière un proxy de confiance) — posé par {@link getFullUrl}, seule
+     * source de cette décision. `HttpContext.setScheme` le lit sans toucher à
+     * l'URL.
+     */
+    scheme: string;
+    /**
+     * Pathname de la requête, TOUJOURS sous forme normalisée WHATWG : découpe
+     * du target quand elle est prouvablement identique au parse (fast-path),
+     * `URL.pathname` sinon. C'est la valeur que consomment le router et le
+     * matching de zones du firewall — sans jamais construire l'URL.
+     */
+    pathname: string;
+    /** Query string au format `URL.search` (`?…`, ou `""`) — même provenance. */
+    search: string;
+    /** L'objet {@link url} a-t-il déjà été construit ? (diagnostic/sonde). */
+    get hasParsedUrl(): boolean;
+    /**
+     * Sérialisation de l'URL de la requête — `URL.href` si l'objet existe,
+     * sinon `sUrl` (identique par construction sur le fast-path). Les lecteurs
+     * descriptifs (logs, profiler, `context.url`) passent par ici : 0 parse.
+     */
+    get href(): string;
+    /**
+     * URL WHATWG complète de la requête, construite au premier accès (fast-path)
+     * ou dès le ctor (bail-out). Porte `query` (le GET parsé) comme toujours.
+     */
+    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.
+     *
+     * Getter (aucune allocation) : `queryPost` reste la source unique.
+     */
+    get body(): Record<string, unknown>;
+    queryStringOptions: (QS.IParseOptions & {
+        decoder?: undefined;
+    }) | undefined;
+    charset: BufferEncoding;
+    uploadOption: IUploadOptions;
+    maxBodySize: number;
+    data: Buffer;
+    /** Media-ranges de l'en-tête `Accept`, parsés au premier accès (mémoïsé). */
+    get accept(): ReturnType<typeof acceptParser>;
+    /** `true` si le client accepte `text/html` — résolu au premier accès (mémoïsé). */
+    get acceptHtml(): boolean;
+    origin: string | undefined;
+    trustedProxy: boolean;
+    forwarded: ResolvedProxy | null;
+    constructor(request: http.IncomingMessage | http2.Http2ServerRequest, context: HttpContext);
+    /**
+     * Fin de corps — émission unique d'`onRequestEnd`. L'alias `body` est posé
+     * ICI sur la requête Node brute (au moment du fire, le corps est parsé) —
+     * 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
+     * `body` dans tout le framework, celui de l'écosystème et d'`IAdminRequest`.
+     */
+    private fireRequestEnd;
+    initialize(): Promise<unknown>;
+    /**
+     * 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
+     * quand le client annonce une taille supérieure à `maxBodySize`. Rideau de
+     * tête (client honnête) ; le compteur streaming de {@link Parser.write} couvre
+     * le cas sans `Content-Length` (chunked) ou menteur. No-op si limite à 0.
+     *
+     * @throws {HttpError} 413 si `Content-Length` dépasse `maxBodySize`.
+     */
+    private enforceBodyLimit;
+    parseRequest(): Promise<ParserType | null>;
+    /**
+     * Parse un corps `multipart/form-data` via **busboy** (streaming pur).
+     *
+     * Contrairement à l'ancien chemin formidable, le corps brut n'est **jamais**
+     * bufferisé en RAM : busboy lit le flux, les fichiers sont écrits au fil de
+     * l'eau dans le répertoire temp (`UploadService.path`), seuls les champs
+     * texte (petits) restent en mémoire → fin de la double-bufferisation
+     * (`Parser.chunks` + parser de fichiers) qui doublait la RAM par upload.
+     *
+     * Robustesse / sécurité :
+     * - `new Busboy()` lève **synchroniquement** si le Content-Type n'est pas un
+     *   multipart exploitable (boundary manquant, en-tête absent) → le flux n'a
+     *   pas encore été consommé → bascule sur le `Parser` de secours.
+     * - `limits.fileSize` borne CHAQUE fichier ; `maxTotalFileSize` borne le
+     *   CUMUL par requête (compteur Nodefony) ; `files`/`fields`/`parts` bornent
+     *   la quantité → 413. Toute erreur nettoie les temporaires déjà posés
+     *   (anti-orphelins / saturation disque sur endpoint d'upload public).
+     * - nom temp = `randomUUID()` + extension d'origine → jamais le nom client
+     *   dans le chemin (anti path-traversal).
+     *
+     * @returns la sentinelle `BODY_DONE` (corps déjà traité), ou le `Parser`
+     *   de secours quand le corps n'est pas un multipart.
+     * @throws {HttpError} 413 si une limite de taille/quantité est dépassée.
+     */
+    parseMultipart(): Promise<ParserType>;
+    /**
+     * Pilote busboy : pipe le flux requête, écrit chaque fichier dans un temp au
+     * fil de l'eau, accumule les champs texte. Résout `{ fields, files }` à
+     * `finish` (après flush de tous les writes), rejette — avec cleanup des temp
+     * déjà posés — à la moindre erreur ou dépassement de limite.
+     */
+    private streamMultipart;
+    /**
+     * Accumule un champ texte multipart. `foo[]` (ou répétition de `foo`) →
+     * tableau ; sinon valeur scalaire. (Anciennement délégué à formidable.)
+     */
+    private assignField;
+    accepts(Type: string): boolean;
+    createFileUpload(name: string, file: IParsedUploadFile): Promise<UploadedFile | undefined>;
+    getMethod(): HTTPMethod;
+    getContentType(request: http.IncomingMessage | http2.Http2ServerRequest): string | null;
+    /**
+     * Charset du corps déduit du `Content-Type` (`charset=…`), normalisé en un
+     * `BufferEncoding` Node valide. Les alias IANA courants sont mappés
+     * (`iso-8859-1` → `latin1`, `us-ascii` → `ascii`…) ; tout charset inconnu ou
+     * non supporté par Node retombe sur `utf8` — JAMAIS de throw `.toString()`
+     * sur un encoding invalide (erreur propre, pas de 500 sur charset exotique).
+     */
+    getCharset(): BufferEncoding;
+    getDomain(): string;
+    getUserAgent(): string | undefined;
+    getHostName(host?: string): string;
+    getHost(): string | undefined;
+    getRemoteAddress(): string | null;
+    /**
+     * Request-target brut (origin-form) tel que reçu du transport — SOURCE
+     * UNIQUE partagée par la concaténation de {@link getFullUrl} et la découpe
+     * fast-path du ctor. HTTP/2 lit le pseudo-header `:path` (override).
+     */
+    getRawTarget(): string | undefined;
+    /**
+     * 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`.
+     */
+    protected resolveScheme(request: http.IncomingMessage | http2.Http2ServerRequest): string;
+    getFullUrl(request?: http.IncomingMessage | http2.Http2ServerRequest): string;
+    getHeader(name: string): string | string[] | null | undefined;
+    setUrl(Url: string): URL;
+    getUrl(sUrl: string, baseUrl?: string): URL;
+    log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;
+}
+export default HttpRequest;