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

package/dist/types/nodefony/config/config.d.ts

@@ -108,6 +108,7 @@ export declare const httpConfigSchema: z.ZodObject<{
         }, z.core.$loose>]>>;
         skipUTF8Validation: z.ZodDefault<z.ZodBoolean>;
         autoPong: z.ZodDefault<z.ZodBoolean>;
+        maxPendingAutoPongs: z.ZodDefault<z.ZodNumber>;
         allowSynchronousEvents: z.ZodDefault<z.ZodBoolean>;
         maxBackpressure: z.ZodDefault<z.ZodNumber>;
         backpressureCloseAfterDrops: z.ZodDefault<z.ZodNumber>;
@@ -115,6 +116,8 @@ export declare const httpConfigSchema: z.ZodObject<{
             close: "close";
             drop: "drop";
         }>>;
+        maxFramesPerSecond: z.ZodDefault<z.ZodNumber>;
+        frameRateCloseAfterRejects: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>>;
     websocketSecure: z.ZodDefault<z.ZodObject<{
         keepaliveInterval: z.ZodDefault<z.ZodNumber>;
@@ -132,6 +135,7 @@ export declare const httpConfigSchema: z.ZodObject<{
         }, z.core.$loose>]>>;
         skipUTF8Validation: z.ZodDefault<z.ZodBoolean>;
         autoPong: z.ZodDefault<z.ZodBoolean>;
+        maxPendingAutoPongs: z.ZodDefault<z.ZodNumber>;
         allowSynchronousEvents: z.ZodDefault<z.ZodBoolean>;
         maxBackpressure: z.ZodDefault<z.ZodNumber>;
         backpressureCloseAfterDrops: z.ZodDefault<z.ZodNumber>;
@@ -139,6 +143,8 @@ export declare const httpConfigSchema: z.ZodObject<{
             close: "close";
             drop: "drop";
         }>>;
+        maxFramesPerSecond: z.ZodDefault<z.ZodNumber>;
+        frameRateCloseAfterRejects: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>>;
     statics: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -204,6 +210,14 @@ export declare const httpConfigSchema: z.ZodObject<{
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
+    grpc: z.ZodDefault<z.ZodObject<{
+        grpc: z.ZodDefault<z.ZodBoolean>;
+        grpcWeb: z.ZodDefault<z.ZodBoolean>;
+        connect: z.ZodDefault<z.ZodBoolean>;
+        readMaxBytes: z.ZodDefault<z.ZodNumber>;
+        writeMaxBytes: z.ZodDefault<z.ZodNumber>;
+        requireConnectProtocolHeader: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
     wsMaxConnectionsPerIp: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strict>;
 /** Type de sortie (config normalisée + défauts appliqués). */

package/dist/types/nodefony/grpc/GrpcCall.d.ts

@@ -0,0 +1,142 @@
+import type { ContextKey, ContextValues, HandlerContext } from "@connectrpc/connect";
+import type { IRpcCall, RpcSystem } from "../interfaces/IRpcCall.js";
+import type HttpContext from "../src/context/http/HttpContext.js";
+/**
+ * Fiche d'un appel gRPC : ce que Nodefony attache à l'appel, et le
+ * `ContextValues` que Connect remet au gestionnaire (`ctx.values`).
+ *
+ * Connect alloue à chaque appel un `ContextValues` fait d'un objet littéral et
+ * de trois fermetures (`context-values.js#createContextValues`), dont la forme
+ * change à chaque `set`. La fiche le REMPLACE (option `contextValues` de
+ * l'adaptateur) : une classe à champs déclarés, méthodes au prototype, une
+ * allocation par appel au lieu de quatre.
+ *
+ * Les clés posées par un tiers (intercepteur, porte) sont confiées à un
+ * `createContextValues()` créé au premier `set` : aucune allocation tant que
+ * personne n'en pose, et aucune conversion de type — la valeur rendue est celle
+ * que le magasin de Connect a typée.
+ *
+ * C'est aussi l'appel RPC du contexte (`HttpContext.rpc`, ADR-0026 D10) : à
+ * l'échéance du délai de réponse, le noyau le termine par {@link expire} ; au
+ * `close` de la réponse, il en fixe le code par {@link settle}, que lisent la
+ * ligne d'accès, l'audit et le canal de traçage.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export declare class GrpcCall implements ContextValues, IRpcCall {
+    #private;
+    /**
+     * L'objet qui implémente le service pour CET appel : le contrôleur, une
+     * instance par appel sous `@Scope("request")`. `null` quand l'adaptateur est
+     * appelé hors de {@link GrpcEndpoint.serve} (jamais en service normal).
+     */
+    readonly target: object | null;
+    /**
+     * Le contexte de la requête qui porte l'appel : l'identité y est lue
+     * (`authenticatedUser()`) sur son magasin, jamais par l'ALS, pour choisir
+     * entre 16 et 7 (ADR-0026 D5, D7). `null` hors de {@link GrpcEndpoint.serve}.
+     */
+    readonly context: HttpContext | null;
+    constructor(target: object | null, context?: HttpContext | null);
+    /**
+     * Le protocole parlé sur le fil : celui du contexte d'appel (`grpc`,
+     * `grpc-web`, `connect`) ; à défaut, celui des en-têtes de la requête.
+     */
+    get system(): RpcSystem;
+    /**
+     * `paquet.Service/Méthode` : le chemin de la route, que l'adaptateur a
+     * reconnu à l'octet près. Lu à la première demande, puis retenu.
+     */
+    get method(): string;
+    /** Le code de l'appel (0 à 16), `null` avant {@link settle}. */
+    get code(): number | null;
+    /** Le nom du code (`OK`, `UNAVAILABLE`…), `null` avec lui. */
+    get codeName(): string | null;
+    /**
+     * Fixe le code de l'appel au `close` de la réponse (ADR-0026 D10 point 2) :
+     *
+     * - motif `ConnectError` → son code ; sa cause, si c'est une `Error`, part
+     *   à la ligne d'accès (exception traduite par D7). Réponse NON finie : 1,
+     *   sauf une fin posée par le serveur (échéance 4, interruption de la fiche)
+     *   — le client est parti, quel que soit le code de son `RST_STREAM` ;
+     * - `AbortError` ou aucun motif → 0 si la réponse est finie, sinon 1 (le
+     *   client est parti — le 499 du noyau, dit en gRPC) ;
+     * - autre valeur → 13, et elle part à la ligne d'accès.
+     *
+     * Une interruption du serveur (délai échu, identité révoquée) abaisse le
+     * signal avec sa `ConnectError` : elle suit la première règle. Sans contexte
+     * d'appel, le code reste `null`.
+     *
+     * @param ended - la réponse a-t-elle été terminée par le serveur ?
+     * @returns la cause à porter par la ligne d'accès, `null` sinon.
+     */
+    settle(ended: boolean): Error | null;
+    /**
+     * Lit une valeur posée par un tiers, ou la valeur par défaut de sa clé.
+     *
+     * @param key - la clé (`createContextKey`).
+     * @returns la valeur posée, sinon `key.defaultValue`.
+     */
+    get<T>(key: ContextKey<T>): T;
+    /**
+     * Pose une valeur pour la durée de l'appel.
+     *
+     * @param key - la clé (`createContextKey`).
+     * @param value - la valeur.
+     * @returns la fiche, pour chaîner.
+     */
+    set<T>(key: ContextKey<T>, value: T): this;
+    /**
+     * Retire une valeur ; sa clé rendra de nouveau sa valeur par défaut.
+     *
+     * @param key - la clé (`createContextKey`).
+     * @returns la fiche, pour chaîner.
+     */
+    delete(key: ContextKey<unknown>): this;
+    /**
+     * Le délai de réponse du serveur est échu : le signal de l'appel s'abaisse
+     * (`ctx.abort`) et l'appel se termine en 4 `DEADLINE_EXCEEDED`, même si le
+     * gestionnaire ne lit pas son signal. Échu avant que le gestionnaire ne
+     * démarre : il est terminé dès son démarrage. Sans effet après la fin.
+     */
+    expire(): void;
+    /**
+     * L'identité qui a ouvert l'appel n'est plus valable : le signal de l'appel
+     * s'abaisse et l'appel se termine en 16 `UNAUTHENTICATED`. Réponse unique :
+     * sa promesse est rejetée. Flux : il s'arrête au message suivant, même si le
+     * gestionnaire ne lit pas son signal — au plus le message déjà en vol part.
+     * Sans effet après la fin, ou après une autre interruption.
+     */
+    revoke(): void;
+    /**
+     * Le serveur s'arrête : le signal de l'appel s'abaisse et l'appel se termine
+     * en 14 `UNAVAILABLE` — le client le rejoue ailleurs (ADR-0026 D8). Flux : il
+     * s'arrête au message suivant, même si le gestionnaire ne lit pas son
+     * signal. Un gestionnaire bloqué qui n'écoute rien tombe avec sa connexion, à
+     * `shutdownTimeout`. Sans effet après la fin, ou après une autre interruption.
+     */
+    shutdown(): void;
+}
+/**
+ * Le contexte d'appel que Connect remet réellement au gestionnaire : son type
+ * public (`HandlerContext`) ne dit pas `abort`, que porte pourtant l'objet créé
+ * par `createHandlerContext` (`HandlerContextController`, non exporté).
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IAbortableHandlerContext extends HandlerContext {
+    /** Interrompt l'appel : `ctx.signal` s'abaisse avec `reason`. */
+    abort(reason?: unknown): void;
+}
+/**
+ * Garde de type : le contexte d'appel porte-t-il `abort` ? Connect le pose sur
+ * tout contexte qu'il crée ; le garde le CONSTATE au lieu de le supposer, pour
+ * qu'une version de Connect qui le retirerait se voie à l'exécution (et au
+ * test qui le garde) plutôt que par un appel qui ne s'interrompt plus.
+ *
+ * @param ctx - le contexte remis au gestionnaire.
+ * @returns `true` si `ctx.abort` est une fonction.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export declare function hasAbort(ctx: HandlerContext): ctx is IAbortableHandlerContext;

package/dist/types/nodefony/grpc/GrpcEndpoint.d.ts

@@ -0,0 +1,98 @@
+import type { DescService } from "@bufbuild/protobuf";
+import type HttpContext from "../src/context/http/HttpContext.js";
+/**
+ * Protocoles servis — la section `grpc` de la configuration http
+ * (ADR-0026 D3, point 5).
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IGrpcProtocols {
+    readonly grpc: boolean;
+    readonly grpcWeb: boolean;
+    readonly connect: boolean;
+}
+/**
+ * La section `grpc` de la configuration http : protocoles servis (D3, point
+ * 5) et bornes des messages (D4, points 1, 2 et 6).
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IGrpcSettings extends IGrpcProtocols {
+    /** Taille maximale d'un message reçu, après décompression (octets). */
+    readonly readMaxBytes: number;
+    /** Taille maximale d'un message émis (octets). */
+    readonly writeMaxBytes: number;
+    /** Exige l'en-tête `Connect-Protocol-Version` sur les requêtes Connect. */
+    readonly requireConnectProtocolHeader: boolean;
+}
+/**
+ * Options d'un {@link GrpcEndpoint}.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IGrpcEndpointOptions {
+    /**
+     * `true` : la cible change à chaque appel (contrôleur `@Scope("request")`),
+     * chaque méthode la relit dans la fiche d'appel. `false` (défaut) : la cible
+     * du premier appel sert tous les suivants (contrôleur singleton) et ses
+     * méthodes sont liées une fois — aucune indirection par appel.
+     */
+    readonly perCall?: boolean;
+}
+/**
+ * Point d'entrée gRPC d'un service : possède l'adaptateur Connect
+ * (`connectNodeAdapter`) et lui confie la requête et la réponse BRUTES de Node
+ * d'un contexte déjà passé par le pipeline (pare-feu, gardes).
+ *
+ * L'adaptateur est construit au premier appel, depuis la section `grpc` de la
+ * configuration http. Il reçoit la fiche d'appel ({@link GrpcCall}) par son
+ * option `contextValues`, qu'il appelle de façon SYNCHRONE avant toute
+ * attente (`connect-node-adapter.js#nodeRequestHandler`) : la cible passe par
+ * une case lue à cet instant — ni ALS, ni promesse, ni écouteur de plus.
+ *
+ * Les méthodes s'inscrivent une à une par `router.rpc`, SANS options : des
+ * options passées à l'inscription rallumeraient gRPC et gRPC-Web coupés par la
+ * configuration (connectrpc/connect-es#1835). La restriction de protocoles
+ * vit sur l'adaptateur seul.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export declare class GrpcEndpoint<S extends DescService = DescService> {
+    #private;
+    /** Le contrat servi (descripteur généré par `buf`). */
+    readonly service: S;
+    /** Cible relue à chaque appel (`@Scope("request")`). */
+    readonly perCall: boolean;
+    constructor(service: S, options?: IGrpcEndpointOptions);
+    /**
+     * Remet la requête du contexte à l'adaptateur, qui écrit lui-même la
+     * réponse et ses trailers. Synchrone : rien n'est attendu ici.
+     *
+     * Avant de la remettre : le contexte est marqué répondu (`sended`), si bien
+     * que le pipeline n'attend aucune réponse de l'action.
+     *
+     * - Appel unaire : le délai de réponse de Nodefony reste armé, et termine
+     *   l'appel en 4 `DEADLINE_EXCEEDED` par sa fiche (`HttpContext.rpc`,
+     *   ADR-0026 D4 point 3).
+     * - Flux : aucune échéance. Il s'ouvre par le cycle de vie d'un flux
+     *   (`openStreamLifecycle`, D4 point 4) — délai de réponse désarmé (à
+     *   l'expiration il écrirait un 503 par-dessus l'adaptateur), place dans
+     *   le budget de connexions longues par IP, client qui ne lit plus coupé
+     *   par le balayage de blocage. Synchrone, sauf quand une session est à
+     *   sauver : l'appel n'est remis qu'après.
+     *
+     * @param context - le contexte HTTP de la requête, pas encore répondu.
+     * @param target - l'objet qui implémente le service pour cet appel.
+     * @returns rien, ou la promesse de la remise quand une session est à sauver.
+     * @throws HttpError 500 quand la réponse est déjà partie, ou que son
+     *   transport n'est pas reconnu.
+     * @throws HttpError 429 quand l'IP du client a déjà tous ses flux et sockets
+     *   (`wsMaxConnectionsPerIp`) — rendu par le pipeline en 14 `UNAVAILABLE`.
+     * @throws HttpError 400 quand l'adaptateur refuse la requête avant d'avoir
+     *   rien écrit (requête sans autorité `Host`) — la réponse revient alors au
+     *   pipeline.
+     * @throws HttpError 404 quand aucune méthode ne correspond au chemin exact
+     *   (casse modifiée) — rendu par le pipeline en 12 `UNIMPLEMENTED`.
+     */
+    serve(context: HttpContext, target: object): void | Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * `@nodefony/http/grpc` — la primitive de transport gRPC (ADR-0026).
+ *
+ * Sous-chemin à part : le point d'entrée principal de `@nodefony/http` ne cite
+ * ni Connect ni protobuf, même en type (D12). Seule une application qui
+ * déclare un service l'importe — par `@nodefony/framework/grpc` — et charge
+ * alors Connect au démarrage.
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export { GrpcCall, hasAbort } from "./GrpcCall.js";
+export type { IAbortableHandlerContext } from "./GrpcCall.js";
+export { GrpcEndpoint } from "./GrpcEndpoint.js";
+export type { IGrpcEndpointOptions, IGrpcProtocols, IGrpcSettings, } from "./GrpcEndpoint.js";
+export { markGrpcRoute } from "../src/grpc/refusal.js";

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

@@ -3,6 +3,7 @@ import type { MaybePromise } from "nodefony";
 import type { ICookie } from "./ICookie.js";
 import type { ISession } from "./ISession.js";
 import type { HTTPMethodType } from "./IRequest.js";
+import type { IRpcCall } from "./IRpcCall.js";
 /**
  * Identité du serveur qui a reçu la requête, nommée par le schéma d'URI qu'il
  * sert en LOCAL (RFC 9110 §4.2, RFC 6455 §3) : elle choisit la section de
@@ -156,6 +157,14 @@ export interface IContext {
 export interface IHttpContext extends IContext {
     proxy: object | null;
     isRedirect: boolean;
+    /**
+     * L'appel RPC servi par cette requête (gRPC, gRPC-Web, Connect), `null` hors
+     * appel RPC — ADR-0026 D10. Son code est fixé au `close`, avant la ligne
+     * d'accès.
+     *
+     * @experimental Surface gRPC, ADR-0026 D11.
+     */
+    rpc: IRpcCall | null;
     /**
      * Sert la requête — synchrone quand l'action et son rendu le sont.
      *

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

@@ -11,6 +11,20 @@ export interface IErrorHttpResult {
     body: unknown;
     headers?: Record<string, string | number>;
 }
+/**
+ * Ce qu'une route HTTP rendrait pour une erreur — son statut et le message
+ * destiné au client —, sans rien écrire. Sert les transports qui n'ont pas de
+ * corps d'erreur à rendre : un appel gRPC traduit ce statut en code
+ * (ADR-0026 D7).
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IErrorDescription {
+    /** Statut HTTP émettable (100 à 599). */
+    readonly status: number;
+    /** Message pour le client : opaque pour un 5xx en production. */
+    readonly message: string;
+}
 /**
  * Aide jointe au corps d'erreur — ce que le développeur doit faire, en clair.
  *

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

@@ -1,5 +1,6 @@
 import type { URL } from "node:url";
 import type { ICookie } from "./ICookie.js";
+import type { IUploadedFile } from "./IUpload.js";
 export type HTTPMethodType = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE" | "PATCH" | "WEBSOCKET";
 export interface IRequest {
     url: URL | string;
@@ -19,7 +20,7 @@ export interface IHttpRequest extends IRequest {
     url: URL;
     query: Record<string, unknown>;
     body: RequestBody;
-    files: readonly unknown[];
+    files: readonly IUploadedFile[];
     remoteAddress: string | null | undefined;
     acceptHtml: boolean;
     getRemoteAddress(): string | null | undefined;

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

@@ -1,5 +1,6 @@
 import type { SchemeType } from "./IContext.js";
 import type { HTTPMethodType } from "./IRequest.js";
+import type { IRpcOutcome } from "./IRpcCall.js";
 /**
  * Nature de l'opération tracée : une requête HTTP, ou le handshake d'une
  * connexion WebSocket.
@@ -53,4 +54,13 @@ export interface IRequestTrace {
      * sans exception n'en porte pas ; c'est à l'abonné de classer un statut.
      */
     readonly error: unknown;
+    /**
+     * L'appel RPC (gRPC, gRPC-Web, Connect) servi par la requête, `null` hors
+     * RPC : système, méthode, code et son nom (ADR-0026 D10 point 5). Un flux
+     * est UN message, de l'ouverture au `close` ; rien par message.
+     * `statusCode` reste le statut HTTP, vrai sur le fil.
+     *
+     * @experimental Surface gRPC, ADR-0026 D11.
+     */
+    readonly rpc: IRpcOutcome | null;
 }

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

@@ -40,12 +40,37 @@ export interface IFirewallGate {
     enforceCsrf(context: ContextType): void;
     /** Répond au preflight CORS ; `204` quand la réponse est déjà envoyée. */
     handleCors(context: ContextType): number | undefined;
-    /** Pose les en-têtes de sécurité (CSP, HSTS…) de la réponse. */
-    applySecurityHeaders(context: ContextType): void;
+    /**
+     * Pose les en-têtes de sécurité applicatifs (CSP, Permissions-Policy…) de la
+     * réponse, appelé par la réponse juste avant son `writeHead`.
+     *
+     * @param contentType - `Content-Type` de la réponse, qui choisit la politique ;
+     *   `null` = réponse sans contenu ; omis = type inconnu (politique complète).
+     * @param servedAsFile - corps servi tel quel (fichier statique, relais) : aucun
+     *   gabarit ne l'a écrit, il ne peut pas porter de nonce.
+     */
+    applySecurityHeaders(context: ContextType, contentType?: string | null, servedAsFile?: boolean): void;
     /**
      * Le revalidateur de l'identité authentifiée de la requête courante, pour une
      * connexion longue qui la gardera (flux SSE) : la même règle que les sockets
      * WebSocket. `null` pour un anonyme — rien à révoquer.
      */
     currentRevalidator?(): ((nowMs?: number) => Promise<boolean>) | null;
+    /**
+     * Prévenu quand le noyau HTTP a recalculé ses en-têtes de transport (édition à
+     * chaud de `securityHeaders`) : la politique de contenu suit `frameOptions`,
+     * qui pilote aussi `frame-ancestors`.
+     */
+    onTransportHeadersChanged?(): void;
+    /**
+     * Déclare les sources qu'un module ajoute à la politique de contenu
+     * (`{ "connect-src": ["wss://rt.example.com"] }`). Un second appel du même
+     * module REMPLACE sa contribution. Absent quand aucun pare-feu ne pose de CSP.
+     *
+     * @param moduleName - module qui contribue, clé de sa contribution
+     * @param fragment - sources par directive, origines exactes (sans joker)
+     */
+    registerCspOrigins?(moduleName: string, fragment: Readonly<Record<string, readonly string[]>>): void;
+    /** Retire la contribution CSP de `moduleName`. */
+    unregisterCspOrigins?(moduleName: string): void;
 }

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

@@ -13,7 +13,8 @@ import type { Profiler } from "../src/profiler/Profiler.js";
  *    `?connection=<requestId>` : les seules frames de cette socket WebSocket
  *  - `GET /nodefony/profiler/api/summary` → les profils de l'anneau agrégés par
  *    route (percentiles, phases, formes SQL, N+1, erreurs — `aggregateProfiles`)
- *  - `GET /nodefony/profiler/api/{id}`    → profil complet (phases) d'un requestId
+ *  - `GET /nodefony/profiler/api/{id}`    → profil complet (phases) d'un requestId ;
+ *    absent → 404 `{ startedAt, clearedAt }` : depuis quand l'anneau sait quelque chose
  *  - `DELETE /nodefony/profiler/api/recent` → vide le ring buffer
  *
  * La debug bar (toute page, dev) lit `X-Request-Id` de SON appel AJAX puis