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

package/dist/nodefony/src/admin/SecurityAdminApi.js

@@ -155,6 +155,9 @@ function toCredentialView(c) {
 *  - `GET /nodefony/security/api/firewall` — introspection du firewall (zones,
 *    authenticators montés, défenses) — état RUNTIME, secrets exclus.
 *  - `GET /nodefony/security/api/roleHierarchy` — hiérarchie de rôles + résolution.
+*  - `GET /nodefony/security/api/csp-reports` — violations CSP reçues (ADR-0024
+*    §C7), dédoublonnées, la plus récente d’abord ; champs écrits par le
+*    navigateur, donc à afficher comme du texte.
 *  - `GET /nodefony/security/api/apikeys` — toutes les clés API (gouvernance),
 *    `GET …/apikeys/status` — backend du token store (« où on écrit »),
 *    `POST …/apikeys/{id}/revoke` — révocation par id (réponse à incident).
@@ -222,6 +225,22 @@ function createSecurityAdminApi(container) {
 				};
 			}
 		},
+		{
+			path: "csp-reports",
+			method: "GET",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Violations de la politique CSP rapportées par les navigateurs (dédoublonnées, URL expurgées, extrait jamais gardé). Champs écrits par le navigateur — à afficher comme du texte.",
+			handler: () => {
+				return container.get("cspReports")?.snapshot() ?? {
+					enabled: false,
+					endpoint: null,
+					capacity: 0,
+					received: 0,
+					rejected: 0,
+					items: []
+				};
+			}
+		},
 		{
 			path: "roleHierarchy",
 			method: "GET",

package/dist/nodefony/src/audit/AuditRefusalAggregator.js

@@ -0,0 +1,139 @@
+// nodefony/src/audit/AuditRefusalAggregator.ts
+/** IP de la clé de repli, quand `maxKeys` est atteint. */
+const OVERFLOW_IP = "*";
+const SEP = "
";
+/**
+* Une clé suivie : le gabarit de la ligne de synthèse et les compteurs de la
+* fenêtre en cours. Champs déclarés au constructeur (forme stable).
+*/
+var RefusalBucket = class {
+	start;
+	count = 0;
+	suppressed = 0;
+	firstSuppressed = 0;
+	lastSuppressed = 0;
+	category;
+	action;
+	outcome;
+	resource;
+	reason;
+	ip;
+	constructor(draft, ip, now) {
+		this.start = now;
+		this.category = draft.category;
+		this.action = draft.action;
+		this.outcome = draft.outcome;
+		this.resource = draft.resource ?? null;
+		this.reason = draft.reason ?? null;
+		this.ip = ip;
+	}
+};
+/**
+* Agrège les REFUS du journal d'audit par source, pour qu'un flot ne se paie pas
+* d'une ligne par requête (OWASP Logging Cheat Sheet : la journalisation ne doit
+* pas épuiser les ressources ni le journal de la base).
+*
+* Clé : catégorie, action, motif, ressource et IP — l'IP résolue par le contexte
+* (`trustProxy`), donc non forgeable par le client. L'acteur n'entre PAS dans la
+* clé : un bourrage d'identifiants change d'acteur à chaque essai, c'est sa
+* source qui le trahit.
+*
+* Par clé et par fenêtre (ouverte au premier refus) : les `burst` premiers refus
+* sont écrits tels quels — l'enquêteur voit les premiers essais, acteur compris ;
+* les suivants sont seulement comptés, et la fenêtre close émet UNE ligne de
+* synthèse (`metadata.aggregated`). Mémoire bornée : au-delà de `maxKeys` clés,
+* les refus se regroupent sous l'IP `*`.
+*
+* Pur : l'horloge est passée à chaque appel, la synthèse part par `emit`. Les
+* succès n'y passent jamais (l'appelant les écarte).
+*/
+var AuditRefusalAggregator = class {
+	#buckets = /* @__PURE__ */ new Map();
+	#options;
+	#emit;
+	/**
+	* @param options - fenêtre, rafale écrite telle quelle, borne de clés.
+	* @param emit - écrit une ligne de synthèse dans le journal.
+	*/
+	constructor(options, emit) {
+		this.#options = options;
+		this.#emit = emit;
+	}
+	/** Nombre de clés suivies (fenêtres ouvertes). */
+	get size() {
+		return this.#buckets.size;
+	}
+	/**
+	* Compte un refus.
+	*
+	* @param draft - l'événement de refus.
+	* @param now - horloge, en ms.
+	* @returns `true` : l'écrire tel quel ; `false` : il est compté dans la synthèse.
+	*/
+	admit(draft, now) {
+		const prefix = draft.category + SEP + draft.action + SEP + draft.outcome + SEP + (draft.reason ?? "") + SEP + (draft.resource ?? "") + SEP;
+		const ip = draft.ip ?? null;
+		let key = prefix + (ip ?? "");
+		let bucket = this.#buckets.get(key);
+		if (bucket === void 0) {
+			let bucketIp = ip;
+			if (this.#buckets.size >= this.#options.maxKeys) {
+				key = prefix + OVERFLOW_IP;
+				bucketIp = OVERFLOW_IP;
+				bucket = this.#buckets.get(key);
+			}
+			if (bucket === void 0) {
+				bucket = new RefusalBucket(draft, bucketIp, now);
+				this.#buckets.set(key, bucket);
+			}
+		}
+		if (now - bucket.start >= this.#options.windowMs) {
+			this.#close(bucket);
+			bucket.start = now;
+			bucket.count = 0;
+			bucket.suppressed = 0;
+		}
+		bucket.count += 1;
+		if (bucket.count <= this.#options.burst) return true;
+		if (bucket.suppressed === 0) bucket.firstSuppressed = now;
+		bucket.suppressed += 1;
+		bucket.lastSuppressed = now;
+		return false;
+	}
+	/**
+	* Ferme les fenêtres échues : émet leur synthèse et libère leurs clés.
+	*
+	* @param now - horloge, en ms.
+	*/
+	sweep(now) {
+		for (const [key, bucket] of this.#buckets) {
+			if (now - bucket.start < this.#options.windowMs) continue;
+			this.#close(bucket);
+			this.#buckets.delete(key);
+		}
+	}
+	/** Émet la synthèse de toutes les fenêtres ouvertes (arrêt) et vide la table. */
+	flush() {
+		for (const bucket of this.#buckets.values()) this.#close(bucket);
+		this.#buckets.clear();
+	}
+	#close(bucket) {
+		if (bucket.suppressed === 0) return;
+		this.#emit({
+			category: bucket.category,
+			action: bucket.action,
+			outcome: bucket.outcome,
+			actor: null,
+			resource: bucket.resource,
+			reason: bucket.reason,
+			ip: bucket.ip,
+			metadata: { aggregated: {
+				count: bucket.suppressed,
+				firstTs: bucket.firstSuppressed,
+				lastTs: bucket.lastSuppressed,
+				windowMs: this.#options.windowMs
+			} }
+		});
+	}
+};
+export { AuditRefusalAggregator };

package/dist/nodefony/src/authenticator/ApiKeyAuthenticator.js

@@ -1,8 +1,8 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { isBoundToAccount } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
-import { bearerToken } from "./bearer.js";
 import { looksLikeApiKey, parseApiKey } from "../apikey/apiKeyFormat.js";
+import { bearerToken } from "./bearer.js";
 // nodefony/src/authenticator/ApiKeyAuthenticator.ts
 const INVALID_TOKEN = "Invalid token";
 /**

package/dist/nodefony/src/authenticator/ExternalSubjectResolver.js

@@ -1,7 +1,7 @@
-import { compileProviderRoleMapping, mapProviderRoles } from "../oauth/providerRoles.js";
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { UnverifiableTokenError } from "../../errors/UnverifiableTokenError.js";
 import { localIdentifierFor } from "./externalSubject.js";
+import { compileProviderRoleMapping, mapProviderRoles } from "../oauth/providerRoles.js";
 import { canonicalIssuer } from "nodefony";
 import { BaseUser } from "@nodefony/user";
 // nodefony/src/authenticator/ExternalSubjectResolver.ts
@@ -11,6 +11,25 @@ import { BaseUser } from "@nodefony/user";
 */
 const INVALID_TOKEN = "Invalid token";
 /**
+* Les utilisateurs FABRIQUÉS en mode `ephemeral` — aucun compte local derrière.
+* Faible : l'entrée meurt avec l'utilisateur, à la fin de sa requête ou de sa
+* socket ; rien n'est à nettoyer.
+*/
+const EPHEMERAL_SUBJECTS = /* @__PURE__ */ new WeakSet();
+/**
+* Cet utilisateur a-t-il été fabriqué pour un appelant machine SANS compte local (mode `ephemeral`) ?
+*
+* L'identité d'admission temps réel en tire `account: false` : rien ne
+* pourrait relire cet appelant par son `id` (`<émetteur>#<sujet>`), et un
+* abonnement durable ne doit pas s'y adosser (ADR-0021 §S10 point 6). Lu sur
+* le FAIT (l'objet vient du résolveur), jamais déduit de la forme de `id`.
+*
+* @param user - utilisateur résolu par le pare-feu.
+*/
+function isEphemeralSubject(user) {
+	return EPHEMERAL_SUBJECTS.has(user);
+}
+/**
 * Les options de rattachement des sujets externes, lues dans la configuration
 * de sécurité — UNE lecture, pour la zone `external-jwt` comme pour le
 * résolveur de compte d'une ressource protégée.
@@ -105,12 +124,17 @@ var ExternalSubjectResolver = class {
 	async resolve(issuer, subject, claims, area) {
 		const mapping = this.#issuers.get(issuer);
 		if (mapping === void 0) throw new UnverifiableTokenError(`émetteur « ${issuer} » vérifié mais absent de la table de rattachement des sujets — configuration incohérente.`);
+		if ((area?.subjectPolicy ?? this.#policy) === "ephemeral") {
+			const identifier = localIdentifierFor(issuer, subject, "prefixed");
+			const ephemeral = new BaseUser({
+				id: identifier,
+				identifier,
+				roles: [...area?.ephemeralRoles ?? this.#ephemeralRoles]
+			});
+			EPHEMERAL_SUBJECTS.add(ephemeral);
+			return ephemeral;
+		}
 		const identifier = localIdentifierFor(issuer, subject, mapping);
-		if ((area?.subjectPolicy ?? this.#policy) === "ephemeral") return new BaseUser({
-			id: identifier,
-			identifier,
-			roles: [...area?.ephemeralRoles ?? this.#ephemeralRoles]
-		});
 		const provider = this.#resolveUserProvider();
 		let user = null;
 		const linked = this.#linkedProviders?.get(issuer);
@@ -177,4 +201,4 @@ function linkProviders(trusted, providers) {
 	for (const issuer of ambiguous) links.delete(issuer);
 	return links.size > 0 ? links : null;
 }
-export { ExternalSubjectResolver, externalSubjectOptions };
+export { ExternalSubjectResolver, externalSubjectOptions, isEphemeralSubject };

package/dist/nodefony/src/authenticator/FirewallRealtimeAuthenticator.js

@@ -1,9 +1,15 @@
-import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { isBoundToAccount } from "../accountBinding.js";
-import { UserRealtimeToken } from "../realtime/UserRealtimeToken.js";
+import { AuthenticationError } from "../../errors/AuthenticationError.js";
+import { LOCAL_ACCOUNT, UserRealtimeToken } from "../realtime/UserRealtimeToken.js";
+import { isEphemeralSubject } from "./ExternalSubjectResolver.js";
+import { tokenStatusOf } from "../token/tokenStatus.js";
 import { Nodefony, RequestContext } from "nodefony";
 import { authenticatedUser } from "@nodefony/user";
 // nodefony/src/authenticator/FirewallRealtimeAuthenticator.ts
+/** Le verdict booléen d'un état : seul `active` fait vivre l'identité. */
+function toValidity(status) {
+	return async (nowMs) => await status(nowMs) === "active";
+}
 /**
 * Authenticator realtime des identités résolues par le **firewall** — équivalent
 * WS de tout ce que le pipeline HTTP sait authentifier.
@@ -90,9 +96,10 @@ var FirewallRealtimeAuthenticator = class {
 		if (user === null) throw new AuthenticationError("Invalid realtime session");
 		const issued = readFirewallToken();
 		const type = issuedType(issued);
-		const revalidate = this.#revalidatorFor(user, issued, type);
+		const status = type === "session" ? null : this.#buildBearerStatus(issued, user.identifier, type);
+		const revalidate = status === null ? buildSessionRevalidator(user.identifier) : toValidity(status);
 		const scopes = issued ? issued.getScopes() : void 0;
-		return new UserRealtimeToken(user, revalidate, type, scopes, this.#accountConfirmationFor(user, type));
+		return new UserRealtimeToken(user, revalidate, type, scopes, this.#accountConfirmationFor(user, type), status, admissionSourceOf(issued, user));
 	}
 	/**
 	* Le revalidateur de l'identité que le firewall a posée sur la requête
@@ -140,46 +147,58 @@ var FirewallRealtimeAuthenticator = class {
 		};
 	}
 	#revalidatorFor(user, issued, type) {
-		return type === "session" ? buildSessionRevalidator(user.identifier) : this.#buildBearerRevalidator(issued, user.identifier, type);
+		return type === "session" ? buildSessionRevalidator(user.identifier) : toValidity(this.#buildBearerStatus(issued, user.identifier, type));
 	}
 	/**
-	* Re-validation d'une identité portée par un **jeton** (JWT, clé API, OAuth) :
-	* rejoue les trois conditions qui tuent un jeton, sans jamais parler de session.
+	* État d'une identité portée par un **jeton** (JWT, clé API, OAuth) : rejoue les
+	* trois conditions qui tuent un jeton, sans jamais parler de session, et en rend
+	* la CAUSE — `expired` ferme la socket en 4006, `revoked` en 4001 (ADR-0021 §S11).
+	*
+	* **Révoqué l'emporte sur expiré** : la liste de refus est interrogée AVANT de
+	* conclure à l'expiration, et l'ordre est celui de `tokenStatusOf`, appelé
+	* plutôt que recopié. Un jeton révoqué puis arrivé à `exp` ferme donc en 4001.
 	*
 	* `exp` est vérifié **sans personne** (la borne voyage dans le jeton) ; le store
 	* n'ajoute que la révocation *avant terme*. C'est pourquoi un store en panne ne
 	* coupe pas les sockets d'agents : ce serait une panne de disponibilité déguisée
 	* en mesure de sécurité, alors que la borne du jeton tient toujours.
 	*/
-	#buildBearerRevalidator(issued, identifier, type) {
-		const claims = issued.getAttribute("claims") ?? EMPTY_CLAIMS;
+	#buildBearerStatus(issued, identifier, type) {
+		const claims = issued?.getAttribute("claims") ?? EMPTY_CLAIMS;
 		const expMs = secondsToMs(claims.exp);
 		const iatMs = secondsToMs(claims.iat);
-		const jti = issued.getAttribute("jti") ?? (typeof claims.jti === "string" ? claims.jti : null);
+		const jti = issued?.getAttribute("jti") ?? (typeof claims.jti === "string" ? claims.jti : null);
 		const resolveStore = this.#resolveStore;
 		if (expMs === null && (resolveStore === null || jti === null && iatMs === null)) {
 			Nodefony.getKernel()?.log(`Realtime ${type} token "${identifier}" carries neither an expiry nor any revocation handle ("jti"/"iat") — connection will be revoked (fail-closed). Ensure the authenticator forwards the token claims.`, "WARNING");
-			return () => Promise.resolve(false);
+			return () => Promise.resolve("revoked");
 		}
-		return async (nowMs = Date.now()) => {
-			if (expMs !== null && nowMs >= expMs) return false;
-			if (!resolveStore) return true;
+		/** `true` révoqué, `false` non, `null` = le store n'a pas pu répondre. */
+		const isRevoked = async () => {
+			if (!resolveStore) return false;
 			let store;
 			try {
 				store = resolveStore();
 			} catch {
-				return expMs !== null;
+				return null;
 			}
-			if (!store) return expMs !== null;
+			if (!store) return null;
 			try {
-				if (jti !== null && await store.isJtiDenied(jti)) return false;
+				if (jti !== null && await store.isJtiDenied(jti)) return true;
 				const invalidBefore = await store.getInvalidBefore(identifier);
-				if (invalidBefore !== null && iatMs !== null && iatMs < invalidBefore) return false;
-				return true;
+				return invalidBefore !== null && iatMs !== null && iatMs < invalidBefore;
 			} catch {
-				return expMs !== null;
+				return null;
 			}
 		};
+		return async (nowMs = Date.now()) => {
+			const revoked = await isRevoked();
+			if (revoked === null && expMs === null) return "revoked";
+			return tokenStatusOf({
+				revokedAt: revoked === true ? nowMs : null,
+				expiresAt: expMs
+			}, nowMs);
+		};
 	}
 };
 const EMPTY_CLAIMS = Object.freeze({});
@@ -200,6 +219,29 @@ function secondsToMs(value) {
 function issuedType(issued) {
 	return typeof issued?.type === "string" && issued.type ? issued.type : "session";
 }
+/**
+* Émetteur et compte local de l'identité, pour l'identité d'admission temps réel (ADR-0021 §S10).
+*
+* L'émetteur est celui que l'authentificateur a VÉRIFIÉ et posé sur le jeton
+* (attribut `issuer` : JWT de l'application, JWT tiers) ; `null` sans jeton
+* porteur (session, clé d'API). Le compte est absent pour le seul appelant
+* machine fabriqué en mode `ephemeral` — constaté sur l'objet, jamais déduit
+* de la forme de son `id`.
+*/
+function admissionSourceOf(issued, user) {
+	const issuer = issued?.getAttribute("issuer");
+	const account = !isEphemeralSubject(user);
+	if (typeof issuer !== "string" || issuer === "") return account ? LOCAL_ACCOUNT : EPHEMERAL_WITHOUT_ISSUER;
+	return {
+		issuer,
+		account
+	};
+}
+/** Filet : un sujet éphémère sans émetteur posé (ne devrait pas exister). */
+const EPHEMERAL_WITHOUT_ISSUER = Object.freeze({
+	issuer: null,
+	account: false
+});
 /** Le jeton posé dans l'ALS par `firewall.handleSecurity`, s'il y en a un. */
 function readFirewallToken() {
 	return RequestContext.get()?.token;

package/dist/nodefony/src/authenticator/JwtAuthenticator.js

@@ -1,12 +1,15 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
-import { loadBoundAccount } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
+import { defaultAudience } from "../token/jwtRuntime.js";
+import { REQUIRED_TIME_CLAIMS, isIssuedInFuture } from "../token/tokenTimeClaims.js";
 import { bearerToken } from "./bearer.js";
 import peekIssuer from "./peekIssuer.js";
+import { loadBoundAccount } from "../accountBinding.js";
 import { canonicalIssuer } from "nodefony";
 // nodefony/src/authenticator/JwtAuthenticator.ts
 const COMPACT_JWS = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/;
 const INVALID_TOKEN = "Invalid token";
+const AUDIENCE = "audience";
 /**
 * Authentification par **JWT Bearer** (RFC 6750) — réservée API service↔service /
 * agents (le web utilise la session BFF). Vérifie un access token EdDSA signé par
@@ -18,7 +21,8 @@ const INVALID_TOKEN = "Invalid token";
 *  - **clé par `kid` depuis le keyset LOCAL** (`createLocalJWKSet`) — jamais
 *    `jku`/`jwk` de l'en-tête (injection de clé / SSRF, §3.5).
 *  - **`aud` (§3.9) + `iss` (§3.8) obligatoires** + `typ:"at+jwt"` (§3.11, sépare
-*    access et refresh) + `exp`/`nbf` (jose).
+*    access et refresh) + `exp`/`nbf` (jose). L'audience est celle de la ZONE
+*    (`resource`, ou l'audience par défaut), jamais toute la liste `jwt.audiences`.
 *  - **révocation** : denylist `jti` + seuil `invalidBefore` par porteur (le JWT
 *    est auto-porté et non révocable sans état serveur).
 *  - **sujet revérifié** (§3.10) : `loadUserByIdentifier(sub)` → compte disparu,
@@ -67,15 +71,31 @@ var JwtAuthenticator = class {
 		const issuer = peekIssuer(token);
 		return issuer === null || issuer === this.#runtime.issuer;
 	}
-	/** Extrait le token brut (non vérifié) → porté par un `UserToken` type `"jwt"`. */
+	/**
+	* Extrait le token brut (non vérifié) → porté par un `UserToken` type `"jwt"`,
+	* avec la ressource de la zone quand elle en déclare une.
+	*
+	* L'audience transite par le token parce que `authenticate()` ne reçoit pas
+	* le contexte (même patron que `ExternalJwtAuthenticator`). Rien n'est posé
+	* pour une zone sans ressource : l'audience par défaut s'y applique.
+	*/
 	createToken(context) {
 		const auth = context.request?.headers.authorization;
-		return Promise.resolve(new UserToken("jwt", bearerToken(auth) ?? ""));
+		const token = new UserToken("jwt", bearerToken(auth) ?? "");
+		const zone = context.security;
+		if (zone && "resource" in zone && typeof zone.resource === "string" && zone.resource.length > 0) token.setAttribute(AUDIENCE, zone.resource);
+		return Promise.resolve(token);
 	}
 	/**
 	* Vérifie la signature + les claims du JWT, applique la révocation et résout le
 	* sujet — ou lève un 401 au message uniforme.
 	*
+	* L'audience exigée est celle de la ZONE, jamais la liste blanche d'émission
+	* entière (RFC 8707, RFC 9068 §4) : la `resource` de la zone si elle en
+	* déclare une, sinon l'audience par défaut — l'application elle-même. Un
+	* jeton émis pour la porte MCP, ou pour la ressource d'une autre zone, figure
+	* dans `jwt.audiences` sans pour autant ouvrir celle-ci.
+	*
 	* @throws AuthenticationError (401) — token absent/invalide/expiré/révoqué, ou
 	*   sujet disparu/banni.
 	* @throws Error (câblage : keystore/store/users absents) — logguée ERROR par le
@@ -84,7 +104,8 @@ var JwtAuthenticator = class {
 	async authenticate(token) {
 		const raw = token.getCredentials();
 		if (typeof raw !== "string" || raw.length === 0) throw new AuthenticationError(INVALID_TOKEN);
-		const { user, payload } = await this.#verify(raw, this.#runtime.audiences);
+		const audience = token.getAttribute(AUDIENCE) ?? defaultAudience(this.#runtime);
+		const { user, payload } = await this.#verify(raw, audience);
 		return this.#promote(token, user, payload);
 	}
 	/**
@@ -143,11 +164,13 @@ var JwtAuthenticator = class {
 				algorithms: ["EdDSA"],
 				issuer: this.#runtime.issuer,
 				audience,
-				typ: "at+jwt"
+				typ: "at+jwt",
+				requiredClaims: [...REQUIRED_TIME_CLAIMS]
 			})).payload;
 		} catch {
 			throw new AuthenticationError(INVALID_TOKEN);
 		}
+		if (isIssuedInFuture(payload, Math.floor(Date.now() / 1e3), 5)) throw new AuthenticationError(INVALID_TOKEN);
 		const sub = payload.sub;
 		const jti = payload.jti;
 		if (typeof sub !== "string" || typeof jti !== "string") throw new AuthenticationError(INVALID_TOKEN);

package/dist/nodefony/src/authenticator/SessionAuthenticator.js

@@ -1,6 +1,7 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
-import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY } from "../accountBinding.js";
+import { StaleSessionError } from "../../errors/StaleSessionError.js";
 import { resolveBoundSessionIdentity } from "../sessionIdentity.js";
+import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
 // nodefony/src/authenticator/SessionAuthenticator.ts
 /**
@@ -72,15 +73,22 @@ var SessionAuthenticator = class {
 	* token. Les contrôles d'état (existe, actif, non verrouillé) vivent dans
 	* {@link resolveSessionIdentity} — partagés avec `AuthFlow.me()`.
 	*
-	* @throws AuthenticationError (401, message uniforme) — session orpheline,
-	*   compte verrouillé ou désactivé.
+	* @throws StaleSessionError (401, message uniforme) — session orpheline,
+	*   compte verrouillé ou désactivé, liaison au compte rompue : un état à
+	*   purger ({@link onFailure}). Une PANNE de la source d'identité remonte
+	*   telle quelle, et ne purge rien.
 	*/
 	async authenticate(token) {
 		const credentials = token.getCredentials();
-		if (!credentials?.identifier) throw new AuthenticationError("Invalid session");
+		if (!credentials?.identifier) throw new StaleSessionError();
 		const provider = this.#provider ??= this.#resolveProvider();
-		const user = await resolveBoundSessionIdentity(provider, credentials.identifier, credentials.accountId, credentials.credentialsVersion);
-		return token.promote(user);
+		try {
+			const user = await resolveBoundSessionIdentity(provider, credentials.identifier, credentials.accountId, credentials.credentialsVersion);
+			return token.promote(user);
+		} catch (error) {
+			if (error instanceof AuthenticationError) throw new StaleSessionError(error.message);
+			throw error;
+		}
 	}
 	/**
 	* Pose l'identifiant sur le contexte : la persistance de session du pipeline
@@ -90,9 +98,14 @@ var SessionAuthenticator = class {
 		context.user = token.getUser().identifier;
 		return Promise.resolve();
 	}
-	/** Slot audit (P6.14). Le 401 est posé par le firewall. */
-	onFailure(_context, _error) {
-		return Promise.resolve();
+	/**
+	* Une session périmée est DÉTRUITE, côté serveur (entrée du stockage) et
+	* côté navigateur (cookie expiré, RFC 6265 §5.3) — sans quoi le navigateur la
+	* renvoie à chaque requête et chaque page lui répond 401, sans issue pour
+	* l'utilisateur. Le firewall poursuit ensuite la chaîne de la zone.
+	*/
+	async onFailure(context, error) {
+		if (error instanceof StaleSessionError) await context.session?.destroy(true);
 	}
 };
 export { SessionAuthenticator, SessionAuthenticator as default };

package/dist/nodefony/src/authenticator/authenticatorRegistry.js

@@ -3,8 +3,8 @@ import { SessionAuthenticator } from "./SessionAuthenticator.js";
 import { UserPasswordAuthenticator } from "./UserPasswordAuthenticator.js";
 import { JwtAuthenticator } from "./JwtAuthenticator.js";
 import { ApiKeyAuthenticator } from "./ApiKeyAuthenticator.js";
-import { externalSubjectOptions } from "./ExternalSubjectResolver.js";
 import { ExternalJwtAuthenticator } from "./ExternalJwtAuthenticator.js";
+import { externalSubjectOptions } from "./ExternalSubjectResolver.js";
 import { resolveJwtRuntime } from "../token/jwtRuntime.js";
 // nodefony/src/authenticator/authenticatorRegistry.ts
 const factories = /* @__PURE__ */ new Map();
@@ -42,7 +42,7 @@ registerAuthenticatorFactory("session", ({ container }) => {
 	});
 });
 registerAuthenticatorFactory("jwt", ({ container, config }) => {
-	return new JwtAuthenticator(container, resolveJwtRuntime(config.jwt));
+	return new JwtAuthenticator(container, resolveJwtRuntime(config.jwt, config.areas));
 });
 registerAuthenticatorFactory("external-jwt", ({ container, config }) => {
 	return new ExternalJwtAuthenticator(container, externalSubjectOptions(config));