@nodefony/security 10.0.0-alpha.1

package/dist/nodefony/src/totp/totpOperations.js

@@ -0,0 +1,129 @@
+import { decryptSecret, encryptSecret } from "../crypto/secretCipher.js";
+import "./totpCipher.js";
+import { base32Encode, buildOtpauthUri, generateRecoveryCodes, generateTotpSecret, hashRecoveryCode, matchRecoveryCode, verifyTotp } from "./totpCrypto.js";
+//#region nodefony/src/totp/totpOperations.ts
+/**
+* Démarre l'enrôlement : génère un secret aléatoire, le **chiffre** au repos et
+* l'enregistre en attente de confirmation (`confirmedAt: null`). Retourne le
+* secret en clair (base32 + URI) — **seul moment** où il est exposé. Idempotent :
+* un nouvel appel écrase un enrôlement non confirmé (re-scan du QR).
+*/
+async function beginTotpEnrollment(deps, userId, account) {
+	const secret = generateTotpSecret();
+	const secretBase32 = base32Encode(secret);
+	const now = deps.now();
+	const record = {
+		userId,
+		secretEnc: encryptSecret(secret, deps.key),
+		algorithm: deps.algorithm,
+		digits: deps.digits,
+		period: deps.period,
+		recoveryCodes: [],
+		confirmedAt: null,
+		lastUsedStep: null,
+		createdAt: now,
+		lastUsedAt: null
+	};
+	await deps.store.save(record);
+	return {
+		secretBase32,
+		otpauthUri: buildOtpauthUri({
+			issuer: deps.issuer,
+			account,
+			secretBase32,
+			algorithm: deps.algorithm,
+			digits: deps.digits,
+			period: deps.period
+		})
+	};
+}
+/**
+* Confirme l'enrôlement : vérifie un 1ᵉʳ code généré par l'app, **active** le 2FA
+* et génère les codes de récupération (retournés clairs 1×, hachés au repos). Le
+* step de confirmation est marqué consommé (anti-rejeu). Lève si aucun enrôlement
+* n'est en cours, s'il est déjà confirmé, ou si le code est invalide (reste pending).
+*/
+async function confirmTotpEnrollment(deps, userId, code) {
+	const record = await deps.store.findByUser(userId);
+	if (!record) throw new Error("totp: aucun enrôlement en cours");
+	if (record.confirmedAt !== null) throw new Error("totp: 2FA déjà activé");
+	const secret = decryptSecret(record.secretEnc, deps.key);
+	const res = verifyTotp(code, secret, {
+		epochMs: deps.now(),
+		step: deps.period,
+		digits: deps.digits,
+		algorithm: deps.algorithm,
+		window: deps.window
+	});
+	if (!res.valid) throw new Error("totp: code de confirmation invalide");
+	const recoveryCodes = generateRecoveryCodes(deps.recoveryCodesCount);
+	const now = deps.now();
+	await deps.store.update(userId, {
+		confirmedAt: now,
+		recoveryCodes: recoveryCodes.map(hashRecoveryCode),
+		lastUsedStep: res.step,
+		lastUsedAt: now
+	});
+	return { recoveryCodes };
+}
+/**
+* Vérifie un second facteur au login : d'abord un code TOTP (fenêtre ±window,
+* **anti-rejeu** via `lastUsedStep`), à défaut un code de récupération (consommé,
+* usage unique). Retourne `ok: false` si le 2FA n'est pas activé ou si rien ne
+* correspond — **jamais d'exception** (chemin d'authentification).
+*/
+async function verifyTotpLogin(deps, userId, code) {
+	const record = await deps.store.findByUser(userId);
+	if (!record || record.confirmedAt === null) return { ok: false };
+	const secret = decryptSecret(record.secretEnc, deps.key);
+	const res = verifyTotp(code, secret, {
+		epochMs: deps.now(),
+		step: deps.period,
+		digits: deps.digits,
+		algorithm: deps.algorithm,
+		window: deps.window
+	});
+	if (res.valid && res.step !== void 0) {
+		if (record.lastUsedStep !== null && res.step <= record.lastUsedStep) return { ok: false };
+		await deps.store.update(userId, {
+			lastUsedStep: res.step,
+			lastUsedAt: deps.now()
+		});
+		return {
+			ok: true,
+			method: "totp"
+		};
+	}
+	const idx = matchRecoveryCode(code, record.recoveryCodes);
+	if (idx >= 0) {
+		await deps.store.update(userId, {
+			recoveryCodes: record.recoveryCodes.filter((_, i) => i !== idx),
+			lastUsedAt: deps.now()
+		});
+		return {
+			ok: true,
+			method: "recovery"
+		};
+	}
+	return { ok: false };
+}
+/** Désactive le 2FA (retire le secret et les codes de récupération). */
+function disableTotp(deps, userId) {
+	return deps.store.delete(userId);
+}
+/** État 2FA d'un utilisateur (absent / pending / activé + codes restants). */
+async function totpStatus(deps, userId) {
+	const record = await deps.store.findByUser(userId);
+	if (!record) return {
+		enabled: false,
+		pending: false,
+		recoveryCodesRemaining: 0
+	};
+	return {
+		enabled: record.confirmedAt !== null,
+		pending: record.confirmedAt === null,
+		recoveryCodesRemaining: record.recoveryCodes.length
+	};
+}
+//#endregion
+export { beginTotpEnrollment, confirmTotpEnrollment, disableTotp, totpStatus, verifyTotpLogin };

package/dist/nodefony/src/totp/totpSecretStoreRegistry.js

@@ -0,0 +1,18 @@
+import { MemoryTotpSecretStore } from "./MemoryTotpSecretStore.js";
+//#region nodefony/src/totp/totpSecretStoreRegistry.ts
+const factories = /* @__PURE__ */ new Map();
+/** Enregistre (ou remplace) la fabrique d'un store de secrets TOTP. */
+function registerTotpStore(name, factory) {
+	factories.set(name, factory);
+}
+/** Fabrique d'un store par nom, ou `undefined` si inconnu. */
+function getTotpStoreFactory(name) {
+	return factories.get(name);
+}
+/** Noms enregistrés (validation boot, introspection Studio, tests). */
+function listTotpStores() {
+	return [...factories.keys()];
+}
+registerTotpStore("memory", () => new MemoryTotpSecretStore());
+//#endregion
+export { getTotpStoreFactory, listTotpStores, registerTotpStore };

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

@@ -0,0 +1,32 @@
+import { RoleHierarchyWalker } from "../RoleHierarchyWalker.js";
+import "../../contracts/IAccessVoter.js";
+//#region nodefony/src/voter/RoleVoter.ts
+/**
+* Voter built-in **niveau A** — résout les attributs `ROLE_*` via la hiérarchie
+* de rôles ({@link RoleHierarchyWalker}).
+*
+* Vote `GRANT` si l'utilisateur possède le rôle (hiérarchie résolue : `ROLE_ADMIN`
+* hérite `ROLE_USER`), **`ABSTAIN` sinon** — jamais `DENY` : l'absence d'un rôle
+* ne doit pas opposer son veto aux autres axes (scope, ownership). C'est le
+* `default DENY` de l'`AuthorizationService` (tous ABSTAIN → refus) qui ferme la
+* porte, pas ce voter.
+*
+* Lit la hiérarchie depuis le container (`roleHierarchy`, posée par le firewall
+* au boot) en lazy — un walker vide gère quand même les rôles plats.
+*/
+var RoleVoter = class {
+	container;
+	#walker = null;
+	constructor(container) {
+		this.container = container;
+	}
+	supports(attribute) {
+		return attribute.startsWith("ROLE_");
+	}
+	vote(token, attribute) {
+		const vote = (this.#walker ??= this.container.get("roleHierarchy") ?? new RoleHierarchyWalker()).hasRole(token.getRoles(), attribute) ? "GRANT" : "ABSTAIN";
+		return Promise.resolve(vote);
+	}
+};
+//#endregion
+export { RoleVoter, RoleVoter as default };

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

@@ -0,0 +1,52 @@
+import "../../contracts/IAccessVoter.js";
+//#region 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`
+* ne bride JAMAIS un humain : il **downscope** un jeton MACHINE délégué (clé API,
+* JWT d'agent, OAuth). Tout type ABSENT de cette liste — présent (`apikey`/`jwt`/
+* `oauth2`) ou futur (`mtls`, `agent`…) — est considéré **scopable**, donc soumis
+* au filtre : **fail-closed côté machine** (un nouveau type délégué est bridé par
+* défaut, jamais ouvert par oubli).
+*
+* `type` est porté à l'identique par `IToken` (HTTP) ET `IRealtimeToken` (WS, pont
+* `api.request`) → ce voter reste transport-agnostique sans rien ajouter au contrat.
+*/
+const NON_SCOPABLE_TOKEN_TYPES = /* @__PURE__ */ new Set([
+	"session",
+	"userpassword",
+	"anonymous"
+]);
+/**
+* Voter built-in **axe SCOPE** (P6.8) — applique les scopes `api:action` déclarés
+* par `@RequireScope`. Frère du {@link RoleVoter} sur l'autre axe : les rôles
+* disent QUI tu es, les scopes disent ce qu'une CLÉ déléguée a le droit de faire.
+*
+* `supports()` ne capte QUE la forme conventionnée `api:action` (un `:`, jamais
+* `ROLE_*`) → aucune collision avec le `RoleVoter` ni un voter métier (`doc.edit`).
+*
+* Vote :
+*  - **jeton non scopable** (humain/anonyme) → `GRANT` : le scope est un no-op,
+*    l'autorisation de l'humain est portée par ses rôles (`@IsGranted`), pas par
+*    un downscoping de clé ;
+*  - **jeton scopable** (clé API / JWT / OAuth) → `GRANT` si le scope exact est
+*    présent, sinon **`ABSTAIN`** (jamais `DENY` : l'absence d'un scope ne doit pas
+*    opposer un veto aux autres attributs OR d'une clause — c'est le default-DENY
+*    de l'`AuthorizationService`, tous ABSTAIN → refus, qui ferme la porte ;
+*    posture identique au `RoleVoter`).
+*
+* Pur : aucune dépendance (ni container, ni I/O) — il ne lit que le jeton déjà
+* résolu au handshake/à l'authentification. Instancié UNE fois au boot.
+*/
+var ScopeVoter = class {
+	/** Capte les attributs scope `api:action` — ni `ROLE_*`, ni attribut métier sans `:`. */
+	supports(attribute) {
+		return attribute.includes(":") && !attribute.startsWith("ROLE_");
+	}
+	vote(token, attribute) {
+		if (NON_SCOPABLE_TOKEN_TYPES.has(token.type)) return Promise.resolve("GRANT");
+		return Promise.resolve(token.getScopes().includes(attribute) ? "GRANT" : "ABSTAIN");
+	}
+};
+//#endregion
+export { ScopeVoter, ScopeVoter as default };

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

@@ -0,0 +1,20 @@
+import { RoleVoter } from "./RoleVoter.js";
+import { ScopeVoter } from "./ScopeVoter.js";
+//#region nodefony/src/voter/voterRegistry.ts
+const factories = /* @__PURE__ */ new Map();
+/**
+* Enregistre (ou remplace) la fabrique d'un voter. Appelé par les builtins au
+* chargement du module, et par les apps/plugins pour les leurs (`ProjectVoter`,
+* `TenantVoter`…).
+*/
+function registerVoterFactory(name, factory) {
+	factories.set(name, factory);
+}
+/** Toutes les fabriques enregistrées (consommées par l'`AuthorizationService`). */
+function listVoterFactories() {
+	return factories;
+}
+registerVoterFactory("role", ({ container }) => new RoleVoter(container));
+registerVoterFactory("scope", () => new ScopeVoter());
+//#endregion
+export { listVoterFactories, registerVoterFactory };

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

@@ -0,0 +1,121 @@
+import { assertPageQuery } from "nodefony";
+//#region 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.
+*/
+function toWebAuthnSummary(c) {
+	return {
+		id: c.id,
+		userId: c.userId,
+		transports: c.transports,
+		backupEligible: c.backupEligible,
+		backupState: c.backupState,
+		uvInitialized: c.uvInitialized,
+		signCount: c.signCount,
+		createdAt: c.createdAt,
+		lastUsedAt: c.lastUsedAt,
+		...c.nickname !== void 0 ? { nickname: c.nickname } : {}
+	};
+}
+var MemoryWebAuthnCredentialStore = class {
+	/** id (base64url) → credential (source de vérité). */
+	#byId = /* @__PURE__ */ new Map();
+	/** userId → ids (allowCredentials + « mes appareils »). */
+	#idsByUser = /* @__PURE__ */ new Map();
+	findById(credentialId) {
+		return Promise.resolve(this.#byId.get(credentialId) ?? null);
+	}
+	findByUser(userId) {
+		const ids = this.#idsByUser.get(userId);
+		if (!ids) return Promise.resolve([]);
+		const out = [];
+		for (const id of ids) {
+			const cred = this.#byId.get(id);
+			if (cred) out.push(cred);
+		}
+		return Promise.resolve(out);
+	}
+	countByUser(userId) {
+		return Promise.resolve(this.#idsByUser.get(userId)?.size ?? 0);
+	}
+	save(credential) {
+		this.#byId.set(credential.id, credential);
+		let set = this.#idsByUser.get(credential.userId);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#idsByUser.set(credential.userId, set);
+		}
+		set.add(credential.id);
+		return Promise.resolve();
+	}
+	update(credentialId, patch) {
+		const cred = this.#byId.get(credentialId);
+		if (cred) {
+			cred.signCount = patch.signCount;
+			cred.backupState = patch.backupState;
+			cred.uvInitialized = patch.uvInitialized;
+			cred.lastUsedAt = patch.lastUsedAt;
+		}
+		return Promise.resolve();
+	}
+	delete(credentialId) {
+		const cred = this.#byId.get(credentialId);
+		if (!cred) return Promise.resolve();
+		this.#byId.delete(credentialId);
+		const set = this.#idsByUser.get(cred.userId);
+		if (set) {
+			set.delete(credentialId);
+			if (set.size === 0) this.#idsByUser.delete(cred.userId);
+		}
+		return Promise.resolve();
+	}
+	/** Credentials filtrés, dans l'ordre contractuel (createdAt DESC, id ASC). */
+	#filtered(query) {
+		const out = [];
+		for (const cred of this.#byId.values()) {
+			if (query.userId !== void 0 && cred.userId !== query.userId) continue;
+			if (query.backedUp !== void 0 && cred.backupState !== query.backedUp) continue;
+			if (query.q !== void 0 && !cred.userId.startsWith(query.q)) continue;
+			out.push(cred);
+		}
+		return out.sort((a, b) => b.createdAt - a.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+	}
+	listPage(query) {
+		assertPageQuery(query, "offset");
+		const limit = Math.max(1, Math.floor(query.limit));
+		const offset = query.offset !== void 0 && query.offset > 0 ? query.offset : 0;
+		const all = this.#filtered(query);
+		const items = all.slice(offset, offset + limit).map(toWebAuthnSummary);
+		return Promise.resolve({
+			items,
+			limit,
+			offset,
+			hasNext: offset + items.length < all.length,
+			...query.withTotal === false ? {} : { total: all.length }
+		});
+	}
+	countCredentials(query) {
+		return Promise.resolve(this.#filtered(query).length);
+	}
+	/** Instantané sérialisable de l'état courant (pour la persistance fichier). */
+	snapshot() {
+		return { credentials: [...this.#byId.values()] };
+	}
+	/** Remplace l'état par celui d'un instantané (reconstruit l'index par user). */
+	restore(snapshot) {
+		this.#byId.clear();
+		this.#idsByUser.clear();
+		for (const cred of snapshot.credentials) {
+			this.#byId.set(cred.id, cred);
+			let set = this.#idsByUser.get(cred.userId);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				this.#idsByUser.set(cred.userId, set);
+			}
+			set.add(cred.id);
+		}
+	}
+};
+//#endregion
+export { MemoryWebAuthnCredentialStore, MemoryWebAuthnCredentialStore as default, toWebAuthnSummary };

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

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

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

@@ -0,0 +1,87 @@
+import { WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS } from "./webhookSort.js";
+import { assertPageQuery, compareByOrder, pickOrder } from "nodefony";
+//#region 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.
+*
+* @param e - endpoint candidat.
+* @param query - filtres du listing (les champs omis ne filtrent pas).
+* @returns `true` si l'endpoint appartient à la collection filtrée.
+*/
+function matchesWebhookQuery(e, query) {
+	if (query.enabled !== void 0 && e.enabled !== query.enabled) return false;
+	if (query.failing !== void 0 && e.failureCount > 0 !== query.failing) return false;
+	if (query.event !== void 0 && !e.events.includes(query.event)) return false;
+	if (query.q !== void 0 && query.q.length > 0) {
+		const needle = query.q.toLowerCase();
+		if (!`${e.url}\n${e.description ?? ""}`.toLowerCase().includes(needle)) return false;
+	}
+	return true;
+}
+/**
+* Store d'endpoints webhook **en mémoire** — défaut dev/test (non persistant :
+* les endpoints sont perdus au redémarrage). En prod, utiliser `drizzle`/
+* `mongoose` (config `webhooks.store`).
+*
+* Map indexée par id (O(1)). Les lectures renvoient une **copie défensive** : le
+* store détient la vérité, un consommateur ne peut pas muter un record en place.
+*/
+var MemoryWebhookStore = class {
+	/**
+	* {@inheritDoc IWebhookStore.sortableFields}
+	*
+	* Le store porte l'endpoint complet : il sait trier tout le vocabulaire
+	* public, sans réduction de capacité.
+	*/
+	sortableFields = WEBHOOK_SORTABLE_FIELDS;
+	#byId = /* @__PURE__ */ new Map();
+	async save(endpoint) {
+		this.#byId.set(endpoint.id, { ...endpoint });
+	}
+	async findById(id) {
+		const found = this.#byId.get(id);
+		return found ? { ...found } : null;
+	}
+	async update(id, patch) {
+		const current = this.#byId.get(id);
+		if (!current) return;
+		this.#byId.set(id, {
+			...current,
+			...patch
+		});
+	}
+	async delete(id) {
+		this.#byId.delete(id);
+	}
+	async listAll() {
+		return [...this.#byId.values()].map((e) => ({ ...e }));
+	}
+	async 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 filtered = [...this.#byId.values()].filter((e) => matchesWebhookQuery(e, query));
+		const order = pickOrder(query.order, this.sortableFields, WEBHOOK_DEFAULT_ORDER);
+		filtered.sort(compareByOrder(order, (e, field) => e[field]));
+		const items = filtered.slice(offset, offset + limit).map((e) => ({
+			...e,
+			events: [...e.events],
+			metadata: { ...e.metadata }
+		}));
+		return {
+			items,
+			total: query.withTotal === false ? void 0 : filtered.length,
+			limit,
+			offset,
+			hasNext: offset + items.length < filtered.length
+		};
+	}
+	async countEndpoints(query) {
+		let n = 0;
+		for (const e of this.#byId.values()) if (matchesWebhookQuery(e, query)) n += 1;
+		return n;
+	}
+};
+//#endregion
+export { MemoryWebhookStore, matchesWebhookQuery };

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

@@ -0,0 +1,208 @@
+import { webhookSignatureHeaders } from "./webhookSignature.js";
+//#region 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
+* jamais mettre le framework en danger** (RÈGLE PERF) :
+*
+* - **Hot-path protégé** : `onAuditEvent` (appelé dans le fire-and-forget de
+*   `AuditService.record`) court-circuite à **coût nul** quand aucun endpoint
+*   n'est configuré (cas dominant). Sinon il empile seulement ; le travail
+*   (JSON/signature/réseau) est **différé** hors de la pile via un pump microtask.
+* - **Concurrence bornée** : au plus `maxConcurrent` livraisons en vol → un
+*   endpoint lent/mort ne peut pas saturer sockets/FD/mémoire.
+* - **File bornée** : au-delà de `maxQueue`, les livraisons sont **abandonnées**
+*   (best-effort) — jamais de croissance mémoire illimitée sous un pic.
+* - **Lazy alloc** : ni file ni Set de timers tant qu'aucune livraison.
+*
+* Toutes les E/S et le temps sont **injectés** (`deps`) → logique testable sans
+* réseau ni timers réels.
+*/
+const MAX_BACKOFF_MS = 3e5;
+const BASE_BACKOFF_MS = 5e3;
+/** Une souscription matche-t-elle une action d'audit ? `*` = toutes, `x.*` = préfixe. */
+function matchesSubscription(patterns, action) {
+	for (const p of patterns) {
+		if (p === "*" || p === action) return true;
+		if (p.endsWith(".*") && action.startsWith(p.slice(0, -1))) return true;
+	}
+	return false;
+}
+/**
+* Classe le résultat d'une livraison : 2xx = succès ; réseau/timeout/429/408/5xx =
+* réessayable ; 3xx/4xx (config cliente erronée) = échec définitif (pas de retry).
+*/
+function classifyDelivery(r) {
+	if (r.ok) return "success";
+	if (r.status === null) return "retry";
+	if (r.status === 429 || r.status === 408 || r.status >= 500) return "retry";
+	return "fail";
+}
+/** Backoff exponentiel déterministe (jitter cross-pod = slice Redis cluster). */
+function backoffMs(attempt) {
+	return Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** attempt);
+}
+var WebhookDispatcher = class {
+	#deps;
+	/** File des livraisons en attente (lazy, bornée à `policy.maxQueue`). */
+	#queue = null;
+	/** Livraisons en vol (≤ `policy.maxConcurrent`). */
+	#inFlight = 0;
+	/** Annulations des retries planifiés (lazy) — vidées au shutdown. */
+	#timers = null;
+	/** Livraisons abandonnées (file pleine) — observabilité. */
+	#dropped = 0;
+	#pumpScheduled = false;
+	#stopped = false;
+	constructor(deps) {
+		this.#deps = deps;
+	}
+	/**
+	* Réagit à un événement d'audit. **Hot-path** : court-circuit à coût nul si
+	* aucun endpoint ; sinon filtre et empile (le travail lourd est différé).
+	*/
+	onAuditEvent(event) {
+		if (this.#stopped) return;
+		if (event.category === "webhook") return;
+		if (this.#deps.endpointCount() === 0) return;
+		for (const ep of this.#deps.getSnapshot()) {
+			if (!ep.enabled) continue;
+			if (!matchesSubscription(ep.events, event.action)) continue;
+			this.#enqueue({
+				ep,
+				event,
+				attempt: 0
+			});
+		}
+	}
+	/** Empile une livraison ; **abandonne** (best-effort) si la file est pleine. */
+	#enqueue(job) {
+		if (this.#stopped) return;
+		if (this.#queue === null) this.#queue = [];
+		if (this.#queue.length >= this.#deps.policy.maxQueue) {
+			this.#dropped++;
+			if (this.#dropped === 1 || this.#dropped % 100 === 0) this.#deps.log(`webhooks: file pleine (${this.#deps.policy.maxQueue}) — ${this.#dropped} livraison(s) abandonnée(s) (best-effort)`);
+			return;
+		}
+		this.#queue.push(job);
+		this.#schedulePump();
+	}
+	/** Déclenche le pump hors de la pile courante (1 microtask coalescée). */
+	#schedulePump() {
+		if (this.#pumpScheduled || this.#stopped) return;
+		this.#pumpScheduled = true;
+		queueMicrotask(() => {
+			this.#pumpScheduled = false;
+			this.#pump();
+		});
+	}
+	/** Lance des livraisons jusqu'à `maxConcurrent`. */
+	#pump() {
+		if (this.#queue === null || this.#stopped) return;
+		const max = this.#deps.policy.maxConcurrent;
+		while (this.#inFlight < max && this.#queue.length > 0) {
+			const job = this.#queue.shift();
+			this.#inFlight++;
+			this.#process(job).finally(() => {
+				this.#inFlight--;
+				if (this.#queue !== null && this.#queue.length > 0) this.#schedulePump();
+			});
+		}
+	}
+	/** Signe + livre une tentative ; gère succès / retry / échec définitif. */
+	async #process(job) {
+		const { ep, event, attempt } = job;
+		try {
+			const id = this.#deps.newMessageId();
+			const nowMs = this.#deps.now();
+			const tsS = Math.floor(nowMs / 1e3);
+			const body = JSON.stringify({
+				id,
+				timestamp: new Date(nowMs).toISOString(),
+				type: event.action,
+				data: event
+			});
+			const headers = {
+				"content-type": "application/json",
+				"user-agent": "Nodefony-Webhooks/1.0",
+				...webhookSignatureHeaders(this.#deps.secretOf(ep), id, tsS, body)
+			};
+			let addresses;
+			try {
+				addresses = await this.#deps.resolveTarget(ep.url);
+			} catch (e) {
+				const error = `ssrf: ${e.message}`;
+				await this.#deps.markDelivery(ep.id, {
+					ok: false,
+					status: null,
+					error
+				});
+				this.#deps.recordDelivery(ep.id, {
+					messageId: id,
+					type: event.action,
+					attempt,
+					ok: false,
+					status: null,
+					error,
+					durationMs: this.#deps.now() - nowMs,
+					requestBody: body,
+					responseBody: null
+				});
+				return;
+			}
+			const result = await this.#deps.deliver(ep.url, body, headers, {
+				timeoutMs: this.#deps.policy.deliveryTimeoutMs,
+				addresses,
+				allowHttp: this.#deps.policy.allowHttp
+			});
+			if (classifyDelivery(result) === "retry" && attempt < this.#deps.policy.maxRetries) {
+				this.#scheduleRetry(job);
+				return;
+			}
+			await this.#deps.markDelivery(ep.id, result);
+			this.#deps.recordDelivery(ep.id, {
+				messageId: id,
+				type: event.action,
+				attempt,
+				ok: result.ok,
+				status: result.status,
+				error: result.error,
+				durationMs: this.#deps.now() - nowMs,
+				requestBody: body,
+				responseBody: result.responseBody ?? null
+			});
+		} catch (e) {
+			this.#deps.log(`webhook dispatch ${ep.id}: ${e.message}`);
+		}
+	}
+	/** Replanifie la livraison après backoff (repasse par la file bornée). */
+	#scheduleRetry(job) {
+		if (this.#stopped) return;
+		if (this.#timers === null) this.#timers = /* @__PURE__ */ new Set();
+		const cancel = this.#deps.schedule(() => {
+			this.#timers?.delete(cancel);
+			this.#enqueue({
+				ep: job.ep,
+				event: job.event,
+				attempt: job.attempt + 1
+			});
+		}, backoffMs(job.attempt));
+		this.#timers.add(cancel);
+	}
+	/** Livraisons abandonnées pour cause de file pleine (observabilité). */
+	droppedCount() {
+		return this.#dropped;
+	}
+	/** Arrêt propre : stoppe l'admission, annule les retries, vide la file. */
+	shutdown() {
+		this.#stopped = true;
+		if (this.#timers !== null) {
+			for (const cancel of this.#timers) cancel();
+			this.#timers.clear();
+			this.#timers = null;
+		}
+		this.#queue = null;
+	}
+};
+//#endregion
+export { WebhookDispatcher, backoffMs, classifyDelivery, matchesSubscription };