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

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 {
@@ -34,10 +34,11 @@ export declare function toValidationFields(error: Error): IValidationField[] | n
 /**
  * Reconnaît un identifiant MAL FORMÉ refusé par la base, et rend la valeur fautive.
  *
- * Deux moteurs le disent : MongoDB par une `CastError` de Mongoose (la clé est
- * un ObjectId), PostgreSQL par `22P02` (la clé est un `uuid` ou un entier).
- * SQLite et MySQL rangent la clé en texte : ils ne lèvent rien, la lecture rend
- * simplement « rien », d'où leur 404 — c'est la cohérence avec eux qui est visée.
+ * Trois sources le disent : MongoDB par une `CastError` de Mongoose (la clé est
+ * un ObjectId), PostgreSQL par `22P02` (la clé est un `uuid` ou un entier), et
+ * le kit de colonnes portable par une `ColumnValueError` de genre `uuid` ou
+ * `integer` — il refuse sur les trois moteurs la clé que PostgreSQL refuserait. Une clé rangée en
+ * texte NATIF ne lève rien, la lecture rend « rien » : le même 404.
  *
  * Même descente dans `cause` que {@link isUniqueViolation} (Drizzle enveloppe).
  *
@@ -105,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

@@ -147,11 +147,20 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * dans `onHttpRequest` (0 alloc/concat par requête).
      */
     private computeSecurityHeaderCaches;
+    /**
+     * En-têtes du transport d'une réponse, figés au démarrage — ce que
+     * `HttpResponse` place en tête de sa réserve.
+     *
+     * @param type - famille du serveur qui a reçu la requête.
+     * @returns la liste plate `[nom, valeur, …]`, noms en minuscules.
+     */
+    transportHeaders(type: ServerType): readonly string[];
     /**
      * Ce que ce kernel ÉMET réellement comme en-têtes de sécurité transport.
      *
      * Ces trois en-têtes (HSTS, X-Frame-Options, X-Content-Type-Options) sont posés
-     * ici, à l'entrée brute, pour couvrir aussi les statiques et les pages d'erreur
+     * par `@nodefony/http` sur TOUTE réponse (en tête de la réserve de `HttpResponse`),
+     * statiques et pages d'erreur comprises
      * — pas par `@nodefony/security`, dont les clés homonymes sont inertes. Toute
      * console d'administration doit donc lire CE point, sinon elle affiche une
      * intention de configuration au lieu de l'état appliqué.
@@ -207,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`.
      *
@@ -474,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 :
@@ -522,6 +542,10 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     /**
      * Chemin d'erreur de {@link handleHttp} : libère le scope d'un contexte qui
      * n'a pas pu se construire, puis rend l'erreur au client (`onError`).
+     *
+     * Sans contexte, `onError` n'a rien sur quoi écrire : la réponse BRUTE
+     * reçoit alors un 500 nu. Sinon HTTP/1.1 coupait la connexion sans un octet
+     * et HTTP/2 laissait le flux pendu.
      */
     private failHttp;
     /**
@@ -545,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.
@@ -715,7 +748,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
         once(event: "close", listener: () => void): unknown;
     }): boolean;
     /**
-     * Re-valide tous les flux SSE et ferme ceux dont l'identité est morte.
+     * Re-valide tous les flux en cours et ferme ceux dont l'identité est morte.
      * Publique pour qu'un banc la déclenche sans attendre le tick.
      */
     revalidateStreams(): Promise<void>;

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/clientError.d.ts

@@ -1,6 +1,7 @@
 import type { Duplex } from "node:stream";
 /**
- * Gère l'event `clientError` d'un `http.Server` / `https.Server`.
+ * Gère l'event `clientError` d'un `http.Server` / `https.Server`, et des connexions
+ * HTTP/1.1 d'un serveur HTTP/2 à `allowHTTP1`.
  *
  * ⚠️ Doc Node (`http.Server` event `'clientError'`) : dès qu'un listener
  * `clientError` est attaché, Node **cesse de fermer le socket automatiquement**
@@ -11,7 +12,7 @@ import type { Duplex } from "node:stream";
  * @param error - erreur émise (codes `llhttp` : `HPE_*`, ou `ECONNRESET`…).
  * @param socket - flux client brut (l'event `clientError` fournit un `Duplex`).
  */
-export declare function handleClientError(error: NodeJS.ErrnoException, socket: Duplex): void;
+export declare function handleClientError(error: Error, socket: Duplex): void;
 /**
  * Gère l'event `sessionError` d'un serveur HTTP/2 (h2c ou TLS) : un pair PARTI
  * se tait, toute autre erreur est rapportée.

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

@@ -16,9 +16,11 @@ export interface IDrainTerminator {
  * Fabrique l'arrêt gracieux d'un serveur HTTP/1.1, HTTPS, HTTP/2 sur TLS ou h2c.
  *
  * Au `terminate()` (SIGTERM, `docker stop`), le serveur cesse d'accepter, puis :
- * - **HTTP/2** : chaque session reçoit un GOAWAY (`session.close()`) — les flux
- *   en vol se terminent, les nouveaux sont refusés, et le client sait qu'il doit
- *   rouvrir ailleurs au lieu de constater une coupure ;
+ * - **HTTP/2** : chaque session reçoit un GOAWAY en deux temps — d'abord à
+ *   `2^31-1` ({@link announceShutdown}), puis, un aller-retour plus tard, le
+ *   définitif (`session.close()`). Les flux en vol se terminent, les nouveaux
+ *   sont refusés, et le client sait qu'il doit rouvrir ailleurs au lieu de
+ *   constater une coupure ;
  * - **HTTP/1.1** : la réponse en vol part avec `Connection: close`, la socket
  *   inactive est fermée tout de suite, une requête qui arrive encore sur une
  *   socket gardée ouverte reçoit aussi `Connection: close`.
@@ -28,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/assets/prebuiltUi.d.ts

@@ -67,8 +67,8 @@ export interface IPrebuiltUiOptions {
  *     requête. Le SPA fallback reste au controller du module (routes littérales,
  *     cf. StudioController).
  *
- * Perf : l'index est lu UNE fois (lazy, caché) ; seule l'injection du nonce
- * coûte un `replaceAll` par rendu — route d'entrée UI, jamais un hot path.
+ * Perf : l'index est lu UNE fois (lazy, caché) et découpé UNE fois autour des
+ * emplacements du nonce ; un rendu ne coûte qu'un `join`.
  */
 export declare class PrebuiltUi {
     readonly publicPath: string;
@@ -76,6 +76,8 @@ export declare class PrebuiltUi {
     private readonly indexPath;
     /** Template HTML caché — `null` tant que non lu (lazy). */
     private template;
+    /** Index découpé autour des emplacements du nonce — `null` tant que non calculé. */
+    private nonceParts;
     constructor(opts: IPrebuiltUiOptions);
     /**
      * Monte `distDir` sous `publicPath` auprès de `server-static` (résolu par
@@ -90,8 +92,11 @@ export declare class PrebuiltUi {
      * Document HTML d'entrée de l'UI (index pré-buildé par Vite).
      *
      * @param nonce nonce CSP de la requête (`Context.cspNonce`) — injecté sur
-     *              chaque `<script>` ; les assets `src` same-origin passent déjà
-     *              par `'self'`, le nonce couvre un éventuel inline Vite.
+     *              chaque `<script>`, `src` compris : sous `'strict-dynamic'`
+     *              (ADR-0024 §C1), `'self'` est ignoré et seul le nonce autorise
+     *              une balise ; ce qu'elle importe ensuite hérite de la confiance.
+     *              Annoncé aussi par `<meta property="csp-nonce">` en tête de
+     *              `<head>` (ADR-0024 §C2) : les `<style>` créés à l'exécution.
      * @returns le HTML, ou un commentaire HTML fail-loud si l'index est absent
      */
     renderIndex(nonce?: string): string;

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

@@ -0,0 +1,109 @@
+import http from "node:http";
+import { Readable } from "node:stream";
+import type HttpContext from "./HttpContext.js";
+/**
+ * Réponse en FLUX D'OCTETS — la sortie d'un processus, le relais d'un autre
+ * service, une archive construite à la volée : toute source d'octets qui n'est
+ * pas un fichier du disque.
+ *
+ * Le cycle de vie (prise de la réponse, session, fermeture lue sur la réponse,
+ * plafond par IP, révocation, coupure d'un client qui ne lit plus) est celui de
+ * la brique commune au SSE (`StreamLifecycle`). Ce fichier porte ce qui est
+ * propre aux octets :
+ * - les en-têtes au PREMIER morceau : une erreur de la source avant lui passe
+ *   par le chemin d'erreur normal (`HttpKernel.onError`), donc un vrai 5xx ;
+ * - l'arrêt de la source par `destroy()`, jamais `unpipe()` — qui la laisse en
+ *   pause, et un producteur bloqué en écriture ne meurt plus ;
+ * - un chien de garde sur une source MUETTE (`idleTimeout`) : un seul minuteur
+ *   périodique par flux, qui compare le compteur d'octets — aucun minuteur ni
+ *   appel d'horloge par morceau (mesuré : l'horodatage par morceau coûtait
+ *   2 à 6 % de CPU sur des morceaux de 4 Kio) ;
+ * - la coupure (jamais une fin propre) quand la source échoue après le premier
+ *   octet : le client doit savoir que le corps est tronqué.
+ */
+/**
+ * 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é, 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` ;
+ * - `stall` : le client ne lisait plus depuis `stallTimeout`.
+ *
+ * L'union PEUT S'AGRANDIR : un `switch` exhaustif garde une branche `default`.
+ */
+export type ByteStreamEndReason = "end" | "client" | "error" | "timeout" | "stall";
+/** Ce que rend la fin d'un flux d'octets. */
+export interface IByteStreamResult {
+    /** Pourquoi le flux s'est terminé. */
+    reason: ByteStreamEndReason;
+    /** Octets écrits sur la réponse. */
+    bytes: number;
+}
+/** Options d'une réponse en flux d'octets. */
+export interface IByteStreamOptions {
+    /** Statut de la réponse, entre 200 et 599. Défaut : 200. */
+    status?: number | undefined;
+    /**
+     * En-têtes de la réponse, écrits au premier morceau. `Content-Length` est
+     * repris s'il est fourni ; sinon HTTP/1.1 envoie par morceaux. Défauts posés
+     * seulement s'ils manquent — ni ici, ni déjà sur la réponse :
+     * `Content-Type: application/octet-stream`, et pour un flux `live`
+     * `Cache-Control: no-cache, no-transform` et `X-Accel-Buffering: no`.
+     */
+    headers?: http.OutgoingHttpHeaders | undefined;
+    /**
+     * Flux VIVANT (défaut `true`) : la sortie d'un processus, un relais — un
+     * proxy inverse ne doit pas le mettre en tampon, ni un cache le garder, d'où
+     * `Cache-Control: no-cache, no-transform` et `X-Accel-Buffering: no` par
+     * défaut. `false` pour une source FINIE et rejouable (un fichier, une
+     * archive) : aucun de ces deux en-têtes n'est posé.
+     */
+    live?: boolean | undefined;
+    /**
+     * Délai maximal sans un octet de la source, en ms ; `0` le désarme. Au-delà :
+     * 504 si rien n'est encore parti, coupure sinon. Le silence est constaté
+     * par un tour de garde tous les quarts de délai : la coupure tombe entre
+     * `idleTimeout` et 1,25 × `idleTimeout`. Défaut : le délai de réponse
+     * du serveur (`responseTimeout`, 30 s). À garder sous le délai de lecture du
+     * proxy inverse (`proxy_read_timeout`, 60 s chez nginx).
+     */
+    idleTimeout?: number | undefined;
+    /**
+     * Délai maximal pendant lequel une écriture peut rester bloquée — le client
+     * ne lit plus —, en ms ; au-delà, la connexion est coupée. `false` pour
+     * l'éteindre. Défaut : 30 000, celui du SSE.
+     */
+    stallTimeout?: number | false | undefined;
+    /** Durée de vie maximale du flux, en ms. `false` (défaut) : pas de borne. */
+    maxDuration?: number | false | undefined;
+    /**
+     * Appelé une fois à la fin du flux, avec sa raison — AVANT la fin de la
+     * requête et la résolution de la promesse. Lié au contexte asynchrone de la
+     * requête.
+     */
+    onClose?: ((reason: ByteStreamEndReason) => void) | undefined;
+}
+/** Une source d'octets : flux Node, ou flux web (`fetch().body`). */
+export type ByteStreamSource = Readable | ReadableStream<Uint8Array>;
+/**
+ * Répond par un flux d'octets sur la réponse d'un contexte HTTP.
+ *
+ * Prend la réponse à l'appel (le noyau ne peut plus répondre par-dessus) ;
+ * les en-têtes partent au premier morceau de la source. La promesse se règle à
+ * la fin du flux, quelle qu'en soit la raison, et ne rejette JAMAIS.
+ *
+ * @param context - le contexte de la requête, pas encore répondu.
+ * @param source - flux Node, ou flux web (`fetch().body`) ; jamais en mode objet.
+ * @param options - statut, en-têtes, délais, écouteur de fin.
+ * @returns la raison de la fin et le nombre d'octets envoyés.
+ * @throws TypeError quand la source est en mode objet.
+ * @throws RangeError quand une option est hors bornes.
+ * @throws HttpError 500 quand la réponse est déjà partie ; 429 quand l'IP a
+ *   déjà tous ses flux et sockets (`wsMaxConnectionsPerIp`).
+ *
+ * La source appartient au flux dès l'appel : quand l'appel lève, elle est
+ * DÉTRUITE (un flux web est annulé) avant que l'erreur ne remonte.
+ */
+export declare function openByteStream(context: HttpContext, source: ByteStreamSource, options?: IByteStreamOptions): Promise<IByteStreamResult>;

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

@@ -2,7 +2,7 @@ import { ServerType, SchemeType } from "../../../service/http-kernel.js";
 import HttpError from "../../errors/httpError.js";
 import Context, { HTTPMethod } from "../Context.js";
 import { Container, Scope, nodefonyError } from "nodefony";
-import type { MaybePromise } from "nodefony";
+import type { DefaultEventsMap, EventsMap, MaybePromise } from "nodefony";
 import HttpRequest from "./Request.js";
 import HttpResponse from "./Response.js";
 import Http2Request from "../http2/Request.js";
@@ -43,8 +43,32 @@ export interface ProxyType {
 export declare function switchUrlScheme(from: URL, scheme: "http" | "https", port?: number): string;
 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 : 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)`).
+ *
+ * Pourquoi au serveur et pas sur la socket : Node y pose déjà son propre
+ * écouteur `timeout`, et un second faisait créer à `EventEmitter` un tableau
+ * d'écouteurs par CONNEXION. Ce site d'allocation, partagé avec tout le
+ * processus et toujours survivant (une connexion vit longtemps), finissait
+ * par être basculé dans le vieux tas par V8 (pretenuring) — dans un démarrage
+ * sur trois environ, mesuré sous charge. Le graphe de chaque requête y
+ * restait alors accroché jusqu'à la collecte complète suivante : +45 % de CPU
+ * par requête, 14 à 19 collectes complètes au lieu de 3. Un écouteur par
+ * 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 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 {
     proxy: ProxyType | null;
     /** Socket h1 inscrite dans `socketActiveContext` — retirée par `clean()`. */
@@ -56,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;
@@ -75,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
@@ -95,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`
@@ -157,11 +214,50 @@ declare class HttpContext extends Context implements IHttpContextInterface {
      *
      * La requête ne se termine qu'à `close()` du flux, ou au départ du client.
      *
+     * @typeParam Events - carte des événements du flux (cf `SseStream`).
      * @param options - battement de cœur, délai `retry:` initial.
      * @returns le flux, ou sa promesse quand une session est à sauver d'abord.
      * @throws HttpError 500 quand la réponse est déjà partie.
      */
-    openSse(options?: ISseStreamOptions): SseStream | Promise<SseStream>;
+    openSse<Events extends EventsMap = DefaultEventsMap>(options?: ISseStreamOptions): SseStream<Events> | Promise<SseStream<Events>>;
+    /**
+     * Répond par un FLUX D'OCTETS : un `<video src>`, un `fetch()`, un
+     * téléchargement ou un outil tiers (curl) le consomment comme n'importe quelle
+     * réponse HTTP, une réponse par consommateur.
+     *
+     * La réponse est prise à l'appel, ses en-têtes partent au premier morceau de
+     * la source. La source est DÉTRUITE à la fin, quelle qu'en soit la raison
+     * (jamais `unpipe`, qui laisse un producteur bloqué en écriture). Pour des
+     * événements texte lus par `EventSource`, voir {@link HttpContext.openSse}.
+     * Dans un middleware, la requête est répondue : ne pas appeler la suite.
+     *
+     * @param source - flux Node, ou flux web (`fetch().body`) ; jamais en mode objet.
+     * @param options - statut, en-têtes, délais, écouteur de fin.
+     * @returns la raison de la fin et le nombre d'octets ; ne rejette jamais.
+     * @throws HttpError 500 quand la réponse est déjà partie, 429 au-delà du
+     *   plafond de connexions par IP ; TypeError pour une source en mode objet.
+     *   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
@@ -194,7 +290,7 @@ declare class HttpContext extends Context implements IHttpContextInterface {
     getHost(): string | undefined;
     getUserAgent(): string | undefined;
     getMethod(): HTTPMethod;
-    setContentType(type?: string, encoding?: BufferEncoding): void | http.ServerResponse<http.IncomingMessage>;
+    setContentType(type?: string, encoding?: BufferEncoding): void;
     protected resolveIsHtml(): boolean;
     setDefaultContentType(): void;
     setContextJson(encoding?: BufferEncoding): void;