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

package/dist/types/nodefony/src/context/http2/Response.d.ts

@@ -9,8 +9,9 @@ interface IHeaderSource {
     getHeader(name: string): http.OutgoingHttpHeader | undefined;
 }
 /**
- * Compose les en-têtes d'une réponse HTTP/2 : ceux posés sur la réponse, puis
- * ceux passés à `writeHead`, qui gagnent.
+ * Compose les en-têtes d'une réponse HTTP/2 : ceux qu'un tiers a écrits sur la
+ * réponse Node, puis ceux de la réserve de la réponse, puis ceux passés à
+ * `writeHead` — chacun l'emporte sur le précédent.
  *
  * Les clés sont ramenées en MINUSCULES : `getHeaders()` rend `content-type`,
  * un contrôleur passe `Content-Type` — fusionnées telles quelles, les deux
@@ -26,9 +27,10 @@ interface IHeaderSource {
  * @param statusMessage - message de statut, recopié en `x-status-message`
  * @param current - la réponse Node qui porte les en-têtes déjà posés
  * @param extra - en-têtes passés à `writeHead` (objet, ou liste plate clé/valeur)
+ * @param stored - la réserve de la réponse, liste plate aux noms en minuscules
  * @returns les en-têtes à transmettre à `respond()`
  */
-export declare function mergeResponseHeaders(statusMessage: string, current: IHeaderSource, extra?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): http.OutgoingHttpHeaders;
+export declare function mergeResponseHeaders(statusMessage: string, current: IHeaderSource, extra?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[], stored?: readonly http.OutgoingHttpHeader[]): http.OutgoingHttpHeaders;
 declare class Http2Response extends HttpResponse {
     statusCode: number;
     stream: http2.ServerHttp2Stream | null;
@@ -52,8 +54,9 @@ declare class Http2Response extends HttpResponse {
      */
     end(chunk?: string | Buffer, encoding?: BufferEncoding): MaybePromise<http.ServerResponse | http2.ServerHttp2Stream>;
     /**
-     * Termine la réponse de compatibilité d'un HEAD, dont Node a clos le flux de
-     * lui-même au `respond()`.
+     * Termine la réponse de compatibilité d'un HEAD, ou d'une réponse gRPC
+     * _Trailers-Only_ (statut gRPC dans les en-têtes), dont le flux s'est clos
+     * au `respond()`.
      *
      * Sans ce geste, `Http2ServerResponse` n'émet ni `finish` ni `close` : le
      * démontage de la requête, branché sur ce `close` (ligne d'accès, profil,
@@ -68,5 +71,37 @@ declare class Http2Response extends HttpResponse {
         code: number;
         message: string;
     };
+    /**
+     * Règle le sort d'un corps non lu quand la réponse part avant qu'il soit
+     * consommé (408 délai, 413 trop gros, refus précoce) : les octets en tampon
+     * sont jetés, puis — une fois la réponse écrite — le flux est fermé en
+     * `NO_ERROR` si le client ÉMET ENCORE.
+     *
+     * RFC 9113 §8.1 : après une réponse complète, le serveur PEUT demander au
+     * client d'arrêter d'émettre par un `RST_STREAM` `NO_ERROR`. `node:http2` ne
+     * le fait pas : le flux resterait ouvert tant que le client émet, et un
+     * client lent garderait sa place de flux sur la session. Attendre `finish`
+     * (fin d'écriture) garantit que la réponse elle-même n'est pas tronquée.
+     *
+     * « Émet encore » se décide après une GRÂCE d'un aller-retour
+     * ({@link closeStreamAfterGrace} : un `PING` par session pour tous les
+     * flux qui attendent, puis l'état du flux). Fini → le flux se ferme seul,
+     * sans `RST_STREAM` ; sinon — client qui émet encore, ou muet — fermé.
+     * Jamais de coupe avant la grâce : un `RST_STREAM` soumis pendant que la
+     * réponse attend dans la file de nghttp2 la fait jeter, et le client reçoit
+     * une fin de flux sans statut. grpc-go, Go `net/http2` et nginx coupent AUSSITÔT : Node, lui,
+     * répond avant de lire les trames DATA déjà en route, et la coupe
+     * immédiate frappait des clients qui finissaient d'émettre — le client
+     * HTTP/2 de Go la lit en erreur (ADR-0026 D13 point 1, constaté par la
+     * suite de conformité de Connect). `request.complete` ne dit rien ici : il
+     * ne passe à `true` qu'une fois le corps CONSOMMÉ.
+     *
+     * Chemin d'erreur seulement : un `PING` par aller-retour et par session,
+     * quel que soit le nombre de refus en attente.
+     *
+     * Sans effet si le corps est entièrement consommé, ou le flux déjà fermé.
+     * Peut s'appeler avant comme après l'écriture de la réponse.
+     */
+    closeUnfinishedRequest(): void;
 }
 export default Http2Response;

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

@@ -1,4 +1,5 @@
 import type { IRequestTrace, RequestTraceProtocol } from "../../interfaces/IRequestTrace.js";
+import type { IRpcOutcome } from "../../interfaces/IRpcCall.js";
 import type Context from "./Context.js";
 /**
  * Nom du `TracingChannel` qui encadre chaque requête HTTP et chaque handshake
@@ -60,5 +61,6 @@ export declare function runTraced<ThisArg, Args extends unknown[], Result>(trace
  * @param context - le contexte de la requête
  * @param statusCode - le statut rendu au client, `null` s'il n'y en a pas eu
  * @param error - l'exception attrapée par le pipeline, `null` ou `undefined` sinon
+ * @param rpc - l'appel RPC de la requête, `null` hors RPC : copié, jamais publié tel quel
  */
-export declare function closeRequestTrace(context: Context, statusCode: number | null, error: unknown): void;
+export declare function closeRequestTrace(context: Context, statusCode: number | null, error: unknown, rpc?: IRpcOutcome | null): void;

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

@@ -0,0 +1,11 @@
+import type { IRpcOutcome } from "../../interfaces/IRpcCall.js";
+/**
+ * Copie le résultat d'un appel RPC — les quatre champs, jamais la fiche
+ * d'appel entière, qui porte le contrôleur et le contexte (ADR-0026 D10). La
+ * forme est fixe : un objet par appel, alloué seulement par qui publie (audit
+ * JSON, canal de traçage avec abonné).
+ *
+ * @param call - l'appel RPC de la requête, `null` hors RPC.
+ * @returns sa copie, `null` hors RPC.
+ */
+export declare function rpcOutcomeOf(call: IRpcOutcome | null): IRpcOutcome | null;

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

@@ -51,3 +51,20 @@ export declare function requestAuthority(headers: {
     host?: string | undefined;
     ":authority"?: string | undefined;
 }): string | undefined;
+/**
+ * Une requête HTTP/2 nomme-t-elle deux hôtes — `:authority` ET un `Host`
+ * différent ? RFC 9113 §8.3.1 : « SHOULD treat a request as malformed ». Le
+ * serveur lit `:authority` ({@link requestAuthority}), mais un code qui lit
+ * `headers.host` verrait un autre hôte que celui que le routage et le
+ * pare-feu ont jugé.
+ *
+ * Chemin de chaque requête : une lecture d'en-tête ; la comparaison n'a lieu
+ * que si les deux sont présents (un navigateur n'envoie pas `Host` en HTTP/2).
+ *
+ * @param headers - en-têtes de la requête Node.
+ * @returns `true` quand les deux autorités diffèrent (casse ignorée).
+ */
+export declare function hasConflictingAuthority(headers: {
+    host?: string | undefined;
+    ":authority"?: string | undefined;
+}): boolean;

package/dist/types/nodefony/src/context/websocket/Response.d.ts

@@ -54,7 +54,12 @@ declare class WebsocketResponse {
     handshakeHeaders: Record<string, string | number> | null;
     /**
      * Retient un en-tête du handshake (cf {@link handshakeHeaders}) ; sans effet
-     * une fois la socket ouverte, où il n'y a plus de réponse HTTP.
+     * une fois la socket ouverte, où il n'y a plus de réponse HTTP — sauf
+     * `Retry-After` posé par une action invoquée par le pont `api.request` : il
+     * va au puits de CETTE invocation, et le pont le sert avec le refus. Le même
+     * code de contrôleur dit donc « réessaie dans N s » sur les deux transports.
+     * Seul cet en-tête passe : un `Set-Cookie` ou un `WWW-Authenticate` n'a
+     * aucun sens sur une trame, et rien d'autre ne doit fuir par là.
      *
      * @param name - nom de l'en-tête
      * @param value - valeur

package/dist/types/nodefony/src/context/websocket/WebsocketContext.d.ts

@@ -1,6 +1,7 @@
 import Context from "../Context.js";
 import { ServerType, SchemeType } from "../../../service/http-kernel.js";
 import { Severity, Msgid, Message, nodefonyError, Scope } from "nodefony";
+import type { IFrameCodec } from "nodefony";
 import Ws from "ws";
 import type { IncomingMessage } from "node:http";
 import WebsocketResponse from "./Response.js";
@@ -11,6 +12,7 @@ import HttpError from "../../errors/httpError.js";
 import { FrameProfile } from "../../profiler/FrameProfile.js";
 import type { PhaseName, IWebsocketContext } from "../../../interfaces/IContext.js";
 import { ProxyType } from "../http/HttpContext.js";
+import { type IFrameRateWindow } from "./wsFrameRate.js";
 import { type ResolvedProxy } from "../forwarded.js";
 export interface IWsRequestExtension {
     url: URL;
@@ -70,10 +72,22 @@ declare class WebsocketContext extends Context implements IWebsocketContextInter
     request: WsIncomingMessage | null;
     response: WebsocketResponse | null;
     acceptedProtocol?: string | undefined;
+    /**
+     * Codec des trames BINAIRES de cette connexion, posé par la couche qui l'a négocié
+     * (le temps réel, ADR-0022 §2). Hors production, le traceur s'en sert pour
+     * afficher une trame binaire décodée plutôt que sa seule taille ; jamais lu en
+     * production. `null` = octets bruts, résumés à leur taille.
+     */
+    frameCodec: IFrameCodec | null;
     port: number | string;
     rejected: boolean;
     teardownWired: boolean;
     connection: Ws | null;
+    /**
+     * Fenêtre de la borne de débit entrante — `null` tant que la borne est
+     * désactivée ou qu'aucune trame n'est arrivée (créée au premier usage).
+     */
+    frameRate: IFrameRateWindow | null;
     /**
      * Le verdict du handshake encore à rendre : posé par le noyau tant que le
      * pipeline décide (pare-feu, garde de l'action), `null` dès que la socket
@@ -109,7 +123,31 @@ declare class WebsocketContext extends Context implements IWebsocketContextInter
     handle(data?: unknown[]): Promise<this>;
     render(chunk: unknown, encoding?: BufferEncoding): Promise<WebsocketResponse>;
     send(data?: string | Buffer | null, encoding?: BufferEncoding): Promise<WebsocketResponse>;
+    /**
+     * Rend le corps rendu (`setBody`) en le RETIRANT de la réponse : une trame
+     * envoyée n'a plus à vivre aussi longtemps que la connexion.
+     *
+     * @param response - la réponse de ce contexte
+     * @returns le corps rendu, ou `null` s'il n'y en a pas
+     */
+    private static takeRenderedBody;
     broadcast(data?: string | Buffer | null, encoding?: BufferEncoding): null | undefined;
+    /**
+     * Le contenu des messages est-il journalisé ? Hors production seulement —
+     * décidé une fois pour le processus (P8 : runtime ∈ {development, production},
+     * `resolveRuntimeEnv`).
+     */
+    private tracesMessageContent;
+    /**
+     * Traceur des trames SORTANTES écrites hors de {@link send} — le temps réel
+     * écrit droit sur la socket. À demander UNE fois par connexion : `null` en
+     * production, donc l'appelant choisit son chemin d'écriture à l'ouverture et
+     * ne paie rien par trame.
+     *
+     * @returns une fonction qui journalise une trame comme `send` (`WS SEND`),
+     *   ou `null` quand le contenu des messages n'est pas journalisé.
+     */
+    outboundTracer(): ((data: unknown) => void) | null;
     /**
      * Logge le CONTENU d'un message WS (corrélé `requestId` via l'override `log`),
      * gaté hors prod et borné — le Suivi de requête (Studio) le surface alors par
@@ -150,6 +188,16 @@ declare class WebsocketContext extends Context implements IWebsocketContextInter
      */
     phaseStart(name: PhaseName): void;
     phaseEnd(name: PhaseName): void;
+    /**
+     * Applique la borne de débit entrante à une trame : `true` = l'admettre.
+     *
+     * Écartée → comptée (`frameRateRejectedTotal`) ; solde de refus atteint →
+     * connexion fermée en `1008` (RFC 6455 §7.4.1, violation de politique).
+     *
+     * @param bound - trames admises par seconde (`> 0`)
+     * @returns `true` si la trame poursuit son chemin
+     */
+    private admitInboundFrame;
     handleMessage(data: Buffer | string, isBinary: boolean): Promise<unknown>;
     onClose(code: number, reason: Buffer): void;
     /**

package/dist/types/nodefony/src/context/websocket/websocketUrl.d.ts

@@ -7,6 +7,10 @@
  * un hôte de l'autre — et une route acceptée par l'une serait refusée par
  * l'autre.
  *
+ * Une cible en forme absolue (`http://hôte/chemin`, RFC 6455 §4.2.1) donne son
+ * hôte, et l'en-tête `Host` est ignoré (RFC 9112 §3.2.2) — la même règle que
+ * `HttpRequest.getHost`.
+ *
  * @param scheme - `ws` ou `wss`
  * @param host - en-tête `Host` de la requête (`localhost` s'il manque)
  * @param rawUrl - cible brute de la requête (`/` si elle manque)

package/dist/types/nodefony/src/context/websocket/wsBackpressure.d.ts

@@ -1,6 +1,7 @@
 import Ws, { WebSocketServer } from "ws";
+import { type BackpressurePolicy, type BackpressureVerdict } from "nodefony";
 /** Politique appliquée quand le buffer d'envoi d'un client dépasse le seuil. */
-export type WsBackpressurePolicy = "drop" | "close";
+export type WsBackpressurePolicy = BackpressurePolicy;
 /**
  * Options de backpressure SORTANTE (serveur → client).
  *
@@ -24,6 +25,10 @@ export interface IWsBackpressureOptions {
 export interface IBackpressureTarget {
     readonly bufferedAmount?: number;
     close(code?: number, reason?: string): void;
+    /** Cumul des frames refusées pour contre-pression (lazy — lu par la sonde socket). */
+    _nfDrops?: number;
+    /** Solde de refus courant (cf {@link nextDropBalance}) ; absent = 0. */
+    _nfDropStreak?: number;
 }
 /** Socket augmentée d'un compteur de drops (number lazy — lu par la sonde socket). */
 export interface IBackpressureSocket extends Ws {
@@ -37,7 +42,7 @@ export interface IBackpressureSocket extends Ws {
     _nfDropStreak?: number;
 }
 /** Décision pour une frame : l'émettre, la sauter, ou (socket fermée) ne rien faire. */
-export type WsSendDecision = "send" | "drop" | "close";
+export type WsSendDecision = BackpressureVerdict;
 /**
  * Relit le seuil + la politique depuis les options du `WebSocketServer`.
  *
@@ -65,9 +70,14 @@ export declare const readBackpressureOptions: (wss: WebSocketServer | null | und
  * « Try Again Later » → le client peut back-off + reconnecter). NE FAIT PAS le `send()`
  * — le caller émet uniquement si le retour vaut `"send"`.
  *
+ * La DÉCISION est celle du cœur (`decideBackpressure` / `nextDropBalance`, partagée
+ * avec `NodefonySocket`) ; cette fonction n'en porte que l'état (compteurs sur la
+ * socket) et le geste serveur (fermeture `1013`).
+ *
  * @param ws - la socket destinataire
  * @param max - seuil d'octets (`<= 0` → désactivé)
  * @param policy - action au dépassement
+ * @param closeAfterDrops - solde de refus qui ferme (`0` = jamais)
  * @returns `"send"` (émettre) · `"drop"` (sauter cette frame) · `"close"` (socket fermée)
  */
 export declare const decideSend: (ws: IBackpressureTarget, max: number, policy: WsBackpressurePolicy, closeAfterDrops?: number) => WsSendDecision;

package/dist/types/nodefony/src/context/websocket/wsFrameRate.d.ts

@@ -0,0 +1,69 @@
+import { type BackpressureVerdict } from "nodefony";
+/**
+ * Options de la borne de débit ENTRANTE (client → serveur), lues dans `wss.options`.
+ *
+ * Knobs Nodefony (pas des options `ws`), conservés par le spread du constructeur
+ * de `ws` — même voie que `IWsBackpressureOptions`.
+ */
+export interface IWsFrameRateOptions {
+    /** Trames reçues admises par seconde et par connexion ; `0`/absent = désactivée. */
+    maxFramesPerSecond?: number;
+    /** Solde de trames écartées qui ferme la connexion (`1008`) ; `0` = jamais. */
+    frameRateCloseAfterRejects?: number;
+}
+/**
+ * Fenêtre de comptage d'une connexion, créée à la PREMIÈRE trame reçue borne activée.
+ *
+ * Mutée en place : aucune allocation par trame.
+ */
+export interface IFrameRateWindow {
+    /** Début de la fenêtre courante (ms, `Date.now()`). */
+    start: number;
+    /** Trames reçues dans la fenêtre courante. */
+    count: number;
+    /** Solde de refus (+1 par trame écartée, −1 par trame admise). */
+    balance: number;
+}
+/** Durée d'une fenêtre de comptage (ms) : la borne s'exprime en trames PAR SECONDE. */
+export declare const FRAME_RATE_WINDOW_MS = 1000;
+/**
+ * Nombre cumulé de trames entrantes écartées par la borne de débit dans ce processus (unité : une trame reçue).
+ *
+ * Monotone, `0` tant que la borne est désactivée. Relayé par la sonde du hub
+ * temps réel sous le nom figé `frameRateRejectedTotal` (ADR-0021 §S9).
+ *
+ * @returns le cumul depuis le démarrage du processus
+ */
+export declare const frameRateRejectedTotal: () => number;
+/**
+ * Borne de débit entrante du serveur WebSocket (`maxFramesPerSecond`) ; `0` = désactivée.
+ *
+ * Appelée à chaque trame : une lecture de propriété, aucune allocation.
+ *
+ * @param server - le serveur du contexte (`context.server`)
+ * @returns trames admises par seconde, `0` si la borne est désactivée
+ */
+export declare const readFrameRateBound: (server: unknown) => number;
+/**
+ * Solde de refus qui ferme la connexion (`frameRateCloseAfterRejects`) ; `0` = jamais.
+ *
+ * @param server - le serveur du contexte (`context.server`)
+ * @returns le solde de fermeture
+ */
+export declare const readFrameRateCloseAfter: (server: unknown) => number;
+/**
+ * Décide du sort d'une trame reçue, AVANT tout décodage : l'admettre, l'écarter, ou fermer la connexion.
+ *
+ * Compte des TRAMES, pas des octets (`maxPayload` borne déjà la taille). La
+ * décision est la règle unique du cœur (`decideBackpressure`), appliquée au
+ * nombre de trames de la fenêtre : écarter au-delà de la borne, fermer quand le
+ * solde de refus atteint `closeAfter` — jamais au premier dépassement. Une
+ * trame écartée est comptée dans {@link frameRateRejectedTotal}.
+ *
+ * @param win - la fenêtre de la connexion (mutée)
+ * @param now - l'instant de réception (ms)
+ * @param bound - trames admises par seconde (`> 0`)
+ * @param closeAfter - solde de refus qui ferme (`0` = jamais)
+ * @returns `"send"` (admettre), `"drop"` (écarter) ou `"close"` (fermer en `1008`)
+ */
+export declare const admitFrame: (win: IFrameRateWindow, now: number, bound: number, closeAfter: number) => BackpressureVerdict;

package/dist/types/nodefony/src/context/websocket/wsLogContent.d.ts

@@ -1,15 +1,18 @@
 /**
- * Formatage **pur** (0 état, 0 dépendance) du CONTENU d'un message WebSocket pour
- * le log de trace (Suivi de requête Studio). Séparé de `WebsocketContext` pour
- * être testable aux limites sans serveur.
+ * Formatage **pur** (0 état) du CONTENU d'un message WebSocket pour le log de trace
+ * (Suivi de requête Studio). Séparé de `WebsocketContext` pour être testable aux
+ * limites sans serveur.
  *
  * 🔒 Robustesse binaire (cf doc `ws` — `socket.send(data)` accepte
  * `String | Number | Object | Buffer | ArrayBuffer | TypedArray | DataView |
  * Buffer[] | Blob`, et l'event `message` livre `Buffer | ArrayBuffer | Buffer[]`).
- * **Toute** charge binaire est résumée `[binary N B]` — JAMAIS sérialisée
- * (`JSON.stringify(new Uint8Array(...))` produirait `{"0":..,"1":..}`, énorme et
- * faux). Seules string et objets « JSON » sont rendus en texte (borné).
+ * **Toute** charge binaire est résumée `[binary N B]` — JAMAIS vidée octet par
+ * octet (`JSON.stringify(new Uint8Array(...))` produirait `{"0":..,"1":..}`, énorme
+ * et faux). Quand la connexion a négocié un codec de frame (CBOR, ADR-0022 §2), la
+ * trame est en plus DÉCODÉE pour être lisible : le débogage se fait à l'observation,
+ * jamais en changeant le fil.
  */
+import { type IFrameCodec } from "nodefony";
 /** Cap de troncature du contenu loggé (octets/chars). Borne ring + JSONL. */
 export declare const WS_LOG_CONTENT_CAP = 4096;
 /**
@@ -26,12 +29,17 @@ export declare function binaryByteLength(data: unknown): number;
 /**
  * Formate une charge utile WS en chaîne **bornée** et **sûre** pour le log :
  *  - `string` → tronquée à `cap` (+ ellipse) ;
- *  - binaire (cf {@link binaryByteLength}) → `[binary N B]` (jamais de dump) ;
+ *  - binaire (cf {@link binaryByteLength}) → `[binary N B]` (jamais de vidage) ;
+ *    avec un `codec`, une trame d'un seul tenant est aussi décodée :
+ *    `[binary N B] <protocole> <frame en JSON>`, octets imbriqués étiquetés ;
+ *    illisible → `[binary N B] <protocole> illisible` ;
  *  - `null`/`undefined` → `""` ;
  *  - objet « JSON » → `JSON.stringify` compact tronqué (cycle, `bigint`, valeur
  *    non sérialisable → repli `String(...)`).
  *
  * @param data - charge utile (RECEIVE/SEND/BROADCAST).
  * @param cap - longueur max avant troncature (défaut {@link WS_LOG_CONTENT_CAP}).
+ * @param codec - codec des trames binaires de la connexion, `null` = octets bruts.
+ * @returns la ligne à journaliser, jamais plus longue que `cap` + 1.
  */
-export declare function formatWsLogContent(data: unknown, cap?: number): string;
+export declare function formatWsLogContent(data: unknown, cap?: number, codec?: IFrameCodec | null): string;

package/dist/types/nodefony/src/cookies/cookie.d.ts

@@ -19,7 +19,6 @@ declare module "http2" {
  * externe nomme le type par `ICookieOptions`, exporté au barrel.
  */
 export type CookieOptionsType = ICookieOptions;
-declare function parser(strToParse: string): import("cookie").Cookies;
 declare function cookiesParser(context: ContextType): void;
 declare class Cookie implements ICookieInterface {
     options: CookieOptionsType;
@@ -57,7 +56,26 @@ declare class Cookie implements ICookieInterface {
     setExpires(date: Date | string | number | undefined): Date | undefined;
     setOriginalMaxAge(ms: number | StringValue): number;
     setPriority(val: PriorityType): PriorityType;
+    /**
+     * Durée de vie restante en SECONDES ENTIÈRES, `undefined` sous une seconde.
+     *
+     * RFC 6265 §4.1.1 : `max-age-av = "Max-Age=" non-zero-digit *DIGIT`. Un
+     * `Max-Age=3599.874` est ignoré par le navigateur, et le cookie devient un
+     * cookie de session. Arrondi INFÉRIEUR : le cookie ne survit jamais à son
+     * `Expires`.
+     */
     getMaxAge(): number | undefined;
+    /**
+     * Vérifie la grammaire RFC 6265 §4.1.1 du nom, du `Path` et du `Domain`,
+     * au moment où le cookie est POSÉ sur la réponse.
+     *
+     * Sans elle, `path: "/; Domain=evil.example"` injectait un attribut, et un
+     * nom porteur de `;` partait tel quel. La grammaire est celle du paquet
+     * `cookie` : une seule implémentation.
+     *
+     * @throws {TypeError} nommant l'attribut hors grammaire.
+     */
+    assertGrammar(): void;
     toString(): string;
     /**
      * Signe une valeur de cookie : `HMAC-SHA256(value)` clé = `secret`, encodé en
@@ -85,4 +103,4 @@ declare class Cookie implements ICookieInterface {
     serializeWebSocket(): IWsCookie;
 }
 export default Cookie;
-export { cookiesParser, parser };
+export { cookiesParser };

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

@@ -1,15 +1,40 @@
 import { nodefonyError as NodefonyError } from "nodefony";
 import { ContextType } from "../../service/http-kernel.js";
-import { HttpRequestType, HttpRsponseType } from "../context/http/HttpContext.js";
+/**
+ * Sérialise les propriétés propres d'une erreur HTTP, sans jamais LIRE celles
+ * qu'on écarte.
+ *
+ * Ne pas lire compte : `stack` est un accesseur paresseux de V8, et sa première
+ * lecture FORMATE la pile (`prepareStackTrace`, plusieurs µs). Lire puis
+ * supprimer, c'est payer ce formatage pour le jeter — ce que faisait le rendu
+ * d'erreur en production, sur chaque 404.
+ *
+ * @param error - l'erreur à sérialiser (en pratique un `HttpError`).
+ * @param omit - clés à écarter EN PLUS des références vivantes, ou `null`.
+ * @returns un objet plat, prêt pour `JSON.stringify`.
+ */
+export declare function serializeHttpError(error: Error, omit?: ReadonlySet<string> | null): Record<string, unknown>;
 declare class HttpError extends NodefonyError {
-    context?: ContextType | undefined;
-    response?: HttpRsponseType | undefined;
-    request?: HttpRequestType | undefined;
     url?: string | undefined;
     controller?: string | undefined;
     action?: string | undefined;
     jsonResponse?: string | undefined;
     constructor(message?: unknown, code?: number, context?: ContextType);
+    /**
+     * Construit un VERDICT de protocole (404, 405, 426…) sans capturer de pile.
+     *
+     * La pile d'un verdict pointe toujours au même endroit du noyau ou du routeur
+     * et ne dit rien de la requête ; la capturer coûte ~3,6 µs à profondeur
+     * réelle (`micro-error-path.mjs`), payés par chaque requête d'un scanner.
+     * Réservé à ce que le framework DÉCIDE — une panne garde sa pile. `stack` ne
+     * porte que l'en-tête (`HttpError: Not Found`).
+     *
+     * @param message - message du verdict.
+     * @param code - statut HTTP (ou code de fermeture WebSocket).
+     * @param context - contexte de la requête, comme pour le constructeur.
+     * @returns l'erreur, sans pile.
+     */
+    static withoutStack(message: string, code: number, context?: ContextType): HttpError;
     toString(): string;
 }
 export default HttpError;

package/dist/types/nodefony/src/grpc/cors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Ce que les protocoles RPC servis (gRPC, gRPC-Web, Connect) demandent à la
+ * politique CORS de l'application (ADR-0026 D9).
+ *
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export interface IRpcCorsLists {
+    /** Méthodes que le préflight doit autoriser. */
+    readonly allowedMethods: readonly string[];
+    /** En-têtes de requête que le préflight doit autoriser. */
+    readonly allowedHeaders: readonly string[];
+    /**
+     * En-têtes qu'une réponse RPC doit exposer au script de la page — sans eux,
+     * un client gRPC-Web ne lit ni le statut ni l'encodage de la réponse.
+     */
+    readonly exposedHeaders: readonly string[];
+}
+/**
+ * `Access-Control-Expose-Headers` d'une réponse RPC, composé une fois au
+ * chargement.
+ */
+export declare const RPC_EXPOSED_HEADERS: string;
+/**
+ * Les listes CORS que demandent les protocoles RPC — dès qu'un service gRPC
+ * est déclaré dans le processus, `null` sinon. Le pare-feu les ajoute à la
+ * politique de l'application au démarrage (`onReady`) : le préflight ne
+ * connaît pas la route, l'union est la seule voie (ADR-0026 D9 point 2).
+ *
+ * @returns les listes, ou `null` sans service gRPC déclaré.
+ * @experimental Surface gRPC, ADR-0026 D11.
+ */
+export declare function rpcCorsLists(): IRpcCorsLists | null;

package/dist/types/nodefony/src/grpc/limits.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Borne par défaut d'un message gRPC, reçu ou émis : 4 Mio (ADR-0026 D4,
+ * points 1 et 2). C'est la borne de réception des implémentations de
+ * référence (`grpc-js`, `grpc-go`) ; l'adaptateur Connect, lui, n'en pose
+ * aucune (`limit-io.js` : `0xffffffff`). Seule source de cette valeur : le
+ * schéma de la section `grpc` et le point d'entrée gRPC la lisent ici.
+ */
+export declare const GRPC_DEFAULT_MAX_MESSAGE_BYTES: number;
+/**
+ * Plus grande borne qu'accepte l'adaptateur Connect pour `readMaxBytes` et
+ * `writeMaxBytes` (`limit-io.js#validateReadWriteMaxBytes`) : la longueur
+ * d'une enveloppe tient sur 32 bits.
+ */
+export declare const GRPC_MAX_MESSAGE_BYTES = 4294967295;