@nodefony/security 10.0.0-beta.5 → 10.0.0-beta.7

package/dist/nodefony/src/csp.js

@@ -1,5 +1,138 @@
+import { BootConfigurationError } from "nodefony";
 // nodefony/src/csp.ts
 /**
+* Fusion de directives Content-Security-Policy — logique PURE (aucune dépendance
+* à Vite, au frontend ni au transport). Permet à un module de DÉCLARER ses besoins
+* CSP (ex. `@nodefony/frontend` en dev : origines Vite + `'unsafe-eval'` pour le
+* Fast Refresh) sans que `@nodefony/security` connaisse leur sémantique : security
+* se contente de MERGER des fragments génériques `directive → sources`.
+*
+* Pourquoi un merge structuré (et pas une simple concaténation) : en CSP une
+* directive RÉPÉTÉE est ignorée après sa 1ʳᵉ occurrence (W3C CSP3 §3) → concaténer
+* deux `script-src` perdrait le second. Il faut fusionner les sources dans UNE
+* directive. Le token `'nonce-{{nonce}}'` est opaque (ni `;` ni espace) → préservé
+* tel quel par parse/serialize.
+*/
+const DIRECTIVE_NAME = /^[A-Za-z0-9-]+$/;
+const SOURCE_TOKEN = /^[\x21-\x2B\x2D-\x3A\x3C-\x7E]+$/;
+const SCHEME_SOURCE = /^[A-Za-z][A-Za-z0-9+.-]*:$/;
+const HOST_OF_SOURCE = /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/)?([^/:]+)/;
+const LOCAL_SCHEMES = /* @__PURE__ */ new Set([
+	"data:",
+	"blob:",
+	"filesystem:",
+	"mediastream:"
+]);
+const SCRIPT_DIRECTIVES = /* @__PURE__ */ new Set([
+	"script-src",
+	"script-src-elem",
+	"script-src-attr"
+]);
+/**
+* Dit si une source CSP ouvre la directive à n'importe quel contenu.
+*
+* Trop large : `*`, un schéma réseau nu (`https:`, `wss:`…), un hôte joker seul
+* (`https://*`, `*:443`). Restent acceptés : une origine exacte, un joker de
+* sous-domaine borné (`https://*.example.com`), un mot-clé (`'self'`) et les
+* schémas locaux (`blob:`, `data:`) — SAUF dans une directive de scripts :
+* `data:` y exécute le code porté par l'URL, `blob:` celui qu'un script a
+* fabriqué, et sans nonce c'est une injection de script.
+*
+* @param source - un jeton de source CSP.
+* @param directive - la directive qui porte la source ; sans elle, les schémas
+*   locaux sont acceptés.
+* @returns `true` si la source autorise n'importe quel hôte ou contenu.
+*/
+function isOverbroadSource(source, directive) {
+	if (source.startsWith("'")) return false;
+	if (SCHEME_SOURCE.test(source)) {
+		if (directive !== void 0 && SCRIPT_DIRECTIVES.has(directive.toLowerCase())) return true;
+		return !LOCAL_SCHEMES.has(source.toLowerCase());
+	}
+	return HOST_OF_SOURCE.exec(source)?.[1] === "*";
+}
+/**
+* Retire d'un fragment de MODULE ses sources trop larges (cf {@link isOverbroadSource}).
+*
+* Moindre privilège : une contribution GLOBALE (`Firewall.registerCspOrigins`)
+* ne déclare que SON origine, et n'ouvre pas la politique de toute l'application.
+* Retirer plutôt que lever : la sécurité ne bloque pas le démarrage. Ne
+* s'applique PAS à ce que l'application écrit elle-même (sa config, un `@Csp` de
+* route) : un choix délibéré de son auteur n'est jamais contourné en silence.
+*
+* @param fragment - directives déclarées par un module.
+* @returns le fragment sans les sources trop larges, et les paires retirées.
+*/
+function withoutOverbroadSources(fragment) {
+	const dropped = findOverbroadSources(Object.entries(fragment));
+	if (dropped.length === 0) return {
+		fragment,
+		dropped
+	};
+	const kept = {};
+	for (const name in fragment) {
+		const sources = (fragment[name] ?? []).filter((s) => !isOverbroadSource(s, name));
+		if (sources.length > 0) kept[name] = sources;
+	}
+	return {
+		fragment: kept,
+		dropped
+	};
+}
+/**
+* Relève les sources trop larges d'un jeu de directives (cf {@link isOverbroadSource}).
+*
+* @param directives - paires `[directive, sources]` (`parseCsp(csp)` ou `Object.entries(fragment)`).
+* @returns les paires `[directive, source]` trop larges, dans l'ordre de lecture.
+*/
+function findOverbroadSources(directives) {
+	const out = [];
+	for (const [name, sources] of directives) for (const source of sources) if (isOverbroadSource(source, name)) out.push([name, source]);
+	return out;
+}
+/**
+* Relève les sources de scripts d'un fragment que `'strict-dynamic'` rend inertes.
+*
+* Sous `'strict-dynamic'` dans `script-src`, un navigateur CSP3 ignore les hôtes
+* et les schémas : un script n'est admis que signé, ou chargé par un script
+* signé (W3C CSP3 § « strict-dynamic »). La source reste utile à un navigateur
+* CSP2 ; on la garde, mais son auteur doit savoir qu'elle n'ouvre rien.
+*
+* @param fragment - directives déclarées par un module.
+* @param policy - politique à laquelle le fragment s'ajoute.
+* @returns les paires `[directive, source]` inertes ; vide sans `'strict-dynamic'`.
+*/
+function findInertScriptSources(fragment, policy) {
+	const out = [];
+	let strictDynamic = null;
+	for (const name in fragment) {
+		if (!SCRIPT_DIRECTIVES.has(name.toLowerCase())) continue;
+		strictDynamic ??= parseCsp(policy).some(([n, sources]) => n.toLowerCase() === "script-src" && sources.includes("'strict-dynamic'"));
+		if (!strictDynamic) return out;
+		for (const source of fragment[name] ?? []) if (!source.startsWith("'")) out.push([name, source]);
+	}
+	return out;
+}
+/**
+* Refuse un fragment CSP qui sortirait de la grammaire CSP3 — seule garde contre
+* l'injection de directives par une valeur de configuration.
+*
+* Sans elle, une source comme `https://a.example; frame-src *` ajoute une
+* directive que personne n'a demandée, et `https://a.example, frame-src *` coupe
+* l'en-tête en deux politiques. Appelée là où un fragment ENTRE (enregistrement
+* d'un module, fusion d'une route `@Csp`), jamais par requête.
+*
+* @param fragment - directives additionnelles (`directive → sources`).
+* @param origin - qui déclare le fragment, pour nommer la faute.
+* @throws BootConfigurationError si un nom ou une source sort de la grammaire.
+*/
+function assertCspFragment(fragment, origin) {
+	for (const name in fragment) {
+		if (!DIRECTIVE_NAME.test(name)) throw new BootConfigurationError(`[@nodefony/security] CSP refusée (${origin}) — nom de directive invalide ${JSON.stringify(name)} : lettres, chiffres et « - » seulement (W3C CSP3 §2.2).`);
+		for (const source of fragment[name] ?? []) if (!SOURCE_TOKEN.test(source)) throw new BootConfigurationError(`[@nodefony/security] CSP refusée (${origin}) — source invalide ${JSON.stringify(source)} dans « ${name} » : ni espace, ni « ; », ni « , », ni caractère de contrôle (W3C CSP3 §2.2). Une source = une origine ou un mot-clé ; déclarer plusieurs sources = plusieurs entrées du tableau.`);
+	}
+}
+/**
 * Parse une chaîne CSP en directives ordonnées `[nom, sources[]]`. L'ordre des
 * directives et des sources est préservé (déterminisme : header stable, tests
 * fiables). Les séparateurs multiples / espaces superflus sont normalisés.
@@ -28,25 +161,147 @@ function serializeCsp(directives) {
 * origines (jamais par requête). Le résultat repart dans `SecurityHeaders`, qui
 * re-split autour de `{{nonce}}` au boot → 1 `join` par requête (hot-path inchangé).
 *
+* Chaque fragment passe {@link assertCspFragment} : une source hors grammaire
+* lève au lieu d'injecter une directive. Aucune source n'est retirée ici : le
+* filtre des sources trop larges ne vise que les contributions globales des
+* modules ({@link withoutOverbroadSources}, appliqué à l'enregistrement).
+*
 * @param base - CSP de configuration (peut contenir `'nonce-{{nonce}}'`).
 * @param fragments - fragments additifs (un par module enregistré).
 * @returns la chaîne CSP fusionnée.
+* @throws BootConfigurationError si un fragment sort de la grammaire CSP3.
 */
 function mergeCspFragments(base, fragments) {
 	const directives = parseCsp(base);
 	const index = /* @__PURE__ */ new Map();
 	for (const [name, src] of directives) index.set(name, src);
-	for (const fragment of fragments) for (const name in fragment) {
-		const additions = fragment[name];
-		if (additions === void 0 || additions.length === 0) continue;
-		let sources = index.get(name);
-		if (!sources) {
-			sources = [];
-			index.set(name, sources);
-			directives.push([name, sources]);
+	for (const fragment of fragments) {
+		assertCspFragment(fragment, "fusion");
+		for (const name in fragment) {
+			const additions = fragment[name];
+			if (additions === void 0 || additions.length === 0) continue;
+			let sources = index.get(name);
+			if (!sources) {
+				sources = [];
+				index.set(name, sources);
+				directives.push([name, sources]);
+			}
+			for (const src of additions) if (!sources.includes(src)) sources.push(src);
 		}
-		for (const src of additions) if (!sources.includes(src)) sources.push(src);
 	}
 	return serializeCsp(directives);
 }
-export { mergeCspFragments, parseCsp, serializeCsp };
+/** Directive réservée aux réponses servies en TLS (ADR-0024 §C6). */
+const UPGRADE_INSECURE_REQUESTS = "upgrade-insecure-requests";
+/**
+* Retire une directive d'une politique, sans toucher au reste.
+*
+* Sert à composer, au démarrage, la variante EN CLAIR d'une politique qui porte
+* `upgrade-insecure-requests` : sur une page servie en `http`, la directive
+* réécrirait chaque sous-ressource en `https`, que le serveur ne sert pas.
+*
+* @param csp - politique (peut contenir `'nonce-{{nonce}}'`).
+* @param name - nom de la directive, insensible à la casse.
+* @returns la politique sans la directive ; la MÊME chaîne si elle n'y est pas.
+*/
+function withoutDirective(csp, name) {
+	const wanted = name.toLowerCase();
+	const directives = parseCsp(csp);
+	const kept = directives.filter(([n]) => n.toLowerCase() !== wanted);
+	return kept.length === directives.length ? csp : serializeCsp(kept);
+}
+/**
+* Traduit la valeur de `X-Frame-Options` en source de `frame-ancestors`.
+*
+* Un seul réglage, `http.securityHeaders.frameOptions`, pilote les DEUX en-têtes :
+* un navigateur CSP ignore `X-Frame-Options` dès que `frame-ancestors` est
+* présent (W3C CSP3 § « `frame-ancestors` »), et l'inverse vaut pour un ancien
+* navigateur. Deux réglages distincts finiraient par dire deux choses.
+*
+* @param frameOptions - valeur émise de `X-Frame-Options` (`null` = non émis).
+* @returns `'none'` pour `DENY`, `'self'` pour `SAMEORIGIN`, `null` sinon
+*   (en-tête coupé, ou valeur que `frame-ancestors` ne sait pas traduire).
+*/
+function frameAncestorsFor(frameOptions) {
+	const value = frameOptions?.trim().toUpperCase();
+	if (value === "DENY") return "'none'";
+	if (value === "SAMEORIGIN") return "'self'";
+	return null;
+}
+/**
+* Ajoute à une politique la directive `frame-ancestors` dérivée de
+* `X-Frame-Options` (cf {@link frameAncestorsFor}).
+*
+* L'application garde la main : une politique qui déclare DÉJÀ
+* `frame-ancestors` est rendue telle quelle — c'est le geste qui autorise
+* l'encadrement par une origine tierce. Une politique vide le reste (pas de CSP
+* voulue). Appelée à la composition de la politique de base, jamais par requête.
+*
+* @param csp - politique de base (config `security.headers.csp`).
+* @param frameOptions - valeur émise de `X-Frame-Options` (`null` = non émis).
+* @returns la politique, complétée de `frame-ancestors` si besoin.
+*/
+function withFrameAncestors(csp, frameOptions) {
+	const source = frameAncestorsFor(frameOptions);
+	if (source === null || csp.trim() === "") return csp;
+	for (const [name] of parseCsp(csp)) if (name.toLowerCase() === "frame-ancestors") return csp;
+	let end = csp.length;
+	while (end > 0 && (csp[end - 1] === ";" || /\s/.test(csp[end - 1] ?? ""))) end--;
+	return `${csp.slice(0, end)}; frame-ancestors ${source}`;
+}
+/**
+* Demande à une politique ses rapports de violation : `report-uri` (lu par
+* tous les navigateurs, en http comme en https) ET `report-to` (Reporting API,
+* que le navigateur n'honore que vers une origine sûre — https ou localhost).
+* ADR-0024 §C7.
+*
+* L'application garde la main : une politique qui déclare DÉJÀ `report-uri` ou
+* `report-to` est rendue telle quelle — elle a son collecteur. Une politique
+* vide le reste.
+*
+* @param csp - politique de base.
+* @param url - où poster les rapports (chemin absolu ou URL https).
+* @param group - nom du groupe `report-to`, déclaré par `Reporting-Endpoints`.
+* @returns la politique, et `added` vrai si les directives ont été posées ici —
+*   c'est alors à l'appelant d'émettre `Reporting-Endpoints`.
+*/
+function withViolationReports(csp, url, group) {
+	if (csp.trim() === "") return {
+		csp,
+		added: false
+	};
+	for (const [name] of parseCsp(csp)) {
+		const lower = name.toLowerCase();
+		if (lower === "report-uri" || lower === "report-to") return {
+			csp,
+			added: false
+		};
+	}
+	let end = csp.length;
+	while (end > 0 && (csp[end - 1] === ";" || /\s/.test(csp[end - 1] ?? ""))) end--;
+	return {
+		csp: `${csp.slice(0, end)}; report-uri ${url}; report-to ${group}`,
+		added: true
+	};
+}
+/**
+* Valide l'URL d'un collecteur de rapports écrite par l'application : un
+* chemin absolu (`/csp`) ou une URL `https:` / `http:`, sans rien qu'un en-tête
+* ou une directive CSP ne puisse porter (espace, `;`, `,`, guillemet).
+*
+* @param url - valeur de `headers.cspReport`.
+* @returns la cause du refus, ou `null` si l'URL est utilisable.
+*/
+function reportUrlProblem(url) {
+	if (url === "") return "URL vide";
+	if (/[^\x21-\x7e]|[;,"\\]/u.test(url)) return "caractère qu’un en-tête ne peut pas porter";
+	if (url.startsWith("/")) return url.startsWith("//") ? "URL relative au schéma (//)" : null;
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return "ni chemin absolu ni URL";
+	}
+	return parsed.protocol === "https:" || parsed.protocol === "http:" ? null : `schéma ${parsed.protocol} refusé`;
+}
+export { UPGRADE_INSECURE_REQUESTS, assertCspFragment, findInertScriptSources, findOverbroadSources, frameAncestorsFor, isOverbroadSource, mergeCspFragments, parseCsp, reportUrlProblem, serializeCsp, withFrameAncestors, withViolationReports, withoutDirective, withoutOverbroadSources };

package/dist/nodefony/src/cspReports.js

@@ -0,0 +1,307 @@
+import { MemoryRateLimitStore } from "@nodefony/http";
+// nodefony/src/cspReports.ts
+const MINUTE_MS = 6e4;
+const MAX_URL_LENGTH = 512;
+const MAX_USER_AGENT_LENGTH = 200;
+/** Directive ou mot-clé de la norme : minuscules et tirets, court. */
+const TOKEN = /^[a-z][a-z0-9-]{0,47}$/u;
+/** Contrôles C0, DEL et C1 — jamais dans une ligne de journal ni un affichage. */
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/gu;
+const MAX_INT = 1e7;
+/**
+* Reçoit, expurge, dédoublonne et garde EN MÉMOIRE les rapports de violation
+* CSP (ADR-0024 §C7). La porte qui les livre est publique — le navigateur
+* n'envoie aucun identifiant — donc tout ce qui entre est traité comme écrit
+* par un attaquant :
+*
+* - **quota par adresse** (fenêtre d'une minute, le limiteur de `@nodefony/http`) ;
+* - **deux types de contenu seulement** : `application/csp-report` (`report-uri`)
+*   et `application/reports+json` (`report-to`) ;
+* - **URL expurgées** de leur requête, de leur fragment et de leurs identifiants
+*   (la norme ne retire pas la requête : elle peut porter un jeton) ; une URL
+*   qui n'est pas HTTP(S) se réduit à son schéma ;
+* - **l'extrait de code n'est jamais gardé** — c'est une chaîne de l'attaquant ;
+* - **mémoire bornée** : au plus `capacity` violations distinctes, la moins
+*   récemment vue évincée d'abord ; une répétition incrémente un compteur ;
+* - **journal dédoublonné et borné** : une violation neuve y part une fois, et
+*   pas plus de `logPerMinute` lignes par minute.
+*
+* Rien n'est écrit sur disque : le journal centralisé voit déjà ce qui compte.
+*/
+var CspReportCollector = class {
+	/** URL que la politique désigne. */
+	endpoint;
+	/** Violations distinctes gardées au plus. */
+	capacity;
+	#violations = /* @__PURE__ */ new Map();
+	#limiter;
+	#log;
+	#now;
+	#logPerMinute;
+	#logWindowStart = 0;
+	#loggedInWindow = 0;
+	#silenced = 0;
+	#received = 0;
+	#rejected = 0;
+	/**
+	* @param options - URL désignée, bornes, journal, horloge.
+	*/
+	constructor(options) {
+		this.endpoint = options.endpoint;
+		this.capacity = options.capacity ?? 200;
+		this.#now = options.now ?? Date.now;
+		this.#log = options.log ?? null;
+		this.#logPerMinute = options.logPerMinute ?? 20;
+		this.#limiter = new MemoryRateLimitStore({
+			windowMs: MINUTE_MS,
+			max: options.perMinute ?? 120,
+			maxTracked: options.maxTrackedClients ?? 1e4
+		}, this.#now);
+	}
+	/**
+	* Traite un corps de rapport déjà lu (et déjà borné par l'appelant).
+	*
+	* @param contentType - type de contenu de la requête, paramètres compris ou non.
+	* @param body - le corps, octets ou texte.
+	* @param client - adresse cliente résolue (proxy de confiance compris) ;
+	*   `null` = inconnue, non comptée (jamais une clé commune à tous).
+	* @param userAgent - en-tête `User-Agent`, gardé tronqué.
+	* @returns ce que le rapport est devenu — pour le journal et les tests ;
+	*   l'émetteur reçoit 204 quoi qu'il arrive.
+	*/
+	receive(contentType, body, client, userAgent) {
+		this.#received++;
+		if (client !== null && this.#limiter.hit(client).limited) {
+			this.#rejected++;
+			return "limited";
+		}
+		const type = mediaTypeOf(contentType);
+		if (type !== "application/csp-report" && type !== "application/reports+json") {
+			this.#rejected++;
+			return "unsupported";
+		}
+		let payload;
+		try {
+			payload = JSON.parse(typeof body === "string" ? body : Buffer.from(body).toString("utf8"));
+		} catch {
+			this.#rejected++;
+			return "malformed";
+		}
+		const agent = cleanText(userAgent, MAX_USER_AGENT_LENGTH);
+		const violations = violationsOf(payload);
+		if (violations.length === 0) {
+			this.#rejected++;
+			return "malformed";
+		}
+		let outcome = "duplicate";
+		for (const violation of violations) if (this.#store(violation, agent)) outcome = "stored";
+		return outcome;
+	}
+	/**
+	* Photo des violations gardées, la plus récemment vue d'abord — ce que rend
+	* le plan d'administration.
+	*
+	* @returns une copie : la modifier ne touche pas le collecteur.
+	*/
+	snapshot() {
+		const items = [];
+		for (const v of this.#violations.values()) items.push({ ...v });
+		items.reverse();
+		return {
+			enabled: true,
+			endpoint: this.endpoint,
+			capacity: this.capacity,
+			received: this.#received,
+			rejected: this.#rejected,
+			items
+		};
+	}
+	/** Range une violation ; `true` si elle est neuve. */
+	#store(violation, userAgent) {
+		const now = this.#now();
+		const key = [
+			violation.disposition,
+			violation.effectiveDirective,
+			violation.documentURL,
+			violation.blockedURL ?? "",
+			violation.sourceFile ?? "",
+			violation.lineNumber ?? "",
+			violation.columnNumber ?? ""
+		].join("\0");
+		const known = this.#violations.get(key);
+		if (known !== void 0) {
+			known.count++;
+			known.lastSeen = now;
+			if (userAgent !== null) known.userAgent = userAgent;
+			this.#violations.delete(key);
+			this.#violations.set(key, known);
+			return false;
+		}
+		if (this.#violations.size >= this.capacity) {
+			const oldest = this.#violations.keys().next();
+			if (oldest.done !== true) this.#violations.delete(oldest.value);
+		}
+		this.#violations.set(key, {
+			...violation,
+			userAgent,
+			count: 1,
+			firstSeen: now,
+			lastSeen: now
+		});
+		this.#announce(violation, now);
+		return true;
+	}
+	/** Journalise une violation neuve, dans la limite du budget de la minute. */
+	#announce(v, now) {
+		if (this.#log === null) return;
+		if (now - this.#logWindowStart >= MINUTE_MS) {
+			if (this.#silenced > 0) this.#log(`CSP : ${this.#silenced} violation(s) neuve(s) non journalisée(s) la minute précédente — liste complète : GET /nodefony/security/api/csp-reports`, "NOTICE");
+			this.#logWindowStart = now;
+			this.#loggedInWindow = 0;
+			this.#silenced = 0;
+		}
+		if (this.#loggedInWindow >= this.#logPerMinute) {
+			this.#silenced++;
+			return;
+		}
+		this.#loggedInWindow++;
+		const where = v.sourceFile !== null ? ` (${v.sourceFile}${v.lineNumber !== null ? `:${v.lineNumber}` : ""})` : "";
+		this.#log(`CSP ${v.disposition === "report" ? "signalée" : "bloquée"} : ${v.effectiveDirective} refuse ${v.blockedURL ?? "?"} sur ${v.documentURL}${where}`, "WARNING");
+	}
+};
+/** Type de contenu sans paramètres, en minuscules. */
+function mediaTypeOf(value) {
+	if (typeof value !== "string") return null;
+	const semi = value.indexOf(";");
+	return (semi === -1 ? value : value.slice(0, semi)).trim().toLowerCase();
+}
+/** Objet ordinaire, ou `null`. */
+function recordOf(value) {
+	return isRecord(value) ? value : null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Lit un corps de rapport selon sa FORME, quel que soit celui des deux types de
+* contenu admis qui l'annonce.
+*
+* Le type ne suffit pas à décider : WebKit (Safari) poste son `report-to` en
+* `application/csp-report` avec UN rapport de la Reporting API, ni enveloppé
+* dans `csp-report` ni mis en tableau (corps relevé au navigateur). Lu sur le
+* seul type, ce rapport était écarté comme malformé — et toutes les violations
+* de Safari avec lui.
+*/
+function violationsOf(payload) {
+	if (Array.isArray(payload)) return fromReportsJson(payload);
+	const record = recordOf(payload);
+	if (record === null) return [];
+	if ("csp-report" in record) return fromCspReport(record);
+	return fromReportsJson([record]);
+}
+/** Corps `{ "csp-report": { … } }` (CSP2, `report-uri`). */
+function fromCspReport(payload) {
+	const report = recordOf(payload["csp-report"]);
+	if (report === null) return [];
+	const one = normalize({
+		documentURL: report["document-uri"],
+		blockedURL: report["blocked-uri"],
+		effectiveDirective: report["effective-directive"],
+		violatedDirective: report["violated-directive"],
+		disposition: report["disposition"],
+		sourceFile: report["source-file"],
+		lineNumber: report["line-number"],
+		columnNumber: report["column-number"],
+		statusCode: report["status-code"]
+	});
+	return one === null ? [] : [one];
+}
+/**
+* Rapports de la Reporting API (`report-to`), dont seuls ceux de type
+* `csp-violation` sont lus.
+*/
+function fromReportsJson(payload) {
+	const out = [];
+	for (const item of payload) {
+		const report = recordOf(item);
+		if (report?.["type"] !== "csp-violation") continue;
+		const body = recordOf(report["body"]);
+		if (body === null) continue;
+		const one = normalize({
+			documentURL: body["documentURL"] ?? report["url"],
+			blockedURL: body["blockedURL"],
+			effectiveDirective: body["effectiveDirective"],
+			violatedDirective: void 0,
+			disposition: body["disposition"],
+			sourceFile: body["sourceFile"],
+			lineNumber: body["lineNumber"],
+			columnNumber: body["columnNumber"],
+			statusCode: body["statusCode"]
+		});
+		if (one !== null) out.push(one);
+	}
+	return out;
+}
+/**
+* Expurge une violation ; `null` si elle ne désigne ni un document ni une
+* directive — rien d'exploitable, donc rien à garder.
+*/
+function normalize(raw) {
+	const documentURL = stripUrl(raw.documentURL);
+	if (documentURL === null) return null;
+	const effectiveDirective = tokenOf(raw.effectiveDirective) ?? firstTokenOf(raw.violatedDirective);
+	if (effectiveDirective === null) return null;
+	return {
+		documentURL,
+		blockedURL: stripUrl(raw.blockedURL),
+		effectiveDirective,
+		disposition: raw.disposition === "report" ? "report" : "enforce",
+		sourceFile: stripUrl(raw.sourceFile),
+		lineNumber: intOf(raw.lineNumber),
+		columnNumber: intOf(raw.columnNumber),
+		statusCode: intOf(raw.statusCode)
+	};
+}
+/**
+* Une URL de rapport, expurgée : sans identifiants, requête ni fragment ; le
+* seul schéma si elle n'est pas HTTP(S) (`w3c-reporting.bs`, « Strip URL for
+* use in reports », qui garde la requête — pas nous : elle peut porter un
+* jeton). Un mot-clé de la norme (`inline`, `eval`…) passe tel quel.
+*/
+function stripUrl(value) {
+	if (typeof value !== "string" || value === "") return null;
+	if (TOKEN.test(value)) return value;
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return url.protocol.slice(0, -1);
+	url.username = "";
+	url.password = "";
+	url.search = "";
+	url.hash = "";
+	const href = url.href;
+	return href.length > MAX_URL_LENGTH ? href.slice(0, MAX_URL_LENGTH) : href;
+}
+function tokenOf(value) {
+	return typeof value === "string" && TOKEN.test(value) ? value : null;
+}
+/** `violated-directive` (CSP2) porte la directive suivie de ses sources. */
+function firstTokenOf(value) {
+	if (typeof value !== "string") return null;
+	const space = value.indexOf(" ");
+	return tokenOf(space === -1 ? value : value.slice(0, space));
+}
+function intOf(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= MAX_INT ? value : null;
+}
+/** Texte libre de l'émetteur : sans contrôles, tronqué. */
+function cleanText(value, max) {
+	if (typeof value !== "string") return null;
+	const text = value.replace(CONTROL, "").trim();
+	if (text === "") return null;
+	return text.length > max ? text.slice(0, max) : text;
+}
+export { CspReportCollector };