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

package/dist/nodefony/src/webhook/WebhookDispatcher.js

@@ -1,4 +1,5 @@
 import { webhookSignatureHeaders } from "./webhookSignature.js";
+import { MAX_CHANNEL_PATTERN_WILDCARDS, compileChannelPattern, countWildcards } from "nodefony";
 // nodefony/src/webhook/WebhookDispatcher.ts
 /**
 * Dispatcher de webhooks sortants — abonné au journal d'audit, il filtre les
@@ -20,15 +21,60 @@ import { webhookSignatureHeaders } from "./webhookSignature.js";
 */
 const MAX_BACKOFF_MS = 3e5;
 const BASE_BACKOFF_MS = 5e3;
-/** Une souscription matche-t-elle une action d'audit ? `*` = toutes, `x.*` = préfixe. */
-function matchesSubscription(patterns, action) {
-	for (const p of patterns) {
-		if (p === "*" || p === action) return true;
-		if (p.endsWith(".*") && action.startsWith(p.slice(0, -1))) return true;
+/**
+* Motifs compilés par liste d'abonnement — une fois par tableau `events`, jamais par
+* événement. La clé est le tableau lui-même : un abonnement modifié porte un tableau
+* neuf, donc se recompile, et l'ancien part avec lui au ramasse-miettes.
+*/
+const compiledSubscriptions = /* @__PURE__ */ new WeakMap();
+/**
+* Rend les motifs compilés d'une liste d'abonnement, compilés à sa première lecture puis relus du cache.
+*
+* Deux appels sur le MÊME tableau rendent la même liste : c'est ce qui garantit
+* qu'un abonnement n'est jamais recompilé par événement. Un motif trop large
+* (refusé par `compileChannelPattern`) n'y figure pas.
+*
+* @param patterns - les motifs de l'abonnement (`IWebhookEndpoint.events`).
+* @returns les expressions compilées, une par motif valide.
+*/
+function compiledPatterns(patterns) {
+	let compiled = compiledSubscriptions.get(patterns);
+	if (compiled === void 0) {
+		const list = [];
+		for (const p of patterns) {
+			const re = compileChannelPattern(p);
+			if (re !== null) list.push(re);
+		}
+		compiled = list;
+		compiledSubscriptions.set(patterns, compiled);
 	}
+	return compiled;
+}
+/**
+* Dit si un abonnement webhook désigne une action d'audit, selon la grammaire commune aux canaux et aux webhooks (ADR-0023 W1).
+*
+* `*` vaut n'importe quelle suite de caractères : `*` désigne tout, `login.*` les
+* actions qui commencent par `login.`, `commande:*` aussi bien que `*:créée`
+* (`compileChannelPattern`, cœur). Chaque liste n'est compilée qu'une fois.
+*
+* @param patterns - les motifs de l'abonnement (`IWebhookEndpoint.events`).
+* @param action - le nom de l'action d'audit.
+* @returns `true` si un motif au moins désigne l'action.
+*/
+function matchesSubscription(patterns, action) {
+	for (const re of compiledPatterns(patterns)) if (re.test(action)) return true;
 	return false;
 }
 /**
+* Refuse une liste d'abonnement dont un motif porte trop de `*`, en le nommant.
+*
+* @param patterns - les motifs proposés à l'enregistrement ou à la mise à jour.
+* @throws Error si un motif dépasse `MAX_CHANNEL_PATTERN_WILDCARDS` étoiles.
+*/
+function assertSubscriptionPatterns(patterns) {
+	for (const p of patterns) if (countWildcards(p) > MAX_CHANNEL_PATTERN_WILDCARDS) throw new Error(`webhooks: le motif « ${p} » porte ${countWildcards(p)} caractères « * » (maximum ${MAX_CHANNEL_PATTERN_WILDCARDS}) — un motif en demande un, deux au pire.`);
+}
+/**
 * Classe le résultat d'une livraison : 2xx = succès ; réseau/timeout/429/408/5xx =
 * réessayable ; 3xx/4xx (config cliente erronée) = échec définitif (pas de retry).
 */
@@ -71,7 +117,8 @@ var WebhookDispatcher = class {
 			this.#enqueue({
 				ep,
 				event,
-				attempt: 0
+				attempt: 0,
+				messageId: null
 			});
 		}
 	}
@@ -112,17 +159,20 @@ var WebhookDispatcher = class {
 	}
 	/** Signe + livre une tentative ; gère succès / retry / échec définitif. */
 	async #process(job) {
-		const { ep, event, attempt } = job;
+		const { event, attempt } = job;
+		const ep = this.#deps.currentEndpoint(job.ep.id);
+		if (ep === null || !ep.enabled || !matchesSubscription(ep.events, event.action)) return;
 		try {
-			const id = this.#deps.newMessageId();
+			const id = job.messageId ?? this.#deps.newMessageId();
 			const nowMs = this.#deps.now();
 			const tsS = Math.floor(nowMs / 1e3);
-			const body = JSON.stringify({
+			const payload = {
 				id,
 				timestamp: new Date(nowMs).toISOString(),
 				type: event.action,
 				data: event
-			});
+			};
+			const body = JSON.stringify(payload);
 			const headers = {
 				"content-type": "application/json",
 				"user-agent": "Nodefony-Webhooks/1.0",
@@ -132,7 +182,7 @@ var WebhookDispatcher = class {
 			try {
 				addresses = await this.#deps.resolveTarget(ep.url);
 			} catch (e) {
-				const error = `ssrf: ${e.message}`;
+				const error = `ssrf: ${e instanceof Error ? e.message : String(e)}`;
 				await this.#deps.markDelivery(ep.id, {
 					ok: false,
 					status: null,
@@ -157,7 +207,7 @@ var WebhookDispatcher = class {
 				allowHttp: this.#deps.policy.allowHttp
 			});
 			if (classifyDelivery(result) === "retry" && attempt < this.#deps.policy.maxRetries) {
-				this.#scheduleRetry(job);
+				this.#scheduleRetry(job, id);
 				return;
 			}
 			await this.#deps.markDelivery(ep.id, result);
@@ -173,11 +223,14 @@ var WebhookDispatcher = class {
 				responseBody: result.responseBody ?? null
 			});
 		} catch (e) {
-			this.#deps.log(`webhook dispatch ${ep.id}: ${e.message}`);
+			this.#deps.log(`webhook dispatch ${ep.id}: ${e instanceof Error ? e.message : String(e)}`);
 		}
 	}
-	/** Replanifie la livraison après backoff (repasse par la file bornée). */
-	#scheduleRetry(job) {
+	/**
+	* Replanifie la livraison après backoff (repasse par la file bornée), sous le
+	* MÊME `webhook-id` que la tentative échouée.
+	*/
+	#scheduleRetry(job, messageId) {
 		if (this.#stopped) return;
 		this.#timers ??= /* @__PURE__ */ new Set();
 		const cancel = this.#deps.schedule(() => {
@@ -185,7 +238,8 @@ var WebhookDispatcher = class {
 			this.#enqueue({
 				ep: job.ep,
 				event: job.event,
-				attempt: job.attempt + 1
+				attempt: job.attempt + 1,
+				messageId
 			});
 		}, backoffMs(job.attempt));
 		this.#timers.add(cancel);
@@ -205,4 +259,4 @@ var WebhookDispatcher = class {
 		this.#queue = null;
 	}
 };
-export { WebhookDispatcher, backoffMs, classifyDelivery, matchesSubscription };
+export { WebhookDispatcher, assertSubscriptionPatterns, backoffMs, classifyDelivery, compiledPatterns, matchesSubscription };

package/dist/nodefony/src/webhook/webhookDelivery.js

@@ -1,7 +1,7 @@
+import { request } from "node:http";
 import { Buffer } from "node:buffer";
 import { isIP } from "node:net";
-import { request } from "node:https";
-import { request as request$1 } from "node:http";
+import { request as request$1 } from "node:https";
 // nodefony/src/webhook/webhookDelivery.ts
 /**
 * Émetteur HTTP d'une livraison webhook — `node:http(s)` natif (0 dép). Trois
@@ -49,7 +49,7 @@ function deliverWebhook(url, body, headers, opts) {
 		else callback(null, pinned, family);
 	} : void 0;
 	const payload = Buffer.from(body, "utf8");
-	const requestFn = isHttps ? request : request$1;
+	const requestFn = isHttps ? request$1 : request;
 	return new Promise((resolve) => {
 		let settled = false;
 		const done = (r) => {

package/dist/nodefony/testing/index.js

@@ -0,0 +1,98 @@
+import { RoleHierarchyWalker } from "../src/RoleHierarchyWalker.js";
+import { DEFAULT_SYSTEM_RULES, buildFrameAuthorizer } from "../src/realtime/frameAuthorizer.js";
+// nodefony/testing/index.ts
+/**
+* Une identité de connexion AUTHENTIFIÉE, telle que le pare-feu l'aurait posée
+* au handshake.
+*
+* Pour éprouver un visiteur anonyme, ne rien passer au harnais : il pose alors
+* le jeton anonyme, comme le repli Zero Trust du runtime.
+*
+* @param options - identifiant, rôles, scopes, utilisateur.
+* @returns un jeton à passer en `identity` au harnais temps réel.
+*/
+function createTestIdentity(options = {}) {
+	const identifier = options.identifier ?? "alice";
+	const roles = options.roles ?? ["ROLE_USER"];
+	return new TestToken(identifier, options.id ?? identifier, roles, options.scopes ?? [], options.user ?? {
+		identifier,
+		roles: [...roles]
+	});
+}
+/** Le jeton que rend {@link createTestIdentity}. */
+var TestToken = class {
+	identifier;
+	id;
+	roles;
+	scopes;
+	user;
+	type = "session";
+	#identity = null;
+	constructor(identifier, id, roles, scopes, user) {
+		this.identifier = identifier;
+		this.id = id;
+		this.roles = roles;
+		this.scopes = scopes;
+		this.user = user;
+	}
+	/**
+	* Identité d'admission gelée — ce que reçoit la règle `allow` d'un canal.
+	*
+	* Même forme que celle du jeton du pare-feu (`UserRealtimeToken.getIdentity`) :
+	* sans elle, tout canal à `allow` refusait la connexion d'essai, et une
+	* application ne pouvait éprouver un salon privé qu'en écrivant son propre jeton.
+	*/
+	getIdentity() {
+		if (this.#identity !== null) return this.#identity;
+		this.#identity = Object.freeze({
+			type: this.type,
+			authenticated: true,
+			id: this.id,
+			userIdentifier: this.identifier,
+			roles: Object.freeze([...this.roles]),
+			scopes: Object.freeze([...this.scopes]),
+			issuer: null,
+			account: true
+		});
+		return this.#identity;
+	}
+	getUserIdentifier() {
+		return this.identifier;
+	}
+	isAuthenticated() {
+		return true;
+	}
+	getRoles() {
+		return [...this.roles];
+	}
+	getScopes() {
+		return [...this.scopes];
+	}
+	getAttribute(key) {
+		return key === "user" ? this.user : void 0;
+	}
+};
+/**
+* Le VRAI verrou de frame du pare-feu, pour le harnais temps réel.
+*
+* C'est lui qui applique `@RealtimeChannel(nom, { roles })`,
+* `@RealtimeAction(nom, { roles })` et les canaux système : sans lui, une
+* politique déclarée n'est appliquée par personne — en test comme au runtime.
+*
+* @param channels - ce qui connaît les politiques déclarées : le hub temps réel
+*   (`getRealtimeHub()`), lu à CHAQUE frame — les politiques que le controller
+*   enregistre à sa construction y sont donc vues.
+* @param options - hiérarchie de rôles de l'application.
+* @returns le verrou à passer en `frameAuthorizer` au harnais.
+*/
+function createTestFrameAuthorizer(channels, options = {}) {
+	const walker = new RoleHierarchyWalker(options.roleHierarchy ?? {});
+	return buildFrameAuthorizer({
+		matchPath: () => null,
+		hasRole: (userRoles, required) => walker.hasRole(userRoles, required)
+	}, {
+		channelResolver: channels,
+		systemRules: DEFAULT_SYSTEM_RULES
+	});
+}
+export { createTestFrameAuthorizer, createTestIdentity };

package/dist/types/index.d.ts

@@ -168,6 +168,7 @@ export { WEBHOOK_SORTABLE_FIELDS, WEBHOOK_DEFAULT_ORDER, } from "./nodefony/src/
 export { registerWebhookStore, getWebhookStoreFactory, listWebhookStores, } from "./nodefony/src/webhook/webhookStoreRegistry.js";
 export type { WebhookStoreFactory, IWebhookStoreFactoryContext, } from "./nodefony/src/webhook/webhookStoreRegistry.js";
 export type { IWebhookEndpoint, WebhookEndpointUpdate, WebhookEndpointSummary, } from "./nodefony/contracts/IWebhookEndpoint.js";
+export type { IWebhookPayload } from "./nodefony/contracts/IWebhookPayload.js";
 export type { IWebhookListQuery, IWebhookStore, } from "./nodefony/contracts/IWebhookStore.js";
 export { assertPublicUrl, isBlockedAddress, } from "./nodefony/src/net/ssrfGuard.js";
 export type { IAssertPublicUrlOptions, IPublicUrlResult, DnsResolver, } from "./nodefony/src/net/ssrfGuard.js";

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

@@ -85,7 +85,9 @@ export declare const securityConfigSchema: z.ZodObject<{
         hsts: z.ZodDefault<z.ZodBoolean>;
         hstsMaxAgeS: z.ZodDefault<z.ZodNumber>;
         csp: z.ZodDefault<z.ZodString>;
+        cspSources: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
         cspNonces: z.ZodDefault<z.ZodBoolean>;
+        cspReport: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
         frameguard: z.ZodDefault<z.ZodEnum<{
             deny: "deny";
             sameorigin: "sameorigin";

package/dist/types/nodefony/contracts/IApiKey.d.ts

@@ -16,7 +16,10 @@ export interface IApiKeyView {
     subjectId: string;
     /** Discriminant du porteur. */
     subjectType: "user" | "service";
-    /** Organisation/tenant (`null` = global). */
+    /**
+     * Périmètre d'un locataire — réservé, toujours `null` tant que le multi-tenant
+     * n'existe pas (`createForSubject` refuse une valeur).
+     */
     tenantId: string | null;
     /** Création (epoch ms). */
     createdAt: number;
@@ -70,6 +73,9 @@ export interface ICreateApiKeyOptions {
     scopes?: string[];
     /** Durée de vie en jours ; `null` = sans expiration ; omis = défaut config. */
     expiresInDays?: number | null;
-    /** Tenant/organisation (multi-tenant) ; `null` = global. */
+    /**
+     * Périmètre d'un locataire — réservé, **refusé s'il est rempli** (`ApiKeyError` 400)
+     * tant que le multi-tenant n'existe pas. Absent ou `null` : clé sans périmètre.
+     */
     tenantId?: string | null;
 }

package/dist/types/nodefony/contracts/IFirewall.d.ts

@@ -28,13 +28,26 @@ export interface IFirewall extends IFirewallGate {
     handleCors(context: ContextType): number | undefined;
     /**
      * Pose les en-têtes de sécurité applicatifs (CSP, Referrer-Policy, COOP/COEP/
-     * CORP, Permissions-Policy) sur la réponse. No-op si désactivés / hors HTTP.
+     * CORP, Permissions-Policy) sur la réponse, selon son type (ADR-0024 §C11).
+     * No-op si désactivés / hors HTTP.
+     *
+     * @param contentType - `Content-Type` de la réponse ; `null` = sans contenu ;
+     *   omis = type inconnu (politique complète).
+     * @param servedAsFile - corps servi tel quel (fichier statique, relais), qui
+     *   ne peut pas porter de nonce : un document y reçoit la politique sans
+     *   nonce ni `'strict-dynamic'` (ADR-0024 §C1).
      */
-    applySecurityHeaders(context: ContextType): void;
+    applySecurityHeaders(context: ContextType, contentType?: string | null, servedAsFile?: boolean): void;
     /**
      * Déclare des directives CSP additionnelles pour un module (ex. `@nodefony/frontend`
      * en dev : origines Vite + `'unsafe-eval'`). Fusionnées dans le CSP de base et
      * recomposées (re-split nonce) au (dé)enregistrement — jamais par requête.
+     *
+     * Ne lève jamais : une contribution MALFORMÉE est ignorée en entier (journal
+     * ERROR), une source TROP LARGE (`*`, `https:`, `https://*`) est retirée
+     * (journal WARNING). La politique ne devient jamais plus permissive que demandé,
+     * et l'application démarre. Ce que l'application écrit elle-même (sa config,
+     * ses `@Csp`) ne passe pas par ce filtre.
      */
     registerCspOrigins(moduleName: string, fragment: CspFragment): void;
     /** Retire les directives CSP d'un module (ex. `stopDev` du frontend). */

package/dist/types/nodefony/contracts/ITokenStore.d.ts

@@ -14,7 +14,7 @@
  *  3. **seuil par porteur** (`invalidBefore`) — révocation EN MASSE (tout access
  *     auto-porté émis avant un instant T est rejeté → « déconnexion globale » / ban).
  */
-import type { IPage, IPageQuery, ISortableSource } from "nodefony";
+import type { IPage, IPageQuery, ISortableSource, TokenStatus } from "nodefony";
 /** Raison de révocation d'un jeton — tracée pour l'audit de sécurité. */
 export type TokenRevokeReason = "logout" | "rotated" | "reuse_detected" | "manual" | "compromised" | "subject_disabled" | "expired_cleanup";
 /**
@@ -153,8 +153,12 @@ export interface ITokenListQuery extends IPageQuery {
      */
     status?: TokenStatus;
 }
-/** État de vie d'un jeton — partition exhaustive, évaluée révoqué → expiré → actif. */
-export type TokenStatus = "active" | "expired" | "revoked";
+/**
+ * État de vie d'un jeton — partition exhaustive, évaluée révoqué → expiré → actif.
+ * Défini au cœur (le temps réel le lit aussi, sans dépendre de la sécurité) et
+ * réexporté ici sous le même nom.
+ */
+export type { TokenStatus } from "nodefony";
 /**
  * Contrat du store de jetons — implémentations enregistrées via
  * `registerTokenStore`, sélectionnées par config. Toutes les opérations sont

package/dist/types/nodefony/contracts/IWebhookEndpoint.d.ts

@@ -15,15 +15,25 @@ export interface IWebhookEndpoint {
     /** Secret de signature **chiffré** au repos (blob `gcm1.…`). Jamais en clair. */
     readonly secretEnc: string;
     /**
-     * Actions d'audit souscrites (ex. `"login.success"`, `"user.created"`).
-     * `"*"` = toutes. La livraison ne part que si l'action de l'événement matche.
+     * Motifs des actions d'audit souscrites, dans la grammaire commune aux canaux et
+     * aux webhooks (ADR-0023 W1) : `*` vaut n'importe quelle suite de caractères —
+     * `"*"` désigne tout, `"login.*"` les actions qui commencent par `login.`,
+     * `"commande:*"` comme `"*:créée"` ; le reste est littéral, trois `*` au plus
+     * (refusé à l'enregistrement au-delà). La livraison ne part que si un motif désigne
+     * l'action. Sans `tenantId`, l'abonnement a le périmètre de la PLATEFORME : il reçoit
+     * aussi les événements qu'une version ultérieure rattachera à un locataire
+     * (ADR-0023 W2).
      */
     readonly events: readonly string[];
     /** Endpoint actif ? (désactivé = aucune livraison). */
     readonly enabled: boolean;
     /** Libellé humain optionnel (console admin). */
     readonly description: string | null;
-    /** Slot multi-tenant (réservé P17) — `null` = global. */
+    /**
+     * Périmètre d'un locataire — réservé, toujours `null` tant que le multi-tenant
+     * n'existe pas (`register` refuse une valeur). Un abonnement sans périmètre ne
+     * reçoit que les événements sans périmètre (ADR-0023 W2).
+     */
     readonly tenantId: string | null;
     /** Identité de l'admin créateur (soft ref, traçabilité). */
     readonly createdBy: string | null;

package/dist/types/nodefony/contracts/IWebhookPayload.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Corps JSON d'une livraison webhook, tel que le destinataire le reçoit — le type à poser sur le `JSON.parse` du récepteur.
+ *
+ * Signé avec ses en-têtes (`webhook-id`, `webhook-timestamp`, `webhook-signature`,
+ * convention Standard Webhooks) : vérifier la signature AVANT de lire le corps.
+ *
+ * @typeParam T - la forme de `data` ; `unknown` tant que le récepteur ne l'a pas vérifiée.
+ */
+export interface IWebhookPayload<T = unknown> {
+    /**
+     * Identifiant du MESSAGE, égal à l'en-tête `webhook-id` et stable d'un réessai à l'autre : la clé de déduplication du récepteur.
+     */
+    readonly id: string;
+    /**
+     * Heure de la TENTATIVE de livraison (ISO 8601), pas celle de l'événement : un réessai porte une heure plus tardive.
+     *
+     * L'heure de l'événement vit dans `data` (`ts` pour un événement d'audit).
+     */
+    readonly timestamp: string;
+    /** Nom de l'événement — l'action d'audit, ex. `"login.success"` ; c'est lui que filtrent les motifs d'abonnement. */
+    readonly type: string;
+    /** L'événement lui-même ; pour l'audit, un `IAuditEvent`. */
+    readonly data: T;
+}

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

@@ -49,6 +49,9 @@ declare class ApiKeyService extends Service {
      * @param roles - rôles du porteur tels que son compte les porte ; omis =
      *   aucun rôle, donc tout scope réservé est refusé (fail-closed).
      * @throws ApiKeyError 400 — nom vide/trop long, scope hors catalogue, expiry invalide.
+     * @throws ApiKeyError 400 — `tenantId` rempli : le périmètre d'un locataire n'est
+     *   pas encore appliqué (aucun lecteur ne cloisonne sur lui) — l'accepter rendrait
+     *   la clé trompeuse, et l'appliquer un jour lui retirerait des accès (rupture).
      * @throws ApiKeyError 403 — scope réservé à des rôles que le porteur n'a pas.
      * @throws ApiKeyError 409 — plafond `maxPerSubject` atteint.
      * @throws ApiKeyError 403 — aucun compte sous cet identifiant (la clé est liée

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

@@ -8,6 +8,12 @@ import type { IFirewall } from "../contracts/IFirewall.js";
 import type { IAuthenticator } from "../contracts/IAuthenticator.js";
 import type { ISecuredArea } from "../contracts/ISecuredArea.js";
 import type { IFirewallDescription, IRoleHierarchyDescription } from "../contracts/IFirewallDescription.js";
+/**
+ * `Cache-Control` par défaut d'une réponse dont la CSP porte un nonce : jamais
+ * gardée par un cache partagé (le nonce y serait servi à plusieurs visiteurs),
+ * toujours redemandée avant réutilisation (ADR-0024 §C2).
+ */
+export declare const NONCED_DOCUMENT_CACHE_CONTROL = "private, no-cache";
 /**
  * Orchestrateur de sécurité Nodefony — refonte 2026 (P6).
  *
@@ -27,7 +33,7 @@ import type { IFirewallDescription, IRoleHierarchyDescription } from "../contrac
  *
  * Conformité : tout 401 porte un challenge `WWW-Authenticate` (RFC 9110
  * §15.5.2) — celui du premier authenticator de la zone qui en déclare un, sinon
- * le défi de repli {@link FALLBACK_CHALLENGE}.
+ * le défi de repli {@link SESSION_AUTH_CHALLENGE}.
  *
  * CORS, CSRF et autorisation par décorateurs viennent se brancher en S4/S5.
  * Toutes les structures sont **lazy** (perf : une app sans zone = zéro alloc).
@@ -141,20 +147,35 @@ declare class Firewall extends Service implements IFirewall {
     /**
      * En-têtes de sécurité APPLICATIFS (P6 J5) — CSP, Referrer-Policy, isolation
      * cross-origin (COOP/COEP/CORP), Origin-Agent-Cluster, Permissions-Policy.
-     * Posés sur toute réponse du pipeline (branché dans `handleHttp`). Complète le
-     * socle transport de `@nodefony/http` (nosniff/frame/HSTS, posé à l'entrée brute)
-     * SANS le ré-émettre. No-op si désactivé ou réponse non-HTTP (WS).
+     * Appelé par la réponse juste avant son `writeHead`, une fois son type fixé :
+     * la politique suit ce type (ADR-0024 §C11). Complète le socle transport de
+     * `@nodefony/http` (nosniff/frame/HSTS) SANS le ré-émettre. No-op si désactivé
+     * ou réponse non-HTTP (WS).
      *
      * En-têtes constants = table figée pré-calculée au boot (0 alloc/concat). Le CSP
-     * nonce/req (étape B) ajoute 1 `join` + 1 `setHeader` UNIQUEMENT si activé.
+     * nonce/req ajoute 1 `join` + 1 `setHeader`, sur un document seulement.
+     *
+     * @param context - contexte de la réponse.
+     * @param contentType - `Content-Type` de la réponse ; `null` = sans contenu ;
+     *   omis = type inconnu, servi comme un document (politique complète).
+     * @param servedAsFile - le corps est servi tel quel (fichier statique,
+     *   relais) : aucun gabarit ne l'a écrit, il ne peut pas porter de nonce. Un
+     *   document reçoit alors la politique sans nonce ni `'strict-dynamic'`
+     *   (ADR-0024 §C1) ; les autres types n'en changent pas.
      */
-    applySecurityHeaders(context: ContextType): void;
+    applySecurityHeaders(context: ContextType, contentType?: string | null, servedAsFile?: boolean): void;
     /**
      * Déclare des directives CSP additionnelles pour `moduleName` (cf `IFirewall`).
      * No-op si les en-têtes applicatifs sont désactivés (pas de CSP à étendre).
      * Recompose `#securityHeaders` (merge + re-split nonce) — hors hot-path.
      */
-    registerCspOrigins(moduleName: string, fragment: CspFragment): void;
+    registerCspOrigins(moduleName: string, declared: CspFragment): void;
+    /**
+     * Le noyau HTTP a recalculé ses en-têtes de transport (édition à chaud de sa
+     * config) : la politique suit `frameOptions`, qui pilote aussi
+     * `frame-ancestors` (ADR-0024 §C5). Hors chemin chaud.
+     */
+    onTransportHeadersChanged(): void;
     /** Retire les directives CSP de `moduleName` et recompose si nécessaire. */
     unregisterCspOrigins(moduleName: string): void;
     log(pci: unknown, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;

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

@@ -1,10 +1,26 @@
 import { type CspFragment } from "../src/csp.js";
+/**
+ * Famille d'une réponse au regard de la politique de contenu (ADR-0024 §C11) :
+ * `document` (HTML, XHTML, SVG — politique complète avec nonce et
+ * `Permissions-Policy`), `script` (JavaScript — politique complète SANS nonce,
+ * celle que prend un worker), `other` (tout le reste — politique courte figée).
+ */
+export type ResponseKind = "document" | "script" | "other";
+/**
+ * Range une réponse dans sa famille d'après son `Content-Type`.
+ *
+ * @param contentType - valeur de `Content-Type` (paramètres admis) ; `null` =
+ *   réponse sans contenu ; `undefined` = type INCONNU de l'appelant, traité en
+ *   document — la politique la plus complète, jamais une plus faible par défaut.
+ * @returns la famille dont la réponse reçoit la politique.
+ */
+export declare function responseKindOf(contentType: string | null | undefined): ResponseKind;
 /**
  * Sous-ensemble APPLICATIF de la config `headers` (cf defineSecurityConfig).
  *
  * `hsts` / `frameguard` / `noSniff` n'y figurent PAS volontairement : ces trois
- * en-têtes « transport » sont posés par `@nodefony/http` à l'entrée brute
- * (`onHttpRequest`, AVANT le pipeline) pour couvrir AUSSI les fichiers statiques,
+ * en-têtes « transport » sont posés par `@nodefony/http` sur toute réponse
+ * (`HttpKernel.transportHeaders`, figés au démarrage) pour couvrir AUSSI les fichiers statiques,
  * les erreurs précoces et un serveur sans module security (secure-by-default).
  * `@nodefony/security` ne les ré-émet pas → une seule source par en-tête.
  */
@@ -18,6 +34,12 @@ export interface ISecurityHeadersOptions {
     corp?: string | undefined;
     originAgentCluster?: boolean | undefined;
     permissionsPolicy?: string | undefined;
+    /**
+     * Valeur de `Reporting-Endpoints` (`groupe="url"`), quand la politique
+     * désigne un groupe `report-to` composé par le framework (ADR-0024 §C7).
+     * Posé là où la politique complète part : document, script, fichier servi.
+     */
+    reportingEndpoints?: string | null | undefined;
 }
 /**
  * En-têtes de sécurité **applicatifs** de Nodefony (couche `@nodefony/security`,
@@ -26,19 +48,65 @@ export interface ISecurityHeadersOptions {
  * cross-origin COOP/COEP/CORP, Origin-Agent-Cluster, Permissions-Policy) → zéro
  * alloc, zéro concat par requête (le firewall la pose telle quelle).
  *
- * **Étape A+B** : en-têtes constants pré-calculés au boot (Referrer/COOP/…). Pour le
- * CSP, deux régimes mutuellement exclusifs : **statique** (posé tel quel via `headers`,
- * 0 alloc/req) OU **nonce par requête** (`cspNonces` + placeholder `{{nonce}}` dans le
- * CSP) → segments pré-split au boot, recomposés par requête via `cspFor(nonce)` (1
- * `join`, aucun parse/regex dans le hot-path). Le nonce lui-même vit sur `Context`.
+ * Pour le CSP, deux régimes mutuellement exclusifs : **statique** (posé tel quel via
+ * `headers`, 0 alloc/req) OU **nonce par requête** (`cspNonces` + placeholder
+ * `{{nonce}}`) → segments pré-split au boot, recomposés par requête via
+ * `cspFor(nonce)` (1 concaténation, aucun parse/regex dans le hot-path).
+ *
+ * **Deux variantes, composées au boot** (ADR-0024 §C6) : la politique telle
+ * qu'écrite, servie en TLS, et la même SANS `upgrade-insecure-requests`, servie
+ * en clair — sur une page `http`, la directive réécrirait les sous-ressources en
+ * `https`, que le serveur ne sert pas. Sans la directive, les deux variantes sont
+ * le MÊME objet : par requête, un booléen choisit, rien de plus.
  *
  * @see Fetch Metadata · W3C CSP Level 3 · WHATWG (COOP/COEP/CORP).
  */
 export declare class SecurityHeaders {
     #private;
-    constructor(o: ISecurityHeadersOptions);
-    /** Table d'en-têtes applicatifs CONSTANTS (figée), posée telle quelle par le firewall. */
+    /**
+     * @param o - options des en-têtes (config `security.headers`, CSP déjà fusionnée).
+     * @param onRejectedExtra - appelé quand les directives `@Csp` d'une route sortent
+     *   de la grammaire CSP3 : la route sert alors la politique de base.
+     */
+    constructor(o: ISecurityHeadersOptions, onRejectedExtra?: (error: unknown) => void);
+    /**
+     * Table d'en-têtes figée d'un DOCUMENT servi tel quel — fichier statique,
+     * réponse relayée — dont le corps ne passe par aucun gabarit et ne peut donc
+     * pas porter de nonce (ADR-0024 §C1) : politique complète sans nonce ni
+     * `'strict-dynamic'` orphelin, et tous les en-têtes d'un document.
+     *
+     * @param tls - la page est servie en `https` (garde `upgrade-insecure-requests`).
+     * @returns la table à poser telle quelle.
+     */
+    headersForServedFile(tls: boolean): Readonly<Record<string, string>>;
+    /**
+     * Table d'en-têtes figée d'une réponse qui n'est pas un document (ADR-0024
+     * §C11) : JavaScript (politique complète sans nonce, Referrer-Policy, COEP,
+     * CORP) ou reste (politique courte `default-src 'none'`, Referrer-Policy,
+     * CORP). Ni l'une ni l'autre ne porte de nonce ; COOP, Origin-Agent-Cluster
+     * et Permissions-Policy, lus sur un document seulement, n'y figurent pas.
+     *
+     * @param kind - famille de la réponse (cf {@link responseKindOf}).
+     * @param tls - la page est servie en `https` (garde `upgrade-insecure-requests`).
+     * @returns la table à poser telle quelle.
+     */
+    headersForResource(kind: Exclude<ResponseKind, "document">, tls: boolean): Readonly<Record<string, string>>;
+    /** Table d'en-têtes applicatifs CONSTANTS (figée) d'une réponse en clair. */
     get headers(): Readonly<Record<string, string>>;
+    /**
+     * Table constante SANS la CSP statique d'une réponse en clair — pour une
+     * réponse qui pose sa propre politique (route `@Csp`), afin que la CSP ne
+     * soit écrite qu'une fois.
+     */
+    get headersWithoutCsp(): Readonly<Record<string, string>>;
+    /**
+     * Table d'en-têtes constants selon le transport de la réponse.
+     *
+     * @param tls - la page est servie en `https` (proxy de confiance compris).
+     * @param withoutCsp - omettre la CSP statique (route `@Csp` qui pose la sienne).
+     * @returns la table figée à poser telle quelle.
+     */
+    headersFor(tls: boolean, withoutCsp?: boolean): Readonly<Record<string, string>>;
     /** `true` si le CSP est recomposé par requête avec un nonce (→ `cspFor`). */
     get hasNonce(): boolean;
     /**
@@ -48,9 +116,11 @@ export declare class SecurityHeaders {
      * `'`/`;`/espace) → aucune évasion possible du token CSP.
      *
      * @param nonce - nonce base64 de la requête (`Context.cspNonce`).
+     * @param tls - la page est servie en `https` : la politique garde
+     *   `upgrade-insecure-requests`. Défaut : en clair.
      * @returns la valeur `Content-Security-Policy` à poser sur la réponse.
      */
-    cspFor(nonce: string): string;
+    cspFor(nonce: string, tls?: boolean): string;
     /**
      * Recompose le CSP en fusionnant ADDITIVEMENT les directives `extra` d'une
      * route (`@Csp`) dans le CSP de base, PUIS en substituant le `nonce`. Le merge
@@ -60,8 +130,9 @@ export declare class SecurityHeaders {
      *
      * @param nonce - nonce base64 de la requête (ignoré si le CSP n'a pas de nonce).
      * @param extra - directives additionnelles de la route (`directive → sources`).
+     * @param tls - la page est servie en `https`. Défaut : en clair.
      * @returns la valeur `Content-Security-Policy` à poser sur la réponse.
      */
-    cspForExtra(nonce: string, extra: CspFragment): string;
+    cspForExtra(nonce: string, extra: CspFragment, tls?: boolean): string;
 }
 export default SecurityHeaders;