nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/kernel/checks/freshness.js

@@ -0,0 +1,139 @@
+import { formatDuration } from "./report.js";
+import { isSkippedDir, isTestFile } from "./walk.js";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+//#region src/kernel/checks/freshness.ts
+/**
+* Contrôle de FRAÎCHEUR — ce qui tourne n'est pas ce qui est écrit.
+*
+* Le runtime charge `dist/`, jamais les sources. Une route ajoutée et non
+* bâtie répond donc 404, un export retiré reste servi, et rien ne le dit :
+* le fichier existe, il compile, le test qui l'importe directement passe.
+* C'est la cause perdue la plus fréquente de ce framework — au point que le
+* noyau la devine déjà, mais seulement APRÈS un échec de démarrage, dans son
+* conseil de remédiation. Ici, on la voit AVANT.
+*
+* Même famille pour le plancher de Node : une version trop basse ne se
+* manifeste qu'au premier octet de syntaxe non reconnue, à un endroit qui
+* n'a aucun rapport avec la cause.
+*
+* Lecture PURE, comme le reste de `nodefony doctor` : des dates de fichiers
+* et deux manifestes, aucun boot, aucun import du code analysé.
+*
+* ⚠️ La date d'un `dist/` est un INDICE, pas une preuve. Un cache de build
+* peut restaurer un artefact avec un horodatage neuf sans que son contenu
+* corresponde aux sources ; l'inverse — sources plus récentes que le build —
+* reste, lui, toujours vrai. C'est pourquoi ce contrôle n'accuse QUE dans ce
+* sens, et le dit dans son message.
+*/
+/** Dossiers de sources d'une application, dans l'ordre où on les rencontre. */
+const SOURCES = [
+	"nodefony",
+	"src",
+	"index.ts",
+	"nodefony.config.ts",
+	"env.ts"
+];
+/**
+* Ce fichier entre-t-il dans le build ?
+*
+* Un test n'y entre PAS : le bundler ne l'emporte pas, et le `dist/` n'a
+* aucune raison d'être plus récent que lui. Le compter faisait réclamer un
+* `npm run build` après chaque test écrit — un geste inutile, réclamé par un
+* outil de diagnostic, donc un outil qu'on apprend à ignorer.
+*
+* @param filePath - chemin relatif, écrit en `/`.
+* @returns `true` si une modification de ce fichier périme le build.
+*/
+function isBuiltSource(filePath) {
+	if (!filePath.endsWith(".ts") || filePath.endsWith(".d.ts")) return false;
+	if (isTestFile(filePath)) return false;
+	return !filePath.split("/").some((segment) => isSkippedDir(segment));
+}
+/** La source la plus RÉCEMMENT modifiée sous un chemin, et laquelle. */
+function newestUnder(root, rel) {
+	const rien = {
+		mtime: 0,
+		file: ""
+	};
+	const target = path.join(root, rel);
+	const stat = statSync(target, { throwIfNoEntry: false });
+	if (!stat) return rien;
+	if (stat.isFile()) return isBuiltSource(rel) ? {
+		mtime: stat.mtimeMs,
+		file: rel
+	} : rien;
+	let found = rien;
+	for (const entry of readdirSync(target, {
+		recursive: true,
+		encoding: "utf8"
+	})) {
+		const filePath = entry.split(path.sep).join("/");
+		if (!isBuiltSource(filePath)) continue;
+		const s = statSync(path.join(target, entry), { throwIfNoEntry: false });
+		if (s?.isFile() && s.mtimeMs > found.mtime) found = {
+			mtime: s.mtimeMs,
+			file: `${rel}/${filePath}`
+		};
+	}
+	return found;
+}
+/** La version majeure exigée par `engines.node`, ou `null` si non déclarée. */
+function requiredNodeMajor(engines) {
+	if (typeof engines !== "object" || engines === null) return null;
+	const brut = engines.node;
+	if (typeof brut !== "string") return null;
+	const m = /(\d+)/u.exec(brut);
+	return m ? Number.parseInt(m[1], 10) : null;
+}
+/**
+* Confronte les sources au build, et la version de Node au plancher déclaré.
+*
+* @param projectRoot - racine de l'application.
+* @param nodeVersion - version du runtime (injectée : une fonction qui lit
+*   `process.version` ne s'éprouve que sur la version qu'elle décrit).
+* @returns les écarts, et si la comparaison a pu avoir lieu.
+*/
+function checkFreshness(projectRoot, nodeVersion = process.version) {
+	const findings = [];
+	const dist = path.join(projectRoot, "dist", "index.js");
+	const distStat = statSync(dist, { throwIfNoEntry: false });
+	let plusRecente = 0;
+	let porteuse = "";
+	for (const rel of SOURCES) {
+		const when = newestUnder(projectRoot, rel);
+		if (when.mtime > plusRecente) {
+			plusRecente = when.mtime;
+			porteuse = when.file;
+		}
+	}
+	if (plusRecente > 0 && !distStat) findings.push({
+		kind: "dist-missing",
+		message: "l'application n'est pas construite (`dist/index.js` absent) : le runtime charge le build, pas les sources — toute route répondra 404. → `npm run build`",
+		file: "dist/index.js"
+	});
+	else if (distStat && plusRecente > distStat.mtimeMs) {
+		const gap = formatDuration((plusRecente - distStat.mtimeMs) / 1e3);
+		findings.push({
+			kind: "dist-stale",
+			message: `des sources ont changé APRÈS le dernier build (\`${porteuse}\` est plus récent de ${gap} que \`dist/index.js\`) : le runtime sert encore l'ancien code — une route neuve répondra 404, un export retiré restera servi. → \`npm run build\``,
+			file: porteuse
+		});
+	}
+	const manifeste = path.join(projectRoot, "package.json");
+	if (existsSync(manifeste)) try {
+		const exige = requiredNodeMajor(JSON.parse(readFileSync(manifeste, "utf8")).engines);
+		const current = Number.parseInt(nodeVersion.replace(/^v/u, ""), 10);
+		if (exige !== null && Number.isFinite(current) && current < exige) findings.push({
+			kind: "node-below-engines",
+			message: `Node ${nodeVersion} est en deçà du plancher déclaré par cette application (\`engines.node\` exige ${exige} ou plus) : l'échec arrivera sur une syntaxe non reconnue, loin de sa cause. → installer Node ${exige}, ou relever \`engines.node\` en connaissance de cause`,
+			file: "package.json"
+		});
+	} catch {}
+	return {
+		findings,
+		notComparable: plusRecente === 0 && !distStat
+	};
+}
+//#endregion
+export { checkFreshness, requiredNodeMajor };

package/dist/node/kernel/checks/gating.js

@@ -0,0 +1,231 @@
+import { engineModeOf } from "../../runtime/engineEnvironment.js";
+import { gateModuleManifest } from "../moduleGating.js";
+import { spawn } from "node:child_process";
+//#region src/kernel/checks/gating.ts
+/**
+* `doctor --env <e>` — ce qui DISPARAÎTRA là-bas, dit depuis ici.
+*
+* Un module `policy: "dev"` est retiré en production. Ce qu'il fournissait
+* disparaît avec lui — un service, un encodeur de mots de passe, une surcharge
+* de configuration — **et le boot continue**. L'application démarre, sert, et
+* une brique manque. Le dépôt a déjà payé ce défaut deux fois, assez pour lui
+* avoir écrit une règle : « une brique requise en production n'est jamais
+* fournie par un seul module `policy:"dev"` ». Rien ne l'attrapait avant la
+* production : le gating n'apparaît dans le bilan que si le DERNIER démarrage
+* était un démarrage de production — c'est-à-dire jamais, sur un poste de
+* développement.
+*
+* 🔴 **Rien n'est déduit, tout est CONSTATÉ.** La question « ce service
+* a-t-il un autre fournisseur là-bas ? » n'a pas de réponse lisible dans un
+* fichier : un défaut du framework et un module de développement posent le même
+* nom, et seul le second l'écrase. On ne la devine donc pas — on demande à un
+* boot console visant l'environnement cible, et on DIFFÉRENCIE les deux vues.
+* Un service encore là-bas est le cas sain, sans qu'aucune règle n'ait eu à le
+* dire.
+*
+* Le boot cible tourne dans un PROCESSUS À PART, et c'est structurel : poser
+* `NODE_ENV=production` dans celui-ci basculerait tout le diagnostic en
+* production — le catalogue de l'application, la fraîcheur du build, jusqu'à la
+* lecture des sources. On l'a déjà vécu une fois, et le rapport était faux sans
+* le dire.
+*/
+/**
+* L'état d'exécution quand aucun environnement n'est visé.
+*
+* Une seule rédaction, parce que deux chemins y mènent — la commande sans
+* `--env`, et la famille appelée sans cible — et que deux formulations du même
+* fait finiraient par se contredire.
+*/
+const NO_TARGET = {
+	ran: false,
+	reason: "aucun environnement visé : il n'y a rien à comparer tant qu'on ne dit pas OÙ l'on va",
+	short: "aucune cible",
+	notApplicable: true,
+	unlock: "`nodefony doctor --live --env production`"
+};
+/**
+* Les services que l'environnement visé ne fournira plus.
+*
+* Fonction PURE : c'est un DIFF de deux listes, rien de plus. Un service encore
+* présent là-bas ne lève rien, quel que soit le module qui le porte — un défaut
+* du framework qui reprend la main est exactement le cas sain que ce contrôle
+* ne doit pas signaler.
+*
+* @param here - les services de l'application telle qu'elle tourne ici.
+* @param there - les services de l'application dans l'environnement visé.
+* @param targetEnv - le nom de l'environnement visé, pour la phrase rendue.
+* @returns un manquement par service perdu, dans l'ordre alphabétique.
+*/
+function lostServices(here, there, targetEnv) {
+	const survivors = new Set(there.map((s) => s.name));
+	/** Les modules qui portent chaque service perdu, sans doublon. */
+	const providers = /* @__PURE__ */ new Map();
+	for (const service of here) {
+		if (survivors.has(service.name)) continue;
+		const list = providers.get(service.name);
+		if (list) {
+			if (!list.includes(service.module)) list.push(service.module);
+		} else providers.set(service.name, [service.module]);
+	}
+	return [...providers.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, from]) => ({
+		kind: "service-lost",
+		service: name,
+		providers: from,
+		message: `« ${name} » — fourni ici par ${from.map((m) => `« ${m} »`).join(", ")}, absent en ${targetEnv}`
+	}));
+}
+/**
+* Confronte ce que l'application fournit ICI à ce qu'elle fournira LÀ-BAS.
+*
+* Ne lève jamais : un boot cible impossible devient un état d'exécution
+* lisible. C'est la doctrine de tout l'étage 2 — le rapport statique est celui
+* dont on a besoin quand l'application va mal, et une exception l'emporterait
+* au pire moment.
+*
+* @param input - l'environnement visé, le manifeste, et les deux vues.
+* @returns les briques perdues, les modules écartés, et l'état d'exécution.
+*/
+async function checkGating(input) {
+	if (!input.targetEnv) return {
+		findings: [],
+		gated: [],
+		execution: NO_TARGET
+	};
+	const target = input.targetEnv;
+	const { gated } = gateModuleManifest(input.manifest, {
+		isProduction: engineModeOf(target) === "production",
+		forceDevModules: false,
+		config: input.config
+	});
+	const there = await input.readTarget(target);
+	if (!there.ok) return {
+		findings: [],
+		gated,
+		execution: {
+			ran: false,
+			reason: there.reason,
+			short: there.short,
+			...there.unlock ? { unlock: there.unlock } : {}
+		}
+	};
+	return {
+		findings: lostServices(input.here, there.services, target),
+		gated,
+		execution: { ran: true }
+	};
+}
+/** Le délai au-delà duquel un boot cible qui n'a pas répondu est abandonné. */
+const TARGET_BOOT_TIMEOUT_MS = 12e4;
+/**
+* Demande à un boot console visant `env` ce qu'il fournit.
+*
+* `nodefony inspect services --json` et rien d'autre : c'est le producteur que
+* la console d'administration et `inspect` lisent déjà, et le dépôt interdit
+* d'en écrire une seconde version. Le sous-processus n'ouvre aucun port (profil
+* console) — il cohabite donc avec un serveur de développement en marche.
+*
+* ⚠️ Les deux étiquettes sont posées ENSEMBLE (`NODE_ENV` et `NF_ENV`) : le
+* mode d'exécution décide du gating `policy`, l'environnement de déploiement
+* décide des surcharges de configuration et des `when()`. N'en poser qu'une
+* ferait diagnostiquer un environnement qui n'existe nulle part.
+*
+* @param input - de quoi relancer le binaire courant.
+* @returns ce que l'environnement visé fournit, ou la raison de son silence.
+*/
+/**
+* L'environnement du boot cible, dérivé de celui d'ici.
+*
+* Extrait pour être ÉPROUVÉ : la seule autre façon de constater ce qu'un
+* sous-processus reçoit est de le démarrer, c'est-à-dire de ne le vérifier que
+* là où il aboutit.
+*
+* @param env - l'environnement du processus courant.
+* @param target - l'environnement visé.
+* @returns l'environnement à donner au boot cible.
+*/
+function targetEnvironment(env, target) {
+	return {
+		...env,
+		NODE_ENV: target,
+		NF_ENV: target
+	};
+}
+function readTargetProvision(input) {
+	return (env) => new Promise((resolve) => {
+		const child = spawn(input.execPath, [
+			input.binPath,
+			"inspect",
+			"services",
+			"--json"
+		], {
+			cwd: input.cwd,
+			env: targetEnvironment(input.env, env),
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let out = "";
+		let err = "";
+		child.stdout.on("data", (c) => out += c.toString());
+		child.stderr.on("data", (c) => err += c.toString());
+		const timer = setTimeout(() => {
+			child.kill("SIGKILL");
+		}, input.timeoutMs ?? 12e4);
+		timer.unref?.();
+		child.on("error", (e) => {
+			clearTimeout(timer);
+			resolve({
+				ok: false,
+				reason: `le démarrage visant ${env} n'a pas pu être lancé — ${e.message}`,
+				short: "boot impossible"
+			});
+		});
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (code !== 0) return resolve({
+				ok: false,
+				reason: `l'application ne démarre pas en ${env} (code ${code ?? "tué"}) — il n'y a rien à comparer tant qu'elle ne démarre pas${lastLine(err)}`,
+				short: "boot en échec",
+				unlock: `NODE_ENV=${env} npx nodefony inspect services`
+			});
+			try {
+				const parsed = JSON.parse(out);
+				if (!Array.isArray(parsed)) throw new Error("liste attendue");
+				return resolve({
+					ok: true,
+					services: parsed.map(toService)
+				});
+			} catch (e) {
+				return resolve({
+					ok: false,
+					reason: `le démarrage visant ${env} a répondu autre chose qu'une liste de services — ${e.message}`,
+					short: "réponse illisible"
+				});
+			}
+		});
+	});
+}
+/** Un élément de la réponse, sans rien affirmer de sa forme. */
+function toService(row) {
+	const bag = row ?? {};
+	return {
+		name: typeof bag.name === "string" ? bag.name : "",
+		module: typeof bag.module === "string" ? bag.module : ""
+	};
+}
+/**
+* La dernière ligne utile d'un journal d'erreur, pour EXPLIQUER un échec.
+*
+* Un boot qui échoue écrit des dizaines de lignes ; les rendre toutes noierait
+* le rapport, n'en rendre aucune laisserait « ça ne démarre pas » sans la
+* moindre piste. Une ligne, et le geste pour voir le reste.
+*/
+function lastLine(stderr) {
+	const lines = stderr.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+	const last = lines[lines.length - 1];
+	return last ? ` : ${last}` : "";
+}
+//#endregion
+export { NO_TARGET, TARGET_BOOT_TIMEOUT_MS, checkGating, lostServices, readTargetProvision, targetEnvironment };

package/dist/node/kernel/checks/guards.js

@@ -0,0 +1,232 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+//#region src/kernel/checks/guards.ts
+/**
+* `doctor` — les GARDES du projet sont-elles armées ?
+*
+* 🔴 Ce contrôle ne signale JAMAIS une occurrence de code. Le linter et le
+* vérificateur de types détectent déjà `any` explicite et `@ts-ignore`, et ils
+* le font correctement : un contrôle recopié en expression régulière se
+* tromperait sur les commentaires et les chaînes, et divergerait de la règle au
+* premier cas particulier. C'est écrit ici en toutes lettres pour que personne
+* ne l'ajoute plus tard.
+*
+* Ce que `doctor` apporte, et que personne ne fait : vérifier que la garde
+* EXISTE. Une application où quelqu'un a mis `"no-explicit-any": "off"`, retiré
+* `--deny-warnings`, ou cassé la chaîne `verify` n'a plus de filet — et rien ne
+* le signale, puisque le lint passe. Un filet décroché ne fait pas de bruit ;
+* c'est toute la difficulté.
+*
+* ⚠️ La désactivation SOUS les tests, la configuration et les scripts est
+* VOULUE : un décor écrit `any` à dessein. C'est ce qui rend un `off` global
+* difficile à repérer à l'œil — il ressemble à ceux-là.
+*/
+/**
+* Les règles dont la désactivation retire un filet, et pourquoi.
+*
+* Nommées ici plutôt que devinées : ce sont celles que le projet a choisies et
+* que sa doctrine cite (« 0 `any`, 0 `@ts-ignore` »). Une liste dérivée de la
+* configuration ne dirait rien — c'est justement l'absence qu'on cherche.
+*/
+const REQUIRED_RULES = [{
+	name: "typescript/no-explicit-any",
+	why: "un `any` explicite éteint le typage là où il compte le plus",
+	category: "restriction"
+}, {
+	name: "typescript/ban-ts-comment",
+	why: "`@ts-ignore` fait taire le compilateur sans laisser de trace",
+	category: "pedantic"
+}];
+/**
+* Les chemins où la désactivation d'une règle est VOULUE.
+*
+* Un décor de test écrit `any` à dessein, une configuration d'outil aussi. Un
+* `off` qui ne vise que ces chemins n'est pas un filet décroché — le confondre
+* avec un `off` global ferait crier `doctor` sur une configuration saine.
+*/
+const ALLOWED_OFF = [
+	"test",
+	"spec",
+	"config",
+	"scripts",
+	"skills"
+];
+/** Ce que la chaîne `verify` doit enchaîner pour mériter son nom. */
+const VERIFY_STEPS = [
+	"typecheck",
+	"lint",
+	"test"
+];
+/** Les sévérités qui n'arment RIEN. `allow` est le mot d'oxlint pour `off`. */
+const SILENT_SEVERITIES = /* @__PURE__ */ new Set([
+	"off",
+	"allow",
+	0
+]);
+/** Une valeur de règle qui NE garde plus rien. */
+function isOff(value) {
+	if (SILENT_SEVERITIES.has(value)) return true;
+	if (Array.isArray(value)) return SILENT_SEVERITIES.has(value[0]);
+	return false;
+}
+/**
+* Le nom d'une règle réduit à ce qui l'identifie vraiment.
+*
+* `typescript/no-explicit-any`, `@typescript-eslint/no-explicit-any` et
+* `no-explicit-any` désignent la MÊME règle — oxlint accepte les trois formes
+* (constaté en l'exécutant). Comparer les chaînes brutes faisait donc déclarer
+* « absente » une règle écrite sous un autre de ses noms.
+*
+* @param name - le nom tel que la configuration l'écrit.
+* @returns le segment qui suit le dernier `/`.
+*/
+function ruleKey(name) {
+	const at = name.lastIndexOf("/");
+	return at === -1 ? name : name.slice(at + 1);
+}
+/**
+* La valeur déclarée pour une règle, quel que soit l'alias employé.
+*
+* @param rules - le bloc `rules` de la configuration.
+* @param name - la règle cherchée.
+* @returns la valeur déclarée, ou `undefined` si la règle n'est pas nommée.
+*/
+function declaredRule(rules, name) {
+	const wanted = ruleKey(name);
+	let found;
+	for (const key of Object.keys(rules)) if (ruleKey(key) === wanted) found = rules[key];
+	return found;
+}
+/**
+* La catégorie qui armerait la règle est-elle activée ?
+*
+* @param linter - la configuration du linter.
+* @param category - la catégorie oxlint de la règle.
+* @returns `true` si la catégorie est déclarée avec une sévérité qui mord.
+*/
+function categoryArms(linter, category) {
+	const severity = (linter.categories ?? {})[category];
+	return severity !== void 0 && !isOff(severity);
+}
+/** `true` si ce motif de fichiers ne vise que des zones où le `off` est voulu. */
+function isAllowedScope(files) {
+	const list = Array.isArray(files) ? files : [files];
+	if (list.length === 0) return false;
+	return list.every((f) => typeof f === "string" && ALLOWED_OFF.some((word) => f.toLowerCase().includes(word)));
+}
+/** Lit un JSON qui tolère les commentaires — la configuration du linter en a. */
+function readJsonc(file) {
+	try {
+		const raw = readFileSync(file, "utf8").replace(/^\s*\/\/[^\n]*$/gmu, "");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+/**
+* Constate que les gardes du projet sont armées.
+*
+* @param options - la racine du projet.
+* @returns les gardes décrochées, et le nombre de celles qui tiennent.
+*/
+function checkGuards(options) {
+	const findings = [];
+	let armed = 0;
+	const armedNames = [];
+	const manifestPath = path.join(options.projectRoot, "package.json");
+	const linterPath = path.join(options.projectRoot, ".oxlintrc.json");
+	const manifest = readJsonc(manifestPath);
+	const linter = readJsonc(linterPath);
+	const manifestFile = "package.json";
+	const linterFile = ".oxlintrc.json";
+	if (manifest) {
+		const scripts = manifest.scripts ?? {};
+		const lint = typeof scripts.lint === "string" ? scripts.lint : "";
+		const typecheck = typeof scripts.typecheck === "string" ? scripts.typecheck : "";
+		const verify = typeof scripts.verify === "string" ? scripts.verify : "";
+		if (!lint) findings.push({
+			kind: "lint-missing",
+			file: manifestFile,
+			message: "aucun script `lint` : les règles du projet ne sont exécutées par personne — ni en local, ni dans une forge, et leur configuration ne garde alors plus rien. → `npm pkg set scripts.lint=\"oxlint --deny-warnings\"`"
+		});
+		else if (!lint.includes("--deny-warnings")) findings.push({
+			kind: "lint-not-blocking",
+			file: manifestFile,
+			message: "le script `lint` ne porte pas `--deny-warnings` : les règles du projet sont en `warn`, donc le linter passe même quand elles mordent — la garde est là, mais elle ne retient rien"
+		});
+		else {
+			armed++;
+			armedNames.push("lint");
+		}
+		if (!typecheck) findings.push({
+			kind: "typecheck-missing",
+			file: manifestFile,
+			message: "aucun script `typecheck` : le bundler ne vérifie PAS les types, et rien d'autre ne le fait — du code qui ne compile pas peut être publié sans qu'aucune barrière ne s'y oppose. → `npm pkg set scripts.typecheck=\"tsgo --noEmit\"`"
+		});
+		else {
+			armed++;
+			armedNames.push("typecheck");
+		}
+		const missing = VERIFY_STEPS.filter((step) => !verify.includes(step));
+		if (!verify) findings.push({
+			kind: "verify-missing",
+			file: manifestFile,
+			message: `aucune chaîne \`verify\` : rien n'enchaîne ${VERIFY_STEPS.join(", ")} en une seule commande — c'est celle qu'une forge appelle, et celle qu'on tape avant de publier. → \`npm pkg set scripts.verify="${VERIFY_STEPS.map((e) => `npm run ${e}`).join(" && ")}"\``
+		});
+		else if (missing.length > 0) findings.push({
+			kind: "verify-broken",
+			file: manifestFile,
+			message: `la chaîne \`verify\` n'enchaîne plus ${missing.join(", ")} : elle passe donc en ignorant ce qu'elle est censée contrôler, et c'est elle qu'une forge appelle`
+		});
+		else if (verify) {
+			armed++;
+			armedNames.push("verify");
+		}
+	}
+	if (linter) {
+		const rules = linter.rules ?? {};
+		const overrides = Array.isArray(linter.overrides) ? linter.overrides : [];
+		for (const { name, why, category } of REQUIRED_RULES) {
+			if (isOff(declaredRule(rules, name))) {
+				findings.push({
+					kind: "rule-disabled",
+					file: linterFile,
+					message: `la règle \`${name}\` est désactivée GLOBALEMENT — ${why}`
+				});
+				continue;
+			}
+			const large = overrides.find((o) => {
+				const bag = o ?? {};
+				return isOff(declaredRule(bag.rules ?? {}, name)) && !isAllowedScope(bag.files);
+			});
+			if (large) {
+				const target = large.files;
+				findings.push({
+					kind: "rule-disabled",
+					file: linterFile,
+					message: `la règle \`${name}\` est désactivée sur ${JSON.stringify(target)} — hors des zones où c'est voulu (tests, configuration, scripts). ${why}`
+				});
+				continue;
+			}
+			if (declaredRule(rules, name) === void 0 && !categoryArms(linter, category)) {
+				findings.push({
+					kind: "rule-missing",
+					file: linterFile,
+					message: `la règle \`${name}\` n'est déclarée nulle part, et la catégorie \`${category}\` qui l'activerait n'est pas retenue : elle ne dit donc rien. ${why}`
+				});
+				continue;
+			}
+			armed++;
+			armedNames.push(name);
+		}
+	}
+	return {
+		findings,
+		armed,
+		armedNames,
+		linterUnreadable: linter === null,
+		manifestUnreadable: manifest === null
+	};
+}
+//#endregion
+export { REQUIRED_RULES, VERIFY_STEPS, checkGuards };