@nodefony/http 10.0.0-alpha.9 → 10.0.0-beta.2

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 import { Kernel, Module } from "nodefony";
+import { type IHttpOverlay } from "./nodefony/config/config.js";
 import type { IHttpConfig, IHttpConfigInput } from "./nodefony/interfaces/IHttpConfig.js";
 import { Profiler } from "./nodefony/src/profiler/Profiler.js";
 import HttpKernel from "./nodefony/service/http-kernel.js";
@@ -22,8 +23,21 @@ declare module "nodefony" {
     interface NodefonyModuleConfig {
         "@nodefony/http": IHttpConfigInput;
     }
+    interface NodefonyModuleOverlay {
+        "@nodefony/http": IHttpOverlay;
+    }
 }
 declare class Http extends Module<IHttpConfig> {
+    overlaySchema: import("zod").ZodObject<{
+        maxBodySize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+        upload: import("zod").ZodOptional<import("zod").ZodObject<{
+            maxFileSize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxTotalFileSize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxFiles: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxFields: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+            maxFieldsSize: import("zod").ZodOptional<import("zod").ZodType<number, number, import("zod/v4/core").$ZodTypeInternals<number, number>>>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>;
     constructor(kernel: Kernel);
     /**
      * Expose le JSON Schema de la config http (dérivé du schéma Zod, flags `meta()`
@@ -75,6 +89,8 @@ export { SESSION_SORTABLE_FIELDS, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_S
 export type { IHttpRequest, IHttp2Request, IWsRequest, HTTPMethodType, } from "./nodefony/interfaces/IRequest.js";
 export type { IHttpResponse, IWebsocketResponse, } from "./nodefony/interfaces/IResponse.js";
 export type { IHttpKernel } from "./nodefony/interfaces/IHttpKernel.js";
+export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./nodefony/interfaces/IRouting.js";
+export type { ISecurityZone, IFirewallGate, } from "./nodefony/interfaces/ISecurity.js";
 export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, } from "./nodefony/interfaces/IUpload.js";
 export type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult, } from "./nodefony/interfaces/IErrorRenderer.js";
 export type { IRequestLogger, IRequestLogEntry, } from "./nodefony/interfaces/IRequestLogger.js";

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

@@ -87,6 +87,7 @@ export declare const httpConfigSchema: z.ZodObject<{
                 name: z.ZodOptional<z.ZodString>;
                 value: z.ZodOptional<z.ZodString>;
                 shortName: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
             }, z.core.$loose>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
@@ -189,6 +190,28 @@ export declare const httpConfigSchema: z.ZodObject<{
 export type IHttpConfig = z.infer<typeof httpConfigSchema>;
 /** Type d'entrée (toutes sections omissibles — défauts du schéma). */
 export type IHttpConfigInput = z.input<typeof httpConfigSchema>;
+/**
+ * LISTE BLANCHE des clés qu'une requête peut surcharger pour elle seule
+ * (`overlayConfig("@nodefony/http", …)`, #494) : les quotas de corps et
+ * d'envoi, lus au MOMENT de lire le corps (`Request.readBodyLimits`) — un
+ * calque posé avant la lecture du corps (écouteur `onRequestScope`, organisation
+ * reconnue à son nom d'hôte) les voit. Tout le reste est refusé : en-têtes de
+ * sécurité, pare-feu, `trustProxy`, sessions, limites de débit, certificats —
+ * et `queryString`, lu au constructeur de la requête, avant tout calque.
+ * Chaque champ réutilise celui du schéma (mêmes bornes) sans son défaut.
+ */
+export declare const httpOverlaySchema: z.ZodObject<{
+    maxBodySize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+    upload: z.ZodOptional<z.ZodObject<{
+        maxFileSize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxTotalFileSize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxFiles: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxFields: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+        maxFieldsSize: z.ZodOptional<z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Calque accepté par `overlayConfig("@nodefony/http", …)`. */
+export type IHttpOverlay = z.input<typeof httpOverlaySchema>;
 /**
  * Défauts du module, matérialisés depuis le schéma (source unique). Toujours
  * valides par construction ; passés au `super(..., config)` du Module class.

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

@@ -1,4 +1,5 @@
 import type { URL } from "node:url";
+import type { MaybePromise } from "nodefony";
 import type { ICookie } from "./ICookie.js";
 import type { ISession } from "./ISession.js";
 import type { HTTPMethodType } from "./IRequest.js";
@@ -10,8 +11,8 @@ export type PhaseName = "parse" | "resolve" | "firewall" | "initialize" | "actio
 export interface PhaseTiming {
     name: PhaseName;
     startMs: number;
-    endMs?: number;
-    durationMs?: number;
+    endMs?: number | undefined;
+    durationMs?: number | undefined;
 }
 /** Issue de la traversée d'une zone firewall. */
 export type SecurityOutcome = 
@@ -110,9 +111,25 @@ export interface IContext {
 export interface IHttpContext extends IContext {
     proxy: object | null;
     isRedirect: boolean;
-    handle(): Promise<object>;
-    render(chunk: unknown, encoding?: BufferEncoding, status?: string | number, headers?: Record<string, string | number>): Promise<object>;
-    send(chunk?: unknown, encoding?: BufferEncoding): Promise<object>;
+    /**
+     * Sert la requête — synchrone quand l'action et son rendu le sont.
+     *
+     * @returns le résultat du rendu, ou sa promesse dès qu'une étape attend.
+     */
+    handle(): MaybePromise<object>;
+    /**
+     * Sérialise puis envoie — synchrone quand l'envoi l'est.
+     *
+     * @returns la réponse, ou sa promesse dès qu'une étape attend.
+     */
+    render(chunk: unknown, encoding?: BufferEncoding, status?: string | number, headers?: Record<string, string | number>): MaybePromise<object>;
+    /**
+     * Envoie la réponse — synchrone sans session à sauver, sans hook `onSend`,
+     * pour une réponse unique.
+     *
+     * @returns la réponse, ou sa promesse dès qu'une étape attend.
+     */
+    send(chunk?: unknown, encoding?: BufferEncoding): MaybePromise<object>;
     end(): Promise<object>;
     redirect(url: string, status?: number | string, headers?: Record<string, string | number>): unknown;
     getHostName(): string | undefined;
@@ -121,8 +138,8 @@ export interface IHttpContext extends IContext {
     getUserAgent(): string | undefined;
 }
 export interface IWebsocketContext extends IContext {
-    acceptedProtocol?: string;
-    connection: unknown | null;
+    acceptedProtocol?: string | undefined;
+    connection: unknown;
     rejected: boolean;
     port: number | string;
     wsUrl: URL | null;

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

@@ -1,15 +1,15 @@
 export type SameSiteType = "Strict" | "Lax" | "None";
 export type PriorityType = "High" | "Medium" | "Low" | undefined;
 export interface ICookieOptions {
-    maxAge?: number;
-    path?: string;
-    domain?: string;
-    secure?: boolean;
-    expires?: Date | string | number;
-    sameSite?: SameSiteType;
-    httpOnly?: boolean;
-    signed?: boolean;
-    secret?: string;
+    maxAge?: number | undefined;
+    path?: string | undefined;
+    domain?: string | undefined;
+    secure?: boolean | undefined;
+    expires?: Date | string | number | undefined;
+    sameSite?: SameSiteType | undefined;
+    httpOnly?: boolean | undefined;
+    signed?: boolean | undefined;
+    secret?: string | undefined;
     priority?: PriorityType;
 }
 export interface IWsCookie {
@@ -26,16 +26,16 @@ export interface ICookie {
     name: string;
     value: unknown;
     options: ICookieOptions;
-    signed?: boolean;
-    originalMaxAge?: number;
-    expires?: Date;
-    maxAge?: number;
-    path?: string;
+    signed?: boolean | undefined;
+    originalMaxAge?: number | undefined;
+    expires?: Date | undefined;
+    maxAge?: number | undefined;
+    path?: string | undefined;
     domain?: string | undefined;
-    httpOnly?: boolean;
-    secure?: boolean;
-    sameSite?: SameSiteType;
-    priority?: string;
+    httpOnly?: boolean | undefined;
+    secure?: boolean | undefined;
+    sameSite?: SameSiteType | undefined;
+    priority?: string | undefined;
     setValue(value: unknown): unknown;
     toString(): string;
     serialize(): string;

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

@@ -1,9 +1,15 @@
+import type { IServerKernel, MaybePromise } from "nodefony";
 import type { ServerType } from "./IContext.js";
-export interface IHttpKernel {
+export interface IHttpKernel extends IServerKernel {
     domain: string;
-    httpPort?: number;
-    httpsPort?: number;
-    handle(request: unknown, response: unknown, type: ServerType): Promise<unknown>;
+    httpPort?: number | undefined;
+    httpsPort?: number | undefined;
+    /**
+     * Pipeline public d'une requête (appelé par les serveurs HTTP/HTTPS).
+     *
+     * @returns le contexte servi, ou sa promesse dès qu'une étape attend.
+     */
+    handle(request: unknown, response: unknown, type: ServerType): MaybePromise<unknown>;
     handleFrontController(context: object, checkFirewall?: boolean): Promise<unknown>;
     onError(error: unknown, context?: object, extraHeaders?: object): Promise<object>;
     isValidDomain(context: object): boolean;

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

@@ -31,7 +31,7 @@ export interface IHttpResponse extends IResponse {
     setCookie(cookie: ICookie): void;
 }
 export interface IWebsocketResponse extends IResponse {
-    connection: unknown | null;
+    connection: unknown;
     webSocketVersion?: number;
     setConnection(connection: unknown): unknown;
     broadcast(data: Buffer | string): void;

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

@@ -0,0 +1,87 @@
+import type { MaybePromise } from "nodefony";
+import type { ContextType } from "../service/http-kernel.js";
+/**
+ * Ce que le pipeline HTTP/WS lit d'une route résolue — et rien de plus.
+ *
+ * Le routage vit dans `@nodefony/framework`, qui dépend de `@nodefony/http` :
+ * `http` ne peut donc pas nommer ses classes sans recréer un cycle. C'est le
+ * LECTEUR qui définit le contrat ; `Route` (framework) le satisfait par
+ * structure, et le typecheck de `framework` garantit l'alignement.
+ */
+export interface IResolvedRoute {
+    /** Nom de la route (journalisation, diagnostic). */
+    readonly name: string;
+    /** Corps laissé en flux (`@Body({ stream: true })`) : le parse est sauté. */
+    readonly bodyStream?: boolean | undefined;
+}
+/**
+ * Ce que le pipeline HTTP/WS attend du résolveur d'une requête, posé sur
+ * `context.resolver` par le routeur.
+ *
+ * Implémenté par `Resolver` (`@nodefony/framework`), qui l'étend de ses propres
+ * membres — un code de `framework` qui a besoin de la classe entière la tient
+ * de son routeur, pas de ce contrat.
+ */
+export interface IRouteResolver {
+    /** Route matchée, `null` tant qu'aucune ne l'est. */
+    readonly route: IResolvedRoute | null;
+    /** `true` si une route a matché la requête. */
+    resolve: boolean;
+    /** Erreur levée pendant la résolution, relue par le pipeline. */
+    exception?: Error | null | undefined;
+    /** Classe du controller résolu — seul son nom est lu (erreurs, journal). */
+    readonly controller?: {
+        readonly name: string;
+    } | null | undefined;
+    /** Nom de l'action résolue. */
+    actionName?: string | undefined;
+    /**
+     * Rejoue le match d'une route sur un contexte (WS : handshake puis frames).
+     *
+     * @param route - la route à matcher, lue sur {@link IRouteResolver.route}
+     * @param context - le contexte courant
+     * @param cleanPath - chemin imposé (pont WS-RPC), sinon l'URL du contexte
+     */
+    match(route: IResolvedRoute, context: ContextType, cleanPath?: string): unknown;
+    /**
+     * Instancie le controller résolu — le pipeline ne fait que le transmettre.
+     *
+     * @param context - le contexte de la requête
+     * @returns l'instance du controller — directement quand elle existe déjà ou
+     *   se construit sans rien attendre, sinon la promesse de sa création
+     */
+    newController(context?: ContextType): MaybePromise<object>;
+    /**
+     * Exécute l'action résolue, puis rend sa valeur sur le transport.
+     *
+     * @param data - arguments supplémentaires de l'action
+     * @param reload - rejouer depuis l'instance en cache (forward)
+     * @returns le résultat du rendu — synchrone quand ni l'action ni le rendu
+     *   n'attendent, sinon sa promesse
+     */
+    callController(data?: unknown[], reload?: boolean): MaybePromise<unknown>;
+}
+/**
+ * Ce que le pipeline HTTP/WS attend du service `router` — implémenté par
+ * `Router` (`@nodefony/framework`).
+ */
+export interface IRequestRouter {
+    /**
+     * Résout la route d'un contexte.
+     *
+     * @param context - le contexte HTTP/WS courant
+     * @param cleanPathOverride - chemin porté par un message (pont WS-RPC)
+     * @param methodOverride - méthode logique exigée en plus du transport WS
+     * @returns le résolveur (`resolve === true` si une route a matché)
+     */
+    resolve(context: ContextType, cleanPathOverride?: string, methodOverride?: string): IRouteResolver;
+    /**
+     * Instance partagée d'un controller `scope: "singleton"`, créée une seule fois.
+     *
+     * @param ctor - la classe du controller (clé du cache)
+     * @param create - fabrique exécutée au premier appel
+     * @returns l'instance partagée une fois créée ; la promesse de sa création
+     *   tant qu'elle est en cours
+     */
+    getSingletonController<T extends object>(ctor: new (...args: never[]) => T, create: () => MaybePromise<T>): MaybePromise<T>;
+}

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

@@ -0,0 +1,45 @@
+import type { ContextType } from "../service/http-kernel.js";
+/**
+ * Ce que le pipeline HTTP/WS — et le résolveur de framework — lit de la zone de sécurité posée sur
+ * `context.security` — et rien de plus.
+ *
+ * Le pare-feu vit dans `@nodefony/security`, qui dépend de `@nodefony/http` :
+ * `http` ne peut donc pas nommer ses classes sans recréer un cycle. C'est le
+ * LECTEUR qui définit le contrat ; `ISecuredArea` (security) l'étend, et le
+ * typecheck de `security` garantit l'alignement.
+ */
+export interface ISecurityZone {
+    /** Nom de la zone (journalisation, profiler). */
+    readonly name: string;
+    /** `true` si la zone exige une authentification. */
+    readonly security: boolean;
+    /** Zone sans session : aucune session n'est ouverte ni lue. */
+    readonly stateless: boolean;
+    /** Stratégie des authenticators : le premier qui répond, ou tous. */
+    readonly mode: "first" | "all";
+    /** Noms des authenticators candidats, dans l'ordre. */
+    readonly authenticators: readonly string[];
+    /**
+     * Rôles exigés par la zone, en OU (un seul suffit) ; `null` = aucune exigence
+     * de rôle. Lu par le résolveur de `@nodefony/framework` pour l'autorisation.
+     */
+    readonly roles: readonly string[] | null;
+}
+/**
+ * Ce que le noyau HTTP appelle du pare-feu, service `firewall` du conteneur.
+ *
+ * Implémenté par `Firewall` (`@nodefony/security`), dont `IFirewall` étend ce
+ * contrat de ses propres membres (CSP, authenticators, description).
+ */
+export interface IFirewallGate {
+    /** Match rapide de zone : pose `context.security`, `true` si une zone capture. */
+    isSecure(context: ContextType): boolean;
+    /** Authentifie la requête d'une zone protégée ; rejette si elle est refusée. */
+    handleSecurity(context: ContextType): Promise<ContextType>;
+    /** Refuse une requête qui ne présente pas le jeton CSRF attendu. */
+    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;
+}

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

@@ -13,7 +13,7 @@ export type MetaBagType = Record<string, unknown>;
  * - `readOnly` : la session est lue/reprise mais **jamais persistée** (0 write storage).
  */
 export interface SessionIntent {
-    readOnly?: boolean;
+    readOnly?: boolean | undefined;
 }
 /**
  * Données de session **sérialisées** échangées avec un {@link ISessionStorage}
@@ -25,8 +25,8 @@ export interface ISerializedSession {
     metaBag: Record<string, unknown>;
     flashBag: Record<string, unknown>;
     user: string;
-    createdAt?: Date;
-    updatedAt?: Date;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
 }
 /**
  * Projection **redactée** d'une session pour l'ADMINISTRATION (data plane Studio,
@@ -100,7 +100,7 @@ export interface ISessionListFilter {
     /** Restreint aux sessions d'un utilisateur (pour « déconnecter partout »). */
     user?: string;
     /** Slot multi-tenant — non scopé aujourd'hui (réserve coût-0). */
-    tenantId?: string | null;
+    tenantId?: string | null | undefined;
 }
 /**
  * Requête d'énumération **paginée** des sessions — le {@link IPageQuery} standard
@@ -253,10 +253,10 @@ export interface ISession {
     cookieSession: ICookie | null | undefined;
     flashBag: FlashBagType;
     strategy: SessionStrategyType;
-    created?: Date;
-    updated?: Date;
-    user?: string;
-    lifetime?: number;
+    created?: Date | undefined;
+    updated?: Date | undefined;
+    user?: string | undefined;
+    lifetime?: number | undefined;
     storage: ISessionStorage;
     start(context: unknown): Promise<ISession>;
     save(user?: string): Promise<ISession>;

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

@@ -28,21 +28,21 @@ export interface IParsedUploadFile {
  */
 export interface IUploadOptions {
     /** Répertoire de dépôt des fichiers temporaires. */
-    uploadDir?: string;
+    uploadDir?: string | undefined;
     /** Taille max d'UN fichier (octets) — `limits.fileSize` busboy. */
-    maxFileSize?: number;
+    maxFileSize?: number | undefined;
     /** Taille max CUMULÉE des fichiers d'une requête (octets) — appliquée par Nodefony. */
-    maxTotalFileSize?: number;
+    maxTotalFileSize?: number | undefined;
     /** Nombre max de fichiers — `limits.files` busboy. */
-    maxFiles?: number;
+    maxFiles?: number | undefined;
     /** Nombre max de champs texte — `limits.fields` busboy. */
-    maxFields?: number;
+    maxFields?: number | undefined;
     /** Taille max d'un champ texte (octets) — `limits.fieldSize` busboy. */
-    maxFieldsSize?: number;
+    maxFieldsSize?: number | undefined;
     /** Hash calculé pendant le stream (défaut `false` = aucun). */
-    hashAlgorithm?: false | "sha1" | "md5" | "sha256";
+    hashAlgorithm?: false | "sha1" | "md5" | "sha256" | undefined;
     /** Encodage par défaut des parts texte. */
-    encoding?: string;
+    encoding?: string | undefined;
 }
 export interface IUploadedFile {
     filename: string;
@@ -60,7 +60,7 @@ export interface IUploadedFile {
     getPrettySize(): string;
 }
 export interface IUploadService {
-    path?: string | unknown;
+    path?: unknown;
     /** Construit un `UploadedFile` en async (stat non bloquant). */
     createUploadFile(file: unknown, name: string): Promise<IUploadedFile>;
 }

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

@@ -5,3 +5,5 @@ export type { IRequest, IHttpRequest, IHttp2Request, IWsRequest, HTTPMethodType,
 export type { IResponse, IHttpResponse, IWebsocketResponse } from "./IResponse.js";
 export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType, WebSocketStateType, CookiesMap, } from "./IContext.js";
 export type { IHttpKernel } from "./IHttpKernel.js";
+export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./IRouting.js";
+export type { ISecurityZone, IFirewallGate } from "./ISecurity.js";

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

@@ -1,6 +1,6 @@
 import type { Severity } from "nodefony";
 import type { IRequestLogger, IRequestLogEntry } from "../interfaces/IRequestLogger.js";
-import type { IHttpContext, IWebsocketContext } from "../interfaces/IContext.js";
+import type { IHttpContext, IWebsocketContext, PhaseTiming } from "../interfaces/IContext.js";
 /**
  * Canonical audit log entry — 1 JSON PDU per request (P3.1).
  *
@@ -32,9 +32,9 @@ export interface AuditLogEntry {
     phases?: {
         name: string;
         durationMs: number | null;
-    }[];
-    error?: AuditErrorEntry;
-    protocol?: string | null;
+    }[] | undefined;
+    error?: AuditErrorEntry | undefined;
+    protocol?: string | null | undefined;
 }
 /**
  * Enriched error description for audit logs (P3.5).
@@ -51,6 +51,15 @@ 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.
@@ -127,11 +136,6 @@ declare class JsonAuditLogger implements IRequestLogger {
     shouldSample(context: IHttpContext, error?: Error | null): boolean;
     renderHttp(context: IHttpContext, error?: Error | null): IRequestLogEntry;
     renderWebsocket(context: IWebsocketContext, error?: Error | null, acceptedProtocol?: string | null): IRequestLogEntry;
-    /**
-     * Total request duration computed from the first phase startMs to now.
-     * Returns null if timing is disabled (no phases recorded).
-     */
-    private computeDurationMs;
     /**
      * Serialise an Error (recursively for `cause` chain) into an AuditErrorEntry.
      * Stack is included only when `includeStack === true` (dev default).
@@ -140,4 +144,4 @@ declare class JsonAuditLogger implements IRequestLogger {
     private serializeError;
 }
 export default JsonAuditLogger;
-export { severityFromStatus };
+export { computeDurationMs, severityFromStatus };