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

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

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

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

@@ -1,7 +1,7 @@
 import { WEBHOOK_FACETS, WEBHOOK_FILTERS, WEBHOOK_STATS_FILTERS } from "../webhook/webhookFilters.js";
 import { adminActor, auditAdmin } from "./adminAudit.js";
-import { parseFilters, parsePageQuery } from "nodefony";
-//#region nodefony/src/admin/WebhookAdminApi.ts
+import { isPlainObject, parseFilters, parsePageQuery } from "nodefony";
+// nodefony/src/admin/WebhookAdminApi.ts
 /**
 * Déduit le driver logique du store webhook depuis son nom de classe (miroir de
 * `tokenStoreDriver`). Fermé sur les implémentations connues ; `null` pour un
@@ -30,6 +30,21 @@ function bodyStringArray(v) {
 	if (!Array.isArray(v) || v.length === 0) return void 0;
 	return v.every((x) => typeof x === "string" && x.length > 0) ? v : void 0;
 }
+/**
+* Le corps d'une requête d'écriture : un objet JSON, ou rien (lu comme `{}`).
+* Un tableau ou un scalaire rend `null` — l'appelant répond 400 au lieu de
+* laisser un `in` lever sur une chaîne.
+*/
+function bodyObject(request) {
+	const body = request.body;
+	if (body === void 0 || body === null) return {};
+	return isPlainObject(body) ? body : null;
+}
+/** Réponse au corps qui n'est pas un objet JSON. */
+const BODY_NOT_OBJECT = {
+	status: 400,
+	body: { error: "JSON object body required" }
+};
 /** Page par défaut du listing d'endpoints (registre de config, volume modeste). */
 const ENDPOINTS_DEFAULT_LIMIT = 50;
 /** Plafond dur : un client ne peut pas demander « tout » via `?limit=`. */
@@ -75,8 +90,8 @@ function parseWebhookListQuery(query, sortable) {
 * fail-closed, et logge).
 */
 function mapWebhookError(e) {
-	if (e.code === 422) {
-		const message = e.message;
+	if (typeof e === "object" && e !== null && "code" in e && e.code === 422) {
+		const message = "message" in e ? e.message : void 0;
 		return {
 			status: 422,
 			body: { error: typeof message === "string" ? message : "invalid url" }
@@ -170,7 +185,8 @@ function webhookAdminEndpoints(container) {
 			handler: async (request) => {
 				const s = svc();
 				if (!ready(s)) return UNAVAILABLE;
-				const body = request.body ?? {};
+				const body = bodyObject(request);
+				if (body === null) return BODY_NOT_OBJECT;
 				const url = bodyString(body.url);
 				if (!url) return {
 					status: 400,
@@ -252,7 +268,8 @@ function webhookAdminEndpoints(container) {
 				if (!ready(s)) return UNAVAILABLE;
 				const id = pathId(request);
 				if (!id) return NOT_FOUND;
-				const body = request.body ?? {};
+				const body = bodyObject(request);
+				if (body === null) return BODY_NOT_OBJECT;
 				const patch = {};
 				const fields = [];
 				if ("url" in body) {
@@ -375,5 +392,4 @@ function webhookAdminEndpoints(container) {
 		}
 	];
 }
-//#endregion
 export { parseWebhookListQuery, webhookAdminEndpoints };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/admin/adminAudit.ts
+// nodefony/src/admin/adminAudit.ts
 /**
 * Helpers d'audit PARTAGÉS par les producteurs admin du module sécurité
 * (`SecurityAdminApi`, `WebhookAdminApi`…). Extraits dans leur propre fichier
@@ -16,7 +16,6 @@
 function adminActor(user) {
 	if (user && typeof user === "object") {
 		const u = user;
-		if (typeof u.username === "string" && u.username) return u.username;
 		if (typeof u.identifier === "string" && u.identifier) return u.identifier;
 	}
 	return "admin";
@@ -33,5 +32,4 @@ function adminActor(user) {
 function auditAdmin(container, draft) {
 	container.get("auditService")?.record?.(draft);
 }
-//#endregion
 export { adminActor, auditAdmin };

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

@@ -1,40 +1,168 @@
-import { USER_REVOKED_EVENT } from "@nodefony/user";
-//#region nodefony/src/admin/userRevocationCascade.ts
+import { USER_CREATED_EVENT, USER_REVOKED_EVENT } from "@nodefony/user";
+// nodefony/src/admin/userRevocationCascade.ts
+/** Garde : la valeur sait-elle journaliser (`log` est une fonction) ? */
+function isKernelLogger(value) {
+	return typeof value === "object" && value !== null && "log" in value && typeof value.log === "function";
+}
+/**
+* Journalise l'échec d'une brique de la cascade. Le geste reste best-effort —
+* une brique en panne n'empêche pas les autres — mais il ne peut plus échouer
+* EN SILENCE : un accès qui survit à sa révocation (session encore ouverte
+* après un changement de mot de passe) doit laisser une trace qui dit laquelle.
+*
+* @param container - container du kernel (service `kernel`).
+* @param brick - brique en échec (`sessions`, `tokenStore`, `totp`, `webauthn`).
+* @param identifier - compte visé par la cascade.
+* @param error - erreur levée par la brique.
+*/
+function reportCascadeFailure(container, brick, identifier, error) {
+	try {
+		const kernel = container.get("kernel");
+		if (!isKernelLogger(kernel)) return;
+		kernel.log(`révocation de "${identifier}" incomplète : la brique ${brick} a échoué — ` + (error instanceof Error ? error.message : String(error)), "ERROR", "SECURITY");
+	} catch {}
+}
 /**
 * Cascade de révocation déclenchée par {@link USER_REVOKED_EVENT} : éjecte
 * **immédiatement** les artefacts d'accès du porteur — ses **sessions** (http,
 * `destroyByUser`) et ses **jetons/PAT** (`tokenStore.revokeAllForSubject`,
-* seuil `invalidBefore`). Best-effort par brique (une indispo n'empêche pas
-* l'autre) — l'accès était DÉJÀ neutralisé par le re-fetch des authenticators,
-* cette cascade est de la **propreté + défense en profondeur**, jamais l'unique
-* rempart. `tenantId` du payload est réservé (scoping non câblé en mono-tenant).
+* seuil `invalidBefore`, qui couvre aussi les clés d'API). Best-effort par
+* brique (une indispo n'empêche pas l'autre) — l'accès était DÉJÀ neutralisé par
+* le re-fetch des authenticators. `tenantId` du payload est réservé (scoping non
+* câblé en mono-tenant).
+*
+* **Suppression du compte** (`reason: "deleted"`) : retire AUSSI ses facteurs —
+* secret TOTP (codes de récupération compris) et passkeys. Ils sont rangés sous
+* l'`identifier`, qu'un compte recréé peut reprendre : laissés en place, le
+* nouveau titulaire hériterait du second facteur de l'ancien. Un compte
+* seulement désactivé ou verrouillé les GARDE — il les retrouve à sa
+* réactivation.
 *
-* @param container - container du kernel (résolution lazy de `sessions`/`tokenStore`).
+* @param container - container du kernel (résolution lazy de `sessions`, `tokenStore`, `totp`, `webauthn`).
 * @param event - charge utile de l'événement (porteur + raison).
 * @param now - horloge (epoch ms) injectable pour les tests.
 */
 async function cascadeUserRevocation(container, event, now = Date.now()) {
 	const identifier = event.identifier;
+	await revokeAccessArtifacts(container, identifier, now);
+	if (event.reason === "deleted") await removeAccountFactors(container, identifier);
+}
+/**
+* Éjecte les artefacts d'accès rangés sous un identifiant — ses sessions (http,
+* `destroyByUser`) et ses jetons/PAT/clés d'API (`tokenStore.revokeAllForSubject`,
+* seuil `invalidBefore`). SEULE implémentation du geste, appelée à la révocation
+* d'un compte ET à sa création. Best-effort par brique : l'indisponibilité de
+* l'une n'empêche pas l'autre.
+*
+* @param container - container du kernel (services `sessions`, `tokenStore`).
+* @param identifier - `IUser.identifier` du compte.
+* @param invalidBefore - seuil (epoch ms) : tout jeton émis avant est rejeté.
+*/
+async function revokeAccessArtifacts(container, identifier, invalidBefore) {
 	try {
 		await container.get("sessions")?.destroyByUser?.(identifier);
-	} catch {}
+	} catch (error) {
+		reportCascadeFailure(container, "sessions", identifier, error);
+	}
 	try {
-		await container.get("tokenStore")?.revokeAllForSubject(identifier, now);
-	} catch {}
+		await container.get("tokenStore")?.revokeAllForSubject(identifier, invalidBefore);
+	} catch (error) {
+		reportCascadeFailure(container, "tokenStore", identifier, error);
+	}
+}
+/**
+* Purge, à la NAISSANCE d'un compte, tout ce qu'un ancien titulaire du même
+* identifiant a laissé derrière lui : sessions, jetons et facteurs. Un compte
+* qui vient de naître n'a encore rien émis — tout artefact déjà rangé sous son
+* identifiant appartient donc à quelqu'un d'autre. C'est ce qui ferme le cas
+* d'un compte supprimé HORS du framework (`DELETE` SQL, aucun événement), dont
+* l'accès redeviendrait valide dès qu'un compte renaît sous son nom.
+*
+* Le seuil est tronqué à la SECONDE : l'`iat` d'un JWT l'est aussi (RFC 7519
+* §2, NumericDate), et un seuil à la milliseconde rejetterait le jeton du
+* nouveau titulaire émis dans la même seconde que sa création.
+*
+* @param container - container du kernel.
+* @param identifier - `IUser.identifier` du compte créé.
+* @param now - horloge (epoch ms) injectable pour les tests.
+*/
+async function purgeInheritedAccess(container, identifier, now = Date.now()) {
+	await revokeAccessArtifacts(container, identifier, Math.floor(now / 1e3) * 1e3);
+	await removeAccountFactors(container, identifier);
+}
+/**
+* Retire les facteurs rangés sous un identifiant — secret TOTP (codes de
+* récupération compris) et passkeys. SEULE implémentation du geste, appelée à
+* la suppression d'un compte ET à la création d'un compte sous cet identifiant.
+* Best-effort par brique : un TOTP indisponible n'empêche pas le retrait des
+* passkeys.
+*
+* @param container - container du kernel (services `totp`, `webauthn`).
+* @param identifier - `IUser.identifier` du compte.
+*/
+async function removeAccountFactors(container, identifier) {
+	try {
+		const totp = container.get("totp");
+		if (totp?.isEnabled?.() !== false) await totp?.disable?.(identifier);
+	} catch (error) {
+		reportCascadeFailure(container, "totp", identifier, error);
+	}
+	try {
+		const webauthn = container.get("webauthn");
+		if (webauthn?.isEnabled?.() !== false) {
+			const creds = await webauthn?.listUserCredentials?.(identifier) ?? [];
+			for (const cred of creds) await webauthn?.removeUserCredential?.(identifier, cred.id);
+		}
+	} catch (error) {
+		reportCascadeFailure(container, "webauthn", identifier, error);
+	}
+}
+/** Garde : charge utile de {@link USER_CREATED_EVENT} (identifiant non vide). */
+function isUserCreatedEvent(value) {
+	return typeof value === "object" && value !== null && "identifier" in value && typeof value.identifier === "string" && value.identifier.length > 0;
 }
 /**
-* Abonne la cascade au bus kernel. À appeler au `onKernelBoot` d'un module
-* bootable (ici `@nodefony/security`). **Extensible** : tout autre module
-* (webhooks…) peut s'abonner au MÊME `USER_REVOKED_EVENT` pour ses propres
-* artefacts, sans toucher à ce fichier.
+* Abonne la cascade au bus kernel, UNE fois, au `onKernelBoot` de
+* `@nodefony/security` — avant qu'aucun compte ne puisse être créé ou révoqué
+* (les comptes semés au démarrage compris). Deux abonnements :
+*  - {@link USER_REVOKED_EVENT} → {@link cascadeUserRevocation} ;
+*  - {@link USER_CREATED_EVENT} → {@link purgeInheritedAccess} : sessions,
+*    jetons et facteurs HÉRITÉS. Un compte qui vient de naître n'a encore rien
+*    émis ni enrôlé, donc tout artefact déjà rangé sous son identifiant
+*    appartient à un ancien titulaire. Règle exacte, aucune date à comparer.
+*    ⚠️ Un import qui chargerait les facteurs AVANT les comptes les verrait
+*    retirés : importer les comptes d'abord.
+*
+* Les deux sont émis par `UserService` seul, et attendus : chaque handler rend
+* sa promesse. **Extensible** : tout autre module (webhooks…) s'abonne aux
+* MÊMES événements pour ses propres artefacts, sans toucher à ce fichier.
 *
 * @param kernel - bus d'événements (kernel) exposant `on`.
-* @param container - container capturé par le handler.
+* @param container - container capturé par les handlers.
 */
 function registerUserRevocationCascade(kernel, container) {
-	kernel.on(USER_REVOKED_EVENT, (event) => {
-		cascadeUserRevocation(container, event);
-	});
+	kernel.on(USER_REVOKED_EVENT, (event) => cascadeUserRevocation(container, event));
+	kernel.on(USER_CREATED_EVENT, (event) => isUserCreatedEvent(event) ? purgeInheritedAccess(container, event.identifier) : void 0);
+}
+/**
+* Avis de démarrage quand le service `users` n'émet pas sur le bus du kernel —
+* construit sans container (`new UserService(repo, encoder)`). Ses événements
+* partent alors sur son propre bus, où personne n'écoute : supprimer un compte
+* laisserait ses sessions, ses jetons et ses facteurs en place, SANS UN MOT.
+*
+* @param container - container du kernel.
+* @param kernel - le kernel attendu comme bus des événements.
+* @returns l'avis à déclarer, ou `null` si `users` est absent ou bien câblé.
+*/
+function usersEventBusNotice(container, kernel) {
+	const users = container.get("users");
+	if (typeof users !== "object" || users === null) return null;
+	if (!("kernel" in users) || users.kernel === kernel) return null;
+	return {
+		code: "USERS_SERVICE_WITHOUT_KERNEL",
+		level: "warning",
+		message: "le service « users » n'atteint pas le kernel : supprimer, désactiver un compte ou changer son mot de passe ne révoquera ni ses sessions, ni ses jetons, ni ses facteurs.",
+		fix: "new UserService(repository, encoder, module.container)"
+	};
 }
-//#endregion
-export { cascadeUserRevocation, registerUserRevocationCascade };
+export { cascadeUserRevocation, purgeInheritedAccess, registerUserRevocationCascade, removeAccountFactors, usersEventBusNotice };

package/dist/nodefony/src/apikey/apiKeyFormat.js

@@ -1,5 +1,5 @@
 import { createHash, randomBytes } from "node:crypto";
-//#region nodefony/src/apikey/apiKeyFormat.ts
+// nodefony/src/apikey/apiKeyFormat.ts
 /**
 * Encodage / décodage / hachage des clés API (PAT) — logique **pure** (aucun I/O,
 * aucun container) → testable sans serveur et partagée par l'émetteur
@@ -103,5 +103,4 @@ function parseApiKey(token, prefix) {
 		secretHash: hashApiKey(token)
 	};
 }
-//#endregion
 export { generateApiKey, hashApiKey, looksLikeApiKey, parseApiKey };

package/dist/nodefony/src/audit/MemoryAuditStore.js

@@ -1,5 +1,5 @@
 import { assertPageQuery } from "nodefony";
-//#region nodefony/src/audit/MemoryAuditStore.ts
+// nodefony/src/audit/MemoryAuditStore.ts
 const DEFAULT_MAX_ENTRIES = 1e4;
 const MAX_LIMIT = 500;
 /**
@@ -113,5 +113,4 @@ var MemoryAuditStore = class {
 		for (const event of snapshot.events) this.#events.push(event);
 	}
 };
-//#endregion
 export { MemoryAuditStore };

package/dist/nodefony/src/audit/auditBridge.js

@@ -1,5 +1,5 @@
 import { PLATFORM_CHANNELS } from "nodefony";
-//#region nodefony/src/audit/auditBridge.ts
+// nodefony/src/audit/auditBridge.ts
 /**
 * Canal WS du flux live d'audit (P6.14 lot 4). Le préfixe `security:` le place
 * sous le plancher `SECURITY_CHANNEL_POLICY` (ROLE_NODEFONY_ADMIN) du verrou de
@@ -82,5 +82,4 @@ function createAuditBridge(source, publish, channel, opts = {}) {
 		unsubscribe();
 	};
 }
-//#endregion
 export { SECURITY_AUDIT_CHANNEL, createAuditBridge, createAuditBridge as default };

package/dist/nodefony/src/audit/auditFilters.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/audit/auditFilters.ts
+// nodefony/src/audit/auditFilters.ts
 /**
 * **Le vocabulaire de filtre du journal d'audit**, en noms PUBLICS — ceux qu'un
 * auditeur écrit dans l'URL (`?category=authz&outcome=denied&since=…`).
@@ -56,5 +56,4 @@ const AUDIT_FILTERS = {
 * les deux à jour », qui avait échoué en silence.
 */
 const AUDIT_FILTER_VOCABULARY_IS_COMPLETE = [true, true];
-//#endregion
 export { AUDIT_FILTERS, AUDIT_FILTER_VOCABULARY_IS_COMPLETE };

package/dist/nodefony/src/audit/auditStoreRegistry.js

@@ -1,5 +1,5 @@
 import { MemoryAuditStore } from "./MemoryAuditStore.js";
-//#region nodefony/src/audit/auditStoreRegistry.ts
+// nodefony/src/audit/auditStoreRegistry.ts
 const factories = /* @__PURE__ */ new Map();
 /**
 * Enregistre (ou remplace) la fabrique d'un store d'audit. Appelée par le builtin
@@ -21,5 +21,4 @@ registerAuditStore("memory", (ctx) => {
 	const days = ctx?.config?.audit?.retentionDays;
 	return typeof days === "number" ? new MemoryAuditStore(Date.now, days * MS_PER_DAY) : new MemoryAuditStore();
 });
-//#endregion
 export { getAuditStoreFactory, listAuditStores, registerAuditStore };

package/dist/nodefony/src/audit/readAuditContext.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/audit/readAuditContext.ts
+// nodefony/src/audit/readAuditContext.ts
 /**
 * Extrait IP / User-Agent / requestId + drapeaux de présence (jamais la valeur)
 * d'un contexte de requête — pour enrichir un événement d'audit avec la
@@ -20,5 +20,4 @@ function readAuditContext(context) {
 		}
 	};
 }
-//#endregion
 export { readAuditContext };

package/dist/nodefony/src/audit/recordAudit.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/audit/recordAudit.ts
+// nodefony/src/audit/recordAudit.ts
 /**
 * Émet un événement d'audit **si** le service est présent — no-op sinon. La
 * résolution se fait par le container (`auditService`) sur le **cold-path**
@@ -12,5 +12,4 @@
 function recordAudit(container, event) {
 	(container?.get("auditService"))?.record(event);
 }
-//#endregion
 export { recordAudit };

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

@@ -1,5 +1,5 @@
 import { AnonymousToken } from "../token/AnonymousToken.js";
-//#region nodefony/src/authenticator/AnonymousAuthenticator.ts
+// nodefony/src/authenticator/AnonymousAuthenticator.ts
 /**
 * Acceptation EXPLICITE de l'anonymat dans une zone — le seul authenticator
 * autorisé à produire un token non authentifié sans déclencher le Zero Trust.
@@ -32,5 +32,4 @@ var AnonymousAuthenticator = class {
 		return Promise.resolve();
 	}
 };
-//#endregion
 export { AnonymousAuthenticator, AnonymousAuthenticator as default };

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

@@ -1,8 +1,9 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
+import { isBoundToAccount } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
 import { bearerToken } from "./bearer.js";
 import { looksLikeApiKey, parseApiKey } from "../apikey/apiKeyFormat.js";
-//#region nodefony/src/authenticator/ApiKeyAuthenticator.ts
+// nodefony/src/authenticator/ApiKeyAuthenticator.ts
 const INVALID_TOKEN = "Invalid token";
 /**
 * Marqueur interne posé par `authenticate()` et consommé par `onSuccess()` :
@@ -81,6 +82,7 @@ var ApiKeyAuthenticator = class {
 		const invalidBefore = await store.getInvalidBefore(record.subjectId);
 		if (invalidBefore !== null && record.createdAt < invalidBefore) throw new AuthenticationError(INVALID_TOKEN);
 		const user = await this.#resolveUserOrReject(record.subjectId);
+		if (!isBoundToAccount(user, record.metadata["accountId"], record.metadata["credentialsVersion"])) throw new AuthenticationError(INVALID_TOKEN);
 		const last = record.lastUsedAt;
 		if (this.#throttleMs === 0 || last === null || now - last >= this.#throttleMs) token.setAttribute(MARK_USED_AT, now);
 		const ut = token;
@@ -160,5 +162,4 @@ var ApiKeyAuthenticator = class {
 		return this.#userProvider;
 	}
 };
-//#endregion
 export { ApiKeyAuthenticator, ApiKeyAuthenticator as default };