@nodefony/security 10.0.0-alpha.1

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

@@ -0,0 +1,27 @@
+import { decryptSecret, deriveKey, encryptSecret, generateEphemeralKey } from "../crypto/secretCipher.js";
+import { Buffer } from "node:buffer";
+//#region 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}).
+*
+* Le secret de signature (HMAC) doit être **relu** par le serveur à chaque
+* livraison → chiffré (AES-256-GCM), jamais haché. Le contexte HKDF est **propre
+* au domaine webhook** : un blob webhook ne se déchiffre pas avec la clé TOTP, et
+* réciproquement (séparation de domaine cryptographique). Ne pas modifier
+* {@link WEBHOOK_DERIVATION} sous peine de rendre illisibles les secrets stockés.
+*/
+/** Contexte HKDF figé du domaine webhook. **Constantes — ne pas changer.** */
+const WEBHOOK_DERIVATION = {
+	salt: Buffer.from("nodefony.webhook.hkdf.v1"),
+	info: Buffer.from("webhook-secret-encryption")
+};
+/**
+* Dérive la clé AES-256 du domaine webhook via HKDF-SHA256 (RFC 5869).
+* Déterministe (clé lisible cross-pod).
+*/
+function deriveWebhookKey(material) {
+	return deriveKey(material, WEBHOOK_DERIVATION);
+}
+//#endregion
+export { decryptSecret, deriveWebhookKey, encryptSecret, generateEphemeralKey };

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

@@ -0,0 +1,102 @@
+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
+/**
+* Émetteur HTTP d'une livraison webhook — `node:http(s)` natif (0 dép). Trois
+* propriétés de sécurité par rapport à `fetch` :
+*
+* 1. **Pas de suivi de redirection** : `node:http(s)` ne suit JAMAIS les 3xx
+*    (contrairement à `fetch`) → un `302 → 169.254.169.254` ne contourne pas le
+*    contrôle SSRF ; le 3xx est rendu tel quel (échec de config).
+* 2. **Pin de l'IP validée** (anti DNS-rebinding) : `lookup` force la connexion TCP
+*    vers l'IP déjà contrôlée par `assertPublicUrl`, tout en gardant le hostname
+*    pour le SNI/TLS et l'en-tête `Host` → pas de re-résolution entre contrôle et
+*    connexion.
+* 3. **Timeout dur** : la requête est détruite au-delà du délai.
+*/
+/** Taille max du corps de réponse capturé (observabilité, anti-mémoire). */
+const RESPONSE_BODY_CAP = 2048;
+/**
+* POST le corps signé vers l'URL, en pinnant l'IP validée et sans suivre les
+* redirections. Ne lève jamais : tout échec est encodé dans {@link IDeliveryResult}.
+*/
+function deliverWebhook(url, body, headers, opts) {
+	let u;
+	try {
+		u = new URL(url);
+	} catch {
+		return Promise.resolve({
+			ok: false,
+			status: null,
+			error: "URL invalide"
+		});
+	}
+	const isHttps = u.protocol === "https:";
+	if (!isHttps && !(u.protocol === "http:" && opts.allowHttp)) return Promise.resolve({
+		ok: false,
+		status: null,
+		error: `protocole ${u.protocol} non autorisé`
+	});
+	const pinned = opts.addresses && opts.addresses.length > 0 ? opts.addresses[0] : null;
+	const lookup = pinned ? (_hostname, options, callback) => {
+		const family = isIP(pinned) === 6 ? 6 : 4;
+		if (options.all) callback(null, [{
+			address: pinned,
+			family
+		}], family);
+		else callback(null, pinned, family);
+	} : void 0;
+	const payload = Buffer.from(body, "utf8");
+	const requestFn = isHttps ? request : request$1;
+	return new Promise((resolve) => {
+		let settled = false;
+		const done = (r) => {
+			if (!settled) {
+				settled = true;
+				resolve(r);
+			}
+		};
+		const req = requestFn(url, {
+			method: "POST",
+			headers: {
+				...headers,
+				"content-length": String(payload.length)
+			},
+			lookup
+		}, (res) => {
+			const status = res.statusCode ?? 0;
+			const ok = status >= 200 && status < 300;
+			let resBody = "";
+			res.on("data", (c) => {
+				if (resBody.length < RESPONSE_BODY_CAP) {
+					resBody += c.toString("utf8");
+					if (resBody.length > RESPONSE_BODY_CAP) resBody = resBody.slice(0, RESPONSE_BODY_CAP);
+				}
+			});
+			res.on("end", () => done({
+				ok,
+				status,
+				error: ok ? null : `HTTP ${status}`,
+				responseBody: resBody.length > 0 ? resBody : null
+			}));
+			res.on("error", (e) => done({
+				ok: false,
+				status,
+				error: e.message,
+				responseBody: resBody.length > 0 ? resBody : null
+			}));
+		});
+		req.setTimeout(opts.timeoutMs, () => req.destroy(/* @__PURE__ */ new Error("timeout")));
+		req.on("error", (e) => done({
+			ok: false,
+			status: null,
+			error: e.message
+		}));
+		req.write(payload);
+		req.end();
+	});
+}
+//#endregion
+export { deliverWebhook };

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

@@ -0,0 +1,56 @@
+//#region 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`).
+*
+* Frère de `WEBHOOK_SORTABLE_FIELDS`, et posé au même endroit pour la même
+* raison : le vocabulaire appartient au propriétaire du contrat, la mécanique de
+* lecture au cœur (`parseFilters`).
+*
+* `event` reste une chaîne LIBRE, et non une énumération : le catalogue
+* d'événements est celui de l'application qui émet, pas du framework. Le refus
+* porte donc sur la forme (paramètre inconnu, valeur mal formée), jamais sur le
+* nom d'un événement — le refuser reviendrait à décider à la place de l'app ce
+* qu'elle a le droit de publier.
+*/
+const WEBHOOK_FILTERS = {
+	/** `true` = actifs seulement, `false` = désactivés seulement, absent = les deux. */
+	enabled: "boolean",
+	/** Endpoints abonnés à CET événement (« qui écoute `user.created` ? »). */
+	event: "string",
+	/** `true` = en échec (`failureCount > 0`), `false` = sains, absent = les deux. */
+	failing: "boolean"
+};
+/**
+* **Les facettes des endpoints** — les questions fermées que la console pose à
+* la collection ENTIÈRE pour ses cartes de tête.
+*
+* Chacune est un filtre du contrat, et c'est la règle : une carte affiche un
+* nombre que le tableau doit pouvoir montrer. `failing` recoupe volontairement
+* `active` et `disabled` — un endpoint peut être actif ET en échec — d'où
+* l'interdiction de déduire une facette d'une autre par soustraction.
+*/
+const WEBHOOK_FACETS = {
+	/** Tous les endpoints configurés. */
+	total: {},
+	/** Endpoints actifs (le dispatcher leur livre). */
+	active: { enabled: true },
+	/** Endpoints désactivés — à la main ou par coupe-circuit. */
+	disabled: { enabled: false },
+	/** Endpoints en échec, actifs ou non. */
+	failing: { failing: true }
+};
+/**
+* Ce que l'endpoint de COMPTEURS accepte de filtrer — `WEBHOOK_FILTERS` **moins**
+* les champs que les facettes décomposent (`enabled`, `failing`).
+*
+* Les demander ici rendrait une réponse contradictoire : le total suivrait le
+* filtre pendant que chaque facette l'écraserait par le sien. `event` reste,
+* parce qu'il découpe une AUTRE dimension — « combien d'endpoints écoutent
+* `user.created`, et dans quel état sont-ils ? » est une question cohérente.
+*
+* 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

@@ -0,0 +1,51 @@
+import { createHmac } from "node:crypto";
+import { Buffer } from "node:buffer";
+//#region 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,
+* friction consommateur) ou un HMAC maison (GitHub/Stripe). Symétrique HMAC-SHA256
+* par défaut (`v1`) ; slot asymétrique Ed25519 (`v1a`) réservé.
+*
+* Base signée = `{id}.{timestamp}.{body}` → le `webhook-id` et le
+* `webhook-timestamp` sont **couverts** (anti-replay : le consommateur vérifie le
+* timestamp dans une tolérance et déduplique par id). Le consommateur recalcule le
+* HMAC avec le secret partagé et compare en temps constant.
+*/
+const SECRET_PREFIX = "whsec_";
+/**
+* Décode un secret `whsec_<base64>` en octets de clé HMAC. Tolère un secret déjà
+* sans préfixe (base64 brut).
+*/
+function parseWebhookSecret(secret) {
+	const b64 = secret.startsWith(SECRET_PREFIX) ? secret.slice(6) : secret;
+	return Buffer.from(b64, "base64");
+}
+/** Construit la base à signer : `{id}.{timestamp}.{body}` (Standard Webhooks). */
+function buildSignatureBase(id, timestampS, body) {
+	return `${id}.${timestampS}.${body}`;
+}
+/**
+* Signe un message webhook (Standard Webhooks `v1`). Retourne la valeur du header
+* `webhook-signature` : `v1,<base64(HMAC-SHA256(secret, base))>`.
+*
+* @param secret - secret `whsec_…` de l'endpoint (en clair).
+* @param id - identifiant du message (`webhook-id`).
+* @param timestampS - horodatage epoch **secondes** (`webhook-timestamp`).
+* @param body - corps JSON sérialisé envoyé.
+*/
+function signStandardWebhook(secret, id, timestampS, body) {
+	const key = parseWebhookSecret(secret);
+	const base = buildSignatureBase(id, timestampS, body);
+	return `v1,${createHmac("sha256", key).update(base).digest("base64")}`;
+}
+/** En-têtes de signature Standard Webhooks à poser sur la requête sortante. */
+function webhookSignatureHeaders(secret, id, timestampS, body) {
+	return {
+		"webhook-id": id,
+		"webhook-timestamp": String(timestampS),
+		"webhook-signature": signStandardWebhook(secret, id, timestampS, body)
+	};
+}
+//#endregion
+export { buildSignatureBase, parseWebhookSecret, signStandardWebhook, webhookSignatureHeaders };

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

@@ -0,0 +1,48 @@
+//#region 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
+* colonne.
+*
+* Il vit ici, chez le propriétaire du contrat (`@nodefony/security`), et non dans
+* chaque backend : c'est ce qui garantit qu'une console offre le même tri, que
+* l'application tourne sur mémoire, SQL ou Mongo. Un store dont le schéma nomme
+* un champ autrement traduit **chez lui** — cf {@link translateWebhookOrderMongo}.
+*
+* - `createdAt` / `updatedAt` — quand l'abonnement a été posé, quand il a bougé ;
+* - `url` — la destination, colonne principale de la console ;
+* - `enabled` — regroupe les abonnements coupés ;
+* - `failureCount` — « qui échoue le plus », l'axe d'exploitation d'un webhook ;
+* - `id` — utile surtout en départage.
+*
+* **Ce qui n'y est PAS, et pourquoi** : `lastDeliveryAt`, `lastDeliveryStatus` et
+* `lastDeliveryError` sont *nullables* — un endpoint qui n'a jamais livré n'a pas
+* de dernière livraison — et le placement des valeurs absentes n'est pas le même
+* d'un moteur à l'autre (PostgreSQL les met en tête d'un tri `DESC`, SQLite,
+* MySQL et le tri en mémoire en queue). Les déclarer offrirait un tri dont
+* l'ordre dépendrait de la base configurée.
+*
+* ⚠️ Cette liste est aussi une **garde de sécurité**, pas seulement une capacité :
+* un nom de champ ne se lie pas en paramètre SQL, il se **concatène** dans le
+* `ORDER BY`. Tout backend qui construit sa requête à la main filtre donc avec
+* elle, en défense en profondeur — sans compter sur le fait que le data plane
+* ait déjà refusé.
+*/
+const WEBHOOK_SORTABLE_FIELDS = [
+	"createdAt",
+	"updatedAt",
+	"url",
+	"enabled",
+	"failureCount",
+	"id"
+];
+/**
+* Ordre contractuel appliqué quand le client n'en demande aucun : les
+* abonnements les plus récents d'abord, départagés par identifiant pour rester
+* **déterministe** à horodatage égal — sans ce tiebreaker, deux endpoints créés
+* dans la même milliseconde peuvent changer de page entre deux appels, et l'un
+* 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

@@ -0,0 +1,18 @@
+import { MemoryWebhookStore } from "./MemoryWebhookStore.js";
+//#region 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) {
+	factories.set(name, factory);
+}
+/** Fabrique d'un store par nom, ou `undefined` si inconnu. */
+function getWebhookStoreFactory(name) {
+	return factories.get(name);
+}
+/** Noms enregistrés (validation boot, introspection Studio, tests). */
+function listWebhookStores() {
+	return [...factories.keys()];
+}
+registerWebhookStore("memory", () => new MemoryWebhookStore());
+//#endregion
+export { getWebhookStoreFactory, listWebhookStores, registerWebhookStore };

package/dist/types/index.d.ts

@@ -0,0 +1,157 @@
+import { Kernel, Module } from "nodefony";
+import Firewall from "./nodefony/service/firewall.js";
+import AuthFlow from "./nodefony/service/authFlow.js";
+import TokenService from "./nodefony/service/tokenService.js";
+import AccessTokenVerifierService from "./nodefony/service/accessTokenVerifier.js";
+import Authorization from "./nodefony/service/authorization.js";
+import WebAuthnService from "./nodefony/service/webAuthn.js";
+import OAuth2Service from "./nodefony/service/oauth2.js";
+import ApiKeyService from "./nodefony/service/apiKeys.js";
+import AuditService from "./nodefony/service/auditService.js";
+import TotpService from "./nodefony/service/totp.js";
+import WebhookService from "./nodefony/service/webhooks.js";
+import type { ISecurityConfigInput } from "./nodefony/config/defineModuleConfig.js";
+declare module "nodefony" {
+    interface NodefonyModuleConfig {
+        "@nodefony/security": ISecurityConfigInput;
+    }
+}
+/**
+ * `@nodefony/security` — couche de sécurité de Nodefony (refonte 2026, P6).
+ *
+ * Identité **hybride** : session serveur cookie opaque (BFF) par défaut web/Studio,
+ * JWT réservé API/M2M/agents. Pattern **`IAuthenticator`** + registre de fabriques
+ * (pluggable), **Zero Trust** par défaut, config type-safe `defineSecurityConfig()`
+ * + Zod validée au boot (fail-closed si invalide). Consomme `@nodefony/user`
+ * (IUser/IUserProvider/IPasswordVerifier) — jamais l'inverse.
+ *
+ * Livré : firewall (zones, mode first|all, challenge RFC 7235), authenticators
+ * `anonymous`/`userpassword` (Basic RFC 7617)/`session` (BFF, J3), flux
+ * login/logout/me (`AuthFlow`, anti-fixation + throttling partagé).
+ * Jwt/oauth2/mtls/apikey, CORS, CSRF, autorisation par décorateurs et data
+ * plane Studio arrivent aux sessions suivantes (plan J0→J10).
+ */
+declare class Security extends Module {
+    constructor(kernel: Kernel);
+    /**
+     * JSON Schema de la config security → data plane admin (config riche Studio).
+     * ⚠️ Les VALEURS effectives des secrets (csrf/jwt/oauth) sont redactées côté
+     * serveur (`safeConfig`) AVANT envoi — le schéma ne décrit que la structure.
+     */
+    configSchema(): unknown;
+    /**
+     * Enregistre les data planes admin **sécurité** (`/nodefony/security/api/*`,
+     * P6.14) ET **utilisateur** (`/nodefony/user/api/*`, P6.15) auprès du broker
+     * AVANT que framework ne monte les routes (`onReady`). Le data plane user est
+     * DÉFINI dans `@nodefony/user` (propriétaire du domaine) mais monté ici, car
+     * `@nodefony/user` est une lib pure non-bootable et `security` en dépend déjà.
+     * No-op si le broker est absent (Studio non chargé) ou déjà enregistré.
+     */
+    onKernelBoot(): Promise<this>;
+}
+export default Security;
+export { Firewall };
+export { AuthFlow };
+export { TokenService };
+export { AccessTokenVerifierService };
+export { RemoteJwtVerifier } from "./nodefony/src/token/RemoteJwtVerifier.js";
+export type { ITrustedIssuer, IRemoteJwtVerifierOptions, } from "./nodefony/src/token/RemoteJwtVerifier.js";
+export { ApiKeyService };
+export { Authorization };
+export { WebAuthnService };
+export { OAuth2Service };
+export { AuditService };
+export { TotpService };
+export { WebhookService };
+export type { IWebhookRegisterInput, IWebhookSecretReveal, IWebhookDeliveryPolicy, } from "./nodefony/service/webhooks.js";
+export type { ISafeUser, ILoginOutcome } from "./nodefony/service/authFlow.js";
+export type { ITokenResponse } from "./nodefony/service/tokenService.js";
+export type { IApiKeyView, IApiKeyCreated, IApiKeyCapabilities, ICreateApiKeyOptions, } from "./nodefony/contracts/IApiKey.js";
+export { ApiKeyError } from "./nodefony/errors/ApiKeyError.js";
+export { SecuredArea } from "./nodefony/src/SecuredArea.js";
+export { Csrf } from "./nodefony/service/csrf.js";
+export { CsrfTokenManager } from "./nodefony/src/csrfToken.js";
+export { Cors } from "./nodefony/service/cors.js";
+export { SecurityHeaders } from "./nodefony/service/securityHeaders.js";
+export { RoleHierarchyWalker } from "./nodefony/src/RoleHierarchyWalker.js";
+export { AnonymousToken } from "./nodefony/src/token/AnonymousToken.js";
+export { UserToken } from "./nodefony/src/token/UserToken.js";
+export { RoleVoter } from "./nodefony/src/voter/RoleVoter.js";
+export { ScopeVoter } from "./nodefony/src/voter/ScopeVoter.js";
+export { registerVoterFactory, listVoterFactories, } from "./nodefony/src/voter/voterRegistry.js";
+export type { VoterFactory, IVoterFactoryContext, } from "./nodefony/src/voter/voterRegistry.js";
+export { AnonymousAuthenticator } from "./nodefony/src/authenticator/AnonymousAuthenticator.js";
+export { UserPasswordAuthenticator } from "./nodefony/src/authenticator/UserPasswordAuthenticator.js";
+export { SessionAuthenticator } from "./nodefony/src/authenticator/SessionAuthenticator.js";
+export { JwtAuthenticator } from "./nodefony/src/authenticator/JwtAuthenticator.js";
+export { ApiKeyAuthenticator } from "./nodefony/src/authenticator/ApiKeyAuthenticator.js";
+export type { IApiKeyAuthenticatorRuntime } from "./nodefony/src/authenticator/ApiKeyAuthenticator.js";
+export { ExternalJwtAuthenticator } from "./nodefony/src/authenticator/ExternalJwtAuthenticator.js";
+export type { ExternalSubjectPolicy, IExternalJwtAuthenticatorOptions, } from "./nodefony/src/authenticator/ExternalJwtAuthenticator.js";
+export { peekIssuer } from "./nodefony/src/authenticator/peekIssuer.js";
+export { generateApiKey, parseApiKey, hashApiKey, looksLikeApiKey, } from "./nodefony/src/apikey/apiKeyFormat.js";
+export type { IGeneratedApiKey, IParsedApiKey, } from "./nodefony/src/apikey/apiKeyFormat.js";
+export { registerAuthenticatorFactory, getAuthenticatorFactory, listAuthenticatorFactories, } from "./nodefony/src/authenticator/authenticatorRegistry.js";
+export type { AuthenticatorFactory, IAuthenticatorFactoryContext, } from "./nodefony/src/authenticator/authenticatorRegistry.js";
+export { MemoryTokenStore } from "./nodefony/src/token/MemoryTokenStore.js";
+export type { TokenStoreSnapshot } from "./nodefony/src/token/MemoryTokenStore.js";
+export { TOKEN_SORTABLE_FIELDS, TOKEN_DEFAULT_ORDER, } from "./nodefony/src/token/tokenSort.js";
+export { tokenStatusCriteria } from "./nodefony/src/token/tokenCriteria.js";
+export { tokenStatusOf, matchesTokenStatus, } from "./nodefony/src/token/tokenStatus.js";
+export type { ITokenLifetime } from "./nodefony/src/token/tokenStatus.js";
+export { TOKEN_FACETS } from "./nodefony/src/token/tokenFilters.js";
+export type { ITokenCounts } from "./nodefony/src/token/tokenFilters.js";
+export { JwtKeystore } from "./nodefony/src/token/JwtKeystore.js";
+export { resolveJwtRuntime } from "./nodefony/src/token/jwtRuntime.js";
+export type { IJwtRuntime } from "./nodefony/src/token/jwtRuntime.js";
+export { registerTokenStore, getTokenStoreFactory, listTokenStores, } from "./nodefony/src/token/tokenStoreRegistry.js";
+export type { TokenStoreFactory, ITokenStoreFactoryContext, } from "./nodefony/src/token/tokenStoreRegistry.js";
+export { MemoryWebAuthnCredentialStore } from "./nodefony/src/webauthn/MemoryWebAuthnCredentialStore.js";
+export type { WebAuthnStoreSnapshot } from "./nodefony/src/webauthn/MemoryWebAuthnCredentialStore.js";
+export { registerWebAuthnStore, getWebAuthnStoreFactory, listWebAuthnStores, } from "./nodefony/src/webauthn/webAuthnCredentialStoreRegistry.js";
+export type { WebAuthnStoreFactory, IWebAuthnStoreFactoryContext, } from "./nodefony/src/webauthn/webAuthnCredentialStoreRegistry.js";
+export type { IWebAuthnUser, IWebAuthnAssertionResult, } from "./nodefony/service/webAuthn.js";
+export type { IWebAuthnCredential } from "./nodefony/contracts/IWebAuthnCredential.js";
+export type { IWebAuthnCredentialStore, IWebAuthnCredentialSummary, IWebAuthnListQuery, WebAuthnAuthUpdate, } from "./nodefony/contracts/IWebAuthnCredentialStore.js";
+export type { IOAuthAuthorization } from "./nodefony/service/oauth2.js";
+export type { IOAuthProvider } from "./nodefony/contracts/IOAuthProvider.js";
+export { registerOAuthProvider, getOAuthProviderFactory, listOAuthProviders, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
+export type { OAuthProviderFactory, IOAuthProviderContext, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
+export { MemoryAuditStore } from "./nodefony/src/audit/MemoryAuditStore.js";
+export type { AuditStoreSnapshot } from "./nodefony/src/audit/MemoryAuditStore.js";
+export type { IAuditEvent, IAuditEventDraft, IAuditEventFlags, AuditCategory, AuditOutcome, } from "./nodefony/contracts/IAuditEvent.js";
+export type { IAuditStore, IAuditSink, IAuditListQuery, } from "./nodefony/contracts/IAuditStore.js";
+export { registerAuditStore, getAuditStoreFactory, listAuditStores, } from "./nodefony/src/audit/auditStoreRegistry.js";
+export type { AuditStoreFactory, IAuditStoreFactoryContext, } from "./nodefony/src/audit/auditStoreRegistry.js";
+export { recordAudit } from "./nodefony/src/audit/recordAudit.js";
+export { readAuditContext } from "./nodefony/src/audit/readAuditContext.js";
+export type { AuditContextInfo } from "./nodefony/src/audit/readAuditContext.js";
+export { createSecurityAdminApi, registerSecurityAdminApi, parseAuditQuery, } from "./nodefony/src/admin/SecurityAdminApi.js";
+export { MemoryTotpSecretStore } from "./nodefony/src/totp/MemoryTotpSecretStore.js";
+export type { TotpStoreSnapshot } from "./nodefony/src/totp/MemoryTotpSecretStore.js";
+export { registerTotpStore, getTotpStoreFactory, listTotpStores, } from "./nodefony/src/totp/totpSecretStoreRegistry.js";
+export type { TotpStoreFactory, ITotpStoreFactoryContext, } from "./nodefony/src/totp/totpSecretStoreRegistry.js";
+export type { ITotpSecret } from "./nodefony/contracts/ITotpSecret.js";
+export type { ITotpSecretStore, ITotpEnrollmentSummary, ITotpListQuery, TotpSecretUpdate, } from "./nodefony/contracts/ITotpSecretStore.js";
+export type { ITotpEnrollment, ITotpActivation, ITotpStatus, ITotpLoginResult, } from "./nodefony/src/totp/totpOperations.js";
+export { beginTotpEnrollment, confirmTotpEnrollment, verifyTotpLogin, disableTotp, totpStatus, } from "./nodefony/src/totp/totpOperations.js";
+export type { ITotpDeps } from "./nodefony/src/totp/totpOperations.js";
+export { totpCode, base32Decode } from "./nodefony/src/totp/totpCrypto.js";
+export { deriveTotpKey } from "./nodefony/src/totp/totpCipher.js";
+export { MemoryWebhookStore } from "./nodefony/src/webhook/MemoryWebhookStore.js";
+export { WEBHOOK_SORTABLE_FIELDS, WEBHOOK_DEFAULT_ORDER, } from "./nodefony/src/webhook/webhookSort.js";
+export { registerWebhookStore, getWebhookStoreFactory, listWebhookStores, } from "./nodefony/src/webhook/webhookStoreRegistry.js";
+export type { WebhookStoreFactory, IWebhookStoreFactoryContext, } from "./nodefony/src/webhook/webhookStoreRegistry.js";
+export type { IWebhookEndpoint, WebhookEndpointUpdate, WebhookEndpointSummary, } from "./nodefony/contracts/IWebhookEndpoint.js";
+export type { IWebhookListQuery, IWebhookStore, } from "./nodefony/contracts/IWebhookStore.js";
+export { assertPublicUrl, isBlockedAddress, } from "./nodefony/src/net/ssrfGuard.js";
+export type { IAssertPublicUrlOptions, IPublicUrlResult, DnsResolver, } from "./nodefony/src/net/ssrfGuard.js";
+export { deriveKey, encryptSecret, decryptSecret, generateEphemeralKey, } from "./nodefony/src/crypto/secretCipher.js";
+export type { IKeyDerivation } from "./nodefony/src/crypto/secretCipher.js";
+export { defineSecurityConfig, securityConfigJsonSchema, } from "./nodefony/config/defineModuleConfig.js";
+export type { ISecurityConfig, ISecurityConfigInput, ISecurityAreaConfig, } from "./nodefony/config/defineModuleConfig.js";
+export { LoginThrottler } from "./nodefony/src/throttle/LoginThrottler.js";
+export type { ILoginThrottleOptions } from "./nodefony/src/throttle/LoginThrottler.js";
+export { AuthenticationError, AccessDeniedError, ThrottledError, UnverifiableTokenError, InvalidTargetError, CsrfError, SsrfError, } from "./nodefony/errors/index.js";
+export { VoterVote } from "./nodefony/contracts/index.js";
+export type { IToken, IAuthenticator, ISecuredArea, IFirewall, IAccessVoter, IAuthorizationService, IAccessTokenRecord, ITokenStore, ITokenListQuery, ITokenUsage, IResourcePermission, TokenRevokeReason, TokenStatus, IJwtKeystore, IJwtSigningKey, } from "./nodefony/contracts/index.js";

package/dist/types/nodefony/command/security-secrets.d.ts

@@ -0,0 +1,24 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * `nodefony security:secrets` — génère les clés de chiffrement attendues par le
+ * module security (TOTP, webhooks, CSRF) au bon format (32 octets aléatoires,
+ * base64) et guide le câblage en 3 FICHIERS (.env → env.ts → nodefony.config.ts).
+ * Réponse directe aux warnings « clé ÉPHÉMÈRE générée » du boot.
+ *
+ * DX anti-confusion (vécu : blocs collés dans le shell → parse error zsh) :
+ * - chaque étape nomme son FICHIER et rappelle que rien ne se tape au terminal ;
+ * - les étapes déjà faites sont DÉTECTÉES (grep des fichiers du projet) et
+ *   affichées `✓` au lieu de redemander un collage ;
+ * - `--write` écrit le `.env` (fichier local gitignoré) : ajoute uniquement les
+ *   clés ABSENTES, ne remplace jamais une valeur existante (rotation = manuelle).
+ * `env.ts` et `nodefony.config.ts` ne sont JAMAIS modifiés (code de l'app).
+ */
+declare class SecuritySecrets extends Command {
+    #private;
+    constructor(cli: CliKernel);
+    generate(opts: {
+        json?: boolean;
+        write?: boolean;
+    }): Promise<this>;
+}
+export default SecuritySecrets;

package/dist/types/nodefony/command/security-token.d.ts

@@ -0,0 +1,44 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * Traduit `--ttl` en secondes, ou rend l'erreur à afficher.
+ *
+ * Exportée pour être ÉPROUVÉE : c'est une fonction pure dont chaque verdict est
+ * binaire, et dont l'échec — une durée acceptée alors qu'elle est aberrante —
+ * ne se verrait qu'au moment où un jeton refuse de mourir.
+ *
+ * @param raw - la valeur telle que tapée, ou rien
+ * @returns les secondes, `undefined` si rien n'est demandé, une `Error` sinon
+ */
+export declare function ttlSeconds(raw: string | undefined): number | undefined | Error;
+/**
+ * `nodefony security: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
+ * au grant : trouver l'URL, composer un JSON, y mettre un mot de passe en clair
+ * dans l'historique du shell, et surtout AVOIR un serveur en marche. Personne ne
+ * fait ça deux fois. Ici l'application SIGNE elle-même — elle possède la clé —
+ * donc : pas de serveur, pas de mot de passe, pas de réseau.
+ *
+ * **L'audience est celle de la porte, et ce n'est pas un détail** (RFC 8707) :
+ * un jeton d'audience différente est refusé, à juste titre — c'est toute la
+ * 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.
+ */
+declare class SecurityToken extends Command {
+    #private;
+    constructor(cli: CliKernel);
+    generate(identifierArg: string | undefined, opts: {
+        scope?: string;
+        ttl?: string;
+        agent?: string;
+        resource?: string;
+        write?: boolean;
+        json?: boolean;
+    }): Promise<this>;
+}
+export default SecurityToken;

package/dist/types/nodefony/command/security-user-add.d.ts

@@ -0,0 +1,28 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * `nodefony security:user:add [identifier]` — crée un compte utilisateur via le
+ * service applicatif `users` (hash Argon2id fait par `UserService.createUser`,
+ * jamais de mot de passe stocké en clair).
+ *
+ * Identifiant : en argument, ou DEMANDÉ quand un terminal est là — la commande
+ * est proposée au menu, où personne ne peut taper d'argument. Hors terminal
+ * (CI, script), l'absence reste une erreur, avec la ligne exacte à taper.
+ *
+ * Mot de passe : `--password` (visible dans l'historique shell — accepté pour
+ * les scripts) ou PROMPT MASQUÉ en TTY (recommandé). Rôles : `--roles a,b,c`
+ * (CSV) ou `--admin` (raccourci `ROLE_ADMIN + ROLE_NODEFONY_ADMIN` → accès
+ * console Studio). Défaut : `ROLE_USER`.
+ *
+ * Le service `users` est posé par l'APPLICATION (cf `provisionUsers` du
+ * template d'app) — absent = message actionnable, pas de stack.
+ */
+declare class SecurityUserAdd extends Command {
+    #private;
+    constructor(cli: CliKernel);
+    generate(identifierArg: string | undefined, opts: {
+        password?: string;
+        roles?: string;
+        admin?: boolean;
+    }): Promise<this>;
+}
+export default SecurityUserAdd;

package/dist/types/nodefony/command/security-user-delete.d.ts

@@ -0,0 +1,25 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * `nodefony security:user:delete <identifiant>` — retire un compte.
+ *
+ * **Un geste destructeur ne se fait pas sur une frappe.** La commande MONTRE ce
+ * qu'elle va supprimer (identifiant, rôles, identifiant interne), puis demande
+ * une confirmation. Hors terminal, elle exige `--yes` : un script qui supprime
+ * doit le dire dans sa ligne, jamais l'obtenir d'un prompt sauté.
+ *
+ * **Garde-fou anti-lockout** : le DERNIER administrateur actif ne se supprime
+ * pas. Sans lui, plus personne n'accède à la console d'administration, et le
+ * seul recours est une écriture directe en base. Le même garde-fou existe côté
+ * data plane (`UserAdminApi`) — ici il est constaté, pas supposé.
+ *
+ * La révocation des sessions et jetons du compte suit d'elle-même : la
+ * suppression émet `onUserRevoked`, auquel `@nodefony/security` réagit en
+ * éjectant sessions et jetons. Rien à faire de plus ici.
+ */
+declare class SecurityUserDelete extends Command {
+    constructor(cli: CliKernel);
+    generate(identifierArg: string | undefined, opts: {
+        yes?: boolean;
+    }): Promise<this>;
+}
+export default SecurityUserDelete;

package/dist/types/nodefony/command/security-user-list.d.ts

@@ -0,0 +1,28 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * `nodefony security:user:list` — qui a un compte dans cette application.
+ *
+ * **Lister n'est pas une fuite, et c'était la question.** Cette commande
+ * s'exécute sur la machine qui possède déjà la base : elle ne divulgue rien que
+ * son utilisateur ne puisse lire avec un client SQL. Ce qui serait dangereux est
+ * ailleurs, et gardé ici : **jamais le hachage du mot de passe**, jamais les
+ * secrets de second facteur, jamais les jetons d'un fournisseur social. La
+ * sortie est composée champ par champ — un `console.table(user)` livrerait le
+ * credential, parce que le repository, lui, le voit.
+ *
+ * Le contraire — ne pas pouvoir lister — a un coût réel : on crée un compte, on
+ * ne voit pas ce qu'on a créé, et on recommence en doublon.
+ *
+ * La pagination est NATIVE (`users.listPage`) : jamais un `find()` complet
+ * ramené en mémoire, indolore sur trois comptes et fatal sur cent mille.
+ */
+declare class SecurityUserList extends Command {
+    constructor(cli: CliKernel);
+    generate(opts: {
+        query?: string;
+        role?: string;
+        limit?: string;
+        json?: boolean;
+    }): Promise<this>;
+}
+export default SecurityUserList;