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

package/dist/nodefony/command/security-user-list.js

@@ -1,5 +1,5 @@
 import { CONSOLE_DATA_RUN_PROFILE, Command } from "nodefony";
-//#region nodefony/command/security-user-list.ts
+// nodefony/command/security-user-list.ts
 const options = {
 	runProfile: CONSOLE_DATA_RUN_PROFILE,
 	helpGroup: "COMPTES ET SECRETS",
@@ -31,7 +31,10 @@ const DEFAULT_LIMIT = 50;
 */
 var SecurityUserList = class extends Command {
 	constructor(cli) {
-		super("security:user:list", "liste les comptes : identifiant, rôles, état", cli, options);
+		super("security:user:list", "liste les comptes : identifiant, rôles, état", cli, {
+			...options,
+			examples: ["nodefony security:user:list", "nodefony security:user:list --role ROLE_ADMIN --json"]
+		});
 		this.addOption("-q, --query <texte>", "filtre sur l'identifiant (sous-chaîne, insensible à la casse)");
 		this.addOption("-r, --role <role>", "n'affiche que les porteurs d'un rôle");
 		this.addOption("-l, --limit <n>", `nombre maximum de comptes (défaut ${DEFAULT_LIMIT})`);
@@ -74,5 +77,4 @@ var SecurityUserList = class extends Command {
 		return this;
 	}
 };
-//#endregion
 export { SecurityUserList as default };

package/dist/nodefony/command/security-user-password.js

@@ -1,6 +1,5 @@
 import { AUTH_LOGIN_PATH, CONSOLE_DATA_RUN_PROFILE, Command, askPasswordMasked } from "nodefony";
-import { USER_REVOKED_EVENT } from "@nodefony/user";
-//#region nodefony/command/security-user-password.ts
+// nodefony/command/security-user-password.ts
 const options = {
 	runProfile: CONSOLE_DATA_RUN_PROFILE,
 	helpGroup: "COMPTES ET SECRETS",
@@ -34,14 +33,17 @@ const RESET = "\x1B[0m";
 *
 * 🔒 **Les sessions et les jetons du compte sont RÉVOQUÉS**, et ce n'est pas une
 * option : on change un mot de passe parce qu'il est compromis ou perdu, et
-* laisser vivre les sessions ouvertes laisserait l'accès à qui l'a volé. La
-* révocation passe par l'événement que la suppression emploie déjà — une
-* cascade, un seul canal, et les abonnés futurs (webhooks) en profitent sans
-* rien changer ici.
+* laisser vivre les sessions ouvertes laisserait l'accès à qui l'a volé.
+* `UserService.changePassword` émet la révocation lui-même — la même que pour
+* le plan d'administration et la page « mon mot de passe » : un seul émetteur,
+* aucun transport ne peut l'oublier.
 */
 var SecurityUserPassword = class extends Command {
 	constructor(cli) {
-		super("security:user:password", "change le mot de passe d'un compte", cli, options);
+		super("security:user:password", "change le mot de passe d'un compte", cli, {
+			...options,
+			examples: ["nodefony security:user:password alice"]
+		});
 		this.addArgument("[identifier]", "identifiant (login) du compte");
 		this.addOption("-p, --password <password>", "nouveau mot de passe (sinon : prompt masqué en TTY)");
 	}
@@ -100,15 +102,8 @@ var SecurityUserPassword = class extends Command {
 			process.exitCode = 1;
 			return this;
 		}
-		this.kernel?.fire(USER_REVOKED_EVENT, {
-			id: user.id,
-			identifier: user.identifier,
-			tenantId: null,
-			reason: "password_changed"
-		});
 		process.stdout.write(`\n${GREEN}✓ mot de passe changé${RESET} — ${BOLD}${user.identifier}${RESET}\n${DIM}  ses sessions et ses jetons sont révoqués : il devra se reconnecter.${RESET}\n${DIM}  connexion : POST ${AUTH_LOGIN_PATH}${RESET}\n` + (opts.password ? `  ${YELLOW}⚠ mot de passe passé en argument — pense à purger l'historique shell${RESET}\n` : "") + "\n");
 		return this;
 	}
 };
-//#endregion
 export { SecurityUserPassword as default };

package/dist/nodefony/config/config.js

@@ -1,5 +1,9 @@
+import { parseKeySet } from "../src/token/JwtKeystore.js";
+import { scopeGrantKeyProblem } from "../src/token/scopeGrants.js";
+import { PLATFORM_ROLE_PREFIX, isPlatformRole } from "../src/oauth/providerRoles.js";
+import { DEFAULT_LOGIN_PAGE_SKIN, LOGIN_PAGE_LAYOUTS, LOGIN_PAGE_PATH, LOGIN_PAGE_SKINS, parseDiscoveryUrl, safeRedirectPath } from "nodefony";
 import { z } from "zod";
-//#region nodefony/config/config.ts
+// nodefony/config/config.ts
 /**
 * ════════════════════════════════════════════════════════════════════════════
 *  @nodefony/security — CONFIGURATION DU MODULE (schéma Zod = source unique)
@@ -45,10 +49,18 @@ const areaSchema = z.strictObject({
 	mode: z.enum(["first", "all"]).default("first").describe("Chaîne d'authenticators : 'first' = le premier qui reconnaît la requête authentifie (ex. cookie OU bearer) ; 'all' = tous doivent passer (ex. mtls+jwt zone admin)."),
 	authenticators: z.array(z.string()).default([]).describe("Authenticators de la zone (sémantique selon `mode`). Validés au boot contre le registre."),
 	roles: z.array(z.string()).default([]).describe("Rôle(s) exigés PAR DÉFAUT dans la zone, en OU (l'un suffit ; hiérarchie comprise). Vide (défaut) = la zone n'exige qu'une identité, et toute route qu'elle couvre est ouverte à n'importe quel compte authentifié — c'est un défaut OUVERT, qu'une surface d'administration ne doit pas garder. Renseigné, le rôle s'applique à toute route de la zone qui ne décide PAS elle-même de son autorisation : une route gardée (`@IsGranted`, `@RequireScope`) et le pont du plan d'administration (qui résout un rôle par point d'entrée) gardent la main — sans quoi une zone fermée à l'administrateur écraserait un point d'entrée voulu accessible à son propriétaire (`me`, `sessions/mine`). Un refus ici est un 403 (authentifié, pas autorisé), jamais un 401."),
-	entryPoint: z.string().optional().describe("Route de login/redirect si non authentifié."),
+	entryPoint: z.string().refine((value) => safeRedirectPath(value, "") === value, { message: "entryPoint doit être un chemin de CETTE origine (`/login`), jamais une adresse externe" }).optional().describe("Page de connexion vers laquelle conduire un visiteur anonyme qui NAVIGUE (GET ou HEAD, `Accept: text/html`, `Sec-Fetch-Mode: navigate` s'il est présent) : 302 vers `<entryPoint>?from=<chemin demandé>`, et la page de connexion ramène au chemin demandé. Tout le reste — appel d'API, `fetch`, POST, WebSocket — garde son 401 et son `WWW-Authenticate`. Le refus reste journalisé (`auth.denied`). Absent (défaut) : 401 pour tous."),
 	host: z.string().optional().describe("Domaine/vhost de la zone (ex. admin.exemple.com). Omis = tous domaines."),
 	resource: z.string().optional().describe("URI canonique de la ressource protégée — l'AUDIENCE qu'un jeton doit porter pour être accepté ici (RFC 8707 §2). Obligatoire dès que la zone liste un authenticator de jetons TIERS (`external-jwt`), qui refuse de démarrer sans elle. C'est ce qui empêche un jeton valide, délivré au même porteur pour un AUTRE service, d'être rejoué sur celui-ci. Elle s'ÉCRIT et ne se dérive pas du `Host` : derrière un relais, ce que le processus croit être son adresse n'est pas ce que le client a demandé, et l'audience doit être exactement celle que le serveur d'autorisation a inscrite dans le jeton. Ex. « https://api.example.com/mcp »."),
-	realtime: z.boolean().default(true).describe("Zone valable AUSSI pour les frames WebSocket (api.request + subscribe), pas seulement HTTP. Défaut `true` (Zero Trust : une zone protégée ferme TOUS ses transports — un opt-IN laisserait le WS anonyme par omission = fail-open). `false` = opt-out explicite pour une zone strictement HTTP. Le verrou WS consulte la MÊME zone que HTTP — invariant : `api.request {path}` n'accorde jamais plus que `GET {path}`.")
+	realtime: z.boolean().default(true).describe("Zone valable AUSSI pour les frames WebSocket (api.request + subscribe), pas seulement HTTP. Défaut `true` (Zero Trust : une zone protégée ferme TOUS ses transports — un opt-IN laisserait le WS anonyme par omission = fail-open). `false` = opt-out explicite pour une zone strictement HTTP. Le verrou WS consulte la MÊME zone que HTTP — invariant : `api.request {path}` n'accorde jamais plus que `GET {path}`."),
+	subjectPolicy: z.enum(["require", "ephemeral"]).optional().describe("Surcharge, pour CETTE zone, de `resourceServer.subjectPolicy` — comment le sujet d'un jeton TIERS devient un utilisateur. Omis (défaut) = la politique globale. Sert à faire cohabiter une zone d'appelants machine (« ephemeral » : aucun compte local exigé) et une zone de personnes (« require ») dans la même application ; une politique globale ne sait pas l'exprimer. N'a de sens que si la zone liste `external-jwt` : déclarée ailleurs, le boot la refuse."),
+	ephemeralRoles: z.array(z.string().min(1)).optional().describe("Rôles accordés à l'appelant accepté par CETTE zone en mode « ephemeral ». Exige `subjectPolicy: \"ephemeral\"` écrit dans la zone même : un pouvoir local ne s'hérite pas d'un réglage écrit ailleurs. Une zone qui déclare « ephemeral » sans ses rôles n'en accorde AUCUN — jamais ceux de `resourceServer.ephemeralRoles`, qui protègent une autre surface.")
+}).refine((area) => area.subjectPolicy === void 0 || area.authenticators.includes("external-jwt"), {
+	message: "subjectPolicy ne s'applique qu'aux jetons tiers : la zone doit lister l'authenticator « external-jwt »",
+	path: ["subjectPolicy"]
+}).refine((area) => area.ephemeralRoles === void 0 || area.subjectPolicy === "ephemeral", {
+	message: "ephemeralRoles exige subjectPolicy: \"ephemeral\" écrit dans la MÊME zone — un pouvoir local ne s'hérite pas",
+	path: ["ephemeralRoles"]
 });
 const corsSchema = z.strictObject({
 	enabled: z.boolean().default(true).describe("Active la gestion CORS."),
@@ -152,7 +164,14 @@ const jwtSchema = z.strictObject({
 	audiences: z.array(z.string()).default([]).describe("Audiences acceptées à la vérification ET **demandables à l'émission** (claim `aud`, RFC 8707) — une liste BLANCHE de ressources, pas une simple valeur par défaut. Un client nomme sa cible par le paramètre `resource` du grant ; absente de cette liste, la demande est REFUSÉE (`invalid_target`, RFC 8707 §2) au lieu d'être servie avec l'audience par défaut — sans quoi tout porteur d'un identifiant valide obtiendrait un jeton pour la ressource de son choix. La PREMIÈRE entrée est l'audience par défaut (jeton demandé sans `resource`). Vide = l'audience de l'app (= `issuer`). Déclarer ici l'URI canonique d'une ressource protégée (porte MCP, API interne) est ce qui la rend joignable avec un jeton émis par cette application. La validation d'audience est OBLIGATOIRE côté resource (RFC 9700)."),
 	issuer: z.string().optional().describe("Émetteur (claim `iss`, RFC 7519). Omis = `\"nodefony\"` — suffisant tant que l'app émet ET vérifie ses propres jetons, mais PAS publiable (RFC 8414 §2 exige une URL https) : sans valeur explicite, aucune découverte n'est offerte. Ne se DEVINE pas — derrière un relais, `Host`/`X-Forwarded-*` viennent du client. STABLE : gravé dans chaque jeton déjà émis, le changer les invalide."),
 	keystore: z.strictObject({
-		keySetJson: z.string().optional().describe("JWK Set (clé(s) privée(s) Ed25519) injecté par l'app depuis son env — SECRET, jamais loggé. Présent = source `env` (prod cloud)."),
+		keySetJson: z.string().refine((json) => {
+			try {
+				parseKeySet(json);
+				return true;
+			} catch {
+				return false;
+			}
+		}, { message: "jeu de clés illisible — attendu le JSON produit par `npx nodefony security:secrets --jwt-keyset` ({ active, keys: [JWK privé avec kid] }), sur une ligne" }).optional().describe("JWK Set (clé(s) privée(s) Ed25519) PARTAGÉ par tous les process de l'app (pods, workers de cluster) — variable `NF_JWT_KEYSET` d'une application générée. SECRET, jamais loggé. Présent = source `env`, prioritaire sur `dir`."),
 		dir: z.string().optional().describe("Dossier de persistance `keyset.json` (chmod 600), généré si absent — opt-in dev/VPS. Sans `keySetJson` ni `dir` = clé ÉPHÉMÈRE en mémoire + warning (refresh non durables).")
 	}).default(() => ({})).describe("Source du matériel de signature JWT (priorité) : env (`keySetJson`) → fichier (`dir`) → mémoire+warn. SecretProvider (Vault/KMS) = P16.")
 }).describe("JWT — réservé API service↔service / agents (le web/navigateur utilise la session BFF).");
@@ -223,8 +242,17 @@ const remoteJwtAlgSchema = z.enum([
 	"EdDSA",
 	"Ed25519"
 ]);
+const discoveryUrlSchema = z.string().refine((value) => {
+	try {
+		parseDiscoveryUrl(value);
+		return true;
+	} catch {
+		return false;
+	}
+}, "adresse http(s) complète du document attendue, sans identifiants ni fragment").optional().describe("Adresse COMPLÈTE où lire le document de métadonnées, quand l'application ne joint pas l'émetteur par son adresse publique — en Kubernetes, le service interne : « http://keycloak.sso:8080/realms/app/.well-known/openid-configuration ». Seul le lieu de lecture change : le document doit toujours se déclarer de `issuer` (RFC 8414 §3.3), sinon refus. Les points appelés de serveur à serveur (jeton, clés) peuvent alors être en http sur l'origine exacte de cette adresse ; le point d'autorisation, où le navigateur est envoyé, reste en https. Keycloak publie ses points internes avec `--hostname-backchannel-dynamic=true`. Omis = découverte sur l'émetteur.");
 const trustedIssuerSchema = z.strictObject({
 	issuer: z.string().min(1).describe("Identifiant de l'émetteur (claim `iss`), en https, sans requête ni fragment (RFC 8414 §2) — ex. « https://auth.example.com/realms/mon-royaume ». C'est une ALLOWLIST : un jeton dont l'`iss` n'est pas ici est refusé avant toute requête sortante."),
+	discoveryUrl: discoveryUrlSchema,
 	jwksUri: z.string().optional().describe("Jeu de clés publiques de l'émetteur. Omis = découvert par les points bien connus RFC 8414/OpenID (3 URL essayées dans l'ordre normatif). Déclaré = aucune découverte (émetteur sans métadonnées, ou démarrage à froid sans requête)."),
 	algorithms: z.array(remoteJwtAlgSchema).min(1).default([
 		"RS256",
@@ -236,7 +264,7 @@ const trustedIssuerSchema = z.strictObject({
 	subjectMapping: z.enum(["prefixed", "subject"]).default("prefixed").describe("Comment le sujet (`sub`) de CET émetteur devient un identifiant dans l'espace de noms local. « prefixed » (défaut) : l'identifiant cherché est « <issuer>#<sub> » — deux émetteurs ne peuvent pas se disputer un compte, et surtout aucun sujet étranger ne peut tomber par hasard sur un identifiant local existant. « subject » : le `sub` est cherché TEL QUEL, l'ancien comportement — à ne déclarer que si l'on maîtrise l'espace de noms de cet émetteur, typiquement parce qu'il EST cette application (jetons maison) ou parce que ses sujets sont déjà des identifiants locaux. 🔴 Le défaut n'est pas un réglage de confort : un annuaire où l'utilisateur choisit son identifiant permet de présenter `sub: \"admin\"`, et « subject » rattache alors le porteur au compte local du même nom. `sub` n'est unique que dans l'espace de son émetteur (OIDC Core §2) — l'identité est la paire, jamais le sujet seul.")
 });
 const resourceServerSchema = z.strictObject({
-	issuers: z.array(trustedIssuerSchema).default([]).describe("Émetteurs dont l'application accepte les jetons. VIDE (défaut) = aucun jeton tiers n'est vérifiable, et le service `accessTokenVerifier` n'est pas posé — une porte protégée refusera alors de servir plutôt que d'accepter des porteurs qu'elle ne sait pas lire. Un seul réglage commande le rôle : pas de drapeau `enabled` qui permettrait « activé sans émetteur »."),
+	issuers: z.array(trustedIssuerSchema).default([]).describe("Émetteurs TIERS dont l'application accepte les jetons. Les jetons signés par l'application elle-même n'ont pas à y figurer : dès que `jwt.enabled`, le service `accessTokenVerifier` les reconnaît, et les juge par les règles de l'authentificateur `jwt` (révocation, compte actif). VIDE (défaut) = aucun jeton tiers n'est vérifiable ; avec `jwt.enabled: false`, le service n'est pas posé et une porte protégée refusera de servir plutôt que d'accepter des porteurs qu'elle ne sait pas lire. Une liste INVALIDE n'en pose aucun, jetons locaux compris."),
 	subjectPolicy: z.enum(["require", "ephemeral"]).default("require").describe("Comment le sujet d'un jeton tiers (`sub`) devient un utilisateur de CETTE application. « require » (défaut) : le sujet doit correspondre à un compte local (`loadUserByIdentifier`) — absent, désactivé ou verrouillé, l'accès est refusé. « ephemeral » : aucun compte local n'est exigé ni créé, l'appelant vit le temps de la requête avec les rôles de `ephemeralRoles` — c'est le mode de l'appelant PUREMENT machine (agent, service). Le défaut est « require » parce qu'un jeton d'un annuaire d'entreprise vaut pour des milliers de comptes : l'accepter d'office ferait de cet annuaire l'unique autorité d'accès à l'application, et supprimerait la seconde décision — locale — qui est la raison d'être du pare-feu."),
 	ephemeralRoles: z.array(z.string().min(1)).default([]).describe("Rôles accordés à un appelant accepté en mode « ephemeral ». VIDE par défaut, et ce n'est pas une omission : sans rôle, l'appelant ne passe aucun `@IsGranted` et n'est autorisé que par ses SCOPES (`@RequireScope`), qui viennent du jeton et sont bornés par le serveur d'autorisation. Y écrire un rôle revient à accorder un pouvoir local à quiconque détient un jeton valide pour cette ressource — à faire sciemment, jamais par confort."),
 	timeoutMs: z.number().int().min(100).default(5e3).describe("Délai maximal d'une requête vers l'émetteur (découverte + clés)."),
@@ -301,28 +329,89 @@ const studioSchema = z.strictObject({
 		description: "INERTE — l'audit des mutations admin est posé point par point par `SecurityAdminApi` (certaines mutations émettent, pas toutes) ; ce drapeau ne pilote aucune couverture globale."
 	})
 }).describe("Sécurité de la console Studio — durcissement exposition publique.");
+const loginPageSchema = z.strictObject({
+	enabled: z.boolean().default(true).describe("Sert la page de connexion par défaut. false = l'application sert la sienne au même chemin (`useNodefonyLogin`) : les redirections continuent d'y mener."),
+	path: z.string().default(LOGIN_PAGE_PATH).refine((p) => p.length > 0 && safeRedirectPath(p, "") === p && !/[?#]/.test(p), "chemin local attendu, sans requête ni fragment (`/login`)").describe("Chemin de la page de connexion. La redirection d'échec d'un fournisseur et le retour après déconnexion fédérée le suivent, sauf s'ils sont réglés."),
+	title: z.string().min(1).optional().describe("Titre de la page. Omis = titre par défaut."),
+	logo: z.string().min(1).optional().describe("Adresse du logo affiché (chemin servi par l'application ou URL). Omis = logo Nodefony."),
+	template: z.string().min(1).optional().describe("Chemin d'un gabarit `.eta` de l'application qui REMPLACE celui du framework. Dernier recours : `stylesheet` (variables `--nf-login-*`), `layout` et les textes (`heading`, `subtitle`, `hero`) suffisent à l'habillage, et survivent aux évolutions du balisage — un gabarit copié, non."),
+	stylesheet: z.string().min(1).optional().describe("Adresse d'une feuille de l'application chargée APRÈS celle du framework : elle redéfinit les variables `--nf-login-*` (couleurs, rayons, `--nf-login-hero-image` pour la photo du panneau). Chemin servi par l'application de préférence — une URL d'un autre site doit être autorisée par la CSP (`style-src`)."),
+	heading: z.string().min(1).optional().describe("Titre de la carte et de l'onglet. Omis = « Se connecter ». Le nom de l'application, lui, vient de `title`."),
+	subtitle: z.string().min(1).optional().describe("Ligne sous le titre. Omis = phrase déduite des moyens proposés (identifiant local, compte de l'organisation, ou les deux)."),
+	providersFirst: z.boolean().default(true).describe("Les boutons des fournisseurs passent AVANT le formulaire identifiant et mot de passe. false = le formulaire d'abord. Sans fournisseur proposé, sans effet."),
+	hero: z.union([z.literal(false), z.strictObject({
+		heading: z.string().min(1).describe("Accroche du panneau."),
+		text: z.string().min(1).optional().describe("Phrase sous l'accroche.")
+	})]).optional().describe("Panneau d'illustration de la mise en page `split`. Omis = vitrine Nodefony. `{ heading, text }` = votre texte à la place. false = la marque seule, sur l'image du panneau. L'image se règle dans `stylesheet` (`--nf-login-hero-image`), jamais ici."),
+	footer: z.boolean().default(true).describe("Pied de page : protections de la session (cookie HttpOnly, anti-CSRF, CSP) et mention « Propulsé par Nodefony ». false = retiré."),
+	password: z.boolean().default(true).describe("Propose le formulaire identifiant et mot de passe. false = connexion par fournisseur seulement (SSO)."),
+	skin: z.enum(LOGIN_PAGE_SKINS).default(DEFAULT_LOGIN_PAGE_SKIN).describe("Habillage : `frontispiece` (défaut), `ledger`, `horizon`, `console`, `blueprint`, `dots`, `minimal`, `enterprise`, `photo-card`. Une feuille du framework chargée avant `stylesheet` ; aucune ne fournit de photo — elle vient de `stylesheet` (`--nf-login-hero-image`). En développement, `?skin=` et `?layout=` en donnent un aperçu."),
+	layout: z.enum(LOGIN_PAGE_LAYOUTS).optional().describe("Mise en page : `split` (illustration et formulaire côte à côte), `card` (panneau centré), `bare` (formulaire seul). Omis = celle pour laquelle l'habillage est dessiné."),
+	previewPicker: z.boolean().default(false).describe("En DÉVELOPPEMENT seulement : un sélecteur d'habillage et de mise en page sur la page, qui recharge avec `?skin=` et `?layout=`. Sans effet en production, où ces paramètres sont ignorés. Pour choisir son habillage à l'écran, pas pour le livrer."),
+	previewHook: z.string().regex(/^\/(?![/\\])/u, "chemin de l'application attendu (« /… »), jamais une autre origine").optional().describe("Avec `previewPicker`, en DÉVELOPPEMENT : chemin de l'application appelé en POST (`{ skin, layout }`, même origine) AVANT chaque rechargement de l'aperçu. Pour qu'un tiers suive l'habillage choisi — le thème d'un Keycloak de développement (`applyKeycloakLoginTheme`). Un échec n'empêche pas le rechargement.")
+}).describe("Page de connexion servie par le framework, sans front (ADR-0015).");
 const oauthProviderSchema = z.strictObject({
 	clientId: z.string().min(1).describe("Identifiant client OAuth délivré par le fournisseur."),
 	clientSecret: z.string().min(1).describe("Secret client OAuth — SECRET, fourni par env, jamais loggé."),
 	clientAuthMethod: z.enum(["client_secret_basic", "client_secret_post"]).optional().describe("Comment le client s'authentifie au point de jeton (RFC 6749 §2.3). OMIS = `client_secret_basic`, ce que la RFC demande de préférer et ce que la plupart des serveurs annoncent par défaut. Poser `client_secret_post` quand le serveur l'EXIGE — il le publie dans ses métadonnées (`token_endpoint_auth_methods_supported`). La méthode `none` (client public) n'est pas offerte ici : ce schéma exige un secret non vide."),
 	redirectUri: z.string().min(1).describe("URL de callback EXACTE (RFC 9700 : exact string matching) enregistrée chez le fournisseur — doit pointer sur .../oauth2/<provider>/callback."),
 	issuer: z.string().optional().describe("Émetteur OIDC self-hosted (Keycloak : URL du realm, ex. https://kc.example/realms/app). REQUIS pour keycloak ; ignoré par les fournisseurs à endpoints fixes (Google/GitHub)."),
+	discoveryUrl: discoveryUrlSchema,
 	scopes: z.array(z.string()).default([]).describe("Scopes demandés. Vide = défauts du fournisseur (Google: openid/profile/email ; GitHub: read:user/user:email)."),
 	successRedirect: z.string().optional().describe("Redirection succès — surcharge le global pour CE fournisseur."),
 	failureRedirect: z.string().optional().describe("Redirection échec — surcharge le global pour CE fournisseur."),
+	postLogoutRedirectUri: z.url().optional().describe("Adresse ABSOLUE où le fournisseur renvoie le navigateur après la déconnexion (`post_logout_redirect_uri`, OpenID Connect RP-Initiated Logout) — doit être enregistrée chez lui. OMIS = l'écran d'échec (`failureRedirect`, la page de connexion) résolu contre `redirectUri`. Sans effet pour un fournisseur qui ne publie pas de point de déconnexion."),
 	defaultRoles: z.array(z.string()).optional().describe("Rôles du Shadow User à la création — surcharge le global pour CE fournisseur."),
+	roleMapping: z.record(z.string().min(1), z.string().min(1)).optional().describe("Rôles du FOURNISSEUR traduits en rôles de l'application, recalculés à chaque connexion ET à chaque jeton présenté à l'API : `{ \"app-admin\": \"ROLE_ADMIN\" }`. Un rôle du fournisseur absent de la table est ignoré, jamais recopié. Les rôles donnés à la main sont conservés. OMIS = les rôles restent entièrement locaux (posés à la création, puis la base fait foi). Un rôle `ROLE_NODEFONY_*` refuse le démarrage, sauf `allowPlatformRoles`."),
+	audiences: z.array(z.string().min(1)).optional().describe("Ressources pour lesquelles CE fournisseur émet des jetons à l'application — la mention « valable pour » (`aud`) qu'il doit imprimer. Chaque entrée est la `resource` d'une zone `external-jwt`. Lue par `security:keycloak:realm`, qui en écrit les mappers d'audience ; sans effet sur la vérification, que la `resource` de la zone porte seule. OMIS = la `resource` de TOUTES les zones `external-jwt`. À écrire dès qu'une zone existe pour REFUSER les jetons de ce fournisseur : la déduire ferait imprimer son adresse."),
+	allowPlatformRoles: z.boolean().default(false).describe("Autorise `roleMapping` à accorder des rôles de PLATEFORME (`ROLE_NODEFONY_*` : console d'administration, génération de code, secrets). OMIS = refusé au démarrage. L'ouvrir fait de l'administrateur de l'annuaire un administrateur de l'instance, et d'un annuaire compromis une prise de contrôle complète — rappelé à chaque démarrage, en avertissement en production, en information ailleurs."),
+	rolesSource: z.array(z.enum([
+		"client",
+		"realm",
+		"groups"
+	])).min(1).optional().describe("Où lire les rôles du fournisseur pour `roleMapping`. `client` (défaut) : les rôles du client de CETTE application (`resource_access.<clientId>.roles`, Keycloak). `realm` : les rôles du realm (`realm_access.roles`). `groups` : le claim `groups` (mapper de groupes à poser chez le fournisseur). Sans `roleMapping`, sans effet."),
 	label: z.string().min(1).optional().describe("Libellé du bouton sur l'écran de connexion. OMIS = dérivé du nom du fournisseur (`keycloak` → « Keycloak », `oidc` → « OIDC », `mon-idp` → « Mon Idp »). À poser quand la marque ne se devine pas du nom de la clé (« Connexion agent », « Annuaire interne »)."),
+	icon: z.string().min(1).optional().describe("Image du bouton sur l'écran de connexion (chemin servi par l'application, ou URL autorisée par la CSP `img-src`). OMIS = icône du framework : la marque pour `github`, une clé sinon."),
+	admin: z.strictObject({
+		username: z.string().min(1).describe("Identifiant administrateur."),
+		password: z.string().min(1).describe("Mot de passe administrateur — SECRET, jamais loggé.")
+	}).optional().describe("DÉVELOPPEMENT seulement — compte d'administration du serveur Keycloak (realm `master`). Sert à poser le thème de connexion qui suit `loginPage.skin` sur un realm EXISTANT (`security:keycloak:realm --apply`, aperçu de `/login`), ce que le fichier d'import ne fait pas. Refusé hors développement : ne le passer qu'en `ctx.isDev`."),
 	hidden: z.boolean().default(false).describe("Retire le bouton de l'écran de connexion SANS désactiver le fournisseur : le flux `/authorize` reste ouvert et fonctionnel. C'est la seule différence avec le fait de ne pas le configurer. Deux usages : une FIXTURE de développement qui pointe vers un serveur fictif (bouton mort), et un fournisseur réservé à un point d'entrée particulier (lien direct, sous-domaine) plutôt qu'offert à tout visiteur.")
+}).superRefine((provider, ctx) => {
+	if (provider.allowPlatformRoles) return;
+	for (const [from, to] of Object.entries(provider.roleMapping ?? {})) {
+		if (!isPlatformRole(to)) continue;
+		ctx.addIssue({
+			code: "custom",
+			path: ["roleMapping", from],
+			message: `« ${to} » est un rôle de PLATEFORME (${PLATFORM_ROLE_PREFIX}*) : un annuaire externe ne l'accorde pas sans \`allowPlatformRoles: true\` écrit sur ce fournisseur. Sinon, le donner à la main (\`security:user:add --admin\`, console d'administration) — il survit alors à chaque connexion.`
+		});
+	}
 }).describe("Fournisseur OAuth/OIDC (secrets via env).");
 const oauth2Schema = z.strictObject({
 	enabled: z.boolean().default(true).describe("Active le social login (les routes ne montent que si ≥1 provider)."),
-	defaultRoles: z.array(z.string()).default(["ROLE_USER"]).describe("Rôles du Shadow User à la CRÉATION uniquement (OAuth = authentification, pas autorisation : les rôles ne sont jamais réécrits ensuite, la base fait foi)."),
+	defaultRoles: z.array(z.string()).default(["ROLE_USER"]).describe("Rôles du Shadow User à la CRÉATION uniquement. Les rôles ne sont jamais réécrits ensuite, la base fait foi — sauf ceux qu'un fournisseur gère par sa `roleMapping`."),
 	allowSignup: z.boolean().default(true).describe("true = crée une ligne locale au 1er login (JIT, Shadow User). false = un compte préexistant lié est requis (fail-closed)."),
 	successRedirect: z.string().default("/").describe("Redirection après login réussi."),
-	failureRedirect: z.string().default("/login").describe("Redirection après échec (state invalide, refus utilisateur...)."),
+	failureRedirect: z.string().optional().describe("Redirection après échec (state invalide, refus utilisateur...). Omis = la page de connexion (`loginPage.path`)."),
 	providers: z.record(z.string(), oauthProviderSchema).default({}).describe("Fournisseurs activés par nom (doit correspondre au registre : builtins google/keycloak/oidc/github ; tout autre serveur OpenID Connect en enregistrant une fabrique, décrit par son seul émetteur).")
 }).describe("Social login OAuth 2.0 — Authorization Code + PKCE, session BFF.");
 /**
+* Qui peut OBTENIR un scope d'application — appliqué par CHAQUE émetteur de
+* l'application (jeton d'accès, clé API), jamais par une zone : un jeton ne
+* sait pas quelle zone le lira, et `security:mcp:token` signe sans requête.
+*/
+const grantableScopesSchema = z.record(z.string(), z.array(z.string().min(1)).min(1, "au moins un rôle — pour n'accorder ce scope à personne, ne pas l'exposer")).superRefine((grants, ctx) => {
+	for (const key of Object.keys(grants)) {
+		const problem = scopeGrantKeyProblem(key);
+		if (problem !== null) ctx.addIssue({
+			code: "custom",
+			path: [key],
+			message: `« ${key} » ${problem}`
+		});
+	}
+}).default({}).describe("Qui peut OBTENIR un scope d'application. Clé : un scope exact (`vitrine:write`) ou une famille (`shop:*`) ; valeur : les rôles dont UN suffit, hiérarchie de rôles comprise. Une clé exacte l'emporte sur une famille, la famille la plus longue sur une plus courte. Un scope qu'aucune clé ne couvre reste accordé à tout compte connecté. Appliqué par chaque émetteur de CETTE application : un jeton d'accès est émis sans les scopes refusés (RFC 6749 §3.3, nommés au journal), une clé API demandée avec l'un d'eux est refusée (403). Ne borne PAS les jetons d'un émetteur tiers (Keycloak…), qui signe selon sa propre politique. `admin:read`, `admin:write` et `admin:*` sont refusés au démarrage : réservés au framework. Un module peut compléter cette section par `module-security` ; un préfixe = un propriétaire, car la fusion de configuration fusionne les listes case par case (`[\"A\",\"B\"]` surchargé par `[\"C\"]` donne `[\"C\",\"B\"]`).");
+/**
 * Règle d'autorisation d'un **namespace de canaux WebSocket** (subscribe/inbound)
 * par préfixe. Contraintes cumulatives ; un champ absent = pas de contrainte sur
 * cet axe. Étend OU surcharge les défauts système (placée AVANT eux à l'évaluation).
@@ -336,6 +425,7 @@ const realtimeChannelRuleSchema = z.strictObject({
 const securityConfigSchema = z.strictObject({
 	encoders: z.record(z.string(), encoderSchema).default(() => ({ default: encoderSchema.parse({ type: "argon2id" }) })).describe("Chaîne d'encodeurs de mot de passe. 1re entrée = principal (hash à la création), suivantes = legacy en lecture seule (migration au login). Défaut : un argon2id sûr — le firewall en dérive le service `passwordEncoder`."),
 	roleHierarchy: z.record(z.string(), z.array(z.string())).default({}).describe("Hiérarchie de rôles (ROLE_ADMIN: ['ROLE_USER'])."),
+	grantableScopes: grantableScopesSchema,
 	areas: z.record(z.string(), areaSchema).default({}).describe("Zones sécurisées (firewall) par nom."),
 	realtimeChannels: z.array(realtimeChannelRuleSchema).default([]).describe("Politiques d'autorisation par préfixe sur le temps réel. Couvre les canaux WS (subscribe/inbound) **ET les actions RPC** : le nom de méthode d'une frame entrante est soumis aux mêmes règles de préfixe — une règle `admin:` garde donc aussi l'action `admin:purge`. Étend/surcharge les défauts système (syslog:/orm:/node:/dashboard:/debugbar:/realtime:/cluster: + :health/:stats = ROLE_NODEFONY_ADMIN, l'échelle PLATEFORME : ces canaux exposent l'état du processus, pas celui d'une application). Ce qui n'est couvert par aucune règle reste libre, sauf gating `@RealtimeChannel` côté controller."),
 	cors: corsSchema.default(() => corsSchema.parse({})),
@@ -352,6 +442,8 @@ const securityConfigSchema = z.strictObject({
 		description: "RÉSERVÉ — Token Exchange RFC 8693 (délégation agents/MCP). Slot P12, aucun champ encore lu par le runtime."
 	}),
 	oauth2: oauth2Schema.default(() => oauth2Schema.parse({})),
+	loginPage: loginPageSchema.default(() => loginPageSchema.parse({})),
+	allowInsecureCredentials: z.boolean().default(false).describe("Laisse passer, en production, un mot de passe ou un code de second facteur reçu en clair (HTTP). false (défaut) : refus 403 AVANT toute vérification, sur toutes les portes — formulaire de session, second facteur, Basic, émission de jeton. Le refus se décide sur le scheme EFFECTIF : derrière un proxy qui termine TLS, déclarer ce proxy de confiance (`trustProxy` de @nodefony/http) suffit, et c'est la bonne réponse — pas cette clé. Ne la passer à true que pour un réseau où le clair est un choix assumé (maillage chiffré au niveau inférieur). Hors production, sans effet."),
 	apiKeys: apiKeysSchema.default(() => apiKeysSchema.parse({})),
 	webhooks: webhooksSchema.default(() => webhooksSchema.parse({})),
 	audit: auditSchema.default(() => auditSchema.parse({})),
@@ -366,5 +458,4 @@ const securityConfigSchema = z.strictObject({
 * construction ; passés au `super(..., config)` du Module class.
 */
 const config = securityConfigSchema.parse({});
-//#endregion
 export { config as default, securityConfigSchema };

package/dist/nodefony/config/defineModuleConfig.js

@@ -1,7 +1,7 @@
 import { securityConfigSchema } from "./config.js";
 import { BootConfigurationError, parseModuleConfig } from "nodefony";
 import { z } from "zod";
-//#region nodefony/config/defineModuleConfig.ts
+// nodefony/config/defineModuleConfig.ts
 /**
 * Valide + normalise + gèle la configuration de sécurité.
 *
@@ -31,5 +31,4 @@ function detectConflicts(areas) {
 		seen.set(area.pattern, name);
 	}
 }
-//#endregion
 export { defineSecurityConfig, securityConfigJsonSchema };

package/dist/nodefony/contracts/IAccessVoter.js

@@ -1,4 +1,4 @@
-//#region nodefony/contracts/IAccessVoter.ts
+// nodefony/contracts/IAccessVoter.ts
 /**
 * Vote d'un {@link IAccessVoter}. Stratégie firewall = affirmative + DENY veto :
 * un seul DENY bloque ; sinon un GRANT suffit ; tous ABSTAIN → DENY (Zero Trust).
@@ -9,5 +9,4 @@ let VoterVote = /* @__PURE__ */ function(VoterVote) {
 	VoterVote["ABSTAIN"] = "ABSTAIN";
 	return VoterVote;
 }({});
-//#endregion
 export { VoterVote };

package/dist/nodefony/contracts/index.js

@@ -1,2 +1 @@
-import { VoterVote } from "./IAccessVoter.js";
-export { VoterVote };
+export { VoterVote } from "./IAccessVoter.js";

package/dist/nodefony/errors/AccessDeniedError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/AccessDeniedError.ts
+// nodefony/errors/AccessDeniedError.ts
 /**
 * Accès refusé — `code = 403`. Levée par l'autorisation (un `@IsGranted` non
 * satisfait, un voter DENY) : l'utilisateur EST authentifié mais n'a pas le droit.
@@ -10,5 +10,4 @@ var AccessDeniedError = class extends nodefonyError {
 		super(message, 403);
 	}
 };
-//#endregion
 export { AccessDeniedError, AccessDeniedError as default };

package/dist/nodefony/errors/ApiKeyError.js

@@ -1,11 +1,13 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/ApiKeyError.ts
+// nodefony/errors/ApiKeyError.ts
 /**
 * Erreur de **gestion** d'une clé API (création/révocation) — porte un `code`
 * HTTP que l'adaptateur framework mappe par duck-typing (il n'importe jamais les
 * classes de `@nodefony/security`).
 *
 *  - `400` — entrée invalide (nom vide, scope hors catalogue) ;
+*  - `403` — scope demandé que le porteur ne peut pas obtenir (`grantableScopes`,
+*    ou `admin:*` sans le rôle d'administration) ;
 *  - `409` — plafond `apiKeys.maxPerSubject` atteint ;
 *  - `503` — store de jetons indisponible (clés activées mais non provisionnées).
 *
@@ -17,5 +19,4 @@ var ApiKeyError = class extends nodefonyError {
 		super(message, code);
 	}
 };
-//#endregion
 export { ApiKeyError, ApiKeyError as default };

package/dist/nodefony/errors/AuthenticationError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/AuthenticationError.ts
+// nodefony/errors/AuthenticationError.ts
 /**
 * Échec d'authentification — `code = 401`. Levée par un {@link IAuthenticator}
 * quand le credential est absent/invalide, ou par le firewall en Zero Trust
@@ -10,5 +10,4 @@ var AuthenticationError = class extends nodefonyError {
 		super(message, 401);
 	}
 };
-//#endregion
 export { AuthenticationError, AuthenticationError as default };

package/dist/nodefony/errors/CsrfError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/CsrfError.ts
+// nodefony/errors/CsrfError.ts
 /**
 * Mutation cross-site bloquée — `code = 403` (RFC 9110 §15.5.4 : le serveur a
 * compris la requête mais refuse de l'honorer).
@@ -19,5 +19,4 @@ var CsrfError = class extends nodefonyError {
 		super(message, 403);
 	}
 };
-//#endregion
 export { CsrfError, CsrfError as default };

package/dist/nodefony/errors/InsecureTransportError.js

@@ -0,0 +1,23 @@
+import { INSECURE_TRANSPORT_MESSAGE, nodefonyError } from "nodefony";
+// nodefony/errors/InsecureTransportError.ts
+/**
+* Secret refusé parce qu'il arrive en clair — `code = 403` (RFC 9110 §15.5.4 :
+* le serveur a compris la requête mais refuse de l'honorer).
+*
+* Message constant ({@link INSECURE_TRANSPORT_MESSAGE}, cœur) : le navigateur
+* le reconnaît, et il ne dit rien de la topologie.
+*
+* Levée AVANT toute vérification, quand un mot de passe ou un code de second
+* facteur arrive en production sur une requête dont le scheme effectif n'est
+* pas `https` (cf {@link CredentialTransportPolicy}). Ce n'est pas un 401 :
+* aucune preuve n'a été jugée, et rien de ce que le client corrigera dans son
+* secret ne changera la réponse — c'est le canal qu'il doit changer. Pas de
+* `WWW-Authenticate` non plus : un défi Basic ferait rouvrir au navigateur la
+* fenêtre qui renverrait le mot de passe par le même canal.
+*/
+var InsecureTransportError = class extends nodefonyError {
+	constructor() {
+		super(INSECURE_TRANSPORT_MESSAGE, 403);
+	}
+};
+export { InsecureTransportError, InsecureTransportError as default };

package/dist/nodefony/errors/InvalidTargetError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/InvalidTargetError.ts
+// nodefony/errors/InvalidTargetError.ts
 /**
 * La ressource demandée à l'émission ne peut pas être servie — `code = 400`,
 * code d'erreur OAuth `invalid_target` (RFC 8707 §2).
@@ -35,5 +35,4 @@ var InvalidTargetError = class extends nodefonyError {
 		this.requested = requested;
 	}
 };
-//#endregion
 export { InvalidTargetError, InvalidTargetError as default };

package/dist/nodefony/errors/SsrfError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/SsrfError.ts
+// nodefony/errors/SsrfError.ts
 /**
 * URL rejetée par la protection SSRF — `code = 422`. Levée quand une URL sortante
 * (endpoint webhook, fetch applicatif…) est syntaxiquement valide mais cible une
@@ -13,5 +13,4 @@ var SsrfError = class extends nodefonyError {
 		super(message, 422);
 	}
 };
-//#endregion
 export { SsrfError, SsrfError as default };

package/dist/nodefony/errors/ThrottledError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/ThrottledError.ts
+// nodefony/errors/ThrottledError.ts
 /**
 * Tentatives de login trop rapprochées — `code = 429` (RFC 6585 §4).
 *
@@ -17,5 +17,4 @@ var ThrottledError = class extends nodefonyError {
 		this.retryAfterS = retryAfterS;
 	}
 };
-//#endregion
 export { ThrottledError, ThrottledError as default };

package/dist/nodefony/errors/UnverifiableTokenError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/UnverifiableTokenError.ts
+// nodefony/errors/UnverifiableTokenError.ts
 /**
 * Le jeton n'a pas pu être VÉRIFIÉ — `code = 503`, et surtout **pas 401**.
 *
@@ -38,5 +38,4 @@ var UnverifiableTokenError = class extends nodefonyError {
 		this.detail = detail;
 	}
 };
-//#endregion
 export { UnverifiableTokenError, UnverifiableTokenError as default };

package/dist/nodefony/errors/WebAuthnError.js

@@ -1,5 +1,5 @@
 import { nodefonyError } from "nodefony";
-//#region nodefony/errors/WebAuthnError.ts
+// nodefony/errors/WebAuthnError.ts
 /**
 * Erreur de **gestion** d'un credential WebAuthn (enrôlement) — porte un `code`
 * HTTP que l'adaptateur framework mappe par duck-typing (il n'importe jamais les
@@ -17,5 +17,4 @@ var WebAuthnError = class extends nodefonyError {
 		super(message, code);
 	}
 };
-//#endregion
 export { WebAuthnError, WebAuthnError as default };

package/dist/nodefony/errors/index.js

@@ -1,3 +1,4 @@
+import { InsecureTransportError } from "./InsecureTransportError.js";
 import { CsrfError } from "./CsrfError.js";
 import { AuthenticationError } from "./AuthenticationError.js";
 import { ThrottledError } from "./ThrottledError.js";
@@ -6,4 +7,4 @@ import { InvalidTargetError } from "./InvalidTargetError.js";
 import { WebAuthnError } from "./WebAuthnError.js";
 import { SsrfError } from "./SsrfError.js";
 import { AccessDeniedError } from "./AccessDeniedError.js";
-export { AccessDeniedError, AuthenticationError, CsrfError, InvalidTargetError, SsrfError, ThrottledError, UnverifiableTokenError, WebAuthnError };
+export { AccessDeniedError, AuthenticationError, CsrfError, InsecureTransportError, InvalidTargetError, SsrfError, ThrottledError, UnverifiableTokenError, WebAuthnError };