@nodefony/security 10.0.0-alpha.1

package/dist/nodefony/src/realtime/frameAuthorizer.js

@@ -0,0 +1,279 @@
+import { NODEFONY_CHANNEL_NAMESPACE, PLATFORM_CHANNELS, PLATFORM_INBOUND, startsWithCI } from "nodefony";
+//#region nodefony/src/realtime/frameAuthorizer.ts
+/**
+* Politique système par défaut des canaux d'**introspection serveur** : réservés
+* aux administrateurs. DURCISSEMENT Zero Trust (P6) : avant, « authentifié
+* suffisait » (tout `ROLE_USER` lisait `nodefony:syslog`) ; désormais `ROLE_ADMIN`.
+* Surchargeable finement par `realtimeChannels` (ex. `ROLE_SECURITY_AUDITOR`).
+*/
+const SYSTEM_CHANNEL_POLICY = {
+	authenticated: true,
+	roles: ["ROLE_ADMIN"]
+};
+/**
+* Namespace d'introspection serveur (observabilité) — s'y abonner expose l'état
+* interne du pod : journaux (`nodefony:syslog`), base (`nodefony:orm:*`), métriques
+* et supervision (`nodefony:dashboard`, `nodefony:supervision@<pid>`), sonde de la
+* socket (`nodefony:socket`), contrôle du pod (`nodefony:kernel:gc` force un GC
+* bloquant). Liste extensible via la config. Convention transverse Nodefony :
+* `<module>:health` / `<module>:stats` (gérée à part dans {@link matchSystemPolicy}).
+*
+* ⚠️ Couplage ASSUMÉ : security connaît le namespace système de la plateforme
+* (c'est son rôle de définir la politique) — mais il ne le REDÉCLARE pas : la
+* constante vient du cœur, comme côté hub.
+*/
+const DEFAULT_SYSTEM_PREFIXES = [NODEFONY_CHANNEL_NAMESPACE];
+/**
+* Plancher des canaux de **sécurité** (`nodefony:audit`, P6.14 lot 4) : réservé au
+* super-admin Nodefony (`ROLE_NODEFONY_ADMIN`) — un cran AU-DESSUS du plancher
+* d'observabilité générique (`ROLE_ADMIN`). Le journal d'audit du pod ne se lit
+* pas avec un simple rôle admin applicatif. Cohérent avec le data plane HTTP de
+* l'audit (`SecurityAdminApi`, lot 3, même rôle).
+*
+* Multi-tenant (futur) : `nodefony:audit` reste un canal **plateforme** (pod),
+* jamais exposé à un user tenant ; l'événement portera le `tenantId` (via l'ALS)
+* pour permettre un filtrage par tenant quand le chantier multi-tenant arrivera.
+*/
+const SECURITY_CHANNEL_POLICY = {
+	authenticated: true,
+	roles: ["ROLE_NODEFONY_ADMIN"]
+};
+/**
+* Politique du canal **MONTANT** des journaux du navigateur
+* ({@link PLATFORM_INBOUND.syslogUplink}) : authentifié, sans rôle particulier.
+*
+* Pourquoi il échappe à {@link SYSTEM_CHANNEL_POLICY} alors qu'il porte la même marque :
+* ce plancher-là protège la **lecture** de l'état interne du pod — s'abonner à
+* `nodefony:syslog` fait sortir les journaux du serveur. Le canal montant ne rend rien ;
+* il ACCEPTE. Lui demander `ROLE_ADMIN` ne le rendrait pas plus sûr, cela le rendrait
+* inutile : on ne recueillerait que les erreurs survenues chez les administrateurs, quand
+* tout l'intérêt est de voir celles que subissent les utilisateurs.
+*
+* Les dangers propres à une surface d'écriture — noyer le journal, y fabriquer des
+* pistes — se traitent là où ils se posent : origine forcée par le serveur, débit et
+* taille bornés par connexion, sévérité plafonnée (`createSyslogUplinkHandler`).
+*
+* Le plancher irréductible reste respecté, et non contourné : `authenticated` est exigé,
+* donc une connexion ANONYME ne pousse rien. Limite assumée, à connaître avant de
+* chercher un journal qui n'existe pas : **les erreurs d'un visiteur non connecté ne
+* remontent pas** — celles de la page de connexion, notamment.
+*/
+const UPLINK_CHANNEL_POLICY = { authenticated: true };
+/**
+* F2 (revue 0.6) — PLANCHER IRRÉDUCTIBLE du namespace réservé plateforme. Il
+* couvre tout ce qui expose l'état interne du pod (logs, audit, métriques,
+* requêtes, supervision) : une règle de config `realtimeChannels` (placée AVANT
+* les défauts, 1ᵉʳ match gagne) pourrait sinon l'OUVRIR à l'anonyme
+* (`{ authenticated:false }` ou policy vide). Le plancher garantit qu'un canal de
+* ce namespace exige TOUJOURS au moins `authenticated` — la config peut RESSERRER
+* (rôle/scope) ou re-cibler le rôle, jamais DESCENDRE sous authenticated. Le canal
+* d'audit en fait partie (son défaut ROLE_NODEFONY_ADMIN est déjà au-dessus, mais
+* le plancher le blinde contre une surcharge de config). Défense structurelle,
+* fail-closed (cf F1 fail-loud).
+*/
+const RESERVED_FLOOR_PREFIXES = DEFAULT_SYSTEM_PREFIXES;
+/**
+* Règles système par défaut. Le canal d'audit est placé EN TÊTE (1ᵉʳ match gagne)
+* avec son plancher super-admin propre ; le reste du namespace plateforme hérite de
+* {@link SYSTEM_CHANNEL_POLICY}. Le firewall y préfixe les règles issues de la
+* config (qui gagnent par ordre).
+*/
+const DEFAULT_SYSTEM_RULES = buildSystemRules(RESERVED_FLOOR_PREFIXES);
+/**
+* Construit les règles système à partir d'une liste de namespaces réservés.
+*
+* Sépare la LISTE (quels namespaces sont réservés — propriété du hub realtime,
+* qui sert ces canaux) de la POLITIQUE (quels droits — propriété de la sécurité).
+* Le firewall appelle donc cette fabrique avec la liste que le hub lui donne, et
+* ne redéclare rien : un namespace ajouté côté realtime hérite automatiquement
+* d'une politique, au lieu de rester ouvert sans que personne ne le remarque.
+*
+* Le canal d'audit est placé EN TÊTE (premier match gagnant) : son plancher est
+* plus haut que celui du reste de l'observabilité. Il n'est pas un namespace mais
+* un canal précis — sa règle n'est donc posée que si la liste reçue le COUVRE : si
+* le hub cessait un jour de réserver ce territoire, la sécurité cesserait avec lui
+* de prétendre l'arbitrer, au lieu de garder une règle orpheline.
+*
+* @param prefixes - namespaces réservés (ordre indifférent).
+* @returns les règles, canal d'audit d'abord.
+*/
+function buildSystemRules(prefixes) {
+	const rules = [];
+	const audit = PLATFORM_CHANNELS.audit;
+	if (prefixes.some((prefix) => startsWithCI(audit, prefix))) rules.push({
+		prefix: audit,
+		policy: SECURITY_CHANNEL_POLICY
+	});
+	const uplink = PLATFORM_INBOUND.syslogUplink;
+	if (prefixes.some((prefix) => startsWithCI(uplink, prefix))) rules.push({
+		prefix: uplink,
+		policy: UPLINK_CHANNEL_POLICY
+	});
+	for (const prefix of prefixes) rules.push({
+		prefix,
+		policy: SYSTEM_CHANNEL_POLICY
+	});
+	return rules;
+}
+/**
+* `s` contient-il `needle`, insensible à la casse et sans allocation ? Pour les
+* conventions transverses `:health`/`:stats` (après le namespace de module —
+* `mymod:health` — éventuellement suffixées d'une cadence `nodefony:orm:health:5000`).
+*/
+function containsCI(s, needle) {
+	const last = s.length - needle.length;
+	for (let i = 0; i <= last; i++) {
+		let ok = true;
+		for (let j = 0; j < needle.length; j++) {
+			let a = s.charCodeAt(i + j);
+			if (a >= 65 && a <= 90) a += 32;
+			let b = needle.charCodeAt(j);
+			if (b >= 65 && b <= 90) b += 32;
+			if (a !== b) {
+				ok = false;
+				break;
+			}
+		}
+		if (ok) return true;
+	}
+	return false;
+}
+/**
+* Politique système applicable à un canal, ou `null` si le canal n'est pas
+* réservé. Premier préfixe qui matche gagne (la config est placée AVANT les
+* défauts par le firewall → elle peut surcharger). Les conventions transverses
+* `:health`/`:stats` retombent sur la politique système par défaut. Le match est
+* INSENSIBLE À LA CASSE (cf {@link startsWithCI}) : le plancher ne se contourne
+* pas en altérant la casse du namespace.
+*/
+function matchSystemPolicy(channel, rules) {
+	for (let i = 0; i < rules.length; i++) if (startsWithCI(channel, rules[i].prefix)) return floorReserved(channel, rules[i].policy);
+	if (containsCI(channel, ":health") || containsCI(channel, ":stats")) return SYSTEM_CHANNEL_POLICY;
+	return null;
+}
+/**
+* F2 (revue 0.6) — applique le PLANCHER irréductible : si `channel` est dans un
+* namespace réservé plateforme ({@link RESERVED_FLOOR_PREFIXES}), l'autorisation
+* effective exige AU MOINS `authenticated`, même si la `policy` (issue d'une règle
+* de config) tente de l'ouvrir. Basé sur le namespace du CANAL, PAS sur le prefixe
+* de la règle qui a matché → pas de contournement via un prefixe de config plus
+* court/altéré (`{ prefix:"sec", authenticated:false }` sur `nodefony:audit`).
+* `policy.authenticated` déjà vrai (cas nominal, défauts + `:health`) → retour tel
+* quel, 0 allocation. N'alloue que sur une config qui tente de DESSERRER un
+* namespace réservé (cold path de misconfiguration).
+*/
+function floorReserved(channel, policy) {
+	if (policy.authenticated) return policy;
+	for (let i = 0; i < RESERVED_FLOOR_PREFIXES.length; i++) if (startsWithCI(channel, RESERVED_FLOOR_PREFIXES[i])) return {
+		...policy,
+		authenticated: true
+	};
+	return policy;
+}
+/**
+* Le token satisfait-il la politique ? Contraintes cumulatives (ET) ; un champ
+* absent = pas de contrainte sur cet axe. SYNC, 0 lecture base (lit le token déjà
+* résolu au handshake).
+*  - `authenticated` : token non anonyme.
+*  - `roles` : l'un des rôles requis, hiérarchie comprise (un anonyme `[]` échoue).
+*  - `scopes` : l'un des scopes requis (session BFF n'en porte pas → refus).
+*/
+function satisfies(policy, token, firewall) {
+	if (policy.authenticated && !token.isAuthenticated()) return false;
+	if (policy.roles && policy.roles.length > 0) {
+		const userRoles = token.getRoles();
+		let granted = false;
+		for (let i = 0; i < policy.roles.length; i++) if (firewall.hasRole(userRoles, policy.roles[i])) {
+			granted = true;
+			break;
+		}
+		if (!granted) return false;
+	}
+	if (policy.scopes && policy.scopes.length > 0) {
+		const userScopes = token.getScopes();
+		let granted = false;
+		for (let i = 0; i < policy.scopes.length; i++) if (userScopes.includes(policy.scopes[i])) {
+			granted = true;
+			break;
+		}
+		if (!granted) return false;
+	}
+	return true;
+}
+/**
+* Verrou `api.request {path}` — vérifie l'autorisation de ZONE du pathname (le
+* MÊME re-match de zone qu'un `GET {path}` ; ne regarde PAS la méthode logique).
+* Une zone protégée + un token anonyme = refus. Les mutations (POST/PUT/PATCH/
+* DELETE) restent possibles via le pont MAIS seulement si la route déclare le
+* transport WEBSOCKET + `methodOverride` (une route REST HTTP-only = 405,
+* inatteignable), et sont gardées EN PLUS par `@IsGranted` + clé d'idempotence au
+* data plane. Le verrou n'accorde donc que le plancher de ZONE, pas l'action.
+*/
+function authorizeApiRequest(firewall, params, token, onDeny) {
+	const path = params?.path;
+	if (typeof path !== "string") return true;
+	const qi = path.indexOf("?");
+	const pathname = qi === -1 ? path : path.slice(0, qi);
+	const area = firewall.matchPath(pathname);
+	if (area && area.security && !token.isAuthenticated()) {
+		onDeny?.("api.request", pathname, "zone_protected", token);
+		return false;
+	}
+	return true;
+}
+/**
+* Verrou `subscribe {channel}` (et canaux inbound full-duplex) — applique la
+* politique du canal. PLANCHER système prioritaire (namespace réservé) ; sinon
+* politique métier déclarée (`@RealtimeChannel`) ; sinon canal libre.
+*/
+function authorizeChannel(channel, token, firewall, resolver, systemRules, onDeny) {
+	const policy = matchSystemPolicy(channel, systemRules) ?? resolver?.resolveChannelPolicy?.(channel) ?? null;
+	if (policy === null) return true;
+	if (satisfies(policy, token, firewall)) return true;
+	onDeny?.("channel", channel, "channel_policy", token);
+	return false;
+}
+/**
+* Construit le verrou de frame WS branché sur le hub realtime par le firewall au
+* boot (`RealtimeService.setFrameAuthorizer`). SYNC, 0 lecture base : lit le
+* token déjà résolu au handshake et matche la cible de la frame contre la zone
+* (api.request) ou la politique du canal (subscribe/inbound).
+*
+* Trois surfaces gardées :
+*  - `api.request {path}` (pont API souverain) : re-match de zone HTTP → zone
+*    protégée + anonyme = refus (autorisation de ZONE, identique à `GET {path}` ;
+*    la méthode/action est gardée en aval par le router + `@IsGranted`).
+*  - `subscribe {channel}` : politique de canal (système plancher + déclaration
+*    métier `@RealtimeChannel` → rôles/scopes).
+*  - inbound (`method` = canal full-duplex déclaré avec policy) : même politique
+*    que `subscribe` — un client ne pousse pas sur un canal protégé sans droit.
+*
+* Toute autre frame (`ping`, `unsubscribe`, action explicitement ouverte) passe — le verrou
+* cible les surfaces qui atteignent le data plane / l'observabilité / un canal
+* protégé.
+*
+* @param firewall    - matcher de zone + checker de rôle (le `Firewall`).
+* @param options     - `channelResolver` (politiques métier déclarées, via le
+*                      service realtime) + `systemRules` (défauts + config) +
+*                      `onDeny` (rapporteur d'audit, invoqué sur refus seulement).
+* @returns un {@link FrameAuthorizer} sync (`true` = frame autorisée).
+*/
+function buildFrameAuthorizer(firewall, options) {
+	const resolver = options?.channelResolver ?? null;
+	const systemRules = options?.systemRules ?? DEFAULT_SYSTEM_RULES;
+	const onDeny = options?.onDeny;
+	return (frame, token) => {
+		const f = frame;
+		const method = f?.method;
+		if (method === "api.request") return authorizeApiRequest(firewall, f.params, token, onDeny);
+		if (method === "subscribe") {
+			const channel = f.params?.channel;
+			if (typeof channel !== "string") return true;
+			return authorizeChannel(channel, token, firewall, resolver, systemRules, onDeny);
+		}
+		if (typeof method === "string") return authorizeChannel(method, token, firewall, resolver, systemRules, onDeny);
+		return true;
+	};
+}
+//#endregion
+export { DEFAULT_SYSTEM_PREFIXES, DEFAULT_SYSTEM_RULES, RESERVED_FLOOR_PREFIXES, SECURITY_CHANNEL_POLICY, SYSTEM_CHANNEL_POLICY, UPLINK_CHANNEL_POLICY, buildFrameAuthorizer, buildFrameAuthorizer as default, buildSystemRules };

package/dist/nodefony/src/realtime/realtimeContracts.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/src/sessionIdentity.js

@@ -0,0 +1,35 @@
+import { AuthenticationError } from "../errors/AuthenticationError.js";
+import { UserNotFoundError } from "@nodefony/user";
+//#region nodefony/src/sessionIdentity.ts
+const INVALID_SESSION = "Invalid session";
+/**
+* Résout l'identité portée par une session (l'identifiant stocké dans le blob)
+* en utilisateur VIVANT — re-fetch systématique auprès du provider.
+*
+* C'est LE choix structurant de la session BFF : la session ne stocke que
+* l'identifiant, jamais l'utilisateur sérialisé. Rôles toujours frais, et un
+* compte verrouillé/désactivé entre deux requêtes est rejeté immédiatement
+* (révocation effective — l'argument décisif face au JWT côté web).
+*
+* Partagé par le `SessionAuthenticator` (requêtes en zone) et `AuthFlow.me()`
+* (hors zone) : une seule source de vérité des contrôles d'état du compte.
+*
+* @param provider - source d'identité (`UserService` via le container).
+* @param identifier - identifiant fonctionnel stocké en session.
+* @returns l'utilisateur actif.
+* @throws AuthenticationError (401, message uniforme) — identifiant inconnu,
+*   compte verrouillé ou désactivé.
+*/
+async function resolveSessionIdentity(provider, identifier) {
+	let user;
+	try {
+		user = await provider.loadUserByIdentifier(identifier);
+	} catch (error) {
+		if (error instanceof UserNotFoundError) throw new AuthenticationError(INVALID_SESSION);
+		throw error;
+	}
+	if (user.isLocked() || !user.isActive()) throw new AuthenticationError(INVALID_SESSION);
+	return user;
+}
+//#endregion
+export { resolveSessionIdentity };

package/dist/nodefony/src/throttle/LoginThrottler.js

@@ -0,0 +1,97 @@
+//#region nodefony/src/throttle/LoginThrottler.ts
+const DEFAULT_FREE_ATTEMPTS = 3;
+const DEFAULT_BASE_DELAY_S = 1;
+const DEFAULT_CAP_DELAY_S = 900;
+const DEFAULT_MAX_TRACKED = 1e4;
+/**
+* Limiteur de tentatives de login **en mémoire, par identifiant saisi**.
+*
+* La clé est l'identifiant TEL QUE SAISI (existant ou non en base) : un
+* identifiant martelé est ralenti qu'il corresponde à un compte ou pas — aucun
+* oracle d'énumération. Par-processus (V1) : en cluster, chaque worker porte son
+* compteur (l'attaquant gagne ×N workers — acceptable car le backoff est
+* exponentiel ; un backend partagé type Redis se branchera derrière la même
+* interface sans toucher l'authenticator).
+*
+* Coût borné (règle perf Nodefony) : `Map` allouée LAZY au premier échec (une
+* app sans échec de login ne paie rien), AUCUN timer — l'expiration est évaluée
+* à la lecture et les entrées mortes sont purgées par balayage opportuniste
+* quand la borne `maxTracked` est atteinte (puis éviction FIFO en dernier
+* recours : ~10 000 × ~100 B ≈ 1 MB au pire).
+*/
+var LoginThrottler = class {
+	freeAttempts;
+	baseDelayS;
+	capDelayS;
+	maxTracked;
+	#entries = null;
+	#now;
+	constructor(options = {}, now = Date.now) {
+		this.freeAttempts = options.freeAttempts ?? DEFAULT_FREE_ATTEMPTS;
+		this.baseDelayS = options.baseDelayS ?? DEFAULT_BASE_DELAY_S;
+		this.capDelayS = options.capDelayS ?? DEFAULT_CAP_DELAY_S;
+		this.maxTracked = options.maxTracked ?? DEFAULT_MAX_TRACKED;
+		this.#now = now;
+	}
+	/**
+	* L'identifiant peut-il tenter un login maintenant ?
+	*
+	* @param identifier - identifiant tel que saisi.
+	* @returns `0` si autorisé, sinon les secondes restantes (→ `Retry-After`,
+	*   arrondies à l'entier supérieur).
+	*/
+	check(identifier) {
+		const entry = this.#entries?.get(identifier);
+		if (entry === void 0) return 0;
+		const remainingMs = entry.blockedUntil - this.#now();
+		return remainingMs > 0 ? Math.ceil(remainingMs / 1e3) : 0;
+	}
+	/**
+	* Enregistre un échec : au-delà de `freeAttempts`, arme un délai exponentiel
+	* `baseDelayS × 2^(échecs - freeAttempts - 1)`, plafonné à `capDelayS`.
+	*
+	* @param identifier - identifiant tel que saisi.
+	*/
+	recordFailure(identifier) {
+		const entries = this.#entries ??= /* @__PURE__ */ new Map();
+		let entry = entries.get(identifier);
+		if (entry === void 0) {
+			if (entries.size >= this.maxTracked) this.#evict(entries);
+			entry = {
+				failures: 0,
+				blockedUntil: 0
+			};
+			entries.set(identifier, entry);
+		}
+		entry.failures += 1;
+		const over = entry.failures - this.freeAttempts;
+		if (over > 0) {
+			const delayS = Math.min(this.baseDelayS * 2 ** (over - 1), this.capDelayS);
+			entry.blockedUntil = this.#now() + delayS * 1e3;
+		}
+	}
+	/**
+	* Login réussi : oublie l'identifiant (le délai repart de zéro — NIST :
+	* l'utilisateur légitime ne traîne pas la dette d'un attaquant passé).
+	*
+	* @param identifier - identifiant tel que saisi.
+	*/
+	recordSuccess(identifier) {
+		this.#entries?.delete(identifier);
+	}
+	/** Nombre d'identifiants actuellement suivis (introspection / tests). */
+	get trackedCount() {
+		return this.#entries?.size ?? 0;
+	}
+	#evict(entries) {
+		const now = this.#now();
+		for (const [key, entry] of entries) if (entry.blockedUntil <= now) entries.delete(key);
+		let excess = entries.size - this.maxTracked + 1;
+		if (excess > 0) for (const key of entries.keys()) {
+			entries.delete(key);
+			if ((excess -= 1) <= 0) break;
+		}
+	}
+};
+//#endregion
+export { LoginThrottler, LoginThrottler as default };

package/dist/nodefony/src/token/AnonymousToken.js

@@ -0,0 +1,40 @@
+import { anonymousUser } from "@nodefony/user";
+//#region nodefony/src/token/AnonymousToken.ts
+/**
+* Token du visiteur non authentifié — Zero Trust : un visiteur EST un utilisateur
+* anonyme (jamais `null`).
+*
+* Porte le singleton gelé `anonymousUser` → **zéro allocation d'utilisateur** par
+* requête non authentifiée (hot path). Les attributs sont lazy (`null` tant qu'on
+* n'en pose pas).
+*/
+var AnonymousToken = class {
+	type = "anonymous";
+	#attributes = null;
+	getUser() {
+		return anonymousUser;
+	}
+	getUserIdentifier() {
+		return anonymousUser.identifier;
+	}
+	isAuthenticated() {
+		return false;
+	}
+	getRoles() {
+		return [...anonymousUser.roles];
+	}
+	getCredentials() {
+		return null;
+	}
+	getScopes() {
+		return [];
+	}
+	getAttribute(key) {
+		return this.#attributes?.get(key);
+	}
+	setAttribute(key, value) {
+		(this.#attributes ??= /* @__PURE__ */ new Map()).set(key, value);
+	}
+};
+//#endregion
+export { AnonymousToken, AnonymousToken as default };

package/dist/nodefony/src/token/JwtKeystore.js

@@ -0,0 +1,160 @@
+import { messageNonRestreint, modeNonRestreintAsync, readIfPresent, writeSecret } from "./secretFile.js";
+import { join } from "node:path";
+//#region nodefony/src/token/JwtKeystore.ts
+/**
+* Keystore Ed25519 — implémentation de référence d'{@link IJwtKeystore}.
+*
+* Résout la clé de signature selon une **priorité** (jamais d'auto-génération en
+* clair « par défaut » en prod) :
+*  1. **env** — `config.jwt.keystore.keySetJson` (JWK Set injecté par l'app depuis
+*     son catalogue d'env) : prod cloud, secret géré hors-app, même clé sur tous
+*     les pods.
+*  2. **fichier** — `config.jwt.keystore.dir/keyset.json` (écrit en mode 600,
+*     généré si absent) : opt-in dev/VPS mono-machine. Le mode effectif est
+*     **constaté** après coup : un système de fichiers qui n'applique pas les
+*     permissions POSIX (NTFS, FAT, NFS sans mapping) déclenche un **warning**
+*     plutôt qu'une garantie silencieusement fausse.
+*  3. **mémoire** — aucune source → clé éphémère générée au 1ᵉʳ usage + **warning**
+*     (perdue au redémarrage = refresh invalidés, incohérente en cluster).
+*
+* jose est importé **paresseusement** (dep lourde — règle perf P6) au premier
+* usage ; le boot ne paie rien si le JWT n'est jamais sollicité. Le chargement
+* est mémoïsé (une seule résolution concurrente).
+*
+* @remarks Race au 1ᵉʳ boot d'un **cluster** sans clé pré-provisionnée : deux
+* workers peuvent générer puis écrire des clés différentes (le dernier `rename`
+* gagne). En prod, provisionner la clé hors-bande (`keySetJson`/SecretProvider
+* P16) élimine ce cas — c'est précisément la source recommandée.
+*/
+var JwtKeystore = class {
+	#source;
+	#log;
+	#keys = [];
+	#activeKid = "";
+	#ready = null;
+	constructor(source, log) {
+		this.#source = source;
+		this.#log = log;
+	}
+	async getSigningKey() {
+		await this.#ensureLoaded();
+		const active = this.#keys.find((k) => k.kid === this.#activeKid);
+		if (!active) throw new Error("JwtKeystore: aucune clé de signature active");
+		return {
+			key: active.privateKey,
+			kid: active.kid,
+			alg: "EdDSA"
+		};
+	}
+	async getPublicJWKS() {
+		await this.#ensureLoaded();
+		return { keys: this.#keys.map((k) => k.publicJwk) };
+	}
+	/** Charge le keyset une seule fois (mémoïsation de la promesse). */
+	#ensureLoaded() {
+		return this.#ready ??= this.#load();
+	}
+	async #load() {
+		const jose = await import("jose");
+		if (this.#source.keySetJson) {
+			await this.#importKeyset(jose, this.#parseKeyset(this.#source.keySetJson));
+			return;
+		}
+		if (this.#source.dir) {
+			const file = join(this.#source.dir, "keyset.json");
+			const existing = await this.#readFile(file);
+			if (existing) {
+				await this.#checkRestricted(file);
+				await this.#importKeyset(jose, this.#parseKeyset(existing));
+				return;
+			}
+			const keyset = await this.#generate(jose);
+			await this.#writeAtomic(file, JSON.stringify(keyset));
+			await this.#importKeyset(jose, keyset);
+			return;
+		}
+		this.#log("JWT keystore: clé de signature ÉPHÉMÈRE en mémoire (perdue au redémarrage → refresh tokens invalidés, incohérente en cluster). Configurez jwt.keystore.dir (dev/VPS) ou jwt.keystore.keySetJson depuis l'env (prod).", "WARNING");
+		await this.#importKeyset(jose, await this.#generate(jose));
+	}
+	/** Génère une nouvelle paire Ed25519 (extractable pour persistance JWK). */
+	async #generate(jose) {
+		const { publicKey, privateKey } = await jose.generateKeyPair("Ed25519", { extractable: true });
+		const publicJwk = await jose.exportJWK(publicKey);
+		const kid = await jose.calculateJwkThumbprint(publicJwk, "sha256");
+		return {
+			active: kid,
+			keys: [{
+				...await jose.exportJWK(privateKey),
+				kid,
+				alg: "EdDSA",
+				use: "sig",
+				createdAt: Date.now()
+			}]
+		};
+	}
+	/** Importe un keyset persisté : privée → `CryptoKey`, public → JWK sans `d`. */
+	async #importKeyset(jose, keyset) {
+		const loaded = [];
+		for (const stored of keyset.keys) {
+			const imported = await jose.importJWK(stored, "Ed25519");
+			if (!(imported instanceof CryptoKey)) throw new Error(`JwtKeystore: clé asymétrique attendue pour le kid "${stored.kid}"`);
+			loaded.push({
+				kid: stored.kid,
+				privateKey: imported,
+				publicJwk: {
+					kty: stored.kty,
+					crv: stored.crv,
+					x: stored.x,
+					kid: stored.kid,
+					use: "sig",
+					alg: "EdDSA"
+				},
+				createdAt: stored.createdAt ?? Date.now()
+			});
+		}
+		if (loaded.length === 0) throw new Error("JwtKeystore: keyset vide");
+		this.#keys = loaded;
+		this.#activeKid = keyset.active && loaded.some((k) => k.kid === keyset.active) ? keyset.active : loaded[0].kid;
+	}
+	#parseKeyset(json) {
+		let parsed;
+		try {
+			parsed = JSON.parse(json);
+		} catch {
+			throw new Error("JwtKeystore: keyset JSON invalide");
+		}
+		const keyset = parsed;
+		if (!keyset || !Array.isArray(keyset.keys) || keyset.keys.length === 0 || keyset.keys.some((k) => typeof k.kid !== "string")) throw new Error("JwtKeystore: keyset malformé (champ `keys` non vide avec `kid` requis)");
+		return keyset;
+	}
+	/** Lit un fichier ; `null` si absent (ENOENT), relance toute autre erreur. */
+	async #readFile(file) {
+		return readIfPresent(file);
+	}
+	/** Écriture atomique (tmp + rename) en mode 600 — pas de fichier partiel lu. */
+	async #writeAtomic(file, data) {
+		await writeSecret(file, data);
+		this.#log(`JWT keystore: clé Ed25519 générée et persistée (${file}).`, "INFO");
+		await this.#checkRestricted(file);
+	}
+	/**
+	* Constate le mode EFFECTIF du fichier de clés et avertit s'il n'est pas 0600.
+	*
+	* Le mode demandé à l'écriture est une intention, pas une garantie : NTFS
+	* (Windows) l'ignore, tout comme un montage FAT/exFAT ou NFS sans mapping
+	* d'identité — sous Linux comme ailleurs. Le fichier porte la clé PRIVÉE :
+	* si la restriction n'a pas pris, la confidentialité repose sur les droits du
+	* dossier, ce qui doit être DIT plutôt que supposé. La capacité se constate,
+	* elle ne se déduit pas de `process.platform`.
+	*
+	* Un `stat` par résolution de keystore (une fois par process, source fichier
+	* uniquement) — hors hot-path.
+	*/
+	async #checkRestricted(file) {
+		const mode = await modeNonRestreintAsync(file);
+		if (mode === null || mode === void 0) return;
+		this.#log(`JWT keystore: ${messageNonRestreint(file, mode)} La clé PRIVÉE y réside : provisionnez-la plutôt hors-bande via jwt.keystore.keySetJson (recommandé en production).`, "WARNING");
+	}
+};
+//#endregion
+export { JwtKeystore, JwtKeystore as default };