@nodefony/security 10.0.0-alpha.1

package/dist/nodefony/service/auditService.js

@@ -0,0 +1,145 @@
+import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { getAuditStoreFactory, listAuditStores } from "../src/audit/auditStoreRegistry.js";
+import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Service, readStoreLocation, resolveAutoStore } from "nodefony";
+import { randomBytes } from "node:crypto";
+//#region nodefony/service/auditService.ts
+const serviceName = "auditService";
+const GC_INTERVAL_MS = 36e5;
+/**
+* Journal d'audit de sécurité (P6.14) — collecte les **événements** de sécurité
+* (login, refus d'accès, jeton émis/révoqué, défense CSRF/CORS, verrou WS) émis
+* EXPLICITEMENT par le firewall, les authenticators et les controllers. Distinct
+* du log de trafic (`JsonAuditLogger`, P3.1, 1 PDU/requête) : ici on trace les
+* **transitions d'état** de sécurité, jamais le hot-path par requête.
+*
+* Propriétaire du {@link IAuditStore} (référence mémoire append-only) : le pose au
+* container (`auditStore`, consommé par le data plane P6.15) et arme le `gc` de
+* rétention (timer `unref`). Implémente {@link IAuditSink} — `record` est
+* **fire-and-forget** (jamais bloquant) et **no-op à coût nul** si désactivé.
+*
+* Slot : store **pluggable** (ORM/Loki, multi-pod) = lot futur, comme
+* `tokenStoreRegistry`. Le socle n'embarque que la référence mémoire.
+*/
+var AuditService = class extends Service {
+	module;
+	#store = null;
+	#enabled = false;
+	/** Abonnés au flux live — `null` tant qu'aucun (lazy, règle hooks). */
+	#listeners = null;
+	/** Préfixe d'id unique au process (1 seul `randomBytes` au boot) + compteur. */
+	#idPrefix = "";
+	#seq = 0;
+	#gc = null;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options);
+		this.module = module;
+		this.kernel?.once("onBoot", () => this.#build());
+		this.kernel?.once("onTerminate", () => this.#shutdown());
+	}
+	#build() {
+		let config;
+		try {
+			config = defineSecurityConfig(this.options);
+		} catch {
+			return;
+		}
+		if (!config.audit.enabled) {
+			this.log("audit service idle — désactivé par la config", "DEBUG");
+			return;
+		}
+		let storeName = config.audit.store;
+		let reason = `store explicitement configuré ("${storeName}")`;
+		if (storeName === AUTO_STORE) {
+			const auto = resolveAutoStore("durable", this.kernel?.infra ?? EMPTY_INFRA, listAuditStores());
+			storeName = auto.store;
+			reason = auto.reason;
+			this.log(`audit.store "auto" → "${storeName}" (${auto.reason})`, "INFO");
+		}
+		const factory = getAuditStoreFactory(storeName);
+		if (!factory) {
+			const msg = `audit store "${storeName}" inconnu (enregistrés : ${listAuditStores().join(", ") || "aucun"})`;
+			if (this.kernel?.environment === "production") throw new Error(`${msg} — journal de sécurité non collecté : boot avorté.`);
+			this.log(`${msg} — audit désactivé (journal de sécurité non collecté)`, "CRITIC");
+			return;
+		}
+		if (storeName === "memory" && this.kernel?.environment === "production") this.log("audit.store \"memory\" en PRODUCTION — journal de sécurité volatil et per-pod : perdu au redémarrage, invisible des autres pods, rétention de conformité impossible. Déclarer une infra durable (NF_DATABASE_URL).", "WARNING");
+		this.#enabled = true;
+		this.#idPrefix = randomBytes(4).toString("hex");
+		this.#store = factory({
+			container: this.container,
+			config
+		});
+		this.container?.set("auditStore", this.#store);
+		this.kernel?.registerStoreResolution({
+			brick: "audit",
+			nature: "durable",
+			configured: config.audit.store,
+			resolved: storeName,
+			available: listAuditStores(),
+			reason,
+			configPath: "security.audit.store",
+			location: readStoreLocation(this.#store)
+		});
+		this.#gc = new GcScheduler({
+			intervalS: GC_INTERVAL_MS / 1e3,
+			jitter: true,
+			run: async () => {
+				const purged = await this.#store?.gc();
+				if (purged && purged > 0) this.log(`audit gc — ${purged} événement(s) purgé(s)`, "DEBUG");
+			},
+			onError: (e) => this.log(e, "WARNING")
+		});
+		this.#gc.start();
+		this.log(`audit service ready — store "${config.audit.store}", rétention ${config.audit.retentionDays}j`, "DEBUG");
+	}
+	#shutdown() {
+		this.#gc?.stop();
+		this.#gc = null;
+		this.#listeners = null;
+		this.#store = null;
+		this.#enabled = false;
+	}
+	record(draft) {
+		if (!this.#enabled || this.#store === null) return;
+		const event = {
+			...draft,
+			id: `${this.#idPrefix}-${(this.#seq++).toString(36)}`,
+			ts: Date.now()
+		};
+		this.#store.append(event).catch((error) => this.log(error, "ERROR"));
+		if (this.#listeners !== null) for (let i = 0; i < this.#listeners.length; i++) try {
+			this.#listeners[i](event);
+		} catch (error) {
+			this.log(error, "ERROR");
+		}
+	}
+	subscribe(listener) {
+		if (this.#listeners === null) this.#listeners = [];
+		this.#listeners.push(listener);
+		let active = true;
+		return () => {
+			if (!active || this.#listeners === null) return;
+			active = false;
+			const idx = this.#listeners.indexOf(listener);
+			if (idx >= 0) this.#listeners.splice(idx, 1);
+			if (this.#listeners.length === 0) this.#listeners = null;
+		};
+	}
+	/** Lit une page du journal (délègue au store) ; vide si l'audit est inactif. */
+	listPage(query) {
+		if (this.#store === null) return Promise.resolve({
+			items: [],
+			limit: query.limit,
+			hasNext: false,
+			nextCursor: null,
+			total: 0
+		});
+		return this.#store.listPage(query);
+	}
+	/** `true` si l'audit est actif (config `audit.enabled`). */
+	isEnabled() {
+		return this.#enabled;
+	}
+};
+//#endregion
+export { AuditService as default };

package/dist/nodefony/service/authFlow.js

@@ -0,0 +1,332 @@
+import { AuthenticationError } from "../errors/AuthenticationError.js";
+import { ThrottledError } from "../errors/ThrottledError.js";
+import { resolveSessionIdentity } from "../src/sessionIdentity.js";
+import { recordAudit } from "../src/audit/recordAudit.js";
+import { readAuditContext } from "../src/audit/readAuditContext.js";
+import { RequestContext, Service } from "nodefony";
+//#region nodefony/service/authFlow.ts
+const serviceName = "authFlow";
+const INVALID_CREDENTIALS = "Invalid credentials";
+const PENDING_MFA_KEY = "mfa:pending";
+/**
+* Flux de session BFF — login/logout/me côté serveur (P6 J3).
+*
+* C'est le GUICHET : le credential est présenté UNE fois (`login`), vérifié par
+* le {@link IPasswordVerifier} (hash, leurre anti-timing, re-hash migration),
+* puis remplacé par un cookie de session opaque `HttpOnly` — le mot de passe ne
+* recircule jamais, le navigateur ne stocke aucun token lisible par JS.
+*
+* Anti session-fixation (OWASP) : l'ID de session est TOUJOURS régénéré au
+* login — un ID pré-posé par un attaquant (cookie forcé avant le guichet) ne
+* survit pas à l'authentification ; l'ancienne entrée storage est détruite.
+*
+* Throttling NIST SP 800-63B : le MÊME `LoginThrottler` que la porte Basic
+* (instance partagée via le container, posée par le firewall au boot) — un
+* attaquant ne contourne pas le backoff en changeant de porte.
+*
+* Les handlers HTTP (`SessionAuthController`, `@nodefony/framework`) sont des
+* adaptateurs minces au-dessus de ce service — la logique reste testable sans
+* transport.
+*/
+var AuthFlow = class extends Service {
+	module;
+	#users = null;
+	#sessions = null;
+	#throttler = null;
+	#throttlerResolved = false;
+	#totp = null;
+	#totpResolved = false;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options);
+		this.module = module;
+	}
+	/**
+	* Authentifie le couple identifiant/mot de passe et OUVRE la session BFF.
+	*
+	* Ordre NIST : throttle AVANT le verifier (un identifiant bloqué ne coûte
+	* aucun hash argon2 — le backoff protège aussi le serveur du DoS), échec
+	* compté, succès remis à zéro.
+	*
+	* @param context - contexte HTTP courant (porte la session/le cookie).
+	* @param identifier - identifiant saisi (body JSON, non typé à la frontière).
+	* @param password - mot de passe saisi.
+	* @returns `authenticated` (identité établie) ou `mfa_required` (2ᵉ facteur requis).
+	* @throws ThrottledError (429 + `Retry-After`) — backoff actif.
+	* @throws AuthenticationError (401, message uniforme) — credential absent ou
+	*   invalide.
+	*/
+	async login(context, identifier, password) {
+		const info = readAuditContext(context);
+		const who = typeof identifier === "string" ? identifier : null;
+		if (typeof identifier !== "string" || identifier.length === 0 || typeof password !== "string" || password.length === 0) {
+			recordAudit(this.container, {
+				category: "auth",
+				action: "login.failure",
+				outcome: "failure",
+				actor: who,
+				reason: "invalid_credentials",
+				...info
+			});
+			throw new AuthenticationError(INVALID_CREDENTIALS);
+		}
+		const throttler = this.#resolveThrottler();
+		if (throttler !== null) {
+			const retryAfterS = throttler.check(identifier);
+			if (retryAfterS > 0) {
+				recordAudit(this.container, {
+					category: "auth",
+					action: "login.throttled",
+					outcome: "failure",
+					actor: identifier,
+					reason: "throttled",
+					...info
+				});
+				throw new ThrottledError(retryAfterS);
+			}
+		}
+		const user = await this.#resolveUsers().authenticate(identifier, password);
+		if (user === null) {
+			throttler?.recordFailure(identifier);
+			recordAudit(this.container, {
+				category: "auth",
+				action: "login.failure",
+				outcome: "failure",
+				actor: identifier,
+				reason: "invalid_credentials",
+				...info
+			});
+			throw new AuthenticationError(INVALID_CREDENTIALS);
+		}
+		throttler?.recordSuccess(identifier);
+		const totp = this.#resolveTotp();
+		if (totp && await totp.isEnabledFor(user.identifier)) {
+			const session = await this.ensureSession(context);
+			session?.set(PENDING_MFA_KEY, user.identifier);
+			await session?.save();
+			recordAudit(this.container, {
+				category: "auth",
+				action: "login.mfa_required",
+				outcome: "success",
+				actor: user.identifier,
+				reason: "totp",
+				...info
+			});
+			return {
+				status: "mfa_required",
+				methods: ["totp"]
+			};
+		}
+		await this.#openSession(context, user.identifier);
+		context.user = user.identifier;
+		RequestContext.set("user", user);
+		recordAudit(this.container, {
+			category: "auth",
+			action: "login.success",
+			outcome: "success",
+			actor: user.identifier,
+			...info
+		});
+		return {
+			status: "authenticated",
+			user: toSafeUser(user)
+		};
+	}
+	/**
+	* Ouvre la session BFF pour un utilisateur **déjà authentifié par un autre
+	* facteur** (passkey/WebAuthn, OAuth, magic link…) — aucun mot de passe à
+	* vérifier ici, la preuve a été apportée en amont par l'appelant.
+	*
+	* Même anti-fixation que {@link login} (ID régénéré, ancienne entrée
+	* détruite). L'identité est re-résolue + revalidée (compte actif/non
+	* verrouillé) via la source unique `resolveSessionIdentity` — un compte banni
+	* entre la preuve et l'ouverture de session est rejeté.
+	*
+	* @param identifier - identifiant de l'utilisateur prouvé (ex. `sub` du credential).
+	* @throws AuthenticationError (401, message uniforme) — identifiant absent, ou
+	*   compte disparu/inactif/verrouillé.
+	*/
+	async establishSessionFor(context, identifier, reason = "federated") {
+		if (typeof identifier !== "string" || identifier.length === 0) throw new AuthenticationError(INVALID_CREDENTIALS);
+		const user = await resolveSessionIdentity(this.#resolveUsers(), identifier);
+		await this.#openSession(context, user.identifier);
+		context.user = user.identifier;
+		RequestContext.set("user", user);
+		recordAudit(this.container, {
+			category: "auth",
+			action: "login.success",
+			outcome: "success",
+			actor: user.identifier,
+			reason,
+			...readAuditContext(context)
+		});
+		return toSafeUser(user);
+	}
+	/**
+	* Valide le **second facteur** (code TOTP ou code de récupération) après un
+	* `login` ayant renvoyé `mfa_required`, puis OUVRE la session BFF. Le défi
+	* PENDING déposé en session par `login` est lu, vérifié, puis invalidé (usage
+	* unique) ; l'identité n'est établie qu'ICI. **Throttlé** sur l'identité en
+	* attente (anti brute-force du code à 6 chiffres).
+	*
+	* @param context - contexte HTTP (porte la session PENDING).
+	* @param code - code présenté (TOTP ou code de récupération).
+	* @returns la projection publique de l'utilisateur authentifié.
+	* @throws ThrottledError (429) — trop de tentatives.
+	* @throws AuthenticationError (401, uniforme) — aucun défi en cours, code absent
+	*   ou invalide (la session N'est PAS ouverte ; le défi reste pour un retry).
+	*/
+	async completeMfaLogin(context, code) {
+		const info = readAuditContext(context);
+		const pending = context.session?.get(PENDING_MFA_KEY);
+		if (typeof pending !== "string" || pending.length === 0) throw new AuthenticationError(INVALID_CREDENTIALS);
+		const throttler = this.#resolveThrottler();
+		if (throttler !== null) {
+			const retryAfterS = throttler.check(pending);
+			if (retryAfterS > 0) {
+				recordAudit(this.container, {
+					category: "auth",
+					action: "login.throttled",
+					outcome: "failure",
+					actor: pending,
+					reason: "throttled",
+					...info
+				});
+				throw new ThrottledError(retryAfterS);
+			}
+		}
+		const totp = this.#resolveTotp();
+		const result = typeof code === "string" && code.length > 0 && totp ? await totp.verifyLogin(pending, code) : {
+			ok: false,
+			method: void 0
+		};
+		if (!result.ok) {
+			throttler?.recordFailure(pending);
+			recordAudit(this.container, {
+				category: "auth",
+				action: "login.failure",
+				outcome: "failure",
+				actor: pending,
+				reason: "mfa_invalid",
+				...info
+			});
+			throw new AuthenticationError(INVALID_CREDENTIALS);
+		}
+		throttler?.recordSuccess(pending);
+		context.session?.set(PENDING_MFA_KEY, null);
+		return this.establishSessionFor(context, pending, result.method ?? "totp");
+	}
+	/**
+	* Garantit une session pour la requête courante — la démarre (+ cookie) si
+	* elle n'existe pas encore. Sert aux cérémonies **pré-authentification**
+	* (login WebAuthn) : elles doivent porter un challenge côté serveur AVANT que
+	* l'utilisateur soit connecté. La session anonyme ainsi créée devient la
+	* session authentifiée au login — {@link establishSessionFor} régénère l'ID
+	* (anti-fixation préservée), donc un challenge déposé ici n'ouvre aucune brèche.
+	*
+	* @returns la session (existante ou neuve), ou `null` si le service de session
+	*   est indisponible.
+	*/
+	async ensureSession(context) {
+		if (context.session) return context.session;
+		return this.#resolveSessions().start(context);
+	}
+	/**
+	* Détruit la session courante (storage + cookie). Idempotent : sans session
+	* active, ne fait rien.
+	*
+	* @returns `true` si une session a réellement été détruite.
+	*/
+	async logout(context) {
+		const session = context.session;
+		if (!session || session.status !== "active") return false;
+		const actor = typeof session.user === "string" ? session.user : null;
+		await session.destroy(true);
+		context.session = null;
+		context.user = null;
+		recordAudit(this.container, {
+			category: "session",
+			action: "logout",
+			outcome: "success",
+			actor,
+			...readAuditContext(context)
+		});
+		return true;
+	}
+	/**
+	* Identité portée par la session courante, re-résolue auprès du provider
+	* (mêmes contrôles que le `SessionAuthenticator` — source unique).
+	*
+	* @returns la projection publique, ou `null` (pas de session, session
+	*   orpheline, compte verrouillé/désactivé) — le handler répond 401.
+	*/
+	async me(context) {
+		const identifier = context.session?.user;
+		if (typeof identifier !== "string" || identifier.length === 0) return null;
+		try {
+			return toSafeUser(await resolveSessionIdentity(this.#resolveUsers(), identifier));
+		} catch (error) {
+			if (error instanceof AuthenticationError) return null;
+			throw error;
+		}
+	}
+	async #openSession(context, identifier) {
+		const session = context.session ?? await this.#resolveSessions().start(context);
+		if (session === null) {
+			this.log("login: session service returned no session", "ERROR");
+			throw new AuthenticationError(INVALID_CREDENTIALS);
+		}
+		const oldId = session.id;
+		session.regenerateId();
+		try {
+			await session.storage.destroy(oldId);
+		} catch {}
+		const provenance = context;
+		try {
+			const ip = provenance.getRemoteAddress?.();
+			if (ip) session.setMetaBag("ip", ip);
+			const ua = provenance.getUserAgent?.();
+			if (ua) session.setMetaBag("ua", ua);
+		} catch {}
+		await session.save(identifier);
+	}
+	#resolveSessions() {
+		if (this.#sessions === null) {
+			const sessions = this.get("sessions");
+			if (!sessions) throw new Error("AuthFlow: aucun service \"sessions\" dans le container — le module @nodefony/http doit être chargé avant @nodefony/security.");
+			this.#sessions = sessions;
+		}
+		return this.#sessions;
+	}
+	#resolveUsers() {
+		if (this.#users === null) {
+			const users = this.get("users");
+			if (!users) throw new Error("AuthFlow: aucun service \"users\" (IPasswordVerifier & IUserProvider) dans le container — enregistrer un UserService au boot de l'application.");
+			this.#users = users;
+		}
+		return this.#users;
+	}
+	#resolveThrottler() {
+		if (!this.#throttlerResolved) {
+			this.#throttler = this.get("loginThrottler") ?? null;
+			this.#throttlerResolved = true;
+		}
+		return this.#throttler;
+	}
+	#resolveTotp() {
+		if (!this.#totpResolved) {
+			const svc = this.get("totp") ?? null;
+			this.#totp = svc && svc.isEnabled() ? svc : null;
+			this.#totpResolved = true;
+		}
+		return this.#totp;
+	}
+};
+function toSafeUser(user) {
+	return {
+		id: user.id,
+		username: user.identifier,
+		roles: [...user.roles]
+	};
+}
+//#endregion
+export { AuthFlow, AuthFlow as default };

package/dist/nodefony/service/authorization.js

@@ -0,0 +1,95 @@
+import { recordAudit } from "../src/audit/recordAudit.js";
+import "../contracts/IAccessVoter.js";
+import { listVoterFactories } from "../src/voter/voterRegistry.js";
+import { Service, logColor } from "nodefony";
+//#region nodefony/service/authorization.ts
+const serviceName = "authorization";
+/**
+* Service d'autorisation Nodefony (niveau C, P6 J6) — décide d'un accès via un
+* jury de {@link IAccessVoter}.
+*
+* Stratégie **affirmative + DENY veto** : un seul `DENY` bloque (veto) ; sinon un
+* `GRANT` suffit ; **silence total** (tous `ABSTAIN`, ou aucun voter compétent)
+* → `DENY` (**Zero Trust** : fermé par défaut). Tout refus est audité (WARNING) ;
+* les accès accordés restent silencieux (pas de spam — l'audit d'octroi explicite
+* viendra avec `@AuditLog`, P6.14).
+*
+* Les voters sont découverts au boot via le `voterRegistry` (built-in `role` +
+* ceux des apps/plugins) — aucun nom en dur ici. Consommé par les décorateurs
+* (`@IsGranted`, J7) et le verrou de frame WS (« 1 garde = N transports »).
+*
+* Perf : aucune allocation par appel (`decide` itère les voters et teste
+* `supports()` en place) ; les voters sont instanciés UNE fois au boot.
+*/
+var Authorization = class extends Service {
+	module;
+	#voters = null;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options);
+		this.module = module;
+		this.kernel?.once("onBoot", () => this.#build());
+	}
+	#build() {
+		const list = [];
+		const ctx = { container: this.container };
+		for (const [, factory] of listVoterFactories()) list.push(factory(ctx));
+		this.#voters = list;
+		this.log(`Authorization ready — ${list.length} voter(s)`, "DEBUG");
+		return list;
+	}
+	/**
+	* Le token a-t-il le droit `attribute` sur `subject` ? Affirmative + DENY veto,
+	* défaut `DENY` (Zero Trust). Voir {@link IAuthorizationService.decide}.
+	*/
+	async decide(token, attribute, subject) {
+		const voters = this.#voters ?? this.#build();
+		let granted = false;
+		let considered = 0;
+		for (let i = 0; i < voters.length; i++) {
+			const voter = voters[i];
+			if (!voter.supports(attribute, subject)) continue;
+			considered++;
+			let vote;
+			try {
+				vote = await voter.vote(token, attribute, subject);
+			} catch (error) {
+				this.log(error, "ERROR");
+				this.#auditDeny(token, attribute, subject, "error");
+				return false;
+			}
+			if (vote === "DENY") {
+				this.#auditDeny(token, attribute, subject, "veto");
+				return false;
+			}
+			if (vote === "GRANT") granted = true;
+		}
+		if (!granted) this.#auditDeny(token, attribute, subject, considered === 0 ? "no-voter" : "abstain");
+		return granted;
+	}
+	#auditDeny(token, attribute, subject, reason) {
+		const who = token.getUserIdentifier();
+		const on = subject === void 0 ? "" : ` on ${describeSubject(subject)}`;
+		this.log(`access denied: "${who}" → "${attribute}"${on} (${reason})`, "WARNING");
+		recordAudit(this.container, {
+			category: "authz",
+			action: "access.denied",
+			outcome: "denied",
+			actor: who,
+			resource: attribute,
+			reason,
+			metadata: subject === void 0 ? void 0 : { subject: describeSubject(subject) }
+		});
+	}
+	log(pci, severity, msgid, msg) {
+		if (!msgid) msgid = logColor.cyan("AUTHORIZATION");
+		return super.log(pci, severity, msgid, msg);
+	}
+};
+/** Descripteur léger d'un sujet pour l'audit (jamais de JSON.stringify aveugle). */
+function describeSubject(subject) {
+	if (typeof subject === "string") return subject;
+	if (subject === null) return "null";
+	return subject?.constructor?.name ?? typeof subject;
+}
+//#endregion
+export { Authorization, Authorization as default };

package/dist/nodefony/service/cors.js

@@ -0,0 +1,81 @@
+//#region nodefony/service/cors.ts
+/**
+* Politique CORS de Nodefony — Same-Origin Policy assouplie côté serveur
+* (Fetch Standard / W3C CORS protocol). Logique PURE et synchrone : décide les
+* en-têtes `Access-Control-*` à poser pour une origine donnée. Instanciée une
+* fois au boot par le firewall, testable sans serveur.
+*
+* Invariants de sécurité (OWASP) :
+* - **Jamais `*` + credentials** : interdit au boot (refine Zod). Ici, `*` n'est
+*   émis QUE si `credentials=false` ; avec credentials, l'origine est reflétée.
+* - **Reflet d'origine ⇒ `Vary: Origin`** : signalé via {@link reflectsOrigin}
+*   pour que l'appelant pose l'en-tête `Vary` (correction de cache).
+* - **Origine non whitelistée ⇒ aucun en-tête** : la réponse n'est pas partageable
+*   (le navigateur bloque), zéro information divulguée.
+*
+* @see Fetch Standard (CORS protocol) · OWASP CORS.
+*/
+var Cors = class {
+	#origins;
+	#wildcard;
+	#credentials;
+	#methods;
+	#allowedHeaders;
+	#exposedHeaders;
+	#maxAge;
+	constructor(options) {
+		this.#origins = new Set(options.origins);
+		this.#wildcard = options.origins.includes("*");
+		this.#credentials = options.credentials;
+		this.#methods = options.methods.join(", ");
+		this.#allowedHeaders = options.allowedHeaders.join(", ");
+		this.#exposedHeaders = options.exposedHeaders.join(", ");
+		this.#maxAge = String(options.maxAgeS);
+	}
+	/**
+	* Valeur de `Access-Control-Allow-Origin` pour cette origine, ou `null` si
+	* l'origine n'est pas autorisée. `*` seulement en l'absence de credentials
+	* (sinon l'origine est reflétée — `*` + credentials est refusé par le navigateur).
+	*/
+	#allowOrigin(origin) {
+		if (this.#wildcard) return this.#credentials ? origin : "*";
+		return this.#origins.has(origin) ? origin : null;
+	}
+	/** `true` si la valeur Allow-Origin reflète l'origine (⇒ l'appelant doit poser `Vary: Origin`). */
+	reflectsOrigin(allowOrigin) {
+		return allowOrigin !== "*";
+	}
+	/**
+	* En-têtes d'une réponse au **preflight** `OPTIONS` (méthodes/headers autorisés
+	* + cache + credentials), ou `null` si l'origine n'est pas autorisée (réponse
+	* 204 nue → le navigateur bloque).
+	*/
+	preflightHeaders(origin) {
+		const allow = this.#allowOrigin(origin);
+		if (allow === null) return null;
+		const h = {
+			"Access-Control-Allow-Origin": allow,
+			"Access-Control-Allow-Methods": this.#methods,
+			"Access-Control-Allow-Headers": this.#allowedHeaders,
+			"Access-Control-Max-Age": this.#maxAge
+		};
+		if (this.reflectsOrigin(allow)) h["Vary"] = "Origin";
+		if (this.#credentials) h["Access-Control-Allow-Credentials"] = "true";
+		return h;
+	}
+	/**
+	* En-têtes d'une réponse à une **requête réelle** cross-origin (Allow-Origin +
+	* credentials + headers exposés au JS), ou `null` si l'origine n'est pas autorisée.
+	*/
+	actualHeaders(origin) {
+		const allow = this.#allowOrigin(origin);
+		if (allow === null) return null;
+		const h = { "Access-Control-Allow-Origin": allow };
+		if (this.reflectsOrigin(allow)) h["Vary"] = "Origin";
+		if (this.#credentials) h["Access-Control-Allow-Credentials"] = "true";
+		if (this.#exposedHeaders) h["Access-Control-Expose-Headers"] = this.#exposedHeaders;
+		return h;
+	}
+};
+//#endregion
+export { Cors, Cors as default };