@nodefony/user 10.0.0-alpha.1

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

@@ -0,0 +1,588 @@
+import { listUserStores } from "../userStoreRegistry.js";
+import { USER_FACETS, USER_FILTERS, USER_STATS_FILTERS } from "../userFilters.js";
+import { WeakPasswordError } from "../../errors/WeakPasswordError.js";
+import { mergeProfileIntoMetadata, projectProfile, validateProfilePatch } from "../userProfile.js";
+import { parseFilters, parsePageQuery } from "nodefony";
+//#region nodefony/src/admin/UserAdminApi.ts
+/**
+* Rôle critique : porteur de l'accès au data plane d'administration (Studio).
+* Les garde-fous anti-lockout protègent **ce** rôle (jamais déchoir le dernier).
+*/
+const ADMIN_ROLE = "ROLE_NODEFONY_ADMIN";
+/** Longueur minimale d'un mot de passe self-service (OWASP ASVS V2.1.1 — plancher). */
+const MIN_PASSWORD_LENGTH = 8;
+/** Convertit un timestamp (`Date`/string ISO/number) en epoch ms — `null` si invalide. */
+function toEpoch(value) {
+	if (value === void 0 || value === null) return null;
+	const t = new Date(value).getTime();
+	return Number.isNaN(t) ? null : t;
+}
+/**
+* Projette un {@link IUser} en {@link IUserSummary} redacté. Fonction **pure**
+* (cœur de la garantie anti-fuite, testée isolément) : `currentRole`/
+* `socialProviders`/timestamps sont lus **défensivement** (présents sur l'entité
+* ORM, absents du contrat strict `IUser`) — `password`/`metadata` jamais lus.
+*/
+function toUserSummary(user) {
+	const ext = user;
+	const social = Array.isArray(ext.socialProviders) ? ext.socialProviders : [];
+	return {
+		id: user.id,
+		identifier: user.identifier,
+		roles: [...user.roles],
+		enabled: user.isActive(),
+		locked: user.isLocked(),
+		hasPassword: typeof ext.password === "string" && ext.password.length > 0,
+		currentRole: typeof ext.currentRole === "string" ? ext.currentRole : null,
+		socialProviders: social.map((p) => ({
+			provider: p.provider,
+			providerId: p.providerId,
+			createdAt: toEpoch(p.createdAt)
+		})),
+		profile: projectProfile(ext.metadata),
+		createdAt: toEpoch(ext.createdAt),
+		updatedAt: toEpoch(ext.updatedAt),
+		tenantId: null
+	};
+}
+/** Identité de l'admin appelant (id pour comparer self, label pour l'audit). */
+function adminActor(user) {
+	if (user && typeof user === "object") {
+		const u = user;
+		return {
+			id: typeof u.id === "string" ? u.id : null,
+			label: typeof u.username === "string" && u.username || typeof u.identifier === "string" && u.identifier || "admin"
+		};
+	}
+	return {
+		id: null,
+		label: "admin"
+	};
+}
+/** Émet un événement d'audit si `@nodefony/security` est monté — no-op sinon. */
+function audit(container, action, actor, resource, metadata) {
+	container.get("auditService")?.record({
+		category: "authz",
+		action,
+		outcome: "success",
+		actor,
+		resource,
+		metadata: {
+			...metadata,
+			viaAdmin: true
+		}
+	});
+}
+/**
+* Identité fonctionnelle (identifier) de l'appelant, lue depuis l'objet user de
+* l'ALS serveur (posé au login par le firewall) — **JAMAIS** un paramètre client.
+* C'est le socle anti-IDOR du self-service : le périmètre d'une action « moi » est
+* fermé par cette valeur, pas par un id reçu dans l'URL ou le corps. `null` si non
+* authentifié (ne devrait pas arriver sous une zone firewall fermée → 401 défensif).
+*/
+function currentIdentifier(user) {
+	if (user && typeof user === "object") {
+		const u = user;
+		if (typeof u.identifier === "string" && u.identifier.length > 0) return u.identifier;
+	}
+	return null;
+}
+/**
+* Émet un événement d'audit d'AUTHENTIFICATION self-service (le propriétaire agit
+* sur son propre compte) — `viaAdmin: false` (distinct des mutations admin), avec
+* un `outcome` paramétrable car **succès ET échec** sont audités (un échec de
+* re-auth est un signal de sécurité). No-op si `@nodefony/security` n'est pas monté.
+*/
+function auditSelf(container, action, outcome, actor, resource, reason) {
+	container.get("auditService")?.record({
+		category: "authn",
+		action,
+		outcome,
+		actor,
+		resource,
+		reason,
+		metadata: { viaAdmin: false }
+	});
+}
+/**
+* Nom de l'événement kernel émis quand l'accès d'un utilisateur doit être révoqué
+* partout (suppression / désactivation / verrouillage). **Point d'extension** : un
+* module qui possède des artefacts liés à un user (sessions, tokens, webhooks…)
+* s'y abonne et nettoie LES SIENS — zéro couplage avec `@nodefony/user`.
+*/
+const USER_REVOKED_EVENT = "onUserRevoked";
+/**
+* Émet {@link USER_REVOKED_EVENT} sur le bus kernel (no-op si pas de kernel).
+* Déclenche la cascade de révocation chez tous les abonnés (sessions, tokens,
+* webhooks futurs). L'accès était DÉJÀ neutralisé par le re-fetch des
+* authenticators ; ceci force le nettoyage immédiat (défense en profondeur).
+*/
+function emitUserRevoked(container, user, reason) {
+	const kernel = container.get("kernel");
+	const event = {
+		id: user.id,
+		identifier: user.identifier,
+		tenantId: null,
+		reason
+	};
+	kernel?.fire(USER_REVOKED_EVENT, event);
+}
+/** Tableau de strings non vides depuis une valeur inconnue, ou `undefined`. */
+function readRoles(value) {
+	if (!Array.isArray(value)) return void 0;
+	const roles = [];
+	for (const entry of value) {
+		if (typeof entry !== "string" || entry.trim().length === 0) continue;
+		const role = entry.trim();
+		if (!roles.includes(role)) roles.push(role);
+	}
+	return roles;
+}
+/**
+* Déduit le **backend** (store) de persistance du nom de classe du repository —
+* convention de nommage des adapters (`InMemoryUserRepository`/
+* `DrizzleUserRepository`/`MongooseUserRepository`). `null` si le nom ne matche
+* aucun adapter connu (jamais throw — un repo custom reste affichable via `repository`).
+*/
+function deduceUserStore(repositoryName) {
+	const n = repositoryName.toLowerCase();
+	if (n.includes("inmemory") || n.includes("memory")) return "memory";
+	if (n.includes("drizzle")) return "drizzle";
+	if (n.includes("mongoose") || n.includes("mongo")) return "mongoose";
+	return null;
+}
+/**
+* Producteur `IAdminApi` du domaine **utilisateur** — exposé sous
+* `/nodefony/user/api/users`. Défini DANS `@nodefony/user` (propriétaire du
+* `UserService`/`IUser`) mais **enregistré par un module bootable**
+* (`@nodefony/security`, via {@link registerUserAdminApi}) car `@nodefony/user`
+* est une lib pure non-bootable — exactement le cas prévu par le core : un
+* module qui ne dépend que de `nodefony` produit sa donnée d'admin.
+*
+* RBAC `ROLE_NODEFONY_ADMIN` (défaut broker, 403 sinon). Mutations = HTTP
+* (pipeline CSRF), auditées (catégorie `authz`). Garde-fous **anti-lockout** :
+* pas d'auto-déchéance, pas de suppression/désactivation du dernier admin actif.
+*
+* @param container - container du kernel (résolution lazy du service `users`).
+*/
+function createUserAdminApi(container) {
+	const resolveUsers = () => container.get("users");
+	const endpoints = [
+		{
+			path: "users",
+			method: "GET",
+			summary: "Utilisateurs (DTO redacté, jamais le hash). Filtres : ?role&enabled&q (identifier) ; pagination ?limit&offset.",
+			page: {
+				sortable: () => resolveUsers()?.sortableFields() ?? [],
+				filters: USER_FILTERS,
+				search: () => true
+			},
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const pageQuery = parsePageQuery(request.query, {
+					sortable: users.sortableFields(),
+					searchable: true
+				});
+				const filters = parseFilters(request.query, USER_FILTERS);
+				const limit = pageQuery.limit;
+				const offset = pageQuery.offset ?? 0;
+				const page = await users.listPage({
+					limit,
+					offset,
+					...filters,
+					...pageQuery.order ? { order: pageQuery.order } : {},
+					...pageQuery.q !== void 0 ? { q: pageQuery.q } : {}
+				});
+				return {
+					items: page.items.map(toUserSummary),
+					total: page.total ?? page.items.length,
+					limit,
+					offset
+				};
+			}
+		},
+		{
+			path: "users/stats",
+			method: "GET",
+			summary: "Compteurs sur l'annuaire ENTIER (total, actifs, désactivés, verrouillés, administrateurs, comptes liés à un fournisseur externe). Filtre `role` seulement. `null` = l'annuaire ne sait pas compter.",
+			page: {
+				filters: USER_STATS_FILTERS,
+				facets: USER_FACETS,
+				search: () => true
+			},
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const page = parsePageQuery(request.query, { searchable: true });
+				return users.countUserFacets(ADMIN_ROLE, {
+					...parseFilters(request.query, USER_STATS_FILTERS),
+					...page.q !== void 0 ? { q: page.q } : {}
+				});
+			}
+		},
+		{
+			path: "users/status",
+			method: "GET",
+			summary: "Statut du sous-système utilisateur (store/driver/count) — jamais de hash.",
+			handler: async () => {
+				const users = resolveUsers();
+				if (!users) return {
+					enabled: false,
+					store: null,
+					available: listUserStores(),
+					repository: "none",
+					count: null,
+					tenantId: null
+				};
+				const repository = users.repository?.constructor?.name ?? "none";
+				const store = deduceUserStore(repository);
+				const available = listUserStores();
+				if (store && !available.includes(store)) available.push(store);
+				let count = null;
+				try {
+					count = await users.count();
+				} catch {
+					count = null;
+				}
+				return {
+					enabled: true,
+					store,
+					available,
+					repository,
+					count,
+					tenantId: null
+				};
+			}
+		},
+		{
+			path: "users/{id}",
+			method: "GET",
+			summary: "Détail d'un utilisateur (DTO redacté). 404 si introuvable.",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const user = await users.findById(request.params.id);
+				if (!user) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				return toUserSummary(user);
+			}
+		},
+		{
+			path: "users",
+			method: "POST",
+			summary: "Crée un utilisateur (identifier requis ; plainPassword/roles optionnels). Audité. 409 si l'identifiant existe déjà.",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const body = request.body ?? {};
+				const identifier = typeof body.identifier === "string" ? body.identifier.trim() : "";
+				if (identifier.length === 0) return {
+					status: 400,
+					body: { error: "identifier required" }
+				};
+				if (await users.findByIdentifier(identifier)) return {
+					status: 409,
+					body: { error: "identifier already exists" }
+				};
+				const plainPassword = typeof body.plainPassword === "string" ? body.plainPassword : null;
+				const created = await users.createUser({
+					identifier,
+					plainPassword,
+					roles: readRoles(body.roles) ?? []
+				});
+				audit(container, "user.created", adminActor(request.user).label, created.id, { identifier });
+				return {
+					status: 201,
+					body: toUserSummary(created)
+				};
+			}
+		},
+		{
+			path: "users/{id}",
+			method: "PATCH",
+			summary: "Modifie roles/enabled/locked/profile. Audité. Garde-fous anti-lockout (pas d'auto-déchéance ADMIN, pas de déchéance du dernier admin).",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const target = await users.findById(request.params.id);
+				if (!target) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				const actor = adminActor(request.user);
+				const isSelf = actor.id !== null && actor.id === target.id;
+				const body = request.body ?? {};
+				const patch = {};
+				const roles = readRoles(body.roles);
+				if (roles !== void 0) {
+					const losesAdmin = target.roles.includes(ADMIN_ROLE) && !roles.includes(ADMIN_ROLE);
+					if (losesAdmin && isSelf) return {
+						status: 409,
+						body: { error: "cannot remove your own admin role" }
+					};
+					if (losesAdmin) {
+						if (await users.countActiveAdmins(ADMIN_ROLE) <= 1) return {
+							status: 409,
+							body: { error: "cannot demote the last active admin" }
+						};
+					}
+					patch.roles = roles;
+				}
+				if (typeof body.enabled === "boolean") {
+					if (body.enabled === false) {
+						if (isSelf) return {
+							status: 409,
+							body: { error: "cannot disable your own account" }
+						};
+						if (target.isActive() && target.roles.includes(ADMIN_ROLE)) {
+							if (await users.countActiveAdmins(ADMIN_ROLE) <= 1) return {
+								status: 409,
+								body: { error: "cannot disable the last active admin" }
+							};
+						}
+					}
+					patch.enabled = body.enabled;
+				}
+				if (typeof body.locked === "boolean") {
+					if (body.locked === true && isSelf) return {
+						status: 409,
+						body: { error: "cannot lock your own account" }
+					};
+					patch.locked = body.locked;
+				}
+				if (body.profile !== void 0) {
+					const parsed = validateProfilePatch(body.profile);
+					if (!parsed.ok) return {
+						status: 400,
+						body: { error: parsed.error }
+					};
+					if (Object.keys(parsed.value).length > 0) patch.metadata = mergeProfileIntoMetadata(target.metadata, parsed.value);
+				}
+				if (Object.keys(patch).length === 0) return {
+					status: 400,
+					body: { error: "no modifiable fields (roles/enabled/locked/profile)" }
+				};
+				const updated = await users.updateOne({ id: target.id }, patch);
+				if (!updated) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				audit(container, "user.updated", actor.label, target.id, { fields: Object.keys(patch) });
+				if (patch.enabled === false) emitUserRevoked(container, target, "disabled");
+				else if (patch.locked === true) emitUserRevoked(container, target, "locked");
+				return toUserSummary(updated);
+			}
+		},
+		{
+			path: "users/{id}/password",
+			method: "POST",
+			summary: "Change le mot de passe d'un utilisateur (plainPassword requis). Audité (jamais la valeur). 404 si introuvable.",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const body = request.body ?? {};
+				const plainPassword = typeof body.plainPassword === "string" ? body.plainPassword : "";
+				if (plainPassword.length === 0) return {
+					status: 400,
+					body: { error: "plainPassword required" }
+				};
+				if (!await users.changePassword(request.params.id, plainPassword)) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				audit(container, "user.password_changed", adminActor(request.user).label, request.params.id);
+				return { ok: true };
+			}
+		},
+		{
+			path: "me",
+			method: "GET",
+			public: true,
+			summary: "MON profil (self-service) — identifiant, rôles, rôle actif, comptes externes liés. DTO redacté (jamais le hash ni de jeton).",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const principal = currentIdentifier(request.user);
+				if (!principal) return {
+					status: 401,
+					body: { error: "unauthenticated" }
+				};
+				const me = await users.findByIdentifier(principal);
+				if (!me) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				return toUserSummary(me);
+			}
+		},
+		{
+			path: "me/password",
+			method: "POST",
+			public: true,
+			summary: "Change MON mot de passe (self-service). Body { currentPassword, newPassword }. Re-auth du mot de passe actuel (403 sinon). Audité.",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const principal = currentIdentifier(request.user);
+				if (!principal) return {
+					status: 401,
+					body: { error: "unauthenticated" }
+				};
+				const body = request.body ?? {};
+				const currentPassword = typeof body.currentPassword === "string" ? body.currentPassword : "";
+				const newPassword = typeof body.newPassword === "string" ? body.newPassword : "";
+				if (currentPassword.length === 0) return {
+					status: 400,
+					body: { error: "currentPassword required" }
+				};
+				if (newPassword.length < MIN_PASSWORD_LENGTH) return {
+					status: 400,
+					body: { error: `newPassword must be at least ${MIN_PASSWORD_LENGTH} characters` }
+				};
+				if (newPassword === currentPassword) return {
+					status: 400,
+					body: { error: "newPassword must differ from the current password" }
+				};
+				const authed = await users.authenticate(principal, currentPassword);
+				if (!authed) {
+					auditSelf(container, "user.password_change_self", "failure", principal, principal, "bad_current_password");
+					return {
+						status: 403,
+						body: { error: "current password is incorrect" }
+					};
+				}
+				try {
+					await users.changePassword(authed.id, newPassword);
+				} catch (err) {
+					if (err instanceof WeakPasswordError) return {
+						status: 400,
+						body: { error: "password rejected (too weak)" }
+					};
+					throw err;
+				}
+				auditSelf(container, "user.password_change_self", "success", principal, authed.id);
+				return { ok: true };
+			}
+		},
+		{
+			path: "me/profile",
+			method: "POST",
+			public: true,
+			summary: "Modifie MON profil (givenName/familyName/displayName/email/locale/picture). Self-service (identité ALS, anti-IDOR). DTO redacté en retour.",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const principal = currentIdentifier(request.user);
+				if (!principal) return {
+					status: 401,
+					body: { error: "unauthenticated" }
+				};
+				const me = await users.findByIdentifier(principal);
+				if (!me) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				const parsed = validateProfilePatch(request.body ?? {});
+				if (!parsed.ok) return {
+					status: 400,
+					body: { error: parsed.error }
+				};
+				const metadata = mergeProfileIntoMetadata(me.metadata, parsed.value);
+				const updated = await users.updateOne({ id: me.id }, { metadata });
+				if (!updated) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				return toUserSummary(updated);
+			}
+		},
+		{
+			path: "users/{id}",
+			method: "DELETE",
+			summary: "Supprime un utilisateur. Audité. Garde-fous : pas d'auto-suppression, pas de suppression du dernier admin actif.",
+			handler: async (request) => {
+				const users = resolveUsers();
+				if (!users) return {
+					status: 503,
+					body: { error: "user service unavailable" }
+				};
+				const target = await users.findById(request.params.id);
+				if (!target) return {
+					status: 404,
+					body: { error: "not found" }
+				};
+				const actor = adminActor(request.user);
+				if (actor.id !== null && actor.id === target.id) return {
+					status: 409,
+					body: { error: "cannot delete your own account" }
+				};
+				if (target.isActive() && target.roles.includes(ADMIN_ROLE)) {
+					if (await users.countActiveAdmins(ADMIN_ROLE) <= 1) return {
+						status: 409,
+						body: { error: "cannot delete the last active admin" }
+					};
+				}
+				await users.delete({ id: target.id });
+				audit(container, "user.deleted", actor.label, target.id, { identifier: target.identifier });
+				emitUserRevoked(container, target, "deleted");
+				return { ok: true };
+			}
+		}
+	];
+	const descriptor = {
+		label: "Utilisateurs",
+		icon: "users",
+		order: 16,
+		role: ADMIN_ROLE
+	};
+	return {
+		adminNamespace: "user",
+		adminDescriptor: () => descriptor,
+		adminEndpoints: () => endpoints
+	};
+}
+/**
+* Enregistre le producteur admin utilisateur sur le broker — **idempotent**.
+* À appeler au `onKernelBoot` d'un module **bootable** qui dépend de
+* `@nodefony/user` (typiquement `@nodefony/security`), `@nodefony/user` n'étant
+* pas lui-même un module.
+*
+* @param registry - broker admin (`container.get("adminBroker")`).
+* @param container - container du kernel (capturé par les handlers lazy).
+*/
+function registerUserAdminApi(registry, container) {
+	if (registry.has("user")) return;
+	registry.register(createUserAdminApi(container));
+}
+//#endregion
+export { USER_REVOKED_EVENT, createUserAdminApi, registerUserAdminApi, toUserSummary };

package/dist/nodefony/src/encoders/Argon2idEncoder.js

@@ -0,0 +1,107 @@
+//#region nodefony/src/encoders/Argon2idEncoder.ts
+let argon2 = null;
+const loadArgon2 = async () => argon2 ??= await import("@node-rs/argon2");
+/** Défauts alignés sur le schéma Zod security (m = minimum OWASP). */
+const DEFAULT_MEMORY_KIB = 19456;
+const DEFAULT_TIME_COST = 3;
+const DEFAULT_PARALLELISM = 1;
+const ARGON2_HASH_RE = /^\$argon2(d|i|id)\$v=(\d+)\$m=(\d+),t=(\d+),p=(\d+)\$/;
+/** Version courante de l'algorithme (0x13) — toute version antérieure est re-hashée. */
+const ARGON2_VERSION = 19;
+/**
+* Encodeur de mot de passe **Argon2id** (RFC 9106) — recommandation NIST/OWASP 2026.
+*
+* Fonction de dérivation à MÉMOIRE DURE : chaque vérification exige `memoryKiB`
+* de RAM en plus du CPU, ce qui ruine les attaques massivement parallèles
+* (GPU/ASIC ont des milliers de cœurs mais pas 19 MiB de mémoire dédiée par
+* cœur). Le variant `id` est hybride : résistant aux canaux auxiliaires
+* (première moitié indépendante du mot de passe) ET aux compromis temps-mémoire.
+*
+* Délègue à `@node-rs/argon2` (binding NAPI Rust, exécuté hors thread principal,
+* **peerDependency optionnelle**) : le binaire natif est importé DYNAMIQUEMENT
+* au premier `hash`/`verify` — instancier l'encodeur ne charge rien.
+*/
+var Argon2idEncoder = class {
+	/** Mémoire par hash (KiB) utilisée pour produire les nouveaux hashs. */
+	memoryKiB;
+	/** Passes sur la mémoire utilisées pour produire les nouveaux hashs. */
+	timeCost;
+	/** Lanes parallèles utilisées pour produire les nouveaux hashs. */
+	parallelism;
+	/**
+	* @param options - coûts Argon2id ; défauts = minimum OWASP (19 MiB, t=2, p=1).
+	* @throws {RangeError} si un paramètre viole les bornes techniques de
+	*   l'algorithme (entiers, `t ≥ 1`, `1 ≤ p ≤ 255`, `m ≥ 8×p`).
+	*/
+	constructor(options = {}) {
+		const m = options.memoryKiB ?? DEFAULT_MEMORY_KIB;
+		const t = options.timeCost ?? DEFAULT_TIME_COST;
+		const p = options.parallelism ?? DEFAULT_PARALLELISM;
+		if (!Number.isInteger(t) || t < 1) throw new RangeError(`Argon2idEncoder: timeCost must be an integer >= 1, got ${t}`);
+		if (!Number.isInteger(p) || p < 1 || p > 255) throw new RangeError(`Argon2idEncoder: parallelism must be an integer in [1, 255], got ${p}`);
+		if (!Number.isInteger(m) || m < 8 * p) throw new RangeError(`Argon2idEncoder: memoryKiB must be an integer >= 8×parallelism (${8 * p}), got ${m}`);
+		this.memoryKiB = m;
+		this.timeCost = t;
+		this.parallelism = p;
+	}
+	/**
+	* Reconnaît un hash argon2 (tous variants `$argon2d|i|id$`) — parsing pur, sync.
+	*
+	* Tous les variants sont supportés à la VÉRIFICATION (le binding parse le
+	* format PHC) ; {@link needsRehash} se charge de moderniser `d`/`i` vers `id`.
+	*
+	* @param hash - hash stocké à inspecter.
+	* @returns `true` si le hash est au format argon2.
+	*/
+	supports(hash) {
+		return ARGON2_HASH_RE.test(hash);
+	}
+	/**
+	* Hache un mot de passe en clair (sel généré, paramètres inclus dans la sortie PHC).
+	*
+	* @param plain - mot de passe en clair.
+	* @returns le hash argon2id à persister.
+	*/
+	async hash(plain) {
+		const mod = await loadArgon2();
+		return mod.hash(plain, {
+			algorithm: mod.Algorithm.Argon2id,
+			memoryCost: this.memoryKiB,
+			timeCost: this.timeCost,
+			parallelism: this.parallelism
+		});
+	}
+	/**
+	* Vérifie un mot de passe en clair contre un hash stocké (temps constant interne).
+	*
+	* Les paramètres de vérification sont LUS DANS le hash PHC (pas ceux de
+	* l'encodeur) : un hash produit avec d'anciens coûts reste vérifiable.
+	*
+	* @param plain - mot de passe fourni à la connexion.
+	* @param hash - hash argon2 stocké.
+	* @returns `true` si la correspondance est valide.
+	*/
+	async verify(plain, hash) {
+		return (await loadArgon2()).verify(hash, plain);
+	}
+	/**
+	* Indique si un hash doit être recalculé : format non argon2, variant non
+	* `id`, version antérieure à 0x13, ou coûts stockés INFÉRIEURS aux coûts
+	* courants (politique affaiblie). Des coûts supérieurs ne déclenchent pas de
+	* re-hash (jamais de downgrade silencieux).
+	*
+	* @param hash - hash stocké à inspecter.
+	* @returns `true` si un re-hash est recommandé au prochain login réussi.
+	*/
+	needsRehash(hash) {
+		const match = ARGON2_HASH_RE.exec(hash);
+		if (match === null) return true;
+		if (match[1] !== "id") return true;
+		if (Number.parseInt(match[2], 10) < ARGON2_VERSION) return true;
+		const m = Number.parseInt(match[3], 10);
+		const t = Number.parseInt(match[4], 10);
+		return m < this.memoryKiB || t < this.timeCost;
+	}
+};
+//#endregion
+export { Argon2idEncoder };