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

package/dist/nodefony/src/token/jwtRuntime.js

@@ -3,12 +3,32 @@
 * Dérive les paramètres effectifs depuis la config sécurité. `issuer` omis →
 * `"nodefony"` (DEVRAIT être surchargé en prod) ; `audiences` vide → l'app est sa
 * propre audience (`[issuer]`).
+*
+* La ressource d'une ZONE (`areas.<zone>.resource`) entre aussi dans la liste,
+* APRÈS les audiences déclarées : c'est une ressource que ce serveur protège, et
+* la redéclarer dans `jwt.audiences` était une seconde écriture de la même
+* valeur — celle qu'on oublie, et dont le seul symptôme est un `invalid_target`
+* à l'émission. Ajoutée en fin de liste, elle ne change jamais l'audience par
+* défaut ({@link defaultAudience}).
+*
+* Elle n'ouvre rien de plus à la VÉRIFICATION : chaque zone, `jwt` comme
+* `external-jwt`, exige SA ressource (l'audience par défaut pour une zone `jwt`
+* qui n'en déclare pas) — un jeton émis pour une zone n'en ouvre pas une autre.
+*
+* @param jwt - section `jwt` de la config validée
+* @param areas - zones du pare-feu ; omises, seules les audiences déclarées comptent
+* @returns les paramètres partagés par l'émetteur et les vérificateurs
 */
-function resolveJwtRuntime(jwt) {
+function resolveJwtRuntime(jwt, areas) {
 	const issuer = jwt.issuer && jwt.issuer.length > 0 ? jwt.issuer : "nodefony";
+	const audiences = jwt.audiences.length > 0 ? [...jwt.audiences] : [issuer];
+	if (areas !== void 0) for (const name in areas) {
+		const resource = areas[name]?.resource;
+		if (resource !== void 0 && !audiences.includes(resource)) audiences.push(resource);
+	}
 	return {
 		issuer,
-		audiences: jwt.audiences.length > 0 ? [...jwt.audiences] : [issuer],
+		audiences,
 		accessTtlS: jwt.accessTtlS,
 		refreshTtlS: jwt.refreshTtlS,
 		rotateRefresh: jwt.rotateRefresh,

package/dist/nodefony/src/token/tokenTimeClaims.js

@@ -0,0 +1,34 @@
+// nodefony/src/token/tokenTimeClaims.ts
+/**
+* Bornes temporelles qu'un jeton d'accès JWT DOIT porter : `exp` et `iat`
+* (RFC 9068 §2.2, l'un et l'autre REQUIRED).
+*
+* UNE règle pour les deux chemins de vérification — jeton de l'application
+* (`JwtAuthenticator`) et jeton d'un émetteur tiers (`RemoteJwtVerifier`). Sans
+* `exp`, une connexion ouverte avec le jeton n'a plus de borne propre : le
+* revalidateur d'une socket ne sait alors la fermer que par le store de
+* révocation, et une clé volée suffit à signer un accès éternel.
+*/
+const REQUIRED_TIME_CLAIMS = Object.freeze(["exp", "iat"]);
+/**
+* Tolérance d'horloge entre l'émetteur et ce serveur, en secondes : appliquée à
+* `exp`/`nbf` par jose, et à `iat` par {@link isIssuedInFuture}.
+*/
+const CLOCK_TOLERANCE_S = 5;
+/**
+* Le jeton se dit-il émis dans le futur, au-delà de la tolérance d'horloge ?
+*
+* jose ne contrôle `iat` que lorsqu'un âge maximal est imposé (`maxTokenAge`),
+* ce que Nodefony ne fait pas. Or un `iat` daté du futur rend inopérante la
+* révocation en masse (`invalidBefore`), qui compare `iat` à un seuil passé :
+* un jeton forgé à `iat = maintenant + 10 ans` ne serait jamais « émis avant ».
+*
+* @param payload - claims VÉRIFIÉS du jeton (signature déjà contrôlée)
+* @param nowS - instant présent, en secondes epoch
+* @param toleranceS - écart d'horloge admis, en secondes
+* @returns `true` si `iat` dépasse `nowS + toleranceS`
+*/
+function isIssuedInFuture(payload, nowS, toleranceS) {
+	return typeof payload.iat === "number" && payload.iat > nowS + toleranceS;
+}
+export { CLOCK_TOLERANCE_S, REQUIRED_TIME_CLAIMS, isIssuedInFuture };

package/dist/nodefony/src/totp/totpOperations.js

@@ -1,6 +1,6 @@
 import { decryptSecret, encryptSecret } from "../crypto/secretCipher.js";
-import "./totpCipher.js";
 import { base32Encode, buildOtpauthUri, generateRecoveryCodes, generateTotpSecret, hashRecoveryCode, matchRecoveryCode, verifyTotp } from "./totpCrypto.js";
+import "./totpCipher.js";
 // nodefony/src/totp/totpOperations.ts
 /**
 * Démarre l'enrôlement : génère un secret aléatoire, le **chiffre** au repos et

package/dist/nodefony/src/voter/RoleVoter.js

@@ -1,5 +1,5 @@
-import { RoleHierarchyWalker } from "../RoleHierarchyWalker.js";
 import "../../contracts/IAccessVoter.js";
+import { RoleHierarchyWalker } from "../RoleHierarchyWalker.js";
 // nodefony/src/voter/RoleVoter.ts
 /**
 * Voter built-in **niveau A** — résout les attributs `ROLE_*` via la hiérarchie

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,101 +1,52 @@
-import { Buffer } from "node:buffer";
-import { isIP } from "node:net";
-import { request } from "node:https";
-import { request as request$1 } from "node:http";
+import { fetchPublic } from "../net/fetchPublic.js";
+import { FetchPublicError } from "../../errors/FetchPublicError.js";
 // nodefony/src/webhook/webhookDelivery.ts
 /**
-* Émetteur HTTP d'une livraison webhook — `node:http(s)` natif (0 dép). Trois
-* propriétés de sécurité par rapport à `fetch` :
-*
-* 1. **Pas de suivi de redirection** : `node:http(s)` ne suit JAMAIS les 3xx
-*    (contrairement à `fetch`) → un `302 → 169.254.169.254` ne contourne pas le
-*    contrôle SSRF ; le 3xx est rendu tel quel (échec de config).
-* 2. **Pin de l'IP validée** (anti DNS-rebinding) : `lookup` force la connexion TCP
-*    vers l'IP déjà contrôlée par `assertPublicUrl`, tout en gardant le hostname
-*    pour le SNI/TLS et l'en-tête `Host` → pas de re-résolution entre contrôle et
-*    connexion.
-* 3. **Timeout dur** : la requête est détruite au-delà du délai.
+* Émetteur HTTP d'une livraison webhook — délègue à {@link fetchPublic}, la
+* primitive unique des requêtes sortantes : pas de suivi de redirection, IP
+* vérifiée épinglée (anti DNS-rebinding), délai total, lecture bornée.
 */
 /** Taille max du corps de réponse capturé (observabilité, anti-mémoire). */
 const RESPONSE_BODY_CAP = 2048;
 /**
-* POST le corps signé vers l'URL, en pinnant l'IP validée et sans suivre les
-* redirections. Ne lève jamais : tout échec est encodé dans {@link IDeliveryResult}.
+* POST le corps signé vers l'URL, par {@link fetchPublic} : IP vérifiée épinglée,
+* aucune redirection suivie, délai TOTAL (un destinataire qui goutte un octet
+* ne retient pas la livraison) et lecture du corps coupée à
+* {@link RESPONSE_BODY_CAP} (connexion détruite, pas drainée). Ne lève jamais :
+* tout échec est encodé dans {@link IDeliveryResult}.
 */
-function deliverWebhook(url, body, headers, opts) {
-	let u;
+async function deliverWebhook(url, body, headers, opts) {
 	try {
-		u = new URL(url);
-	} catch {
-		return Promise.resolve({
+		const vetted = opts.addresses !== void 0 && opts.addresses.length > 0;
+		const r = await fetchPublic(url, {
+			method: "POST",
+			headers,
+			body,
+			maxBytes: RESPONSE_BODY_CAP,
+			timeoutMs: opts.timeoutMs,
+			allowHttp: opts.allowHttp === true,
+			allowPrivate: !vetted,
+			...vetted ? { vettedAddresses: opts.addresses } : {}
+		});
+		const ok = r.status >= 200 && r.status < 300;
+		const text = r.body.length > 0 ? new TextDecoder().decode(r.body) : "";
+		return {
+			ok,
+			status: r.status,
+			error: ok ? null : `HTTP ${r.status}`,
+			responseBody: text.length > 0 ? text : null
+		};
+	} catch (e) {
+		if (e instanceof FetchPublicError && e.reason === "timeout") return {
 			ok: false,
 			status: null,
-			error: "URL invalide"
-		});
-	}
-	const isHttps = u.protocol === "https:";
-	if (!isHttps && !(u.protocol === "http:" && opts.allowHttp)) return Promise.resolve({
-		ok: false,
-		status: null,
-		error: `protocole ${u.protocol} non autorisé`
-	});
-	const pinned = opts.addresses && opts.addresses.length > 0 ? opts.addresses[0] : null;
-	const lookup = pinned ? (_hostname, options, callback) => {
-		const family = isIP(pinned) === 6 ? 6 : 4;
-		if (options.all) callback(null, [{
-			address: pinned,
-			family
-		}], family);
-		else callback(null, pinned, family);
-	} : void 0;
-	const payload = Buffer.from(body, "utf8");
-	const requestFn = isHttps ? request : request$1;
-	return new Promise((resolve) => {
-		let settled = false;
-		const done = (r) => {
-			if (!settled) {
-				settled = true;
-				resolve(r);
-			}
+			error: "timeout"
 		};
-		const req = requestFn(url, {
-			method: "POST",
-			headers: {
-				...headers,
-				"content-length": String(payload.length)
-			},
-			lookup
-		}, (res) => {
-			const status = res.statusCode ?? 0;
-			const ok = status >= 200 && status < 300;
-			let resBody = "";
-			res.on("data", (c) => {
-				if (resBody.length < RESPONSE_BODY_CAP) {
-					resBody += c.toString("utf8");
-					if (resBody.length > RESPONSE_BODY_CAP) resBody = resBody.slice(0, RESPONSE_BODY_CAP);
-				}
-			});
-			res.on("end", () => done({
-				ok,
-				status,
-				error: ok ? null : `HTTP ${status}`,
-				responseBody: resBody.length > 0 ? resBody : null
-			}));
-			res.on("error", (e) => done({
-				ok: false,
-				status,
-				error: e.message,
-				responseBody: resBody.length > 0 ? resBody : null
-			}));
-		});
-		req.setTimeout(opts.timeoutMs, () => req.destroy(/* @__PURE__ */ new Error("timeout")));
-		req.on("error", (e) => done({
+		return {
 			ok: false,
 			status: null,
-			error: e.message
-		}));
-		req.write(payload);
-		req.end();
-	});
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
 }
 export { deliverWebhook };

package/dist/nodefony/testing/index.js

@@ -2,40 +2,6 @@ import { RoleHierarchyWalker } from "../src/RoleHierarchyWalker.js";
 import { DEFAULT_SYSTEM_RULES, buildFrameAuthorizer } from "../src/realtime/frameAuthorizer.js";
 // nodefony/testing/index.ts
 /**
-* `@nodefony/security/testing` — **identité d'essai et VRAI verrou de frame**,
-* pour éprouver un canal ou une action temps réel protégés.
-*
-* Le harnais de `@nodefony/realtime/testing` accepte une identité et un verrou,
-* mais n'en fournit aucun : `@nodefony/realtime` ne connaît pas la sécurité.
-* Faute de mieux, une application écrivait un jeton factice et un verrou qui ne
-* regardait que `isAuthenticated()` — son test passait, et n'éprouvait PAS la
-* politique de rôles du canal. Un canal mal protégé y était vert. Deux agents
-* sur deux l'ont fait, en recopiant le jeton que montrait le test généré.
-*
-* Ce module rend les deux pièces, et le verrou rendu est celui du pare-feu —
-* {@link buildFrameAuthorizer}, la même fabrique que le boot branche sur le hub,
-* avec la même hiérarchie de rôles et les mêmes canaux système. Seuls manquent
-* le journal d'audit (un refus en test n'est pas une transition de sécurité) et
-* les ZONES HTTP : une frame `api.request` y passe comme hors de toute zone, et
-* la garde d'une route s'éprouve par HTTP, pas ici.
-*
-* ```ts
-* import { getRealtimeHub } from "@nodefony/realtime";
-* import { createRealtimeHarness } from "@nodefony/realtime/testing";
-* import {
-*   createTestFrameAuthorizer,
-*   createTestIdentity,
-* } from "@nodefony/security/testing";
-*
-* const h = createRealtimeHarness((ctx) => new ChatController(ctx), {
-*   identity: createTestIdentity({ identifier: "alice", roles: ["ROLE_USER"] }),
-*   frameAuthorizer: createTestFrameAuthorizer(getRealtimeHub()),
-* });
-* ```
-*
-* @packageDocumentation
-*/
-/**
 * Une identité de connexion AUTHENTIFIÉE, telle que le pare-feu l'aurait posée
 * au handshake.
 *
@@ -48,7 +14,7 @@ import { DEFAULT_SYSTEM_RULES, buildFrameAuthorizer } from "../src/realtime/fram
 function createTestIdentity(options = {}) {
 	const identifier = options.identifier ?? "alice";
 	const roles = options.roles ?? ["ROLE_USER"];
-	return new TestToken(identifier, roles, options.scopes ?? [], options.user ?? {
+	return new TestToken(identifier, options.id ?? identifier, roles, options.scopes ?? [], options.user ?? {
 		identifier,
 		roles: [...roles]
 	});
@@ -56,16 +22,40 @@ function createTestIdentity(options = {}) {
 /** Le jeton que rend {@link createTestIdentity}. */
 var TestToken = class {
 	identifier;
+	id;
 	roles;
 	scopes;
 	user;
 	type = "session";
-	constructor(identifier, roles, scopes, user) {
+	#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;
 	}

package/dist/types/index.d.ts

@@ -168,9 +168,12 @@ 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";
+export { fetchPublic } from "./nodefony/src/net/fetchPublic.js";
+export type { IFetchPublicOptions, IFetchPublicResult, } from "./nodefony/src/net/fetchPublic.js";
 export { deriveKey, encryptSecret, decryptSecret, generateEphemeralKey, } from "./nodefony/src/crypto/secretCipher.js";
 export type { IKeyDerivation } from "./nodefony/src/crypto/secretCipher.js";
 export { defineSecurityConfig, securityConfigJsonSchema, } from "./nodefony/config/defineModuleConfig.js";
@@ -179,6 +182,7 @@ export { LoginThrottler } from "./nodefony/src/throttle/LoginThrottler.js";
 export type { ILoginThrottleOptions } from "./nodefony/src/throttle/LoginThrottler.js";
 export { CredentialTransportPolicy, shouldEnforceCredentialTransport, } from "./nodefony/src/transport/CredentialTransportPolicy.js";
 export type { ICredentialTransportContext, ICredentialTransportPolicyOptions, } from "./nodefony/src/transport/CredentialTransportPolicy.js";
-export { AuthenticationError, AccessDeniedError, ThrottledError, UnverifiableTokenError, InvalidTargetError, CsrfError, SsrfError, InsecureTransportError, } from "./nodefony/errors/index.js";
+export { AuthenticationError, AccessDeniedError, ThrottledError, UnverifiableTokenError, InvalidTargetError, CsrfError, SsrfError, FetchPublicError, InsecureTransportError, } from "./nodefony/errors/index.js";
+export type { FetchPublicFailure } from "./nodefony/errors/index.js";
 export { VoterVote } from "./nodefony/contracts/index.js";
 export type { IToken, IAuthenticator, ISecuredArea, IFirewall, IAccessVoter, IAuthorizationService, IAccessTokenRecord, ITokenStore, ITokenListQuery, ITokenUsage, IResourcePermission, TokenRevokeReason, TokenStatus, IJwtKeystore, IJwtSigningKey, } from "./nodefony/contracts/index.js";

package/dist/types/nodefony/command/security-mcp-token.d.ts

@@ -19,6 +19,18 @@ export declare function ttlSeconds(raw: string | undefined): number | undefined
  * @returns les secondes, `undefined` pour le défaut de configuration, une `Error` sinon
  */
 export declare function tokenTtlSeconds(raw: string | undefined, write: boolean): number | undefined | Error;
+/**
+ * Le jeton vise-t-il une AUTRE porte que celle de l'outillage ?
+ *
+ * `NF_MCP_TOKEN` et `--write` servent la porte par défaut, et elle seule : un
+ * jeton d'une autre audience (RFC 8707) y prendrait sa place, et cette porte le
+ * refuserait — ses outils réservés disparaîtraient sans un mot.
+ *
+ * @param resource - la valeur de `--resource`, ou rien
+ * @param defaultResource - la porte par défaut de l'application
+ * @returns `true` quand `--resource` désigne une autre porte
+ */
+export declare function targetsOtherGate(resource: string | undefined, defaultResource: string): boolean;
 /**
  * `nodefony security:mcp:token` — émet un jeton d'accès pour une porte de cette
  * application (la porte MCP par défaut).

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";
@@ -338,6 +340,12 @@ export declare const securityConfigSchema: z.ZodObject<{
         immutable: z.ZodDefault<z.ZodBoolean>;
         stream: z.ZodDefault<z.ZodBoolean>;
         retentionDays: z.ZodDefault<z.ZodNumber>;
+        aggregate: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            windowMs: z.ZodDefault<z.ZodNumber>;
+            burst: z.ZodDefault<z.ZodNumber>;
+            maxKeys: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     studio: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

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;