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

package/dist/nodefony/service/totp.js

@@ -1,4 +1,6 @@
 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";
@@ -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) {

package/dist/nodefony/service/webAuthn.js

@@ -3,12 +3,30 @@ 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 { createHash } from "node:crypto";
 import { Buffer } from "node:buffer";
 //#region 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).
@@ -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,
@@ -348,4 +366,4 @@ var WebAuthnService = class extends Service {
 	}
 };
 //#endregion
-export { WebAuthnService, WebAuthnService as default };
+export { WebAuthnService, WebAuthnService as default, userHandleBytes };

package/dist/nodefony/src/SecuredArea.js

@@ -1,3 +1,4 @@
+import { stripTrailingSlashes } from "nodefony";
 //#region 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) {

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

@@ -99,6 +99,39 @@ function parseAuditQuery(query) {
 	if (page.cursor !== void 0) filter.cursor = page.cursor;
 	return filter;
 }
+/**
+* Traduit l'`id` d'un compte (paramètre `{id}` d'une route admin) en sa **clé de
+* sujet** `IUser.identifier` — la clé sous laquelle vivent ses facteurs (TOTP,
+* passkeys), sa session et ses jetons.
+*
+* Viser un store avec l'`id` brut agit sur une clé qui n'existe pas et rend un
+* succès : l'administrateur croit avoir débloqué un compte resté bloqué. D'où
+* le 503 quand le service `users` manque — sans lui, l'`id` ne se traduit pas.
+*
+* @param container - container du kernel (service `users`).
+* @param id - paramètre `{id}` de la route.
+* @returns le compte (`id` + `identifier`), ou la réponse d'erreur à rendre (404/503).
+*/
+async function resolveSubject(container, id) {
+	if (typeof id !== "string" || id.length === 0) return {
+		status: 404,
+		body: { error: "not found" }
+	};
+	const users = container.get("users");
+	if (!users) return {
+		status: 503,
+		body: { error: "users unavailable" }
+	};
+	const user = await users.findById(id);
+	if (!user || typeof user.identifier !== "string") return {
+		status: 404,
+		body: { error: "not found" }
+	};
+	return {
+		id,
+		identifier: user.identifier
+	};
+}
 /** Projette un credential serveur vers sa vue admin (sans `publicKey`/`userId`). */
 function toCredentialView(c) {
 	return {
@@ -170,6 +203,25 @@ function createSecurityAdminApi(container) {
 				return firewall.describe();
 			}
 		},
+		{
+			path: "oauth/diagnosis",
+			method: "GET",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Diagnostic des fournisseurs OAuth sans connexion humaine : émetteur, URL de retour, secret (?provider=<nom>). Interroge les fournisseurs à chaque appel ; aucun secret rendu.",
+			handler: async (request) => {
+				const oauth = container.get("oauth2");
+				if (!oauth || !oauth.isEnabled()) return {
+					enabled: false,
+					providers: []
+				};
+				const raw = request.query.provider;
+				const provider = typeof raw === "string" && raw !== "" ? raw : void 0;
+				return {
+					enabled: true,
+					providers: await oauth.diagnose(provider)
+				};
+			}
+		},
 		{
 			path: "roleHierarchy",
 			method: "GET",
@@ -324,17 +376,9 @@ function createSecurityAdminApi(container) {
 					status: 503,
 					body: { error: "webauthn unavailable" }
 				};
-				const id = request.params.id;
-				if (typeof id !== "string" || id.length === 0) return {
-					status: 404,
-					body: { error: "not found" }
-				};
-				const users = container.get("users");
-				if (users && !await users.findById(id)) return {
-					status: 404,
-					body: { error: "not found" }
-				};
-				return { credentials: (await svc.listUserCredentials(id)).map(toCredentialView) };
+				const account = await resolveSubject(container, request.params.id);
+				if (!("identifier" in account)) return account;
+				return { credentials: (await svc.listUserCredentials(account.identifier)).map(toCredentialView) };
 			}
 		},
 		{
@@ -348,13 +392,14 @@ function createSecurityAdminApi(container) {
 					status: 503,
 					body: { error: "webauthn unavailable" }
 				};
-				const id = request.params.id;
 				const credentialId = request.params.credentialId;
-				if (typeof id !== "string" || id.length === 0 || typeof credentialId !== "string" || credentialId.length === 0) return {
+				if (typeof credentialId !== "string" || credentialId.length === 0) return {
 					status: 404,
 					body: { error: "not found" }
 				};
-				if (!await svc.removeUserCredential(id, credentialId)) return {
+				const account = await resolveSubject(container, request.params.id);
+				if (!("identifier" in account)) return account;
+				if (!await svc.removeUserCredential(account.identifier, credentialId)) return {
 					status: 404,
 					body: { error: "not found" }
 				};
@@ -363,7 +408,7 @@ function createSecurityAdminApi(container) {
 					action: "user.passkey_revoked",
 					outcome: "success",
 					actor: adminActor(request.user),
-					resource: id,
+					resource: account.id,
 					metadata: {
 						credentialId,
 						viaAdmin: true
@@ -381,7 +426,8 @@ function createSecurityAdminApi(container) {
 				const svc = container.get("totp");
 				const pageQuery = parsePageQuery(request.query, {
 					defaultLimit: KEYS_DEFAULT_LIMIT,
-					maxLimit: KEYS_MAX_LIMIT
+					maxLimit: KEYS_MAX_LIMIT,
+					searchable: true
 				});
 				const limit = pageQuery.limit;
 				const offset = pageQuery.offset ?? 0;
@@ -393,7 +439,7 @@ function createSecurityAdminApi(container) {
 					offset
 				};
 				const confirmed = one(request.query, "confirmed");
-				const q = one(request.query, "q");
+				const q = pageQuery.q;
 				const page = await svc.listPage({
 					limit,
 					offset,
@@ -420,17 +466,9 @@ function createSecurityAdminApi(container) {
 					status: 503,
 					body: { error: "totp unavailable" }
 				};
-				const id = request.params.id;
-				if (typeof id !== "string" || id.length === 0) return {
-					status: 404,
-					body: { error: "not found" }
-				};
-				const users = container.get("users");
-				if (users && !await users.findById(id)) return {
-					status: 404,
-					body: { error: "not found" }
-				};
-				return svc.status(id);
+				const account = await resolveSubject(container, request.params.id);
+				if (!("identifier" in account)) return account;
+				return svc.status(account.identifier);
 			}
 		},
 		{
@@ -444,23 +482,15 @@ function createSecurityAdminApi(container) {
 					status: 503,
 					body: { error: "totp unavailable" }
 				};
-				const id = request.params.id;
-				if (typeof id !== "string" || id.length === 0) return {
-					status: 404,
-					body: { error: "not found" }
-				};
-				const users = container.get("users");
-				if (users && !await users.findById(id)) return {
-					status: 404,
-					body: { error: "not found" }
-				};
-				await svc.disable(id);
+				const account = await resolveSubject(container, request.params.id);
+				if (!("identifier" in account)) return account;
+				await svc.disable(account.identifier);
 				auditAdmin(container, {
 					category: "auth",
 					action: "user.totp_disabled",
 					outcome: "success",
 					actor: adminActor(request.user),
-					resource: id,
+					resource: account.id,
 					metadata: { viaAdmin: true }
 				});
 				return { ok: true };

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

@@ -16,7 +16,6 @@
 function adminActor(user) {
 	if (user && typeof user === "object") {
 		const u = user;
-		if (typeof u.username === "string" && u.username) return u.username;
 		if (typeof u.identifier === "string" && u.identifier) return u.identifier;
 	}
 	return "admin";

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

@@ -1,15 +1,22 @@
-import { USER_REVOKED_EVENT } from "@nodefony/user";
+import { USER_CREATED_EVENT, USER_REVOKED_EVENT } from "@nodefony/user";
 //#region nodefony/src/admin/userRevocationCascade.ts
 /**
 * Cascade de révocation déclenchée par {@link USER_REVOKED_EVENT} : éjecte
 * **immédiatement** les artefacts d'accès du porteur — ses **sessions** (http,
 * `destroyByUser`) et ses **jetons/PAT** (`tokenStore.revokeAllForSubject`,
-* seuil `invalidBefore`). Best-effort par brique (une indispo n'empêche pas
-* l'autre) — l'accès était DÉJÀ neutralisé par le re-fetch des authenticators,
-* cette cascade est de la **propreté + défense en profondeur**, jamais l'unique
-* rempart. `tenantId` du payload est réservé (scoping non câblé en mono-tenant).
+* seuil `invalidBefore`, qui couvre aussi les clés d'API). Best-effort par
+* brique (une indispo n'empêche pas l'autre) — l'accès était DÉJÀ neutralisé par
+* le re-fetch des authenticators. `tenantId` du payload est réservé (scoping non
+* câblé en mono-tenant).
 *
-* @param container - container du kernel (résolution lazy de `sessions`/`tokenStore`).
+* **Suppression du compte** (`reason: "deleted"`) : retire AUSSI ses facteurs —
+* secret TOTP (codes de récupération compris) et passkeys. Ils sont rangés sous
+* l'`identifier`, qu'un compte recréé peut reprendre : laissés en place, le
+* nouveau titulaire hériterait du second facteur de l'ancien. Un compte
+* seulement désactivé ou verrouillé les GARDE — il les retrouve à sa
+* réactivation.
+*
+* @param container - container du kernel (résolution lazy de `sessions`, `tokenStore`, `totp`, `webauthn`).
 * @param event - charge utile de l'événement (porteur + raison).
 * @param now - horloge (epoch ms) injectable pour les tests.
 */
@@ -21,20 +28,77 @@ async function cascadeUserRevocation(container, event, now = Date.now()) {
 	try {
 		await container.get("tokenStore")?.revokeAllForSubject(identifier, now);
 	} catch {}
+	if (event.reason === "deleted") await removeAccountFactors(container, identifier);
 }
 /**
-* Abonne la cascade au bus kernel. À appeler au `onKernelBoot` d'un module
-* bootable (ici `@nodefony/security`). **Extensible** : tout autre module
-* (webhooks…) peut s'abonner au MÊME `USER_REVOKED_EVENT` pour ses propres
-* artefacts, sans toucher à ce fichier.
+* Retire les facteurs rangés sous un identifiant — secret TOTP (codes de
+* récupération compris) et passkeys. SEULE implémentation du geste, appelée à
+* la suppression d'un compte ET à la création d'un compte sous cet identifiant.
+* Best-effort par brique : un TOTP indisponible n'empêche pas le retrait des
+* passkeys.
+*
+* @param container - container du kernel (services `totp`, `webauthn`).
+* @param identifier - `IUser.identifier` du compte.
+*/
+async function removeAccountFactors(container, identifier) {
+	try {
+		const totp = container.get("totp");
+		if (totp?.isEnabled?.() !== false) await totp?.disable?.(identifier);
+	} catch {}
+	try {
+		const webauthn = container.get("webauthn");
+		if (webauthn?.isEnabled?.() !== false) {
+			const creds = await webauthn?.listUserCredentials?.(identifier) ?? [];
+			for (const cred of creds) await webauthn?.removeUserCredential?.(identifier, cred.id);
+		}
+	} catch {}
+}
+/** Garde : charge utile de {@link USER_CREATED_EVENT} (identifiant non vide). */
+function isUserCreatedEvent(value) {
+	return typeof value === "object" && value !== null && "identifier" in value && typeof value.identifier === "string" && value.identifier.length > 0;
+}
+/**
+* Abonne la cascade au bus kernel, UNE fois, au `onKernelBoot` de
+* `@nodefony/security` — avant qu'aucun compte ne puisse être créé ou révoqué
+* (les comptes semés au démarrage compris). Deux abonnements :
+*  - {@link USER_REVOKED_EVENT} → {@link cascadeUserRevocation} ;
+*  - {@link USER_CREATED_EVENT} → purge des facteurs HÉRITÉS : un compte qui
+*    vient de naître n'a encore rien enrôlé, donc tout facteur déjà rangé sous
+*    son identifiant appartient à un ancien titulaire. Règle exacte, aucune
+*    date à comparer. ⚠️ Un import qui chargerait les facteurs AVANT les
+*    comptes les verrait retirés : importer les comptes d'abord.
+*
+* Les deux sont émis par `UserService` seul, et attendus : chaque handler rend
+* sa promesse. **Extensible** : tout autre module (webhooks…) s'abonne aux
+* MÊMES événements pour ses propres artefacts, sans toucher à ce fichier.
 *
 * @param kernel - bus d'événements (kernel) exposant `on`.
-* @param container - container capturé par le handler.
+* @param container - container capturé par les handlers.
 */
 function registerUserRevocationCascade(kernel, container) {
-	kernel.on(USER_REVOKED_EVENT, (event) => {
-		cascadeUserRevocation(container, event);
-	});
+	kernel.on(USER_REVOKED_EVENT, (event) => cascadeUserRevocation(container, event));
+	kernel.on(USER_CREATED_EVENT, (event) => isUserCreatedEvent(event) ? removeAccountFactors(container, event.identifier) : void 0);
+}
+/**
+* Avis de démarrage quand le service `users` n'émet pas sur le bus du kernel —
+* construit sans container (`new UserService(repo, encoder)`). Ses événements
+* partent alors sur son propre bus, où personne n'écoute : supprimer un compte
+* laisserait ses sessions, ses jetons et ses facteurs en place, SANS UN MOT.
+*
+* @param container - container du kernel.
+* @param kernel - le kernel attendu comme bus des événements.
+* @returns l'avis à déclarer, ou `null` si `users` est absent ou bien câblé.
+*/
+function usersEventBusNotice(container, kernel) {
+	const users = container.get("users");
+	if (typeof users !== "object" || users === null) return null;
+	if (!("kernel" in users) || users.kernel === kernel) return null;
+	return {
+		code: "USERS_SERVICE_WITHOUT_KERNEL",
+		level: "warning",
+		message: "le service « users » n'atteint pas le kernel : supprimer, désactiver un compte ou changer son mot de passe ne révoquera ni ses sessions, ni ses jetons, ni ses facteurs.",
+		fix: "new UserService(repository, encoder, module.container)"
+	};
 }
 //#endregion
-export { cascadeUserRevocation, registerUserRevocationCascade };
+export { cascadeUserRevocation, registerUserRevocationCascade, removeAccountFactors, usersEventBusNotice };

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

@@ -1,3 +1,4 @@
+import { mapProviderRoles } from "../oauth/providerRoles.js";
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { UnverifiableTokenError } from "../../errors/UnverifiableTokenError.js";
 import { UserToken } from "../token/UserToken.js";
@@ -16,6 +17,11 @@ const INVALID_TOKEN = "Invalid token";
 /** Clé de transport de l'audience entre `createToken` et `authenticate`. */
 const AUDIENCE = "audience";
 /**
+* Clé de transport de la zone qui SURCHARGE la politique de rattachement.
+* Posée seulement par ces zones-là : les autres ne paient rien de plus.
+*/
+const SUBJECT_AREA = "subjectArea";
+/**
 * Authentification par **jeton d'accès émis par un serveur d'autorisation
 * TIERS** (Keycloak, Auth0, Entra, ou l'émetteur d'une flotte d'agents).
 *
@@ -58,6 +64,10 @@ var ExternalJwtAuthenticator = class {
 	#issuers;
 	#policy;
 	#ephemeralRoles;
+	/** Émetteur canonique → fournisseur de connexion ; `null` = aucun lien. */
+	#linkedProviders;
+	/** Fournisseur de connexion → table des rôles ; `null` = aucune table. */
+	#roleMappings;
 	#userProvider = null;
 	/**
 	* @param container - container DI (résolution lazy du vérificateur et de `users`)
@@ -74,6 +84,8 @@ var ExternalJwtAuthenticator = class {
 		this.#issuers = issuers;
 		this.#policy = options.subjectPolicy;
 		this.#ephemeralRoles = options.ephemeralRoles;
+		this.#linkedProviders = linkProviders(issuers, options.oauthProviders);
+		this.#roleMappings = collectRoleMappings(options.oauthProviders);
 	}
 	/**
 	* La requête porte-t-elle un jeton se réclamant d'un émetteur de confiance ?
@@ -108,6 +120,7 @@ var ExternalJwtAuthenticator = class {
 		const token = new UserToken("external-jwt", bearerToken(auth) ?? "");
 		const area = context.security;
 		if (area?.resource) token.setAttribute(AUDIENCE, area.resource);
+		if (area?.subjectPolicy !== void 0) token.setAttribute(SUBJECT_AREA, area);
 		return Promise.resolve(token);
 	}
 	/**
@@ -136,7 +149,7 @@ var ExternalJwtAuthenticator = class {
 		if (!subject) throw new AuthenticationError(INVALID_TOKEN);
 		const mapping = this.#issuers.get(principal.issuer);
 		if (mapping === void 0) throw new UnverifiableTokenError(`émetteur « ${principal.issuer} » vérifié mais absent de la table de rattachement des sujets — configuration incohérente.`);
-		const user = await this.#resolveUser(principal.issuer, subject, mapping);
+		const user = await this.#resolveUser(principal.issuer, subject, mapping, principal.claims, token.getAttribute(SUBJECT_AREA));
 		const ut = token;
 		ut.promote(user);
 		ut.setAttribute("scopes", [...principal.scopes]);
@@ -194,16 +207,21 @@ var ExternalJwtAuthenticator = class {
 	* nous, est cette personne ? » et « quel pouvoir accorde-t-on à une machine
 	* que l'annuaire a authentifiée ? ».
 	*/
-	async #resolveUser(issuer, subject, mapping) {
+	async #resolveUser(issuer, subject, mapping, claims, area) {
 		const identifier = localIdentifierFor(issuer, subject, mapping);
-		if (this.#policy === "ephemeral") return new BaseUser({
+		if ((area?.subjectPolicy ?? this.#policy) === "ephemeral") return new BaseUser({
 			id: identifier,
 			identifier,
-			roles: [...this.#ephemeralRoles]
+			roles: [...area?.ephemeralRoles ?? this.#ephemeralRoles]
 		});
 		const provider = this.#resolveUserProvider();
-		let user;
-		try {
+		let user = null;
+		const linked = this.#linkedProviders?.get(issuer);
+		if (linked !== void 0) try {
+			const roleMapping = this.#roleMappings?.get(linked);
+			user = roleMapping !== void 0 && canSyncRoles(provider) ? await provider.syncOAuthRoles(linked, subject, mapProviderRoles(roleMapping, claims)) : await provider.loadUserByOAuth(linked, subject);
+		} catch {}
+		if (user === null) try {
 			user = await provider.loadUserByIdentifier(identifier);
 		} catch {
 			throw new AuthenticationError(INVALID_TOKEN);
@@ -220,5 +238,47 @@ var ExternalJwtAuthenticator = class {
 		return this.#userProvider;
 	}
 };
+/** Le fournisseur d'utilisateurs sait-il recalculer les rôles gérés par un annuaire ? */
+function canSyncRoles(provider) {
+	return typeof provider.syncOAuthRoles === "function";
+}
+/** Tables de rôles par fournisseur de connexion — `null` quand aucun n'en déclare. */
+function collectRoleMappings(providers) {
+	if (!providers) return null;
+	let mappings = null;
+	for (const { name, roleMapping } of providers) {
+		if (roleMapping == null) continue;
+		mappings ??= /* @__PURE__ */ new Map();
+		mappings.set(name, roleMapping);
+	}
+	return mappings;
+}
+/**
+* Associe chaque émetteur de confiance au fournisseur de connexion qui partage
+* son émetteur canonique.
+*
+* Un émetteur revendiqué par DEUX fournisseurs n'est lié à aucun : choisir l'un
+* des deux ferait dépendre l'identité de l'ordre de la configuration.
+*
+* @returns la table, ou `null` quand aucun émetteur n'est lié (rien à chercher).
+*/
+function linkProviders(trusted, providers) {
+	if (!providers || providers.length === 0) return null;
+	const links = /* @__PURE__ */ new Map();
+	const ambiguous = /* @__PURE__ */ new Set();
+	for (const { name, issuer } of providers) {
+		let canonical;
+		try {
+			canonical = canonicalIssuer(issuer);
+		} catch {
+			continue;
+		}
+		if (!trusted.has(canonical)) continue;
+		if (links.has(canonical)) ambiguous.add(canonical);
+		links.set(canonical, name);
+	}
+	for (const issuer of ambiguous) links.delete(issuer);
+	return links.size > 0 ? links : null;
+}
 //#endregion
 export { ExternalJwtAuthenticator, ExternalJwtAuthenticator as default };