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

package/dist/nodefony/src/authenticator/FirewallRealtimeAuthenticator.js

@@ -1,9 +1,15 @@
-import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { isBoundToAccount } from "../accountBinding.js";
-import { UserRealtimeToken } from "../realtime/UserRealtimeToken.js";
+import { AuthenticationError } from "../../errors/AuthenticationError.js";
+import { LOCAL_ACCOUNT, UserRealtimeToken } from "../realtime/UserRealtimeToken.js";
+import { isEphemeralSubject } from "./ExternalSubjectResolver.js";
+import { tokenStatusOf } from "../token/tokenStatus.js";
 import { Nodefony, RequestContext } from "nodefony";
 import { authenticatedUser } from "@nodefony/user";
 // nodefony/src/authenticator/FirewallRealtimeAuthenticator.ts
+/** Le verdict booléen d'un état : seul `active` fait vivre l'identité. */
+function toValidity(status) {
+	return async (nowMs) => await status(nowMs) === "active";
+}
 /**
 * Authenticator realtime des identités résolues par le **firewall** — équivalent
 * WS de tout ce que le pipeline HTTP sait authentifier.
@@ -90,9 +96,10 @@ var FirewallRealtimeAuthenticator = class {
 		if (user === null) throw new AuthenticationError("Invalid realtime session");
 		const issued = readFirewallToken();
 		const type = issuedType(issued);
-		const revalidate = this.#revalidatorFor(user, issued, type);
+		const status = type === "session" ? null : this.#buildBearerStatus(issued, user.identifier, type);
+		const revalidate = status === null ? buildSessionRevalidator(user.identifier) : toValidity(status);
 		const scopes = issued ? issued.getScopes() : void 0;
-		return new UserRealtimeToken(user, revalidate, type, scopes, this.#accountConfirmationFor(user, type));
+		return new UserRealtimeToken(user, revalidate, type, scopes, this.#accountConfirmationFor(user, type), status, admissionSourceOf(issued, user));
 	}
 	/**
 	* Le revalidateur de l'identité que le firewall a posée sur la requête
@@ -140,46 +147,58 @@ var FirewallRealtimeAuthenticator = class {
 		};
 	}
 	#revalidatorFor(user, issued, type) {
-		return type === "session" ? buildSessionRevalidator(user.identifier) : this.#buildBearerRevalidator(issued, user.identifier, type);
+		return type === "session" ? buildSessionRevalidator(user.identifier) : toValidity(this.#buildBearerStatus(issued, user.identifier, type));
 	}
 	/**
-	* Re-validation d'une identité portée par un **jeton** (JWT, clé API, OAuth) :
-	* rejoue les trois conditions qui tuent un jeton, sans jamais parler de session.
+	* État d'une identité portée par un **jeton** (JWT, clé API, OAuth) : rejoue les
+	* trois conditions qui tuent un jeton, sans jamais parler de session, et en rend
+	* la CAUSE — `expired` ferme la socket en 4006, `revoked` en 4001 (ADR-0021 §S11).
+	*
+	* **Révoqué l'emporte sur expiré** : la liste de refus est interrogée AVANT de
+	* conclure à l'expiration, et l'ordre est celui de `tokenStatusOf`, appelé
+	* plutôt que recopié. Un jeton révoqué puis arrivé à `exp` ferme donc en 4001.
 	*
 	* `exp` est vérifié **sans personne** (la borne voyage dans le jeton) ; le store
 	* n'ajoute que la révocation *avant terme*. C'est pourquoi un store en panne ne
 	* coupe pas les sockets d'agents : ce serait une panne de disponibilité déguisée
 	* en mesure de sécurité, alors que la borne du jeton tient toujours.
 	*/
-	#buildBearerRevalidator(issued, identifier, type) {
-		const claims = issued.getAttribute("claims") ?? EMPTY_CLAIMS;
+	#buildBearerStatus(issued, identifier, type) {
+		const claims = issued?.getAttribute("claims") ?? EMPTY_CLAIMS;
 		const expMs = secondsToMs(claims.exp);
 		const iatMs = secondsToMs(claims.iat);
-		const jti = issued.getAttribute("jti") ?? (typeof claims.jti === "string" ? claims.jti : null);
+		const jti = issued?.getAttribute("jti") ?? (typeof claims.jti === "string" ? claims.jti : null);
 		const resolveStore = this.#resolveStore;
 		if (expMs === null && (resolveStore === null || jti === null && iatMs === null)) {
 			Nodefony.getKernel()?.log(`Realtime ${type} token "${identifier}" carries neither an expiry nor any revocation handle ("jti"/"iat") — connection will be revoked (fail-closed). Ensure the authenticator forwards the token claims.`, "WARNING");
-			return () => Promise.resolve(false);
+			return () => Promise.resolve("revoked");
 		}
-		return async (nowMs = Date.now()) => {
-			if (expMs !== null && nowMs >= expMs) return false;
-			if (!resolveStore) return true;
+		/** `true` révoqué, `false` non, `null` = le store n'a pas pu répondre. */
+		const isRevoked = async () => {
+			if (!resolveStore) return false;
 			let store;
 			try {
 				store = resolveStore();
 			} catch {
-				return expMs !== null;
+				return null;
 			}
-			if (!store) return expMs !== null;
+			if (!store) return null;
 			try {
-				if (jti !== null && await store.isJtiDenied(jti)) return false;
+				if (jti !== null && await store.isJtiDenied(jti)) return true;
 				const invalidBefore = await store.getInvalidBefore(identifier);
-				if (invalidBefore !== null && iatMs !== null && iatMs < invalidBefore) return false;
-				return true;
+				return invalidBefore !== null && iatMs !== null && iatMs < invalidBefore;
 			} catch {
-				return expMs !== null;
+				return null;
 			}
 		};
+		return async (nowMs = Date.now()) => {
+			const revoked = await isRevoked();
+			if (revoked === null && expMs === null) return "revoked";
+			return tokenStatusOf({
+				revokedAt: revoked === true ? nowMs : null,
+				expiresAt: expMs
+			}, nowMs);
+		};
 	}
 };
 const EMPTY_CLAIMS = Object.freeze({});
@@ -200,6 +219,29 @@ function secondsToMs(value) {
 function issuedType(issued) {
 	return typeof issued?.type === "string" && issued.type ? issued.type : "session";
 }
+/**
+* Émetteur et compte local de l'identité, pour l'identité d'admission temps réel (ADR-0021 §S10).
+*
+* L'émetteur est celui que l'authentificateur a VÉRIFIÉ et posé sur le jeton
+* (attribut `issuer` : JWT de l'application, JWT tiers) ; `null` sans jeton
+* porteur (session, clé d'API). Le compte est absent pour le seul appelant
+* machine fabriqué en mode `ephemeral` — constaté sur l'objet, jamais déduit
+* de la forme de son `id`.
+*/
+function admissionSourceOf(issued, user) {
+	const issuer = issued?.getAttribute("issuer");
+	const account = !isEphemeralSubject(user);
+	if (typeof issuer !== "string" || issuer === "") return account ? LOCAL_ACCOUNT : EPHEMERAL_WITHOUT_ISSUER;
+	return {
+		issuer,
+		account
+	};
+}
+/** Filet : un sujet éphémère sans émetteur posé (ne devrait pas exister). */
+const EPHEMERAL_WITHOUT_ISSUER = Object.freeze({
+	issuer: null,
+	account: false
+});
 /** Le jeton posé dans l'ALS par `firewall.handleSecurity`, s'il y en a un. */
 function readFirewallToken() {
 	return RequestContext.get()?.token;

package/dist/nodefony/src/authenticator/JwtAuthenticator.js

@@ -1,8 +1,9 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
-import { loadBoundAccount } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
+import { REQUIRED_TIME_CLAIMS, isIssuedInFuture } from "../token/tokenTimeClaims.js";
 import { bearerToken } from "./bearer.js";
 import peekIssuer from "./peekIssuer.js";
+import { loadBoundAccount } from "../accountBinding.js";
 import { canonicalIssuer } from "nodefony";
 // nodefony/src/authenticator/JwtAuthenticator.ts
 const COMPACT_JWS = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/;
@@ -143,11 +144,13 @@ var JwtAuthenticator = class {
 				algorithms: ["EdDSA"],
 				issuer: this.#runtime.issuer,
 				audience,
-				typ: "at+jwt"
+				typ: "at+jwt",
+				requiredClaims: [...REQUIRED_TIME_CLAIMS]
 			})).payload;
 		} catch {
 			throw new AuthenticationError(INVALID_TOKEN);
 		}
+		if (isIssuedInFuture(payload, Math.floor(Date.now() / 1e3), 5)) throw new AuthenticationError(INVALID_TOKEN);
 		const sub = payload.sub;
 		const jti = payload.jti;
 		if (typeof sub !== "string" || typeof jti !== "string") throw new AuthenticationError(INVALID_TOKEN);

package/dist/nodefony/src/authenticator/SessionAuthenticator.js

@@ -1,6 +1,6 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
-import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY } from "../accountBinding.js";
 import { resolveBoundSessionIdentity } from "../sessionIdentity.js";
+import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
 // nodefony/src/authenticator/SessionAuthenticator.ts
 /**

package/dist/nodefony/src/authenticator/authenticatorRegistry.js

@@ -3,8 +3,8 @@ import { SessionAuthenticator } from "./SessionAuthenticator.js";
 import { UserPasswordAuthenticator } from "./UserPasswordAuthenticator.js";
 import { JwtAuthenticator } from "./JwtAuthenticator.js";
 import { ApiKeyAuthenticator } from "./ApiKeyAuthenticator.js";
-import { externalSubjectOptions } from "./ExternalSubjectResolver.js";
 import { ExternalJwtAuthenticator } from "./ExternalJwtAuthenticator.js";
+import { externalSubjectOptions } from "./ExternalSubjectResolver.js";
 import { resolveJwtRuntime } from "../token/jwtRuntime.js";
 // nodefony/src/authenticator/authenticatorRegistry.ts
 const factories = /* @__PURE__ */ new Map();

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 };