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

package/dist/nodefony/controller/OAuth2Controller.js

@@ -1,20 +1,80 @@
-import Controller from "../src/Controller.js";
 import router_default from "../service/router.js";
-//#region nodefony/controller/OAuth2Controller.ts
+import SecurityApiController from "../src/SecurityApiController.js";
+import { OAUTH2_API_BASE, OAUTH2_FAILED_REASON, safeRedirectPath } from "nodefony";
+// nodefony/controller/OAuth2Controller.ts
 const STATE_KEY = "oauth2:state";
 const VERIFIER_KEY = "oauth2:verifier";
 const PROVIDER_KEY = "oauth2:provider";
+const FROM_KEY = "oauth2:from";
+const BACK_KEY = "oauth2:back";
 let mounted = false;
 /**
+* Codes d'erreur qu'un serveur d'autorisation peut renvoyer au callback, et
+* SEULS codes que l'écran d'arrivée reçoit : OAuth 2.0 (RFC 6749 §4.1.2.1) et
+* OpenID Connect Core (§3.1.2.6). Une liste fermée — jamais la chaîne reçue
+* telle quelle : le paramètre `error` vient de l'URL, donc de n'importe qui.
+*/
+const AUTHORIZATION_ERRORS = /* @__PURE__ */ new Set([
+	"invalid_request",
+	"unauthorized_client",
+	"access_denied",
+	"unsupported_response_type",
+	"invalid_scope",
+	"server_error",
+	"temporarily_unavailable",
+	"interaction_required",
+	"login_required",
+	"account_selection_required",
+	"consent_required"
+]);
+/**
+* Thème que la page appelante a rendu (`?theme=`), à transmettre à l'écran du
+* fournisseur. Liste FERMÉE : la chaîne vient de l'URL, toute autre valeur est
+* ignorée sans un mot — rien d'arbitraire n'atteint la requête d'autorisation.
+*
+* @param value - paramètre `theme` de la requête, ou `null`
+* @returns l'option à passer à `createAuthorization`, vide hors liste
+*/
+function providerThemeOption(value) {
+	return value === "light" || value === "dark" ? { theme: value } : {};
+}
+const PROBE_ORIGIN = "http://redirect.invalid";
+/**
+* Compose l'adresse de l'écran d'échec : la raison de l'échec, et la page où
+* aller une fois connecté, pour que l'écran la garde à la tentative suivante.
+*
+* `reason` vaut le code rendu par le fournisseur s'il appartient à la liste
+* normalisée (`access_denied` = l'utilisateur a choisi de revenir), sinon
+* {@link OAUTH2_FAILED_REASON} — jamais la chaîne reçue, qui vient de l'URL.
+* Une `reason` ou un `from` déjà présents sont REMPLACÉS (l'écran qui a lancé
+* le flux peut porter ceux d'une tentative précédente) ; le reste de la
+* requête et le fragment sont conservés, et une adresse relative reste relative.
+*
+* @param failure - l'écran d'échec : `back` revalidé, ou `failureRedirect`
+* @param error - le paramètre `error` reçu au callback, ou `null`
+* @param from - la page où aller une fois connecté (revalidée), ou `null`
+* @returns l'adresse de redirection
+*/
+function oauth2FailureTarget(failure, error, from) {
+	const reason = error !== null && AUTHORIZATION_ERRORS.has(error) ? error : OAUTH2_FAILED_REASON;
+	const absolute = /^[a-z][a-z0-9+.-]*:/i.test(failure);
+	const url = new URL(failure, PROBE_ORIGIN);
+	url.searchParams.set("reason", reason);
+	if (from === null) url.searchParams.delete("from");
+	else url.searchParams.set("from", from);
+	return absolute ? url.href : `${url.pathname}${url.search}${url.hash}`;
+}
+/**
 * Endpoints HTTP du **social login OAuth 2.0** (P6 J9) — adaptateurs MINCES
 * au-dessus du service `oauth2` (`@nodefony/security`) :
 *
-*  - `GET /nodefony/security/api/oauth2/{provider}/authorize` — démarre le flux :
-*    pose `state`+`code_verifier` en session (anonyme), redirige (302) vers le
-*    fournisseur.
+*  - `GET /nodefony/security/api/oauth2/{provider}/authorize?from=&back=` —
+*    démarre le flux : pose `state`+`code_verifier` en session (anonyme), avec
+*    les retours revalidés en chemins locaux, redirige (302) vers le fournisseur.
 *  - `GET /nodefony/security/api/oauth2/{provider}/callback` — valide le `state`
 *    (anti-CSRF), échange le `code`, provisionne le Shadow User et OUVRE la
-*    session BFF (302 vers `successRedirect`).
+*    session BFF (302 vers `from`, sinon `successRedirect`). Un échec mène à
+*    `back`, sinon à `failureRedirect`, avec `reason` et `from`.
 *
 * Montés UNIQUEMENT si le service `oauth2` existe (social login activé) — 404
 * sinon, zéro surface.
@@ -25,7 +85,7 @@ let mounted = false;
 * La session anonyme ne porte que `state`/`verifier` ; `establishSessionFor`
 * régénère l'ID (anti-fixation) à la promotion.
 */
-var OAuth2Controller = class extends Controller {
+var OAuth2Controller = class extends SecurityApiController {
 	constructor(context) {
 		super("OAuth2Controller", context);
 	}
@@ -55,7 +115,7 @@ var OAuth2Controller = class extends Controller {
 		if (!svc.listProviders().includes(provider)) return this.renderJson({ error: "Unknown provider" }, 404);
 		let auth;
 		try {
-			auth = await svc.createAuthorization(provider);
+			auth = await svc.createAuthorization(provider, providerThemeOption(this.#queryString("theme")));
 		} catch (error) {
 			this.log(`oauth2 authorize "${provider}" : ${error.message}`, "ERROR");
 			return this.renderJson({ error: "OAuth provider unavailable" }, 503);
@@ -65,6 +125,8 @@ var OAuth2Controller = class extends Controller {
 		session.set(STATE_KEY, auth.state);
 		session.set(VERIFIER_KEY, auth.codeVerifier);
 		session.set(PROVIDER_KEY, provider);
+		session.set(FROM_KEY, this.#localPath("from"));
+		session.set(BACK_KEY, this.#localPath("back"));
 		await session.save();
 		this.redirect(auth.url, 302);
 	}
@@ -78,28 +140,73 @@ var OAuth2Controller = class extends Controller {
 		const expectedState = session?.get(STATE_KEY);
 		const storedVerifier = session?.get(VERIFIER_KEY);
 		const expectedProvider = session?.get(PROVIDER_KEY);
+		const from = safeRedirectPath(session?.get(FROM_KEY), "") || null;
+		const back = safeRedirectPath(session?.get(BACK_KEY), "") || null;
 		session?.set(STATE_KEY, null);
 		session?.set(VERIFIER_KEY, null);
 		session?.set(PROVIDER_KEY, null);
+		session?.set(FROM_KEY, null);
+		session?.set(BACK_KEY, null);
 		await session?.save();
+		const failedAt = back ?? failure;
 		const code = this.#queryString("code");
 		const returnedState = this.#queryString("state");
 		const returnedIss = this.#queryString("iss");
-		if (code === null || returnedState === null || typeof expectedState !== "string" || returnedState !== expectedState || expectedProvider !== provider) {
-			this.redirect(failure, 302);
+		const stateIsValid = returnedState !== null && typeof expectedState === "string" && returnedState === expectedState && expectedProvider === provider;
+		if (code === null || !stateIsValid) {
+			const returnedError = code === null && stateIsValid ? this.#queryString("error") : null;
+			if (returnedError !== null) {
+				const logged = AUTHORIZATION_ERRORS.has(returnedError) ? returnedError : "code non normalisé";
+				this.log(`oauth2 callback "${provider}" : le fournisseur a répondu « ${logged} »`, "INFO");
+			}
+			this.redirect(oauth2FailureTarget(failedAt, returnedError, from), 302);
 			return;
 		}
 		try {
-			const { identifier } = await svc.exchangeAndProvision(provider, code, typeof storedVerifier === "string" ? storedVerifier : null, returnedIss);
+			const { identifier, logoutHint } = await svc.exchangeAndProvision(provider, code, typeof storedVerifier === "string" ? storedVerifier : null, returnedIss);
 			await flow.establishSessionFor(this.context, identifier, "oauth");
-			this.redirect(success, 302);
+			const opened = this.context.session;
+			if (opened && logoutHint !== void 0 && svc.rememberLogout) svc.rememberLogout(opened, logoutHint);
+			this.redirect(from ?? success, 302);
 			return;
 		} catch (error) {
 			this.log(`oauth2 callback "${provider}" : ${error.message.slice(0, 200)}`, "WARNING");
-			this.redirect(failure, 302);
+			this.redirect(oauth2FailureTarget(failedAt, null, from), 302);
 			return;
 		}
 	}
+	/**
+	* Canal arrière : le fournisseur demande de fermer les sessions qu'il
+	* désigne (OpenID Connect Back-Channel Logout 1.0 §2.5-2.8).
+	*
+	* Appelé serveur à serveur — ni cookie, ni session, ni jeton CSRF : la
+	* SIGNATURE du `logout_token` est la seule authentification. Réponses de la
+	* norme (§2.8) : 200 si la déconnexion a eu lieu (ou n'avait plus lieu
+	* d'être), 400 sinon — jeton refusé (`invalid_request`) comme déconnexion
+	* impossible (la cause part au journal, jamais au fournisseur). Toujours
+	* `Cache-Control: no-store`.
+	*/
+	async backchannelLogout(provider) {
+		const noStore = { "cache-control": "no-store" };
+		const svc = this.#service();
+		if (!svc || !svc.listProviders().includes(provider)) return this.renderJson({ error: "Unknown provider" }, 404, noStore);
+		if (!svc.backchannelLogout) return this.renderJson({ error: "Not implemented" }, 501, noStore);
+		const token = this.body?.logout_token;
+		if (typeof token !== "string" || token.length === 0) return this.renderJson({ error: "invalid_request" }, 400, noStore);
+		let outcome;
+		try {
+			({outcome} = await svc.backchannelLogout(provider, token));
+		} catch (error) {
+			this.log(`oauth2 back-channel logout "${provider}" : ${error.message.slice(0, 200)}`, "ERROR");
+			return this.renderJson({ error: "invalid_request" }, 400, noStore);
+		}
+		if (outcome === "unsupported") return this.renderJson({ error: "Not implemented" }, 501, noStore);
+		if (outcome === "refused") {
+			this.log(`oauth2 back-channel logout "${provider}" : jeton de déconnexion refusé`, "WARNING");
+			return this.renderJson({ error: "invalid_request" }, 400, noStore);
+		}
+		return this.renderResponse("", "utf8", 200, noStore);
+	}
 	#service() {
 		const svc = this.get("oauth2");
 		return svc?.isEnabled() ? svc : null;
@@ -107,9 +214,13 @@ var OAuth2Controller = class extends Controller {
 	#flow() {
 		return this.get("authFlow") ?? null;
 	}
+	/** Paramètre de query string revalidé en chemin local, ou `null`. */
+	#localPath(key) {
+		return safeRedirectPath(this.#queryString(key), "") || null;
+	}
 	/** Lit un paramètre de query string (GET), ou `null`. */
 	#queryString(key) {
-		const v = this.queryGet?.[key];
+		const v = this.query?.[key];
 		return typeof v === "string" && v.length > 0 ? v : null;
 	}
 };
@@ -119,7 +230,7 @@ var OAuth2Controller = class extends Controller {
 */
 function mountOAuth2Routes(frameworkModule) {
 	if (mounted) return;
-	const base = "/nodefony/security/api/oauth2";
+	const base = OAUTH2_API_BASE;
 	const routes = [
 		[
 			"security.oauth2.providers",
@@ -138,6 +249,12 @@ function mountOAuth2Routes(frameworkModule) {
 			`${base}/{provider}/callback`,
 			"GET",
 			"callback"
+		],
+		[
+			"security.oauth2.backchannelLogout",
+			`${base}/{provider}/backchannel-logout`,
+			"POST",
+			"backchannelLogout"
 		]
 	];
 	for (const [name, path, method, classMethod] of routes) router_default.createRoute(name, {
@@ -150,5 +267,4 @@ function mountOAuth2Routes(frameworkModule) {
 	if (!Object.prototype.hasOwnProperty.call(OAuth2Controller.prototype, "module")) router_default.setController(OAuth2Controller, frameworkModule);
 	mounted = true;
 }
-//#endregion
-export { OAuth2Controller as default, mountOAuth2Routes };
+export { OAuth2Controller as default, mountOAuth2Routes, oauth2FailureTarget, providerThemeOption };

package/dist/nodefony/controller/ProtectedResourceMetadataController.js

@@ -2,7 +2,7 @@ import Controller from "../src/Controller.js";
 import router_default from "../service/router.js";
 import { askedAuthority, onDeclaredAuthority } from "./oauthAuthority.js";
 import { buildProtectedResourceMetadata, canonicalResourceUri, protectedResourceMetadataPath } from "nodefony";
-//#region nodefony/controller/ProtectedResourceMetadataController.ts
+// nodefony/controller/ProtectedResourceMetadataController.ts
 let mounted = false;
 /**
 * Ce qui a été PUBLIÉ au montage — la même liste qui a décidé des chemins.
@@ -217,5 +217,4 @@ function mountProtectedResourceRoutes(frameworkModule, resources) {
 	mounted = true;
 	return paths.length;
 }
-//#endregion
 export { collectProtectedResources, ProtectedResourceMetadataController as default, mountProtectedResourceRoutes, protectedResourceRoutePaths };

package/dist/nodefony/controller/SessionAuthController.js

@@ -1,6 +1,9 @@
-import Controller from "../src/Controller.js";
+import { CsrfProtect } from "../decorators/routerDecorators.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
 import router_default from "../service/router.js";
-//#region nodefony/controller/SessionAuthController.ts
+import SecurityApiController from "../src/SecurityApiController.js";
+import { AUTH_API_BASE } from "nodefony";
+// nodefony/controller/SessionAuthController.ts
 let mounted = false;
 /**
 * Endpoints HTTP du flux de session BFF — adaptateurs MINCES au-dessus du
@@ -8,7 +11,8 @@ let mounted = false;
 *
 *  - `POST /nodefony/security/api/auth/login`  — body JSON `{username, password}`
 *  - `POST /nodefony/security/api/auth/logout` — idempotent
-*  - `GET  /nodefony/security/api/auth/me`     — identité de la session courante
+*  - `GET  /nodefony/security/api/auth/me`     — identité de la session courante :
+*    TOUJOURS `200`, `{ user }` ou `{ user: null }` sans session
 *
 * Montés par le module framework UNIQUEMENT si le service `authFlow` existe
 * (module security chargé) — sans lui, les routes n'existent pas (404, zéro
@@ -19,14 +23,20 @@ let mounted = false;
 * `Retry-After` (RFC 6585) posé par le throttler NIST ; tout le reste remonte
 * au pipeline d'erreurs standard (500, détail loggé jamais fuité).
 *
-* @remarks Dérogation RFC 7235 §3.1 DÉLIBÉRÉE : les 401 de `login`/`me` ne
+* `me` est une SONDE d'état, pas une ressource protégée : « pas de session »
+* est un état normal du navigateur, pas une faute — d'où `200` + `{ user:
+* null }`, comme les bibliothèques qui livrent aussi le client de connexion
+* (Auth.js, better-auth). Le `401` y écrivait une erreur réseau dans la console
+* de chaque visiteur anonyme, sans rien protéger : la réponse ne révèle rien.
+*
+* @remarks Dérogation RFC 9110 §15.5.2 DÉLIBÉRÉE : les 401 de `login` ne
 * portent PAS de `WWW-Authenticate` — aucun scheme HTTP ne décrit un cookie de
 * session, et un challenge `Basic` mensonger déclencherait le popup natif du
 * navigateur (l'anti-pattern que le BFF élimine). Les zones du firewall, elles,
 * restent strictement conformes (challenge du premier authenticator qui en
 * déclare un).
 */
-var SessionAuthController = class extends Controller {
+var SessionAuthController = class extends SecurityApiController {
 	constructor(context) {
 		super("SessionAuthController", context);
 	}
@@ -34,7 +44,7 @@ var SessionAuthController = class extends Controller {
 	async login() {
 		const flow = this.#flow();
 		if (!flow) return this.renderJson({ error: "Authentication unavailable" }, 503);
-		const body = this.queryPost ?? {};
+		const body = this.body ?? {};
 		try {
 			const outcome = await flow.login(this.context, body.username, body.password);
 			if (outcome.status === "mfa_required") return await this.renderJson({
@@ -54,7 +64,7 @@ var SessionAuthController = class extends Controller {
 	async loginTotp() {
 		const flow = this.#flow();
 		if (!flow) return this.renderJson({ error: "Authentication unavailable" }, 503);
-		const body = this.queryPost ?? {};
+		const body = this.body ?? {};
 		try {
 			const user = await flow.completeMfaLogin(this.context, body.code);
 			return await this.renderJson({ user });
@@ -62,19 +72,42 @@ var SessionAuthController = class extends Controller {
 			return this.#renderAuthError(e);
 		}
 	}
-	/** Détruit la session (storage + cookie). Toujours 200 (idempotent). */
+	/**
+	* Détruit la session (storage + cookie). Toujours 200 (idempotent). Quand la
+	* session venait d'un fournisseur qui publie un point de déconnexion, la
+	* réponse porte `logoutUrl` : le client y envoie le navigateur pour fermer
+	* aussi la session du fournisseur.
+	*/
 	async logout() {
 		const flow = this.#flow();
 		if (!flow) return this.renderJson({ error: "Authentication unavailable" }, 503);
-		await flow.logout(this.context);
+		const context = this.context;
+		if (flow.logoutWithProvider) {
+			const { logoutUrl } = await flow.logoutWithProvider(context);
+			return this.renderJson(logoutUrl ? {
+				ok: true,
+				logoutUrl
+			} : { ok: true });
+		}
+		await flow.logout(context);
 		return this.renderJson({ ok: true });
 	}
-	/** Identité de la session courante, re-résolue (rôles frais), ou 401. */
+	/**
+	* Identité de la session courante, re-résolue (rôles frais). Toujours `200` :
+	* `{ user: null }` quand il n'y a pas de session (ou qu'elle ne mène plus à
+	* un compte actif) — l'absence de session est un état, pas une erreur.
+	*
+	* **Sème aussi le jeton anti-CSRF** (cookie lisible `csrf-token`) : c'est la
+	* seule requête sûre que TOUT client connaît d'avance. Sans elle, une mutation
+	* `@CsrfProtect` n'a de jeton à rejouer que si son auteur a AUSSI décoré une
+	* lecture — protéger les seules écritures, le geste naturel, rendait alors 403
+	* sans issue, au navigateur comme aux tests générés. Le jeton est sans état
+	* (HMAC) : celui-ci vaut pour toute route protégée.
+	*/
 	async me() {
 		const flow = this.#flow();
 		if (!flow) return this.renderJson({ error: "Authentication unavailable" }, 503);
 		const user = await flow.me(this.context);
-		if (user === null) return this.renderJson({ error: "Unauthorized" }, 401);
 		return this.renderJson({ user });
 	}
 	#flow() {
@@ -87,9 +120,14 @@ var SessionAuthController = class extends Controller {
 			return this.renderJson({ error: "Too many attempts" }, 429, { "retry-after": String(typeof retry === "number" ? retry : 1) });
 		}
 		if (code === 401) return this.renderJson({ error: "Invalid credentials" }, 401);
+		if (code === 403) {
+			const message = e instanceof Error ? e.message : "Forbidden";
+			return this.renderJson({ error: message }, 403);
+		}
 		throw e;
 	}
 };
+__decorate([CsrfProtect()], SessionAuthController.prototype, "me", null);
 /**
 * Monte les routes du flux de session BFF — appelé par le module framework à
 * `onKernelReady`, seulement si le service `authFlow` est présent.
@@ -100,7 +138,7 @@ var SessionAuthController = class extends Controller {
 */
 function mountSessionAuthRoutes(frameworkModule) {
 	if (mounted) return;
-	const base = "/nodefony/security/api/auth";
+	const base = AUTH_API_BASE;
 	const routes = [
 		[
 			"security.auth.login",
@@ -137,5 +175,4 @@ function mountSessionAuthRoutes(frameworkModule) {
 	if (!Object.prototype.hasOwnProperty.call(SessionAuthController.prototype, "module")) router_default.setController(SessionAuthController, frameworkModule);
 	mounted = true;
 }
-//#endregion
 export { SessionAuthController as default, mountSessionAuthRoutes };

package/dist/nodefony/controller/TokenAuthController.js

@@ -1,6 +1,6 @@
-import Controller from "../src/Controller.js";
 import router_default from "../service/router.js";
-//#region nodefony/controller/TokenAuthController.ts
+import SecurityApiController from "../src/SecurityApiController.js";
+// nodefony/controller/TokenAuthController.ts
 let mounted = false;
 /** Normalise le paramètre `scope` (string OAuth « a b c » ou tableau) → string[]. */
 function parseScope(scope) {
@@ -24,11 +24,11 @@ function parseScope(scope) {
 * framework ne peut pas importer les classes d'erreur de security ; un 429
 * reporte le `Retry-After` (RFC 6585) du throttler NIST.
 *
-* @remarks Dérogation RFC 7235 §3.1 (comme `SessionAuthController`) : ces 401 ne
+* @remarks Dérogation RFC 9110 §15.5.2 (comme `SessionAuthController`) : ces 401 ne
 * portent pas de `WWW-Authenticate` — l'endpoint d'émission n'est pas une
 * ressource protégée par Bearer, il DÉLIVRE le Bearer.
 */
-var TokenAuthController = class extends Controller {
+var TokenAuthController = class extends SecurityApiController {
 	constructor(context) {
 		super("TokenAuthController", context);
 	}
@@ -36,9 +36,9 @@ var TokenAuthController = class extends Controller {
 	async token() {
 		const svc = this.#issuer();
 		if (!svc || !svc.isEnabled()) return this.renderJson({ error: "Token issuance unavailable" }, 503);
-		const body = this.queryPost ?? {};
+		const body = this.body ?? {};
 		try {
-			const tokens = await svc.issueForCredentials(body.username, body.password, parseScope(body.scope), body.resource);
+			const tokens = await svc.issueForCredentials(body.username, body.password, parseScope(body.scope), body.resource, this.context);
 			return await this.renderJson(tokens);
 		} catch (e) {
 			return this.#renderAuthError(e);
@@ -48,7 +48,7 @@ var TokenAuthController = class extends Controller {
 	async refresh() {
 		const svc = this.#issuer();
 		if (!svc || !svc.isEnabled()) return this.renderJson({ error: "Token issuance unavailable" }, 503);
-		const body = this.queryPost ?? {};
+		const body = this.body ?? {};
 		try {
 			const tokens = await svc.refresh(body.refresh_token, body.resource);
 			return await this.renderJson(tokens);
@@ -73,6 +73,13 @@ var TokenAuthController = class extends Controller {
 			return this.renderJson({ error: "Too many attempts" }, 429, { "retry-after": String(typeof retry === "number" ? retry : 1) });
 		}
 		if (code === 401) return this.renderJson({ error: "invalid_grant" }, 401);
+		if (code === 403) {
+			const description = e instanceof Error ? e.message : "Forbidden";
+			return this.renderJson({
+				error: "invalid_request",
+				error_description: description
+			}, 403);
+		}
 		throw e;
 	}
 };
@@ -109,5 +116,4 @@ function mountTokenAuthRoutes(frameworkModule) {
 	if (!Object.prototype.hasOwnProperty.call(TokenAuthController.prototype, "module")) router_default.setController(TokenAuthController, frameworkModule);
 	mounted = true;
 }
-//#endregion
 export { TokenAuthController as default, mountTokenAuthRoutes };

package/dist/nodefony/controller/TotpController.js

@@ -1,6 +1,6 @@
-import Controller from "../src/Controller.js";
 import router_default from "../service/router.js";
-//#region nodefony/controller/TotpController.ts
+import SecurityApiController from "../src/SecurityApiController.js";
+// nodefony/controller/TotpController.ts
 let mounted = false;
 /**
 * Endpoints HTTP **self-service 2FA TOTP (P6.17)** — console « ma sécurité »,
@@ -20,7 +20,7 @@ let mounted = false;
 * `totp` existe (security chargé) — sans security, 404 et zéro surface ; 2FA
 * désactivé, les routes répondent 503.
 */
-var TotpController = class extends Controller {
+var TotpController = class extends SecurityApiController {
 	constructor(context) {
 		super("TotpController", context);
 	}
@@ -39,11 +39,11 @@ var TotpController = class extends Controller {
 		if (!svc) return this.renderJson({ error: "2FA unavailable" }, 503);
 		const subject = await this.#currentSubject();
 		if (subject === null) return this.renderJson({ error: "Unauthorized" }, 401);
-		const code = this.queryPost?.code;
+		const code = this.body?.code;
 		if (typeof code !== "string" || code.length === 0) return this.renderJson({ error: "Invalid code" }, 400);
 		let activation;
 		try {
-			activation = await svc.confirmEnrollment(subject, code);
+			activation = await svc.confirmEnrollment(subject, code, this.context);
 		} catch {
 			return this.renderJson({ error: "Invalid or expired code" }, 400);
 		}
@@ -55,7 +55,7 @@ var TotpController = class extends Controller {
 		if (!svc) return this.renderJson({ error: "2FA unavailable" }, 503);
 		const subject = await this.#currentSubject();
 		if (subject === null) return this.renderJson({ error: "Unauthorized" }, 401);
-		await svc.disable(subject);
+		await svc.disable(subject, this.context);
 		return this.renderJson({ ok: true });
 	}
 	/** État 2FA du porteur courant (alimente la console « ma sécurité »). */
@@ -78,7 +78,7 @@ var TotpController = class extends Controller {
 		const flow = this.#flow();
 		if (!flow) return null;
 		const me = await flow.me(this.context);
-		return me && typeof me.username === "string" ? me.username : null;
+		return me && typeof me.identifier === "string" ? me.identifier : null;
 	}
 };
 /**
@@ -128,5 +128,4 @@ function mountTotpRoutes(frameworkModule) {
 	if (!Object.prototype.hasOwnProperty.call(TotpController.prototype, "module")) router_default.setController(TotpController, frameworkModule);
 	mounted = true;
 }
-//#endregion
 export { TotpController as default, mountTotpRoutes };

package/dist/nodefony/controller/WebAuthnController.js

@@ -1,6 +1,7 @@
-import Controller from "../src/Controller.js";
 import router_default from "../service/router.js";
-//#region nodefony/controller/WebAuthnController.ts
+import SecurityApiController from "../src/SecurityApiController.js";
+import { WEBAUTHN_API_BASE, WEBAUTHN_STATUS_PATH } from "nodefony";
+// nodefony/controller/WebAuthnController.ts
 const REG_CHALLENGE = "webauthn:reg:challenge";
 const AUTH_CHALLENGE = "webauthn:auth:challenge";
 let mounted = false;
@@ -31,10 +32,18 @@ let mounted = false;
 * firewall (qui, sur l'aire data plane, déclencherait un deadlock identique au
 * login BFF).
 */
-var WebAuthnController = class extends Controller {
+var WebAuthnController = class extends SecurityApiController {
 	constructor(context) {
 		super("WebAuthnController", context);
 	}
+	/**
+	* Dit si la connexion par passkey répondra : `{ enabled }`, toujours `200`.
+	* Un écran de connexion le lit pour ne pas proposer un bouton dont la
+	* cérémonie répondrait `503` (passkeys coupées).
+	*/
+	status() {
+		return this.renderJson({ enabled: this.#service() !== null });
+	}
 	/** Défi d'enregistrement — l'utilisateur connecté ajoute un passkey. */
 	async registerOptions() {
 		const svc = this.#service();
@@ -43,8 +52,9 @@ var WebAuthnController = class extends Controller {
 		const me = await flow.me(this.context);
 		if (!me) return this.renderJson({ error: "Unauthorized" }, 401);
 		const options = await svc.generateRegistrationOptions({
-			id: me.username,
-			name: me.username
+			id: me.identifier,
+			name: me.identifier,
+			handle: me.id
 		});
 		const session = await flow.ensureSession(this.context);
 		session?.set(REG_CHALLENGE, options.challenge);
@@ -60,7 +70,7 @@ var WebAuthnController = class extends Controller {
 		const challenge = await this.#takeChallenge(REG_CHALLENGE);
 		if (!challenge) return this.renderJson({ error: "No challenge" }, 400);
 		try {
-			const credential = await svc.verifyRegistration(this.#body().response, challenge, me.username, this.#origin());
+			const credential = await svc.verifyRegistration(this.#body().response, challenge, me.identifier, this.#origin());
 			return await this.renderJson({
 				verified: true,
 				credentialId: credential.id
@@ -90,7 +100,7 @@ var WebAuthnController = class extends Controller {
 		const flow = this.#flow();
 		if (!svc || !flow) return this.renderJson({ error: "WebAuthn unavailable" }, 503);
 		const me = await flow.me(this.context);
-		const options = await svc.generateAuthenticationOptions(me?.username);
+		const options = await svc.generateAuthenticationOptions(me?.identifier);
 		const session = await flow.ensureSession(this.context);
 		session?.set(AUTH_CHALLENGE, options.challenge);
 		await session?.save();
@@ -121,7 +131,7 @@ var WebAuthnController = class extends Controller {
 		if (!svc || !flow) return this.renderJson({ error: "WebAuthn unavailable" }, 503);
 		const me = await flow.me(this.context);
 		if (!me) return this.renderJson({ error: "Unauthorized" }, 401);
-		const creds = await svc.listUserCredentials(me.username);
+		const creds = await svc.listUserCredentials(me.identifier);
 		return this.renderJson({ credentials: creds.map((c) => ({
 			id: c.id,
 			transports: c.transports,
@@ -138,7 +148,7 @@ var WebAuthnController = class extends Controller {
 		const me = await flow.me(this.context);
 		if (!me) return this.renderJson({ error: "Unauthorized" }, 401);
 		if (typeof id !== "string" || id.length === 0) return this.renderJson({ error: "Not found" }, 404);
-		if (!await svc.removeUserCredential(me.username, id)) return this.renderJson({ error: "Not found" }, 404);
+		if (!await svc.removeUserCredential(me.identifier, id)) return this.renderJson({ error: "Not found" }, 404);
 		return this.renderJson({ ok: true });
 	}
 	#service() {
@@ -154,7 +164,7 @@ var WebAuthnController = class extends Controller {
 	* cérémonie est découvrable (cf {@link WebAuthnController.loginOptions}).
 	*/
 	#body() {
-		return this.queryPost ?? {};
+		return this.body ?? {};
 	}
 	/** Origine HTTP de la requête (validée par le service contre le rpID). */
 	#origin() {
@@ -183,7 +193,7 @@ var WebAuthnController = class extends Controller {
 */
 function mountWebAuthnRoutes(frameworkModule) {
 	if (mounted) return;
-	const base = "/nodefony/security/api/webauthn";
+	const base = WEBAUTHN_API_BASE;
 	const routes = [
 		[
 			"security.webauthn.register.options",
@@ -199,6 +209,13 @@ function mountWebAuthnRoutes(frameworkModule) {
 			"registerVerify",
 			true
 		],
+		[
+			"security.webauthn.status",
+			WEBAUTHN_STATUS_PATH,
+			"GET",
+			"status",
+			true
+		],
 		[
 			"security.webauthn.login.options",
 			`${base}/login/options`,
@@ -238,5 +255,4 @@ function mountWebAuthnRoutes(frameworkModule) {
 	if (!Object.prototype.hasOwnProperty.call(WebAuthnController.prototype, "module")) router_default.setController(WebAuthnController, frameworkModule);
 	mounted = true;
 }
-//#endregion
 export { WebAuthnController as default, mountWebAuthnRoutes };

package/dist/nodefony/controller/oauthAuthority.js

@@ -1,4 +1,4 @@
-//#region nodefony/controller/oauthAuthority.ts
+// nodefony/controller/oauthAuthority.ts
 /**
 * Une seule règle : un document bien connu ne se sert QUE sur l'autorité dont
 * il se réclame.
@@ -70,5 +70,4 @@ function askedAuthority(headers) {
 	const asked = Array.isArray(raw) ? raw[0] : raw;
 	return typeof asked === "string" && asked.length > 0 ? asked : void 0;
 }
-//#endregion
 export { askedAuthority, onDeclaredAuthority };