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

package/dist/nodefony/src/realtime/UserRealtimeToken.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/realtime/UserRealtimeToken.ts
+// nodefony/src/realtime/UserRealtimeToken.ts
 /** Aucun scope — figé et partagé (0 allocation pour le cas humain, le plus courant). */
 const EMPTY_SCOPES = Object.freeze([]);
 /**
@@ -41,12 +41,20 @@ var UserRealtimeToken = class {
 	*/
 	#scopes;
 	/**
+	* Confirmation du COMPTE (annuaire relu), fournie par le
+	* {@link FirewallRealtimeAuthenticator} pour les modes dont l'application
+	* émet elle-même l'artefact. `null` = rien à confirmer.
+	*/
+	#confirmAccount;
+	/**
 	* @param user - identité authentifiée résolue par le firewall.
 	* @param revalidate - preuve de vie de l'identité, adaptée à son mode.
 	* @param type - mode d'authentification réel (défaut `"session"`).
 	* @param scopes - scopes délégués du jeton d'origine (défaut aucun).
+	* @param confirmAccount - relecture du compte, payée sur `api.request` seul.
 	*/
-	constructor(user, revalidate = null, type = "session", scopes = EMPTY_SCOPES) {
+	constructor(user, revalidate = null, type = "session", scopes = EMPTY_SCOPES, confirmAccount = null) {
+		this.#confirmAccount = confirmAccount;
 		this.#user = user;
 		this.#revalidate = revalidate;
 		this.type = type;
@@ -67,6 +75,13 @@ var UserRealtimeToken = class {
 	isValid(nowMs) {
 		return this.#revalidate ? this.#revalidate(nowMs) : Promise.resolve(true);
 	}
+	/**
+	* Le compte qui a ouvert la socket existe-t-il toujours, actif, et sous le
+	* même `id` immuable ? `true` si aucune confirmation n'est câblée.
+	*/
+	confirmAccount() {
+		return this.#confirmAccount ? this.#confirmAccount() : Promise.resolve(true);
+	}
 	getUserIdentifier() {
 		return this.#user.identifier;
 	}
@@ -90,5 +105,4 @@ var UserRealtimeToken = class {
 		return key === "user" ? this.#user : void 0;
 	}
 };
-//#endregion
 export { UserRealtimeToken, UserRealtimeToken as default };

package/dist/nodefony/src/realtime/frameAuthorizer.js

@@ -1,5 +1,5 @@
 import { NODEFONY_CHANNEL_NAMESPACE, PLATFORM_CHANNELS, PLATFORM_INBOUND, startsWithCI } from "nodefony";
-//#region nodefony/src/realtime/frameAuthorizer.ts
+// nodefony/src/realtime/frameAuthorizer.ts
 /**
 * Politique système par défaut des canaux d'**introspection serveur** : réservés
 * à l'exploitant de l'INSTANCE, pas à l'administrateur d'une application.
@@ -289,5 +289,4 @@ function buildFrameAuthorizer(firewall, options) {
 		return true;
 	};
 }
-//#endregion
 export { DEFAULT_SYSTEM_PREFIXES, DEFAULT_SYSTEM_RULES, RESERVED_FLOOR_PREFIXES, SECURITY_CHANNEL_POLICY, SYSTEM_CHANNEL_POLICY, UPLINK_CHANNEL_POLICY, buildFrameAuthorizer, buildFrameAuthorizer as default, buildSystemRules };

package/dist/nodefony/src/rolesWithin.js

@@ -0,0 +1,57 @@
+// nodefony/src/rolesWithin.ts
+/**
+* Lit un compte de l'annuaire, sans faire confiance au fournisseur : une
+* lecture qui lève et une lecture qui rend `null` disent toutes deux
+* « introuvable ».
+*/
+async function loadAccount(users, identifier) {
+	try {
+		return await users.loadUserByIdentifier(identifier) ?? null;
+	} catch {
+		return null;
+	}
+}
+/** Rôles chaîne d'un compte lu, sans lui faire confiance. */
+function rolesOf(user) {
+	return Array.isArray(user.roles) ? user.roles.filter((r) => typeof r === "string") : [];
+}
+/**
+* La règle « jouer un autre compte » : les rôles de `target`, hiérarchie
+* comprise, sont-ils TOUS atteints par ceux de `owner` ? Jouer un compte ne
+* monte jamais en droits.
+*
+* Fermée en cas de doute : un annuaire absent, un compte introuvable — y
+* compris un sujet externe éphémère, qui n'a pas de compte local — rendent un
+* refus, jamais un accord. L'annuaire est résolu à l'appel : le service `users`
+* peut être posé après le pare-feu.
+*
+* @param resolveUsers - rend l'annuaire des comptes (`users`), ou `null`
+* @param hierarchy - la hiérarchie de rôles du pare-feu
+* @returns la règle, à poser au conteneur sous `ROLES_WITHIN`
+*/
+function rolesWithin(resolveUsers, hierarchy) {
+	return async (owner, target) => {
+		const users = resolveUsers();
+		if (users === null) return {
+			ok: false,
+			reason: "annuaire des comptes indisponible (@nodefony/user)"
+		};
+		const ownerUser = await loadAccount(users, owner);
+		if (ownerUser === null) return {
+			ok: false,
+			reason: `\`${owner}\` n'a pas de compte dans l'annuaire de l'application (un sujet externe éphémère ne peut jouer aucun compte)`
+		};
+		const targetUser = await loadAccount(users, target);
+		if (targetUser === null) return {
+			ok: false,
+			reason: `compte \`${target}\` introuvable`
+		};
+		const granted = hierarchy.reachableRoles(rolesOf(ownerUser));
+		const extra = [...hierarchy.reachableRoles(rolesOf(targetUser))].filter((role) => !granted.has(role));
+		return extra.length === 0 ? { ok: true } : {
+			ok: false,
+			reason: `\`${target}\` a des rôles que \`${owner}\` n'a pas : ${extra.sort().join(", ")}`
+		};
+	};
+}
+export { rolesWithin };

package/dist/nodefony/src/sessionAuthentication.js

@@ -0,0 +1,25 @@
+// nodefony/src/sessionAuthentication.ts
+/**
+* Facteurs d'authentification de Nodefony → méthodes RFC 8176, posées dans la
+* session à son ouverture. Les clés et leur lecteur sont au cœur
+* (`readSessionAuthentication`, `nodefony`) ; seule la POLITIQUE de
+* correspondance vit ici.
+*/
+const FACTOR_AMR = Object.freeze({
+	password: Object.freeze(["pwd"]),
+	totp: Object.freeze(["pwd", "otp"]),
+	recovery: Object.freeze(["pwd", "otp"]),
+	webauthn: Object.freeze(["pop"])
+});
+const NO_LOCAL_FACTOR = Object.freeze([]);
+/**
+* Valeurs RFC 8176 d'un facteur nommé par un chemin d'authentification.
+*
+* @param factor - le facteur tel que l'audit le nomme (`password`, `totp`,
+*   `recovery`, `webauthn`, `oauth`…)
+* @returns les méthodes vérifiées localement ; vide pour un facteur délégué
+*/
+function amrForFactor(factor) {
+	return Object.hasOwn(FACTOR_AMR, factor) ? FACTOR_AMR[factor] ?? NO_LOCAL_FACTOR : NO_LOCAL_FACTOR;
+}
+export { amrForFactor };

package/dist/nodefony/src/sessionIdentity.js

@@ -1,6 +1,7 @@
 import { AuthenticationError } from "../errors/AuthenticationError.js";
+import { isBoundToAccount } from "./accountBinding.js";
 import { UserNotFoundError } from "@nodefony/user";
-//#region nodefony/src/sessionIdentity.ts
+// nodefony/src/sessionIdentity.ts
 const INVALID_SESSION = "Invalid session";
 /**
 * Résout l'identité portée par une session (l'identifiant stocké dans le blob)
@@ -31,5 +32,30 @@ async function resolveSessionIdentity(provider, identifier) {
 	if (user.isLocked() || !user.isActive()) throw new AuthenticationError(INVALID_SESSION);
 	return user;
 }
-//#endregion
-export { resolveSessionIdentity };
+/**
+* Résout l'identité d'une session DÉJÀ ouverte, en exigeant qu'elle ait été
+* ouverte pour CE compte — {@link resolveSessionIdentity} plus la liaison à
+* l'identifiant immuable (`isBoundToAccount`).
+*
+* La session range son principal sous l'`identifier`, qu'un compte recréé
+* (suppression hors framework, restauration, import) peut reprendre : sans la
+* liaison, la session de l'ancien titulaire ouvrirait le compte du nouveau.
+* Une session sans liaison est refusée au même titre.
+*
+* @param provider - source d'identité (`UserService` via le container).
+* @param identifier - identifiant fonctionnel stocké en session.
+* @param boundAccountId - identifiant immuable inscrit à l'ouverture
+*   (`metaBag`, clé `ACCOUNT_ID_KEY`).
+* @param boundCredentialsVersion - version des identifiants inscrite à
+*   l'ouverture (`metaBag`, clé `CREDENTIALS_VERSION_KEY`).
+* @returns l'utilisateur actif, titulaire de la session.
+* @throws AuthenticationError (401, message uniforme) — identifiant inconnu,
+*   compte verrouillé ou désactivé, session ouverte pour un autre compte ou
+*   avant le dernier changement de mot de passe.
+*/
+async function resolveBoundSessionIdentity(provider, identifier, boundAccountId, boundCredentialsVersion) {
+	const user = await resolveSessionIdentity(provider, identifier);
+	if (!isBoundToAccount(user, boundAccountId, boundCredentialsVersion)) throw new AuthenticationError(INVALID_SESSION);
+	return user;
+}
+export { resolveBoundSessionIdentity, resolveSessionIdentity };

package/dist/nodefony/src/throttle/LoginThrottler.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/throttle/LoginThrottler.ts
+// nodefony/src/throttle/LoginThrottler.ts
 const DEFAULT_FREE_ATTEMPTS = 3;
 const DEFAULT_BASE_DELAY_S = 1;
 const DEFAULT_CAP_DELAY_S = 900;
@@ -93,5 +93,4 @@ var LoginThrottler = class {
 		}
 	}
 };
-//#endregion
 export { LoginThrottler, LoginThrottler as default };

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

@@ -1,5 +1,5 @@
 import { anonymousUser } from "@nodefony/user";
-//#region nodefony/src/token/AnonymousToken.ts
+// nodefony/src/token/AnonymousToken.ts
 /**
 * Token du visiteur non authentifié — Zero Trust : un visiteur EST un utilisateur
 * anonyme (jamais `null`).
@@ -36,5 +36,4 @@ var AnonymousToken = class {
 		(this.#attributes ??= /* @__PURE__ */ new Map()).set(key, value);
 	}
 };
-//#endregion
 export { AnonymousToken, AnonymousToken as default };

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

@@ -1,6 +1,7 @@
-import { messageNonRestreint, modeNonRestreintAsync, readIfPresent, writeSecret } from "./secretFile.js";
+import { createSecretExclusive, messageNonRestreint, modeNonRestreintAsync, readIfPresent } from "./secretFile.js";
+import { isPlainObject } from "nodefony";
 import { join } from "node:path";
-//#region nodefony/src/token/JwtKeystore.ts
+// nodefony/src/token/JwtKeystore.ts
 /**
 * Dossiers que le `Dockerfile` généré EFFACE à l'étage de construction.
 *
@@ -36,6 +37,67 @@ function keystoreLeaksIntoImage(dir) {
 	return `JWT keystore: « ${dir} » n'est PAS sous ${CLEANED_DIRS.map((d) => `\`${d}/\``).join(" ni ")}, les seuls dossiers que le Dockerfile généré efface avant de fabriquer l'image. La clé privée de signature partira donc dans ton image de conteneur, où elle reste lisible par quiconque la télécharge — même effacée par une couche suivante. Deux issues : déplacer le dossier sous \`var/\` (ex. \`var/keys\`), ou injecter la clé par jwt.keystore.keySetJson depuis l'environnement, ce qui est la voie de production.`;
 }
 /**
+* Lit un jeu de clés sérialisé et en vérifie la FORME — la seule lecture du
+* dépôt, appelée par le keystore ET par la validation de configuration.
+*
+* Ne vérifie que la structure (`keys` non vide, un `kid` par clé) : importer
+* les clés exige `jose`, chargé paresseusement au premier jeton. Les messages
+* ne recopient JAMAIS la valeur reçue — elle porte une clé privée.
+*
+* @param json - le jeu de clés, tel que `NF_JWT_KEYSET` ou `keyset.json` le porte.
+* @returns le jeu de clés lu.
+* @throws Error si le JSON est illisible ou la structure incomplète.
+*/
+function parseKeySet(json) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		throw new Error("JwtKeystore: keyset JSON invalide");
+	}
+	if (!isStoredKeySet(parsed)) throw new Error("JwtKeystore: keyset malformé (champ `keys` non vide avec `kid` requis)");
+	return parsed;
+}
+/**
+* Forme minimale d'un jeu de clés relu : un objet dont `keys` est un tableau non
+* vide d'objets portant chacun un `kid` textuel. Le reste de chaque JWK est
+* éprouvé par `jose` à l'import de la clé.
+*/
+function isStoredKeySet(value) {
+	if (!isPlainObject(value)) return false;
+	const keys = value.keys;
+	return Array.isArray(keys) && keys.length > 0 && keys.every((k) => isPlainObject(k) && typeof k.kid === "string");
+}
+/** Génère une nouvelle paire Ed25519 (extractable pour persistance JWK). */
+async function buildKeySet(jose) {
+	const { publicKey, privateKey } = await jose.generateKeyPair("Ed25519", { extractable: true });
+	const publicJwk = await jose.exportJWK(publicKey);
+	const kid = await jose.calculateJwkThumbprint(publicJwk, "sha256");
+	return {
+		active: kid,
+		keys: [{
+			...await jose.exportJWK(privateKey),
+			kid,
+			alg: "EdDSA",
+			use: "sig",
+			createdAt: Date.now()
+		}]
+	};
+}
+/**
+* Génère un jeu de clés de signature à partager entre tous les process d'une
+* application — la valeur de `NF_JWT_KEYSET`.
+*
+* Même générateur que celui du keystore (une seule implémentation), sérialisé
+* en JSON COMPACT : une ligne, sans quote simple, qu'un `.env` porte entre
+* quotes simples et qu'un gestionnaire de secrets stocke tel quel.
+*
+* @returns le jeu de clés sérialisé — il contient la clé PRIVÉE.
+*/
+async function generateKeySet() {
+	return JSON.stringify(await buildKeySet(await import("jose")));
+}
+/**
 * Keystore Ed25519 — implémentation de référence d'{@link IJwtKeystore}.
 *
 * Résout la clé de signature selon une **priorité** (jamais d'auto-génération en
@@ -55,10 +117,15 @@ function keystoreLeaksIntoImage(dir) {
 * usage ; le boot ne paie rien si le JWT n'est jamais sollicité. Le chargement
 * est mémoïsé (une seule résolution concurrente).
 *
-* @remarks Race au 1ᵉʳ boot d'un **cluster** sans clé pré-provisionnée : deux
-* workers peuvent générer puis écrire des clés différentes (le dernier `rename`
-* gagne). En prod, provisionner la clé hors-bande (`keySetJson`/SecretProvider
-* P16) élimine ce cas — c'est précisément la source recommandée.
+* @remarks Plusieurs process qui servent la MÊME application doivent signer
+* avec la même clé, sinon un jeton signé par l'un est refusé par l'autre :
+* - **pods** (aucun disque partagé) → source `env` obligatoire, la même valeur
+*   injectée partout (`NF_JWT_KEYSET`, générée par `security:secrets`) ;
+* - **workers de `nodefony cluster`** → la source `env` est héritée au fork ; à
+*   défaut, la source `fichier` est sûre : la création de `keyset.json` est
+*   EXCLUSIVE ({@link createSecretExclusive}), un seul worker la génère et les
+*   autres relisent la sienne ;
+* - source `mémoire` → une clé par process, jamais cohérente.
 */
 var JwtKeystore = class {
 	#source;
@@ -91,7 +158,7 @@ var JwtKeystore = class {
 	async #load() {
 		const jose = await import("jose");
 		if (this.#source.keySetJson) {
-			await this.#importKeyset(jose, this.#parseKeyset(this.#source.keySetJson));
+			await this.#importKeyset(jose, parseKeySet(this.#source.keySetJson));
 			return;
 		}
 		if (this.#source.dir) {
@@ -101,32 +168,24 @@ var JwtKeystore = class {
 			const existing = await this.#readFile(file);
 			if (existing) {
 				await this.#checkRestricted(file);
-				await this.#importKeyset(jose, this.#parseKeyset(existing));
+				await this.#importKeyset(jose, parseKeySet(existing));
+				return;
+			}
+			const keyset = await buildKeySet(jose);
+			if (await createSecretExclusive(file, JSON.stringify(keyset))) {
+				this.#log(`JWT keystore: clé Ed25519 générée et persistée (${file}).`, "INFO");
+				await this.#checkRestricted(file);
+				await this.#importKeyset(jose, keyset);
 				return;
 			}
-			const keyset = await this.#generate(jose);
-			await this.#writeAtomic(file, JSON.stringify(keyset));
-			await this.#importKeyset(jose, keyset);
+			const winner = await this.#readFile(file);
+			if (winner === null) throw new Error(`JwtKeystore: ${file} a disparu juste après sa création`);
+			await this.#checkRestricted(file);
+			await this.#importKeyset(jose, parseKeySet(winner));
 			return;
 		}
-		this.#log("JWT keystore: clé de signature ÉPHÉMÈRE en mémoire (perdue au redémarrage → refresh tokens invalidés, incohérente en cluster). Configurez jwt.keystore.dir (dev/VPS) ou jwt.keystore.keySetJson depuis l'env (prod).", "WARNING");
-		await this.#importKeyset(jose, await this.#generate(jose));
-	}
-	/** Génère une nouvelle paire Ed25519 (extractable pour persistance JWK). */
-	async #generate(jose) {
-		const { publicKey, privateKey } = await jose.generateKeyPair("Ed25519", { extractable: true });
-		const publicJwk = await jose.exportJWK(publicKey);
-		const kid = await jose.calculateJwkThumbprint(publicJwk, "sha256");
-		return {
-			active: kid,
-			keys: [{
-				...await jose.exportJWK(privateKey),
-				kid,
-				alg: "EdDSA",
-				use: "sig",
-				createdAt: Date.now()
-			}]
-		};
+		this.#log("JWT keystore: clé de signature ÉPHÉMÈRE en mémoire — perdue au redémarrage (jetons en vol invalidés) et propre à CE process : derrière plusieurs pods ou workers, un jeton signé par l'un est refusé par l'autre (401 au hasard). Production : poser jwt.keystore.keySetJson depuis l'environnement (NF_JWT_KEYSET dans une application générée — `npx nodefony security:secrets --jwt-keyset`). Développement : jwt.keystore.dir.", "WARNING");
+		await this.#importKeyset(jose, await buildKeySet(jose));
 	}
 	/** Importe un keyset persisté : privée → `CryptoKey`, public → JWK sans `d`. */
 	async #importKeyset(jose, keyset) {
@@ -153,27 +212,10 @@ var JwtKeystore = class {
 		this.#keys = loaded;
 		this.#activeKid = keyset.active && loaded.some((k) => k.kid === keyset.active) ? keyset.active : firstKey.kid;
 	}
-	#parseKeyset(json) {
-		let parsed;
-		try {
-			parsed = JSON.parse(json);
-		} catch {
-			throw new Error("JwtKeystore: keyset JSON invalide");
-		}
-		const keyset = parsed;
-		if (!keyset || !Array.isArray(keyset.keys) || keyset.keys.length === 0 || keyset.keys.some((k) => typeof k.kid !== "string")) throw new Error("JwtKeystore: keyset malformé (champ `keys` non vide avec `kid` requis)");
-		return keyset;
-	}
 	/** Lit un fichier ; `null` si absent (ENOENT), relance toute autre erreur. */
 	async #readFile(file) {
 		return readIfPresent(file);
 	}
-	/** Écriture atomique (tmp + rename) en mode 600 — pas de fichier partiel lu. */
-	async #writeAtomic(file, data) {
-		await writeSecret(file, data);
-		this.#log(`JWT keystore: clé Ed25519 générée et persistée (${file}).`, "INFO");
-		await this.#checkRestricted(file);
-	}
 	/**
 	* Constate le mode EFFECTIF du fichier de clés et avertit s'il n'est pas 0600.
 	*
@@ -193,5 +235,4 @@ var JwtKeystore = class {
 		this.#log(`JWT keystore: ${messageNonRestreint(file, mode)} La clé PRIVÉE y réside : provisionnez-la plutôt hors-bande via jwt.keystore.keySetJson (recommandé en production).`, "WARNING");
 	}
 };
-//#endregion
-export { JwtKeystore, JwtKeystore as default, keystoreLeaksIntoImage };
+export { JwtKeystore, JwtKeystore as default, generateKeySet, keystoreLeaksIntoImage, parseKeySet };

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

@@ -1,7 +1,7 @@
 import { TOKEN_DEFAULT_ORDER, TOKEN_SORTABLE_FIELDS } from "./tokenSort.js";
 import { matchesTokenStatus } from "./tokenStatus.js";
 import { assertPageQuery, compareByOrder, pickOrder } from "nodefony";
-//#region nodefony/src/token/MemoryTokenStore.ts
+// nodefony/src/token/MemoryTokenStore.ts
 /**
 * Filtre un record contre une requête de listing — prédicat de RÉFÉRENCE du
 * contrat, réutilisé par les implémentations qui évaluent en mémoire.
@@ -245,5 +245,4 @@ var MemoryTokenStore = class {
 		for (const [jti, expiresAt] of this.#deniedJti) if (expiresAt <= now) this.#deniedJti.delete(jti);
 	}
 };
-//#endregion
 export { MemoryTokenStore, matchesTokenQuery };

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

@@ -1,5 +1,6 @@
-import { canonicalIssuer, extractScopes, issuerMetadataUrls, validateIssuerMetadata } from "nodefony";
-//#region nodefony/src/token/RemoteJwtVerifier.ts
+import { describeTransportFailure, untrustedAuthorityHint } from "../net/transportFailure.js";
+import { canonicalIssuer, extractScopes, metadataCandidateUrls, parseDiscoveryUrl, validateIssuerMetadata } from "nodefony";
+// nodefony/src/token/RemoteJwtVerifier.ts
 /**
 * Codes d'erreur `jose` qui désignent un **jeton fautif** — la liste est
 * BLANCHE, et c'est le point important.
@@ -65,8 +66,8 @@ var RemoteJwtVerifier = class {
 	#jose = null;
 	/**
 	* @param options - émetteurs de confiance et réglages réseau
-	* @throws Error si un émetteur est invalide, dupliqué, ou déclare un
-	*         algorithme à secret partagé
+	* @throws Error si un émetteur est invalide, dupliqué, déclare un
+	*         algorithme à secret partagé ou une `discoveryUrl` invalide
 	*/
 	constructor(options) {
 		this.#options = options;
@@ -75,6 +76,7 @@ var RemoteJwtVerifier = class {
 			const issuer = canonicalIssuer(trusted.issuer);
 			if (this.#issuers.has(issuer)) throw new Error(`émetteur « ${issuer} » déclaré deux fois — deux politiques pour un même émetteur ne peuvent pas coexister : la seconde serait ignorée en silence.`);
 			assertAsymmetric(issuer, trusted.algorithms);
+			if (trusted.discoveryUrl !== void 0) parseDiscoveryUrl(trusted.discoveryUrl);
 			this.#issuers.set(issuer, {
 				...trusted,
 				issuer
@@ -101,6 +103,36 @@ var RemoteJwtVerifier = class {
 	*         « jeton invalide »
 	*/
 	async verify(token, audience) {
+		const verified = await this.verifyClaims(token, audience);
+		if (verified === null) return null;
+		const { issuer, payload } = verified;
+		return {
+			issuer,
+			subject: typeof payload.sub === "string" ? payload.sub : void 0,
+			scopes: extractScopes(payload),
+			expiresAt: typeof payload.exp === "number" ? payload.exp : void 0,
+			issuedAt: typeof payload.iat === "number" ? payload.iat : void 0,
+			tokenId: typeof payload.jti === "string" ? payload.jti : void 0,
+			claims: payload
+		};
+	}
+	/**
+	* Vérifie un jeton et rend ses claims BRUTS — pour un jeton qui n'est pas un
+	* jeton d'accès (jeton de déconnexion OpenID Connect, par exemple), dont le
+	* sens se lit dans des claims que {@link verify} ne remonte pas.
+	*
+	* Mêmes garanties et même contrat d'erreur que {@link verify} : signature,
+	* émetteur de la liste fermée, algorithme imposé, audience obligatoire,
+	* claims exigés par l'émetteur ; un refus est un `null`, une panne lève.
+	*
+	* @param token - le jeton brut, tel que présenté
+	* @param audience - audience que le jeton DOIT porter dans `aud`
+	* @returns l'émetteur canonique et les claims vérifiés, ou `null` si le jeton
+	*          est refusé
+	* @throws Error si l'émetteur ne peut pas être joint ou publie un jeu de clés
+	*         inutilisable
+	*/
+	async verifyClaims(token, audience) {
 		if (typeof token !== "string" || token.length === 0) return null;
 		const jose = this.#jose ??= await import("jose");
 		let claimedIssuer;
@@ -126,18 +158,16 @@ var RemoteJwtVerifier = class {
 				...trusted.typ ? { typ: trusted.typ } : {},
 				...trusted.requiredClaims?.length ? { requiredClaims: [...trusted.requiredClaims] } : {}
 			});
-			const subject = typeof payload.sub === "string" ? payload.sub : void 0;
 			return {
 				issuer: claimedIssuer,
-				subject,
-				scopes: extractScopes(payload),
-				expiresAt: typeof payload.exp === "number" ? payload.exp : void 0,
-				issuedAt: typeof payload.iat === "number" ? payload.iat : void 0,
-				tokenId: typeof payload.jti === "string" ? payload.jti : void 0
+				payload
 			};
 		} catch (error) {
 			const code = error.code;
-			if (!code || !TOKEN_FAULT_CODES.has(code)) throw new Error(`vérification impossible : l'émetteur « ${trusted.issuer} » n'a pas fourni de jeu de clés utilisable (${code ?? error.message}).`, { cause: error });
+			if (!code || !TOKEN_FAULT_CODES.has(code)) {
+				const hint = untrustedAuthorityHint(error);
+				throw new Error(`vérification impossible : l'émetteur « ${trusted.issuer} » n'a pas fourni de jeu de clés utilisable (${code ?? describeTransportFailure(error)}).` + (hint === null ? "" : ` ${hint}.`), { cause: error });
+			}
 			this.#audit(`jeton refusé (${trusted.issuer}) : ${code}`);
 			return null;
 		}
@@ -167,7 +197,7 @@ var RemoteJwtVerifier = class {
 			trusted,
 			getKey: jose.createLocalJWKSet(await trusted.localJwks())
 		};
-		const jwksUri = trusted.jwksUri ?? await this.#discover(trusted.issuer);
+		const jwksUri = trusted.jwksUri ?? await this.#discover(trusted);
 		const options = {
 			timeoutDuration: this.#options.timeoutMs ?? 5e3,
 			cooldownDuration: this.#options.cooldownMs ?? 3e4,
@@ -188,11 +218,12 @@ var RemoteJwtVerifier = class {
 	* « meilleure réponse que rien » : il est écarté comme s'il n'avait pas
 	* répondu, et la recherche continue.
 	*/
-	async #discover(issuer) {
+	async #discover(trusted) {
+		const { issuer, discoveryUrl } = trusted;
 		const doFetch = this.#options.fetch ?? globalThis.fetch;
 		const timeout = this.#options.timeoutMs ?? 5e3;
 		const failures = [];
-		for (const url of issuerMetadataUrls(issuer)) try {
+		for (const url of metadataCandidateUrls(issuer, discoveryUrl)) try {
 			const response = await doFetch(url, {
 				signal: AbortSignal.timeout(timeout),
 				redirect: "manual",
@@ -202,7 +233,7 @@ var RemoteJwtVerifier = class {
 				failures.push(`${url} → HTTP ${response.status}`);
 				continue;
 			}
-			const metadata = validateIssuerMetadata(await response.json(), issuer);
+			const metadata = validateIssuerMetadata(await response.json(), issuer, discoveryUrl);
 			this.#audit(`émetteur « ${issuer} » découvert : clés sur ${metadata.jwksUri}.`);
 			return metadata.jwksUri;
 		} catch (error) {
@@ -227,5 +258,4 @@ function assertAsymmetric(issuer, algorithms) {
 	if (algorithms.length === 0) throw new Error(`émetteur « ${issuer} » : aucun algorithme accepté — la liste est la garde principale (RFC 8725 §3.1), elle ne peut pas être vide.`);
 	for (const alg of algorithms) if (alg.startsWith("HS") || alg.toLowerCase() === "none") throw new Error(`émetteur « ${issuer} » : algorithme « ${alg} » refusé. Les clés proviennent d'un jeu PUBLIC : un algorithme à secret partagé y transformerait la clé publique en secret de signature.`);
 }
-//#endregion
 export { RemoteJwtVerifier, RemoteJwtVerifier as default };

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

@@ -1,5 +1,5 @@
 import { anonymousUser } from "@nodefony/user";
-//#region nodefony/src/token/UserToken.ts
+// nodefony/src/token/UserToken.ts
 /**
 * Jeton porteur d'un utilisateur réel — produit par les authenticators à
 * credential (`userpassword`, puis `session`/`jwt`...).
@@ -63,5 +63,4 @@ var UserToken = class {
 		(this.#attributes ??= /* @__PURE__ */ new Map()).set(key, value);
 	}
 };
-//#endregion
 export { UserToken, UserToken as default };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/token/jwtRuntime.ts
+// nodefony/src/token/jwtRuntime.ts
 /**
 * Dérive les paramètres effectifs depuis la config sécurité. `issuer` omis →
 * `"nodefony"` (DEVRAIT être surchargé en prod) ; `audiences` vide → l'app est sa
@@ -27,5 +27,4 @@ function resolveJwtRuntime(jwt) {
 function defaultAudience(runtime) {
 	return runtime.audiences[0] ?? runtime.issuer;
 }
-//#endregion
 export { defaultAudience, resolveJwtRuntime };