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

package/dist/nodefony/service/tokenService.js

@@ -1,14 +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 { JwtKeystore } from "../src/token/JwtKeystore.js";
-import { AUTO_STORE, 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 +
@@ -36,13 +40,48 @@ var TokenService = class extends Service {
 	#users = null;
 	#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);
 		this.module = module;
-		this.kernel?.once("onBoot", () => this.#build());
+		const tokenServiceBoot = () => this.#build();
+		this.kernel?.once("onBoot", tokenServiceBoot);
 		this.kernel?.once("onTerminate", () => this.#shutdown());
 	}
+	/**
+	* Refuse de SERVIR en production sans clé de signature partagée.
+	*
+	* Sans `keySetJson` ni `dir`, le keystore tire une clé ÉPHÉMÈRE propre au
+	* process : derrière plusieurs pods ou workers, un jeton signé par l'un est
+	* refusé par l'autre (401 au hasard de la répartition), et chaque
+	* redémarrage invalide tous les jetons. Un avertissement au premier jeton ne
+	* suffisait pas — il tombait en production, loin de celui qui pouvait agir.
+	*
+	* Seul un run qui SERT est concerné (`runProfile.servers`) : une commande de
+	* console (`orm:migrate`, `security:user:add`) ne signe aucun jeton, et la
+	* bloquer casserait le job de migration pour rien.
+	*
+	* @throws BootConfigurationError - production, serveur, et aucune source.
+	*/
+	#requireSharedSigningKey(keystore) {
+		if (keystore.keySetJson || keystore.dir) return;
+		if (this.kernel?.environment !== "production") return;
+		if (!this.kernel.runProfile.servers) return;
+		throw new BootConfigurationError([
+			"[@nodefony/security] DÉMARRAGE REFUSÉ — aucune clé de signature des jetons partagée (jwt.keystore).",
+			"  Pourquoi : chaque process signerait avec la sienne. Un jeton émis par un pod ou un worker",
+			"  serait refusé par les autres (401 au hasard), et tous seraient perdus au redémarrage.",
+			"  Que faire — une des trois :",
+			"    1. Poser NF_JWT_KEYSET (câblée sur jwt.keystore.keySetJson) : valeur générée UNE fois par",
+			"       `npx nodefony security:secrets --jwt-keyset`, rangée dans le gestionnaire de secrets,",
+			"       injectée dans chaque pod.",
+			"    2. Serveur unique à disque persistant : jwt.keystore.dir.",
+			"    3. L'application n'émet aucun jeton : jwt.enabled: false."
+		].join("\n"));
+	}
 	#build() {
 		let config;
 		try {
@@ -52,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;
@@ -59,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");
@@ -71,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
@@ -89,6 +129,7 @@ var TokenService = class extends Service {
 		});
 		this.container?.set("tokenStore", this.#store);
 		if (jwtEnabled) {
+			this.#requireSharedSigningKey(config.jwt.keystore);
 			this.#runtime = resolveJwtRuntime(config.jwt);
 			this.#keystore = new JwtKeystore(config.jwt.keystore, (m, s) => this.log(m, s));
 			this.container?.set("jwtKeystore", this.#keystore);
@@ -193,10 +234,24 @@ var TokenService = class extends Service {
 	* Émet un couple access/refresh après vérification d'un credential
 	* identifiant/mot de passe (grant M2M/CLI). Throttling NIST partagé si activé.
 	*
+	* @param context - requête HTTP qui porte le credential. Présente, elle
+	*   soumet l'appel au refus du clair en production ; absente (CLI, appel
+	*   programmatique), il n'y a pas de transport à juger. Un endpoint HTTP DOIT
+	*   la passer.
+	* @throws InsecureTransportError (403) — credential reçu en clair en production.
 	* @throws ThrottledError (429) — backoff actif.
 	* @throws AuthenticationError (401, message uniforme) — credential invalide.
 	*/
-	async issueForCredentials(identifier, password, requestedScopes, resource) {
+	async issueForCredentials(identifier, password, requestedScopes, resource, context) {
+		if (context !== void 0) {
+			this.#transport ??= this.get("credentialTransport") ?? null;
+			try {
+				this.#transport?.assert(context, "token");
+			} catch (error) {
+				if (error instanceof InsecureTransportError) this.#auditGrant("login.failure", typeof identifier === "string" && identifier.length > 0 ? identifier : null, "insecure_transport", readAuditContext(context));
+				throw error;
+			}
+		}
 		if (typeof identifier !== "string" || identifier.length === 0 || typeof password !== "string" || password.length === 0) {
 			this.#auditGrant("login.failure", typeof identifier === "string" && identifier.length > 0 ? identifier : null, "invalid_credentials");
 			throw new AuthenticationError("Invalid credentials");
@@ -218,13 +273,14 @@ var TokenService = class extends Service {
 		throttler?.recordSuccess(identifier);
 		return this.issueTokens(user, requestedScopes, resource);
 	}
-	#auditGrant(action, actor, reason) {
+	#auditGrant(action, actor, reason, info) {
 		recordAudit(this.container, {
 			category: "auth",
 			action,
 			outcome: "failure",
 			actor,
-			reason
+			reason,
+			...info
 		});
 	}
 	/**
@@ -289,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",
@@ -367,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,
@@ -379,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;
@@ -393,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.
@@ -411,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 {
@@ -420,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],
@@ -439,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
 		};
@@ -492,5 +560,4 @@ var TokenService = class extends Service {
 		return this.#throttler;
 	}
 };
-//#endregion
 export { TokenService, TokenService as default };

package/dist/nodefony/service/totp.js

@@ -1,10 +1,12 @@
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { recordAudit } from "../src/audit/recordAudit.js";
+import { readAuditContext } from "../src/audit/readAuditContext.js";
 import { getTotpStoreFactory, listTotpStores } from "../src/totp/totpSecretStoreRegistry.js";
 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";
@@ -91,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");
@@ -103,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
@@ -157,17 +159,60 @@ var TotpService = class extends Service {
 	beginEnrollment(userId, account) {
 		return beginTotpEnrollment(this.#ensureReady(), userId, account);
 	}
-	/** Confirme l'enrôlement par un 1ᵉʳ code → active + codes de récupération clairs. */
-	confirmEnrollment(userId, code) {
-		return confirmTotpEnrollment(this.#ensureReady(), userId, code);
+	/**
+	* Confirme l'enrôlement par un 1ᵉʳ code → active + codes de récupération clairs.
+	*
+	* Activer un second facteur est un geste de SÉCURITÉ : il est audité ici
+	* (`user.totp_enabled`), avec la requête qui l'a porté — sans trace, un facteur
+	* posé à l'insu du titulaire ne se retrouve pas.
+	*
+	* @param userId - compte dont on active le 2FA (le porteur de la session).
+	* @param code - premier code de l'application d'authentification.
+	* @param context - contexte de la requête (IP, navigateur, identifiant de
+	*   requête) recopié dans l'événement d'audit ; absent, l'événement part sans.
+	* @returns les codes de récupération, affichés une seule fois.
+	* @throws quand le code est faux, l'enrôlement absent ou déjà confirmé.
+	*/
+	async confirmEnrollment(userId, code, context) {
+		const activation = await confirmTotpEnrollment(this.#ensureReady(), userId, code);
+		recordAudit(this.container, {
+			category: "auth",
+			action: "user.totp_enabled",
+			outcome: "success",
+			actor: userId,
+			resource: userId,
+			...readAuditContext(context)
+		});
+		return activation;
 	}
 	/** Vérifie un second facteur au login (code TOTP ou code de récupération). */
 	verifyLogin(userId, code) {
 		return verifyTotpLogin(this.#ensureReady(), userId, code);
 	}
-	/** Désactive le 2FA d'un utilisateur. */
-	disable(userId) {
-		return disableTotp(this.#ensureReady(), userId);
+	/**
+	* Désactive le 2FA d'un utilisateur.
+	*
+	* Avec un `context`, c'est le TITULAIRE qui retire son facteur (porte
+	* libre-service) : le geste est audité ici (`user.totp_disabled`). Sans
+	* contexte, l'appelant porte lui-même l'audit — le plan d'administration le
+	* fait avec l'identité de l'administrateur (`viaAdmin`), qu'ici on ignore.
+	* Un seul événement par geste, jamais deux.
+	*
+	* @param userId - compte dont on retire le 2FA.
+	* @param context - contexte de la requête du titulaire (audit libre-service).
+	*/
+	async disable(userId, context) {
+		await disableTotp(this.#ensureReady(), userId);
+		if (context === void 0) return;
+		recordAudit(this.container, {
+			category: "auth",
+			action: "user.totp_disabled",
+			outcome: "success",
+			actor: userId,
+			resource: userId,
+			metadata: { viaAdmin: false },
+			...readAuditContext(context)
+		});
 	}
 	/** État 2FA d'un utilisateur (absent / pending / activé + codes restants). */
 	status(userId) {
@@ -207,5 +252,4 @@ var TotpService = class extends Service {
 		return this.#deps;
 	}
 };
-//#endregion
 export { TotpService, TotpService as default };

package/dist/nodefony/service/webAuthn.js

@@ -2,13 +2,31 @@ 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";
 }
+/** Taille maximale d'un `userHandle` (WebAuthn L3 §4, « User Handle »). */
+const USER_HANDLE_MAX_BYTES = 64;
+/**
+* Octets du `userHandle` d'une cérémonie d'enregistrement — opaques, bornés, sans
+* donnée personnelle (cf {@link IWebAuthnUser.handle}).
+*
+* @param user - sujet de la cérémonie.
+* @returns `handle` encodé s'il est fourni et tient en 64 octets, sinon le
+*   condensat SHA-256 de l'`id`.
+*/
+function userHandleBytes(user) {
+	if (user.handle !== void 0 && user.handle.length > 0) {
+		const bytes = Buffer.from(user.handle, "utf8");
+		if (bytes.length <= USER_HANDLE_MAX_BYTES) return new Uint8Array(bytes);
+	}
+	return new Uint8Array(createHash("sha256").update(user.id, "utf8").digest());
+}
 /**
 * **WebAuthn / passkeys** (P6 J9) — orchestrateur des deux cérémonies FIDO2
 * (WebAuthn L3 §7.1 enregistrement, §7.2 authentification).
@@ -74,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");
@@ -86,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
@@ -143,7 +161,7 @@ var WebAuthnService = class extends Service {
 			rpName: this.#rpName,
 			rpID: this.#rpID,
 			userName: user.name,
-			userID: new Uint8Array(Buffer.from(user.id, "utf8")),
+			userID: userHandleBytes(user),
 			userDisplayName: user.displayName ?? user.name,
 			attestationType: pk.attestation,
 			timeout: pk.timeoutMs,
@@ -347,5 +365,4 @@ var WebAuthnService = class extends Service {
 		};
 	}
 };
-//#endregion
-export { WebAuthnService, WebAuthnService as default };
+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,4 +1,5 @@
-//#region nodefony/src/SecuredArea.ts
+import { stripTrailingSlashes } from "nodefony";
+// nodefony/src/SecuredArea.ts
 /**
 * Zone sécurisée concrète — pattern d'URL compilé + métadonnées d'authentification.
 *
@@ -16,22 +17,30 @@ var SecuredArea = class {
 	host;
 	realtime;
 	resource;
+	entryPoint;
+	subjectPolicy;
+	ephemeralRoles;
 	/**
 	* Rôles exigés par défaut dans la zone, ou `null` quand elle n'en exige
 	* aucun. `null` plutôt qu'un tableau vide : le hot path teste une référence,
 	* et aucune zone ne porte de tableau qu'elle n'utilise pas.
 	*/
 	roles;
+	#hostKey;
 	constructor(name, config) {
 		this.name = name;
-		this.pattern = new RegExp(config.pattern, "u");
+		this.pattern = new RegExp(config.pattern, "iu");
 		this.security = config.security;
 		this.stateless = config.stateless;
 		this.mode = config.mode;
 		this.authenticators = config.authenticators;
 		this.host = config.host;
+		this.#hostKey = config.host ? config.host.toLowerCase() : null;
 		this.realtime = config.realtime;
 		this.resource = config.resource;
+		this.entryPoint = config.entryPoint;
+		this.subjectPolicy = config.subjectPolicy;
+		this.ephemeralRoles = config.subjectPolicy === "ephemeral" ? config.ephemeralRoles ?? [] : void 0;
 		this.roles = config.roles.length > 0 ? config.roles : null;
 	}
 	/**
@@ -40,8 +49,10 @@ var SecuredArea = class {
 	* UNIQUE de la décision de zone (invariant `api.request {path}` ≤ `GET {path}`).
 	*/
 	matchPath(pathname, host) {
-		if (this.host && this.host !== host) return false;
-		return this.pattern.test(pathname);
+		if (this.#hostKey !== null && this.#hostKey !== host?.toLowerCase()) return false;
+		if (this.pattern.test(pathname)) return true;
+		const bare = stripTrailingSlashes(pathname);
+		return bare !== pathname && this.pattern.test(bare);
 	}
 	/** La requête tombe-t-elle dans cette zone ? (host éventuel + pathname). */
 	match(context) {
@@ -54,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 };