@nodefony/framework 10.0.0-alpha.1

package/dist/nodefony/controller/SessionAuthController.js

@@ -0,0 +1,141 @@
+import Controller from "../src/Controller.js";
+import router_default from "../service/router.js";
+//#region nodefony/controller/SessionAuthController.ts
+let mounted = false;
+/**
+* Endpoints HTTP du flux de session BFF — adaptateurs MINCES au-dessus du
+* service `authFlow` (`@nodefony/security`) :
+*
+*  - `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
+*
+* 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
+* surface). Remplace les mocks `/nodefony/studio/api/auth/*` de Studio.
+*
+* Erreurs : mappées par DUCK-TYPING sur `code` (401/429) — framework ne peut
+* pas importer les classes d'erreur de security. Un 429 reporte le
+* `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
+* 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 {
+	constructor(context) {
+		super("SessionAuthController", context);
+	}
+	/** Login BFF : credential JSON présenté UNE fois → cookie de session opaque. */
+	async login() {
+		const flow = this.#flow();
+		if (!flow) return this.renderJson({ error: "Authentication unavailable" }, 503);
+		const body = this.queryPost ?? {};
+		try {
+			const outcome = await flow.login(this.context, body.username, body.password);
+			if (outcome.status === "mfa_required") return this.renderJson({
+				mfaRequired: true,
+				methods: outcome.methods
+			}, 202);
+			return this.renderJson({ user: outcome.user });
+		} catch (e) {
+			return this.#renderAuthError(e);
+		}
+	}
+	/**
+	* Second facteur (TOTP ou code de récupération) après un `login` ayant répondu
+	* `202 mfaRequired`. Body JSON `{ code }`. Succès → 200 + identité ; code
+	* absent/invalide → 401 (uniforme) ; trop de tentatives → 429 (Retry-After).
+	*/
+	async loginTotp() {
+		const flow = this.#flow();
+		if (!flow) return this.renderJson({ error: "Authentication unavailable" }, 503);
+		const body = this.queryPost ?? {};
+		try {
+			const user = await flow.completeMfaLogin(this.context, body.code);
+			return this.renderJson({ user });
+		} catch (e) {
+			return this.#renderAuthError(e);
+		}
+	}
+	/** Détruit la session (storage + cookie). Toujours 200 (idempotent). */
+	async logout() {
+		const flow = this.#flow();
+		if (!flow) return this.renderJson({ error: "Authentication unavailable" }, 503);
+		await flow.logout(this.context);
+		return this.renderJson({ ok: true });
+	}
+	/** Identité de la session courante, re-résolue (rôles frais), ou 401. */
+	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() {
+		return this.get("authFlow") ?? null;
+	}
+	#renderAuthError(e) {
+		const code = e.code;
+		if (code === 429) {
+			const retry = e.retryAfterS;
+			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);
+		throw e;
+	}
+};
+/**
+* Monte les routes du flux de session BFF — appelé par le module framework à
+* `onKernelReady`, seulement si le service `authFlow` est présent.
+*
+* Routes nommées `security.auth.*` (espace data plane
+* `/nodefony/security/api/*`, convention « toujours ≥ 3 segments »). HTTP-only :
+* la sémantique session-par-socket du pont WS-RPC n'est pas conçue (P6+).
+*/
+function mountSessionAuthRoutes(frameworkModule) {
+	if (mounted) return;
+	const base = "/nodefony/security/api/auth";
+	const routes = [
+		[
+			"security.auth.login",
+			`${base}/login`,
+			"POST",
+			"login"
+		],
+		[
+			"security.auth.login.totp",
+			`${base}/login/totp`,
+			"POST",
+			"loginTotp"
+		],
+		[
+			"security.auth.logout",
+			`${base}/logout`,
+			"POST",
+			"logout"
+		],
+		[
+			"security.auth.me",
+			`${base}/me`,
+			"GET",
+			"me"
+		]
+	];
+	for (const [name, path, method, classMethod] of routes) router_default.createRoute(name, {
+		path,
+		constructor: SessionAuthController,
+		classMethod,
+		requirements: { methods: [method] },
+		bypassFirewall: true
+	});
+	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

@@ -0,0 +1,113 @@
+import Controller from "../src/Controller.js";
+import router_default from "../service/router.js";
+//#region nodefony/controller/TokenAuthController.ts
+let mounted = false;
+/** Normalise le paramètre `scope` (string OAuth « a b c » ou tableau) → string[]. */
+function parseScope(scope) {
+	if (typeof scope === "string" && scope.trim().length > 0) return scope.trim().split(/\s+/);
+	if (Array.isArray(scope)) return scope.filter((s) => typeof s === "string");
+}
+/**
+* Endpoints HTTP d'émission/rotation de **JWT** — adaptateurs MINCES au-dessus du
+* service `tokenService` (`@nodefony/security`) :
+*
+*  - `POST /nodefony/security/api/token`         — body `{username, password, scope?}`
+*    → `{access_token, refresh_token, token_type, expires_in, scope}` (RFC 6749 §5.1)
+*  - `POST /nodefony/security/api/token/refresh` — body `{refresh_token}` → rotation
+*
+* Montés par le module framework UNIQUEMENT si le service `tokenService` existe
+* (module security chargé + JWT activé) — sans lui, les routes n'existent pas
+* (404, zéro surface).
+*
+* Le JWT part en **réponse JSON** (Bearer), JAMAIS en cookie ni en URL (anti
+* fuite / non-révocable). Erreurs mappées par DUCK-TYPING sur `code` (401/429) —
+* 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
+* 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 {
+	constructor(context) {
+		super("TokenAuthController", context);
+	}
+	/** Émission : credential présenté → couple access/refresh. */
+	async token() {
+		const svc = this.#issuer();
+		if (!svc || !svc.isEnabled()) return this.renderJson({ error: "Token issuance unavailable" }, 503);
+		const body = this.queryPost ?? {};
+		try {
+			const tokens = await svc.issueForCredentials(body.username, body.password, parseScope(body.scope), body.resource);
+			return this.renderJson(tokens);
+		} catch (e) {
+			return this.#renderAuthError(e);
+		}
+	}
+	/** Rotation : refresh présenté → nouveau couple (ancien révoqué). */
+	async refresh() {
+		const svc = this.#issuer();
+		if (!svc || !svc.isEnabled()) return this.renderJson({ error: "Token issuance unavailable" }, 503);
+		const body = this.queryPost ?? {};
+		try {
+			const tokens = await svc.refresh(body.refresh_token, body.resource);
+			return this.renderJson(tokens);
+		} catch (e) {
+			return this.#renderAuthError(e);
+		}
+	}
+	#issuer() {
+		return this.get("tokenService") ?? null;
+	}
+	#renderAuthError(e) {
+		const code = e.code;
+		if (code === 400) {
+			const oauthError = e.oauthError;
+			return this.renderJson({
+				error: typeof oauthError === "string" ? oauthError : "invalid_request",
+				error_description: e.message
+			}, 400);
+		}
+		if (code === 429) {
+			const retry = e.retryAfterS;
+			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);
+		throw e;
+	}
+};
+/**
+* Monte les routes d'émission/rotation JWT — appelé par le module framework à
+* `onKernelReady`, seulement si le service `tokenService` est présent.
+*
+* Routes nommées `security.token.*` (espace data plane `/nodefony/security/api/*`).
+* `bypassFirewall: true` : ces routes SONT le mécanisme d'émission — l'aire data
+* plane les matcherait sinon (obtenir un token exigerait d'être déjà authentifié,
+* deadlock).
+*/
+function mountTokenAuthRoutes(frameworkModule) {
+	if (mounted) return;
+	const base = "/nodefony/security/api/token";
+	const routes = [[
+		"security.token.issue",
+		base,
+		"POST",
+		"token"
+	], [
+		"security.token.refresh",
+		`${base}/refresh`,
+		"POST",
+		"refresh"
+	]];
+	for (const [name, path, method, classMethod] of routes) router_default.createRoute(name, {
+		path,
+		constructor: TokenAuthController,
+		classMethod,
+		requirements: { methods: [method] },
+		bypassFirewall: true
+	});
+	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

@@ -0,0 +1,129 @@
+import Controller from "../src/Controller.js";
+import router_default from "../service/router.js";
+//#region nodefony/controller/TotpController.ts
+let mounted = false;
+/**
+* Endpoints HTTP **self-service 2FA TOTP (P6.17)** — console « ma sécurité »,
+* adaptateurs MINCES au-dessus du service `totp` (`@nodefony/security`) :
+*
+*  - `POST /nodefony/security/api/totp/enroll`  → `{secretBase32, otpauthUri}`
+*    (secret affiché 1× pour le QR ; secret PENDING tant que non confirmé)
+*  - `POST /nodefony/security/api/totp/confirm` — body `{code}` → `{recoveryCodes}`
+*    (active le 2FA ; codes de récupération affichés 1×)
+*  - `POST /nodefony/security/api/totp/disable` → `{ok}` (retire le 2FA)
+*  - `GET  /nodefony/security/api/totp/status`  → `{enabled, pending, recoveryCodesRemaining}`
+*
+* **PAS de `bypassFirewall`** (≠ login/totp) : ces routes vivent DANS la zone data
+* plane `^/nodefony/[^/]+/api(/|$)` → **session BFF requise**. Le sujet est
+* TOUJOURS l'utilisateur courant (`authFlow.me`), jamais un paramètre — on n'active
+* /ne désactive jamais le 2FA d'autrui (anti-IDOR). Montés seulement si le service
+* `totp` existe (security chargé + 2FA activé) → 404, zéro surface, sinon.
+*/
+var TotpController = class extends Controller {
+	constructor(context) {
+		super("TotpController", context);
+	}
+	/** Démarre l'enrôlement : secret + URI otpauth affichés une seule fois. */
+	async enroll() {
+		const svc = this.#service();
+		if (!svc) return this.renderJson({ error: "2FA unavailable" }, 503);
+		const subject = await this.#currentSubject();
+		if (subject === null) return this.renderJson({ error: "Unauthorized" }, 401);
+		const enrollment = await svc.beginEnrollment(subject, subject);
+		return this.renderJson(enrollment);
+	}
+	/** Confirme l'enrôlement par un 1ᵉʳ code → active + codes de récupération (1×). */
+	async confirm() {
+		const svc = this.#service();
+		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;
+		if (typeof code !== "string" || code.length === 0) return this.renderJson({ error: "Invalid code" }, 400);
+		try {
+			const activation = await svc.confirmEnrollment(subject, code);
+			return this.renderJson(activation);
+		} catch {
+			return this.renderJson({ error: "Invalid or expired code" }, 400);
+		}
+	}
+	/** Désactive le 2FA du porteur courant (retire secret + codes). */
+	async disable() {
+		const svc = this.#service();
+		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);
+		return this.renderJson({ ok: true });
+	}
+	/** État 2FA du porteur courant (alimente la console « ma sécurité »). */
+	async status() {
+		const svc = this.#service();
+		if (!svc) return this.renderJson({ error: "2FA unavailable" }, 503);
+		const subject = await this.#currentSubject();
+		if (subject === null) return this.renderJson({ error: "Unauthorized" }, 401);
+		return this.renderJson(await svc.status(subject));
+	}
+	#service() {
+		const svc = this.get("totp");
+		return svc && svc.isEnabled() ? svc : null;
+	}
+	#flow() {
+		return this.get("authFlow") ?? null;
+	}
+	/** Identifiant du porteur courant (session BFF revalidée), ou `null`. */
+	async #currentSubject() {
+		const flow = this.#flow();
+		if (!flow) return null;
+		const me = await flow.me(this.context);
+		return me && typeof me.username === "string" ? me.username : null;
+	}
+};
+/**
+* Monte les routes self-service 2FA — appelé par le module framework à
+* `onKernelReady`, seulement si le service `totp` est présent.
+*
+* Routes nommées `security.totp.*` (espace data plane `/nodefony/security/api/*`).
+* **Aucun `bypassFirewall`** : l'aire data plane (session BFF) les garde — gérer
+* son 2FA exige d'être authentifié.
+*/
+function mountTotpRoutes(frameworkModule) {
+	if (mounted) return;
+	const base = "/nodefony/security/api/totp";
+	const routes = [
+		[
+			"security.totp.enroll",
+			`${base}/enroll`,
+			"POST",
+			"enroll"
+		],
+		[
+			"security.totp.confirm",
+			`${base}/confirm`,
+			"POST",
+			"confirm"
+		],
+		[
+			"security.totp.disable",
+			`${base}/disable`,
+			"POST",
+			"disable"
+		],
+		[
+			"security.totp.status",
+			`${base}/status`,
+			"GET",
+			"status"
+		]
+	];
+	for (const [name, path, method, classMethod] of routes) router_default.createRoute(name, {
+		path,
+		constructor: TotpController,
+		classMethod,
+		requirements: { methods: [method] }
+	});
+	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

@@ -0,0 +1,242 @@
+import Controller from "../src/Controller.js";
+import router_default from "../service/router.js";
+//#region nodefony/controller/WebAuthnController.ts
+const REG_CHALLENGE = "webauthn:reg:challenge";
+const AUTH_CHALLENGE = "webauthn:auth:challenge";
+let mounted = false;
+/**
+* Endpoints HTTP des cérémonies **WebAuthn / passkeys** (P6 J9) — adaptateurs
+* MINCES au-dessus du service `webauthn` (`@nodefony/security`) :
+*
+*  - `POST /nodefony/security/api/webauthn/register/options` — défi de création
+*    (utilisateur DÉJÀ connecté : lie un passkey à son compte)
+*  - `POST /nodefony/security/api/webauthn/register/verify`  — vérifie + stocke
+*  - `POST /nodefony/security/api/webauthn/login/options`    — défi d'assertion
+*  - `POST /nodefony/security/api/webauthn/login/verify`     — vérifie + ouvre
+*    la session BFF (l'empreinte remplace le mot de passe)
+*
+* Le **challenge** est stocké côté serveur en session (jamais rejouable) entre
+* `options` et `verify`.
+*
+* **Deux conditions distinctes, deux réponses distinctes** : les routes ne sont
+* montées que si le service `webauthn` est dans le container (`framework/index.ts:400`),
+* c'est-à-dire dès que `@nodefony/security` est chargé — sans security, **404**,
+* zéro surface. Le service reste enregistré même passkeys DÉSACTIVÉS
+* (`@services` l'instancie inconditionnellement) : dans ce cas les routes existent
+* et répondent **503** (`isEnabled()` faux). Ne pas lire un 503 comme « route
+* absente », ni un 404 comme « passkeys coupés ».
+*
+* @remarks `bypassFirewall` : `login/*` précède toute authentification ;
+* `register/*` exige une session active, vérifiée ICI (`me()` → 401), pas par le
+* firewall (qui, sur l'aire data plane, déclencherait un deadlock identique au
+* login BFF).
+*/
+var WebAuthnController = class extends Controller {
+	constructor(context) {
+		super("WebAuthnController", context);
+	}
+	/** Défi d'enregistrement — l'utilisateur connecté ajoute un passkey. */
+	async registerOptions() {
+		const svc = this.#service();
+		const flow = this.#flow();
+		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 options = await svc.generateRegistrationOptions({
+			id: me.username,
+			name: me.username
+		});
+		const session = await flow.ensureSession(this.context);
+		session?.set(REG_CHALLENGE, options.challenge);
+		await session?.save();
+		return this.renderJson(options);
+	}
+	/** Vérifie la réponse d'enregistrement et persiste le credential. */
+	async registerVerify() {
+		const svc = this.#service();
+		if (!svc) return this.renderJson({ error: "WebAuthn unavailable" }, 503);
+		const me = await this.#flow()?.me(this.context);
+		if (!me) return this.renderJson({ error: "Unauthorized" }, 401);
+		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());
+			return this.renderJson({
+				verified: true,
+				credentialId: credential.id
+			});
+		} catch (e) {
+			return this.#renderAuthError(e);
+		}
+	}
+	/**
+	* Défi d'authentification. **Le ciblage ne vient jamais de la requête** : un
+	* appelant anonyme obtient un défi découvrable (`allowCredentials` omis), un
+	* appelant déjà authentifié obtient le sien (ré-authentification / step-up).
+	*
+	* @remarks Route en `bypassFirewall` : n'importe qui peut la poster. Peupler
+	*   `allowCredentials` depuis un identifiant fourni dirait deux choses à cet
+	*   inconnu — que le compte porte une passkey, et **lesquelles** (W3C WebAuthn
+	*   L3, « Privacy leak via credential IDs » : un `credentialId` est un
+	*   identifiant corrélable, exposé il dés-anonymise entre sites et confirme
+	*   une hypothèse d'identité avec un accès momentané à l'authenticator). La
+	*   spec propose deux remèdes, ce sont les deux régimes ci-dessous : les
+	*   credentials découvrables pour l'anonyme, une **authentification préalable**
+	*   quand on cible vraiment. Verrouillé par
+	*   `tests/unit/webauthnLoginOptionsPrivacy.test.ts`.
+	*/
+	async loginOptions() {
+		const svc = this.#service();
+		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 session = await flow.ensureSession(this.context);
+		session?.set(AUTH_CHALLENGE, options.challenge);
+		await session?.save();
+		return this.renderJson(options);
+	}
+	/** Vérifie l'assertion (empreinte) et OUVRE la session BFF. */
+	async loginVerify() {
+		const svc = this.#service();
+		const flow = this.#flow();
+		if (!svc || !flow) return this.renderJson({ error: "WebAuthn unavailable" }, 503);
+		const challenge = await this.#takeChallenge(AUTH_CHALLENGE);
+		if (!challenge) return this.renderJson({ error: "No challenge" }, 400);
+		try {
+			const { userId } = await svc.verifyAuthentication(this.#body().response, challenge, this.#origin());
+			const user = await flow.establishSessionFor(this.context, userId, "webauthn");
+			return this.renderJson({
+				verified: true,
+				user
+			});
+		} catch (e) {
+			return this.#renderAuthError(e);
+		}
+	}
+	/** Liste les passkeys de l'utilisateur courant (console « mes appareils »). */
+	async listCredentials() {
+		const svc = this.#service();
+		const flow = this.#flow();
+		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);
+		return this.renderJson({ credentials: creds.map((c) => ({
+			id: c.id,
+			transports: c.transports,
+			backupState: c.backupState,
+			createdAt: c.createdAt,
+			lastUsedAt: c.lastUsedAt
+		})) });
+	}
+	/** Supprime une passkey DU porteur courant (sinon 404 — anti-IDOR/anti-énumération). */
+	async removeCredential(id) {
+		const svc = this.#service();
+		const flow = this.#flow();
+		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);
+		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);
+		return this.renderJson({ ok: true });
+	}
+	#service() {
+		const svc = this.get("webauthn");
+		return svc && svc.isEnabled() ? svc : null;
+	}
+	#flow() {
+		return this.get("authFlow") ?? null;
+	}
+	/**
+	* Corps utile des cérémonies : la réponse de l'authenticator, rien d'autre.
+	* Aucun identifiant n'est lu ici — l'identité vient de la session, ou la
+	* cérémonie est découvrable (cf {@link WebAuthnController.loginOptions}).
+	*/
+	#body() {
+		return this.queryPost ?? {};
+	}
+	/** Origine HTTP de la requête (validée par le service contre le rpID). */
+	#origin() {
+		const origin = this.context.request?.headers?.origin;
+		return typeof origin === "string" ? origin : void 0;
+	}
+	/** Lit le challenge en session puis l'INVALIDE (usage unique, anti-replay). */
+	async #takeChallenge(key) {
+		const session = this.context.session;
+		const value = session?.get(key);
+		if (typeof value !== "string" || value.length === 0) return null;
+		session?.set(key, null);
+		await session?.save();
+		return value;
+	}
+	#renderAuthError(e) {
+		const code = e.code;
+		if (code === 401) return this.renderJson({ error: "WebAuthn verification failed" }, 401);
+		if (code === 409) return this.renderJson({ error: e.message ?? "Passkey limit reached" }, 409);
+		throw e;
+	}
+};
+/**
+* Monte les routes des cérémonies WebAuthn — appelé par le module framework à
+* `onKernelReady`, seulement si le service `webauthn` est présent.
+*/
+function mountWebAuthnRoutes(frameworkModule) {
+	if (mounted) return;
+	const base = "/nodefony/security/api/webauthn";
+	const routes = [
+		[
+			"security.webauthn.register.options",
+			`${base}/register/options`,
+			"POST",
+			"registerOptions",
+			true
+		],
+		[
+			"security.webauthn.register.verify",
+			`${base}/register/verify`,
+			"POST",
+			"registerVerify",
+			true
+		],
+		[
+			"security.webauthn.login.options",
+			`${base}/login/options`,
+			"POST",
+			"loginOptions",
+			true
+		],
+		[
+			"security.webauthn.login.verify",
+			`${base}/login/verify`,
+			"POST",
+			"loginVerify",
+			true
+		],
+		[
+			"security.webauthn.credentials.list",
+			`${base}/credentials`,
+			"GET",
+			"listCredentials",
+			false
+		],
+		[
+			"security.webauthn.credentials.remove",
+			`${base}/credentials/{id}`,
+			"DELETE",
+			"removeCredential",
+			false
+		]
+	];
+	for (const [name, path, method, classMethod, bypass] of routes) router_default.createRoute(name, {
+		path,
+		constructor: WebAuthnController,
+		classMethod,
+		requirements: { methods: [method] },
+		bypassFirewall: bypass
+	});
+	if (!Object.prototype.hasOwnProperty.call(WebAuthnController.prototype, "module")) router_default.setController(WebAuthnController, frameworkModule);
+	mounted = true;
+}
+//#endregion
+export { WebAuthnController as default, mountWebAuthnRoutes };