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

package/dist/nodefony/src/voter/RoleVoter.js

@@ -1,6 +1,6 @@
 import { RoleHierarchyWalker } from "../RoleHierarchyWalker.js";
 import "../../contracts/IAccessVoter.js";
-//#region nodefony/src/voter/RoleVoter.ts
+// nodefony/src/voter/RoleVoter.ts
 /**
 * Voter built-in **niveau A** — résout les attributs `ROLE_*` via la hiérarchie
 * de rôles ({@link RoleHierarchyWalker}).
@@ -28,5 +28,4 @@ var RoleVoter = class {
 		return Promise.resolve(vote);
 	}
 };
-//#endregion
 export { RoleVoter, RoleVoter as default };

package/dist/nodefony/src/voter/ScopeVoter.js

@@ -1,5 +1,5 @@
 import "../../contracts/IAccessVoter.js";
-//#region nodefony/src/voter/ScopeVoter.ts
+// nodefony/src/voter/ScopeVoter.ts
 /**
 * Types de jetons **non scopables** — identité humaine interactive (session BFF
 * web/Studio/WS, login mot de passe) ou visiteur anonyme. Un scope `api:action`
@@ -48,5 +48,4 @@ var ScopeVoter = class {
 		return Promise.resolve(token.getScopes().includes(attribute) ? "GRANT" : "ABSTAIN");
 	}
 };
-//#endregion
 export { ScopeVoter, ScopeVoter as default };

package/dist/nodefony/src/voter/voterRegistry.js

@@ -1,6 +1,6 @@
 import { RoleVoter } from "./RoleVoter.js";
 import { ScopeVoter } from "./ScopeVoter.js";
-//#region nodefony/src/voter/voterRegistry.ts
+// nodefony/src/voter/voterRegistry.ts
 const factories = /* @__PURE__ */ new Map();
 /**
 * Enregistre (ou remplace) la fabrique d'un voter. Appelé par les builtins au
@@ -16,5 +16,4 @@ function listVoterFactories() {
 }
 registerVoterFactory("role", ({ container }) => new RoleVoter(container));
 registerVoterFactory("scope", () => new ScopeVoter());
-//#endregion
 export { listVoterFactories, registerVoterFactory };

package/dist/nodefony/src/webauthn/MemoryWebAuthnCredentialStore.js

@@ -1,5 +1,5 @@
 import { assertPageQuery } from "nodefony";
-//#region nodefony/src/webauthn/MemoryWebAuthnCredentialStore.ts
+// nodefony/src/webauthn/MemoryWebAuthnCredentialStore.ts
 /**
 * Projection contractuelle : credential complet → vue admin **sans `publicKey`**.
 * Partagée par les backends qui matérialisent des credentials en mémoire.
@@ -135,5 +135,4 @@ var MemoryWebAuthnCredentialStore = class {
 		}
 	}
 };
-//#endregion
 export { MemoryWebAuthnCredentialStore, MemoryWebAuthnCredentialStore as default, toWebAuthnSummary };

package/dist/nodefony/src/webauthn/webAuthnCredentialStoreRegistry.js

@@ -1,5 +1,5 @@
 import { MemoryWebAuthnCredentialStore } from "./MemoryWebAuthnCredentialStore.js";
-//#region nodefony/src/webauthn/webAuthnCredentialStoreRegistry.ts
+// nodefony/src/webauthn/webAuthnCredentialStoreRegistry.ts
 const factories = /* @__PURE__ */ new Map();
 /** Enregistre (ou remplace) la fabrique d'un store de credentials WebAuthn. */
 function registerWebAuthnStore(name, factory) {
@@ -14,5 +14,4 @@ function listWebAuthnStores() {
 	return [...factories.keys()];
 }
 registerWebAuthnStore("memory", () => new MemoryWebAuthnCredentialStore());
-//#endregion
 export { getWebAuthnStoreFactory, listWebAuthnStores, registerWebAuthnStore };

package/dist/nodefony/src/webhook/MemoryWebhookStore.js

@@ -1,6 +1,6 @@
 import { WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS } from "./webhookSort.js";
 import { assertPageQuery, compareByOrder, pickOrder } from "nodefony";
-//#region nodefony/src/webhook/MemoryWebhookStore.ts
+// nodefony/src/webhook/MemoryWebhookStore.ts
 /**
 * Applique les filtres d'{@link IWebhookListQuery} à un endpoint — sémantique de
 * RÉFÉRENCE du contrat, partagée par les backends qui filtrent en mémoire.
@@ -91,5 +91,4 @@ var MemoryWebhookStore = class {
 		return n;
 	}
 };
-//#endregion
 export { MemoryWebhookStore, matchesWebhookQuery };

package/dist/nodefony/src/webhook/WebhookDispatcher.js

@@ -1,5 +1,5 @@
 import { webhookSignatureHeaders } from "./webhookSignature.js";
-//#region nodefony/src/webhook/WebhookDispatcher.ts
+// nodefony/src/webhook/WebhookDispatcher.ts
 /**
 * Dispatcher de webhooks sortants — abonné au journal d'audit, il filtre les
 * événements par souscription, signe (Standard Webhooks v1) et livre, **sans
@@ -205,5 +205,4 @@ var WebhookDispatcher = class {
 		this.#queue = null;
 	}
 };
-//#endregion
 export { WebhookDispatcher, backoffMs, classifyDelivery, matchesSubscription };

package/dist/nodefony/src/webhook/webhookCipher.js

@@ -1,6 +1,6 @@
 import { decryptSecret, deriveKey, encryptSecret, generateEphemeralKey } from "../crypto/secretCipher.js";
 import { Buffer } from "node:buffer";
-//#region nodefony/src/webhook/webhookCipher.ts
+// nodefony/src/webhook/webhookCipher.ts
 /**
 * Chiffrement réversible du secret de signature webhook au repos — façade de
 * domaine au-dessus de {@link ../crypto/secretCipher} (calque {@link ../totp/totpCipher}).
@@ -23,5 +23,4 @@ const WEBHOOK_DERIVATION = {
 function deriveWebhookKey(material) {
 	return deriveKey(material, WEBHOOK_DERIVATION);
 }
-//#endregion
 export { decryptSecret, deriveWebhookKey, encryptSecret, generateEphemeralKey };

package/dist/nodefony/src/webhook/webhookDelivery.js

@@ -2,7 +2,7 @@ import { Buffer } from "node:buffer";
 import { isIP } from "node:net";
 import { request } from "node:https";
 import { request as request$1 } from "node:http";
-//#region nodefony/src/webhook/webhookDelivery.ts
+// nodefony/src/webhook/webhookDelivery.ts
 /**
 * Émetteur HTTP d'une livraison webhook — `node:http(s)` natif (0 dép). Trois
 * propriétés de sécurité par rapport à `fetch` :
@@ -98,5 +98,4 @@ function deliverWebhook(url, body, headers, opts) {
 		req.end();
 	});
 }
-//#endregion
 export { deliverWebhook };

package/dist/nodefony/src/webhook/webhookFilters.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/webhook/webhookFilters.ts
+// nodefony/src/webhook/webhookFilters.ts
 /**
 * **Le vocabulaire de filtre des endpoints webhook**, en noms PUBLICS — ceux
 * qu'un client écrit dans l'URL (`?enabled=false&event=user.created`).
@@ -52,5 +52,4 @@ const WEBHOOK_FACETS = {
 * Un test verrouille l'accord entre cette liste et {@link WEBHOOK_FACETS}.
 */
 const WEBHOOK_STATS_FILTERS = { event: "string" };
-//#endregion
 export { WEBHOOK_FACETS, WEBHOOK_FILTERS, WEBHOOK_STATS_FILTERS };

package/dist/nodefony/src/webhook/webhookSignature.js

@@ -1,6 +1,6 @@
 import { createHmac } from "node:crypto";
 import { Buffer } from "node:buffer";
-//#region nodefony/src/webhook/webhookSignature.ts
+// nodefony/src/webhook/webhookSignature.ts
 /**
 * Signature des webhooks sortants — schéma **Standard Webhooks v1**
 * (standardwebhooks.com), choisi plutôt que RFC 9421 (trop lourd pour un webhook,
@@ -47,5 +47,4 @@ function webhookSignatureHeaders(secret, id, timestampS, body) {
 		"webhook-signature": signStandardWebhook(secret, id, timestampS, body)
 	};
 }
-//#endregion
 export { buildSignatureBase, parseWebhookSecret, signStandardWebhook, webhookSignatureHeaders };

package/dist/nodefony/src/webhook/webhookSort.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/webhook/webhookSort.ts
+// nodefony/src/webhook/webhookSort.ts
 /**
 * **Le vocabulaire de tri des endpoints webhook**, en noms PUBLICS — ceux qu'un
 * client écrit dans l'URL (`?order=failureCount:DESC`), jamais des noms de
@@ -44,5 +44,4 @@ const WEBHOOK_SORTABLE_FIELDS = [
 * des deux ne jamais apparaître.
 */
 const WEBHOOK_DEFAULT_ORDER = [["createdAt", "DESC"], ["id", "ASC"]];
-//#endregion
 export { WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS };

package/dist/nodefony/src/webhook/webhookStoreRegistry.js

@@ -1,5 +1,5 @@
 import { MemoryWebhookStore } from "./MemoryWebhookStore.js";
-//#region nodefony/src/webhook/webhookStoreRegistry.ts
+// nodefony/src/webhook/webhookStoreRegistry.ts
 const factories = /* @__PURE__ */ new Map();
 /** Enregistre (ou remplace) la fabrique d'un store d'endpoints webhook. */
 function registerWebhookStore(name, factory) {
@@ -14,5 +14,4 @@ function listWebhookStores() {
 	return [...factories.keys()];
 }
 registerWebhookStore("memory", () => new MemoryWebhookStore());
-//#endregion
 export { getWebhookStoreFactory, listWebhookStores, registerWebhookStore };

package/dist/types/nodefony/command/{security-token.d.ts → security-mcp-token.d.ts}

@@ -20,7 +20,7 @@ export declare function ttlSeconds(raw: string | undefined): number | undefined
  */
 export declare function tokenTtlSeconds(raw: string | undefined, write: boolean): number | undefined | Error;
 /**
- * `nodefony security:token` — émet un jeton d'accès pour une porte de cette
+ * `nodefony security:mcp:token` — émet un jeton d'accès pour une porte de cette
  * application (la porte MCP par défaut).
  *
  * **Pourquoi une commande, et pas un `curl`.** Le jeton s'obtenait par un appel
@@ -34,11 +34,12 @@ export declare function tokenTtlSeconds(raw: string | undefined, write: boolean)
  * raison d'être de la liaison d'audience. La commande la vise d'elle-même,
  * `--resource` ne sert qu'à en viser une autre.
  *
- * Suit `security:secrets` : `--write` pose la valeur là où l'AGENT la lit
- * (gitignoré), jamais dans le `.env` commité, et ne remplace jamais une valeur
- * existante — une rotation est un geste explicite.
+ * `--write` pose la valeur là où l'AGENT la lit (gitignoré), jamais dans le
+ * `.env` de l'application. Relancée, elle REMPLACE le jeton chez les agents qui
+ * le portent déjà — la rotation est le geste le plus fréquent — et n'en câble
+ * aucun nouveau sans le proposer.
  */
-declare class SecurityToken extends Command {
+declare class SecurityMcpToken extends Command {
     #private;
     constructor(cli: CliKernel);
     generate(identifierArg: string | undefined, opts: {
@@ -50,4 +51,4 @@ declare class SecurityToken extends Command {
         json?: boolean;
     }): Promise<this>;
 }
-export default SecurityToken;
+export default SecurityMcpToken;

package/dist/types/nodefony/config/config.d.ts

@@ -31,6 +31,7 @@ export declare const securityConfigSchema: z.ZodObject<{
         rounds: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>>;
     roleHierarchy: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    grantableScopes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     areas: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         pattern: z.ZodString;
         security: z.ZodDefault<z.ZodBoolean>;

package/dist/types/nodefony/errors/ApiKeyError.d.ts

@@ -5,6 +5,8 @@ import { nodefonyError } from "nodefony";
  * classes de `@nodefony/security`).
  *
  *  - `400` — entrée invalide (nom vide, scope hors catalogue) ;
+ *  - `403` — scope demandé que le porteur ne peut pas obtenir (`grantableScopes`,
+ *    ou `admin:*` sans le rôle d'administration) ;
  *  - `409` — plafond `apiKeys.maxPerSubject` atteint ;
  *  - `503` — store de jetons indisponible (clés activées mais non provisionnées).
  *
@@ -12,6 +14,6 @@ import { nodefonyError } from "nodefony";
  * 401, message uniforme anti-énumération).
  */
 export declare class ApiKeyError extends nodefonyError {
-    constructor(message: string, code: 400 | 409 | 503);
+    constructor(message: string, code: 400 | 403 | 409 | 503);
 }
 export default ApiKeyError;

package/dist/types/nodefony/service/accessTokenVerifier.d.ts

@@ -1,29 +1,50 @@
 import { Service, Module } from "nodefony";
-import { RemoteJwtVerifier } from "../src/token/RemoteJwtVerifier.js";
+import type { IAccessTokenVerifier } from "nodefony";
 /**
- * Pose (ou non) le vérificateur de jetons d'accès TIERS dans le conteneur.
+ * Pose (ou non) le vérificateur de jetons d'accès dans le conteneur — celui
+ * qu'une ressource protégée (porte MCP, zone `external-jwt`) interroge.
  *
- * Ce service est une **décision de câblage**, pas de la cryptographie : toute la
- * mécanique vit dans {@link RemoteJwtVerifier}, et la doctrine de refus dans le
- * cœur (`nodefony/src/oauth/`). Ici, on lit la configuration et on tranche une
- * seule question — cette application accepte-t-elle des jetons émis ailleurs ?
+ * Ce service est une **décision de câblage**, pas de la cryptographie : la
+ * vérification d'un jeton TIERS vit dans {@link RemoteJwtVerifier}, celle d'un
+ * jeton de CETTE application dans {@link JwtAuthenticator}, et la doctrine de
+ * refus dans le cœur (`nodefony/src/oauth/`). Ici, on tranche deux questions :
+ * l'application signe-t-elle ses jetons, et en accepte-t-elle d'ailleurs ?
  *
- * **Aucun émetteur déclaré = rien n'est posé**, et c'est le comportement voulu :
- * une porte protégée qui ne trouve pas de vérificateur refuse de servir en le
- * disant (503 + CRITIC), là où un vérificateur présent mais vide refuserait
+ * ⭐ **Un jeton signé par cette application est TOUJOURS vérifiable**, dès que
+ * sa capacité JWT est active (`security.jwt.enabled`, le défaut) — sans rien
+ * déclarer dans `resourceServer.issuers`. Une application qui émet un jeton
+ * pour sa propre porte (`nodefony security:mcp:token --resource …`) doit pouvoir
+ * le lire : sans cette règle, la porte refusait un jeton parfaitement valide,
+ * et l'application était un serveur d'autorisation dont aucune ressource ne
+ * reconnaissait la signature. Rien de nouveau ne devient valide : l'audience
+ * reste exigée, et seules celles de `jwt.audiences` sont émises.
+ *
+ * 🔴 **Il est vérifié par les règles de l'authentificateur `jwt`, pas par son
+ * jeu de clés seul** : révocation ciblée et en masse, compte encore actif. Lu
+ * comme un jeton tiers, un jeton RÉVOQUÉ — ou celui d'un compte désactivé —
+ * ouvrait encore la porte jusqu'à son expiration.
+ *
+ * L'aiguillage se fait sur l'émetteur revendiqué (`peekIssuer`), comme dans le
+ * pare-feu : l'émetteur de l'application va à la vérification locale, tout
+ * autre à la liste fermée des émetteurs tiers. Un émetteur inconnu est refusé
+ * sans la moindre requête sortante.
+ *
+ * **Rien à vérifier = rien n'est posé** (capacité JWT coupée, aucun émetteur
+ * tiers) : une porte protégée qui ne trouve pas de vérificateur refuse alors de
+ * servir en le disant (503 + CRITIC), là où un vérificateur vide refuserait
  * chaque jeton un par un — même résultat pour l'appelant, diagnostic beaucoup
  * plus difficile pour l'exploitant.
  *
- * Le coût est nul quand la capacité n'est pas utilisée : rien n'est instancié,
- * aucune requête n'est faite au démarrage. La découverte des clés n'a lieu qu'au
- * PREMIER jeton réellement présenté, et une seule fois par émetteur.
+ * Le coût est nul tant qu'aucun jeton n'est présenté : aucune requête au
+ * démarrage, clés locales lues au premier jeton, découverte d'un émetteur tiers
+ * au premier jeton qui s'en réclame.
  */
 declare class AccessTokenVerifierService extends Service {
     #private;
     module: Module;
     constructor(module: Module);
-    /** Le vérificateur, ou `null` si aucun émetteur n'est déclaré. */
-    get verifier(): RemoteJwtVerifier | null;
+    /** Le vérificateur posé, ou `null` si rien n'est vérifiable. */
+    get verifier(): IAccessTokenVerifier | null;
 }
 export default AccessTokenVerifierService;
 export { AccessTokenVerifierService };

package/dist/types/nodefony/service/apiKeys.d.ts

@@ -40,11 +40,22 @@ declare class ApiKeyService extends Service {
      * Émet une nouvelle clé API pour un porteur — renvoie sa vue publique **+ le
      * token en clair** (affiché une seule fois).
      *
+     * Un scope que le porteur ne peut pas OBTENIR — réservé par
+     * `grantableScopes` à des rôles qu'il n'a pas, ou `admin:*` sans le rôle
+     * d'administration — refuse la création entière : une clé émise avec moins
+     * que demandé surprendrait sans qu'aucune réponse ne le dise. Même juge que
+     * l'émission des jetons ({@link refusedScopes}).
+     *
+     * @param roles - rôles du porteur tels que son compte les porte ; omis =
+     *   aucun rôle, donc tout scope réservé est refusé (fail-closed).
      * @throws ApiKeyError 400 — nom vide/trop long, scope hors catalogue, expiry invalide.
+     * @throws ApiKeyError 403 — scope réservé à des rôles que le porteur n'a pas.
      * @throws ApiKeyError 409 — plafond `maxPerSubject` atteint.
-     * @throws ApiKeyError 503 — store indisponible.
+     * @throws ApiKeyError 403 — aucun compte sous cet identifiant (la clé est liée
+     *   à l'`id` immuable du compte, lu dans l'annuaire).
+     * @throws ApiKeyError 503 — store ou annuaire `users` indisponible.
      */
-    createForSubject(subjectId: string, subjectType: "user" | "service", opts: ICreateApiKeyOptions): Promise<IApiKeyCreated>;
+    createForSubject(subjectId: string, subjectType: "user" | "service", opts: ICreateApiKeyOptions, roles?: readonly string[]): Promise<IApiKeyCreated>;
     /** Liste les clés (PAT) d'un porteur — vue publique, sans secret, récentes d'abord. */
     listForSubject(subjectId: string): Promise<IApiKeyView[]>;
     /**

package/dist/types/nodefony/service/oauth2.d.ts

@@ -71,6 +71,26 @@ export interface IOAuthAuthorization {
  * @throws BootConfigurationError - émetteur requis absent, ou mal formé.
  */
 export declare function checkProviderIssuer(name: string, issuer: string | undefined): void;
+/**
+ * Annonce qu'un annuaire accorde des rôles de PLATEFORME, à la sévérité de
+ * l'environnement — ou `null` quand il n'y a rien à dire.
+ *
+ * L'ouverture est ÉCRITE (`allowPlatformRoles`), donc voulue : l'annonce ne
+ * la conteste pas, elle la rappelle. Le risque — un annuaire compromis
+ * administre l'instance — n'est réel qu'en production : là, `WARNING` ;
+ * ailleurs le même fait est dit en `INFO`, sans sonner une alarme à chaque
+ * démarrage d'un décor de développement.
+ *
+ * @param name - nom du fournisseur (`oauth2.providers.<name>`).
+ * @param allowed - `allowPlatformRoles` tel que déclaré.
+ * @param granted - rôles de l'application que la table accorde.
+ * @param production - l'application tourne en production.
+ * @returns le message et sa sévérité, ou `null`.
+ */
+export declare function platformRolesNotice(name: string, allowed: boolean | undefined, granted: readonly string[], production: boolean): {
+    message: string;
+    severity: "WARNING" | "INFO";
+} | null;
 /**
  * **Social login OAuth 2.0** (P6 J9) — orchestrateur du flux *Authorization Code*.
  *

package/dist/types/nodefony/src/accountBinding.d.ts

@@ -0,0 +1,82 @@
+import type { IUser, IUserProvider } from "@nodefony/user";
+/**
+ * Claim d'un jeton d'accès émis par l'application qui porte l'identifiant
+ * IMMUABLE du compte (`IUser.id`) — `sub` porte l'identifiant fonctionnel.
+ */
+export declare const ACCOUNT_ID_CLAIM = "uid";
+/**
+ * Clé, dans `metadata` d'un enregistrement de jeton (refresh, clé d'API) comme
+ * dans le `metaBag` d'une session, qui porte l'identifiant immuable du compte.
+ */
+export declare const ACCOUNT_ID_KEY = "accountId";
+/**
+ * Claim d'un jeton d'accès émis par l'application qui porte la version des
+ * identifiants du compte à l'émission (`IUser.credentialsVersion`).
+ */
+export declare const CREDENTIALS_VERSION_CLAIM = "cv";
+/**
+ * Clé, dans `metadata` d'un enregistrement de jeton comme dans le `metaBag`
+ * d'une session, qui porte la version des identifiants lue à l'émission.
+ */
+export declare const CREDENTIALS_VERSION_KEY = "credentialsVersion";
+/**
+ * La version des identifiants à inscrire dans un artefact qu'on émet pour ce
+ * compte — 0 quand le compte n'en porte pas encore.
+ *
+ * @param user - compte pour lequel l'artefact est émis.
+ * @returns la version courante, jamais `null`.
+ */
+export declare function credentialsVersionOf(user: IUser): number;
+/**
+ * Dit si un artefact d'accès (jeton, session, clé) appartient bien au compte
+ * qu'on vient de recharger par son identifiant fonctionnel, ET s'il a été émis
+ * depuis le dernier changement de mot de passe.
+ *
+ * Les artefacts sont rangés sous l'`identifier`, qu'un compte RECRÉÉ peut
+ * reprendre : supprimé hors du framework (`DELETE` SQL, restauration, import)
+ * puis revenu sous le même nom, l'identité se rechargerait et l'artefact de
+ * l'ancien titulaire ouvrirait le compte du nouveau. L'identifiant immuable
+ * lève l'ambiguïté sans dépendre d'aucun événement ni d'aucun stockage : deux
+ * comptes successifs portent deux `id` différents. SEULE règle de
+ * comparaison — chaque authentificateur l'appelle, aucun ne la recopie.
+ *
+ * Un artefact SANS liaison est refusé : il a été émis avant que la règle
+ * existe, et rien ne dit à qui il appartient.
+ *
+ * La version des identifiants fait de la coupure au changement de mot de passe
+ * un ÉTAT du compte, et non une suppression : si la cascade de révocation
+ * échoue, ou si une requête en vol sur un autre processus réécrit la session
+ * qu'on vient d'effacer, l'artefact porte toujours l'ancienne version, et il
+ * tombe ici. Un artefact émis avant cette règle n'en porte pas : il vaut 0,
+ * comme un compte qui n'a jamais changé de mot de passe — le déploiement ne
+ * déconnecte personne. Une valeur d'un autre type est refusée.
+ *
+ * ⚠️ Chemin chaud — appelée sur CHAQUE requête authentifiée : deux comparaisons
+ * de chaîne et d'entier, aucune allocation.
+ *
+ * @param user - compte rechargé par l'identifiant que porte l'artefact.
+ * @param boundAccountId - identifiant immuable inscrit dans l'artefact.
+ * @param boundCredentialsVersion - version des identifiants inscrite dans
+ *   l'artefact ({@link CREDENTIALS_VERSION_KEY}), `undefined` si absente.
+ *   Obligatoire dans la signature pour qu'aucune porte ne l'oublie.
+ * @returns `true` si l'artefact a été émis pour CE compte, à sa version courante.
+ */
+export declare function isBoundToAccount(user: IUser, boundAccountId: unknown, boundCredentialsVersion: unknown): boolean;
+/**
+ * Recharge le compte qu'un jeton d'accès de CETTE application désigne, ou
+ * `null` : sujet inconnu, compte inactif ou verrouillé, jeton émis pour un
+ * autre compte du même nom ou avant un changement de mot de passe.
+ *
+ * SEULE implémentation de la règle « ce jeton ouvre-t-il encore ce compte ? »
+ * pour un jeton maison : la zone `jwt` (`JwtAuthenticator`) et le résolveur de
+ * compte d'une ressource protégée l'appellent, aucun ne la recopie. Un refus
+ * est `null`, jamais une exception : chaque appelant le traduit dans son
+ * propre contrat (401 uniforme, outil en `isError`).
+ *
+ * @param provider - annuaire des comptes de l'application.
+ * @param identifier - identifiant fonctionnel porté par le jeton (`sub`).
+ * @param boundAccountId - identifiant immuable inscrit dans le jeton ({@link ACCOUNT_ID_CLAIM}).
+ * @param boundCredentialsVersion - version des identifiants inscrite ({@link CREDENTIALS_VERSION_CLAIM}).
+ * @returns le compte, ou `null` s'il n'est pas (ou plus) celui du jeton.
+ */
+export declare function loadBoundAccount(provider: IUserProvider, identifier: string, boundAccountId: unknown, boundCredentialsVersion: unknown): Promise<IUser | null>;

package/dist/types/nodefony/src/admin/userRevocationCascade.d.ts

@@ -29,6 +29,23 @@ interface KernelListenerLike {
  * @param now - horloge (epoch ms) injectable pour les tests.
  */
 export declare function cascadeUserRevocation(container: Container, event: IUserRevokedEvent, now?: number): Promise<void>;
+/**
+ * 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.
+ */
+export declare function purgeInheritedAccess(container: ServiceLookupLike, identifier: string, now?: number): Promise<void>;
 /**
  * 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 à
@@ -45,11 +62,12 @@ export declare function removeAccountFactors(container: ServiceLookupLike, ident
  * `@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} → purge des facteurs HÉRITÉS : un compte qui
- *    vient de naître n'a encore rien enrôlé, donc tout facteur 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.
+ *  - {@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

package/dist/types/nodefony/src/authenticator/ExternalJwtAuthenticator.d.ts

@@ -3,50 +3,8 @@ import type { ContextType } from "@nodefony/http";
 import type { IAuthenticator } from "../../contracts/IAuthenticator.js";
 import type { ISecuredArea } from "../../contracts/ISecuredArea.js";
 import type { IToken } from "../../contracts/IToken.js";
-import { type ExternalSubjectMapping } from "./externalSubject.js";
-import { type IProviderRoleMapping } from "../oauth/providerRoles.js";
-/** Comment le sujet d'un jeton devient un utilisateur de cette application. */
-export type ExternalSubjectPolicy = "require" | "ephemeral";
-/** Un émetteur reconnu, et la façon dont ses sujets entrent chez nous. */
-export interface IExternalIssuerBinding {
-    /** Émetteur de confiance, sous sa forme canonique. */
-    issuer: string;
-    /** Comment le `sub` de CET émetteur devient un identifiant local. */
-    subjectMapping: ExternalSubjectMapping;
-}
-/** Ce que la fabrique doit fournir à l'authenticator. */
-export interface IExternalJwtAuthenticatorOptions {
-    /**
-     * Émetteurs de confiance, et leur politique de sujet.
-     *
-     * La liste sert à deux choses, qu'il ne faut pas confondre : reconnaître les
-     * jetons qui relèvent de cet authenticator (aiguillage — elle n'accorde
-     * rien, le vérificateur refait le contrôle sur sa propre liste), et savoir
-     * dans quel espace de noms lire le sujet de chacun.
-     */
-    issuers: readonly IExternalIssuerBinding[];
-    /** Politique de rattachement du sujet à un utilisateur local. */
-    subjectPolicy: ExternalSubjectPolicy;
-    /** Rôles accordés en mode `ephemeral`. */
-    ephemeralRoles: readonly string[];
-    /**
-     * Fournisseurs de CONNEXION (`oauth2.providers`) qui déclarent leur émetteur.
-     *
-     * Quand l'émetteur d'un jeton est celui d'un fournisseur de connexion, la
-     * même personne a pu se connecter par le navigateur : son compte local porte
-     * alors le lien `(fournisseur, sub)`. Le chercher d'abord évite qu'un jeton
-     * d'API désigne un AUTRE compte que la session de son porteur.
-     */
-    oauthProviders?: readonly {
-        name: string;
-        issuer: string;
-        /**
-         * Table de correspondance des rôles du fournisseur, compilée — absente ou
-         * `null` : les rôles du compte lié restent locaux.
-         */
-        roleMapping?: IProviderRoleMapping | null;
-    }[];
-}
+import { type IExternalJwtAuthenticatorOptions } from "./ExternalSubjectResolver.js";
+export type { ExternalSubjectPolicy, IExternalIssuerBinding, IExternalJwtAuthenticatorOptions, } from "./ExternalSubjectResolver.js";
 /**
  * Authentification par **jeton d'accès émis par un serveur d'autorisation
  * TIERS** (Keycloak, Auth0, Entra, ou l'émetteur d'une flotte d'agents).