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

package/README.md

@@ -148,6 +148,11 @@ le trafic courant ne passe pas par l'audit (cold-path)
 → aucun coût ajouté au hot-path nominal. Activé par défaut (`audit.enabled`, OWASP A09), coût nul si
 désactivé. Lecture : `GET /nodefony/security/api/audit/events` (RBAC `ROLE_NODEFONY_ADMIN`).
 
+Un **flot de refus** d'une même source (même IP, même motif) ne s'écrit pas ligne à ligne : les
+10 premiers refus par fenêtre de 60 s sont journalisés tels quels, les suivants comptés, puis une ligne
+de synthèse porte le total (`metadata.aggregated`). Les succès ne sont jamais agrégés. Réglage :
+`audit.aggregate` — détail dans [docs/audit.md](docs/audit.md).
+
 **Flux temps réel** (lot 4) : canal WS **`nodefony:audit`**, réservé `ROLE_NODEFONY_ADMIN`
 (plancher système, un cran au-dessus de l'observabilité générique `ROLE_ADMIN`). Enregistré comme
 **canal système** sur le hub realtime (servable par tout endpoint, sans couplage à Studio) ;
@@ -178,6 +183,25 @@ Un **secret n'entre jamais** dans un événement — seule sa _présence_ est tr
 
 - `AuthenticationError` → `401` (non authentifié).
 - `AccessDeniedError` → `403` (authentifié mais non autorisé).
+- `SsrfError` → `422` (adresse sortante interdite, redirection comprise).
+- `FetchPublicError` → `504` (délai total) ou `502` (trop de redirections, réseau).
+
+## Requêtes sortantes sûres
+
+`fetchPublic(url, options)` lit une adresse fournie par un humain sans atteindre le réseau interne : IP vérifiée
+puis épinglée à chaque saut, redirections comptées et revérifiées (`maxRedirects`, 0 par défaut), délai TOTAL
+(`timeoutMs`), corps coupé à `maxBytes` et non décodé, ni cookie ni `Authorization`. Les webhooks passent par elle.
+
+```ts
+import { fetchPublic } from "@nodefony/security";
+
+const page = await fetchPublic(url, {
+  maxRedirects: 3,
+  maxBytes: 262_144,
+  timeoutMs: 4000,
+});
+console.log(page.status, new TextDecoder().decode(page.body));
+```
 
 ## Licence
 

package/dist/_virtual/{_@oxc-project_runtime@0.157.0 → _@oxc-project_runtime@0.158.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-// \0@oxc-project+runtime@0.157.0/helpers/esm/decorate.js
+// \0@oxc-project+runtime@0.158.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/index.js

@@ -28,7 +28,7 @@ import SecurityOAuthDoctor from "./nodefony/command/security-oauth-doctor.js";
 import { createSecurityAdminApi, parseAuditQuery, registerSecurityAdminApi } from "./nodefony/src/admin/SecurityAdminApi.js";
 import { registerUserRevocationCascade, usersEventBusNotice } from "./nodefony/src/admin/userRevocationCascade.js";
 import { defineSecurityConfig, securityConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { RemoteJwtVerifier } from "./nodefony/src/token/RemoteJwtVerifier.js";
 import { amrForFactor } from "./nodefony/src/sessionAuthentication.js";
 import { ApiKeyError } from "./nodefony/errors/ApiKeyError.js";
@@ -73,6 +73,7 @@ import { KeycloakAdminClient, KeycloakAdminError, keycloakAdminTarget, keycloakL
 import { createDiscoveredOidcProvider, createOidcProvider, readLogoutTokenClaims } from "./nodefony/src/oauth/providers/oidc.js";
 import { SsrfError } from "./nodefony/errors/SsrfError.js";
 import { createGithubProvider } from "./nodefony/src/oauth/providers/github.js";
+import { FetchPublicError } from "./nodefony/errors/FetchPublicError.js";
 import { MemoryAuditStore } from "./nodefony/src/audit/MemoryAuditStore.js";
 import { getAuditStoreFactory, listAuditStores, registerAuditStore } from "./nodefony/src/audit/auditStoreRegistry.js";
 import { recordAudit } from "./nodefony/src/audit/recordAudit.js";
@@ -86,6 +87,7 @@ import { MemoryWebhookStore } from "./nodefony/src/webhook/MemoryWebhookStore.js
 import { WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS } from "./nodefony/src/webhook/webhookSort.js";
 import { getWebhookStoreFactory, listWebhookStores, registerWebhookStore } from "./nodefony/src/webhook/webhookStoreRegistry.js";
 import { assertPublicUrl, isBlockedAddress } from "./nodefony/src/net/ssrfGuard.js";
+import { fetchPublic } from "./nodefony/src/net/fetchPublic.js";
 import { decryptSecret, deriveKey, encryptSecret, generateEphemeralKey } from "./nodefony/src/crypto/secretCipher.js";
 import { LoginThrottler } from "./nodefony/src/throttle/LoginThrottler.js";
 import { CredentialTransportPolicy, shouldEnforceCredentialTransport } from "./nodefony/src/transport/CredentialTransportPolicy.js";
@@ -186,4 +188,4 @@ Security = __decorate([services([
 	KeycloakService
 ])], Security);
 var security_default = Security;
-export { AccessDeniedError, AccessTokenVerifierService, AnonymousAuthenticator, AnonymousToken, ApiKeyAuthenticator, ApiKeyError, ApiKeyService, AuditService, AuthFlow, AuthenticationError, Authorization, Cors, CredentialTransportPolicy, Csrf, CsrfError, CsrfTokenManager, ExternalJwtAuthenticator, Firewall, InsecureTransportError, InvalidTargetError, JwtAuthenticator, JwtKeystore, KeycloakAdminClient, KeycloakAdminError, KeycloakService, LoginThrottler, MemoryAuditStore, MemoryTokenStore, MemoryTotpSecretStore, MemoryWebAuthnCredentialStore, MemoryWebhookStore, OAuth2Client, OAuth2RequestError, OAuth2Service, OAuth2Tokens, RemoteJwtVerifier, RoleHierarchyWalker, RoleVoter, ScopeVoter, SecuredArea, SecurityHeaders, SessionAuthenticator, SsrfError, TOKEN_DEFAULT_ORDER, TOKEN_FACETS, TOKEN_SORTABLE_FIELDS, ThrottledError, TokenService, TotpService, UnverifiableTokenError, UserPasswordAuthenticator, UserToken, VoterVote, WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS, WebAuthnService, WebhookService, amrForFactor, assertPublicUrl, base32Decode, beginTotpEnrollment, confirmTotpEnrollment, createCodeChallenge, createDiscoveredOidcProvider, createGithubProvider, createOidcProvider, createSecurityAdminApi, decryptSecret, security_default as default, defineSecurityConfig, deriveKey, deriveTotpKey, diagnoseOAuthProvider, disableTotp, discoverAuthorizationServer, encryptSecret, generateApiKey, generateCodeVerifier, generateEphemeralKey, generateState, getAuditStoreFactory, getAuthenticatorFactory, getOAuthProviderFactory, getTokenStoreFactory, getTotpStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, hashApiKey, isBlockedAddress, keycloakAdminTarget, keycloakLoginThemeCheck, listAuditStores, listAuthenticatorFactories, listOAuthProviders, listTokenStores, listTotpStores, listVoterFactories, listWebAuthnStores, listWebhookStores, looksLikeApiKey, matchesTokenStatus, oauthProviderRequiresIssuer, parseApiKey, parseAuditQuery, peekIssuer, readAuditContext, readKeycloakLoginTheme, readLogoutTokenClaims, recordAudit, registerAuditStore, registerAuthenticatorFactory, registerOAuthProvider, registerSecurityAdminApi, registerTokenStore, registerTotpStore, registerVoterFactory, registerWebAuthnStore, registerWebhookStore, requestClientCredentialsToken, resolveJwtRuntime, securityConfigJsonSchema, shouldEnforceCredentialTransport, tokenStatusCriteria, tokenStatusOf, totpCode, totpStatus, verifyTotpLogin };
+export { AccessDeniedError, AccessTokenVerifierService, AnonymousAuthenticator, AnonymousToken, ApiKeyAuthenticator, ApiKeyError, ApiKeyService, AuditService, AuthFlow, AuthenticationError, Authorization, Cors, CredentialTransportPolicy, Csrf, CsrfError, CsrfTokenManager, ExternalJwtAuthenticator, FetchPublicError, Firewall, InsecureTransportError, InvalidTargetError, JwtAuthenticator, JwtKeystore, KeycloakAdminClient, KeycloakAdminError, KeycloakService, LoginThrottler, MemoryAuditStore, MemoryTokenStore, MemoryTotpSecretStore, MemoryWebAuthnCredentialStore, MemoryWebhookStore, OAuth2Client, OAuth2RequestError, OAuth2Service, OAuth2Tokens, RemoteJwtVerifier, RoleHierarchyWalker, RoleVoter, ScopeVoter, SecuredArea, SecurityHeaders, SessionAuthenticator, SsrfError, TOKEN_DEFAULT_ORDER, TOKEN_FACETS, TOKEN_SORTABLE_FIELDS, ThrottledError, TokenService, TotpService, UnverifiableTokenError, UserPasswordAuthenticator, UserToken, VoterVote, WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS, WebAuthnService, WebhookService, amrForFactor, assertPublicUrl, base32Decode, beginTotpEnrollment, confirmTotpEnrollment, createCodeChallenge, createDiscoveredOidcProvider, createGithubProvider, createOidcProvider, createSecurityAdminApi, decryptSecret, security_default as default, defineSecurityConfig, deriveKey, deriveTotpKey, diagnoseOAuthProvider, disableTotp, discoverAuthorizationServer, encryptSecret, fetchPublic, generateApiKey, generateCodeVerifier, generateEphemeralKey, generateState, getAuditStoreFactory, getAuthenticatorFactory, getOAuthProviderFactory, getTokenStoreFactory, getTotpStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, hashApiKey, isBlockedAddress, keycloakAdminTarget, keycloakLoginThemeCheck, listAuditStores, listAuthenticatorFactories, listOAuthProviders, listTokenStores, listTotpStores, listVoterFactories, listWebAuthnStores, listWebhookStores, looksLikeApiKey, matchesTokenStatus, oauthProviderRequiresIssuer, parseApiKey, parseAuditQuery, peekIssuer, readAuditContext, readKeycloakLoginTheme, readLogoutTokenClaims, recordAudit, registerAuditStore, registerAuthenticatorFactory, registerOAuthProvider, registerSecurityAdminApi, registerTokenStore, registerTotpStore, registerVoterFactory, registerWebAuthnStore, registerWebhookStore, requestClientCredentialsToken, resolveJwtRuntime, securityConfigJsonSchema, shouldEnforceCredentialTransport, tokenStatusCriteria, tokenStatusOf, totpCode, totpStatus, verifyTotpLogin };

package/dist/nodefony/command/security-mcp-token.js

@@ -1,5 +1,5 @@
 import { messageNonRestreint, modeNonRestreint, readIfPresentSync, writeSecretSync } from "../src/token/secretFile.js";
-import { ADMIN_SCOPE_READ, ADMIN_SCOPE_WRITE, AGENT_TARGETS, CONSOLE_DATA_RUN_PROFILE, Command, MCP_ENDPOINT_PATH, MCP_TOKEN_ENV, agentRoot, agentsPresents, alreadyHasKey, chargePrompts, poseVariable, requestedAgents } from "nodefony";
+import { ADMIN_SCOPE_READ, ADMIN_SCOPE_WRITE, AGENT_TARGETS, CONSOLE_DATA_RUN_PROFILE, Command, MCP_ENDPOINT_PATH, MCP_TOKEN_ENV, agentRoot, agentsPresents, alreadyHasKey, chargePrompts, poseVariable, requestedAgents, stripTrailingSlashes } from "nodefony";
 import path from "node:path";
 import { existsSync } from "node:fs";
 import { spawnSync } from "node:child_process";
@@ -61,6 +61,30 @@ function tokenTtlSeconds(raw, write) {
 	if (raw !== void 0) return ttlSeconds(raw);
 	return write ? AGENT_TTL_MINUTES * 60 : void 0;
 }
+/** Une URI de ressource sous une forme comparable : sans barre finale. */
+function comparableResource(uri) {
+	try {
+		const url = new URL(uri);
+		return `${url.origin}${stripTrailingSlashes(url.pathname)}`;
+	} catch {
+		return stripTrailingSlashes(uri.trim());
+	}
+}
+/**
+* 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
+*/
+function targetsOtherGate(resource, defaultResource) {
+	if (resource === void 0) return false;
+	return comparableResource(resource) !== comparableResource(defaultResource);
+}
 /** « 8 h », « 1 h 30 », « 15 min » — la durée telle qu'on la dit. */
 function humanDuration(seconds) {
 	const minutes = Math.round(seconds / 60);
@@ -274,11 +298,20 @@ var SecurityMcpToken = class extends Command {
 			process.exitCode = 1;
 			return this;
 		}
-		const resource = opts.resource ?? this.#defaultResource();
+		const defaultResource = this.#defaultResource();
+		const resource = opts.resource ?? defaultResource;
+		const otherGate = targetsOtherGate(opts.resource, defaultResource);
+		if (otherGate && opts.write === true) {
+			this.log(`--write refusé pour cette porte.
+
+  --write pose ${MCP_TOKEN_ENV}, le jeton de la porte de l'outillage\n  (${defaultResource}). Ce jeton-ci a pour audience ${resource} :\n  il y prendrait sa place, cette porte le refuserait, et ses outils\n  réservés disparaîtraient sans un mot.\n\n  → relance sans --write, puis pose le jeton dans l'en-tête de\n    l'agent qui parle à ${resource}.`, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
 		const requestedScopes = (opts.scope ?? "").split(/\s+/u).filter(Boolean);
 		const scopes = requestedScopes.length > 0 ? requestedScopes : [ADMIN_SCOPE_READ];
 		let write = opts.write === true;
-		if (!write && !opts.json && process.stdin.isTTY) {
+		if (!write && !opts.json && !otherGate && process.stdin.isTTY) {
 			await this.loadPrompts();
 			write = await this.prompts.confirm({
 				message: `Poser ${MCP_TOKEN_ENV} dans la configuration des agents présents ?`,
@@ -295,7 +328,7 @@ var SecurityMcpToken = class extends Command {
 		try {
 			issued = await tokens.issueTokens(user, scopes, resource, ttlS);
 		} catch (e) {
-			if (e.oauthError === "invalid_target") {
+			if ((typeof e === "object" && e !== null && "oauthError" in e ? e.oauthError : void 0) === "invalid_target") {
 				const env = this.kernel?.environment ?? "?";
 				const enDev = env === "development";
 				this.log(`impossible d'émettre un jeton pour cette porte ici.
@@ -366,9 +399,14 @@ var SecurityMcpToken = class extends Command {
 			w(`${DIM}  Vibe et Codex prennent le NOM de la variable, pas le secret — déclare la porte une fois :${RESET}\n\n  ${DIM}vibe mcp add nodefony --transport streamable-http \\${RESET}\n  ${DIM}  --url ${resource} --api-key-env ${MCP_TOKEN_ENV}${RESET}\n  ${DIM}codex mcp add nodefony --url ${resource} \\${RESET}\n  ${DIM}  --bearer-token-env-var ${MCP_TOKEN_ENV}${RESET}\n\n`);
 			return this;
 		}
+		if (otherGate) {
+			w(`  ${token}\n\n`);
+			w(`${DIM}  Ce jeton ne vaut que pour ${resource} : pose-le dans l'en-tête\n  de l'agent qui parle à cette porte, par exemple :\n    claude mcp add --transport http <nom> ${resource} \\\n      --header "Authorization: Bearer <ce jeton>"\n  Pas dans ${MCP_TOKEN_ENV} : elle porte le jeton de ${defaultResource}.${RESET}\n\n`);
+			return this;
+		}
 		w(`  export ${MCP_TOKEN_ENV}=${token}\n\n`);
 		w(`${DIM}  --write pose la valeur chez les agents présents · nodefony ai:mcp --auth câble .mcp.json${RESET}\n\n`);
 		return this;
 	}
 };
-export { SecurityMcpToken as default, tokenTtlSeconds, ttlSeconds };
+export { SecurityMcpToken as default, targetsOtherGate, tokenTtlSeconds, ttlSeconds };

package/dist/nodefony/config/config.js

@@ -51,7 +51,7 @@ const areaSchema = z.strictObject({
 	roles: z.array(z.string()).default([]).describe("Rôle(s) exigés PAR DÉFAUT dans la zone, en OU (l'un suffit ; hiérarchie comprise). Vide (défaut) = la zone n'exige qu'une identité, et toute route qu'elle couvre est ouverte à n'importe quel compte authentifié — c'est un défaut OUVERT, qu'une surface d'administration ne doit pas garder. Renseigné, le rôle s'applique à toute route de la zone qui ne décide PAS elle-même de son autorisation : une route gardée (`@IsGranted`, `@RequireScope`) et le pont du plan d'administration (qui résout un rôle par point d'entrée) gardent la main — sans quoi une zone fermée à l'administrateur écraserait un point d'entrée voulu accessible à son propriétaire (`me`, `sessions/mine`). Un refus ici est un 403 (authentifié, pas autorisé), jamais un 401."),
 	entryPoint: z.string().refine((value) => safeRedirectPath(value, "") === value, { message: "entryPoint doit être un chemin de CETTE origine (`/login`), jamais une adresse externe" }).optional().describe("Page de connexion vers laquelle conduire un visiteur anonyme qui NAVIGUE (GET ou HEAD, `Accept: text/html`, `Sec-Fetch-Mode: navigate` s'il est présent) : 302 vers `<entryPoint>?from=<chemin demandé>`, et la page de connexion ramène au chemin demandé. Tout le reste — appel d'API, `fetch`, POST, WebSocket — garde son 401 et son `WWW-Authenticate`. Le refus reste journalisé (`auth.denied`). Absent (défaut) : 401 pour tous."),
 	host: z.string().optional().describe("Domaine/vhost de la zone (ex. admin.exemple.com). Omis = tous domaines."),
-	resource: z.string().optional().describe("URI canonique de la ressource protégée — l'AUDIENCE qu'un jeton doit porter pour être accepté ici (RFC 8707 §2). Obligatoire dès que la zone liste un authenticator de jetons TIERS (`external-jwt`), qui refuse de démarrer sans elle. C'est ce qui empêche un jeton valide, délivré au même porteur pour un AUTRE service, d'être rejoué sur celui-ci. Elle s'ÉCRIT et ne se dérive pas du `Host` : derrière un relais, ce que le processus croit être son adresse n'est pas ce que le client a demandé, et l'audience doit être exactement celle que le serveur d'autorisation a inscrite dans le jeton. Ex. « https://api.example.com/mcp »."),
+	resource: z.string().optional().describe("URI canonique de la ressource protégée — l'AUDIENCE qu'un jeton doit porter pour être accepté ici (RFC 8707 §2). Obligatoire dès que la zone liste un authenticator de jetons TIERS (`external-jwt`), qui refuse de démarrer sans elle. C'est ce qui empêche un jeton valide, délivré au même porteur pour un AUTRE service, d'être rejoué sur celui-ci. Elle s'ÉCRIT et ne se dérive pas du `Host` : derrière un relais, ce que le processus croit être son adresse n'est pas ce que le client a demandé, et l'audience doit être exactement celle que le serveur d'autorisation a inscrite dans le jeton. L'application peut aussi ÉMETTRE des jetons pour cette ressource (`resource` à l'émission, RFC 8707) sans la recopier dans `jwt.audiences` : elle y est ajoutée après les audiences déclarées, qui gardent l'audience par défaut. Un CHEMIN (« /api/partner ») est rendu absolu contre `jwt.issuer`, l'adresse publique de l'application — la forme d'un module qui apporte sa zone sans connaître cette adresse ; le démarrage refuse si l'émetteur n'est pas une URL http(s). Ex. « https://api.example.com/mcp »."),
 	realtime: z.boolean().default(true).describe("Zone valable AUSSI pour les frames WebSocket (api.request + subscribe), pas seulement HTTP. Défaut `true` (Zero Trust : une zone protégée ferme TOUS ses transports — un opt-IN laisserait le WS anonyme par omission = fail-open). `false` = opt-out explicite pour une zone strictement HTTP. Le verrou WS consulte la MÊME zone que HTTP — invariant : `api.request {path}` n'accorde jamais plus que `GET {path}`."),
 	subjectPolicy: z.enum(["require", "ephemeral"]).optional().describe("Surcharge, pour CETTE zone, de `resourceServer.subjectPolicy` — comment le sujet d'un jeton TIERS devient un utilisateur. Omis (défaut) = la politique globale. Sert à faire cohabiter une zone d'appelants machine (« ephemeral » : aucun compte local exigé) et une zone de personnes (« require ») dans la même application ; une politique globale ne sait pas l'exprimer. N'a de sens que si la zone liste `external-jwt` : déclarée ailleurs, le boot la refuse."),
 	ephemeralRoles: z.array(z.string().min(1)).optional().describe("Rôles accordés à l'appelant accepté par CETTE zone en mode « ephemeral ». Exige `subjectPolicy: \"ephemeral\"` écrit dans la zone même : un pouvoir local ne s'hérite pas d'un réglage écrit ailleurs. Une zone qui déclare « ephemeral » sans ses rôles n'en accorde AUCUN — jamais ceux de `resourceServer.ephemeralRoles`, qui protègent une autre surface.")
@@ -191,9 +191,9 @@ const tokenStoreSchema = z.strictObject({
 }).describe("Store de jetons serveur (refresh, PAT, denylist `jti`, seuil de révocation par porteur) + maintenance gc.");
 const passkeysSchema = z.strictObject({
 	enabled: z.boolean().default(true).describe("Active WebAuthn/passkeys (MFA phishing-resistant, NIST AAL2)."),
-	rpId: z.string().optional().describe("Relying Party ID (domaine). Omis = domaine de l'app au boot."),
+	rpId: z.string().optional().describe("Relying Party ID (domaine). Omis = domaine de l'app au boot. Un domaine international s'écrit tel quel : il est converti en punycode (`xn--…`) au démarrage, forme que présente le navigateur."),
 	rpName: z.string().optional().describe("Nom lisible de la Relying Party affiché dans l'invite OS/navigateur. Omis = nom de l'app."),
-	origins: z.array(z.string()).default([]).describe("Origines autorisées aux ceremonies. Vide = origine de l'app."),
+	origins: z.array(z.string()).default([]).describe("Origines autorisées aux cérémonies (`scheme://hôte[:port]`). Vide = origine de l'app. Converties en punycode au démarrage ; une entrée qui n'est pas une origine est écartée et nommée en ERROR."),
 	userVerification: z.enum([
 		"required",
 		"preferred",
@@ -321,7 +321,18 @@ const auditSchema = z.strictObject({
 		reserved: true,
 		description: "INERTE — la diffusion realtime dépend de la présence d'abonnés WS (canal `nodefony:audit`), pas de ce drapeau. Le journal est diffusé dès qu'un client s'abonne."
 	}),
-	retentionDays: z.number().int().default(365)
+	retentionDays: z.number().int().default(365),
+	aggregate: z.strictObject({
+		enabled: z.boolean().default(true).describe("Agrège les REFUS (failure/denied) d'une même source : un flot ne s'écrit pas d'une ligne par requête. Les succès ne sont jamais agrégés."),
+		windowMs: z.number().int().positive().default(6e4).describe("Durée d'une fenêtre, en ms, ouverte au premier refus d'une clé (catégorie, action, issue, motif, ressource, IP)."),
+		burst: z.number().int().nonnegative().default(10).describe("Refus d'une clé écrits TELS QUELS par fenêtre (acteur compris) ; les suivants sont comptés, puis UNE ligne de synthèse (`metadata.aggregated`) clôt la fenêtre."),
+		maxKeys: z.number().int().positive().default(1e4).describe("Clés suivies au plus (mémoire bornée) ; au-delà, les refus se regroupent sous l'IP `*`.")
+	}).default(() => ({
+		enabled: true,
+		windowMs: 6e4,
+		burst: 10,
+		maxKeys: 1e4
+	}))
 }).describe("Journal d'audit sécurité (login, accès refusé, clés, webhooks).");
 const studioSchema = z.strictObject({
 	enabled: z.boolean().default(false).describe("Console admin Studio. OFF par défaut (surtout en prod)."),
@@ -425,7 +436,7 @@ const grantableScopesSchema = z.record(z.string(), z.array(z.string().min(1)).mi
 * cet axe. Étend OU surcharge les défauts système (placée AVANT eux à l'évaluation).
 */
 const realtimeChannelRuleSchema = z.strictObject({
-	pattern: z.string().describe("Préfixe de canal (match `startsWith`) : ex. 'orm:' couvre nodefony:orm:health/nodefony:orm:flow. Placé AVANT les défauts système → permet de surcharger (assouplir/durcir) un namespace réservé."),
+	pattern: z.string().describe("Préfixe de canal (match `startsWith`) : ex. 'nodefony:orm:' couvre nodefony:orm:health/nodefony:orm:flow, 'net:' couvre net:health. Placé AVANT les défauts système → permet de surcharger un namespace réservé (le durcir, le re-cibler sur un autre rôle — jamais l'ouvrir à l'anonyme) ou d'ouvrir à l'application un canal à suffixe :health/:stats."),
 	authenticated: z.boolean().optional().describe("Exige une connexion authentifiée (token non anonyme)."),
 	roles: z.array(z.string()).optional().describe("Un de ces rôles suffit (évalué AVEC la hiérarchie de rôles)."),
 	scopes: z.array(z.string()).optional().describe("Un de ces scopes suffit (axe API : JWT/clé API ; une session BFF n'en porte pas).")
@@ -435,7 +446,7 @@ const securityConfigSchema = z.strictObject({
 	roleHierarchy: z.record(z.string(), z.array(z.string())).default({}).describe("Hiérarchie de rôles (ROLE_ADMIN: ['ROLE_USER'])."),
 	grantableScopes: grantableScopesSchema,
 	areas: z.record(z.string(), areaSchema).default({}).describe("Zones sécurisées (firewall) par nom."),
-	realtimeChannels: z.array(realtimeChannelRuleSchema).default([]).describe("Politiques d'autorisation par préfixe sur le temps réel. Couvre les canaux WS (subscribe/inbound) **ET les actions RPC** : le nom de méthode d'une frame entrante est soumis aux mêmes règles de préfixe — une règle `admin:` garde donc aussi l'action `admin:purge`. Étend/surcharge les défauts système (syslog:/orm:/node:/dashboard:/debugbar:/realtime:/cluster: + :health/:stats = ROLE_NODEFONY_ADMIN, l'échelle PLATEFORME : ces canaux exposent l'état du processus, pas celui d'une application). Ce qui n'est couvert par aucune règle reste libre, sauf gating `@RealtimeChannel` côté controller."),
+	realtimeChannels: z.array(realtimeChannelRuleSchema).default([]).describe("Politiques d'autorisation par préfixe sur le temps réel. Couvre les canaux WS (subscribe/inbound) **ET les actions RPC** : le nom de méthode d'une frame entrante est soumis aux mêmes règles de préfixe — une règle `admin:` garde donc aussi l'action `admin:purge`. Étend/surcharge les défauts système (espace nodefony: + suffixes :health/:stats dans TOUT espace de noms = ROLE_NODEFONY_ADMIN, l'échelle PLATEFORME : ces canaux exposent l'état du processus, pas celui d'une application). Ce qui n'est couvert par aucune règle reste libre, sauf gating `@RealtimeChannel` côté controller."),
 	cors: corsSchema.default(() => corsSchema.parse({})),
 	csrf: csrfSchema.default(() => csrfSchema.parse({})),
 	headers: headersSchema.default(() => headersSchema.parse({})),

package/dist/nodefony/config/defineModuleConfig.js

@@ -1,5 +1,5 @@
 import { securityConfigSchema } from "./config.js";
-import { BootConfigurationError, parseModuleConfig } from "nodefony";
+import { BootConfigurationError, parseModuleConfig, stripTrailingSlashes } from "nodefony";
 import { z } from "zod";
 // nodefony/config/defineModuleConfig.ts
 /**
@@ -12,9 +12,60 @@ import { z } from "zod";
 function defineSecurityConfig(config = {}) {
 	const validated = parseModuleConfig(securityConfigSchema, config, "@nodefony/security");
 	detectConflicts(validated.areas);
+	resolveAreaResources(validated.areas, validated.jwt.issuer);
 	return Object.freeze(validated);
 }
 /**
+* Rend absolue la `resource` d'une zone écrite comme un CHEMIN (`/api/partner`),
+* contre l'émetteur des jetons de l'application (`jwt.issuer`) — son URL
+* publique, celle que voient les clients.
+*
+* Pourquoi : un MODULE qui apporte sa zone à jeton (surcharge
+* `module-security`) ne connaît pas l'adresse publique de l'application — elle
+* vient de l'environnement, que seul `env.ts` lit. Le chemin est ce qu'il
+* connaît ; l'origine est ce que l'application a déjà ÉCRIT une fois. La valeur
+* reste donc écrite, jamais dérivée du `Host`.
+*
+* Concaténation, pas `new URL(chemin, base)` : un émetteur qui porte un chemin
+* (`https://exemple.com/auth`) le garde, comme le fait déjà l'adresse publique
+* des gabarits (`${publicBaseUrl}/api/…`).
+*
+* @param areas - zones validées (mutées sur place, avant le gel)
+* @param issuer - `jwt.issuer` validé
+* @throws BootConfigurationError si un chemin est relatif au protocole (`//…`),
+*   ou si l'émetteur n'est pas une URL http(s) — retirer la zone ouvrirait ses
+*   routes à la zone voisine, donc on refuse de démarrer en nommant le geste.
+*/
+function resolveAreaResources(areas, issuer) {
+	for (const name in areas) {
+		const area = areas[name];
+		const resource = area?.resource;
+		if (area === void 0 || resource === void 0) continue;
+		if (!resource.startsWith("/")) continue;
+		if (resource.startsWith("//")) throw new BootConfigurationError(`[@nodefony/security] areas.${name}.resource « ${resource} » : un chemin commence par UN seul « / » — « // » désigne un autre hôte.`);
+		const base = publicIssuerBase(issuer);
+		if (base === null) throw new BootConfigurationError(`[@nodefony/security] areas.${name}.resource « ${resource} » est un chemin, rendu absolu contre jwt.issuer — qui n'est pas une URL http(s) (« ${issuer ?? "nodefony"} »). Pose jwt.issuer à l'adresse publique de l'application (une application générée la lit dans NF_JWT_ISSUER), ou écris la ressource en entier (https://…).`);
+		area.resource = `${base}${resource}`;
+	}
+}
+/**
+* L'émetteur, sans `/` final, s'il est une URL http(s) — sinon `null`.
+*
+* @param issuer - `jwt.issuer` validé
+* @returns la base contre laquelle résoudre un chemin, ou `null`
+*/
+function publicIssuerBase(issuer) {
+	if (issuer === void 0) return null;
+	let url;
+	try {
+		url = new URL(issuer);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+	return stripTrailingSlashes(issuer);
+}
+/**
 * JSON Schema introspectable de la config sécurité — **Studio génère son
 * formulaire d'édition depuis ça** (labels/types/défauts/descriptions),
 * sans UI hardcodée. Surface du data plane `/nodefony/security/api/config/schema`.

package/dist/nodefony/errors/FetchPublicError.js

@@ -0,0 +1,18 @@
+import { nodefonyError } from "nodefony";
+// nodefony/errors/FetchPublicError.ts
+/**
+* Échec d'une requête sortante vers un site tiers (`fetchPublic`) qui n'est PAS
+* un refus de cible : délai total dépassé (`504`), trop de redirections ou
+* échec réseau (`502`). Une cible interdite lève `SsrfError` (422), pas
+* celle-ci — l'appelant distingue ainsi « tu n'as pas le droit d'y aller » de
+* « le site n'a pas répondu ».
+*/
+var FetchPublicError = class extends nodefonyError {
+	/** Cause de l'échec, stable et exploitable sans lire le message. */
+	reason;
+	constructor(reason, message) {
+		super(message, reason === "timeout" ? 504 : 502);
+		this.reason = reason;
+	}
+};
+export { FetchPublicError };

package/dist/nodefony/errors/SsrfError.js

@@ -9,8 +9,16 @@ import { nodefonyError } from "nodefony";
 * d'un webhook invalide).
 */
 var SsrfError = class extends nodefonyError {
-	constructor(message = "URL sortante interdite (SSRF)") {
+	/**
+	* `forbidden` : la cible est interdite (protocole, identifiants, IP non
+	* publique). `unresolvable` : l'hôte n'a aucune adresse — rien d'interne n'est
+	* visé, le site est simplement injoignable ; un appelant qui rend ces deux cas
+	* à l'utilisateur les distingue par ce champ, jamais par le texte du message.
+	*/
+	reason;
+	constructor(message = "URL sortante interdite (SSRF)", reason = "forbidden") {
 		super(message, 422);
+		this.reason = reason;
 	}
 };
 export { SsrfError, SsrfError as default };

package/dist/nodefony/errors/StaleSessionError.js

@@ -0,0 +1,20 @@
+import { AuthenticationError } from "./AuthenticationError.js";
+// nodefony/errors/StaleSessionError.ts
+/**
+* Session PÉRIMÉE — elle ne désigne plus personne de valide : compte supprimé,
+* verrouillé, désactivé, recréé sous le même identifiant, mot de passe changé
+* depuis son ouverture, ou blob vidé. C'est un ÉTAT à purger, pas une preuve
+* fausse présentée par un tiers : le `SessionAuthenticator` la détruit côté
+* serveur ET côté navigateur (cookie expiré, RFC 6265 §5.3), puis le firewall
+* poursuit comme si aucune session n'avait été présentée — une page ouverte
+* aux anonymes s'affiche, une zone fermée redemande la connexion.
+*
+* Jamais levée pour une PANNE de la source d'identité : une base injoignable
+* ne dit rien de la session, qui doit survivre à l'incident.
+*/
+var StaleSessionError = class extends AuthenticationError {
+	constructor(message = "Invalid session") {
+		super(message);
+	}
+};
+export { StaleSessionError, StaleSessionError as default };

package/dist/nodefony/errors/index.js

@@ -1,10 +1,12 @@
 import { AuthenticationError } from "./AuthenticationError.js";
+import { StaleSessionError } from "./StaleSessionError.js";
 import { AccessDeniedError } from "./AccessDeniedError.js";
 import { ThrottledError } from "./ThrottledError.js";
 import { UnverifiableTokenError } from "./UnverifiableTokenError.js";
 import { InvalidTargetError } from "./InvalidTargetError.js";
 import { CsrfError } from "./CsrfError.js";
 import { SsrfError } from "./SsrfError.js";
+import { FetchPublicError } from "./FetchPublicError.js";
 import { WebAuthnError } from "./WebAuthnError.js";
 import { InsecureTransportError } from "./InsecureTransportError.js";
-export { AccessDeniedError, AuthenticationError, CsrfError, InsecureTransportError, InvalidTargetError, SsrfError, ThrottledError, UnverifiableTokenError, WebAuthnError };
+export { AccessDeniedError, AuthenticationError, CsrfError, FetchPublicError, InsecureTransportError, InvalidTargetError, SsrfError, StaleSessionError, ThrottledError, UnverifiableTokenError, WebAuthnError };

package/dist/nodefony/keycloak/scaffold.js

@@ -25,15 +25,19 @@ const APP_KEYCLOAK_REALM_FILE = "docker/keycloak/import/realm.json";
 const APP_KEYCLOAK_THEMES_DIR = "docker/keycloak/themes";
 const APP_KEYCLOAK_THEME_DIR = `${APP_KEYCLOAK_THEMES_DIR}/${KEYCLOAK_THEME_NAME}`;
 /** Fichier de configuration de sécurité d'une application générée. */
-const APP_SECURITY_CONFIG_FILE = "nodefony/config/security.ts";
 /**
-* Ressource de l'API partenaire d'une application neuve en développement :
-* ce que rend `partnerResource()` du gabarit `complete` sans `NF_JWT_ISSUER`
-* ni `NF_PORT_HTTPS` — le port HTTPS par défaut, comme les URL de retour du
-* realm. Deux paquets, une valeur : le test de contribution compare le
-* gabarit rendu à cette constante.
+* Le fichier où la démo de `create app --demo` (module privé `modules/demo`)
+* déclare sa zone à jeton — la surcharge `module-security` qu'elle apporte.
 */
-const APP_PARTNER_DEV_RESOURCE = "https://localhost:5152/api/partner";
+const DEMO_SECURITY_CONFIG_FILE = "modules/demo/nodefony/config/security.ts";
+/**
+* Ressource de l'API partenaire de la démo en développement : le chemin de sa
+* zone (`/demo/api/partner`) rendu absolu contre l'émetteur de développement
+* — le port HTTPS par défaut, comme les URL de retour du realm. Deux paquets,
+* une valeur : le test de contribution la confronte à une application
+* `--demo` réellement rendue.
+*/
+const APP_PARTNER_DEV_RESOURCE = "https://localhost:5152/demo/api/partner";
 /** Les types de thème que le realm sait déclarer, et la clé qui les porte. */
 const THEME_TYPES = [
 	"login",
@@ -124,6 +128,12 @@ function devMachineSecret(appName) {
 * rôle client `admin` (`roleMapping: { admin: "ROLE_ADMIN" }`), et les
 * audiences des zones `external-jwt` que la configuration rendue déclare.
 *
+* Le client « machine » (`<app>-machine`, `client_credentials`) n'existe que
+* s'il a une audience à recevoir : une application neuve n'ouvre aucune zone à
+* jeton tiers (#746), et un client que rien n'accepte serait un secret de plus
+* à garder pour rien. La démo, qui apporte l'API entre programmes, le fait
+* naître en déclarant sa ressource.
+*
 * @param appName - nom de l'application (= realm = identifiant de client)
 * @param themes - types de thème à déclarer
 * @param ids - `sub` des comptes de démonstration, FIXÉS dans le fichier :
@@ -150,7 +160,7 @@ function appDevRealmInput(appName, themes, ids, audiences = []) {
 			description: "Administrateur de l'application — traduit en ROLE_ADMIN par la table roleMapping du fournisseur keycloak."
 		}],
 		realmRoles: [],
-		machine: {
+		machine: audiences.length === 0 ? null : {
 			clientId: `${appName}-machine`,
 			secret: devMachineSecret(appName),
 			name: `${appName} — appelant machine (compte de service)`,
@@ -191,17 +201,24 @@ function mountsKeycloak(context) {
 	].some((file) => context.read(file)?.includes("./docker/keycloak/") === true);
 }
 /**
-* Les audiences que la configuration RENDUE de l'application déclare. Le
-* gabarit `complete` ouvre la zone `partner` (`jwt` + `external-jwt`) : sans
-* son audience dans le realm, le jeton du client machine y est refusé dès le
-* premier essai, et `security:keycloak:realm --check` trouve le realm né en
-* désaccord avec la configuration.
+* Les audiences que la configuration RENDUE de l'application déclare. Une
+* application neuve n'en déclare aucune ; la démo ouvre la zone
+* `demo-partner` (`jwt` + `external-jwt`) dans son propre module : sans son
+* audience dans le realm, le jeton du client machine y serait refusé dès le
+* premier essai, et `security:keycloak:realm --check` trouverait le realm né
+* en désaccord avec la configuration.
+*
+* Le fichier de zone de la démo doit écrire le CHEMIN de la ressource : un
+* module qui l'aurait changé n'a pas l'audience de cette constante, et
+* mieux vaut ne rien inscrire qu'une audience que la zone refuserait.
 *
 * @param context - contexte de contribution
 * @returns les ressources à inscrire dans les jetons du realm
 */
 function renderedAudiences(context) {
-	return context.read(APP_SECURITY_CONFIG_FILE)?.includes("partnerResource(") === true ? [APP_PARTNER_DEV_RESOURCE] : [];
+	const demo = context.read(DEMO_SECURITY_CONFIG_FILE);
+	const resourcePath = new URL(APP_PARTNER_DEV_RESOURCE).pathname;
+	return demo?.includes(`"${resourcePath}"`) === true ? [APP_PARTNER_DEV_RESOURCE] : [];
 }
 /**
 * Recopie les thèmes livrés dans l'application — `nodefony` et ses thèmes

package/dist/nodefony/service/accessTokenVerifier.js

@@ -67,7 +67,7 @@ var AccessTokenVerifierService = class extends Service {
 		} catch {
 			return;
 		}
-		const runtime = config.jwt.enabled ? resolveJwtRuntime(config.jwt) : null;
+		const runtime = config.jwt.enabled ? resolveJwtRuntime(config.jwt, config.areas) : null;
 		const local = runtime === null ? null : new JwtAuthenticator(this.container, runtime);
 		const { issuers, ...tuning } = config.resourceServer;
 		let remote = null;

package/dist/nodefony/service/auditService.js

@@ -1,5 +1,6 @@
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { getAuditStoreFactory, listAuditStores } from "../src/audit/auditStoreRegistry.js";
+import { AuditRefusalAggregator } from "../src/audit/AuditRefusalAggregator.js";
 import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Service, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 import { randomBytes } from "node:crypto";
 // nodefony/service/auditService.ts
@@ -30,11 +31,21 @@ var AuditService = class extends Service {
 	#idPrefix = "";
 	#seq = 0;
 	#gc = null;
+	/** Agrégation des refus — `null` si désactivée par la config. */
+	#aggregator = null;
+	/** Balayage des fenêtres échues — armé au premier refus suivi, coupé à vide. */
+	#sweep = null;
+	#windowMs = 0;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
-		this.kernel?.once("onBoot", () => this.#build());
-		this.kernel?.once("onTerminate", () => this.#shutdown());
+		this.kernel?.once("onBoot", () => {
+			try {
+				this.#build();
+			} finally {
+				this.kernel?.once("onTerminate", () => this.#shutdown());
+			}
+		});
 	}
 	#build() {
 		let config;
@@ -91,9 +102,17 @@ var AuditService = class extends Service {
 			onError: (e) => this.log(e, "WARNING")
 		});
 		this.#gc.start();
+		const aggregate = config.audit.aggregate;
+		if (aggregate.enabled) {
+			this.#windowMs = aggregate.windowMs;
+			this.#aggregator = new AuditRefusalAggregator(aggregate, (draft) => this.#write(draft, Date.now()));
+		}
 		this.log(`audit service ready — store "${config.audit.store}", rétention ${config.audit.retentionDays}j`, "DEBUG");
 	}
 	#shutdown() {
+		this.#stopSweep();
+		this.#aggregator?.flush();
+		this.#aggregator = null;
 		this.#gc?.stop();
 		this.#gc = null;
 		this.#listeners = null;
@@ -102,10 +121,21 @@ var AuditService = class extends Service {
 	}
 	record(draft) {
 		if (!this.#enabled || this.#store === null) return;
+		const now = Date.now();
+		if (draft.outcome !== "success" && this.#aggregator !== null) {
+			const written = this.#aggregator.admit(draft, now);
+			if (this.#sweep === null) this.#startSweep();
+			if (!written) return;
+		}
+		this.#write(draft, now);
+	}
+	/** Persiste (fire-and-forget) et diffuse un événement horodaté `ts`. */
+	#write(draft, ts) {
+		if (this.#store === null) return;
 		const event = {
 			...draft,
 			id: `${this.#idPrefix}-${(this.#seq++).toString(36)}`,
-			ts: Date.now()
+			ts
 		};
 		this.#store.append(event).catch((error) => this.log(error, "ERROR"));
 		if (this.#listeners !== null) for (const listener of this.#listeners) try {
@@ -114,6 +144,21 @@ var AuditService = class extends Service {
 			this.log(error, "ERROR");
 		}
 	}
+	/** Arme le balayage des fenêtres échues (une fois par fenêtre, `unref`). */
+	#startSweep() {
+		this.#sweep = setInterval(() => {
+			const aggregator = this.#aggregator;
+			if (aggregator === null) return this.#stopSweep();
+			aggregator.sweep(Date.now());
+			if (aggregator.size === 0) this.#stopSweep();
+		}, this.#windowMs);
+		this.#sweep.unref();
+	}
+	#stopSweep() {
+		if (this.#sweep === null) return;
+		clearInterval(this.#sweep);
+		this.#sweep = null;
+	}
 	subscribe(listener) {
 		this.#listeners ??= [];
 		this.#listeners.push(listener);

package/dist/nodefony/service/authFlow.js

@@ -284,8 +284,8 @@ var AuthFlow = class extends Service {
 	* (mêmes contrôles que le `SessionAuthenticator` — source unique).
 	*
 	* @returns la projection publique, ou `null` (pas de session, session
-	*   orpheline, compte verrouillé/désactivé) — le handler répond `200`
-	*   `{ user: null }`.
+	*   orpheline, compte verrouillé/désactivé — la session périmée est alors
+	*   détruite, cookie compris) — le handler répond `200` `{ user: null }`.
 	*/
 	async me(context) {
 		const identifier = context.session?.user;
@@ -295,7 +295,10 @@ var AuthFlow = class extends Service {
 		try {
 			return toSafeUser(await resolveBoundSessionIdentity(this.#resolveUsers(), identifier, context.session?.getMetaBag(ACCOUNT_ID_KEY), context.session?.getMetaBag(CREDENTIALS_VERSION_KEY)));
 		} catch (error) {
-			if (error instanceof AuthenticationError) return null;
+			if (error instanceof AuthenticationError) {
+				await context.session?.destroy(true);
+				return null;
+			}
 			throw error;
 		}
 	}