@nodefony/security 10.0.0-alpha.1

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

@@ -0,0 +1,236 @@
+import { TOKEN_DEFAULT_ORDER, TOKEN_SORTABLE_FIELDS } from "./tokenSort.js";
+import { matchesTokenStatus } from "./tokenStatus.js";
+import { assertPageQuery, compareByOrder, pickOrder } from "nodefony";
+//#region nodefony/src/token/MemoryTokenStore.ts
+/**
+* Filtre un record contre une requête de listing — prédicat de RÉFÉRENCE du
+* contrat, réutilisé par les implémentations qui évaluent en mémoire.
+*
+* @param now - instant de référence pour l'état du jeton (`status`). Requis :
+*   « expiré » n'a pas de sens sans une horloge, et la lire ici ferait dépendre
+*   le résultat du moment du test plutôt que de la donnée.
+*/
+function matchesTokenQuery(record, query, now) {
+	if (query.subjectId !== void 0 && record.subjectId !== query.subjectId) return false;
+	if (query.kind !== void 0 && record.kind !== query.kind) return false;
+	if (!matchesTokenStatus(record, query.status, now)) return false;
+	return true;
+}
+/**
+* Store de jetons **en mémoire** — implémentation de référence d'{@link ITokenStore}.
+*
+* 0 dépendance, idéale pour le développement mono-process et les **tests**. NON
+* partagée entre process (pas de cluster) et **volatile** (tout est perdu au
+* redémarrage) → en production multi-process, utiliser un adapter ORM ou Redis.
+*
+* Perf/mémoire : les `Map` n'existent que si le store est instancié (JWT activé),
+* jamais sur le hot path par requête. La denylist `jti` est bornée par un
+* **balayage amorti** (purge des entrées expirées tous les 256 ajouts) doublé
+* d'une expiration paresseuse à la lecture — pas de minuterie, pas de fuite.
+*
+* Horloge injectable (`now`) pour des tests déterministes (pattern `LoginThrottler`).
+*/
+var MemoryTokenStore = class {
+	/**
+	* {@inheritDoc ITokenStore.sortableFields}
+	*
+	* Le store mémoire porte l'enregistrement complet : il sait donc trier tout le
+	* vocabulaire public, sans réduction de capacité.
+	*/
+	sortableFields = TOKEN_SORTABLE_FIELDS;
+	/** id → enregistrement (source de vérité). */
+	#byId = /* @__PURE__ */ new Map();
+	/** hash de secret → id (recherche au login). */
+	#idByHash = /* @__PURE__ */ new Map();
+	/** famille de rotation → ids (révocation groupée, reuse detection). */
+	#idsByFamily = /* @__PURE__ */ new Map();
+	/** porteur → ids (console « mes jetons », révocation ciblée). */
+	#idsBySubject = /* @__PURE__ */ new Map();
+	/** jti d'access denylisté → expiration (epoch ms). */
+	#deniedJti = /* @__PURE__ */ new Map();
+	/** porteur → seuil `invalidBefore` (epoch ms) — révocation en masse. */
+	#invalidBefore = /* @__PURE__ */ new Map();
+	#now;
+	/** Fenêtre de conservation d'un PAT révoqué sans expiration (audit) avant purge. */
+	#retentionRevokedMs;
+	#sweepCounter = 0;
+	constructor(now = Date.now, retentionRevokedMs = 2592e6) {
+		this.#now = now;
+		this.#retentionRevokedMs = retentionRevokedMs;
+	}
+	put(record) {
+		this.#byId.set(record.id, record);
+		this.#idByHash.set(record.secretHash, record.id);
+		this.#addToIndex(this.#idsBySubject, record.subjectId, record.id);
+		if (record.family) this.#addToIndex(this.#idsByFamily, record.family, record.id);
+		return Promise.resolve();
+	}
+	findById(id) {
+		return Promise.resolve(this.#byId.get(id) ?? null);
+	}
+	findByHash(secretHash) {
+		const id = this.#idByHash.get(secretHash);
+		return Promise.resolve(id !== void 0 ? this.#byId.get(id) ?? null : null);
+	}
+	findBySubject(subjectId) {
+		const ids = this.#idsBySubject.get(subjectId);
+		if (!ids) return Promise.resolve([]);
+		const out = [];
+		for (const id of ids) {
+			const record = this.#byId.get(id);
+			if (record) out.push(record);
+		}
+		return Promise.resolve(out);
+	}
+	listAll() {
+		return Promise.resolve([...this.#byId.values()]);
+	}
+	listPage(query) {
+		assertPageQuery(query, "offset");
+		const limit = Math.max(1, Math.floor(query.limit));
+		const offset = Math.max(0, Math.floor(query.offset ?? 0));
+		const now = this.#now();
+		const filtered = [...this.#byId.values()].filter((r) => matchesTokenQuery(r, query, now));
+		const order = pickOrder(query.order, this.sortableFields, TOKEN_DEFAULT_ORDER);
+		filtered.sort(compareByOrder(order, (r, field) => r[field]));
+		const items = filtered.slice(offset, offset + limit);
+		const total = query.withTotal === false ? void 0 : filtered.length;
+		return Promise.resolve({
+			items,
+			total,
+			limit,
+			offset,
+			hasNext: offset + items.length < filtered.length
+		});
+	}
+	countTokens(query) {
+		const now = this.#now();
+		let n = 0;
+		for (const r of this.#byId.values()) if (matchesTokenQuery(r, query, now)) n += 1;
+		return Promise.resolve(n);
+	}
+	markUsed(id, usage) {
+		const record = this.#byId.get(id);
+		if (record) {
+			record.lastUsedAt = usage.at;
+			record.lastUsedIp = usage.ip ?? null;
+			record.lastUsedUserAgent = usage.userAgent ?? null;
+		}
+		return Promise.resolve();
+	}
+	revoke(id, reason) {
+		this.#revokeRecord(this.#byId.get(id), reason);
+		return Promise.resolve();
+	}
+	revokeFamily(family, reason) {
+		const ids = this.#idsByFamily.get(family);
+		if (ids) for (const id of ids) this.#revokeRecord(this.#byId.get(id), reason);
+		return Promise.resolve();
+	}
+	denyJti(jti, expiresAt) {
+		this.#deniedJti.set(jti, expiresAt);
+		this.#maybeSweep();
+		return Promise.resolve();
+	}
+	isJtiDenied(jti) {
+		const expiresAt = this.#deniedJti.get(jti);
+		if (expiresAt === void 0) return Promise.resolve(false);
+		if (expiresAt <= this.#now()) {
+			this.#deniedJti.delete(jti);
+			return Promise.resolve(false);
+		}
+		return Promise.resolve(true);
+	}
+	revokeAllForSubject(subjectId, invalidBefore) {
+		const current = this.#invalidBefore.get(subjectId);
+		if (current === void 0 || invalidBefore > current) this.#invalidBefore.set(subjectId, invalidBefore);
+		return Promise.resolve();
+	}
+	getInvalidBefore(subjectId) {
+		return Promise.resolve(this.#invalidBefore.get(subjectId) ?? null);
+	}
+	gc(now = this.#now()) {
+		let purged = 0;
+		for (const [jti, expiresAt] of this.#deniedJti) if (expiresAt <= now) {
+			this.#deniedJti.delete(jti);
+			purged++;
+		}
+		for (const [id, record] of this.#byId) if (this.#isPurgeable(record, now)) {
+			this.#removeRecord(id, record);
+			purged++;
+		}
+		return Promise.resolve(purged);
+	}
+	/**
+	* Un record est purgeable s'il est **expiré** (`expiresAt` passé — couvre les
+	* refresh, y compris révoqués par rotation : conservés jusqu'à leur `exp` =
+	* fenêtre de détection de rejeu, puis tombent ici), OU s'il est un PAT
+	* **révoqué sans expiration** au-delà de la fenêtre de rétention (audit) —
+	* sinon il resterait éternellement.
+	*/
+	#isPurgeable(record, now) {
+		if (record.expiresAt !== null && record.expiresAt <= now) return true;
+		return record.revokedAt !== null && record.expiresAt === null && record.revokedAt + this.#retentionRevokedMs <= now;
+	}
+	/** Instantané sérialisable de l'état courant (records + denylist + seuils). */
+	snapshot() {
+		return {
+			records: [...this.#byId.values()],
+			deniedJti: [...this.#deniedJti.entries()],
+			invalidBefore: [...this.#invalidBefore.entries()]
+		};
+	}
+	/** Remplace l'état par celui d'un instantané (reconstruit les index dérivés). */
+	restore(snapshot) {
+		this.#byId.clear();
+		this.#idByHash.clear();
+		this.#idsByFamily.clear();
+		this.#idsBySubject.clear();
+		this.#deniedJti.clear();
+		this.#invalidBefore.clear();
+		for (const record of snapshot.records) {
+			this.#byId.set(record.id, record);
+			this.#idByHash.set(record.secretHash, record.id);
+			this.#addToIndex(this.#idsBySubject, record.subjectId, record.id);
+			if (record.family) this.#addToIndex(this.#idsByFamily, record.family, record.id);
+		}
+		for (const [jti, expiresAt] of snapshot.deniedJti) this.#deniedJti.set(jti, expiresAt);
+		for (const [subjectId, ts] of snapshot.invalidBefore) this.#invalidBefore.set(subjectId, ts);
+	}
+	#addToIndex(index, key, id) {
+		let set = index.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			index.set(key, set);
+		}
+		set.add(id);
+	}
+	#revokeRecord(record, reason) {
+		if (record && record.revokedAt === null) {
+			record.revokedAt = this.#now();
+			record.revokedReason = reason;
+		}
+	}
+	/** Retire un record et nettoie TOUS ses index (évite les références fantômes). */
+	#removeRecord(id, record) {
+		this.#byId.delete(id);
+		this.#idByHash.delete(record.secretHash);
+		this.#dropFromIndex(this.#idsBySubject, record.subjectId, id);
+		if (record.family) this.#dropFromIndex(this.#idsByFamily, record.family, id);
+	}
+	#dropFromIndex(index, key, id) {
+		const set = index.get(key);
+		if (set) {
+			set.delete(id);
+			if (set.size === 0) index.delete(key);
+		}
+	}
+	/** Purge amortie des `jti` expirés — borne la denylist sans coût par appel. */
+	#maybeSweep() {
+		if ((++this.#sweepCounter & 255) !== 0) return;
+		const now = this.#now();
+		for (const [jti, expiresAt] of this.#deniedJti) if (expiresAt <= now) this.#deniedJti.delete(jti);
+	}
+};
+//#endregion
+export { MemoryTokenStore, matchesTokenQuery };

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

@@ -0,0 +1,231 @@
+import { canonicalIssuer, extractScopes, issuerMetadataUrls, validateIssuerMetadata } from "nodefony";
+//#region nodefony/src/token/RemoteJwtVerifier.ts
+/**
+* Codes d'erreur `jose` qui désignent un **jeton fautif** — la liste est
+* BLANCHE, et c'est le point important.
+*
+* La distinction refus / panne n'est pas cosmétique : répondre « jeton refusé »
+* quand l'émetteur est injoignable envoie le client en chercher un autre — qui
+* échouera pareil — et noie la panne dans une statistique d'authentification.
+*
+* Le sens de la liste a été choisi en lisant la source de `jose`, pas de
+* mémoire : un JWKS qui répond `500`, ou dont le corps n'est pas du JSON, y
+* lève une erreur GÉNÉRIQUE (`ERR_JOSE_GENERIC`), et une panne réseau brute
+* remonte sans aucun code. Une liste noire des pannes aurait donc classé ces
+* trois cas — tous des pannes — en « jeton invalide », silencieusement. Ici,
+* ce qui n'est pas explicitement imputable au jeton devient une panne visible.
+*/
+const TOKEN_FAULT_CODES = /* @__PURE__ */ new Set([
+	"ERR_JWS_SIGNATURE_VERIFICATION_FAILED",
+	"ERR_JWT_EXPIRED",
+	"ERR_JWT_CLAIM_VALIDATION_FAILED",
+	"ERR_JWT_INVALID",
+	"ERR_JWS_INVALID",
+	"ERR_JOSE_ALG_NOT_ALLOWED",
+	"ERR_JWKS_NO_MATCHING_KEY"
+]);
+/**
+* Vérificateur de jetons d'accès émis par un **serveur d'autorisation tiers**.
+*
+* C'est la pièce qui manquait pour que le rôle *serveur de ressource* du cœur
+* (`nodefony/src/oauth/`) soit autre chose qu'un refus poli : il sait publier ce
+* qu'il protège et dire où prendre un jeton, mais rien, jusqu'ici, ne savait
+* LIRE ce jeton. `JwtAuthenticator` ne vérifie que les jetons émis par
+* Nodefony lui-même (jeu de clés local) ; ici, les clés appartiennent à
+* quelqu'un d'autre, arrivent par le réseau et tournent sans prévenir.
+*
+* ## Ce qui vaut garantie
+*
+* - **L'audience est obligatoire et vient de l'APPELANT** — jamais du jeton. Un
+*   jeton parfaitement valide, émis par un émetteur de confiance, pour un AUTRE
+*   service, est refusé (RFC 8707 §2). C'est la seule chose qui empêche le
+*   rejeu d'un jeton légitime d'une ressource vers une autre.
+* - **L'algorithme est imposé par la configuration** (RFC 8725 §3.1), jamais lu
+*   dans l'en-tête ; `alg: none` n'existe pas pour cette API.
+* - **Les clés viennent du `jwks_uri` de l'émetteur**, jamais d'un `jku` ou
+*   d'un `jwk` porté par le jeton (§3.5) — sans quoi un attaquant fournirait
+*   la clé qui valide sa propre signature.
+* - **La liste des émetteurs est fermée** : un `iss` inconnu est refusé avant
+*   toute requête sortante.
+*
+* ## Ce que cette classe ne fait pas
+*
+* Elle n'établit pas d'utilisateur applicatif : elle rend un sujet et des
+* scopes. Rattacher ce sujet à un compte local (approvisionnement à la volée,
+* comptes de service) est une décision d'application, pas de protocole — et
+* l'entremêler ici rendrait impossible d'accepter un appelant purement machine,
+* qui est précisément le cas d'usage.
+*
+* @see references/rfc/ietf/rfc8707.txt — l'audience, qui LIE un jeton à CE service
+*/
+var RemoteJwtVerifier = class {
+	#issuers;
+	#resolved = /* @__PURE__ */ new Map();
+	#options;
+	#jose = null;
+	/**
+	* @param options - émetteurs de confiance et réglages réseau
+	* @throws Error si un émetteur est invalide, dupliqué, ou déclare un
+	*         algorithme à secret partagé
+	*/
+	constructor(options) {
+		this.#options = options;
+		this.#issuers = /* @__PURE__ */ new Map();
+		for (const trusted of options.issuers) {
+			const issuer = canonicalIssuer(trusted.issuer);
+			if (this.#issuers.has(issuer)) throw new Error(`émetteur « ${issuer} » déclaré deux fois — deux politiques pour un même émetteur ne peuvent pas coexister : la seconde serait ignorée en silence.`);
+			assertAsymmetric(issuer, trusted.algorithms);
+			this.#issuers.set(issuer, {
+				...trusted,
+				issuer
+			});
+		}
+	}
+	/** Nombre d'émetteurs de confiance — pour l'introspection et les journaux. */
+	get size() {
+		return this.#issuers.size;
+	}
+	/**
+	* Vérifie un jeton porté, pour UNE ressource donnée.
+	*
+	* Conforme au contrat `IAccessTokenVerifier` du cœur : un refus est un `null`,
+	* jamais une exception. Les exceptions sont réservées aux pannes — un
+	* émetteur injoignable n'est pas un jeton invalide.
+	*
+	* @param token - le jeton brut, tel que présenté
+	* @param audience - URI canonique de la ressource visée ; le jeton DOIT la
+	*          porter dans `aud`
+	* @returns le principal établi, ou `null` si le jeton est refusé
+	* @throws Error si l'émetteur ne peut pas être joint ou publie un jeu de clés
+	*         inutilisable — la porte doit alors refuser de servir, pas répondre
+	*         « jeton invalide »
+	*/
+	async verify(token, audience) {
+		if (typeof token !== "string" || token.length === 0) return null;
+		const jose = this.#jose ??= await import("jose");
+		let claimedIssuer;
+		try {
+			const claims = jose.decodeJwt(token);
+			if (typeof claims.iss !== "string") return null;
+			claimedIssuer = canonicalIssuer(claims.iss);
+		} catch {
+			return null;
+		}
+		const trusted = this.#issuers.get(claimedIssuer);
+		if (!trusted) {
+			this.#audit(`jeton refusé : émetteur « ${claimedIssuer} » non déclaré.`);
+			return null;
+		}
+		const { getKey } = await this.#resolve(trusted, jose);
+		try {
+			const { payload } = await jose.jwtVerify(token, getKey, {
+				algorithms: [...trusted.algorithms],
+				issuer: trusted.issuer,
+				audience,
+				clockTolerance: this.#options.clockToleranceS ?? 5,
+				...trusted.typ ? { typ: trusted.typ } : {},
+				...trusted.requiredClaims?.length ? { requiredClaims: [...trusted.requiredClaims] } : {}
+			});
+			const subject = typeof payload.sub === "string" ? payload.sub : void 0;
+			return {
+				issuer: claimedIssuer,
+				subject,
+				scopes: extractScopes(payload),
+				expiresAt: typeof payload.exp === "number" ? payload.exp : void 0,
+				issuedAt: typeof payload.iat === "number" ? payload.iat : void 0,
+				tokenId: typeof payload.jti === "string" ? payload.jti : void 0
+			};
+		} catch (error) {
+			const code = error.code;
+			if (!code || !TOKEN_FAULT_CODES.has(code)) throw new Error(`vérification impossible : l'émetteur « ${trusted.issuer} » n'a pas fourni de jeu de clés utilisable (${code ?? error.message}).`, { cause: error });
+			this.#audit(`jeton refusé (${trusted.issuer}) : ${code}`);
+			return null;
+		}
+	}
+	/**
+	* Résout — une seule fois par émetteur — la fonction qui fournit les clés.
+	*
+	* La promesse elle-même est mémorisée, pas son résultat : deux jetons qui
+	* arrivent ensemble à froid partagent la même découverte au lieu d'en lancer
+	* deux. En cas d'échec, l'entrée est retirée pour qu'un appel ultérieur
+	* réessaie — une panne passagère ne doit pas condamner l'émetteur pour la
+	* durée de vie du processus.
+	*/
+	#resolve(trusted, jose) {
+		if (trusted.localJwks) return this.#build(trusted, jose);
+		const pending = this.#resolved.get(trusted.issuer);
+		if (pending) return pending;
+		const promise = this.#build(trusted, jose).catch((error) => {
+			this.#resolved.delete(trusted.issuer);
+			throw error;
+		});
+		this.#resolved.set(trusted.issuer, promise);
+		return promise;
+	}
+	async #build(trusted, jose) {
+		if (trusted.localJwks) return {
+			trusted,
+			getKey: jose.createLocalJWKSet(await trusted.localJwks())
+		};
+		const jwksUri = trusted.jwksUri ?? await this.#discover(trusted.issuer);
+		const options = {
+			timeoutDuration: this.#options.timeoutMs ?? 5e3,
+			cooldownDuration: this.#options.cooldownMs ?? 3e4,
+			cacheMaxAge: this.#options.cacheMaxAgeMs ?? 6e5
+		};
+		const fetchImpl = this.#options.fetch;
+		if (fetchImpl) options[jose.customFetch] = fetchImpl;
+		return {
+			trusted,
+			getKey: jose.createRemoteJWKSet(new URL(jwksUri), options)
+		};
+	}
+	/**
+	* Trouve le `jwks_uri` d'un émetteur en essayant les points bien connus,
+	* dans l'ordre normatif, et en s'arrêtant au premier document VALIDE.
+	*
+	* Un document qui répond mais ne se réclame pas du bon émetteur n'est pas une
+	* « meilleure réponse que rien » : il est écarté comme s'il n'avait pas
+	* répondu, et la recherche continue.
+	*/
+	async #discover(issuer) {
+		const doFetch = this.#options.fetch ?? globalThis.fetch;
+		const timeout = this.#options.timeoutMs ?? 5e3;
+		const failures = [];
+		for (const url of issuerMetadataUrls(issuer)) try {
+			const response = await doFetch(url, {
+				signal: AbortSignal.timeout(timeout),
+				redirect: "manual",
+				headers: { accept: "application/json" }
+			});
+			if (!response.ok) {
+				failures.push(`${url} → HTTP ${response.status}`);
+				continue;
+			}
+			const metadata = validateIssuerMetadata(await response.json(), issuer);
+			this.#audit(`émetteur « ${issuer} » découvert : clés sur ${metadata.jwksUri}.`);
+			return metadata.jwksUri;
+		} catch (error) {
+			failures.push(`${url} → ${error.message}`);
+		}
+		throw new Error(`découverte impossible pour l'émetteur « ${issuer} » : aucun document de métadonnées valide. Essayé — ${failures.join(" ; ")}. Déclarer \`jwksUri\` évite toute découverte.`);
+	}
+	#audit(message) {
+		this.#options.log?.(message);
+	}
+};
+/**
+* Refuse un algorithme à secret partagé sur un jeu de clés PUBLIC.
+*
+* C'est la confusion d'algorithme la plus classique (RFC 8725 §2.1) : la clé
+* publique de l'émetteur est lisible par tout le monde ; acceptée comme secret
+* HMAC, elle laisse n'importe qui signer un jeton valide. La règle vaut au
+* démarrage, où elle empêche la configuration d'exister, plutôt qu'à la
+* vérification, où elle dépendrait d'un jeton pour se manifester.
+*/
+function assertAsymmetric(issuer, algorithms) {
+	if (algorithms.length === 0) throw new Error(`émetteur « ${issuer} » : aucun algorithme accepté — la liste est la garde principale (RFC 8725 §3.1), elle ne peut pas être vide.`);
+	for (const alg of algorithms) if (alg.startsWith("HS") || alg.toLowerCase() === "none") throw new Error(`émetteur « ${issuer} » : algorithme « ${alg} » refusé. Les clés proviennent d'un jeu PUBLIC : un algorithme à secret partagé y transformerait la clé publique en secret de signature.`);
+}
+//#endregion
+export { RemoteJwtVerifier, RemoteJwtVerifier as default };

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

@@ -0,0 +1,67 @@
+import { anonymousUser } from "@nodefony/user";
+//#region nodefony/src/token/UserToken.ts
+/**
+* Jeton porteur d'un utilisateur réel — produit par les authenticators à
+* credential (`userpassword`, puis `session`/`jwt`...).
+*
+* Cycle en deux états, UN SEUL objet alloué par tentative (cold path login) :
+* 1. `createToken()` → non authentifié : porte le credential brut extrait de la
+*    requête, `getUser()` rend l'anonyme (jamais `null`, Zero Trust).
+* 2. `authenticate()` réussit → {@link promote} : l'utilisateur vérifié est posé
+*    et le credential est **effacé** (anti-fuite : un mot de passe ne doit
+*    survivre ni en mémoire ni dans un heap dump/log).
+*
+* Les attributs (claims, providerId...) sont lazy — `null` tant que rien n'est posé.
+*/
+var UserToken = class {
+	type;
+	#user = null;
+	#credentials;
+	#attributes = null;
+	/**
+	* @param type - type du token (`"userpassword"`, `"session"`, `"jwt"`...).
+	* @param credentials - credential brut extrait de la requête (vidé au succès).
+	*/
+	constructor(type, credentials = null) {
+		this.type = type;
+		this.#credentials = credentials;
+	}
+	/**
+	* Marque le jeton authentifié : pose l'utilisateur vérifié et EFFACE le
+	* credential. Appelé uniquement par l'authenticator au succès.
+	*
+	* @param user - utilisateur vérifié par la source d'identité.
+	* @returns le jeton lui-même (chaînage).
+	*/
+	promote(user) {
+		this.#user = user;
+		this.#credentials = null;
+		return this;
+	}
+	getUser() {
+		return this.#user ?? anonymousUser;
+	}
+	getUserIdentifier() {
+		return (this.#user ?? anonymousUser).identifier;
+	}
+	isAuthenticated() {
+		return this.#user !== null;
+	}
+	getRoles() {
+		return this.#user ? [...this.#user.roles] : [...anonymousUser.roles];
+	}
+	getCredentials() {
+		return this.#credentials;
+	}
+	getScopes() {
+		return this.#attributes?.get("scopes") ?? [];
+	}
+	getAttribute(key) {
+		return this.#attributes?.get(key);
+	}
+	setAttribute(key, value) {
+		(this.#attributes ??= /* @__PURE__ */ new Map()).set(key, value);
+	}
+};
+//#endregion
+export { UserToken, UserToken as default };

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

@@ -0,0 +1,19 @@
+//#region nodefony/src/token/jwtRuntime.ts
+/**
+* Dérive les paramètres effectifs depuis la config sécurité. `issuer` omis →
+* `"nodefony"` (DEVRAIT être surchargé en prod) ; `audiences` vide → l'app est sa
+* propre audience (`[issuer]`).
+*/
+function resolveJwtRuntime(jwt) {
+	const issuer = jwt.issuer && jwt.issuer.length > 0 ? jwt.issuer : "nodefony";
+	return {
+		issuer,
+		audiences: jwt.audiences.length > 0 ? [...jwt.audiences] : [issuer],
+		accessTtlS: jwt.accessTtlS,
+		refreshTtlS: jwt.refreshTtlS,
+		rotateRefresh: jwt.rotateRefresh,
+		alg: "EdDSA"
+	};
+}
+//#endregion
+export { resolveJwtRuntime };

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

@@ -0,0 +1,134 @@
+import path from "node:path";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import process from "node:process";
+//#region nodefony/src/token/secretFile.ts
+/**
+* Écrire un SECRET sur disque — la seule implémentation du dépôt.
+*
+* ## Les trois règles, et ce que chacune évite
+*
+* 1. **Ne jamais tester la présence avant de lire.** `existsSync(f) ? read(f)
+*    : ""` ouvre une fenêtre entre le test et l'usage : le fichier peut
+*    disparaître, ou devenir un lien vers ailleurs. La forme juste est de lire
+*    et de traiter `ENOENT` — le système de fichiers répond en une opération ce
+*    que deux appels ne peuvent pas garantir.
+* 2. **Écrire en 0600, atomiquement.** Un secret créé au masque par défaut est
+*    lisible par tous les comptes de la machine, et rien ne le signale. Le
+*    couple fichier temporaire + `rename` évite en plus qu'un lecteur tombe sur
+*    un fichier à demi écrit.
+* 3. **CONSTATER le mode obtenu.** Le mode demandé est une intention, pas une
+*    garantie : NTFS l'ignore, comme un montage FAT/exFAT ou NFS sans mapping
+*    d'identité. Une capacité se constate, elle ne se déduit pas de
+*    `process.platform` — et si la restriction n'a pas pris, il faut le DIRE
+*    plutôt que laisser croire à une protection.
+*
+* ## Pourquoi les deux formes, synchrone et asynchrone
+*
+* Le runtime persiste ses clés dans du code asynchrone ; une commande de CLI
+* écrit un jeton dans un flot synchrone, où introduire une promesse
+* changerait l'ordre des messages affichés. Les deux formes appliquent le même
+* raisonnement, écrit ici une seule fois — deux copies divergeraient, et l'on
+* sait exactement comment : l'une porterait le mode 0600, l'autre non.
+*
+* @module
+*/
+/** Mode attendu d'un fichier qui porte un secret : lisible par son seul propriétaire. */
+const MODE_SECRET = 384;
+/**
+* Le contenu du fichier, ou `null` s'il n'existe pas.
+*
+* @throws Toute erreur autre qu'`ENOENT` — un fichier illisible pour cause de
+*         droits n'est PAS un fichier absent, et le confondre ferait écraser un
+*         secret existant par un fichier neuf.
+*/
+async function readIfPresent(file) {
+	try {
+		return await readFile(file, "utf8");
+	} catch (e) {
+		if (e.code === "ENOENT") return null;
+		throw e;
+	}
+}
+/** Forme synchrone de {@link readIfPresent}. */
+function readIfPresentSync(file) {
+	try {
+		return readFileSync(file, "utf8");
+	} catch (e) {
+		if (e.code === "ENOENT") return null;
+		throw e;
+	}
+}
+/**
+* Le mode effectif du fichier n'est-il PAS restreint au propriétaire ?
+*
+* @returns `null` si le fichier a disparu ou n'est pas interrogeable (le chemin
+*          d'erreur normal parlera), sinon le mode effectif quand il diffère de
+*          0600 — et `undefined` quand tout va bien.
+*/
+function modeNonRestreint(file) {
+	let mode;
+	try {
+		mode = statSync(file).mode & 511;
+	} catch {
+		return null;
+	}
+	return mode === 384 ? void 0 : mode;
+}
+/** Forme asynchrone de {@link modeNonRestreint}. */
+async function modeNonRestreintAsync(file) {
+	let mode;
+	try {
+		mode = (await stat(file)).mode & 511;
+	} catch {
+		return null;
+	}
+	return mode === 384 ? void 0 : mode;
+}
+/**
+* La phrase à journaliser quand la restriction n'a PAS pris.
+*
+* Elle nomme la cause probable et ce qui reste à faire : un avertissement qui
+* dit seulement « mode inattendu » se lit comme du bruit et finit ignoré.
+*/
+function messageNonRestreint(file, mode) {
+	return `${file} porte un SECRET mais n'est PAS restreint au seul propriétaire (mode ${mode.toString(8).padStart(4, "0")}, attendu 0600). Le système de fichiers n'applique pas les permissions POSIX (NTFS, FAT/exFAT, NFS sans mapping d'identité), ou le fichier a été déposé par un tiers. La confidentialité dépend alors des seuls droits du dossier — restreignez-les : ` + (process.platform === "win32" ? `icacls "${file}" /inheritance:r /grant:r "%USERNAME%:R"` : `chmod 600 "${file}"`) + `.`;
+}
+/**
+* Écrit un secret : dossier créé, mode 0600, remplacement ATOMIQUE.
+*
+* Le mode est posé à la création du temporaire — et non après `rename` — pour
+* qu'il n'existe à aucun instant un fichier au contenu secret et au masque par
+* défaut. `chmod` est ensuite réappliqué sur la cible : un `rename` par-dessus
+* un fichier EXISTANT conserve, sur certains systèmes, le mode de la cible.
+*/
+async function writeSecret(file, content) {
+	await mkdir(path.dirname(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.tmp`;
+	await writeFile(tmp, content, { mode: 384 });
+	try {
+		await rename(tmp, file);
+	} catch (e) {
+		await rm(tmp, { force: true }).catch(() => {});
+		throw e;
+	}
+}
+/** Forme synchrone de {@link writeSecret}. */
+function writeSecretSync(file, content) {
+	mkdirSync(path.dirname(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.tmp`;
+	writeFileSync(tmp, content, { mode: 384 });
+	try {
+		renameSync(tmp, file);
+	} catch (e) {
+		try {
+			rmSync(tmp, { force: true });
+		} catch {}
+		throw e;
+	}
+	try {
+		chmodSync(file, 384);
+	} catch {}
+}
+//#endregion
+export { MODE_SECRET, messageNonRestreint, modeNonRestreint, modeNonRestreintAsync, readIfPresent, readIfPresentSync, writeSecret, writeSecretSync };