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

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;
@@ -137,17 +224,6 @@ var JwtAuthenticator = class {
 		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");
@@ -173,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 };

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

@@ -1,7 +1,7 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { ThrottledError } from "../../errors/ThrottledError.js";
 import { UserToken } from "../token/UserToken.js";
-//#region nodefony/src/authenticator/UserPasswordAuthenticator.ts
+// nodefony/src/authenticator/UserPasswordAuthenticator.ts
 const BASIC_SCHEME = /^basic\s+/i;
 const INVALID_CREDENTIALS = "Invalid credentials";
 /**
@@ -101,5 +101,4 @@ var UserPasswordAuthenticator = class {
 		return "Basic realm=\"nodefony\", charset=\"UTF-8\"";
 	}
 };
-//#endregion
 export { UserPasswordAuthenticator, UserPasswordAuthenticator as default };

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

@@ -1,12 +1,12 @@
-import { compileProviderRoleMapping } from "../oauth/providerRoles.js";
 import { AnonymousAuthenticator } from "./AnonymousAuthenticator.js";
 import { SessionAuthenticator } from "./SessionAuthenticator.js";
 import { UserPasswordAuthenticator } from "./UserPasswordAuthenticator.js";
 import { JwtAuthenticator } from "./JwtAuthenticator.js";
 import { ApiKeyAuthenticator } from "./ApiKeyAuthenticator.js";
+import { externalSubjectOptions } from "./ExternalSubjectResolver.js";
 import { ExternalJwtAuthenticator } from "./ExternalJwtAuthenticator.js";
 import { resolveJwtRuntime } from "../token/jwtRuntime.js";
-//#region nodefony/src/authenticator/authenticatorRegistry.ts
+// nodefony/src/authenticator/authenticatorRegistry.ts
 const factories = /* @__PURE__ */ new Map();
 /**
 * Enregistre (ou remplace) la fabrique d'un authenticator. Appelé par les
@@ -45,20 +45,7 @@ registerAuthenticatorFactory("jwt", ({ container, config }) => {
 	return new JwtAuthenticator(container, resolveJwtRuntime(config.jwt));
 });
 registerAuthenticatorFactory("external-jwt", ({ container, config }) => {
-	const rs = config.resourceServer;
-	return new ExternalJwtAuthenticator(container, {
-		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)
-		}] : [])
-	});
+	return new ExternalJwtAuthenticator(container, externalSubjectOptions(config));
 });
 registerAuthenticatorFactory("apikey", ({ container, config }) => {
 	return new ApiKeyAuthenticator(container, {
@@ -66,5 +53,4 @@ registerAuthenticatorFactory("apikey", ({ container, config }) => {
 		lastUsedThrottleS: config.apiKeys.lastUsedThrottleS
 	});
 });
-//#endregion
 export { getAuthenticatorFactory, listAuthenticatorFactories, registerAuthenticatorFactory };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/authenticator/externalSubject.ts
+// nodefony/src/authenticator/externalSubject.ts
 /**
 * Séparateur entre l'émetteur et le sujet.
 *
@@ -32,5 +32,4 @@ function localIdentifierFor(issuer, subject, mapping) {
 	if (mapping === "subject") return subject;
 	return `${issuer}${SEPARATOR}${subject}`;
 }
-//#endregion
 export { localIdentifierFor };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/authenticator/peekIssuer.ts
+// nodefony/src/authenticator/peekIssuer.ts
 /**
 * Lecture NON VÉRIFIÉE de l'émetteur d'un JWS compact.
 *
@@ -52,5 +52,4 @@ function peekIssuer(raw) {
 		return null;
 	}
 }
-//#endregion
 export { peekIssuer as default, peekIssuer };

package/dist/nodefony/src/boot/publicRoutesNotice.js

@@ -1,5 +1,5 @@
 import { isFrameworkZone } from "nodefony";
-//#region nodefony/src/boot/publicRoutesNotice.ts
+// nodefony/src/boot/publicRoutesNotice.ts
 /**
 * Le point d'attention « routes métier publiques » du bilan de démarrage.
 *
@@ -23,5 +23,4 @@ function publicRoutesNotice(zones) {
 		fix: "use(\"@nodefony/security\", { areas: { main: { pattern: \"^/api\", authenticators: [\"session\"] } } })"
 	};
 }
-//#endregion
 export { publicRoutesNotice };

package/dist/nodefony/src/crypto/secretCipher.js

@@ -1,6 +1,6 @@
 import { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from "node:crypto";
 import { Buffer } from "node:buffer";
-//#region nodefony/src/crypto/secretCipher.ts
+// nodefony/src/crypto/secretCipher.ts
 /**
 * Chiffrement **réversible** de secrets applicatifs au repos — AES-256-GCM
 * (authentifié). Brique générique partagée par tous les domaines qui doivent
@@ -75,5 +75,4 @@ function decryptSecret(blob, key) {
 	decipher.setAuthTag(tag);
 	return Buffer.concat([decipher.update(ct), decipher.final()]);
 }
-//#endregion
 export { decryptSecret, deriveKey, encryptSecret, generateEphemeralKey };

package/dist/nodefony/src/csp.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/csp.ts
+// nodefony/src/csp.ts
 /**
 * Parse une chaîne CSP en directives ordonnées `[nom, sources[]]`. L'ordre des
 * directives et des sources est préservé (déterminisme : header stable, tests
@@ -49,5 +49,4 @@ function mergeCspFragments(base, fragments) {
 	}
 	return serializeCsp(directives);
 }
-//#endregion
 export { mergeCspFragments, parseCsp, serializeCsp };

package/dist/nodefony/src/csrfToken.js

@@ -1,5 +1,5 @@
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-//#region nodefony/src/csrfToken.ts
+// nodefony/src/csrfToken.ts
 /**
 * Jeton synchronizer CSRF — modèle **double-submit signé** (OWASP CSRF Prevention
 * Cheat Sheet, « Signed Double-Submit Cookie »). Le token est
@@ -61,5 +61,4 @@ var CsrfTokenManager = class CsrfTokenManager {
 		return timingSafeEqual(ba, bb);
 	}
 };
-//#endregion
 export { CsrfTokenManager, CsrfTokenManager as default };

package/dist/nodefony/src/entryPoint.js

@@ -1,5 +1,5 @@
 import { loginPagePath, safeRedirectPath } from "nodefony";
-//#region nodefony/src/entryPoint.ts
+// nodefony/src/entryPoint.ts
 /**
 * Dit si une requête refusée est la NAVIGATION d'un navigateur — le seul cas
 * où conduire à la page de connexion aide, au lieu de casser un client.
@@ -35,5 +35,4 @@ function entryPointLocation(entryPoint, request) {
 	if (request.path.split("?", 1)[0] === entryPoint.split("?", 1)[0]) return null;
 	return loginPagePath(safeRedirectPath(request.path), entryPoint);
 }
-//#endregion
 export { entryPointLocation, isBrowserNavigation };

package/dist/nodefony/src/net/ssrfGuard.js

@@ -1,7 +1,7 @@
 import { SsrfError } from "../../errors/SsrfError.js";
 import { BlockList, isIP } from "node:net";
 import { lookup } from "node:dns/promises";
-//#region nodefony/src/net/ssrfGuard.ts
+// nodefony/src/net/ssrfGuard.ts
 /**
 * Protection **SSRF** (Server-Side Request Forgery) générique pour les URL
 * sortantes — endpoints webhook, fetch applicatif, futurs agents/RAG.
@@ -126,5 +126,4 @@ async function assertPublicUrl(rawUrl, options = {}) {
 		addresses
 	};
 }
-//#endregion
 export { assertPublicUrl, isBlockedAddress };

package/dist/nodefony/src/net/transportFailure.js

@@ -0,0 +1,57 @@
+// nodefony/src/net/transportFailure.ts
+/**
+* Codes TLS d'une chaîne de certificats qu'aucune autorité CONNUE ne signe.
+*
+* Leur remède est le même : faire reconnaître l'autorité. Un certificat expiré
+* (`CERT_HAS_EXPIRED`) ou émis pour un autre nom (`ERR_TLS_CERT_ALTNAME_INVALID`)
+* n'en fait pas partie : ajouter une autorité n'y changerait rien.
+*/
+const UNTRUSTED_AUTHORITY_CODES = /* @__PURE__ */ new Set([
+	"SELF_SIGNED_CERT_IN_CHAIN",
+	"DEPTH_ZERO_SELF_SIGNED_CERT",
+	"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+	"UNABLE_TO_GET_ISSUER_CERT",
+	"UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+	"CERT_UNTRUSTED"
+]);
+/** Le code porté par la `cause` d'un échec de `fetch`, s'il y en a un. */
+function causeCode(error) {
+	if (!(error instanceof Error)) return null;
+	const cause = error.cause;
+	if (!(cause instanceof Error)) return null;
+	const code = cause.code;
+	return typeof code === "string" ? code : null;
+}
+/**
+* Rend un échec de transport LISIBLE : `fetch` (undici) ne dit que
+* `fetch failed` et range la vraie raison dans `cause` — certificat refusé,
+* connexion refusée, nom introuvable.
+*
+* @param error - ce que `fetch` (ou une bibliothèque qui l'appelle) a levé
+* @returns `message (CODE : raison)`, ou le message seul faute de cause
+*/
+function describeTransportFailure(error) {
+	if (!(error instanceof Error)) return String(error);
+	const cause = error.cause;
+	if (!(cause instanceof Error)) return error.message;
+	const code = causeCode(error);
+	return code !== null ? `${error.message} (${code} : ${cause.message})` : `${error.message} (${cause.message})`;
+}
+/**
+* Le remède d'un certificat signé par une autorité que le processus ne
+* reconnaît pas — `null` pour tout autre échec.
+*
+* En développement, Nodefony reconnaît d'office l'autorité qu'il a générée ; en
+* production jamais, et c'est voulu. Sans ce remède, le journal ne montrait que
+* `SELF_SIGNED_CERT_IN_CHAIN` : la variable qui le règle n'était écrite que dans
+* un commentaire du `.env`, fichier qu'un serveur de production n'a pas.
+*
+* @param error - ce que `fetch` (ou une bibliothèque qui l'appelle) a levé
+* @returns une phrase d'action, ou `null`
+*/
+function untrustedAuthorityHint(error) {
+	const code = causeCode(error);
+	if (code === null || !UNTRUSTED_AUTHORITY_CODES.has(code)) return null;
+	return "le certificat de ce serveur est signé par une autorité que l'application ne reconnaît pas : déclare-la dans NF_TLS_CA_FILE (fichier PEM, `http.certificates.extraCaFiles`)";
+}
+export { describeTransportFailure, untrustedAuthorityHint };

package/dist/nodefony/src/oauth/clientCredentials.js

@@ -1,6 +1,6 @@
 import { postTokenRequest } from "./oauth2Client.js";
 import { discoverAuthorizationServer } from "./metadata.js";
-//#region nodefony/src/oauth/clientCredentials.ts
+// nodefony/src/oauth/clientCredentials.ts
 /**
 * Obtient un jeton d'accès pour un programme, par le flux `client_credentials`
 * (RFC 6749 §4.4), auprès d'un émetteur découvert (RFC 8414).
@@ -36,5 +36,4 @@ async function requestClientCredentialsToken(request) {
 		timeoutMs: request.timeoutMs
 	}, body);
 }
-//#endregion
 export { requestClientCredentialsToken };

package/dist/nodefony/src/oauth/httpJson.js

@@ -1,4 +1,5 @@
-//#region nodefony/src/oauth/httpJson.ts
+import { isPlainObject } from "nodefony";
+// nodefony/src/oauth/httpJson.ts
 /**
 * Lecture BORNÉE d'un corps JSON — la brique de transport commune aux trois
 * appels sortants du social login (découverte, point de jeton, API d'un
@@ -57,8 +58,7 @@ async function readJsonBounded(response, maxBytes, subject) {
 */
 async function readJsonObjectBounded(response, maxBytes, subject) {
 	const payload = await readJsonBounded(response, maxBytes, subject);
-	if (payload === null || typeof payload !== "object" || Array.isArray(payload)) throw new Error(`${subject} → corps inattendu (objet JSON attendu)`);
+	if (!isPlainObject(payload)) throw new Error(`${subject} → corps inattendu (objet JSON attendu)`);
 	return payload;
 }
-//#endregion
 export { readJsonBounded, readJsonObjectBounded };

package/dist/nodefony/src/oauth/metadata.js

@@ -1,6 +1,7 @@
+import { describeTransportFailure, untrustedAuthorityHint } from "../net/transportFailure.js";
 import { readJsonObjectBounded } from "./httpJson.js";
 import { canonicalIssuer, isBackChannelTransportAllowed, metadataCandidateUrls, validateIssuerMetadata } from "nodefony";
-//#region nodefony/src/oauth/metadata.ts
+// nodefony/src/oauth/metadata.ts
 /**
 * **Découverte des métadonnées d'un serveur d'autorisation** (RFC 8414) — la face
 * CLIENTE de la règle que le cœur porte déjà.
@@ -22,19 +23,6 @@ import { canonicalIssuer, isBackChannelTransportAllowed, metadataCandidateUrls,
 const DISCOVERY_TIMEOUT_MS = 1e4;
 /** Au-delà, le document n'est plus un document de métadonnées — on refuse de lire. */
 const MAX_METADATA_BYTES = 1048576;
-/**
-* Rend un échec de transport LISIBLE : `fetch` (undici) ne dit que
-* `fetch failed` et range la vraie raison dans `cause` — certificat refusé,
-* connexion refusée, nom introuvable. Sans elle, « métadonnées introuvables »
-* envoie chercher un émetteur absent quand c'est la confiance TLS qui manque.
-*/
-function describeTransportFailure(error) {
-	if (!(error instanceof Error)) return String(error);
-	const cause = error.cause;
-	if (!(cause instanceof Error)) return error.message;
-	const code = cause.code;
-	return typeof code === "string" ? `${error.message} (${code} : ${cause.message})` : `${error.message} (${cause.message})`;
-}
 async function fetchMetadataDocument(url, options) {
 	const response = await (options.fetch ?? globalThis.fetch)(url, {
 		headers: {
@@ -86,6 +74,7 @@ function optionalEndpoint(document, field, issuer) {
 async function discoverAuthorizationServer(rawIssuer, options = {}) {
 	const issuer = canonicalIssuer(rawIssuer);
 	const failures = [];
+	let hint = null;
 	const discoveryUrl = options.discoveryUrl;
 	for (const candidate of metadataCandidateUrls(issuer, discoveryUrl)) {
 		let document;
@@ -93,6 +82,7 @@ async function discoverAuthorizationServer(rawIssuer, options = {}) {
 			document = await fetchMetadataDocument(candidate, options);
 		} catch (error) {
 			failures.push(describeTransportFailure(error));
+			hint ??= untrustedAuthorityHint(error);
 			continue;
 		}
 		const identity = validateIssuerMetadata(document, issuer, discoveryUrl);
@@ -109,7 +99,6 @@ async function discoverAuthorizationServer(rawIssuer, options = {}) {
 			idTokenSigningAlgValuesSupported: Array.isArray(idTokenAlgs) ? idTokenAlgs.filter((a) => typeof a === "string") : null
 		};
 	}
-	throw new Error(`métadonnées introuvables pour « ${issuer} » — ${failures.join(" ; ")}`);
+	throw new Error(`métadonnées introuvables pour « ${issuer} » — ${failures.join(" ; ")}` + (hint === null ? "" : ` — ${hint}`));
 }
-//#endregion
 export { discoverAuthorizationServer };

package/dist/nodefony/src/oauth/oauth2Client.js

@@ -1,6 +1,6 @@
 import { readJsonObjectBounded } from "./httpJson.js";
 import { createHash, randomBytes } from "node:crypto";
-//#region nodefony/src/oauth/oauth2Client.ts
+// nodefony/src/oauth/oauth2Client.ts
 /**
 * Client **OAuth 2.0 / Authorization Code** minimal — la face cliente du protocole
 * dont Nodefony écrit déjà la face serveur (émetteur de jetons, métadonnées,
@@ -289,5 +289,4 @@ function basicCredentials(client) {
 	const secret = formUrlencode(client.clientSecret);
 	return Buffer.from(`${id}:${secret}`, "utf8").toString("base64");
 }
-//#endregion
 export { OAuth2Client, OAuth2RequestError, OAuth2Tokens, createCodeChallenge, generateCodeVerifier, generateState, postTokenRequest };

package/dist/nodefony/src/oauth/oauthProviderRegistry.js

@@ -1,6 +1,6 @@
 import { createDiscoveredOidcProvider } from "./providers/oidc.js";
 import { createGithubProvider } from "./providers/github.js";
-//#region nodefony/src/oauth/oauthProviderRegistry.ts
+// nodefony/src/oauth/oauthProviderRegistry.ts
 const factories = /* @__PURE__ */ new Map();
 /**
 * Enregistre (ou remplace) la fabrique d'un fournisseur OAuth. Appelée par les
@@ -55,5 +55,4 @@ registerOAuthProvider("google", (ctx) => createDiscoveredOidcProvider("google",
 registerOAuthProvider("keycloak", async (ctx) => withKeycloakThemeHint(await createDiscoveredOidcProvider("keycloak", ctx)), { requiresIssuer: true });
 registerOAuthProvider("oidc", (ctx) => createDiscoveredOidcProvider("oidc", ctx), { requiresIssuer: true });
 registerOAuthProvider("github", createGithubProvider);
-//#endregion
 export { KEYCLOAK_THEME_PARAMETER, getOAuthProviderFactory, listOAuthProviders, oauthProviderRequiresIssuer, registerOAuthProvider, withKeycloakThemeHint };

package/dist/nodefony/src/oauth/providerDiagnosis.js

@@ -1,6 +1,7 @@
+import { describeTransportFailure, untrustedAuthorityHint } from "../net/transportFailure.js";
 import { OAuth2RequestError, generateCodeVerifier, generateState } from "./oauth2Client.js";
 import { IssuerMismatchError } from "nodefony";
-//#region nodefony/src/oauth/providerDiagnosis.ts
+// nodefony/src/oauth/providerDiagnosis.ts
 /** Le code présenté au point de jeton : il n'a jamais été émis, il sera refusé. */
 const PROBE_CODE = "nodefony-doctor-probe";
 const AUTHORIZATION_TIMEOUT_MS = 1e4;
@@ -10,10 +11,9 @@ const AUTHORIZATION_TIMEOUT_MS = 1e4;
 */
 const MAX_ERROR_PAGE_BYTES = 65536;
 function errorMessage(error) {
-	if (!(error instanceof Error)) return String(error);
-	const cause = error.cause;
-	if (cause instanceof Error) return `${error.message} (${cause.message})`;
-	return error.message;
+	const hint = untrustedAuthorityHint(error);
+	const text = describeTransportFailure(error);
+	return hint === null ? text : `${text} — ${hint}`;
 }
 /** Les premiers octets d'une page, en texte — le reste est abandonné. */
 async function readHead(response, maxBytes) {
@@ -279,5 +279,4 @@ async function diagnoseOAuthProvider(input) {
 		checks
 	};
 }
-//#endregion
 export { diagnoseOAuthProvider };

package/dist/nodefony/src/oauth/providerRoles.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/oauth/providerRoles.ts
+// nodefony/src/oauth/providerRoles.ts
 /** Source par défaut : les rôles du CLIENT — ceux que l'annuaire attribue à CETTE application. */
 const DEFAULT_ROLE_SOURCES = ["client"];
 /**
@@ -75,5 +75,4 @@ function strings(value) {
 	if (!Array.isArray(value)) return [];
 	return value.filter((v) => typeof v === "string");
 }
-//#endregion
 export { DEFAULT_ROLE_SOURCES, PLATFORM_ROLE_PREFIX, compileProviderRoleMapping, isPlatformRole, mapProviderRoles };

package/dist/nodefony/src/oauth/providers/github.js

@@ -1,6 +1,7 @@
-import { readJsonBounded } from "../httpJson.js";
+import { readJsonBounded, readJsonObjectBounded } from "../httpJson.js";
 import { OAuth2Client, OAuth2RequestError } from "../oauth2Client.js";
-//#region nodefony/src/oauth/providers/github.ts
+import { isPlainObject } from "nodefony";
+// nodefony/src/oauth/providers/github.ts
 /** Scopes minimaux : profil public + emails (l'email primaire peut être privé). */
 const DEFAULT_SCOPES = ["read:user", "user:email"];
 const API = "https://api.github.com";
@@ -25,7 +26,17 @@ async function ghGet(url, accessToken) {
 		signal: AbortSignal.timeout(API_TIMEOUT_MS)
 	});
 	if (!res.ok) throw new Error(`GitHub API ${url} → ${res.status}`);
-	return readJsonBounded(res, MAX_PROFILE_BYTES, `GitHub API ${url}`);
+	return res;
+}
+/**
+* Les adresses que rend `GET /user/emails` — un tableau, sinon une erreur qui
+* nomme l'appel ; une entrée qui n'est pas un objet est écartée.
+*/
+async function ghEmails(accessToken) {
+	const url = `${API}/user/emails`;
+	const list = await readJsonBounded(await ghGet(url, accessToken), MAX_PROFILE_BYTES, `GitHub API ${url}`);
+	if (!Array.isArray(list)) throw new Error(`GitHub API ${url} → corps inattendu (tableau JSON attendu)`);
+	return list.filter(isPlainObject);
 }
 /**
 * Codes d'erreur PROPRES à GitHub, rendus dans leur équivalent RFC 6749 §5.2
@@ -86,7 +97,7 @@ function createGithubProvider(ctx) {
 		},
 		async fetchProfile(tokens) {
 			const accessToken = tokens.accessToken();
-			const user = await ghGet(`${API}/user`, accessToken);
+			const user = await readJsonObjectBounded(await ghGet(`${API}/user`, accessToken), MAX_PROFILE_BYTES, `GitHub API ${API}/user`);
 			const id = user.id;
 			if (typeof id !== "number" && typeof id !== "string") throw new Error("GitHub /user sans identifiant.");
 			const login = typeof user.login === "string" ? user.login : null;
@@ -94,7 +105,7 @@ function createGithubProvider(ctx) {
 			let email = typeof user.email === "string" ? user.email : null;
 			let emailVerified = email !== null;
 			if (email === null) {
-				const list = await ghGet(`${API}/user/emails`, accessToken);
+				const list = await ghEmails(accessToken);
 				const primary = list.find((e) => e.primary === true) ?? list.at(0) ?? null;
 				if (primary && typeof primary.email === "string") {
 					email = primary.email;
@@ -112,5 +123,4 @@ function createGithubProvider(ctx) {
 		}
 	};
 }
-//#endregion
 export { createGithubProvider };