@nodefony/http 10.0.0-beta.6 → 10.0.0-beta.7

package/dist/types/nodefony/interfaces/IRouting.d.ts

@@ -1,5 +1,6 @@
 import type { MaybePromise } from "nodefony";
 import type { ContextType } from "../service/http-kernel.js";
+import type { IRouteUploadOptions } from "./IUpload.js";
 /**
  * Ce que le pipeline HTTP/WS lit d'une route résolue — et rien de plus.
  *
@@ -22,6 +23,24 @@ export interface IResolvedRoute {
     } | undefined;
     /** Corps laissé en flux (`@Body({ stream: true })`) : le parse est sauté. */
     readonly bodyStream?: boolean | undefined;
+    /**
+     * Route servie par un point d'entrée gRPC (`markGrpcRoute`) : une requête
+     * gRPC native n'est acceptée que sur une telle route (ADR-0026 D13 point 3).
+     *
+     * @experimental Surface gRPC, ADR-0026 D11.
+     */
+    readonly grpc?: boolean | undefined;
+    /**
+     * Délai de réponse propre à la route (ms) ; `null` ou absent = celui du
+     * serveur. Ré-armé par `HttpContext.handle` une fois la route résolue.
+     */
+    readonly responseTimeout?: number | null | undefined;
+    /**
+     * Bornes d'envoi propres à la route (option `upload`), fusionnées sur celles
+     * de la configuration à la lecture du corps ; `null` ou absent = celles de
+     * la configuration.
+     */
+    readonly upload?: IRouteUploadOptions | null | undefined;
 }
 /**
  * Ce que le pipeline HTTP/WS attend du résolveur d'une requête, posé sur

package/dist/types/nodefony/interfaces/IRpcCall.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Le protocole RPC parlé sur le fil : `grpc`, `grpc-web` ou `connect` pour un
+ * appel gRPC (ADR-0026 D10). Union OUVERTE : un appel JSON-RPC (porte MCP,
+ * A2A) pourra s'y ajouter (`jsonrpc`) sans rupture.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export type RpcSystem = "grpc" | "grpc-web" | "connect" | (string & {});
+/**
+ * Le résultat d'un appel RPC tel que le voient la ligne d'accès, l'audit et le
+ * canal de traçage (ADR-0026 D10) : quatre champs, jamais la fiche d'appel
+ * entière — elle porte le contrôleur et le contexte.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IRpcOutcome {
+    /** Le protocole parlé sur le fil. */
+    readonly system: RpcSystem;
+    /**
+     * La méthode appelée, `paquet.Service/Méthode` — tirée de la route : jamais
+     * une valeur inventée (`_OTHER`), la route est connue.
+     */
+    readonly method: string;
+    /**
+     * Le code de l'appel (gRPC : 0 à 16), lu une fois au `close` de la réponse.
+     * `null` avant, ou quand l'appel n'a jamais commencé (requête refusée par le
+     * transport avant tout contexte d'appel : le statut HTTP dit alors tout).
+     */
+    readonly code: number | null;
+    /** Le nom du code (`OK`, `UNAVAILABLE`…), `null` avec lui. */
+    readonly codeName: string | null;
+}
+/**
+ * Un appel RPC servi sur une requête HTTP — gRPC, gRPC-Web ou Connect —, porté
+ * par `HttpContext.rpc`, `null` hors appel RPC (ADR-0026 D10).
+ *
+ * Le contrat vit dans `@nodefony/http` et ne nomme rien de l'adaptateur : un
+ * appel JSON-RPC pourra le porter sans rupture. La fiche d'appel gRPC
+ * (`GrpcCall`, sous-chemin `@nodefony/http/grpc`) l'implémente : aucune
+ * allocation de plus par appel.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IRpcCall extends IRpcOutcome {
+    /**
+     * Le délai de réponse du serveur est échu : termine l'appel au format de
+     * son protocole (gRPC : 4 `DEADLINE_EXCEEDED`). Appelé par
+     * `HttpContext._onTimeout` À LA PLACE du 503, qui serait un second
+     * écrivain sur une réponse que l'adaptateur possède (ADR-0026 D4, point 3).
+     * Sans effet sur un appel déjà terminé.
+     */
+    expire(): void;
+    /**
+     * L'identité qui a ouvert l'appel n'est plus valable (jeton révoqué,
+     * session fermée, droits changés) : termine l'appel au format de son
+     * protocole (gRPC : 16 `UNAUTHENTICATED`). Appelé par le cycle de vie d'un
+     * flux À LA PLACE de la destruction du transport, qui ne dirait au client
+     * qu'une coupure (ADR-0026 D6). Sans effet sur un appel déjà terminé.
+     */
+    revoke(): void;
+    /**
+     * Le serveur s'arrête : termine l'appel au format de son protocole (gRPC :
+     * 14 `UNAVAILABLE`, « réessaie, ailleurs »). Appelé par le noyau à l'arrêt,
+     * AVANT le drain des connexions, pour chaque flux long encore ouvert
+     * (ADR-0026 D8) — à la place de la destruction du transport à
+     * `shutdownTimeout`, qui ne dirait au client qu'une coupure. Sans effet sur
+     * un appel déjà terminé, ou déjà interrompu.
+     */
+    shutdown(): void;
+    /**
+     * Fixe le code de l'appel, une fois, au `close` de la réponse — appelé par
+     * le noyau AVANT la ligne d'accès (`HttpKernel.teardownHttp`, ADR-0026 D10
+     * point 2). Les appels suivants ne changent rien.
+     *
+     * @param ended - la réponse a-t-elle été terminée par le serveur
+     *   (`responseEnded`) ? Un appel sans motif d'interruption est alors réussi
+     *   (0), sinon annulé par le client (1).
+     * @returns la cause à porter par la ligne d'accès (`context.error`) quand
+     *   l'appel a échoué sur une exception — UNE ligne par appel en erreur
+     *   (D10 point 3) —, `null` sinon.
+     */
+    settle(ended: boolean): Error | null;
+}

package/dist/types/nodefony/interfaces/IUpload.d.ts

@@ -1,3 +1,4 @@
+import type { FileClass } from "nodefony";
 /**
  * Forme neutre d'un fichier multipart parsé (temp écrit sur disque), découplée
  * du parser sous-jacent. Remplace l'ex-couplage à `formidable.File` : le moteur
@@ -44,18 +45,64 @@ export interface IUploadOptions {
     /** Encodage par défaut des parts texte. */
     encoding?: string | undefined;
 }
+/**
+ * Les bornes d'envoi qu'une ROUTE règle pour elle-même (option de route
+ * `upload`). Chaque clé déclarée remplace celle de la configuration http,
+ * dans les deux sens : un dépôt de vidéos relève `maxFileSize` sans le
+ * relever pour les autres routes, un avatar l'abaisse à quelques centaines de
+ * kilo-octets — et le fichier trop gros est coupé PENDANT le flux, avant
+ * d'avoir rempli le disque. Une clé absente garde la valeur de la
+ * configuration.
+ *
+ * Lues au moment de lire le corps, quand la route est déjà résolue : une route
+ * qui ne déclare rien ne paie rien. Le dossier de dépôt et l'encodage restent
+ * ceux de la configuration.
+ */
+export interface IRouteUploadOptions {
+    /** Taille max d'UN fichier (octets). */
+    readonly maxFileSize?: number | undefined;
+    /** Taille max CUMULÉE des fichiers de la requête (octets). */
+    readonly maxTotalFileSize?: number | undefined;
+    /** Nombre max de fichiers. */
+    readonly maxFiles?: number | undefined;
+    /** Nombre max de champs texte. */
+    readonly maxFields?: number | undefined;
+    /** Taille max d'un champ texte (octets). */
+    readonly maxFieldsSize?: number | undefined;
+    /** Empreinte calculée pendant le flux (`false` = aucune). */
+    readonly hashAlgorithm?: false | "sha1" | "md5" | "sha256" | undefined;
+}
+/**
+ * Un fichier reçu dans un corps multipart, déjà écrit dans le dossier
+ * d'upload sous un nom temporaire.
+ *
+ * Le temporaire est EFFACÉ à la fin de la requête (réponse envoyée ou client
+ * parti) : pour garder le fichier, l'action le déplace avec `moveAsync()`
+ * avant de répondre. Un refus (pare-feu, garde, erreur de l'action) ne laisse
+ * donc rien sur le disque.
+ */
 export interface IUploadedFile {
     filename: string;
     size: number;
     prettySize: string;
-    mimeType: string | null | undefined;
+    /**
+     * Le type DÉCLARÉ par le client, sinon deviné de l'extension ; `false`
+     * quand ni l'un ni l'autre ne le disent. Déclaratif : jamais une preuve du
+     * contenu.
+     */
+    mimeType: string | false;
     hash: string | null | undefined;
     hashAlgorithm: false | "sha1" | "md5" | "sha256";
     lastModifiedDate: Date | null | undefined;
-    move(target: string): IUploadedFile;
+    /**
+     * Déplace le fichier vers `target` (un fichier, ou un dossier existant) et
+     * rend le fichier de DESTINATION — un `FileClass`, pas un fichier reçu : le
+     * nom d'origine, la taille déclarée et l'empreinte restent sur celui-ci.
+     */
+    move(target: string): FileClass;
     /** Variante non bloquante de `move()` (recommandée dans le pipeline). */
-    moveAsync(target: string): Promise<IUploadedFile>;
-    getMimeType(): string | null | undefined;
+    moveAsync(target: string): Promise<FileClass>;
+    getMimeType(): string | false;
     getSize(): number;
     getPrettySize(): string;
 }

package/dist/types/nodefony/interfaces/index.d.ts

@@ -1,6 +1,6 @@
 export type { ICookie, ICookieOptions, IWsCookie, SameSiteType, PriorityType, } from "./ICookie.js";
 export type { ISession, ISessionStorage, ISerializedSession, SessionIntent, SessionStatusType, SessionStrategyType, FlashBagType, MetaBagType, } from "./ISession.js";
-export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, } from "./IUpload.js";
+export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, IRouteUploadOptions, } from "./IUpload.js";
 export type { IRequest, IHttpRequest, RequestBody, IHttp2Request, IWsRequest, HTTPMethodType, } from "./IRequest.js";
 export type { IResponse, IHttpResponse, IWebsocketResponse } from "./IResponse.js";
 export type { IContext, IHttpContext, IWebsocketContext, ServerType, ProtocolName, AlpnProtocol, SchemeType, WebSocketStateType, CookiesMap, } from "./IContext.js";
@@ -8,4 +8,5 @@ export type { IHttpKernel } from "./IHttpKernel.js";
 export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./IRouting.js";
 export type { ISecurityZone, IFirewallGate } from "./ISecurity.js";
 export type { IRequestTrace, RequestTraceProtocol } from "./IRequestTrace.js";
+export type { IRpcCall, IRpcOutcome, RpcSystem } from "./IRpcCall.js";
 export type { IProxyMount, IProxyMountOptions, ProxyTarget, } from "./IReverseProxy.js";

package/dist/types/nodefony/service/audit-logger.d.ts

@@ -1,6 +1,7 @@
 import type { Severity } from "nodefony";
 import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
 import type { IContext, IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+import type { IRpcOutcome } from "../interfaces/IRpcCall.js";
 declare const statusOf: (context: IContext) => number | null;
 /**
  * Canonical audit log entry — 1 JSON PDU per request (P3.1).
@@ -35,6 +36,15 @@ export interface AuditLogEntry {
         name: string;
         durationMs: number | null;
     }[] | undefined;
+    /**
+     * L'appel RPC de la requête (système, méthode, code, nom), `null` hors
+     * RPC et pour une WebSocket : forme stable (ADR-0026 D10 point 4) —
+     * toujours posé par `JsonAuditLogger` ; optionnel au type, pour qu'un
+     * journal maison qui bâtit une entrée ne casse pas.
+     *
+     * @experimental Surface gRPC, ADR-0026 D11.
+     */
+    rpc?: IRpcOutcome | null | undefined;
     error?: AuditErrorEntry | undefined;
     protocol?: string | null | undefined;
 }
@@ -59,6 +69,25 @@ export interface AuditErrorEntry {
  * Unknown/missing status → INFO.
  */
 declare function severityFromStatus(status: number | null | undefined): Severity;
+/**
+ * Gravité d'un appel RPC selon son code (ADR-0026 D10 point 4) : 0 → INFO ;
+ * une erreur du serveur ({@link RPC_SERVER_ERRORS}) → ERROR ; les autres —
+ * refus, échecs métier ou client — → WARNING.
+ *
+ * @param code - le code de l'appel (gRPC : 0 à 16).
+ * @returns la gravité de la ligne.
+ */
+declare function severityFromRpcCode(code: number): Severity;
+/**
+ * Gravité de la ligne d'une requête HTTP : celle du code de son appel RPC
+ * quand il est fixé — le statut HTTP d'un appel gRPC reste 200 quand l'appel
+ * échoue —, sinon celle de son statut.
+ *
+ * @param context - le contexte de la requête.
+ * @param status - son statut HTTP.
+ * @returns la gravité de la ligne.
+ */
+declare function severityOfHttp(context: IHttpContext, status: number | null | undefined): Severity;
 export interface JsonAuditLoggerOptions {
     /**
      * Whether to include `error.stack` and recursive `error.cause.stack`.
@@ -115,8 +144,9 @@ declare class JsonAuditLogger implements IRequestLogger {
     /**
      * Decide whether the current HTTP request must be logged (audit sampling).
      *
-     * Always `true` when `sampleRate <= 1`, on errors, and for `status >= 400`
-     * (failures are never sampled out). Otherwise selects 1 in `sampleRate` of
+     * Always `true` when `sampleRate <= 1`, on errors, for `status >= 400` and
+     * for a failed RPC call — whose HTTP status may stay 200 (failures are
+     * never sampled out). Otherwise selects 1 in `sampleRate` of
      * the 2xx/3xx requests with a deterministic counter.
      *
      * Called by `Context.logRequest()` **before** `renderHttp`, so a sampled-out
@@ -137,4 +167,4 @@ declare class JsonAuditLogger implements IRequestLogger {
     private serializeError;
 }
 export default JsonAuditLogger;
-export { severityFromStatus, statusOf };
+export { severityFromRpcCode, severityFromStatus, severityOfHttp, statusOf };

package/dist/types/nodefony/service/error-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult } from "../interfaces/IErrorRenderer.js";
+import type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult, IErrorDescription } from "../interfaces/IErrorRenderer.js";
 import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
 /** Champ fautif, tel qu'exposé au client dans le corps JSON (`error.fields`). */
 export interface IValidationField {
@@ -106,6 +106,27 @@ export declare function schemaMismatchOf(error: unknown): SchemaMismatchConfiden
 declare class DefaultErrorRenderer implements IErrorRenderer {
     renderHttp(error: Error, context: IHttpContext): IErrorHttpResult;
     renderWebsocket(error: Error, context: IWebsocketContext): IErrorWebsocketResult;
+    /**
+     * Le statut HTTP et le message client qu'une route HTTP rendrait pour cette
+     * erreur — mêmes classements que {@link renderHttp} (validation 422, conflit
+     * 409, identifiant malformé, code numérique) et même opacité d'un 5xx en
+     * production —, sans RIEN écrire : ni statut sur la réponse, ni `metaData`,
+     * ni pile formatée. Sert les transports sans corps d'erreur : un appel gRPC
+     * traduit ce statut en code (ADR-0026 D7).
+     *
+     * Un identifiant malformé y vaut 400 : sans contexte, aucun chemin ne le
+     * désigne.
+     *
+     * @param error - l'erreur levée.
+     * @returns son statut émettable et le message destiné au client.
+     *
+     * @experimental Surface gRPC, ADR-0026 D11.
+     */
+    describe(error: Error): IErrorDescription;
+    /**
+     * Ramène une erreur à une `HttpError`. Sans contexte (`describe`), rien
+     * n'est écrit : `HttpError` ne pose le statut sur la réponse qu'avec lui.
+     */
     private toHttpError;
     /**
      * Ramène un `code` d'erreur à un statut HTTP réellement émettable.

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

@@ -216,7 +216,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * Le message nomme l'action, ce qu'elle a rendu et le geste qui convient
      * (`unsentResponseWarning`).
      *
-     * Appelé au timeout, AVANT que le 504/408 parte — après, `sended` est vrai et
+     * Appelé au timeout, AVANT que le 503 parte — après, `sended` est vrai et
      * plus rien ne se signalerait — et au démontage, pour un client parti avant.
      * Gratuit en production : rien n'est lu au-delà de `waitAsync`.
      *
@@ -483,6 +483,17 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @returns `undefined` quand le démontage est terminé ; sinon la promesse de
      *   sa fin, qui ne rejette pas.
      */
+    /**
+     * Fixe le code d'un appel RPC au `close` : « réponse finie » est la règle
+     * unique du noyau ({@link responseEnded}, celle du 499), jamais
+     * `writableFinished`, qui dit « finie » sur une annulation HTTP/2. Une cause
+     * rendue par l'appel devient l'erreur de la requête : la ligne d'accès la
+     * porte, le canal la publie — une ligne par appel en erreur (D10 point 3).
+     *
+     * @param context - le contexte de la requête.
+     * @param rpc - son appel RPC.
+     */
+    private settleRpc;
     private teardownHttp;
     /**
      * Suite ASYNCHRONE du démontage, quand il y a des hooks à attendre :
@@ -558,6 +569,15 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * N'attend que le repli statique, et seulement quand aucune route ne matche.
      */
     private routeHttpRequest;
+    /**
+     * L'échéance de réception HTTP/2 du serveur qui sert (`requestTimeout` de sa
+     * section), créée au premier corps HTTP/2 lu ; `null` si le délai vaut 0.
+     *
+     * À l'échéance, la réception en cours est interrompue (`abortBody`) et la
+     * requête rendue en 408 par le chemin d'erreur habituel — comme un corps qui
+     * dépasse sa limite (413).
+     */
+    private http2ReceiveDeadline;
     /**
      * Le corps — lu seulement s'il y en a un à lire —, puis les gardes
      * ({@link onRequestEnd}) et l'action. Chacun n'est attendu que s'il attend.

package/dist/types/nodefony/service/request-logger.d.ts

@@ -1,5 +1,15 @@
 import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
 import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+import type { IRpcOutcome } from "../interfaces/IRpcCall.js";
+/**
+ * Segment d'un appel RPC sur la ligne d'accès : `RPC : <méthode> <NOM>`
+ * (ADR-0026 D10 point 4) — le statut HTTP reste à sa place. Sans code (appel
+ * jamais commencé), la méthode seule.
+ *
+ * @param rpc - le résultat de l'appel.
+ * @returns le segment, sans espace de tête.
+ */
+export declare function rpcSegment(rpc: IRpcOutcome): string;
 /**
  * Default Nodefony per-request logger — preserves the legacy colored format.
  *

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

@@ -30,8 +30,8 @@ export interface IDrainTerminator {
  *
  * ⚠️ Les sockets WebSocket upgradées (sans réponse HTTP en cours) sont détruites
  * SANS frame Close → les serveurs WS doivent fermer leurs clients (close 1001)
- * AVANT ce drain. Garanti par l'ordre des listeners `onTerminate` : WS/WSS
- * s'attachent en `prependOnceListener`, les serveurs HTTP en `once`.
+ * AVANT ce drain. Garanti par `HttpKernel.drainTraffic` (ADR-0027 D2) : l'étape
+ * `dismiss` (1001) est attendue avant l'étape `drain`.
  *
  * @param server - serveur Node à drainer, créé AVANT son `listen` (le suivi des
  *   connexions commence ici)

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

@@ -1,5 +1,5 @@
 import { Container, Service, Severity, Msgid, Message, Pci, Pdu, KernelEventsType, nodefonyError, Scope } from "nodefony";
-import type { IProfilerQuery, RequestContextPayload } from "nodefony";
+import type { IProfilerQuery, IRequestUser, RequestContextPayload } from "nodefony";
 import type { IRouteResolver, IRequestRouter } from "../../interfaces/IRouting.js";
 import type { ISecurityZone } from "../../interfaces/ISecurity.js";
 import { WebSocketServer } from "ws";
@@ -213,6 +213,14 @@ declare class Context extends Service implements IContextInterface {
      * @param store - le magasin passé à `RequestContext.run`
      */
     holdRequestStore(store: RequestContextPayload): void;
+    /**
+     * L'utilisateur authentifié de l'unité de travail, lu sur son magasin et
+     * non sur l'ALS : valable là où la bulle n'est plus active (rendu d'une
+     * erreur, démontage). Même règle que `RequestContext.getAuthenticatedUser`.
+     *
+     * @returns l'utilisateur connecté, ou `null` (anonyme, hors zone, nettoyé).
+     */
+    authenticatedUser(): IRequestUser | null;
     clean(): void;
     /**
      * Log d'un event du cycle de vie — gate boot-time (V2.1) : en production le

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

@@ -25,7 +25,7 @@ import type HttpContext from "./HttpContext.js";
  * Raison de la fin d'un flux d'octets.
  *
  * - `end` : la source est finie, ou le serveur a fermé le flux (durée de vie,
- *   révocation de l'identité) ;
+ *   révocation de l'identité, arrêt du serveur pour un flux `live`) ;
  * - `client` : le client est parti ;
  * - `error` : la source a échoué ;
  * - `timeout` : la source est restée muette plus de `idleTimeout` ;

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

@@ -45,7 +45,7 @@ export type HttpRequestType = Http2Request | HttpRequest;
 export type HttpRsponseType = Http2Response | HttpResponse;
 /**
  * Route le délai d'inactivité d'une socket HTTP/1.1 vers la requête qu'elle
- * porte : 408/504 si une requête est en cours, fermeture si la connexion
+ * porte : 503 si une requête est en cours, fermeture si la connexion
  * persistante est inactive. Écouteur `timeout` du SERVEUR — un seul pour
  * toutes ses connexions —, que Node appelle avec la socket en argument
  * (`socketOnTimeout` → `server.emit("timeout", socket)`).
@@ -61,10 +61,12 @@ export type HttpRsponseType = Http2Response | HttpResponse;
  * serveur supprime aussi une fermeture et une entrée de registre par connexion.
  *
  * @param socket - la socket dont le délai a expiré ; une session HTTP/2 (même
- *   événement sur un serveur `allowHTTP1`) est laissée à son propre délai
+ *   événement sur un serveur `allowHTTP1`) est fermée par l'écouteur que pose
+ *   `setHttp2SessionTimeout` (`src/servers/http2Limits.ts`)
  */
 export declare function routeSocketTimeout(socket: unknown): void;
 import type { IHttpContext as IHttpContextInterface } from "../../../interfaces/IContext.js";
+import type { IRpcCall } from "../../../interfaces/IRpcCall.js";
 import { type ISseStreamOptions, type SseStream } from "./SseStream.js";
 import { type ByteStreamSource, type IByteStreamOptions, type IByteStreamResult } from "./ByteStream.js";
 declare class HttpContext extends Context implements IHttpContextInterface {
@@ -78,6 +80,15 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      * son montage. `null` = servie par l'application (cas de toute requête).
      */
     relayAccessLog: "all" | "errors" | null;
+    /**
+     * L'appel RPC servi sur cette requête (gRPC, gRPC-Web, Connect), `null`
+     * hors appel RPC (ADR-0026 D10) : un champ, aucune allocation. Posé par le
+     * point d'entrée gRPC ; à l'échéance du délai de réponse, {@link _onTimeout}
+     * le termine au lieu d'écrire un 503.
+     *
+     * @experimental Surface gRPC, ADR-0026 D11.
+     */
+    rpc: IRpcCall | null;
     request: HttpRequestType;
     response: HttpRsponseType;
     uploadService: uploadService | null;
@@ -97,6 +108,18 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      * d'éventuels listeners externes — guard 0-listener : 0 alloc sinon.
      */
     _onTimeout(): void;
+    /**
+     * Ré-arme le délai de réponse de la requête à la valeur propre de sa route
+     * (`responseTimeout` d'une option de route), une fois celle-ci résolue.
+     *
+     * Même mécanisme que {@link setTimeout} — délai d'inactivité de la socket
+     * (HTTP/1.1) ou du flux (HTTP/2) —, sans second écouteur : sous HTTP/2,
+     * `setTimeout(ms)` sans rappel remplace le minuteur et garde celui posé par
+     * {@link setTimeout}. `0` désactive le délai pour la requête.
+     *
+     * @param ms - délai de la route, en millisecondes.
+     */
+    rearmTimeout(ms: number): void;
     setScheme(): SchemeType;
     /**
      * Sert la requête : délai de réponse, hooks `onRequest`, puis l'action
@@ -117,9 +140,21 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      * réellement rendu (le relais écrit la réponse brute, pas celle du
      * contexte) ; un montage `accessLog: "errors"` ne l'écrit qu'en échec.
      *
+     * Le statut natif n'est recopié que si la réponse a été TERMINÉE
+     * ({@link responseEnded}) : sinon il n'a jamais atteint le client (200 par
+     * défaut de Node), et le statut du contexte — 499 d'un client parti — dit
+     * vrai. Règle unique pour toute réponse écrite par un tiers (#695, critère
+     * 38).
+     *
      * @param httpError - l'erreur de la requête, s'il y en a une
      */
     logRequest(httpError?: Error | HttpError | nodefonyError | null): import("nodefony").Pdu | undefined;
+    /**
+     * Reprend le statut de la réponse native, écrite par un tiers (relais,
+     * adaptateur RPC) — si la réponse est TERMINÉE seulement : sinon ce statut
+     * n'a jamais atteint le client, et celui du contexte (499) dit vrai.
+     */
+    private adoptNativeStatus;
     /**
      * Nettoie le contexte, et le DÉTACHE de sa socket h1 : la connexion
      * persistante survit à la requête, et l'entrée de `socketActiveContext`
@@ -204,6 +239,25 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      *   Quand l'appel lève, la source est DÉTRUITE (un flux web est annulé).
      */
     openStream(source: ByteStreamSource, options?: IByteStreamOptions): Promise<IByteStreamResult>;
+    /**
+     * Répond par une `Response` Web standard — celle que rend `fetch()`, ou une
+     * réponse construite (`new Response(…)`, `Response.json(…)`) : son statut,
+     * ses en-têtes, et son corps EN FLUX, jamais lu d'avance.
+     *
+     * C'est ce que fait le framework quand une action renvoie une `Response`.
+     * Une réponse relayée (issue de `fetch`) perd `content-encoding`,
+     * `content-length` et `set-cookie` de l'amont ; une réponse construite garde
+     * les siens. Les en-têtes de connexion ne partent jamais. Le reste — arrêt au
+     * départ du client, contre-pression, délais, HEAD sans lire le corps — est
+     * celui de {@link HttpContext.openStream}.
+     *
+     * @param response - une `Response` dont le corps n'a pas été consommé.
+     * @param options - délais et écouteur de fin ; statut et en-têtes viennent de la réponse.
+     * @returns la raison de la fin et le nombre d'octets ; ne rejette jamais.
+     * @throws HttpError 502 pour `Response.error()` (statut 0, aucune réponse) ;
+     *   les cas de {@link HttpContext.openStream} sinon.
+     */
+    openWebResponse(response: Response, options?: Omit<IByteStreamOptions, "status" | "headers">): Promise<IByteStreamResult>;
     flush(chunk: unknown, encoding: BufferEncoding): MaybePromise<HttpResponse>;
     /**
      * Termine la requête : hook `onClose`, puis fin de la réponse si l'envoi ne

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

@@ -10,9 +10,20 @@ 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 HttpError from "../../errors/httpError.js";
 import { type ResolvedProxy } from "../forwarded.js";
 declare class BodyHandled {
 }
+/**
+ * Une réception multipart EN COURS, interruptible de l'extérieur : `fail` rompt
+ * la lecture comme le ferait un dépassement de limite (temporaires nettoyés).
+ * Posée dans `request.parser` le temps de la lecture seulement — l'allocation
+ * est réservée au multipart, déjà lourd.
+ */
+declare class MultipartReception {
+    readonly fail: (error: HttpError) => boolean;
+    constructor(fail: (error: HttpError) => boolean);
+}
 declare module "url" {
     interface URL {
         query: QS.ParsedQs;
@@ -31,7 +42,7 @@ declare module "http2" {
         session: Session;
     }
 }
-type ParserType = ParserXml | ParserQs | Parser | BodyHandled;
+type ParserType = ParserXml | ParserQs | Parser | BodyHandled | MultipartReception;
 declare class HttpRequest {
     #private;
     context: HttpContext;
@@ -88,6 +99,9 @@ declare class HttpRequest {
      * temporaire — lus par `@UploadedFile()` / `@UploadedFiles()`. Les champs
      * texte du même corps sont dans {@link body}.
      *
+     * Ces temporaires sont EFFACÉS à la fin de la requête : pour garder un
+     * fichier, l'action le déplace (`moveAsync`) avant de répondre.
+     *
      * Lecture seule : une requête sans upload rend un vide partagé et gelé,
      * aucune allocation.
      */
@@ -150,6 +164,16 @@ declare class HttpRequest {
      * @returns `undefined` quand tout est fait, sinon la promesse à attendre.
      */
     private endWithoutBody;
+    /**
+     * 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), puis par les
+     * bornes que la route déclare pour elle-même (option de route `upload`). La
+     * route est déjà résolue à ce moment : une route sans bornes propres
+     * n'alloue rien. Hors pipeline (aucun scope ouvert), la configuration du
+     * module telle quelle.
+     */
+    private readBodyLimits;
     /**
      * 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
@@ -159,13 +183,6 @@ 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>;
     /**
@@ -200,6 +217,19 @@ declare class HttpRequest {
      * déjà posés — à la moindre erreur ou dépassement de limite.
      */
     private streamMultipart;
+    /**
+     * Interrompt la réception du corps en cours : la promesse de `initialize()`
+     * rejette avec `error`, rendue par le chemin d'erreur habituel — comme un
+     * corps qui dépasse sa limite (413).
+     *
+     * Sert le délai de réception HTTP/2 (`requestTimeout`), que `node:http2` ne
+     * borne pas. Sans effet hors réception : corps déjà reçu, lu en flux par
+     * l'action (`bodyStream`), ou méthode sans corps.
+     *
+     * @param error - la cause rendue au client (408 au délai dépassé)
+     * @returns vrai si une réception en cours a été interrompue
+     */
+    abortBody(error: HttpError): boolean;
     /**
      * Accumule un champ texte multipart. `foo[]` (ou répétition de `foo`) →
      * tableau ; sinon valeur scalaire. (Anciennement délégué à formidable.)