@nodefony/security 10.0.0-alpha.1

package/dist/nodefony/src/admin/WebhookAdminApi.js

@@ -0,0 +1,378 @@
+import { WEBHOOK_FACETS, WEBHOOK_FILTERS, WEBHOOK_STATS_FILTERS } from "../webhook/webhookFilters.js";
+import { adminActor, auditAdmin } from "./adminAudit.js";
+import { parseFilters, parsePageQuery } from "nodefony";
+//#region nodefony/src/admin/WebhookAdminApi.ts
+/**
+* Déduit le driver logique du store webhook depuis son nom de classe (miroir de
+* `tokenStoreDriver`). Fermé sur les implémentations connues ; `null` pour un
+* store tiers inconnu (honnête — on n'invente pas un driver). **Pas de variante
+* Redis** : un endpoint webhook est une donnée DURABLE (registre), sa place est
+* en SGBD, pas dans un cache volatil (Redis sert la file d'envoi cluster, pas le
+* registre — chantier séparé).
+*
+* @param className - `store.constructor.name` (ex. `DrizzleWebhookStore`).
+*/
+function webhookStoreDriver(className) {
+	switch (className) {
+		case "MemoryWebhookStore": return "memory";
+		case "DrizzleWebhookStore":
+		case "MongooseWebhookStore": return "orm";
+		default: return null;
+	}
+}
+/** String non vide d'un corps de requête, ou `undefined`. */
+function bodyString(v) {
+	return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+/** Array de strings non vides (≥ 1 élément), ou `undefined` si invalide. */
+function bodyStringArray(v) {
+	if (!Array.isArray(v) || v.length === 0) return void 0;
+	return v.every((x) => typeof x === "string" && x.length > 0) ? v : void 0;
+}
+/** Page par défaut du listing d'endpoints (registre de config, volume modeste). */
+const ENDPOINTS_DEFAULT_LIMIT = 50;
+/** Plafond dur : un client ne peut pas demander « tout » via `?limit=`. */
+const ENDPOINTS_MAX_LIMIT = 200;
+/**
+* Traduit la query string admin en {@link IWebhookListQuery} **bornée**
+* (`limit` défaut 50, cap 200 ; pagination, tri, et les filtres de
+* {@link WEBHOOK_FILTERS}). Pagination **offset uniquement** : les trois stores
+* webhook (memory/drizzle/mongoose) sont offset-pur — aucun curseur ici.
+*
+* **UN SEUL traducteur par dimension, jamais deux** : `parsePageQuery` pour la
+* page et le tri, `parseFilters` pour les filtres. En appeler un second sans son
+* allowlist ferait refuser en 400 ce que le premier venait d'accepter, et aucun
+* test unitaire ne le verrait.
+*
+* Un filtre inconnu ou mal formé est **refusé** (400) et non plus ignoré :
+* `?enabled=oui` rendait la liste entière, lue comme « aucun endpoint désactivé ».
+*
+* @param query - `request.query` du broker admin.
+* @param sortable - champs que le backend branché sait trier ; un `?order=`
+*   portant autre chose est refusé en 400 par le traducteur.
+*/
+function parseWebhookListQuery(query, sortable) {
+	const page = parsePageQuery(query, {
+		defaultLimit: ENDPOINTS_DEFAULT_LIMIT,
+		maxLimit: ENDPOINTS_MAX_LIMIT,
+		sortable,
+		searchable: true
+	});
+	const out = {
+		limit: page.limit,
+		...parseFilters(query, WEBHOOK_FILTERS)
+	};
+	if (page.offset !== void 0) out.offset = page.offset;
+	if (page.q !== void 0) out.q = page.q;
+	if (page.order !== void 0) out.order = page.order;
+	return out;
+}
+/**
+* Mappe une erreur du service webhook en réponse admin. Seule l'erreur SSRF
+* (`code === 422`, **duck-typée** — pas d'import de la classe `SsrfError`) est
+* « attendue » et traduite en 422 ; tout le reste remonte (le broker rend un 500
+* fail-closed, et logge).
+*/
+function mapWebhookError(e) {
+	if (e.code === 422) {
+		const message = e.message;
+		return {
+			status: 422,
+			body: { error: typeof message === "string" ? message : "invalid url" }
+		};
+	}
+	throw e;
+}
+const NOT_FOUND = {
+	status: 404,
+	body: { error: "not found" }
+};
+const UNAVAILABLE = {
+	status: 503,
+	body: { error: "webhooks unavailable" }
+};
+/**
+* Construit les endpoints admin webhook, à **spreader** dans les
+* `adminEndpoints()` du producteur `security`. Les handlers résolvent le service
+* `webhooks` **lazy** (à la requête) → un service désactivé/absent rend 503 (ou
+* un état honnête en lecture), jamais une erreur au montage.
+*
+* @param container - container du kernel (capturé par les handlers lazy).
+*/
+function webhookAdminEndpoints(container) {
+	const svc = () => container.get("webhooks");
+	const ready = (s) => !!s && s.isReady();
+	const pathId = (request) => {
+		const id = request.params.id;
+		return typeof id === "string" && id.length > 0 ? id : null;
+	};
+	return [
+		{
+			path: "webhooks",
+			method: "GET",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Endpoints webhook sortants (registre) + backend du store (« où on écrit » : memory/orm). Secrets EXCLUS (chiffrés au repos, jamais ici).",
+			page: {
+				sortable: () => {
+					const s = svc();
+					return ready(s) ? s.sortableFields() : [];
+				},
+				filters: WEBHOOK_FILTERS,
+				search: () => ready(svc())
+			},
+			handler: async (request) => {
+				const s = svc();
+				const className = container.get("webhookStore")?.constructor?.name;
+				const query = parseWebhookListQuery(request.query, ready(s) ? s.sortableFields() : []);
+				const page = ready(s) ? await s.listPage(query) : null;
+				return {
+					enabled: ready(s),
+					driver: webhookStoreDriver(className),
+					store: className ?? "none",
+					endpoints: page?.items ?? [],
+					total: page?.total,
+					limit: query.limit,
+					offset: page?.offset
+				};
+			}
+		},
+		{
+			path: "webhooks/stats",
+			method: "GET",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Compteurs des endpoints sur la collection ENTIÈRE (total, actifs, désactivés, en échec) — mêmes filtres que la liste. `null` = le backend ne sait pas compter. Webhooks coupés → tous les compteurs null.",
+			page: {
+				filters: WEBHOOK_STATS_FILTERS,
+				facets: WEBHOOK_FACETS,
+				search: () => ready(svc())
+			},
+			handler: async (request) => {
+				const s = svc();
+				const page = parsePageQuery(request.query, { searchable: ready(s) });
+				if (!ready(s)) return {
+					total: null,
+					active: null,
+					disabled: null,
+					failing: null
+				};
+				return s.countWebhookFacets({
+					...parseFilters(request.query, WEBHOOK_STATS_FILTERS),
+					...page.q !== void 0 ? { q: page.q } : {}
+				});
+			}
+		},
+		{
+			path: "webhooks",
+			method: "POST",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Crée un endpoint (URL validée anti-SSRF). Le secret de signature n'est renvoyé QU'ICI, une seule fois. Audité (webhook.created).",
+			handler: async (request) => {
+				const s = svc();
+				if (!ready(s)) return UNAVAILABLE;
+				const body = request.body ?? {};
+				const url = bodyString(body.url);
+				if (!url) return {
+					status: 400,
+					body: { error: "url required" }
+				};
+				const events = bodyStringArray(body.events);
+				if (!events) return {
+					status: 400,
+					body: { error: "events must be a non-empty string array" }
+				};
+				if (body.description !== void 0 && body.description !== null && typeof body.description !== "string") return {
+					status: 400,
+					body: { error: "description must be a string" }
+				};
+				if (body.enabled !== void 0 && typeof body.enabled !== "boolean") return {
+					status: 400,
+					body: { error: "enabled must be a boolean" }
+				};
+				const actor = adminActor(request.user);
+				try {
+					const created = await s.register({
+						url,
+						events,
+						description: body.description ?? null,
+						enabled: body.enabled,
+						createdBy: actor
+					});
+					auditAdmin(container, {
+						category: "webhook",
+						action: "webhook.created",
+						outcome: "success",
+						actor,
+						resource: created.endpoint.id,
+						metadata: { url }
+					});
+					return {
+						status: 201,
+						body: created
+					};
+				} catch (e) {
+					return mapWebhookError(e);
+				}
+			}
+		},
+		{
+			path: "webhooks/{id}",
+			method: "GET",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Un endpoint webhook par id (vue publique, sans secret). 404 sinon.",
+			handler: async (request) => {
+				const s = svc();
+				if (!ready(s)) return UNAVAILABLE;
+				const id = pathId(request);
+				if (!id) return NOT_FOUND;
+				return await s.getEndpoint(id) ?? NOT_FOUND;
+			}
+		},
+		{
+			path: "webhooks/{id}/deliveries",
+			method: "GET",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Historique des dernières livraisons d'un endpoint (ce qui a été ENVOYÉ + la réponse) — RAM, borné, par pod. Aucun secret. 404 si endpoint absent.",
+			handler: async (request) => {
+				const s = svc();
+				if (!ready(s)) return UNAVAILABLE;
+				const id = pathId(request);
+				if (!id) return NOT_FOUND;
+				if (!await s.getEndpoint(id)) return NOT_FOUND;
+				return { deliveries: s.listDeliveries(id) };
+			}
+		},
+		{
+			path: "webhooks/{id}",
+			method: "PATCH",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Met à jour un endpoint (url/events/enabled/description). Une nouvelle url est re-validée anti-SSRF. Audité (webhook.updated). 404 si absent.",
+			handler: async (request) => {
+				const s = svc();
+				if (!ready(s)) return UNAVAILABLE;
+				const id = pathId(request);
+				if (!id) return NOT_FOUND;
+				const body = request.body ?? {};
+				const patch = {};
+				const fields = [];
+				if ("url" in body) {
+					const u = bodyString(body.url);
+					if (!u) return {
+						status: 400,
+						body: { error: "url must be a non-empty string" }
+					};
+					patch.url = u;
+					fields.push("url");
+				}
+				if ("events" in body) {
+					const ev = bodyStringArray(body.events);
+					if (!ev) return {
+						status: 400,
+						body: { error: "events must be a non-empty string array" }
+					};
+					patch.events = ev;
+					fields.push("events");
+				}
+				if ("enabled" in body) {
+					if (typeof body.enabled !== "boolean") return {
+						status: 400,
+						body: { error: "enabled must be a boolean" }
+					};
+					patch.enabled = body.enabled;
+					fields.push("enabled");
+				}
+				if ("description" in body) {
+					const d = body.description;
+					if (d !== null && typeof d !== "string") return {
+						status: 400,
+						body: { error: "description must be a string or null" }
+					};
+					patch.description = d;
+					fields.push("description");
+				}
+				const actor = adminActor(request.user);
+				try {
+					const updated = await s.update(id, patch);
+					if (!updated) return NOT_FOUND;
+					auditAdmin(container, {
+						category: "webhook",
+						action: "webhook.updated",
+						outcome: "success",
+						actor,
+						resource: id,
+						metadata: { fields }
+					});
+					return updated;
+				} catch (e) {
+					return mapWebhookError(e);
+				}
+			}
+		},
+		{
+			path: "webhooks/{id}",
+			method: "DELETE",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Supprime un endpoint. Audité (webhook.deleted). 404 si absent.",
+			handler: async (request) => {
+				const s = svc();
+				if (!ready(s)) return UNAVAILABLE;
+				const id = pathId(request);
+				if (!id) return NOT_FOUND;
+				if (!await s.delete(id)) return NOT_FOUND;
+				auditAdmin(container, {
+					category: "webhook",
+					action: "webhook.deleted",
+					outcome: "success",
+					actor: adminActor(request.user),
+					resource: id
+				});
+				return { ok: true };
+			}
+		},
+		{
+			path: "webhooks/{id}/rotate",
+			method: "POST",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Régénère le secret de signature (rotation) — nouveau secret renvoyé QU'ICI, une fois. L'ancien cesse d'être valide. Audité. 404 si absent.",
+			handler: async (request) => {
+				const s = svc();
+				if (!ready(s)) return UNAVAILABLE;
+				const id = pathId(request);
+				if (!id) return NOT_FOUND;
+				const rotated = await s.rotateSecret(id);
+				if (!rotated) return NOT_FOUND;
+				auditAdmin(container, {
+					category: "webhook",
+					action: "webhook.rotated",
+					outcome: "success",
+					actor: adminActor(request.user),
+					resource: id
+				});
+				return rotated;
+			}
+		},
+		{
+			path: "webhooks/{id}/reveal",
+			method: "POST",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Révèle le secret de signature en clair (réversible — copie console). Action SENSIBLE systématiquement audité (webhook.revealed). 404 sinon. POST (pas GET) : jamais de secret dans une URL/log d'accès, CSRF requise.",
+			handler: async (request) => {
+				const s = svc();
+				if (!ready(s)) return UNAVAILABLE;
+				const id = pathId(request);
+				if (!id) return NOT_FOUND;
+				const secret = await s.revealSecret(id);
+				if (secret === null) return NOT_FOUND;
+				auditAdmin(container, {
+					category: "webhook",
+					action: "webhook.revealed",
+					outcome: "success",
+					actor: adminActor(request.user),
+					resource: id
+				});
+				return { secret };
+			}
+		}
+	];
+}
+//#endregion
+export { parseWebhookListQuery, webhookAdminEndpoints };

package/dist/nodefony/src/admin/adminAudit.js

@@ -0,0 +1,37 @@
+//#region nodefony/src/admin/adminAudit.ts
+/**
+* Helpers d'audit PARTAGÉS par les producteurs admin du module sécurité
+* (`SecurityAdminApi`, `WebhookAdminApi`…). Extraits dans leur propre fichier
+* pour être consommés par plusieurs producteurs SANS créer de cycle d'import
+* (un producteur composé ne ré-importe pas le producteur qui le compose).
+*/
+/**
+* Identité de l'admin appelant (label d'audit) — duck-typing prudent sur
+* l'`IUser` projeté dans `IAdminRequest.user` (ALS du firewall). Repli
+* `"admin"` (libellé d'audit, jamais une décision d'autorisation).
+*
+* @param user - `request.user` du broker admin.
+* @returns un libellé d'identité stable, jamais un secret.
+*/
+function adminActor(user) {
+	if (user && typeof user === "object") {
+		const u = user;
+		if (typeof u.username === "string" && u.username) return u.username;
+		if (typeof u.identifier === "string" && u.identifier) return u.identifier;
+	}
+	return "admin";
+}
+/**
+* Émet un événement d'audit pour une mutation admin (best-effort,
+* fire-and-forget) — l'audit ne doit jamais bloquer ni faire échouer l'action.
+* No-op si le service `auditService` est absent. Couplage structurel : `record`
+* lu défensivement (jamais d'import de la classe concrète).
+*
+* @param container - container du kernel.
+* @param draft - événement (sans `id`/`ts`, posés par le service).
+*/
+function auditAdmin(container, draft) {
+	container.get("auditService")?.record?.(draft);
+}
+//#endregion
+export { adminActor, auditAdmin };

package/dist/nodefony/src/admin/userRevocationCascade.js

@@ -0,0 +1,40 @@
+import { USER_REVOKED_EVENT } from "@nodefony/user";
+//#region nodefony/src/admin/userRevocationCascade.ts
+/**
+* Cascade de révocation déclenchée par {@link USER_REVOKED_EVENT} : éjecte
+* **immédiatement** les artefacts d'accès du porteur — ses **sessions** (http,
+* `destroyByUser`) et ses **jetons/PAT** (`tokenStore.revokeAllForSubject`,
+* seuil `invalidBefore`). Best-effort par brique (une indispo n'empêche pas
+* l'autre) — l'accès était DÉJÀ neutralisé par le re-fetch des authenticators,
+* cette cascade est de la **propreté + défense en profondeur**, jamais l'unique
+* rempart. `tenantId` du payload est réservé (scoping non câblé en mono-tenant).
+*
+* @param container - container du kernel (résolution lazy de `sessions`/`tokenStore`).
+* @param event - charge utile de l'événement (porteur + raison).
+* @param now - horloge (epoch ms) injectable pour les tests.
+*/
+async function cascadeUserRevocation(container, event, now = Date.now()) {
+	const identifier = event.identifier;
+	try {
+		await container.get("sessions")?.destroyByUser?.(identifier);
+	} catch {}
+	try {
+		await container.get("tokenStore")?.revokeAllForSubject?.(identifier, now);
+	} catch {}
+}
+/**
+* Abonne la cascade au bus kernel. À appeler au `onKernelBoot` d'un module
+* bootable (ici `@nodefony/security`). **Extensible** : tout autre module
+* (webhooks…) peut s'abonner au MÊME `USER_REVOKED_EVENT` pour ses propres
+* artefacts, sans toucher à ce fichier.
+*
+* @param kernel - bus d'événements (kernel) exposant `on`.
+* @param container - container capturé par le handler.
+*/
+function registerUserRevocationCascade(kernel, container) {
+	kernel.on(USER_REVOKED_EVENT, (event) => {
+		cascadeUserRevocation(container, event);
+	});
+}
+//#endregion
+export { cascadeUserRevocation, registerUserRevocationCascade };

package/dist/nodefony/src/apikey/apiKeyFormat.js

@@ -0,0 +1,107 @@
+import { createHash, randomBytes } from "node:crypto";
+//#region nodefony/src/apikey/apiKeyFormat.ts
+/**
+* Encodage / décodage / hachage des clés API (PAT) — logique **pure** (aucun I/O,
+* aucun container) → testable sans serveur et partagée par l'émetteur
+* (`ApiKeyService`) et le vérificateur (`ApiKeyAuthenticator`).
+*
+* **Format émis** : `<prefix>_<pubid><secret><crc>` (un seul séparateur `_`, le
+* reste est **positionnel** — pas de `split` fragile, car le charset base64url
+* contient lui-même `-` et `_`). Exemple : `nf_a1b2c3d4XXXX…XXXXz9z9z9`.
+*
+*  - `prefix`  : marque applicative (`apiKeys.prefix`, ex. `nf`) — discrimine un
+*    PAT d'un JWT (qui, lui, a la structure compacte `a.b.c`) ;
+*  - `pubid`   : 6 octets aléatoires → 8 car. — identifiant **public** affichable
+*    (`record.prefix` = `nf_a1b2c3d4`), jamais secret, sert l'UI/console ;
+*  - `secret`  : 32 octets aléatoires → 43 car. = **256 bits d'entropie** ;
+*  - `crc`     : CRC32 (4 octets → 6 car.) du `prefix_pubid_secret`. Checksum
+*    **public** (jamais un secret) : permet (1) de **rejeter une clé malformée en
+*    O(1) sans toucher la base** (anti-DoS du store), (2) le **secret-scanning**
+*    (GitGuardian/GitHub détectent un `nf_…` au checksum valide qui aurait fuité).
+*
+* **Au repos** : seul `sha256(token entier)` est stocké (`secretHash`). `sha256`
+* suffit ici — contrairement à un mot de passe humain (faible → argon2), un secret
+* de 256 bits aléatoires n'est ni brute-forçable ni sujet aux rainbow tables ; un
+* pepper ne protègerait que des secrets faibles.
+*/
+const PUBID_BYTES = 6;
+const SECRET_BYTES = 32;
+const PUBID_LEN = 8;
+const BODY_LEN = 57;
+const BASE64URL = /^[A-Za-z0-9_-]+$/;
+const CRC_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let n = 0; n < 256; n++) {
+		let c = n;
+		for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		table[n] = c >>> 0;
+	}
+	return table;
+})();
+/** CRC32 (IEEE) d'une chaîne ASCII — entier non signé 32 bits. */
+function crc32(input) {
+	let crc = 4294967295;
+	for (let i = 0; i < input.length; i++) crc = CRC_TABLE[(crc ^ input.charCodeAt(i)) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+/** Chunk de checksum (6 car. base64url) du payload `prefix_pubid_secret`. */
+function crcChunk(payload) {
+	const buf = Buffer.allocUnsafe(4);
+	buf.writeUInt32BE(crc32(payload));
+	return buf.toString("base64url");
+}
+/** Hash au repos d'une clé présentée (token entier) — `sha256` hex. */
+function hashApiKey(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+/**
+* Génère une nouvelle clé API cryptographiquement aléatoire.
+*
+* @param prefix - marque applicative (`apiKeys.prefix`).
+* @returns le token clair + ses dérivés publics/persistants.
+*/
+function generateApiKey(prefix) {
+	const pubid = randomBytes(PUBID_BYTES).toString("base64url");
+	const payload = `${prefix}_${pubid}${randomBytes(SECRET_BYTES).toString("base64url")}`;
+	const token = `${payload}${crcChunk(payload)}`;
+	return {
+		token,
+		pubid,
+		publicPrefix: `${prefix}_${pubid}`,
+		secretHash: hashApiKey(token)
+	};
+}
+/**
+* Test **bon marché** (préfixe seul) — discrimine un PAT d'un JWT à l'`supports()`
+* de l'authenticator, sans calculer le checksum.
+*/
+function looksLikeApiKey(token, prefix) {
+	return token.startsWith(`${prefix}_`);
+}
+/**
+* Valide la **forme** d'une clé présentée et en dérive le hash de lookup —
+* **sans aucun accès au store**. Rejette (→ `null`) un préfixe absent, une
+* longueur incorrecte, un charset non base64url ou un **CRC invalide** : autant
+* de requêtes qui n'atteignent jamais la base (anti-DoS).
+*
+* @param token - valeur brute présentée (after `Bearer `).
+* @param prefix - marque applicative attendue.
+* @returns la décomposition + le `secretHash` de lookup, ou `null` si malformée.
+*/
+function parseApiKey(token, prefix) {
+	const head = `${prefix}_`;
+	if (!token.startsWith(head)) return null;
+	const body = token.slice(head.length);
+	if (body.length !== BODY_LEN || !BASE64URL.test(body)) return null;
+	const pubid = body.slice(0, PUBID_LEN);
+	const secret = body.slice(PUBID_LEN, 51);
+	const crc = body.slice(51);
+	if (crcChunk(`${prefix}_${pubid}${secret}`) !== crc) return null;
+	return {
+		pubid,
+		publicPrefix: `${prefix}_${pubid}`,
+		secretHash: hashApiKey(token)
+	};
+}
+//#endregion
+export { generateApiKey, hashApiKey, looksLikeApiKey, parseApiKey };

package/dist/nodefony/src/audit/MemoryAuditStore.js

@@ -0,0 +1,121 @@
+import { assertPageQuery } from "nodefony";
+//#region nodefony/src/audit/MemoryAuditStore.ts
+const DEFAULT_MAX_ENTRIES = 1e4;
+const DEFAULT_LIMIT = 100;
+const MAX_LIMIT = 500;
+/**
+* Sépare les deux composantes du curseur. Le curseur est **composite**
+* (`<ts>:<id>`) et non un id nu : il se suffit à lui-même, donc une page reste
+* exacte même si l'événement qui l'a produite a été purgé entre-temps par
+* {@link MemoryAuditStore.gc} (un id nu, lui, n'aurait plus rien à résoudre →
+* curseur ignoré → retour silencieux à la première page).
+*
+* Format **privé au store** : l'appelant repasse le jeton tel quel.
+*/
+const CURSOR_SEPARATOR = ":";
+/**
+* Journal d'audit **en mémoire** — implémentation de référence d'{@link IAuditStore}.
+*
+* 0 dépendance, idéal pour le dev mono-process et les **tests**. **Volatile**
+* (perdu au redémarrage) et **non partagé** (per-pod) → en prod multi-process,
+* brancher un backend ORM/Redis. Le volume est **borné** (`maxEntries`, FIFO : au
+* delà, le plus ancien tombe) pour ne JAMAIS fuir, doublé d'une purge par âge
+* ({@link MemoryAuditStore.gc}, rétention). Append-only : aucune mutation d'un
+* événement déjà journalisé.
+*
+* Horloge injectable (`now`) pour des tests déterministes (pattern `MemoryTokenStore`).
+*/
+var MemoryAuditStore = class {
+	/** Événements en ordre d'insertion (ancien → récent). FIFO borné. */
+	#events = [];
+	#now;
+	#maxEntries;
+	/** Fenêtre de rétention (ms) — au-delà, `gc` purge. */
+	#retentionMs;
+	constructor(now = Date.now, retentionMs = 31536e6, maxEntries = DEFAULT_MAX_ENTRIES) {
+		this.#now = now;
+		this.#retentionMs = retentionMs;
+		this.#maxEntries = maxEntries;
+	}
+	append(event) {
+		this.#events.push(event);
+		if (this.#events.length > this.#maxEntries) this.#events.shift();
+		return Promise.resolve();
+	}
+	listPage(query) {
+		assertPageQuery(query, "cursor");
+		const limit = Math.min(Math.max(1, query.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
+		const matched = [];
+		for (let i = 0; i < this.#events.length; i++) {
+			const event = this.#events[i];
+			if (this.#matches(event, query)) matched.push(event);
+		}
+		const total = matched.length;
+		matched.sort((a, b) => a.ts !== b.ts ? b.ts - a.ts : a.id < b.id ? 1 : -1);
+		let page = matched;
+		const cursor = this.#parseCursor(query.cursor);
+		if (cursor) {
+			const from = matched.findIndex((event) => event.ts < cursor.ts || event.ts === cursor.ts && event.id < cursor.id);
+			page = from >= 0 ? matched.slice(from) : [];
+		}
+		const hasNext = page.length > limit;
+		const items = hasNext ? page.slice(0, limit) : page;
+		const last = items[items.length - 1];
+		return Promise.resolve({
+			items,
+			limit,
+			hasNext,
+			nextCursor: hasNext && last ? `${last.ts}${CURSOR_SEPARATOR}${last.id}` : null,
+			...query.withTotal === false ? {} : { total }
+		});
+	}
+	/**
+	* Décode le curseur composite. Un jeton absent ou malformé (forgé — le nôtre
+	* ne l'est jamais) rend `null` : la lecture repart de la page la plus récente,
+	* jamais d'erreur sur un chemin de consultation.
+	*/
+	#parseCursor(cursor) {
+		if (cursor === void 0) return null;
+		const sep = cursor.indexOf(CURSOR_SEPARATOR);
+		if (sep <= 0) return null;
+		const ts = Number(cursor.slice(0, sep));
+		return Number.isFinite(ts) ? {
+			ts,
+			id: cursor.slice(sep + 1)
+		} : null;
+	}
+	gc(now = this.#now()) {
+		const threshold = now - this.#retentionMs;
+		let purged = 0;
+		while (this.#events.length > 0 && this.#events[0].ts < threshold) {
+			this.#events.shift();
+			purged++;
+		}
+		return Promise.resolve(purged);
+	}
+	#matches(event, filter) {
+		if (filter.category !== void 0 && event.category !== filter.category) return false;
+		if (filter.outcome !== void 0 && event.outcome !== filter.outcome) return false;
+		if (filter.actor !== void 0 && event.actor !== filter.actor) return false;
+		if (filter.action !== void 0 && event.action !== filter.action) return false;
+		if (filter.requestId !== void 0 && event.requestId !== filter.requestId) return false;
+		if (filter.since !== void 0 && event.ts < filter.since) return false;
+		if (filter.until !== void 0 && event.ts > filter.until) return false;
+		return true;
+	}
+	/** Nombre d'événements actuellement retenus (introspection / tests). */
+	get size() {
+		return this.#events.length;
+	}
+	/** Instantané sérialisable de l'état courant. */
+	snapshot() {
+		return { events: [...this.#events] };
+	}
+	/** Remplace l'état par celui d'un instantané. */
+	restore(snapshot) {
+		this.#events.length = 0;
+		for (const event of snapshot.events) this.#events.push(event);
+	}
+};
+//#endregion
+export { MemoryAuditStore };