// © 2026 TechnoLibre (http://www.technolibre.ca)
// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)

// Gardes des sources de l'interface, lues dans l'arbre d'analyse et non dans
// le texte : chaque composant passe par parse de svelte/compiler, chaque
// module JavaScript par le même analyseur, enveloppé dans un <script module>,
// chaque feuille .css par parseCss. Un commentaire n'est donc jamais relevé :
// la règle porte sur ce que le code fait, et un commentaire qui nomme un
// interdit le documente.
//
// Huit gardes : les chaînes visibles en dur (§ 14.6), les clés littérales de
// t qui n'existent pas, le contenu des tables de traduction (§ 5.5, § 7.6,
// § 7.7, § 12.8, § 12.10.8), les couleurs (§ 12.7, § 13.3, § 13.5), le
// balisage et les fenêtres du navigateur (§ 13.1, § 2.1), le texte comprimé et
// les animations (§ 7.4, § 19.2), le câblage des composants (§ 12.9, § 13.3),
// les sélecteurs que le compilateur élague (§ 13.3). Chaque garde rend un
// relevé « chemin:ligne motif « extrait » », trié, qui nomme d'un coup chaque
// fichier et chaque ligne fautifs ; elle lève sur un balayage vide (§ 14.2).
//
// Le périmètre est le code livré : les épreuves — *.test.js, dont
// *.navigateur.test.js — et test/ portent exprès ce que les gardes refusent,
// et n'en font pas partie. D'autres épreuves font tourner chaque garde sur un
// arbre temporaire qui porte, à plus d'un niveau, les formes refusées et des
// formes voisines admises.
import assert from 'node:assert/strict';
import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { dirname, join, relative, sep } from 'node:path';
import { fileURLToPath } from 'node:url';
import { compile, parse, parseCss } from 'svelte/compiler';
import { TABLES_APPLICATION } from '../src/application/libelles.js';
import { creerTraduction } from '../src/application/traduction.js';
import { TABLES_INTERFACE } from '../src/interface/libelles.js';
import { describe, test } from './lanceur.js';

const RACINE = fileURLToPath(new URL('..', import.meta.url));

// --- Lecture des sources ------------------------------------------------------

// Une épreuve, node ou navigateur : hors du périmètre de chaque garde.
const EPREUVE = /\.test\.[cm]?js$/;

// Chemins relatifs, en « / », des fichiers des arbres donnés dont le nom finit
// par l'une des extensions, épreuves exclues, triés. Un arbre absent n'en
// fournit aucun ; un répertoire node_modules n'est jamais retenu.
function sources(racine, arbres, extensions) {
  const chemins = [];
  for (const arbre of arbres) {
    let entrees;
    try {
      entrees = readdirSync(join(racine, arbre), { recursive: true, withFileTypes: true });
    } catch (erreur) {
      if (erreur.code === 'ENOENT') continue;
      throw erreur;
    }
    for (const entree of entrees) {
      if (!entree.isFile()) continue;
      const chemin = relative(racine, join(entree.parentPath, entree.name)).split(sep).join('/');
      if (chemin.split('/').includes('node_modules') || EPREUVE.test(chemin)) continue;
      if (extensions.some((extension) => chemin.endsWith(extension))) chemins.push(chemin);
    }
  }
  return chemins.sort();
}

// Lève quand un balayage n'examine aucun fichier (§ 14.2).
function exigerNonVide(chemins, garde) {
  assert.ok(chemins.length > 0, `${garde} : aucun fichier examiné`);
  return chemins;
}

// Numéro, à partir de 1, de la ligne qui porte le caractère d'indice donné.
const ligneDe = (texte, indice) => texte.slice(0, indice).split('\n').length;

// Un extrait lisible d'un texte relevé : blancs réduits, quarante caractères
// au plus.
function extrait(texte) {
  const court = String(texte).replace(/\s+/g, ' ').trim();
  return `« ${court.length > 40 ? `${court.slice(0, 39)}\u{2026}` : court} »`;
}

// Un composant : son arbre moderne, ses positions comptées dans son texte.
function analyserComposant(racine, chemin) {
  const texte = readFileSync(join(racine, chemin), 'utf8');
  try {
    return { texte, ast: parse(texte, { modern: true }) };
  } catch (erreur) {
    throw new Error(`${chemin} : analyse impossible (${erreur.code ?? erreur.name})`, { cause: erreur });
  }
}

// Un module JavaScript, enveloppé dans un <script module> : le préfixe ne
// porte aucun saut de ligne, les numéros de ligne restent ceux du fichier.
function analyserModule(racine, chemin) {
  const texte = `<script module>${readFileSync(join(racine, chemin), 'utf8')}</script>`;
  try {
    return { texte, ast: parse(texte, { modern: true }).module.content };
  } catch (erreur) {
    throw new Error(`${chemin} : analyse impossible (${erreur.code ?? erreur.name})`, { cause: erreur });
  }
}

// Parcourt un arbre d'analyse en profondeur, dans l'ordre des champs : visite
// chaque nœud typé avec la liste de ses ancêtres typés, du plus lointain au
// plus proche. Les champs de service des analyseurs ne sont pas descendus.
const CHAMPS_IGNORES = new Set(['parent', 'loc', 'metadata', 'name_loc', 'range']);
function parcourir(noeud, visiter, ancetres = []) {
  if (noeud === null || typeof noeud !== 'object') return;
  if (Array.isArray(noeud)) {
    for (const enfant of noeud) parcourir(enfant, visiter, ancetres);
    return;
  }
  const type = typeof noeud.type === 'string';
  if (type) visiter(noeud, ancetres);
  const suivants = type ? [...ancetres, noeud] : ancetres;
  for (const [champ, valeur] of Object.entries(noeud)) {
    if (!CHAMPS_IGNORES.has(champ) && valeur !== null && typeof valeur === 'object') {
      parcourir(valeur, visiter, suivants);
    }
  }
}

// Les parties JavaScript et le gabarit d'un composant, sans sa feuille.
const partiesCode = (ast) => [ast.module, ast.instance, ast.fragment];

// Les chaînes littérales qu'une expression peut rendre telle quelle : un
// littéral, les morceaux fixes d'un gabarit de chaîne, les deux branches
// d'une condition, les opérandes d'une concaténation et d'un « || » ou « ?? »,
// le second d'un « && », le dernier terme d'une séquence. Un appel, un
// membre, un identifiant ne rendent aucun littéral : t('cle') n'affiche pas
// sa clé. Rend [{ valeur, debut }].
function litterauxRendus(expression) {
  if (expression === null || typeof expression !== 'object') return [];
  switch (expression.type) {
    case 'Literal':
      return typeof expression.value === 'string' ? [{ valeur: expression.value, debut: expression.start }] : [];
    case 'TemplateLiteral':
      return [
        { valeur: expression.quasis.map((q) => q.value.cooked ?? q.value.raw).join(''), debut: expression.start },
        ...expression.expressions.flatMap(litterauxRendus),
      ];
    case 'ConditionalExpression':
      return [...litterauxRendus(expression.consequent), ...litterauxRendus(expression.alternate)];
    case 'LogicalExpression':
      return expression.operator === '&&'
        ? litterauxRendus(expression.right)
        : [...litterauxRendus(expression.left), ...litterauxRendus(expression.right)];
    case 'BinaryExpression':
      return expression.operator === '+'
        ? [...litterauxRendus(expression.left), ...litterauxRendus(expression.right)]
        : [];
    case 'SequenceExpression':
      return litterauxRendus(expression.expressions.at(-1));
    default:
      return [];
  }
}

// Les morceaux de la valeur d'un attribut du gabarit : { statique, debut }
// pour un texte, { expression } pour une expression. Un attribut sans valeur
// n'en a aucun.
function morceauxAttribut(attribut) {
  const valeur = attribut.value;
  if (valeur === true || valeur === undefined || valeur === null) return [];
  const morceaux = Array.isArray(valeur) ? valeur : [valeur];
  return morceaux.map((m) =>
    m.type === 'Text' ? { statique: m.data, debut: m.start } : { expression: m.expression, debut: m.start },
  );
}

// Le plus proche ancêtre élément d'un nœud du gabarit, ou null.
const ELEMENTS = new Set(['RegularElement', 'SvelteElement', 'Component', 'SvelteComponent', 'SlotElement']);
function elementParent(ancetres) {
  for (let i = ancetres.length - 1; i >= 0; i -= 1) if (ELEMENTS.has(ancetres[i].type)) return ancetres[i];
  return null;
}

// Vrai quand le nœud est dans la valeur d'un attribut ou d'une directive.
const DANS_UN_ATTRIBUT = new Set(['Attribute', 'StyleDirective', 'SpreadAttribute', 'BindDirective', 'ClassDirective']);
const dansUnAttribut = (ancetres) => ancetres.some((a) => DANS_UN_ATTRIBUT.has(a.type));

// --- Garde 1 : les chaînes visibles en dur (§ 14.6) ---------------------------

const LETTRE = /\p{L}/u;
// Attributs qu'une technologie d'assistance annonce, ou que la page montre.
const ATTRIBUTS_ANNONCES = new Set(['aria-label', 'aria-roledescription', 'title', 'placeholder', 'alt']);
// Éléments du SVG dont le contenu est un texte : tout contenu statique non
// blanc y est une chaîne visible, ponctuation comprise.
const TEXTES_SVG = new Set(['title', 'desc', 'text', 'tspan']);
// Une chaîne entre guillemets d'une valeur CSS.
const CHAINE_CSS = /(["'])((?:\\.|(?!\1).)*)\1/g;

// Vrai quand un texte placé dans cet élément est une chaîne visible : une
// lettre partout, tout caractère non blanc dans un texte du SVG.
function texteVisible(texte, element) {
  if (element !== null && element.type === 'RegularElement' && TEXTES_SVG.has(element.name)) {
    return texte.trim() !== '';
  }
  return LETTRE.test(texte);
}

// Vrai quand une valeur de « content » porte une lettre dans une chaîne.
const contenuLettre = (valeur) => [...valeur.matchAll(CHAINE_CSS)].some(([, , chaine]) => LETTRE.test(chaine));

// Relevé des chaînes visibles écrites dans les composants de src/interface :
// texte statique, attribut annoncé, contenu d'un texte du SVG, déclaration
// « content » lettrée, littéral que rend une expression du gabarit.
function releverChainesEnDur(racine) {
  const chemins = exigerNonVide(sources(racine, ['src/interface'], ['.svelte']), 'chaînes en dur');
  const releves = [];
  for (const chemin of chemins) {
    const { texte, ast } = analyserComposant(racine, chemin);
    const relever = (debut, motif, valeur) =>
      releves.push({ chemin, ligne: ligneDe(texte, debut), texte: `${motif} ${extrait(valeur)}` });
    parcourir(ast.fragment, (noeud, ancetres) => {
      if (noeud.type === 'Text' && !dansUnAttribut(ancetres)) {
        const element = elementParent(ancetres);
        if (texteVisible(noeud.data, element)) relever(noeud.start, 'texte', noeud.data);
      } else if (noeud.type === 'ExpressionTag' && !dansUnAttribut(ancetres)) {
        const element = elementParent(ancetres);
        for (const { valeur, debut } of litterauxRendus(noeud.expression)) {
          if (texteVisible(valeur, element)) relever(debut, 'expression littérale', valeur);
        }
      } else if (noeud.type === 'Attribute' && ATTRIBUTS_ANNONCES.has(noeud.name)) {
        for (const morceau of morceauxAttribut(noeud)) {
          const valeurs = 'statique' in morceau
            ? [{ valeur: morceau.statique, debut: morceau.debut }]
            : litterauxRendus(morceau.expression);
          for (const { valeur, debut } of valeurs) {
            if (LETTRE.test(valeur)) relever(debut, `attribut ${noeud.name}`, valeur);
          }
        }
      } else if (noeud.type === 'Attribute' && noeud.name === 'style') {
        for (const morceau of morceauxAttribut(noeud)) {
          if ('statique' in morceau && /content\s*:/.test(morceau.statique) && contenuLettre(morceau.statique)) {
            relever(morceau.debut, 'content', morceau.statique);
          }
        }
      }
    });
    parcourir(ast.css, (noeud) => {
      if (noeud.type === 'Declaration' && noeud.property === 'content' && contenuLettre(noeud.value)) {
        relever(noeud.start, 'content', noeud.value);
      }
    });
  }
  return trier(releves);
}

// Relevé trié par chemin, puis par ligne, puis par texte ; rendu en chaînes.
function trier(releves) {
  return releves
    .sort((a, b) =>
      a.chemin < b.chemin ? -1 : a.chemin > b.chemin ? 1 : a.ligne - b.ligne || (a.texte < b.texte ? -1 : a.texte > b.texte ? 1 : 0),
    )
    .map(({ chemin, ligne, texte }) => `${chemin}:${ligne} ${texte}`);
}

// --- Garde 2 : les clés littérales de t existent (§ 14.6, § 19.11) ------------

// Les clés de toutes les tables assemblées, celles qu'App donne à t.
const CLES = new Set(creerTraduction([...TABLES_APPLICATION, ...TABLES_INTERFACE]).cles());

// La clé littérale du premier argument d'un appel de t — t(…) ou x.t(…) —, ou
// null : une clé composée à l'exécution échappe à cette garde.
function cleLitterale(appel) {
  const appele = appel.callee;
  const estT =
    (appele.type === 'Identifier' && appele.name === 't') ||
    (appele.type === 'MemberExpression' && !appele.computed && appele.property.name === 't');
  if (!estT) return null;
  const [premier] = appel.arguments;
  if (premier?.type === 'Literal' && typeof premier.value === 'string') return premier.value;
  if (premier?.type === 'TemplateLiteral' && premier.expressions.length === 0) return premier.quasis[0].value.cooked;
  return null;
}

// Relevé des clés littérales passées à t, dans les composants et les modules
// de src/interface, qu'aucune table de cles ne porte. Lève quand aucun fichier
// n'est examiné, et quand aucune clé littérale ne l'est : un accesseur renommé
// ou une forme d'appel que la garde ne reconnaît plus la viderait sans bruit.
function releverClesAbsentes(racine, cles) {
  const chemins = exigerNonVide(sources(racine, ['src/interface'], ['.svelte', '.js']), 'clés de t');
  const releves = [];
  let nbCles = 0;
  for (const chemin of chemins) {
    const { texte, ast } = chemin.endsWith('.svelte') ? analyserComposant(racine, chemin) : analyserModule(racine, chemin);
    const parties = chemin.endsWith('.svelte') ? partiesCode(ast) : [ast];
    parcourir(parties, (noeud) => {
      if (noeud.type !== 'CallExpression') return;
      const cle = cleLitterale(noeud);
      if (cle === null) return;
      nbCles += 1;
      if (!cles.has(cle)) releves.push({ chemin, ligne: ligneDe(texte, noeud.start), texte: `clé absente ${extrait(cle)}` });
    });
  }
  assert.ok(nbCles > 0, 'clés de t : aucune clé examinée');
  return trier(releves);
}

// --- Garde 3 : le contenu des tables de traduction ----------------------------

// Un texte comparé sans égard à la casse ni aux accents ; l'apostrophe
// typographique se lit comme la droite.
const normaliser = (texte) =>
  texte.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase().replace(/[\u{2019}\u{02BC}]/gu, "'");

// Mots que le logiciel n'écrit pas, cherchés dans le texte normalisé. Un
// « écart » nu n'existe pas au glossaire (§ 5.5) : seuls l'écart
// d'itinéraire et l'écart au plafond a priori y figurent ; « écarté », du
// verbe, n'en est pas un.
const MOTS_INTERDITS = [
  ['conforme', /conform/],
  ['écart hors du glossaire', /\becarts?\b(?!\s+(?:d'itineraire|au plafond a priori))/],
  ['satisfaction', /satisfaction/],
  ['écart-type', /\becarts?[\s-]+types?\b/],
  ['variance', /\bvariances?\b/],
  ['équité', /\bequite\b/],
  ['score', /\bscores?\b/],
  ['peut mieux faire', /\bpeut mieux faire\b/],
  ['manque minimal', /\bmanques?\s+minima/],
  ['récupérable', /recuperable/],
  ['évitable', /(?<!in)evitable/],
];
const PICTOGRAMME = /\p{Extended_Pictographic}/u;

// Les exceptions nommées aux mots refusés. Chacune admet une forme exacte du
// texte normalisé, pour un mot de MOTS_INTERDITS, dans les seules valeurs dont
// la clé répond à cles ; tout autre emploi du mot, dans la même valeur
// comprise, reste relevé. Une exception qu'aucune valeur ne sert se relève
// « sans objet ».
//
// Le diagnostic d'un manque énonce ce qui le rendrait évitable (§ 5.6) : ses
// remèdes disent qu'un changement « la rend » ou « la rendent évitable ».
// Ailleurs, « évitable » nommerait le second segment du manque (§ 12.4), que
// le logiciel n'écrit pas.
const EXCEPTIONS_DE_CONTENU = [
  {
    mot: 'évitable',
    cles: /^diagnostic\.remede\./,
    forme: /\bla rend(?:ent)? evitable\b/g,
    nom: 'diagnostic.remede.* « la rend(ent) évitable »',
  },
];

// Une chaîne de forme clé — un code, LECTURE_SEULE, ou un libellé,
// plan.refus.fermer — : une fonction la passe à texte, ou la compare à un
// détail, et ne l'affiche pas.
const FORME_CLE = /^(?:[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*|[a-z][A-Za-z0-9]*(?:\.[A-Za-z0-9]+)+)$/;

// Le texte d'une fonction de détails qu'un écran peut lire : ses chaînes
// littérales et les morceaux fixes de ses gabarits de chaîne, échappements
// décodés, joints par un blanc ; une chaîne de forme clé n'en est pas. Le nom
// d'une variable n'est pas un texte : une fonction qui nomme « ecart » une
// valeur intermédiaire n'écrit pas le mot. Un texte que l'analyseur refuse se
// lit en entier.
function texteDeFonction(fonction) {
  const source = String(fonction);
  let programme;
  try {
    programme = parse(`<script module>(${source});</script>`, { modern: true }).module.content;
  } catch {
    return source;
  }
  const morceaux = [];
  parcourir(programme, (noeud) => {
    if (noeud.type === 'Literal' && typeof noeud.value === 'string' && !FORME_CLE.test(noeud.value)) morceaux.push(noeud.value);
    if (noeud.type === 'TemplateElement') morceaux.push(noeud.value.cooked ?? noeud.value.raw);
  });
  return morceaux.join(' ');
}

// Relevé « clé : motif « extrait » » des valeurs des tables : chaque chaîne,
// et le texte de chaque fonction de détails (texteDeFonction). localiser(cle),
// quand il est donné, rend { chemin, ligne } de la clé, qui préfixe le relevé
// et l'ordonne ; sans lieu, le relevé s'ordonne par clé. Une forme qu'une
// exception admet est effacée du texte avant que son mot y soit cherché ; suit
// une ligne « exception sans objet : nom » par exception qui n'a rien effacé,
// dans l'ordre de la liste.
function releverContenuTables(tables, localiser = () => null, exceptions = EXCEPTIONS_DE_CONTENU) {
  const entrees = tables.flatMap((table) => [...table]);
  assert.ok(entrees.length > 0, 'contenu des tables : aucune entrée examinée');
  const releves = [];
  const servies = new Set();
  // Le texte normalisé d'une valeur, privé des formes que les exceptions du
  // mot admettent pour cette clé.
  const sansFormesAdmises = (normale, mot, cle) =>
    exceptions
      .filter((exception) => exception.mot === mot && exception.cles.test(cle))
      .reduce((texte, exception) => {
        const reste = texte.replace(exception.forme, ' ');
        if (reste !== texte) servies.add(exception);
        return reste;
      }, normale);
  for (const [cle, entree] of entrees) {
    const valeur = typeof entree === 'function' ? texteDeFonction(entree) : entree;
    const normale = normaliser(valeur);
    const { chemin, ligne } = localiser(cle) ?? { chemin: '', ligne: 0 };
    const relever = (motif) => releves.push({ chemin, ligne, texte: `${cle} : ${motif} ${extrait(valeur)}` });
    for (const [mot, motif] of MOTS_INTERDITS) if (motif.test(sansFormesAdmises(normale, mot, cle))) relever(mot);
    const pictogramme = valeur.match(PICTOGRAMME);
    if (pictogramme !== null) {
      relever(`pictogramme U+${pictogramme[0].codePointAt(0).toString(16).toUpperCase().padStart(4, '0')}`);
    }
  }
  const sansObjet = exceptions.filter((exception) => !servies.has(exception)).map(({ nom }) => `exception sans objet : ${nom}`);
  return [...trier(releves).map((releve) => releve.replace(/^:0 /, '')), ...sansObjet];
}

// { chemin, ligne } de l'entrée [cle, …] dans les tables de libelles/ de
// l'application et des écrans, ou null.
function localisateur(racine) {
  const fichiers = sources(racine, ['src/application/libelles', 'src/interface/libelles'], ['.js']).map((chemin) => ({
    chemin,
    texte: readFileSync(join(racine, chemin), 'utf8'),
  }));
  return (cle) => {
    const motif = new RegExp(`\\[\\s*(['"\`])${RegExp.escape(cle)}\\1\\s*,`);
    for (const { chemin, texte } of fichiers) {
      const trouve = motif.exec(texte);
      if (trouve !== null) return { chemin, ligne: ligneDe(texte, trouve.index) };
    }
    return null;
  };
}

// --- Garde 4 : les couleurs (§ 12.7, § 13.3, § 13.5) --------------------------

const FEUILLE_DES_JETONS = 'src/interface/jetons.css';
const JETON_CONFLIT = '--couleur-conflit';

// Les couleurs nommées de CSS, et les couleurs du système : chacune est un
// littéral. transparent et currentColor ne portent aucune teinte et restent
// admis.
const COULEURS_NOMMEES = (
  'aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown ' +
  'burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan ' +
  'darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid ' +
  'darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet ' +
  'deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ' +
  'ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki ' +
  'lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow ' +
  'lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray ' +
  'lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine ' +
  'mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise ' +
  'mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab ' +
  'orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru ' +
  'pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown ' +
  'seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan ' +
  'teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen ' +
  'accentcolor accentcolortext activetext buttonborder buttonface buttontext canvas canvastext field ' +
  'fieldtext graytext highlight highlighttext linktext mark marktext selecteditem selecteditemtext visitedtext'
).split(' ');
const COULEUR_NOMMEE = new RegExp(`(?<![\\w-])(?:${COULEURS_NOMMEES.join('|')})(?![\\w-])`, 'i');
const COULEUR_HEX = /#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3,4})(?![\w-])/i;
const COULEUR_FONCTION = /(?<![\w-])(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\s*\(/i;

// Le littéral de couleur que porte une valeur CSS ou d'attribut, ou null. Les
// noms de propriétés personnalisées, les adresses url(…) et les chaînes
// entre guillemets sont retirés avant la recherche.
function couleurLitterale(valeur) {
  const nette = valeur
    .replace(/url\([^)]*\)/gi, ' ')
    .replace(CHAINE_CSS, ' ')
    .replace(/--[\w-]+/g, ' ');
  for (const motif of [COULEUR_HEX, COULEUR_FONCTION, COULEUR_NOMMEE]) {
    const trouve = nette.match(motif);
    if (trouve !== null) return trouve[0];
  }
  return null;
}

// Une chaîne qui est en entier un littéral de couleur : un code hexadécimal,
// une fonction de couleur, un nom de couleur.
const COULEUR_ENTIERE = new RegExp(
  `^(?:#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3,4})|${COULEUR_FONCTION.source}.*\\)|${COULEURS_NOMMEES.join('|')})$`,
  'is',
);

// Attributs du gabarit qui portent une couleur.
const ATTRIBUTS_COULEUR = new Set(['fill', 'stroke', 'color', 'stop-color', 'flood-color', 'lighting-color']);

// Les déclarations d'une feuille, chacune avec le texte du sélecteur de la
// règle la plus proche et l'arbre de ce sélecteur (null hors de toute règle) :
// { propriete, valeur, debut, selecteur, prelude }.
function declarations(css, texte) {
  const trouvees = [];
  parcourir(css, (noeud, ancetres) => {
    if (noeud.type !== 'Declaration') return;
    const regle = ancetres.findLast((a) => a.type === 'Rule');
    const selecteur = regle === undefined ? '' : texte.slice(regle.prelude.start, regle.prelude.end);
    const prelude = regle === undefined ? null : regle.prelude;
    trouvees.push({ propriete: noeud.property, valeur: noeud.value, debut: noeud.start, selecteur, prelude });
  });
  return trouvees;
}

// Les déclarations d'un attribut style statique : « propriété: valeur » par
// point-virgule, positionnées au début du morceau.
const declarationsEnLigne = (statique, debut) =>
  statique
    .split(';')
    .map((morceau) => /^\s*([\w-]+)\s*:(.*)$/s.exec(morceau))
    .filter((d) => d !== null)
    .map(([, propriete, valeur]) => ({ propriete, valeur, debut }));

// Une classe qui nomme l'état de conflit : « conflit », ou un nom en
// « -conflit » dont aucun segment ne le nie (« sans-conflit », « non-conflit »).
// « conflit-leve » ne finit pas par « -conflit » et ne le nomme pas.
const NEGATIONS = new Set(['sans', 'non', 'hors', 'pas', 'aucun']);
function classeDeConflit(nom) {
  const segments = nom.toLowerCase().split('-');
  return segments.at(-1) === 'conflit' && !segments.some((segment) => NEGATIONS.has(segment));
}

// Vrai quand une déclaration du jeton de conflit est l'une des règles de
// conflit du plan : dans un composant de src/interface/plan/, sous une règle
// dont CHAQUE sélecteur de la liste porte, dans l'un de ses sélecteurs
// composés, une classe de conflit. Seules les classes posées directement sur
// un composé comptent : celles qu'un :not(…), un :is(…) ou un :global(…)
// enveloppe sont des arguments et ne qualifient pas la règle.
function regleDeConflit(chemin, prelude) {
  if (!chemin.startsWith('src/interface/plan/') || prelude?.type !== 'SelectorList') return false;
  return prelude.children.every((complexe) =>
    complexe.children.some((relatif) =>
      relatif.selectors.some((simple) => simple.type === 'ClassSelector' && classeDeConflit(simple.name)),
    ),
  );
}

// Relevé des couleurs : littéral de couleur dans une feuille, un attribut
// style ou de couleur, une directive style:, ou une chaîne du script d'un
// composant ; déclaration de jeton hors de la feuille des jetons ; lecture du
// jeton de conflit hors des règles de conflit du plan. Les composants de
// src/interface et les feuilles .css de src/ sont lus, la feuille des jetons
// exceptée.
function releverCouleurs(racine) {
  const chemins = exigerNonVide(
    sources(racine, ['src'], ['.svelte', '.css']).filter((c) => c !== FEUILLE_DES_JETONS && (c.endsWith('.css') || c.startsWith('src/interface/'))),
    'couleurs',
  );
  const releves = [];
  for (const chemin of chemins) {
    let texte;
    let decls;
    const relever = (debut, motif) => releves.push({ chemin, ligne: ligneDe(texte, debut), texte: motif });
    // Une déclaration, d'une feuille ou en ligne ; enLigne : hors de toute règle.
    const examiner = ({ propriete, valeur, debut, selecteur, prelude }, enLigne) => {
      const couleur = couleurLitterale(valeur);
      if (couleur !== null) relever(debut, `couleur ${extrait(couleur)} dans ${propriete}`);
      if (propriete.startsWith('--')) relever(debut, `jeton déclaré ${propriete}`);
      if (valeur.includes(JETON_CONFLIT) && (enLigne || !regleDeConflit(chemin, prelude))) {
        relever(debut, `jeton de conflit hors d'une règle de conflit du plan, ${enLigne ? 'en ligne' : extrait(selecteur)}`);
      }
    };
    if (chemin.endsWith('.css')) {
      texte = readFileSync(join(racine, chemin), 'utf8');
      decls = declarations(parseCss(texte), texte);
      for (const d of decls) examiner(d, false);
    } else {
      const analyse = analyserComposant(racine, chemin);
      texte = analyse.texte;
      for (const d of declarations(analyse.ast.css, texte)) examiner(d, false);
      parcourir(analyse.ast.fragment, (noeud) => {
        if (noeud.type === 'Attribute' && noeud.name.startsWith('--')) relever(noeud.start, `jeton déclaré ${noeud.name}`);
        if (noeud.type === 'StyleDirective') {
          if (noeud.name.startsWith('--')) relever(noeud.start, `jeton déclaré ${noeud.name}`);
          for (const morceau of morceauxAttribut(noeud)) {
            const valeurs = 'statique' in morceau ? [morceau.statique] : litterauxRendus(morceau.expression).map((l) => l.valeur);
            for (const valeur of valeurs) examiner({ propriete: noeud.name.replace(/^--.*/, 'style:'), valeur, debut: noeud.start, selecteur: '' }, true);
          }
        }
        if (noeud.type !== 'Attribute') return;
        for (const morceau of morceauxAttribut(noeud)) {
          if (noeud.name === 'style' && 'statique' in morceau) {
            for (const d of declarationsEnLigne(morceau.statique, morceau.debut)) examiner(d, true);
          } else if (noeud.name === 'style' || ATTRIBUTS_COULEUR.has(noeud.name)) {
            const valeurs = 'statique' in morceau
              ? [{ valeur: morceau.statique, debut: morceau.debut }]
              : litterauxRendus(morceau.expression);
            for (const { valeur, debut } of valeurs) {
              const couleur = couleurLitterale(valeur);
              if (couleur !== null) relever(debut, `couleur ${extrait(couleur)} dans ${noeud.name}`);
              if (valeur.includes(JETON_CONFLIT)) relever(debut, "jeton de conflit hors d'une règle de conflit du plan, en ligne");
            }
          }
        }
      });
      // Une chaîne du script qui est en entier un littéral de couleur, ou qui
      // nomme le jeton de conflit.
      parcourir([analyse.ast.module, analyse.ast.instance], (noeud) => {
        if (noeud.type !== 'Literal' || typeof noeud.value !== 'string') return;
        const valeur = noeud.value.trim();
        if (COULEUR_ENTIERE.test(valeur)) {
          relever(noeud.start, `couleur ${extrait(valeur)} dans le script`);
        }
        if (valeur.includes(JETON_CONFLIT)) relever(noeud.start, "jeton de conflit hors d'une règle de conflit du plan, dans le script");
      });
    }
  }
  return trier(releves);
}

// Relevé des jetons de couleur de la feuille des jetons qu'un des deux thèmes
// ne définit pas : chaque --couleur-…, où qu'il soit déclaré, l'est dans le
// bloc clair et dans le bloc sombre.
function releverThemes(racine) {
  const texte = readFileSync(join(racine, FEUILLE_DES_JETONS), 'utf8');
  const decls = declarations(parseCss(texte), texte).filter((d) => d.propriete.startsWith('--couleur-'));
  assert.ok(decls.length > 0, 'thèmes : aucun jeton de couleur examiné');
  const theme = (nom) => new RegExp(`\\[\\s*data-theme\\s*=\\s*(["'])${nom}\\1\\s*\\]`);
  const blocs = { clair: theme('clair'), sombre: theme('sombre') };
  const releves = [];
  const premiere = new Map();
  for (const d of decls) if (!premiere.has(d.propriete)) premiere.set(d.propriete, d.debut);
  for (const [jeton, debut] of premiere) {
    for (const [nom, motif] of Object.entries(blocs)) {
      if (!decls.some((d) => d.propriete === jeton && motif.test(d.selecteur))) {
        releves.push({ chemin: FEUILLE_DES_JETONS, ligne: ligneDe(texte, debut), texte: `${jeton} absent du thème ${nom}` });
      }
    }
  }
  return trier(releves);
}

// --- Garde 5 : balisage et fenêtres du navigateur (§ 13.1, § 2.1) -------------

const PROPRIETES_BALISAGE = new Set(['innerHTML', 'outerHTML', 'insertAdjacentHTML']);
const FENETRES = new Set(['alert', 'confirm', 'prompt']);
const GLOBAUX = new Set(['window', 'globalThis', 'self']);

// Le nom d'un membre non calculé, ou d'un membre calculé par un littéral.
const nomDeMembre = (membre) =>
  membre.computed ? (membre.property.type === 'Literal' ? String(membre.property.value) : null) : membre.property.name;

// Relevé du balisage injecté, des fenêtres du navigateur, de beforeunload, et,
// sous src/interface, de la lecture de .message d'une erreur. Les composants
// et les modules de src/ sont lus.
function releverBalisageEtFenetres(racine) {
  const chemins = exigerNonVide(sources(racine, ['src'], ['.svelte', '.js']), 'balisage et fenêtres');
  const releves = [];
  for (const chemin of chemins) {
    const composant = chemin.endsWith('.svelte');
    const { texte, ast } = composant ? analyserComposant(racine, chemin) : analyserModule(racine, chemin);
    const relever = (debut, motif) => releves.push({ chemin, ligne: ligneDe(texte, debut), texte: motif });
    const interface_ = chemin.startsWith('src/interface/');
    parcourir(composant ? partiesCode(ast) : [ast], (noeud) => {
      switch (noeud.type) {
        case 'HtmlTag':
          relever(noeud.start, '{@html}');
          break;
        case 'MemberExpression': {
          const nom = nomDeMembre(noeud);
          if (PROPRIETES_BALISAGE.has(nom)) relever(noeud.start, nom);
          if (noeud.object.type === 'Identifier' && noeud.object.name === 'document' && (nom === 'write' || nom === 'writeln')) {
            relever(noeud.start, `document.${nom}`);
          }
          if (interface_ && nom === 'message') relever(noeud.start, '.message');
          break;
        }
        case 'CallExpression': {
          const appele = noeud.callee;
          const nom =
            appele.type === 'Identifier'
              ? appele.name
              : appele.type === 'MemberExpression' && appele.object.type === 'Identifier' && GLOBAUX.has(appele.object.name)
                ? nomDeMembre(appele)
                : null;
          if (FENETRES.has(nom)) relever(noeud.start, `${nom}(`);
          break;
        }
        case 'Literal':
          if (typeof noeud.value === 'string' && /beforeunload/i.test(noeud.value)) relever(noeud.start, 'beforeunload');
          break;
        case 'TemplateElement':
          if (/beforeunload/i.test(noeud.value.raw)) relever(noeud.start, 'beforeunload');
          break;
        case 'Identifier':
          if (/beforeunload/i.test(noeud.name)) relever(noeud.start, 'beforeunload');
          break;
        case 'Attribute':
        case 'OnDirective':
          if (/beforeunload/i.test(noeud.name)) relever(noeud.start, 'beforeunload');
          break;
        default:
      }
    });
  }
  return trier(releves);
}

// --- Garde 6 : texte comprimé et animations (§ 7.4, § 19.2) ------------------

// Le motif qu'un nom ou une chaîne nomme, ou null : un mot entier, que ni
// lettre ni chiffre ne prolonge, sans égard à la casse — getComputedTextLength,
// la mesure du § 7.4, ne nomme pas textLength — ; un nom d'écouteur,
// ontransitionend, nomme son événement.
const nomme = (texte, motifs) =>
  motifs.find((motif) => new RegExp(`(?<![\\p{L}\\p{N}])(?:on)?${motif}(?![\\p{L}\\p{N}])`, 'iu').test(texte)) ?? null;

// Les noms d'un arbre d'analyse — identifiants, attributs, directives,
// chaînes littérales — que les motifs nomment : [{ debut, motif }].
function nomsReleves(parties, motifs) {
  const trouves = [];
  parcourir(parties, (noeud) => {
    let nom = null;
    if (noeud.type === 'Identifier' || noeud.type === 'Attribute' || noeud.type === 'OnDirective') nom = noeud.name;
    else if (noeud.type === 'Literal' && typeof noeud.value === 'string') nom = noeud.value;
    else if (noeud.type === 'TemplateElement') nom = noeud.value.raw;
    const motif = nom === null ? null : nomme(nom, motifs);
    if (motif !== null) trouves.push({ debut: noeud.start, motif });
  });
  return trouves;
}

// Le mot qui ouvre une directive d'animation d'un composant — animate,
// transition, in, out —, ou null pour tout autre nœud.
function nomDeDirective(noeud) {
  if (noeud.type === 'AnimateDirective') return 'animate';
  if (noeud.type !== 'TransitionDirective') return null;
  if (noeud.intro && !noeud.outro) return 'in';
  if (noeud.outro && !noeud.intro) return 'out';
  return 'transition';
}

// Déclarations d'animation admises : celles qui l'éteignent.
const ANIMATION_ETEINTE = /^\s*(?:none|0m?s)\s*$/i;

// Relevé de textLength et lengthAdjust sous src/interface et src/geometrie, de
// transitionend et animationend sous src/interface, et de toute transition
// ou animation de l'interface : déclaration transition…, animation… ou
// @keyframes d'une feuille, directive transition:, in:, out: ou animate:
// d'un composant. Un état qui attendrait la fin d'une transition ne
// s'atteindrait plus sous la feuille qui les annule (§ 19.2).
function releverTexteEtAnimation(racine) {
  const chemins = exigerNonVide(
    sources(racine, ['src/interface', 'src/geometrie'], ['.svelte', '.js', '.css']),
    'texte et animation',
  );
  const releves = [];
  for (const chemin of chemins) {
    const interface_ = chemin.startsWith('src/interface/');
    const motifs = interface_ ? ['textLength', 'lengthAdjust', 'transitionend', 'animationend'] : ['textLength', 'lengthAdjust'];
    let texte;
    let parties = [];
    let css = null;
    if (chemin.endsWith('.css')) {
      texte = readFileSync(join(racine, chemin), 'utf8');
      css = parseCss(texte);
    } else if (chemin.endsWith('.svelte')) {
      const analyse = analyserComposant(racine, chemin);
      texte = analyse.texte;
      parties = partiesCode(analyse.ast);
      css = analyse.ast.css;
    } else {
      const analyse = analyserModule(racine, chemin);
      texte = analyse.texte;
      parties = [analyse.ast];
    }
    const relever = (debut, motif) => releves.push({ chemin, ligne: ligneDe(texte, debut), texte: motif });
    for (const { debut, motif } of nomsReleves(parties, motifs)) relever(debut, motif);
    if (!interface_) continue;
    parcourir(parties, (noeud) => {
      const directive = nomDeDirective(noeud);
      if (directive !== null) relever(noeud.start, `directive ${directive}:${noeud.name}`);
    });
    parcourir(css, (noeud) => {
      const anime = noeud.type === 'Declaration' && /^(?:transition|animation)(?:-|$)/.test(noeud.property);
      if (anime && !ANIMATION_ETEINTE.test(noeud.value)) {
        relever(noeud.start, `${noeud.property}: ${noeud.value}`);
      }
      if (noeud.type === 'Atrule' && /keyframes$/i.test(noeud.name)) relever(noeud.start, `@${noeud.name}`);
    });
  }
  return trier(releves);
}

// --- Garde 7 : le câblage (§ 12.9, § 13.3) ------------------------------------

const TRIS_ET_REDUCTIONS = new Set(['sort', 'toSorted', 'reduce', 'reduceRight']);
// Les mesures de la table d'évaluation, que src/application/evaluation.js
// seul importe (§ 12.9).
const MESURES = new Set([
  'mesurer',
  'plafondsRealises',
  'plafondsAPriori',
  'troisChiffres',
  'manques',
  'ecartsAuPlafondAPriori',
  'minimumAtteint',
]);
const EVALUATION = 'src/application/evaluation.js';

// Relevé des calculs écrits dans un composant de src/interface — Math., un tri,
// une réduction —, et des imports d'une mesure dans un module de
// src/application autre qu'evaluation.js : spécificateur d'import ou de
// réexportation, ou membre d'un espace de noms importé.
function releverCablage(racine) {
  const composants = exigerNonVide(sources(racine, ['src/interface'], ['.svelte']), 'câblage des composants');
  const modules = exigerNonVide(sources(racine, ['src/application'], ['.js']), 'imports des mesures');
  const releves = [];
  for (const chemin of composants) {
    const { texte, ast } = analyserComposant(racine, chemin);
    parcourir(partiesCode(ast), (noeud) => {
      if (noeud.type === 'MemberExpression' && noeud.object.type === 'Identifier' && noeud.object.name === 'Math') {
        releves.push({ chemin, ligne: ligneDe(texte, noeud.start), texte: `Math.${nomDeMembre(noeud) ?? '[…]'}` });
      }
      if (noeud.type === 'CallExpression' && noeud.callee.type === 'MemberExpression') {
        const nom = nomDeMembre(noeud.callee);
        if (TRIS_ET_REDUCTIONS.has(nom)) releves.push({ chemin, ligne: ligneDe(texte, noeud.start), texte: `.${nom}(` });
      }
    });
  }
  for (const chemin of modules) {
    if (chemin === EVALUATION) continue;
    const { texte, ast } = analyserModule(racine, chemin);
    const espaces = new Set();
    parcourir(ast, (noeud, ancetres) => {
      if (noeud.type === 'ImportNamespaceSpecifier') espaces.add(noeud.local.name);
      // Une réexportation porte la source de sa déclaration ; un
      // « export { nom } » d'une valeur locale n'importe rien.
      const reexporte = noeud.type === 'ExportSpecifier' && (ancetres.at(-1)?.source ?? null) !== null;
      const importe = noeud.type === 'ImportSpecifier' ? noeud.imported : reexporte ? noeud.local : null;
      const nom = importe === null ? null : (importe.name ?? importe.value);
      if (MESURES.has(nom)) releves.push({ chemin, ligne: ligneDe(texte, noeud.start), texte: `import de ${nom}` });
    });
    parcourir(ast, (noeud) => {
      if (
        noeud.type === 'MemberExpression' &&
        noeud.object.type === 'Identifier' &&
        espaces.has(noeud.object.name) &&
        MESURES.has(nomDeMembre(noeud))
      ) {
        releves.push({ chemin, ligne: ligneDe(texte, noeud.start), texte: `import de ${nomDeMembre(noeud)}` });
      }
    });
  }
  return trier(releves);
}

// --- Garde 8 : les sélecteurs élagués (§ 13.3, § 14.2) ------------------------

// Relevé des avertissements css_unused_selector de chaque composant de
// src/interface, compilé par compile de svelte/compiler sans greffon : une
// règle que le compilateur élague ne peindrait jamais l'état qu'elle vise.
function releverSelecteursElagues(racine) {
  const chemins = exigerNonVide(sources(racine, ['src/interface'], ['.svelte']), 'sélecteurs élagués');
  const releves = [];
  for (const chemin of chemins) {
    const texte = readFileSync(join(racine, chemin), 'utf8');
    const { warnings } = compile(texte, { filename: chemin, generate: false });
    for (const avertissement of warnings) {
      if (avertissement.code !== 'css_unused_selector') continue;
      const debut = avertissement.start?.character ?? 0;
      releves.push({
        chemin,
        ligne: avertissement.start?.line ?? ligneDe(texte, debut),
        texte: `sélecteur élagué ${extrait(texte.slice(debut, avertissement.end?.character ?? debut))}`,
      });
    }
  }
  return trier(releves);
}

// --- Arbres d'épreuve ---------------------------------------------------------

// Écrit dans un répertoire temporaire l'arbre { chemin relatif: contenu }, le
// passe à examiner, puis l'efface ; rend ce que rend examiner.
function avecArbre(fichiers, examiner) {
  const racine = mkdtempSync(join(tmpdir(), 'sources-interface-'));
  try {
    for (const [chemin, contenu] of Object.entries(fichiers)) {
      mkdirSync(dirname(join(racine, chemin)), { recursive: true });
      writeFileSync(join(racine, chemin), contenu);
    }
    return examiner(racine);
  } finally {
    rmSync(racine, { recursive: true, force: true });
  }
}

// Exige un relevé vide ; le message d'échec en donne chaque ligne.
function exigerVide(releves, garde) {
  assert.ok(releves.length === 0, `${garde} : ${releves.length} relevé(s)\n${releves.join('\n')}`);
}

// Un composant d'épreuve : son script, son gabarit, sa feuille.
const composant = ({ script = '', gabarit = '', style = '' }) =>
  `${script === '' ? '' : `<script>\n${script}\n</script>\n`}${gabarit}\n${style === '' ? '' : `<style>\n${style}\n</style>\n`}`;

// Une feuille des jetons minimale, ses deux thèmes complets.
const JETONS_EPREUVE = [
  ':root, :root[data-theme="clair"] { --couleur-a: #ffffff; --couleur-conflit: #b3261e; }',
  ":root[data-theme='sombre'] { --couleur-a: #000000; --couleur-conflit: #ff8a80; }",
  '',
].join('\n');

describe('sources de l’interface : les chaînes visibles en dur (§ 14.6)', () => {
  test('aucun composant de src/interface n’écrit de chaîne visible', () => {
    exigerVide(releverChainesEnDur(RACINE), 'chaînes en dur');
  });

  test('la garde relève un bouton « Modifier » et chaque forme refusée, à toute profondeur, et pas leurs voisines', () => {
    const fichiers = {
      'src/interface/A.svelte': '<button>Modifier</button>\n',
      'src/interface/plan/sous/B.svelte': composant({
        script: "  const t = (cle) => cle;\n  let x = $state(true);",
        gabarit: [
          '<p title="Titre du plan" aria-label={x ? \'Oui\' : t(\'k.non\')}>{t(\'k.titre\')} — {42}</p>',
          '<svg><text>…</text><tspan>{\'·\'}</tspan><desc> </desc><title>{t(\'k.svg\')}</title></svg>',
          '<input placeholder="{x} places" alt={`Image ${x}`} aria-roledescription="table" />',
          '<span>{`${x} places`}</span><span>{x ?? \'Aucun\'}</span><span>{x && \'Plein\'}</span>',
          '<span class="vide" data-x="Nom">{x} / {x}</span><img alt="" />',
          '<span style="content: \'Note\'">.</span>',
          '<!-- Commentaire écrit en dur -->',
        ].join('\n'),
        style: '  .vide::after { content: "Fin"; }\n  .vide::before { content: counter(rang) ". "; }',
      }),
      'src/interface/C.test.js': "export const a = '<button>Modifier</button>';\n",
      'src/interface/D.navigateur.test.js': "export const a = '<button>Modifier</button>';\n",
    };
    assert.deepEqual(avecArbre(fichiers, releverChainesEnDur), [
      'src/interface/A.svelte:1 texte « Modifier »',
      'src/interface/plan/sous/B.svelte:5 attribut aria-label « Oui »',
      'src/interface/plan/sous/B.svelte:5 attribut title « Titre du plan »',
      'src/interface/plan/sous/B.svelte:6 expression littérale « · »',
      'src/interface/plan/sous/B.svelte:6 texte « … »',
      'src/interface/plan/sous/B.svelte:7 attribut alt « Image »',
      'src/interface/plan/sous/B.svelte:7 attribut aria-roledescription « table »',
      'src/interface/plan/sous/B.svelte:7 attribut placeholder « places »',
      'src/interface/plan/sous/B.svelte:8 expression littérale « Aucun »',
      'src/interface/plan/sous/B.svelte:8 expression littérale « Plein »',
      'src/interface/plan/sous/B.svelte:8 expression littérale « places »',
      'src/interface/plan/sous/B.svelte:10 content « content: \'Note\' »',
      'src/interface/plan/sous/B.svelte:13 content « "Fin" »',
    ]);
  });

  test('un arbre sans composant fait échouer la garde', () => {
    assert.throws(
      () => avecArbre({ 'src/interface/a.js': 'export const a = 1;\n' }, releverChainesEnDur),
      /chaînes en dur : aucun fichier examiné/,
    );
  });
});

describe('sources de l’interface : les clés littérales de t existent (§ 14.6, § 19.11)', () => {
  test('chaque clé littérale passée à t dans src/interface existe dans les tables assemblées', () => {
    exigerVide(releverClesAbsentes(RACINE, CLES), 'clés de t');
  });

  test('la garde relève une clé absente, dans un composant comme dans un module, et pas une clé présente ni composée', () => {
    const cles = new Set(['k.present']);
    const fichiers = {
      'src/interface/A.svelte': composant({
        script: "  import { getContext } from 'svelte';\n  const t = getContext('t');\n  const a = t('k.absente');",
        gabarit: "<p>{t('k.present')}</p>\n<p>{t(`k.gabarit`)}</p>\n<p>{t(`k.${a}`)}</p>\n<p>{traduction.t(\"k.membre\")}</p>",
      }),
      'src/interface/plan/modele.js': [
        '// t(\'k.commentaire\') ne compte pas.',
        "export const cle = (t) => t('k.module', { n: 1 });",
        "export const autre = (texte) => texte('k.texte');",
        '',
      ].join('\n'),
      'src/interface/plan/modele.test.js': "t('k.epreuve');\n",
    };
    assert.deepEqual(avecArbre(fichiers, (racine) => releverClesAbsentes(racine, cles)), [
      'src/interface/A.svelte:4 clé absente « k.absente »',
      'src/interface/A.svelte:7 clé absente « k.gabarit »',
      'src/interface/A.svelte:9 clé absente « k.membre »',
      'src/interface/plan/modele.js:2 clé absente « k.module »',
    ]);
  });

  test('un arbre sans source d’interface fait échouer la garde', () => {
    assert.throws(() => avecArbre({ 'src/application/a.js': '' }, (r) => releverClesAbsentes(r, CLES)), /aucun fichier examiné/);
  });

  test('des sources d’interface sans aucune clé littérale passée à t font échouer la garde', () => {
    const fichiers = {
      'src/interface/A.svelte': "<p>{tr('k.absente')}</p>\n",
      'src/interface/B.svelte': composant({
        script: "  import { getContext } from 'svelte';\n  const traduire = getContext('t');",
        gabarit: "<p>{traduire('plan.x')}</p>\n<p>{t(cle)}</p>",
      }),
      'src/interface/c.js': "export const d = (t, n) => t(`k.${n}`);\n",
    };
    assert.throws(() => avecArbre(fichiers, (r) => releverClesAbsentes(r, CLES)), /clés de t : aucune clé examinée/);
  });
});

describe('sources de l’interface : le contenu des tables de traduction (§ 5.5, § 7.6, § 7.7, § 12.8)', () => {
  test('aucune valeur des tables assemblées ne porte un mot refusé ni un pictogramme', () => {
    exigerVide(releverContenuTables([...TABLES_APPLICATION, ...TABLES_INTERFACE], localisateur(RACINE)), 'contenu des tables');
  });

  test('la garde relève chaque mot refusé, sans égard à la casse ni aux accents, dans une chaîne et dans une fonction', () => {
    const refusees = new Map([
      ['a.conforme', 'Conforme'],
      ['a.nonConforme', 'Plan non conforme'],
      ['a.conformite', 'CONFORMITÉ'],
      ['a.ecart', ({ n }) => `Un écart de ${n}`],
      ['a.ecartSeul', (details, texte) => texte('a.ecart', details)],
      ['a.ecartType', 'Écart-type'],
      ['a.satisfaction', 'Taux de satisfaction'],
      ['a.variance', 'variance'],
      ['a.equite', 'Équité'],
      ['a.score', 'Score'],
      ['a.mieux', 'Peut mieux faire'],
      ['a.minimal', 'Manque minimal'],
      ['a.recuperable', 'récupérable'],
      ['a.evitable', 'Évitable'],
      ['a.emoji', ({ n }) => `${n} \u{1F512}`],
      ['a.copyright', '\u{00A9} Club des Merles'],
    ]);
    const admises = new Map([
      ['b.itineraire', 'Écart d\u{2019}itinéraire'],
      ['b.itineraires', "écarts d'itinéraire maximal"],
      ['b.plafond', 'Écart au plafond a priori'],
      ['b.inevitable', 'Inévitable'],
      ['b.ecartee', 'Proposition écartée'],
      ['b.fleche', 'Tour 1 \u{2192} tour 2'],
      ['b.nom', 'Iris Ombrelle'],
      ['b.variable', ({ n }) => {
        const ecart = n + 1;
        return `Tour ${ecart}`;
      }],
    ]);
    assert.deepEqual(releverContenuTables([refusees, admises], () => null, []), [
      "a.conforme : conforme « Conforme »",
      'a.conformite : conforme « CONFORMITÉ »',
      'a.copyright : pictogramme U+00A9 « © Club des Merles »',
      'a.ecart : écart hors du glossaire « Un écart de »',
      'a.ecartType : écart hors du glossaire « Écart-type »',
      'a.ecartType : écart-type « Écart-type »',
      'a.emoji : pictogramme U+1F512 « \u{1F512} »',
      'a.equite : équité « Équité »',
      'a.evitable : évitable « Évitable »',
      'a.mieux : peut mieux faire « Peut mieux faire »',
      'a.minimal : manque minimal « Manque minimal »',
      'a.nonConforme : conforme « Plan non conforme »',
      'a.recuperable : récupérable « récupérable »',
      'a.satisfaction : satisfaction « Taux de satisfaction »',
      'a.score : score « Score »',
      'a.variance : variance « variance »',
    ]);
  });

  test('la garde nomme le fichier et la ligne de la clé fautive, et lève sur des tables vides', () => {
    const fichiers = {
      'src/interface/libelles/plan.js': "export const TABLE = new Map([\n  ['plan.a', 'A'],\n  [\n    'plan.b',\n    'Score',\n  ],\n]);\n",
    };
    const releves = avecArbre(fichiers, (racine) =>
      releverContenuTables([new Map([['plan.a', 'A'], ['plan.b', 'Score']])], localisateur(racine), []),
    );
    assert.deepEqual(releves, ['src/interface/libelles/plan.js:3 plan.b : score « Score »']);
    assert.throws(() => releverContenuTables([new Map()]), /aucune entrée examinée/);
  });

  test('une exception nommée n’admet que sa forme, sous ses clés ; tout autre « évitable » se relève, et une exception que rien ne sert est sans objet', () => {
    const tables = new Map([
      ['diagnostic.remede.un', '2 chaises de plus la rend évitable'],
      ['diagnostic.remede.deux', ({ n }) => (n === 1 ? 'une table la rend évitable' : `${n} tables la rendent évitable`)],
      ['diagnostic.remede.reste', 'la rend évitable, part évitable'],
      ['diagnostic.remede.autre', 'la place devient évitable'],
      ['diagnostic.titre', 'un tabouret la rend évitable'],
      ['plan.segment', 'la rend évitable'],
      ['diagnostic.remede.inevitable', 'inévitable'],
    ]);
    assert.deepEqual(releverContenuTables([tables]), [
      'diagnostic.remede.autre : évitable « la place devient évitable »',
      'diagnostic.remede.reste : évitable « la rend évitable, part évitable »',
      'diagnostic.titre : évitable « un tabouret la rend évitable »',
      'plan.segment : évitable « la rend évitable »',
    ]);
    const sansRemede = new Map([['diagnostic.remede.un', 'ajouter une table']]);
    assert.deepEqual(releverContenuTables([sansRemede]), ['exception sans objet : diagnostic.remede.* « la rend(ent) évitable »']);
  });
});

describe('sources de l’interface : les couleurs (§ 12.7, § 13.3, § 13.5)', () => {
  test('aucun littéral de couleur, aucun jeton déclaré hors de jetons.css, le jeton de conflit lu par les seules règles de conflit du plan', () => {
    exigerVide(releverCouleurs(RACINE), 'couleurs');
  });

  test('chaque jeton de couleur est défini dans les deux thèmes', () => {
    exigerVide(releverThemes(RACINE), 'thèmes');
  });

  test('la garde relève stroke: #c00 et chaque littéral, et pas un jeton ni une adresse de motif', () => {
    const fichiers = {
      'src/interface/jetons.css': JETONS_EPREUVE,
      'src/interface/plan/A.svelte': composant({
        gabarit: '<g class="table"><circle r="1" /></g>',
        style: [
          '  .table { stroke: #c00; }',
          '  .table circle { fill: url(#hachure); stroke: var(--couleur-a); }',
          '  circle { color: rgb(1 2 3); background: Tomato; border-color: transparent currentColor; }',
          '  .table { outline-color: var(--couleur-a, white); --rang: 2; }',
        ].join('\n'),
      }),
      'src/interface/accueil/sous/B.svelte': composant({
        script: "  const couleur = '#ABCDEF';\n  const code = 'orange-sanguine';",
        gabarit: '<svg><rect fill="red" stroke={x ? \'hsl(0 0% 0%)\' : \'none\'} style="color: #fff; --ombre: 1px" style:fill="Canvas" /></svg>\n<Bouton --teinte="1" />',
      }),
      'src/interface/autre.css': '.x { color: #123456; }\n',
      'src/interface/C.navigateur.test.js': "const c = 'stroke: #c00';\n",
    };
    assert.deepEqual(avecArbre(fichiers, releverCouleurs), [
      'src/interface/accueil/sous/B.svelte:2 couleur « #ABCDEF » dans le script',
      'src/interface/accueil/sous/B.svelte:5 couleur « #fff » dans color',
      'src/interface/accueil/sous/B.svelte:5 couleur « Canvas » dans fill',
      'src/interface/accueil/sous/B.svelte:5 couleur « hsl( » dans stroke',
      'src/interface/accueil/sous/B.svelte:5 couleur « red » dans fill',
      'src/interface/accueil/sous/B.svelte:5 jeton déclaré --ombre',
      'src/interface/accueil/sous/B.svelte:6 jeton déclaré --teinte',
      'src/interface/autre.css:1 couleur « #123456 » dans color',
      'src/interface/plan/A.svelte:3 couleur « #c00 » dans stroke',
      'src/interface/plan/A.svelte:5 couleur « Tomato » dans background',
      'src/interface/plan/A.svelte:5 couleur « rgb( » dans color',
      'src/interface/plan/A.svelte:6 couleur « white » dans outline-color',
      'src/interface/plan/A.svelte:6 jeton déclaré --rang',
    ]);
  });

  test('la garde relève un bouton peint du jeton de conflit, et l’admet dans une règle de conflit du plan', () => {
    const fichiers = {
      'src/interface/jetons.css': JETONS_EPREUVE,
      'src/interface/accueil/Bouton.svelte': composant({
        gabarit: '<button class="danger">x</button>',
        style: '  .danger { color: var(--couleur-conflit); }',
      }),
      'src/interface/plan/Table.svelte': composant({
        gabarit: '<g class:conflit={true} class="table"><rect /></g><span style="color: var(--couleur-conflit)">1</span>',
        style: '  .table.conflit rect { stroke: var(--couleur-conflit); }\n  .table rect { fill: var(--couleur-conflit); }',
      }),
      'src/interface/plan/Trou.svelte': composant({
        gabarit: '<g class="table b"><rect /></g><button class="sans-conflit">x</button><i class="non-conflit a"></i>',
        style: [
          '  .table:not(.conflit) rect { fill: var(--couleur-conflit); }',
          '  .sans-conflit { color: var(--couleur-conflit); }',
          '  .non-conflit { color: var(--couleur-conflit); }',
          '  .a, .b.conflit { fill: var(--couleur-conflit); }',
          '  .conflit-leve { fill: var(--couleur-conflit); }',
          '  .b.conflit, .b .trait-conflit, .plateau-en-conflit { stroke: var(--couleur-conflit); }',
        ].join('\n'),
      }),
    };
    assert.deepEqual(avecArbre(fichiers, releverCouleurs), [
      "src/interface/accueil/Bouton.svelte:3 jeton de conflit hors d'une règle de conflit du plan, « .danger »",
      "src/interface/plan/Table.svelte:1 jeton de conflit hors d'une règle de conflit du plan, en ligne",
      "src/interface/plan/Table.svelte:4 jeton de conflit hors d'une règle de conflit du plan, « .table rect »",
      "src/interface/plan/Trou.svelte:3 jeton de conflit hors d'une règle de conflit du plan, « .table:not(.conflit) rect »",
      "src/interface/plan/Trou.svelte:4 jeton de conflit hors d'une règle de conflit du plan, « .sans-conflit »",
      "src/interface/plan/Trou.svelte:5 jeton de conflit hors d'une règle de conflit du plan, « .non-conflit »",
      "src/interface/plan/Trou.svelte:6 jeton de conflit hors d'une règle de conflit du plan, « .a, .b.conflit »",
      "src/interface/plan/Trou.svelte:7 jeton de conflit hors d'une règle de conflit du plan, « .conflit-leve »",
    ]);
  });

  test('la garde des thèmes relève un jeton qu’un thème ne redéfinit pas', () => {
    const fichiers = {
      'src/interface/jetons.css': [
        ':root { --espace-1: 1px; }',
        ':root, :root[data-theme="clair"] { --couleur-sol: #fff; --couleur-gel: #00f; }',
        ":root[data-theme='sombre'] { --couleur-sol: #000; --couleur-fantome: #0f0; }",
        '',
      ].join('\n'),
    };
    assert.deepEqual(avecArbre(fichiers, releverThemes), [
      'src/interface/jetons.css:2 --couleur-gel absent du thème sombre',
      'src/interface/jetons.css:3 --couleur-fantome absent du thème clair',
    ]);
  });

  test('un arbre sans composant ni feuille fait échouer la garde', () => {
    assert.throws(() => avecArbre({ 'src/interface/jetons.css': JETONS_EPREUVE }, releverCouleurs), /couleurs : aucun fichier examiné/);
  });

  test('une feuille des jetons sans jeton de couleur fait échouer la garde des thèmes', () => {
    const fichiers = { 'src/interface/jetons.css': ':root, :root[data-theme="clair"] { --espace-1: 1px; }\n' };
    assert.throws(() => avecArbre(fichiers, releverThemes), /thèmes : aucun jeton de couleur examiné/);
  });
});

describe('sources de l’interface : balisage et fenêtres du navigateur (§ 13.1, § 2.1)', () => {
  test('aucun balisage injecté, aucune fenêtre du navigateur, aucun beforeunload, aucun .message affiché', () => {
    exigerVide(releverBalisageEtFenetres(RACINE), 'balisage et fenêtres');
  });

  test('la garde relève {@html nom} et chaque forme refusée, et pas leurs voisines ni un commentaire', () => {
    const fichiers = {
      'src/interface/A.svelte': composant({
        script: "  let nom = $state('');\n  // aucun beforeunload, jamais alert(…) ni err.message",
        gabarit: '<p>{@html nom}</p>\n<svelte:window onbeforeunload={() => {}} />',
      }),
      'src/interface/plan/sous/b.js': [
        'export function f(el, erreur, seance) {',
        "  el.innerHTML = '';",
        "  el['outerHTML'] = '';",
        "  el.insertAdjacentHTML('beforeend', '');",
        "  document.write('x');",
        "  window.alert('x'); confirm('x'); globalThis.prompt('x');",
        "  addEventListener('beforeunload', f);",
        '  return erreur.message ?? erreur?.message;',
        '}',
        'export const voisins = (s) => [s.confirmer(), s.alert(), s.textContent, s.code, s.messages];',
        '',
      ].join('\n'),
      'src/application/c.js': "export const m = (e) => e.message;\nexport const h = (el) => { el.innerHTML = ''; };\n",
      'src/interface/A.test.js': "window.confirm('x'); el.innerHTML = '';\n",
    };
    assert.deepEqual(avecArbre(fichiers, releverBalisageEtFenetres), [
      'src/application/c.js:2 innerHTML',
      'src/interface/A.svelte:5 {@html}',
      'src/interface/A.svelte:6 beforeunload',
      'src/interface/plan/sous/b.js:2 innerHTML',
      'src/interface/plan/sous/b.js:3 outerHTML',
      'src/interface/plan/sous/b.js:4 insertAdjacentHTML',
      'src/interface/plan/sous/b.js:5 document.write',
      'src/interface/plan/sous/b.js:6 alert(',
      'src/interface/plan/sous/b.js:6 confirm(',
      'src/interface/plan/sous/b.js:6 prompt(',
      'src/interface/plan/sous/b.js:7 beforeunload',
      'src/interface/plan/sous/b.js:8 .message',
      'src/interface/plan/sous/b.js:8 .message',
    ]);
  });

  test('un arbre sans source fait échouer la garde', () => {
    assert.throws(() => avecArbre({ 'src/interface/a.css': '' }, releverBalisageEtFenetres), /aucun fichier examiné/);
  });
});

describe('sources de l’interface : texte comprimé et animations (§ 7.4, § 19.2)', () => {
  test('ni textLength ni lengthAdjust, ni transitionend ni animationend, ni transition ni animation', () => {
    exigerVide(releverTexteEtAnimation(RACINE), 'texte et animation');
  });

  test('la garde relève chaque forme dans son périmètre, et pas hors de lui ni dans un commentaire', () => {
    const fichiers = {
      'src/interface/plan/A.svelte': composant({
        script: "  import { fade } from 'svelte/transition';\n  // ni textLength ni transitionend",
        gabarit: [
          '<text textLength="10" lengthAdjust="spacing">{x}</text>',
          '<div transition:fade ontransitionend={f}></div><p in:fade out:fade></p>',
        ].join('\n'),
        style: '  div { transition: opacity 1s; animation: none; transition-duration: 0s; }\n  @keyframes pulse { to { opacity: 1; } }',
      }),
      'src/geometrie/texte.js': [
        "export const f = (el) => el.setAttribute('textLength', 1);",
        "export const g = 'transitionend';",
        'export const h = (el) => el.getComputedTextLength();',
        "export const i = '[textLength], [lengthAdjust]';",
        '',
      ].join('\n'),
      'src/interface/b.js': "export const f = (el) => el.addEventListener('animationend', f);\n",
      'src/application/c.js': "export const f = 'textLength';\n",
      'src/interface/A.navigateur.test.js': "export const f = '[textLength], [lengthAdjust]';\n",
    };
    assert.deepEqual(avecArbre(fichiers, releverTexteEtAnimation), [
      'src/geometrie/texte.js:1 textLength',
      'src/geometrie/texte.js:4 textLength',
      'src/interface/b.js:1 animationend',
      'src/interface/plan/A.svelte:5 lengthAdjust',
      'src/interface/plan/A.svelte:5 textLength',
      'src/interface/plan/A.svelte:6 directive in:fade',
      'src/interface/plan/A.svelte:6 directive out:fade',
      'src/interface/plan/A.svelte:6 directive transition:fade',
      'src/interface/plan/A.svelte:6 transitionend',
      'src/interface/plan/A.svelte:8 transition: opacity 1s',
      'src/interface/plan/A.svelte:9 @keyframes',
    ]);
  });

  test('un arbre sans source fait échouer la garde', () => {
    assert.throws(() => avecArbre({ 'src/application/a.js': '' }, releverTexteEtAnimation), /aucun fichier examiné/);
  });
});

describe('sources de l’interface : le câblage (§ 12.9, § 13.3)', () => {
  test('aucun composant ne calcule, et seul evaluation.js importe les mesures', () => {
    exigerVide(releverCablage(RACINE), 'câblage');
  });

  test('la garde relève Math., .sort( et .reduce( dans un composant, et l’import d’une mesure hors d’evaluation.js', () => {
    const fichiers = {
      'src/interface/plan/A.svelte': composant({
        script: '  let liste = $state([]);\n  const tries = $derived(liste.toSorted());\n  // Math.max, liste.sort()',
        gabarit: '<p>{Math.round(liste.length)}</p>\n<p>{liste.reduce((s, x) => s + x, 0)}</p>\n<p>{liste.sort().join()}</p>\n<p>{liste.filter(Boolean).length}</p>',
      }),
      'src/interface/b.js': 'export const f = (l) => Math.max(...l.sort());\n',
      'src/application/evaluation.js': "import { mesurer, manques } from '../moteur/indicateurs.js';\nexport { mesurer };\n",
      'src/application/generation.js': [
        "import { troisChiffres as chiffres } from '../moteur/indicateurs.js';",
        "import * as indicateurs from '../moteur/indicateurs.js';",
        "export { minimumAtteint } from '../moteur/indicateurs.js';",
        'export const f = (x) => indicateurs.plafondsRealises(x) + indicateurs.autre(x);',
        "import { evaluer } from './evaluation.js';",
        '',
      ].join('\n'),
      'src/application/generation.test.js': "import { mesurer } from '../moteur/indicateurs.js';\n",
    };
    assert.deepEqual(avecArbre(fichiers, releverCablage), [
      'src/application/generation.js:1 import de troisChiffres',
      'src/application/generation.js:3 import de minimumAtteint',
      'src/application/generation.js:4 import de plafondsRealises',
      'src/interface/plan/A.svelte:3 .toSorted(',
      'src/interface/plan/A.svelte:6 Math.round',
      'src/interface/plan/A.svelte:7 .reduce(',
      'src/interface/plan/A.svelte:8 .sort(',
    ]);
  });

  test('un arbre sans composant fait échouer la garde', () => {
    assert.throws(() => avecArbre({ 'src/application/a.js': '' }, releverCablage), /câblage des composants : aucun fichier examiné/);
  });
});

describe('sources de l’interface : les sélecteurs élagués (§ 13.3, § 14.2)', () => {
  test('aucun composant ne porte une règle que le compilateur élague', () => {
    exigerVide(releverSelecteursElagues(RACINE), 'sélecteurs élagués');
  });

  test('la garde relève une règle .conflit qui vise un élément sans classe dynamique, et admet class:conflit', () => {
    const fichiers = {
      'src/interface/plan/sous/Table.svelte': composant({
        gabarit: '<g class="table"><rect /></g>',
        style: '  .table { stroke-width: 1; }\n  .table.conflit rect { stroke-width: 3; }',
      }),
      'src/interface/plan/Table2.svelte': composant({
        script: '  let { conflit } = $props();',
        gabarit: '<g class="table" class:conflit><rect /></g>',
        style: '  .table.conflit rect { stroke-width: 3; }',
      }),
    };
    assert.deepEqual(avecArbre(fichiers, releverSelecteursElagues), [
      'src/interface/plan/sous/Table.svelte:4 sélecteur élagué « .table.conflit rect »',
    ]);
  });

  test('un arbre sans composant fait échouer la garde', () => {
    assert.throws(() => avecArbre({ 'src/interface/a.js': '' }, releverSelecteursElagues), /aucun fichier examiné/);
  });
});