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

package/dist/nodefony/src/proxy/rules.js

@@ -1,5 +1,7 @@
-import { isLoopbackHostname } from "nodefony";
+import { isLoopbackHostname, parseBareOrigin } from "nodefony";
 // nodefony/src/proxy/rules.ts
+/** Schémas d’amont d’un relais : un proxy inverse ne parle que HTTP. */
+const PROXY_ORIGIN_PROTOCOLS = ["http:", "https:"];
 /**
 * Règles d'un montage du proxy inverse — UNIQUE source, lue par le schéma de
 * configuration (`proxy.mounts`) ET par `ReverseProxy.mount()` : un montage
@@ -49,17 +51,7 @@ function normalizePrefix(prefix) {
 * @returns l'URL analysée, ou `null` si ce n'est pas une origine http(s) nue
 */
 function parseProxyOrigin(origin) {
-	let url;
-	try {
-		url = new URL(origin);
-	} catch {
-		return null;
-	}
-	if (url.protocol !== "http:" && url.protocol !== "https:") return null;
-	if (!/^https?:\/\/[^/?#]+\/?$/i.test(origin.trim())) return null;
-	if (url.search !== "" || url.hash !== "") return null;
-	if (url.username !== "" || url.password !== "") return null;
-	return url;
+	return parseBareOrigin(origin, PROXY_ORIGIN_PROTOCOLS);
 }
 /**
 * Examine un montage. Rend TOUS les refus, pas le premier : une configuration
@@ -163,6 +155,29 @@ const UPGRADE_WEBSOCKET = /^\s*websocket\s*$/i;
 /** Le jeton `upgrade` dans une liste `Connection` (RFC 9110 §7.6.1). */
 const CONNECTION_UPGRADE = /(?:^|,)\s*upgrade\s*(?:,|$)/i;
 /**
+* Le corps reçu porte-t-il un codage de transfert que le serveur ne sait pas
+* défaire ? Seul `chunked` est compris : Node le retire, mais laisse en place
+* tout codage qui le précède (`gzip, chunked`) — le corps livré serait encore
+* compressé. RFC 9112 §6.1 : un tel message reçoit 501. Un `chunked` qui n'est
+* pas le DERNIER codage est déjà refusé par Node en 400 (§6.3).
+*
+* Seule règle, pour le serveur d'origine et pour le proxy inverse. Chemin de
+* chaque requête : une lecture d'en-tête, rien d'autre sans `Transfer-Encoding`.
+*
+* @param coding - valeur de l'en-tête `Transfer-Encoding`, absente le plus souvent
+* @returns `true` quand le corps ne peut pas être lu tel qu'annoncé
+*/
+function isUnsupportedTransferCoding(coding) {
+	if (coding === void 0 || coding === "chunked") return false;
+	return coding.trim().toLowerCase() !== "chunked";
+}
+/**
+* Raison rendue par {@link websocketHandshakeProblem} quand le client parle une
+* autre version du protocole : la seule qui appelle une réponse distincte —
+* le client doit apprendre vers quelle version se rabattre (RFC 6455 §4.4).
+*/
+const WS_UNSUPPORTED_VERSION = "Sec-WebSocket-Version ≠ 13";
+/**
 * Un upgrade est-il un handshake WebSocket conforme (RFC 6455 §4.2.1) ? Seul
 * un tel handshake est relayé : un `Upgrade` quelconque (`h2c`…) raccordé
 * octet pour octet ouvrirait un tunnel que rien n'inspecte.
@@ -180,9 +195,9 @@ function websocketHandshakeProblem(method, headers) {
 	if (typeof upgrade !== "string" || !UPGRADE_WEBSOCKET.test(upgrade)) return "Upgrade autre que websocket";
 	const connection = headers.connection;
 	if (!(typeof connection === "string" ? CONNECTION_UPGRADE.test(connection) : Array.isArray(connection) && connection.some((token) => CONNECTION_UPGRADE.test(token)))) return "Connection sans upgrade";
-	if (headers["sec-websocket-version"] !== "13") return "Sec-WebSocket-Version ≠ 13";
+	if (headers["sec-websocket-version"] !== "13") return WS_UNSUPPORTED_VERSION;
 	const key = headers["sec-websocket-key"];
 	if (typeof key !== "string" || !WS_KEY.test(key)) return "Sec-WebSocket-Key invalide";
 	return null;
 }
-export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, isAmbiguousPath, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };
+export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, WS_UNSUPPORTED_VERSION, isAmbiguousPath, isUnsupportedTransferCoding, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };

package/dist/nodefony/src/servers/upgradeDispatch.js

@@ -1,7 +1,60 @@
+import { refuseMalformedHandshake, refuseUpgrade } from "../proxy/forward.js";
 import { websocketHandshakeProblem } from "../proxy/rules.js";
-import { refuseUpgrade } from "../proxy/forward.js";
 import { STATUS_CODES } from "node:http";
+import { WebSocketServer } from "ws";
 // nodefony/src/servers/upgradeDispatch.ts
+/**
+* Sous-protocole choisi par handshake, entre {@link IUpgradeAdmission.selectSubprotocol}
+* et le rappel `handleProtocols` de `ws` — qui ne reçoit que la requête. Une
+* table faible plutôt qu'une variable « en cours » : un `verifyClient`
+* asynchrone sépare les deux instants, et deux handshakes s'y croiseraient.
+* Une entrée n'existe que pour un handshake qui a choisi.
+*/
+const chosenSubprotocols = /* @__PURE__ */ new WeakMap();
+/**
+* Fabrique l'option `handleProtocols` du serveur `ws` de Nodefony : le choix
+* retenu par l'admission ({@link IUpgradeAdmission.selectSubprotocol}) s'il y
+* en a un, sinon `fallback` (celle de la configuration), sinon le premier
+* offert — le défaut de `ws` 8, conservé pour tout contrôleur qui ne choisit
+* pas.
+*
+* @param fallback - l'option `handleProtocols` de la configuration, s'il y en a une
+* @returns le rappel à passer à `new WebSocketServer({ handleProtocols })`
+*/
+function createSubprotocolHandler(fallback) {
+	return (protocols, request) => {
+		const chosen = chosenSubprotocols.get(request);
+		if (chosen !== void 0) {
+			chosenSubprotocols.delete(request);
+			return chosen !== false && protocols.has(chosen) ? chosen : false;
+		}
+		if (fallback !== void 0) return fallback(protocols, request);
+		const first = protocols.values().next();
+		return first.done === true ? false : first.value;
+	};
+}
+/**
+* Construit le serveur `ws` de Nodefony à partir des options de la
+* configuration, en forçant ce que Nodefony gère — seul endroit où ces
+* options sont posées, pour le serveur clair comme pour le sécurisé :
+*
+* - `noServer` : l'upgrade passe d'abord par le proxy inverse, puis par
+*   {@link attachUpgradeDispatch} ;
+* - `clientTracking` : requis par `broadcast()` et le heartbeat ;
+* - `handleProtocols` : le sous-protocole CHOISI par le contrôleur
+*   ({@link createSubprotocolHandler}), celui de la configuration à défaut.
+*
+* @param options - options `ws` issues de la configuration du serveur WebSocket
+* @returns le serveur, sans écoute propre
+*/
+function createNodefonyWebSocketServer(options) {
+	return new WebSocketServer({
+		...options,
+		noServer: true,
+		clientTracking: true,
+		handleProtocols: createSubprotocolHandler(options.handleProtocols)
+	});
+}
 /** Défaut sans noyau : tout upgrade conforme est accepté puis émis en `connection`. */
 function acceptAll(wss) {
 	return (req, admission) => {
@@ -38,6 +91,9 @@ var UpgradeAdmission = class {
 		this.#onPendingError = () => socket.destroy();
 		socket.on("error", this.#onPendingError);
 	}
+	selectSubprotocol(protocol) {
+		if (!this.#settled) chosenSubprotocols.set(this.req, protocol);
+	}
 	#settle() {
 		if (this.#settled) return false;
 		this.#settled = true;
@@ -71,6 +127,7 @@ var UpgradeAdmission = class {
 	}
 	refuse(status, headers) {
 		if (!this.#settle()) return;
+		chosenSubprotocols.delete(this.req);
 		refuseUpgrade(this.socket, status, STATUS_CODES[status] ?? "Refused", headers);
 	}
 };
@@ -114,8 +171,9 @@ function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(ws
 			refuseUpgrade(socket, status, STATUS_CODES[status] ?? "Refused");
 			return;
 		}
-		if (websocketHandshakeProblem(req.method, req.headers) !== null) {
-			refuseUpgrade(socket, 400, STATUS_CODES[400] ?? "Bad Request");
+		const problem = websocketHandshakeProblem(req.method, req.headers);
+		if (problem !== null) {
+			refuseMalformedHandshake(socket, problem);
 			return;
 		}
 		admit(req, new UpgradeAdmission(wss, req, socket, head));
@@ -125,4 +183,4 @@ function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(ws
 		server.removeListener("upgrade", onUpgrade);
 	};
 }
-export { attachUpgradeDispatch };
+export { attachUpgradeDispatch, createNodefonyWebSocketServer, createSubprotocolHandler };

package/dist/types/index.d.ts

@@ -68,10 +68,16 @@ declare class Http extends Module<IHttpConfig> {
 }
 export default Http;
 export { defineHttpConfig, httpConfigJsonSchema, } from "./nodefony/config/defineModuleConfig.js";
+export { parseRequestTarget } from "./nodefony/src/context/http/urlFastPath.js";
+export { isContentlessStatus } from "./nodefony/src/context/http/Response.js";
+export type { ISplitTarget } from "./nodefony/src/context/http/urlFastPath.js";
 export { httpConfigSchema } from "./nodefony/config/config.js";
 export type { IHttpConfig, IHttpConfigInput, } from "./nodefony/interfaces/IHttpConfig.js";
 export { decideSend, readBackpressureOptions, type WsBackpressurePolicy, type WsSendDecision, type IWsBackpressureOptions, type IBackpressureSocket, type IBackpressureTarget, } from "./nodefony/src/context/websocket/wsBackpressure.js";
+export { admitFrame, frameRateRejectedTotal, readFrameRateBound, readFrameRateCloseAfter, FRAME_RATE_WINDOW_MS, type IFrameRateWindow, type IWsFrameRateOptions, } from "./nodefony/src/context/websocket/wsFrameRate.js";
 export { isWebsocketContext } from "./nodefony/src/context/websocket/isWebsocketContext.js";
+export { REQUEST_TRACE_CHANNEL } from "./nodefony/src/context/requestTrace.js";
+export type { IRequestTrace, RequestTraceProtocol, } from "./nodefony/interfaces/IRequestTrace.js";
 export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed, } from "./nodefony/src/context/domainMatcher.js";
 export type { DomainPattern, ITrustedHostsConfig, } from "./nodefony/src/context/domainMatcher.js";
 export { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
@@ -79,6 +85,8 @@ export type { IRateLimitStore, IRateLimitOptions, RateLimitVerdict, } from "./no
 export { Context, Session, SessionsService, HttpError, HttpKernel, Response, Http2Response, Response as HttpResponse, wsResponse, wsResponse as WebsocketResponse, Cookie, HttpContext, WebsocketContext, HttpRequest, Http2Request, DefaultErrorRenderer, DefaultRequestLogger, JsonAuditLogger, PrettyRequestLogger, Profiler, };
 export { SseStream, openSseStream, acceptsEventStream, SSE_HEARTBEAT_MS, } from "./nodefony/src/context/http/SseStream.js";
 export type { ISseStreamOptions, ISseSendOptions, } from "./nodefony/src/context/http/SseStream.js";
+export { openByteStream } from "./nodefony/src/context/http/ByteStream.js";
+export type { ByteStreamEndReason, ByteStreamSource, IByteStreamOptions, IByteStreamResult, } from "./nodefony/src/context/http/ByteStream.js";
 export { schemaMismatchOf, type SchemaMismatchConfidence, } from "./nodefony/service/error-renderer.js";
 export { toValidationFields, type IValidationField, } from "./nodefony/service/error-renderer.js";
 export type { ProfileEntry, ProfileSummary, ProfilePhase, ProfileQuery, ProfileSecurity, IProfileBatch, IProfilerReader, } from "./nodefony/src/profiler/Profiler.js";

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

@@ -115,6 +115,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>;
@@ -139,6 +141,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>;
@@ -198,6 +202,10 @@ export declare const httpConfigSchema: z.ZodObject<{
             stripHeaders: z.ZodDefault<z.ZodArray<z.ZodString>>;
             timeoutMs: z.ZodOptional<z.ZodNumber>;
             secure: z.ZodDefault<z.ZodBoolean>;
+            accessLog: z.ZodDefault<z.ZodEnum<{
+                all: "all";
+                errors: "errors";
+            }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
     wsMaxConnectionsPerIp: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;

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

@@ -127,6 +127,15 @@ export interface IContext {
     readonly phases: PhaseTiming[];
     phaseStart(name: PhaseName): void;
     phaseEnd(name: PhaseName): void;
+    /**
+     * Arrête l'horloge de la requête (au premier appel) et rend sa durée en ms —
+     * la SEULE durée de requête du framework, mesurée partout par défaut ; `null`
+     * seulement si `timing.enabled` vaut `false`.
+     *
+     * Membre REQUIS : le journal d'accès et le profileur le lisent sans repli.
+     * Une implémentation maison d'`IContext` qui ne mesure rien rend `null`.
+     */
+    stopClock(): number | null;
     profiling: boolean;
     securityTrace: ISecurityTrace | null;
     onAfterResponse(fn: AfterResponseHandler): void;

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

@@ -0,0 +1,56 @@
+import type { SchemeType } from "./IContext.js";
+import type { HTTPMethodType } from "./IRequest.js";
+/**
+ * Nature de l'opération tracée : une requête HTTP, ou le handshake d'une
+ * connexion WebSocket.
+ */
+export type RequestTraceProtocol = "http" | "websocket";
+/**
+ * Message publié sur le `TracingChannel` `nodefony.http.request`, le même
+ * objet de `start` à `asyncEnd` pour une requête donnée.
+ *
+ * Les champs d'identité (`requestId`, `protocol`, `method`, `scheme`, `url`)
+ * sont posés dès `start`. Les champs de résultat (`route`, `routePath`,
+ * `module`, `statusCode`, `durationMs`, `error`) valent `null` jusqu'à la fin
+ * de la requête : un abonné les lit sur `asyncEnd`. Tout est en lecture seule
+ * pour l'abonné — c'est Nodefony qui les remplit.
+ */
+export interface IRequestTrace {
+    /** Identifiant de corrélation de la requête (`X-Request-Id` entrant, sinon généré). */
+    readonly requestId: string;
+    /** `"http"` pour une requête, `"websocket"` pour un handshake. */
+    readonly protocol: RequestTraceProtocol;
+    /** Méthode de la requête (`"WEBSOCKET"` pour un handshake). */
+    readonly method: HTTPMethodType | null;
+    /** Schéma vu par le client, proxy de confiance compris (`url.scheme` d'OpenTelemetry). */
+    readonly scheme: SchemeType;
+    /** URL complète de la requête, chaîne de requête comprise — l'abonné en tire `url.path` et `url.query`. */
+    readonly url: string;
+    /** Nom de la route qui a répondu, `null` sans route (statique, 404). */
+    readonly route: string | null;
+    /**
+     * Gabarit de la route, préfixe compris (`/users/{id}`) : faible cardinalité,
+     * c'est l'attribut `http.route` d'OpenTelemetry. La racine vaut `/`. `null`
+     * sans route.
+     */
+    readonly routePath: string | null;
+    /** Module qui a signé la réponse — le même que celui de la ligne d'accès. */
+    readonly module: string | null;
+    /**
+     * Statut rendu au client : celui de l'amont pour une requête relayée, `101`
+     * pour un handshake accepté, le statut du refus sinon. `null` si le client
+     * est parti avant toute réponse.
+     */
+    readonly statusCode: number | null;
+    /**
+     * Durée de la requête en millisecondes, construction du contexte → dernier
+     * octet remis (fin du handshake en WebSocket). `null` si `timing.enabled`
+     * vaut `false`.
+     */
+    readonly durationMs: number | null;
+    /**
+     * Exception attrapée par le pipeline, `null` sinon. Un statut 4xx rendu
+     * sans exception n'en porte pas ; c'est à l'abonné de classer un statut.
+     */
+    readonly error: unknown;
+}

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

@@ -59,6 +59,14 @@ export interface IProxyMountOptions {
      * ACCEPTÉ que vers la boucle locale (refus au montage sinon).
      */
     secure?: boolean | undefined;
+    /**
+     * Ligne d'accès des requêtes relayées : `"all"` (défaut) les écrit toutes,
+     * `"errors"` seulement celles en échec (statut ≥ 400). Pour un amont qui sert
+     * des centaines de fichiers par page (le relais de Vite) : un fichier bien
+     * servi n'apprend rien, et ses lignes chassaient les autres de la mémoire
+     * du journal.
+     */
+    accessLog?: "all" | "errors" | undefined;
 }
 /** Un montage tel que le proxy le garde : préfixe normalisé + réglages. */
 export interface IProxyMount extends IProxyMountOptions {

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

@@ -11,6 +11,15 @@ import type { ContextType } from "../service/http-kernel.js";
 export interface IResolvedRoute {
     /** Nom de la route (journalisation, diagnostic). */
     readonly name: string;
+    /**
+     * Gabarit de la route, préfixe compris (`/users/{id}`) — faible cardinalité,
+     * publié comme `routePath` sur le canal `nodefony.http.request`.
+     */
+    readonly path?: string | undefined;
+    /** Module propriétaire — il signe la ligne d'accès de la requête. */
+    readonly module?: {
+        readonly name: string;
+    } | undefined;
     /** Corps laissé en flux (`@Body({ stream: true })`) : le parse est sauté. */
     readonly bodyStream?: boolean | undefined;
 }
@@ -35,6 +44,13 @@ export interface IRouteResolver {
     } | null | undefined;
     /** Nom de l'action résolue. */
     actionName?: string | undefined;
+    /**
+     * Ce que l'action a rendu sans que rien ne soit envoyé (`"null"`,
+     * `"undefined"`, `"une instance de Book"`…), `null` sinon. Posé seulement
+     * sur la branche « l'action répond elle-même » : lu au démontage pour dire,
+     * en développement, POURQUOI une requête a attendu son délai d'expiration.
+     */
+    readonly unrendered?: string | null | undefined;
     /**
      * Rejoue le match d'une route sur un contexte (WS : handshake puis frames).
      *

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

@@ -7,4 +7,5 @@ export type { IContext, IHttpContext, IWebsocketContext, ServerType, ProtocolNam
 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 { IProxyMount, IProxyMountOptions, ProxyTarget, } from "./IReverseProxy.js";

package/dist/types/nodefony/service/ProfilerAdminApi.d.ts

@@ -10,7 +10,11 @@ import type { Profiler } from "../src/profiler/Profiler.js";
  *
  * Endpoints :
  *  - `GET /nodefony/profiler/api/recent`  → derniers profils (résumés, récent → ancien)
- *  - `GET /nodefony/profiler/api/{id}`    → profil complet (phases) d'un requestId
+ *    `?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 ;
+ *    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

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 { IHttpContext, IWebsocketContext, PhaseTiming } from "../interfaces/IContext.js";
+import type { IContext, IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+declare const statusOf: (context: IContext) => number | null;
 /**
  * Canonical audit log entry — 1 JSON PDU per request (P3.1).
  *
@@ -52,15 +53,6 @@ export interface AuditErrorEntry {
     /** Recursive — capped to depth 5 to avoid pathological cycles. */
     cause?: AuditErrorEntry;
 }
-/**
- * Durée totale de la requête, de la première phase (`startMs`) à maintenant.
- * `null` si le chronométrage est coupé (aucune phase enregistrée). Partagée
- * par le journal d'audit et le journal lisible — une seule définition.
- *
- * @param phases - phases chronométrées du contexte
- * @returns durée en millisecondes, ou `null`
- */
-declare function computeDurationMs(phases: PhaseTiming[]): number | null;
 /**
  * Severity derived from HTTP status code — RFC 9110 categories.
  * 1xx/2xx/3xx → INFO ; 4xx → WARNING ; 5xx → ERROR.
@@ -145,4 +137,4 @@ declare class JsonAuditLogger implements IRequestLogger {
     private serializeError;
 }
 export default JsonAuditLogger;
-export { computeDurationMs, severityFromStatus };
+export { severityFromStatus, statusOf };

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

@@ -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).
  *

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

@@ -134,6 +134,8 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     private errorRenderer;
     private requestLogger;
     private profiler;
+    /** `timing.tooling` : profiler aussi l'outillage (lu une fois, à onReady). */
+    private profileTooling;
     private _trustProxyChecker;
     private _wsOriginPolicy;
     private rateLimiter;
@@ -145,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é.
@@ -186,6 +197,32 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * tel quel plutôt que d'inventer un état.
      */
     get rateLimitStore(): IRateLimitStore | null;
+    /**
+     * Cette requête — ou cette frame du pont — se profile-t-elle ? Jamais sans
+     * profileur (production). L'outillage (console, profileur, journaux, Vite :
+     * `isProfiledUrl`, sur la règle `isConsolePath` du cœur) seulement sous
+     * `timing.tooling` — on ne
+     * mesure pas la façon dont on mesure : ni tampon SQL, ni instantané, ni place
+     * dans les anneaux du profileur.
+     *
+     * @param url - URL ou chemin de la requête
+     * @returns `true` quand le profil doit être pris
+     */
+    shouldProfile(url: string): boolean;
+    /**
+     * En développement, signale une action qui a rendu une valeur que le
+     * Resolver ne sait pas envoyer (`null`, `undefined`, instance de classe)
+     * et n'a rien envoyé elle-même : la requête attend son délai d'expiration.
+     * 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
+     * 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`.
+     *
+     * @param context - le contexte HTTP de la requête
+     */
+    warnUnsentResponse(context: HttpContext): void;
     private configureRateLimit;
     /**
      * (Re)configure le backstop OPT-IN de connexions WS concurrentes par IP (F6c)
@@ -474,6 +511,18 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @returns le contexte servi, ou sa promesse.
      */
     handleHttp(scope: Scope, request: httpRequest, response: httpResponse, type: ServerType): MaybePromise<HttpContext>;
+    /**
+     * Sert un contexte HTTP fraîchement créé : le crochet `onCreateContext`
+     * s'il a des écouteurs, puis le pipeline.
+     *
+     * Hot path : `fireAsync` est une fonction async → 1 Promise + 1 microtask
+     * MÊME à 0 listener. En prod sans @nodefony/security ces seams
+     * (onCreateContext/beforeResolve/afterAuth) n'ont aucun listener → garde
+     * `listenerCount` (O(1), 0 alloc) pour ne RIEN planifier.
+     *
+     * @returns le contexte servi, ou sa promesse
+     */
+    private dispatchHttpContext;
     /**
      * Traceparent, tampon du profileur, puis le pipeline dans la bulle ALS de la
      * requête (`RequestContext.run`).
@@ -482,6 +531,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;
     /**
@@ -578,6 +631,16 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * @returns ce que rend l'action de handshake
      */
     handleWebsocket(scope: Scope, req: IncomingMessage, admission: IUpgradeAdmission, type: ServerType): Promise<unknown>;
+    /**
+     * Fin du canal `nodefony.http.request` pour un handshake interrompu par une
+     * exception — sans effet si un refus l'a déjà publiée (`refuseHandshake`).
+     * Le statut est un fait, pas une déduction : une socket rattachée dit que
+     * le `101` est parti ; sinon c'est le `500` du filet qui a été rendu.
+     *
+     * @param context - le contexte du handshake, `null` s'il n'a pu être construit
+     * @param error - l'exception qui a interrompu le pipeline
+     */
+    private closeFailedWebsocketTrace;
     private releaseOrphanWsScope;
     /**
      * Juge un handshake WebSocket AVANT son acceptation : hôte, origine,
@@ -665,7 +728,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/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`.

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;