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

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

@@ -3,10 +3,9 @@ import { UnverifiableTokenError } from "../../errors/UnverifiableTokenError.js";
 import { UserToken } from "../token/UserToken.js";
 import { bearerToken } from "./bearer.js";
 import peekIssuer from "./peekIssuer.js";
-import { localIdentifierFor } from "./externalSubject.js";
-import { ACCESS_TOKEN_VERIFIER, buildBearerChallenge, canonicalIssuer, protectedResourceMetadataUrl } from "nodefony";
-import { BaseUser } from "@nodefony/user";
-//#region nodefony/src/authenticator/ExternalJwtAuthenticator.ts
+import { ExternalSubjectResolver } from "./ExternalSubjectResolver.js";
+import { ACCESS_TOKEN_VERIFIER, buildBearerChallenge, protectedResourceMetadataUrl } from "nodefony";
+// nodefony/src/authenticator/ExternalJwtAuthenticator.ts
 /**
 * Message UNIFORME de refus — la cause fine (expiré, audience, signature, sujet
 * inconnu) part au journal, jamais au client : un refus détaillé est un oracle
@@ -16,6 +15,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).
 *
@@ -55,25 +59,15 @@ const AUDIENCE = "audience";
 var ExternalJwtAuthenticator = class {
 	name = "external-jwt";
 	#container;
-	#issuers;
-	#policy;
-	#ephemeralRoles;
-	#userProvider = null;
+	/** Rattachement du sujet à un compte local — partagé, jamais recopié. */
+	#subjects;
 	/**
 	* @param container - container DI (résolution lazy du vérificateur et de `users`)
 	* @param options - émetteurs reconnus et politique de rattachement
 	*/
 	constructor(container, options) {
 		this.#container = container;
-		const issuers = /* @__PURE__ */ new Map();
-		for (const binding of options.issuers) try {
-			issuers.set(canonicalIssuer(binding.issuer), binding.subjectMapping);
-		} catch {
-			continue;
-		}
-		this.#issuers = issuers;
-		this.#policy = options.subjectPolicy;
-		this.#ephemeralRoles = options.ephemeralRoles;
+		this.#subjects = new ExternalSubjectResolver(container, options);
 	}
 	/**
 	* La requête porte-t-elle un jeton se réclamant d'un émetteur de confiance ?
@@ -89,12 +83,7 @@ var ExternalJwtAuthenticator = class {
 		if (raw === null) return false;
 		const issuer = peekIssuer(raw);
 		if (issuer === null) return false;
-		if (this.#issuers.has(issuer)) return true;
-		try {
-			return this.#issuers.has(canonicalIssuer(issuer));
-		} catch {
-			return false;
-		}
+		return this.#subjects.recognizes(issuer);
 	}
 	/**
 	* Extrait le jeton brut ET l'audience de la zone.
@@ -108,6 +97,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);
 	}
 	/**
@@ -134,9 +124,7 @@ var ExternalJwtAuthenticator = class {
 		if (principal === null) throw new AuthenticationError(INVALID_TOKEN);
 		const subject = principal.subject;
 		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.#subjects.resolve(principal.issuer, subject, principal.claims, token.getAttribute(SUBJECT_AREA));
 		const ut = token;
 		ut.promote(user);
 		ut.setAttribute("scopes", [...principal.scopes]);
@@ -187,38 +175,5 @@ var ExternalJwtAuthenticator = class {
 	validateArea(area) {
 		if (!area.resource) throw new Error(`area "${area.name}": l'authenticator "${this.name}" exige que la zone déclare sa ressource (\`resource\`) — c'est l'audience que le jeton doit porter (RFC 8707 §2). Sans elle, un jeton valide délivré au même porteur pour un AUTRE service serait accepté ici.`);
 	}
-	/**
-	* Établit l'utilisateur applicatif à partir du sujet du jeton.
-	*
-	* Les deux politiques répondent à deux questions différentes : « qui, chez
-	* nous, est cette personne ? » et « quel pouvoir accorde-t-on à une machine
-	* que l'annuaire a authentifiée ? ».
-	*/
-	async #resolveUser(issuer, subject, mapping) {
-		const identifier = localIdentifierFor(issuer, subject, mapping);
-		if (this.#policy === "ephemeral") return new BaseUser({
-			id: identifier,
-			identifier,
-			roles: [...this.#ephemeralRoles]
-		});
-		const provider = this.#resolveUserProvider();
-		let user;
-		try {
-			user = await provider.loadUserByIdentifier(identifier);
-		} catch {
-			throw new AuthenticationError(INVALID_TOKEN);
-		}
-		if (!user.isActive() || user.isLocked()) throw new AuthenticationError(INVALID_TOKEN);
-		return user;
-	}
-	#resolveUserProvider() {
-		if (this.#userProvider === null) {
-			const provider = this.#container.get("users");
-			if (!provider) throw new Error("ExternalJwtAuthenticator: aucun service \"users\" (IUserProvider) dans le container — enregistrer un UserService au boot, ou passer la politique de sujet à \"ephemeral\" si l'appelant est une machine sans compte local.");
-			this.#userProvider = provider;
-		}
-		return this.#userProvider;
-	}
 };
-//#endregion
 export { ExternalJwtAuthenticator, ExternalJwtAuthenticator as default };

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

@@ -0,0 +1,180 @@
+import { compileProviderRoleMapping, mapProviderRoles } from "../oauth/providerRoles.js";
+import { AuthenticationError } from "../../errors/AuthenticationError.js";
+import { UnverifiableTokenError } from "../../errors/UnverifiableTokenError.js";
+import { localIdentifierFor } from "./externalSubject.js";
+import { canonicalIssuer } from "nodefony";
+import { BaseUser } from "@nodefony/user";
+// nodefony/src/authenticator/ExternalSubjectResolver.ts
+/**
+* Message UNIFORME de refus — la cause fine (sujet inconnu, compte verrouillé)
+* part au journal, jamais au client : un refus détaillé est un oracle.
+*/
+const INVALID_TOKEN = "Invalid token";
+/**
+* Les options de rattachement des sujets externes, lues dans la configuration
+* de sécurité — UNE lecture, pour la zone `external-jwt` comme pour le
+* résolveur de compte d'une ressource protégée.
+*
+* @param config - configuration de sécurité validée
+* @returns émetteurs, politique de sujet, fournisseurs de connexion liables
+*/
+function externalSubjectOptions(config) {
+	const rs = config.resourceServer;
+	return {
+		issuers: rs.issuers.map((i) => ({
+			issuer: i.issuer,
+			subjectMapping: i.subjectMapping
+		})),
+		subjectPolicy: rs.subjectPolicy,
+		ephemeralRoles: rs.ephemeralRoles,
+		oauthProviders: Object.entries(config.oauth2.providers).flatMap(([name, p]) => p.issuer ? [{
+			name,
+			issuer: p.issuer,
+			roleMapping: compileProviderRoleMapping(p)
+		}] : [])
+	};
+}
+/**
+* Établit l'utilisateur applicatif que désigne le sujet d'un jeton TIERS —
+* la décision qui transforme « un annuaire a authentifié ce sujet » en « ce
+* compte agit chez nous ».
+*
+* UNE implémentation, deux consommateurs : la zone `external-jwt` du pare-feu
+* (`ExternalJwtAuthenticator`) et le résolveur de compte d'une ressource
+* protégée (porte MCP). Recopiée, la règle d'espace de noms aurait divergé dès
+* le premier émetteur ajouté — et c'est elle qui empêche un annuaire tiers de
+* réclamer le compte local `admin`.
+*/
+var ExternalSubjectResolver = class {
+	#container;
+	#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 de `users`)
+	* @param options - émetteurs reconnus et politique de rattachement
+	*/
+	constructor(container, options) {
+		this.#container = container;
+		const issuers = /* @__PURE__ */ new Map();
+		for (const binding of options.issuers) try {
+			issuers.set(canonicalIssuer(binding.issuer), binding.subjectMapping);
+		} catch {
+			continue;
+		}
+		this.#issuers = issuers;
+		this.#policy = options.subjectPolicy;
+		this.#ephemeralRoles = options.ephemeralRoles;
+		this.#linkedProviders = linkProviders(issuers, options.oauthProviders);
+		this.#roleMappings = collectRoleMappings(options.oauthProviders);
+	}
+	/**
+	* L'émetteur revendiqué est-il l'un des nôtres ? Ne lève JAMAIS : la valeur
+	* vient d'un jeton que n'importe qui peut forger.
+	*
+	* @param issuer - émetteur lu dans le jeton, non vérifié
+	*/
+	recognizes(issuer) {
+		if (this.#issuers.has(issuer)) return true;
+		try {
+			return this.#issuers.has(canonicalIssuer(issuer));
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Établit l'utilisateur applicatif à partir du sujet d'un jeton VÉRIFIÉ.
+	*
+	* Les deux politiques répondent à deux questions différentes : « qui, chez
+	* nous, est cette personne ? » et « quel pouvoir accorde-t-on à une machine
+	* que l'annuaire a authentifiée ? ».
+	*
+	* @param issuer - émetteur canonique, tel que le vérificateur l'a établi
+	* @param subject - sujet brut (`sub`) chez cet émetteur
+	* @param claims - revendications du jeton (rôles d'annuaire)
+	* @param area - zone qui SURCHARGE la politique, s'il y en a une
+	* @throws AuthenticationError (401) — sujet sans compte local utilisable
+	* @throws UnverifiableTokenError (503) — émetteur vérifié mais absent de la
+	*   table de rattachement : configuration incohérente
+	*/
+	async resolve(issuer, subject, claims, area) {
+		const mapping = this.#issuers.get(issuer);
+		if (mapping === void 0) throw new UnverifiableTokenError(`émetteur « ${issuer} » vérifié mais absent de la table de rattachement des sujets — configuration incohérente.`);
+		const identifier = localIdentifierFor(issuer, subject, mapping);
+		if ((area?.subjectPolicy ?? this.#policy) === "ephemeral") return new BaseUser({
+			id: identifier,
+			identifier,
+			roles: [...area?.ephemeralRoles ?? this.#ephemeralRoles]
+		});
+		const provider = this.#resolveUserProvider();
+		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);
+		}
+		if (!user.isActive() || user.isLocked()) throw new AuthenticationError(INVALID_TOKEN);
+		return user;
+	}
+	#resolveUserProvider() {
+		if (this.#userProvider === null) {
+			const provider = this.#container.get("users");
+			if (!provider) throw new Error("ExternalJwtAuthenticator: aucun service \"users\" (IUserProvider) dans le container — enregistrer un UserService au boot, ou passer la politique de sujet à \"ephemeral\" si l'appelant est une machine sans compte local.");
+			this.#userProvider = provider;
+		}
+		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;
+}
+export { ExternalSubjectResolver, externalSubjectOptions };

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

@@ -1,8 +1,9 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
+import { isBoundToAccount } from "../accountBinding.js";
 import { UserRealtimeToken } from "../realtime/UserRealtimeToken.js";
 import { Nodefony, RequestContext } from "nodefony";
-import { anonymousUser } from "@nodefony/user";
-//#region nodefony/src/authenticator/FirewallRealtimeAuthenticator.ts
+import { authenticatedUser } from "@nodefony/user";
+// nodefony/src/authenticator/FirewallRealtimeAuthenticator.ts
 /**
 * Authenticator realtime des identités résolues par le **firewall** — équivalent
 * WS de tout ce que le pipeline HTTP sait authentifier.
@@ -57,16 +58,25 @@ var FirewallRealtimeAuthenticator = class {
 	*/
 	#resolveStore;
 	/**
+	* Accès paresseux à l'annuaire des comptes, pour confirmer avant chaque
+	* `api.request` que le compte de la socket existe toujours sous le même `id`.
+	* Absent (`null`) → aucune confirmation (seul `isValid` fait foi).
+	*/
+	#resolveUsers;
+	/**
 	* @param resolveStore - fournit le store de révocation des jetons (le firewall
 	*   passe une closure sur son container). Omis → mode dégradé documenté :
 	*   seules les bornes portées par le jeton lui-même sont vérifiables.
+	* @param resolveUsers - fournit l'annuaire des comptes (`users`). Omis → pas
+	*   de confirmation du compte avant `api.request`.
 	*/
-	constructor(resolveStore = null) {
+	constructor(resolveStore = null, resolveUsers = null) {
 		this.#resolveStore = resolveStore;
+		this.#resolveUsers = resolveUsers;
 	}
 	/** Une identité authentifiée a-t-elle été résolue (par le firewall) au handshake ? */
 	supports(_handshake) {
-		return isAuthenticatedUser(RequestContext.getUser());
+		return authenticatedUser() !== null;
 	}
 	/**
 	* Promeut l'identité déjà résolue (ALS) en jeton realtime — 0 lecture base.
@@ -76,13 +86,61 @@ var FirewallRealtimeAuthenticator = class {
 	*   filet défensif fail-closed → le hub ferme la socket en 4001).
 	*/
 	async authenticate(_handshake) {
-		const user = RequestContext.getUser();
-		if (!isAuthenticatedUser(user)) throw new AuthenticationError("Invalid realtime session");
+		const user = authenticatedUser();
+		if (user === null) throw new AuthenticationError("Invalid realtime session");
 		const issued = readFirewallToken();
-		const type = typeof issued?.type === "string" && issued.type ? issued.type : "session";
-		const revalidate = type === "session" ? buildSessionRevalidator(user.identifier) : this.#buildBearerRevalidator(issued, user.identifier, type);
+		const type = issuedType(issued);
+		const revalidate = this.#revalidatorFor(user, issued, type);
 		const scopes = issued ? issued.getScopes() : void 0;
-		return new UserRealtimeToken(user, revalidate, type, scopes);
+		return new UserRealtimeToken(user, revalidate, type, scopes, this.#accountConfirmationFor(user, type));
+	}
+	/**
+	* Le revalidateur de l'identité que le firewall a posée sur la requête
+	* COURANTE (ALS), pour toute connexion longue — socket WebSocket ou flux SSE.
+	*
+	* Une seule règle décide qu'une identité est morte, quel que soit le
+	* transport qui la porte : c'est celle-ci, et le hub comme le noyau HTTP
+	* l'appellent au lieu de la recopier.
+	*
+	* @returns `null` pour un anonyme (rien à révoquer), sinon la fonction qui
+	*   dit si l'identité est TOUJOURS valable — fail-closed : `false` quand elle
+	*   ne peut pas le prouver.
+	*/
+	currentRevalidator() {
+		const user = authenticatedUser();
+		if (user === null) return null;
+		const issued = readFirewallToken();
+		return this.#revalidatorFor(user, issued, issuedType(issued));
+	}
+	/**
+	* Choisit la preuve de révocation selon le mode d'authentification : la
+	* session se relit, un jeton porteur se borne par `exp` et la denylist.
+	*/
+	/**
+	* Confirmation du compte, pour les modes dont l'APPLICATION émet l'artefact
+	* (session, JWT maison, clé d'API) : le compte relu doit exister, être actif
+	* et porter le même `id` immuable qu'au handshake — sinon il a disparu ou un
+	* autre compte a repris son identifiant hors du framework (#139). Un sujet
+	* `external-jwt` peut être éphémère, sans compte local : il n'est pas
+	* confirmé. `null` = rien à confirmer.
+	*/
+	#accountConfirmationFor(user, type) {
+		const resolveUsers = this.#resolveUsers;
+		if (resolveUsers === null || !ACCOUNT_CONFIRMED_TYPES.has(type)) return null;
+		return async () => {
+			const users = resolveUsers();
+			if (users === null) return true;
+			let current;
+			try {
+				current = await users.loadUserByIdentifier(user.identifier);
+			} catch {
+				return false;
+			}
+			return current.isActive() && !current.isLocked() && isBoundToAccount(current, user.id, user.credentialsVersion);
+		};
+	}
+	#revalidatorFor(user, issued, type) {
+		return type === "session" ? buildSessionRevalidator(user.identifier) : this.#buildBearerRevalidator(issued, user.identifier, type);
 	}
 	/**
 	* Re-validation d'une identité portée par un **jeton** (JWT, clé API, OAuth) :
@@ -125,10 +183,23 @@ var FirewallRealtimeAuthenticator = class {
 	}
 };
 const EMPTY_CLAIMS = Object.freeze({});
+/** Modes dont l'application émet l'artefact : leur compte est local, donc relisible. */
+const ACCOUNT_CONFIRMED_TYPES = /* @__PURE__ */ new Set([
+	"session",
+	"jwt",
+	"apikey"
+]);
 /** Claim temporel JWT (secondes, RFC 7519) → epoch ms, ou `null` si absent/invalide. */
 function secondsToMs(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value * 1e3 : null;
 }
+/**
+* Le mode d'authentification du jeton du firewall. Absent (zone historique) →
+* le mode le plus strict, la session : un repli sûr, jamais permissif.
+*/
+function issuedType(issued) {
+	return typeof issued?.type === "string" && issued.type ? issued.type : "session";
+}
 /** Le jeton posé dans l'ALS par `firewall.handleSecurity`, s'il y en a un. */
 function readFirewallToken() {
 	return RequestContext.get()?.token;
@@ -161,14 +232,4 @@ function buildSessionRevalidator(identifier) {
 		}
 	};
 }
-/**
-* Vrai si `user` est un utilisateur AUTHENTIFIÉ (≠ anonyme). Le firewall pose
-* `token.getUser()` dans l'ALS : soit l'`IUser` réel, soit `anonymousUser`
-* (singleton). Tout ce qui n'est pas l'anonyme et porte un `identifier` est
-* une identité valide.
-*/
-function isAuthenticatedUser(user) {
-	return !!user && user !== anonymousUser && typeof user.identifier === "string";
-}
-//#endregion
 export { FirewallRealtimeAuthenticator, FirewallRealtimeAuthenticator as default };

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

@@ -1,8 +1,10 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
+import { loadBoundAccount } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
 import { bearerToken } from "./bearer.js";
 import peekIssuer from "./peekIssuer.js";
-//#region nodefony/src/authenticator/JwtAuthenticator.ts
+import { canonicalIssuer } from "nodefony";
+// nodefony/src/authenticator/JwtAuthenticator.ts
 const COMPACT_JWS = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/;
 const INVALID_TOKEN = "Invalid token";
 /**
@@ -82,6 +84,57 @@ var JwtAuthenticator = class {
 	async authenticate(token) {
 		const raw = token.getCredentials();
 		if (typeof raw !== "string" || raw.length === 0) throw new AuthenticationError(INVALID_TOKEN);
+		const { user, payload } = await this.#verify(raw, this.#runtime.audiences);
+		return this.#promote(token, user, payload);
+	}
+	/**
+	* Vérifie un jeton émis par CETTE application pour une ressource protégée
+	* nommée par l'appelant — la porte d'une ressource (RFC 8707), pas une zone.
+	*
+	* Les MÊMES règles que {@link authenticate}, appliquées par la même fonction :
+	* signature par le keyset local, `iss`, `typ: at+jwt`, révocation ciblée
+	* (`jti`) et en masse (`invalidBefore`), compte encore actif. Seule
+	* l'audience diffère : c'est celle de la ressource qui appelle, et elle est
+	* exigée. Un jeton révoqué, ou celui d'un compte désactivé, n'ouvre donc pas
+	* plus une porte MCP qu'une route — ce que la vérification par le seul jeu de
+	* clés publiques laissait passer jusqu'à l'expiration.
+	*
+	* @param raw - le jeton présenté, brut
+	* @param audience - l'URI canonique de la ressource qui le reçoit
+	* @returns le principal établi, ou `null` pour tout refus (contrat
+	*   `IAccessTokenVerifier` : un refus n'est jamais une exception)
+	* @throws Error si le câblage manque (keystore, store, annuaire) — la porte
+	*   le traduit en `503`, jamais en jeton accepté
+	*/
+	async verifyForResource(raw, audience) {
+		let verified;
+		try {
+			verified = await this.#verify(raw, audience);
+		} catch (error) {
+			if (error instanceof AuthenticationError) return null;
+			throw error;
+		}
+		const { payload } = verified;
+		const scope = payload.scope;
+		return {
+			issuer: this.#resourceIssuer(),
+			subject: payload.sub,
+			scopes: typeof scope === "string" && scope.length > 0 ? scope.split(" ") : [],
+			expiresAt: payload.exp,
+			issuedAt: payload.iat,
+			tokenId: payload.jti,
+			claims: payload
+		};
+	}
+	/**
+	* La vérification entière d'un jeton maison — UNE implémentation, pour la
+	* zone ({@link authenticate}) comme pour la ressource
+	* ({@link verifyForResource}).
+	*
+	* @throws AuthenticationError pour tout refus (message uniforme)
+	* @throws Error si le câblage manque
+	*/
+	async #verify(raw, audience) {
 		const jose = this.#jose ??= await import("jose");
 		const getKey = await this.#ensureGetKey(jose);
 		let payload;
@@ -89,7 +142,7 @@ var JwtAuthenticator = class {
 			payload = (await jose.jwtVerify(raw, getKey, {
 				algorithms: ["EdDSA"],
 				issuer: this.#runtime.issuer,
-				audience: this.#runtime.audiences,
+				audience,
 				typ: "at+jwt"
 			})).payload;
 		} catch {
@@ -104,8 +157,31 @@ var JwtAuthenticator = class {
 		if (invalidBefore !== null) {
 			if ((typeof payload.iat === "number" ? payload.iat * 1e3 : 0) < invalidBefore) throw new AuthenticationError(INVALID_TOKEN);
 		}
-		const user = await this.#resolveUserOrReject(sub);
-		return this.#promote(token, user, payload);
+		const user = await loadBoundAccount(this.#resolveUserProvider(), sub, payload["uid"], payload["cv"]);
+		if (user === null) throw new AuthenticationError(INVALID_TOKEN);
+		return {
+			user,
+			payload
+		};
+	}
+	/**
+	* Recharge le compte que désigne un principal établi par
+	* {@link verifyForResource} — pour une ressource protégée qui fait agir un
+	* outil au nom du propriétaire du jeton.
+	*
+	* La MÊME règle que la zone ({@link loadBoundAccount}), rejouée sur les
+	* revendications du principal : le vérificateur ne garde pas le compte qu'il
+	* a lu, et une seconde lecture de l'annuaire est le coût accepté d'un outil
+	* qui la demande — les autres ne la paient pas.
+	*
+	* @param principal - principal d'un jeton émis par CETTE application
+	* @returns le compte, ou `null` s'il n'est pas (ou plus) celui du jeton
+	* @throws Error si l'annuaire des comptes n'est pas câblé
+	*/
+	resolveAccount(principal) {
+		const subject = principal.subject;
+		if (principal.issuer !== this.#resourceIssuer() || typeof subject !== "string" || subject.length === 0) return Promise.resolve(null);
+		return loadBoundAccount(this.#resolveUserProvider(), subject, principal.claims?.["uid"], principal.claims?.["cv"]);
 	}
 	/** Slot audit (J4b). */
 	onSuccess(_context, _token) {
@@ -119,6 +195,17 @@ var JwtAuthenticator = class {
 	challenge() {
 		return "Bearer";
 	}
+	/**
+	* L'émetteur que portent les principaux de {@link verifyForResource} — et
+	* donc celui qu'un principal doit porter pour être un jeton maison.
+	*/
+	#resourceIssuer() {
+		try {
+			return canonicalIssuer(this.#runtime.issuer);
+		} catch {
+			return this.#runtime.issuer;
+		}
+	}
 	/** Construit (une fois) le résolveur de clé par `kid` depuis le JWKS public. */
 	async #ensureGetKey(jose) {
 		if (this.#getKey !== null) return this.#getKey;
@@ -134,19 +221,9 @@ var JwtAuthenticator = class {
 		ut.setAttribute("scopes", scopes);
 		ut.setAttribute("jti", payload.jti);
 		ut.setAttribute("claims", payload);
+		ut.setAttribute("issuer", payload.iss);
 		return ut;
 	}
-	async #resolveUserOrReject(sub) {
-		const provider = this.#resolveUserProvider();
-		let user;
-		try {
-			user = await provider.loadUserByIdentifier(sub);
-		} catch {
-			throw new AuthenticationError(INVALID_TOKEN);
-		}
-		if (!user.isActive() || user.isLocked()) throw new AuthenticationError(INVALID_TOKEN);
-		return user;
-	}
 	#resolveKeystore() {
 		if (this.#keystore === null) {
 			const ks = this.#container.get("jwtKeystore");
@@ -172,5 +249,4 @@ var JwtAuthenticator = class {
 		return this.#userProvider;
 	}
 };
-//#endregion
 export { JwtAuthenticator, JwtAuthenticator as default };

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

@@ -1,7 +1,8 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
-import { resolveSessionIdentity } from "../sessionIdentity.js";
+import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY } from "../accountBinding.js";
+import { resolveBoundSessionIdentity } from "../sessionIdentity.js";
 import { UserToken } from "../token/UserToken.js";
-//#region nodefony/src/authenticator/SessionAuthenticator.ts
+// nodefony/src/authenticator/SessionAuthenticator.ts
 /**
 * Authentification par **session serveur** (cookie opaque, modèle BFF) — la
 * preuve des requêtes qui SUIVENT le login (`AuthFlow.login`, qui a déjà posé
@@ -59,7 +60,11 @@ var SessionAuthenticator = class {
 	}
 	/** Extrait l'identifiant du blob de session (jamais de secret en jeu). */
 	createToken(context) {
-		const credentials = { identifier: context.session?.user ?? "" };
+		const credentials = {
+			identifier: context.session?.user ?? "",
+			accountId: context.session?.getMetaBag(ACCOUNT_ID_KEY),
+			credentialsVersion: context.session?.getMetaBag(CREDENTIALS_VERSION_KEY)
+		};
 		return Promise.resolve(new UserToken(this.name, credentials));
 	}
 	/**
@@ -74,7 +79,7 @@ var SessionAuthenticator = class {
 		const credentials = token.getCredentials();
 		if (!credentials?.identifier) throw new AuthenticationError("Invalid session");
 		const provider = this.#provider ??= this.#resolveProvider();
-		const user = await resolveSessionIdentity(provider, credentials.identifier);
+		const user = await resolveBoundSessionIdentity(provider, credentials.identifier, credentials.accountId, credentials.credentialsVersion);
 		return token.promote(user);
 	}
 	/**
@@ -90,5 +95,4 @@ var SessionAuthenticator = class {
 		return Promise.resolve();
 	}
 };
-//#endregion
 export { SessionAuthenticator, SessionAuthenticator as default };