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

package/dist/nodefony/service/tokenService.js

@@ -1,16 +1,18 @@
 import { JwtKeystore } from "../src/token/JwtKeystore.js";
+import { ScopeGrantPolicy, refusedScopes } from "../src/token/scopeGrants.js";
 import { InsecureTransportError } from "../errors/InsecureTransportError.js";
 import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { ThrottledError } from "../errors/ThrottledError.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY, credentialsVersionOf, isBoundToAccount } from "../src/accountBinding.js";
 import { defaultAudience, resolveJwtRuntime } from "../src/token/jwtRuntime.js";
 import { recordAudit } from "../src/audit/recordAudit.js";
 import { readAuditContext } from "../src/audit/readAuditContext.js";
 import { InvalidTargetError } from "../errors/InvalidTargetError.js";
 import { getTokenStoreFactory, listTokenStores } from "../src/token/tokenStoreRegistry.js";
-import { AUTO_STORE, BootConfigurationError, EMPTY_INFRA, GcScheduler, Service, canonicalIssuer, durableStoreRemedy, readStoreConnector, readStoreLocation, refusedAdminScopes, resolveAutoStore, runNeedsExternalServices } from "nodefony";
+import { AUTO_STORE, BootConfigurationError, EMPTY_INFRA, GcScheduler, Service, canonicalIssuer, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-//#region nodefony/service/tokenService.ts
+// nodefony/service/tokenService.ts
 const serviceName = "tokenService";
 /**
 * Orchestrateur des jetons longue durée (P6 J4) — émission/refresh des JWT +
@@ -39,6 +41,8 @@ var TokenService = class extends Service {
 	#throttler = null;
 	#throttlerResolved = false;
 	#transport = null;
+	/** `grantableScopes` compilé au boot ; `null` tant que la config n'est pas lue. */
+	#scopeGrants = null;
 	#gc = null;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
@@ -87,6 +91,7 @@ var TokenService = class extends Service {
 		}
 		const jwtEnabled = config.jwt.enabled;
 		const apiKeysEnabled = config.apiKeys.enabled;
+		this.#scopeGrants = new ScopeGrantPolicy(config.grantableScopes);
 		if (!jwtEnabled && !apiKeysEnabled) {
 			this.log("token service idle — JWT et clés API désactivés", "DEBUG");
 			return;
@@ -94,7 +99,7 @@ var TokenService = class extends Service {
 		let storeName = config.tokenStore.store;
 		let reason = `store explicitement configuré ("${storeName}")`;
 		if (storeName === AUTO_STORE) {
-			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTokenStores(), "memory", runNeedsExternalServices(this.kernel));
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTokenStores(), "memory", storeConnectivity(this.kernel));
 			storeName = auto.store;
 			reason = auto.reason;
 			this.log(`tokenStore "auto" → "${storeName}" (${auto.reason})`, "INFO");
@@ -106,7 +111,7 @@ var TokenService = class extends Service {
 			this.log(`${msg} — JWT/clés API indisponibles`, "CRITIC");
 			return;
 		}
-		if (storeName === "memory" && this.kernel?.environment === "production") this.log("tokenStore \"memory\" en PRODUCTION — denylist JWT, refresh tokens et clés API per-pod et volatils : révocation non partagée entre pods, tout est perdu au redémarrage. " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
+		if (storeName === "memory" && this.kernel?.environment === "production") this.log("tokenStore \"memory\" en PRODUCTION — denylist JWT, refresh tokens et clés API per-pod et volatils : révocation non partagée entre pods, tout est perdu au redémarrage. " + durableStoreRemedy(storeConnectivity(this.kernel)), "WARNING");
 		this.#store = factory({
 			container: this.container,
 			config
@@ -340,26 +345,30 @@ var TokenService = class extends Service {
 	* d'informer le client — c'est ce que fait le champ `scope` de la réponse,
 	* déjà rempli avec les scopes réellement accordés.
 	*
-	* Les scopes d'une APPLICATION ne sont pas jugés ici : c'est à elle de dire
-	* qui peut obtenir `shop:read`.
+	* Les scopes d'une APPLICATION se bornent par `grantableScopes` : c'est elle
+	* qui dit qui peut obtenir `shop:write`. Un scope qu'elle ne déclare pas
+	* reste accordé à tout porteur. Les deux familles passent par le MÊME juge
+	* ({@link refusedScopes}), que les clés API appellent aussi.
 	*
 	* @param user - le porteur, déjà authentifié.
 	* @param requested - ce qu'il demande.
 	* @returns ce qui lui est accordé.
 	*/
 	#grantableScopes(user, requested) {
+		if (requested.length === 0) return requested;
 		const roles = Array.isArray(user.roles) ? user.roles.filter((r) => typeof r === "string") : [];
-		const refuses = refusedAdminScopes(requested, roles);
-		if (refuses.length === 0) return requested;
-		this.log(`grant : scope(s) « ${refuses.join(" ")} » NON accordé(s) à « ${user.identifier} » — réservé(s) au rôle d'administration. Le jeton est émis avec les scopes restants (RFC 6749 §3.3).`, "WARNING");
-		return requested.filter((scope) => !refuses.includes(scope));
+		const refusals = refusedScopes(requested, roles, this.#scopeGrants ?? new ScopeGrantPolicy(), this.container?.get("roleHierarchy") ?? null);
+		if (refusals.length === 0) return requested;
+		const named = refusals.map((r) => `${r.scope} (${r.rule === "admin" ? "réservé au rôle d'administration" : "réservé par grantableScopes"})`).join(", ");
+		this.log(`grant : scope(s) NON accordé(s) à « ${user.identifier} » — ${named}. Le jeton est émis avec les scopes restants (RFC 6749 §3.3).`, "WARNING");
+		return requested.filter((scope) => !refusals.some((r) => r.scope === scope));
 	}
 	async issueTokens(user, requestedScopes, resource, accessTtlS) {
 		const { store, runtime } = this.#ensureReady();
 		const scopes = this.#grantableScopes(user, requestedScopes && requestedScopes.length > 0 ? [...requestedScopes] : []);
 		const audience = this.#resolveAudience(runtime, resource);
-		const access = await this.#signAccess(user.identifier, scopes, audience, accessTtlS);
-		const { record, raw } = this.#buildRefresh(user.identifier, scopes, this.#randomId(), audience);
+		const access = await this.#signAccess(user, scopes, audience, accessTtlS);
+		const { record, raw } = this.#buildRefresh(user, scopes, this.#randomId(), audience);
 		await store.put(record);
 		recordAudit(this.container, {
 			category: "token",
@@ -418,10 +427,11 @@ var TokenService = class extends Service {
 		const now = Date.now();
 		if (record.expiresAt !== null && record.expiresAt <= now) throw new AuthenticationError("Invalid token");
 		const user = await this.#resolveUserForRefresh(record.subjectId);
-		const scopes = [...record.scopes];
+		if (!isBoundToAccount(user, record.metadata["accountId"], record.metadata["credentialsVersion"])) throw new AuthenticationError("Invalid token");
+		const scopes = this.#grantableScopes(user, [...record.scopes]);
 		const audience = record.audience?.at(0) ?? defaultAudience(runtime);
 		if (resource !== void 0 && resource !== null && resource !== audience) throw new InvalidTargetError("The requested resource does not match the one granted to this token (RFC 8707 §2.2).", typeof resource === "string" ? resource : void 0);
-		const access = await this.#signAccess(user.identifier, scopes, audience);
+		const access = await this.#signAccess(user, scopes, audience);
 		if (!runtime.rotateRefresh) return {
 			access_token: access,
 			refresh_token: rawRefresh,
@@ -430,7 +440,7 @@ var TokenService = class extends Service {
 			scope: scopes.join(" ")
 		};
 		const family = record.family ?? this.#randomId();
-		const next = this.#buildRefresh(user.identifier, scopes, family, audience);
+		const next = this.#buildRefresh(user, scopes, family, audience);
 		await store.put(next.record);
 		record.replacedBy = next.record.id;
 		record.revokedAt = now;
@@ -444,15 +454,19 @@ var TokenService = class extends Service {
 			scope: scopes.join(" ")
 		};
 	}
-	async #signAccess(subject, scopes, audience, ttlS) {
+	async #signAccess(user, scopes, audience, ttlS) {
 		const { keystore, runtime: rt } = this.#ensureReady();
 		const jose = await this.#ensureJose();
 		const { key, kid } = await keystore.getSigningKey();
-		return new jose.SignJWT({ scope: scopes.join(" ") }).setProtectedHeader({
+		return new jose.SignJWT({
+			scope: scopes.join(" "),
+			["uid"]: user.id,
+			["cv"]: credentialsVersionOf(user)
+		}).setProtectedHeader({
 			alg: "EdDSA",
 			kid,
 			typ: "at+jwt"
-		}).setIssuedAt().setIssuer(rt.issuer).setSubject(subject).setAudience(audience).setExpirationTime(`${ttlS ?? rt.accessTtlS}s`).setJti(randomUUID()).sign(key);
+		}).setIssuedAt().setIssuer(rt.issuer).setSubject(user.identifier).setAudience(audience).setExpirationTime(`${ttlS ?? rt.accessTtlS}s`).setJti(randomUUID()).sign(key);
 	}
 	/**
 	* Construit (sans persister) un record refresh + son secret opaque en clair.
@@ -462,7 +476,7 @@ var TokenService = class extends Service {
 	*          silencieusement l'accès à l'audience par défaut — un downscoping
 	*          qui s'annule au bout de quelques minutes n'en est pas un.
 	*/
-	#buildRefresh(subject, scopes, family, audience) {
+	#buildRefresh(user, scopes, family, audience) {
 		const raw = `nfr_${randomBytes(32).toString("base64url")}`;
 		const now = Date.now();
 		return {
@@ -471,7 +485,7 @@ var TokenService = class extends Service {
 				kind: "refresh",
 				name: "refresh token",
 				prefix: null,
-				subjectId: subject,
+				subjectId: user.identifier,
 				subjectType: "user",
 				tenantId: null,
 				scopes: [...scopes],
@@ -490,7 +504,10 @@ var TokenService = class extends Service {
 				lastUsedUserAgent: null,
 				revokedAt: null,
 				revokedReason: null,
-				metadata: {}
+				metadata: {
+					[ACCOUNT_ID_KEY]: user.id,
+					[CREDENTIALS_VERSION_KEY]: credentialsVersionOf(user)
+				}
 			},
 			raw
 		};
@@ -543,5 +560,4 @@ var TokenService = class extends Service {
 		return this.#throttler;
 	}
 };
-//#endregion
 export { TokenService, TokenService as default };

package/dist/nodefony/service/totp.js

@@ -5,8 +5,8 @@ import { getTotpStoreFactory, listTotpStores } from "../src/totp/totpSecretStore
 import { generateEphemeralKey } from "../src/crypto/secretCipher.js";
 import { deriveTotpKey } from "../src/totp/totpCipher.js";
 import { beginTotpEnrollment, confirmTotpEnrollment, disableTotp, totpStatus, verifyTotpLogin } from "../src/totp/totpOperations.js";
-import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, runNeedsExternalServices } from "nodefony";
-//#region nodefony/service/totp.ts
+import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
+// nodefony/service/totp.ts
 const serviceName = "totp";
 function isFlushable(s) {
 	return s !== null && typeof s.flushNow === "function";
@@ -93,7 +93,7 @@ var TotpService = class extends Service {
 		let driver = config.totp.store;
 		let reason = `store explicitement configuré ("${driver}")`;
 		if (driver === AUTO_STORE) {
-			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTotpStores(), "memory", runNeedsExternalServices(this.kernel));
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listTotpStores(), "memory", storeConnectivity(this.kernel));
 			driver = auto.store;
 			reason = auto.reason;
 			this.log(`totp.store "auto" → "${driver}" (${auto.reason})`, "INFO");
@@ -105,7 +105,7 @@ var TotpService = class extends Service {
 			this.log(`${msg} — 2FA indisponible`, "CRITIC");
 			return null;
 		}
-		if (driver === "memory" && this.kernel?.environment === "production") this.log("totp.store \"memory\" en PRODUCTION — secrets 2FA volatils : perdus au redémarrage (utilisateurs verrouillés). " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
+		if (driver === "memory" && this.kernel?.environment === "production") this.log("totp.store \"memory\" en PRODUCTION — secrets 2FA volatils : perdus au redémarrage (utilisateurs verrouillés). " + durableStoreRemedy(storeConnectivity(this.kernel)), "WARNING");
 		const store = factory({
 			container: this.container,
 			config
@@ -252,5 +252,4 @@ var TotpService = class extends Service {
 		return this.#deps;
 	}
 };
-//#endregion
 export { TotpService, TotpService as default };

package/dist/nodefony/service/webAuthn.js

@@ -2,10 +2,10 @@ import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { WebAuthnError } from "../errors/WebAuthnError.js";
 import { getWebAuthnStoreFactory, listWebAuthnStores } from "../src/webauthn/webAuthnCredentialStoreRegistry.js";
-import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, runNeedsExternalServices } from "nodefony";
+import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 import { createHash } from "node:crypto";
 import { Buffer } from "node:buffer";
-//#region nodefony/service/webAuthn.ts
+// nodefony/service/webAuthn.ts
 const serviceName = "webauthn";
 function isFlushable(s) {
 	return s !== null && typeof s.flushNow === "function";
@@ -92,7 +92,7 @@ var WebAuthnService = class extends Service {
 			let driver = config.passkeys.store;
 			reason = `store explicitement configuré ("${driver}")`;
 			if (driver === AUTO_STORE) {
-				const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebAuthnStores(), "memory", runNeedsExternalServices(this.kernel));
+				const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebAuthnStores(), "memory", storeConnectivity(this.kernel));
 				driver = auto.store;
 				reason = auto.reason;
 				this.log(`passkeys.store "auto" → "${driver}" (${auto.reason})`, "INFO");
@@ -104,7 +104,7 @@ var WebAuthnService = class extends Service {
 				this.log(`${msg} — passkeys indisponibles`, "CRITIC");
 				return;
 			}
-			if (driver === "memory" && this.kernel?.environment === "production") this.log("passkeys.store \"memory\" en PRODUCTION — credentials WebAuthn volatils : tous les passkeys enregistrés sont perdus au redémarrage (utilisateurs verrouillés hors de leur compte). " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
+			if (driver === "memory" && this.kernel?.environment === "production") this.log("passkeys.store \"memory\" en PRODUCTION — credentials WebAuthn volatils : tous les passkeys enregistrés sont perdus au redémarrage (utilisateurs verrouillés hors de leur compte). " + durableStoreRemedy(storeConnectivity(this.kernel)), "WARNING");
 			this.#store = factory({
 				container: this.container,
 				config
@@ -365,5 +365,4 @@ var WebAuthnService = class extends Service {
 		};
 	}
 };
-//#endregion
 export { WebAuthnService, WebAuthnService as default, userHandleBytes };

package/dist/nodefony/service/webhooks.js

@@ -6,11 +6,11 @@ import { deriveWebhookKey } from "../src/webhook/webhookCipher.js";
 import { assertPublicUrl } from "../src/net/ssrfGuard.js";
 import { WebhookDispatcher } from "../src/webhook/WebhookDispatcher.js";
 import { deliverWebhook } from "../src/webhook/webhookDelivery.js";
-import { AUTO_STORE, EMPTY_INFRA, Service, countFacets, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, runNeedsExternalServices } from "nodefony";
+import { AUTO_STORE, EMPTY_INFRA, Service, countFacets, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 import { randomBytes } from "node:crypto";
 import { Buffer } from "node:buffer";
 import { schemaMismatchOf } from "@nodefony/http";
-//#region nodefony/service/webhooks.ts
+// nodefony/service/webhooks.ts
 const serviceName = "webhooks";
 /** Historique de livraisons gardé PAR endpoint (ring borné, RAM, par pod). */
 const MAX_DELIVERIES_PER_ENDPOINT = 20;
@@ -155,7 +155,7 @@ var WebhookService = class extends Service {
 		let driver = config.webhooks.store;
 		let reason = `store explicitement configuré ("${driver}")`;
 		if (driver === AUTO_STORE) {
-			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebhookStores(), "memory", runNeedsExternalServices(this.kernel));
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listWebhookStores(), "memory", storeConnectivity(this.kernel));
 			driver = auto.store;
 			reason = auto.reason;
 			this.log(`webhooks.store "auto" → "${driver}" (${auto.reason})`, "INFO");
@@ -167,7 +167,7 @@ var WebhookService = class extends Service {
 			this.log(`${msg} — webhooks indisponibles`, "CRITIC");
 			return null;
 		}
-		if (driver === "memory" && this.kernel?.environment === "production") this.log("webhooks.store \"memory\" en PRODUCTION — abonnements volatils et per-pod : perdus au redémarrage, non partagés entre pods. " + durableStoreRemedy(runNeedsExternalServices(this.kernel)), "WARNING");
+		if (driver === "memory" && this.kernel?.environment === "production") this.log("webhooks.store \"memory\" en PRODUCTION — abonnements volatils et per-pod : perdus au redémarrage, non partagés entre pods. " + durableStoreRemedy(storeConnectivity(this.kernel)), "WARNING");
 		const store = factory({
 			container: this.container,
 			config
@@ -546,5 +546,4 @@ var WebhookService = class extends Service {
 		return addresses;
 	}
 };
-//#endregion
 export { WebhookService, WebhookService as default };

package/dist/nodefony/src/RoleHierarchyWalker.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/RoleHierarchyWalker.ts
+// nodefony/src/RoleHierarchyWalker.ts
 /**
 * Résout la hiérarchie de rôles — `ROLE_ADMIN` hérite `ROLE_USER`, etc.
 *
@@ -73,5 +73,4 @@ var RoleHierarchyWalker = class {
 		for (const node of Object.keys(hierarchy)) if ((color.get(node) ?? WHITE) === WHITE) visit(node);
 	}
 };
-//#endregion
 export { RoleHierarchyWalker, RoleHierarchyWalker as default };

package/dist/nodefony/src/SecuredArea.js

@@ -1,5 +1,5 @@
 import { stripTrailingSlashes } from "nodefony";
-//#region nodefony/src/SecuredArea.ts
+// nodefony/src/SecuredArea.ts
 /**
 * Zone sécurisée concrète — pattern d'URL compilé + métadonnées d'authentification.
 *
@@ -65,5 +65,4 @@ var SecuredArea = class {
 		return this.matchPath(pathname, context.domain);
 	}
 };
-//#endregion
 export { SecuredArea, SecuredArea as default };

package/dist/nodefony/src/accountBinding.js

@@ -0,0 +1,96 @@
+// nodefony/src/accountBinding.ts
+/**
+* Claim d'un jeton d'accès émis par l'application qui porte l'identifiant
+* IMMUABLE du compte (`IUser.id`) — `sub` porte l'identifiant fonctionnel.
+*/
+const ACCOUNT_ID_CLAIM = "uid";
+/**
+* Clé, dans `metadata` d'un enregistrement de jeton (refresh, clé d'API) comme
+* dans le `metaBag` d'une session, qui porte l'identifiant immuable du compte.
+*/
+const ACCOUNT_ID_KEY = "accountId";
+/**
+* Claim d'un jeton d'accès émis par l'application qui porte la version des
+* identifiants du compte à l'émission (`IUser.credentialsVersion`).
+*/
+const CREDENTIALS_VERSION_CLAIM = "cv";
+/**
+* Clé, dans `metadata` d'un enregistrement de jeton comme dans le `metaBag`
+* d'une session, qui porte la version des identifiants lue à l'émission.
+*/
+const CREDENTIALS_VERSION_KEY = "credentialsVersion";
+/**
+* La version des identifiants à inscrire dans un artefact qu'on émet pour ce
+* compte — 0 quand le compte n'en porte pas encore.
+*
+* @param user - compte pour lequel l'artefact est émis.
+* @returns la version courante, jamais `null`.
+*/
+function credentialsVersionOf(user) {
+	return user.credentialsVersion ?? 0;
+}
+/**
+* Dit si un artefact d'accès (jeton, session, clé) appartient bien au compte
+* qu'on vient de recharger par son identifiant fonctionnel, ET s'il a été émis
+* depuis le dernier changement de mot de passe.
+*
+* Les artefacts sont rangés sous l'`identifier`, qu'un compte RECRÉÉ peut
+* reprendre : supprimé hors du framework (`DELETE` SQL, restauration, import)
+* puis revenu sous le même nom, l'identité se rechargerait et l'artefact de
+* l'ancien titulaire ouvrirait le compte du nouveau. L'identifiant immuable
+* lève l'ambiguïté sans dépendre d'aucun événement ni d'aucun stockage : deux
+* comptes successifs portent deux `id` différents. SEULE règle de
+* comparaison — chaque authentificateur l'appelle, aucun ne la recopie.
+*
+* Un artefact SANS liaison est refusé : il a été émis avant que la règle
+* existe, et rien ne dit à qui il appartient.
+*
+* La version des identifiants fait de la coupure au changement de mot de passe
+* un ÉTAT du compte, et non une suppression : si la cascade de révocation
+* échoue, ou si une requête en vol sur un autre processus réécrit la session
+* qu'on vient d'effacer, l'artefact porte toujours l'ancienne version, et il
+* tombe ici. Un artefact émis avant cette règle n'en porte pas : il vaut 0,
+* comme un compte qui n'a jamais changé de mot de passe — le déploiement ne
+* déconnecte personne. Une valeur d'un autre type est refusée.
+*
+* ⚠️ Chemin chaud — appelée sur CHAQUE requête authentifiée : deux comparaisons
+* de chaîne et d'entier, aucune allocation.
+*
+* @param user - compte rechargé par l'identifiant que porte l'artefact.
+* @param boundAccountId - identifiant immuable inscrit dans l'artefact.
+* @param boundCredentialsVersion - version des identifiants inscrite dans
+*   l'artefact ({@link CREDENTIALS_VERSION_KEY}), `undefined` si absente.
+*   Obligatoire dans la signature pour qu'aucune porte ne l'oublie.
+* @returns `true` si l'artefact a été émis pour CE compte, à sa version courante.
+*/
+function isBoundToAccount(user, boundAccountId, boundCredentialsVersion) {
+	return typeof boundAccountId === "string" && boundAccountId.length > 0 && boundAccountId === user.id && (boundCredentialsVersion ?? 0) === (user.credentialsVersion ?? 0);
+}
+/**
+* Recharge le compte qu'un jeton d'accès de CETTE application désigne, ou
+* `null` : sujet inconnu, compte inactif ou verrouillé, jeton émis pour un
+* autre compte du même nom ou avant un changement de mot de passe.
+*
+* SEULE implémentation de la règle « ce jeton ouvre-t-il encore ce compte ? »
+* pour un jeton maison : la zone `jwt` (`JwtAuthenticator`) et le résolveur de
+* compte d'une ressource protégée l'appellent, aucun ne la recopie. Un refus
+* est `null`, jamais une exception : chaque appelant le traduit dans son
+* propre contrat (401 uniforme, outil en `isError`).
+*
+* @param provider - annuaire des comptes de l'application.
+* @param identifier - identifiant fonctionnel porté par le jeton (`sub`).
+* @param boundAccountId - identifiant immuable inscrit dans le jeton ({@link ACCOUNT_ID_CLAIM}).
+* @param boundCredentialsVersion - version des identifiants inscrite ({@link CREDENTIALS_VERSION_CLAIM}).
+* @returns le compte, ou `null` s'il n'est pas (ou plus) celui du jeton.
+*/
+async function loadBoundAccount(provider, identifier, boundAccountId, boundCredentialsVersion) {
+	let user;
+	try {
+		user = await provider.loadUserByIdentifier(identifier);
+	} catch {
+		return null;
+	}
+	if (!user.isActive() || user.isLocked()) return null;
+	return isBoundToAccount(user, boundAccountId, boundCredentialsVersion) ? user : null;
+}
+export { ACCOUNT_ID_CLAIM, ACCOUNT_ID_KEY, CREDENTIALS_VERSION_CLAIM, CREDENTIALS_VERSION_KEY, credentialsVersionOf, isBoundToAccount, loadBoundAccount };

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

@@ -3,7 +3,7 @@ import { AUDIT_FILTERS } from "../audit/auditFilters.js";
 import { adminActor, auditAdmin } from "./adminAudit.js";
 import { webhookAdminEndpoints } from "./WebhookAdminApi.js";
 import { parseFilters, parsePageQuery } from "nodefony";
-//#region nodefony/src/admin/SecurityAdminApi.ts
+// nodefony/src/admin/SecurityAdminApi.ts
 /**
 * Déduit le **driver** logique d'un store à partir de son nom de classe — le
 * `tokenService` connaît le driver config (`tokenStore.store`) mais ne l'expose
@@ -522,5 +522,4 @@ function registerSecurityAdminApi(registry, container) {
 	if (registry.has("security")) return;
 	registry.register(createSecurityAdminApi(container));
 }
-//#endregion
 export { createSecurityAdminApi, parseAuditQuery, parseTokenListQuery, registerSecurityAdminApi };

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

@@ -1,7 +1,7 @@
 import { WEBHOOK_FACETS, WEBHOOK_FILTERS, WEBHOOK_STATS_FILTERS } from "../webhook/webhookFilters.js";
 import { adminActor, auditAdmin } from "./adminAudit.js";
-import { parseFilters, parsePageQuery } from "nodefony";
-//#region nodefony/src/admin/WebhookAdminApi.ts
+import { isPlainObject, parseFilters, parsePageQuery } from "nodefony";
+// nodefony/src/admin/WebhookAdminApi.ts
 /**
 * Déduit le driver logique du store webhook depuis son nom de classe (miroir de
 * `tokenStoreDriver`). Fermé sur les implémentations connues ; `null` pour un
@@ -30,6 +30,21 @@ function bodyStringArray(v) {
 	if (!Array.isArray(v) || v.length === 0) return void 0;
 	return v.every((x) => typeof x === "string" && x.length > 0) ? v : void 0;
 }
+/**
+* Le corps d'une requête d'écriture : un objet JSON, ou rien (lu comme `{}`).
+* Un tableau ou un scalaire rend `null` — l'appelant répond 400 au lieu de
+* laisser un `in` lever sur une chaîne.
+*/
+function bodyObject(request) {
+	const body = request.body;
+	if (body === void 0 || body === null) return {};
+	return isPlainObject(body) ? body : null;
+}
+/** Réponse au corps qui n'est pas un objet JSON. */
+const BODY_NOT_OBJECT = {
+	status: 400,
+	body: { error: "JSON object body required" }
+};
 /** Page par défaut du listing d'endpoints (registre de config, volume modeste). */
 const ENDPOINTS_DEFAULT_LIMIT = 50;
 /** Plafond dur : un client ne peut pas demander « tout » via `?limit=`. */
@@ -75,8 +90,8 @@ function parseWebhookListQuery(query, sortable) {
 * fail-closed, et logge).
 */
 function mapWebhookError(e) {
-	if (e.code === 422) {
-		const message = e.message;
+	if (typeof e === "object" && e !== null && "code" in e && e.code === 422) {
+		const message = "message" in e ? e.message : void 0;
 		return {
 			status: 422,
 			body: { error: typeof message === "string" ? message : "invalid url" }
@@ -170,7 +185,8 @@ function webhookAdminEndpoints(container) {
 			handler: async (request) => {
 				const s = svc();
 				if (!ready(s)) return UNAVAILABLE;
-				const body = request.body ?? {};
+				const body = bodyObject(request);
+				if (body === null) return BODY_NOT_OBJECT;
 				const url = bodyString(body.url);
 				if (!url) return {
 					status: 400,
@@ -252,7 +268,8 @@ function webhookAdminEndpoints(container) {
 				if (!ready(s)) return UNAVAILABLE;
 				const id = pathId(request);
 				if (!id) return NOT_FOUND;
-				const body = request.body ?? {};
+				const body = bodyObject(request);
+				if (body === null) return BODY_NOT_OBJECT;
 				const patch = {};
 				const fields = [];
 				if ("url" in body) {
@@ -375,5 +392,4 @@ function webhookAdminEndpoints(container) {
 		}
 	];
 }
-//#endregion
 export { parseWebhookListQuery, webhookAdminEndpoints };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/admin/adminAudit.ts
+// nodefony/src/admin/adminAudit.ts
 /**
 * Helpers d'audit PARTAGÉS par les producteurs admin du module sécurité
 * (`SecurityAdminApi`, `WebhookAdminApi`…). Extraits dans leur propre fichier
@@ -32,5 +32,4 @@ function adminActor(user) {
 function auditAdmin(container, draft) {
 	container.get("auditService")?.record?.(draft);
 }
-//#endregion
 export { adminActor, auditAdmin };

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

@@ -1,5 +1,27 @@
 import { USER_CREATED_EVENT, USER_REVOKED_EVENT } from "@nodefony/user";
-//#region nodefony/src/admin/userRevocationCascade.ts
+// nodefony/src/admin/userRevocationCascade.ts
+/** Garde : la valeur sait-elle journaliser (`log` est une fonction) ? */
+function isKernelLogger(value) {
+	return typeof value === "object" && value !== null && "log" in value && typeof value.log === "function";
+}
+/**
+* Journalise l'échec d'une brique de la cascade. Le geste reste best-effort —
+* une brique en panne n'empêche pas les autres — mais il ne peut plus échouer
+* EN SILENCE : un accès qui survit à sa révocation (session encore ouverte
+* après un changement de mot de passe) doit laisser une trace qui dit laquelle.
+*
+* @param container - container du kernel (service `kernel`).
+* @param brick - brique en échec (`sessions`, `tokenStore`, `totp`, `webauthn`).
+* @param identifier - compte visé par la cascade.
+* @param error - erreur levée par la brique.
+*/
+function reportCascadeFailure(container, brick, identifier, error) {
+	try {
+		const kernel = container.get("kernel");
+		if (!isKernelLogger(kernel)) return;
+		kernel.log(`révocation de "${identifier}" incomplète : la brique ${brick} a échoué — ` + (error instanceof Error ? error.message : String(error)), "ERROR", "SECURITY");
+	} catch {}
+}
 /**
 * Cascade de révocation déclenchée par {@link USER_REVOKED_EVENT} : éjecte
 * **immédiatement** les artefacts d'accès du porteur — ses **sessions** (http,
@@ -22,13 +44,51 @@ import { USER_CREATED_EVENT, USER_REVOKED_EVENT } from "@nodefony/user";
 */
 async function cascadeUserRevocation(container, event, now = Date.now()) {
 	const identifier = event.identifier;
+	await revokeAccessArtifacts(container, identifier, now);
+	if (event.reason === "deleted") await removeAccountFactors(container, identifier);
+}
+/**
+* Éjecte les artefacts d'accès rangés sous un identifiant — ses sessions (http,
+* `destroyByUser`) et ses jetons/PAT/clés d'API (`tokenStore.revokeAllForSubject`,
+* seuil `invalidBefore`). SEULE implémentation du geste, appelée à la révocation
+* d'un compte ET à sa création. Best-effort par brique : l'indisponibilité de
+* l'une n'empêche pas l'autre.
+*
+* @param container - container du kernel (services `sessions`, `tokenStore`).
+* @param identifier - `IUser.identifier` du compte.
+* @param invalidBefore - seuil (epoch ms) : tout jeton émis avant est rejeté.
+*/
+async function revokeAccessArtifacts(container, identifier, invalidBefore) {
 	try {
 		await container.get("sessions")?.destroyByUser?.(identifier);
-	} catch {}
+	} catch (error) {
+		reportCascadeFailure(container, "sessions", identifier, error);
+	}
 	try {
-		await container.get("tokenStore")?.revokeAllForSubject(identifier, now);
-	} catch {}
-	if (event.reason === "deleted") await removeAccountFactors(container, identifier);
+		await container.get("tokenStore")?.revokeAllForSubject(identifier, invalidBefore);
+	} catch (error) {
+		reportCascadeFailure(container, "tokenStore", identifier, error);
+	}
+}
+/**
+* Purge, à la NAISSANCE d'un compte, tout ce qu'un ancien titulaire du même
+* identifiant a laissé derrière lui : sessions, jetons et facteurs. Un compte
+* qui vient de naître n'a encore rien émis — tout artefact déjà rangé sous son
+* identifiant appartient donc à quelqu'un d'autre. C'est ce qui ferme le cas
+* d'un compte supprimé HORS du framework (`DELETE` SQL, aucun événement), dont
+* l'accès redeviendrait valide dès qu'un compte renaît sous son nom.
+*
+* Le seuil est tronqué à la SECONDE : l'`iat` d'un JWT l'est aussi (RFC 7519
+* §2, NumericDate), et un seuil à la milliseconde rejetterait le jeton du
+* nouveau titulaire émis dans la même seconde que sa création.
+*
+* @param container - container du kernel.
+* @param identifier - `IUser.identifier` du compte créé.
+* @param now - horloge (epoch ms) injectable pour les tests.
+*/
+async function purgeInheritedAccess(container, identifier, now = Date.now()) {
+	await revokeAccessArtifacts(container, identifier, Math.floor(now / 1e3) * 1e3);
+	await removeAccountFactors(container, identifier);
 }
 /**
 * Retire les facteurs rangés sous un identifiant — secret TOTP (codes de
@@ -44,14 +104,18 @@ async function removeAccountFactors(container, identifier) {
 	try {
 		const totp = container.get("totp");
 		if (totp?.isEnabled?.() !== false) await totp?.disable?.(identifier);
-	} catch {}
+	} catch (error) {
+		reportCascadeFailure(container, "totp", identifier, error);
+	}
 	try {
 		const webauthn = container.get("webauthn");
 		if (webauthn?.isEnabled?.() !== false) {
 			const creds = await webauthn?.listUserCredentials?.(identifier) ?? [];
 			for (const cred of creds) await webauthn?.removeUserCredential?.(identifier, cred.id);
 		}
-	} catch {}
+	} catch (error) {
+		reportCascadeFailure(container, "webauthn", identifier, error);
+	}
 }
 /** Garde : charge utile de {@link USER_CREATED_EVENT} (identifiant non vide). */
 function isUserCreatedEvent(value) {
@@ -62,11 +126,12 @@ function isUserCreatedEvent(value) {
 * `@nodefony/security` — avant qu'aucun compte ne puisse être créé ou révoqué
 * (les comptes semés au démarrage compris). Deux abonnements :
 *  - {@link USER_REVOKED_EVENT} → {@link cascadeUserRevocation} ;
-*  - {@link USER_CREATED_EVENT} → purge des facteurs HÉRITÉS : un compte qui
-*    vient de naître n'a encore rien enrôlé, donc tout facteur déjà rangé sous
-*    son identifiant appartient à un ancien titulaire. Règle exacte, aucune
-*    date à comparer. ⚠️ Un import qui chargerait les facteurs AVANT les
-*    comptes les verrait retirés : importer les comptes d'abord.
+*  - {@link USER_CREATED_EVENT} → {@link purgeInheritedAccess} : sessions,
+*    jetons et facteurs HÉRITÉS. Un compte qui vient de naître n'a encore rien
+*    émis ni enrôlé, donc tout artefact déjà rangé sous son identifiant
+*    appartient à un ancien titulaire. Règle exacte, aucune date à comparer.
+*    ⚠️ Un import qui chargerait les facteurs AVANT les comptes les verrait
+*    retirés : importer les comptes d'abord.
 *
 * Les deux sont émis par `UserService` seul, et attendus : chaque handler rend
 * sa promesse. **Extensible** : tout autre module (webhooks…) s'abonne aux
@@ -77,7 +142,7 @@ function isUserCreatedEvent(value) {
 */
 function registerUserRevocationCascade(kernel, container) {
 	kernel.on(USER_REVOKED_EVENT, (event) => cascadeUserRevocation(container, event));
-	kernel.on(USER_CREATED_EVENT, (event) => isUserCreatedEvent(event) ? removeAccountFactors(container, event.identifier) : void 0);
+	kernel.on(USER_CREATED_EVENT, (event) => isUserCreatedEvent(event) ? purgeInheritedAccess(container, event.identifier) : void 0);
 }
 /**
 * Avis de démarrage quand le service `users` n'émet pas sur le bus du kernel —
@@ -100,5 +165,4 @@ function usersEventBusNotice(container, kernel) {
 		fix: "new UserService(repository, encoder, module.container)"
 	};
 }
-//#endregion
-export { cascadeUserRevocation, registerUserRevocationCascade, removeAccountFactors, usersEventBusNotice };
+export { cascadeUserRevocation, purgeInheritedAccess, registerUserRevocationCascade, removeAccountFactors, usersEventBusNotice };