@starterlib/cli 0.10.2

package/src/etapes/jetons.mjs

@@ -0,0 +1,107 @@
+/**
+ * Etape `jetons` (lot 157, A0921) : chaque `var(--st-*)` SANS repli lue par une feuille de la SPA
+ * existe dans les feuilles de `@starterlib/tokens` INSTALLE, ou dans la liste des jetons poses a
+ * l'execution. Une reference avec repli (`var(--st-x, 1.5rem)`) est toleree : le repli s'applique
+ * quand le jeton manque.
+ *
+ * Le defaut qu'elle ferme : `font-family: var(--st-police-texte)`, un jeton qui n'a jamais existe.
+ * Une declaration `var()` vers une propriete inexistante est invalide au calcul, et la propriete
+ * retombe sur sa valeur initiale : le corps de la coquille s'affichait dans la police par defaut du
+ * navigateur, sans une erreur nulle part.
+ *
+ * Sont lues les feuilles `.scss` et `.css` sous `src/`, et les styles EN LIGNE des composants
+ * (`styles: \`...\``), que la copie de la coquille ne voyait pas.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fichiers, relatif } from '../commun.mjs';
+
+/** Poses a l'execution par un composant du socle, donc absents des feuilles engendrees. */
+const POSES_A_L_EXECUTION = new Set([
+  // st-app-shell mesure l'en-tete collant et publie sa hauteur (scroll-padding de la page).
+  '--st-hauteur-entete',
+]);
+
+/** Une lecture de jeton : son nom, et le caractere qui suit (`,` : avec repli ; `)` : sans). */
+const LECTURE = /var\(\s*(--st-[A-Za-z0-9-]+)\s*([,)])/g;
+/** Une declaration de jeton dans une feuille du socle. */
+const DECLARATION = /(--st-[A-Za-z0-9-]+)\s*:/g;
+/** Les styles en ligne d'un composant : `styles: \`...\`` ou `styles: [\`...\`]`. */
+const STYLES_EN_LIGNE = /\bstyles\s*:\s*\[?\s*`([^`]*)`/g;
+
+/**
+ * Les commentaires retires, longueur conservee : un jeton cite dans un commentaire n'est pas lu, et
+ * les numeros de ligne restent justes. Un `//` precede de `:` est une adresse, pas un commentaire.
+ */
+function sansCommentaires(texte) {
+  const blanc = (morceau) => morceau.replace(/[^\n]/g, ' ');
+  return texte
+    .replace(/\/\*[\s\S]*?\*\//g, blanc)
+    .replace(/(^|[^:])(\/\/[^\n]*)/g, (_, avant, commentaire) => avant + blanc(commentaire));
+}
+
+function ligne(texte, indice) {
+  return texte.slice(0, indice).split('\n').length;
+}
+
+/** Les defauts des `feuilles` (`{ nom, texte }`) contre les jetons `definis`. */
+export function jugerLesJetons(feuilles, definis) {
+  const defauts = [];
+  let lues = 0;
+  for (const { nom, texte } of feuilles) {
+    const propre = sansCommentaires(texte);
+    for (const lecture of propre.matchAll(LECTURE)) {
+      const [, jeton, suite] = lecture;
+      if (suite === ',') continue;
+      lues += 1;
+      if (!definis.has(jeton) && !POSES_A_L_EXECUTION.has(jeton)) {
+        defauts.push(
+          `${nom}:${String(ligne(propre, lecture.index))} : var(${jeton}) sans repli, jeton absent ` +
+            'de @starterlib/tokens. Corriger le nom, ou poser un repli (var(--st-x, valeur)).',
+        );
+      }
+    }
+  }
+  return { defauts, lues };
+}
+
+export default {
+  nom: 'jetons',
+  roles: ['remote', 'hote'],
+  executer(projet) {
+    const socle = join(projet.racine, 'node_modules', '@starterlib', 'tokens', 'styles');
+    const definis = new Set();
+    for (const feuille of fichiers(socle).filter((chemin) => chemin.endsWith('.css'))) {
+      for (const [, nom] of readFileSync(feuille, 'utf8').matchAll(DECLARATION)) definis.add(nom);
+    }
+    if (definis.size === 0) {
+      return {
+        defauts: [`aucun jeton lu dans ${relatif(projet.racine, socle)} : pnpm install d'abord.`],
+      };
+    }
+
+    const sources = join(projet.racine, 'src');
+    const feuilles = [];
+    for (const chemin of fichiers(sources)) {
+      const nom = relatif(projet.racine, chemin);
+      if (chemin.endsWith('.scss') || chemin.endsWith('.css')) {
+        feuilles.push({ nom, texte: readFileSync(chemin, 'utf8') });
+      } else if (chemin.endsWith('.ts') && !chemin.endsWith('.spec.ts')) {
+        for (const [, style] of readFileSync(chemin, 'utf8').matchAll(STYLES_EN_LIGNE)) {
+          feuilles.push({ nom, texte: style });
+        }
+      }
+    }
+    // Une garde qui n'a rien lu ne prouve rien : zero feuille est un defaut, pas un succes.
+    if (feuilles.length === 0) {
+      return {
+        defauts: ['aucune feuille ni style en ligne sous src/ : la garde n a rien analyse.'],
+      };
+    }
+    const { defauts, lues } = jugerLesJetons(feuilles, definis);
+    return {
+      defauts,
+      resume: `${String(lues)} lecture(s) sans repli dans ${String(feuilles.length)} feuille(s), toutes definies.`,
+    };
+  },
+};

package/src/etapes/manifeste.mjs

@@ -0,0 +1,120 @@
+/**
+ * Etape `manifeste` : le manifeste CONSTRUIT respecte le contrat que le BFF verifie a l'agregation
+ * — ici, avant la livraison, quand c'est encore gratuit. Un manifeste refuse par le BFF est un
+ * remote invisible, sans autre symptome qu'un compteur.
+ *
+ * Les regles ne sont plus recopiees (lot 177, constats A0817 et A0906) : l'etape applique celles
+ * que `@starterlib/core` INSTALLE publie — `validerLeManifesteDeRemote`, miroir de
+ * ValidationDuManifeste du socle Java, et le schema JSON, plus strict (un champ inconnu y est une
+ * faute de frappe). Un corpus commun (`schemas/corpus-de-manifestes.json`) prouve que le schema,
+ * le TypeScript et le Java rendent le meme verdict.
+ *
+ * S'y ajoute ce qu'aucun des deux ne peut voir : le nom est le meme partout ou il sert de cle
+ * (`angular.json`, `dist/<nom>/browser`, `manifest.source.json`), les actifs annonces sont livres,
+ * et chaque module de route est expose par `remoteEntry.json`.
+ *
+ * Pour l'hote, le manifeste de la coquille : ce que le BFF lit pour dire aux remotes quel train il
+ * embarque (`CoquilleDeclaree`).
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { lireJson } from '../commun.mjs';
+import { validerSelonLeSchema } from '../schema.mjs';
+import { contratDeFederation } from '../socle-installe.mjs';
+
+const VERSION_EXACTE = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
+const TRAIN = /^\d+\.\d+$/;
+
+const chaine = (valeur) => typeof valeur === 'string' && valeur.length > 0;
+
+/**
+ * Ce que ni le schema ni le validateur du socle ne voient : les actifs annonces et livres, les
+ * modules des routes exposes, `pleinePage` tel qu'attendu. `exposes` : cles de `remoteEntry.json` ;
+ * `existe(chemin)` : l'actif est-il livre.
+ */
+export function jugerLaLivraison(m, { attendu, exposes, existe }) {
+  const defauts = [];
+  const prefixe = `/ui/${String(m.nom)}/`;
+  if (typeof m.pleinePage === 'boolean' && m.pleinePage !== attendu.pleinePage) {
+    defauts.push(`pleinePage ${String(m.pleinePage)}, attendu ${String(attendu.pleinePage)}.`);
+  }
+  for (const route of Array.isArray(m.routes) ? m.routes : []) {
+    if (chaine(route.module) && !exposes.has(route.module)) {
+      defauts.push(
+        `route ${String(route.prefixe)} : ${route.module} n'est pas expose par remoteEntry.json.`,
+      );
+    }
+  }
+  const annonces = [m.remoteEntry, ...Object.values(m.i18n?.catalogues ?? {}), m.sprite].filter(
+    chaine,
+  );
+  for (const url of annonces) {
+    if (url.startsWith(prefixe) && !existe(url.slice(prefixe.length))) {
+      defauts.push(`fichier annonce absent : ${url}.`);
+    }
+  }
+  return defauts;
+}
+
+/** Le nom est le meme partout ou il sert de cle. */
+function jugerLesNoms(projet) {
+  const defauts = [];
+  const { nom } = projet;
+  if (projet.source?.nom !== nom) {
+    defauts.push(`manifest.source.json : nom ${String(projet.source?.nom)}, attendu ${nom}.`);
+  }
+  if (projet.nomDuProjetAngular !== nom) {
+    defauts.push(`angular.json : projet ${projet.nomDuProjetAngular}, attendu ${nom}.`);
+  }
+  if (projet.sortieRelative !== `dist/${nom}/browser`) {
+    defauts.push(`angular.json : sortie ${projet.sortieRelative}, attendu dist/${nom}/browser.`);
+  }
+  return defauts;
+}
+
+function manifesteDeLHote(m) {
+  const defauts = [];
+  if (m.nom !== 'socle') defauts.push(`nom ${String(m.nom)}, attendu socle.`);
+  if (!VERSION_EXACTE.test(String(m.version))) defauts.push('version : exacte attendue.');
+  if (!VERSION_EXACTE.test(String(m.socle?.construit))) {
+    defauts.push('socle.construit : version exacte attendue.');
+  }
+  if (!TRAIN.test(String(m.angular))) defauts.push('angular : train attendu.');
+  return { defauts, resume: `coquille ${String(m.version)}, socle ${String(m.socle?.construit)}.` };
+}
+
+export default {
+  nom: 'manifeste',
+  roles: ['remote', 'hote'],
+  async executer(projet) {
+    const m = lireJson(join(projet.sortie, 'manifest.json'));
+    if (m === null) {
+      return { defauts: [`${projet.sortieRelative}/manifest.json absent : construire d'abord.`] };
+    }
+    if (projet.role === 'hote') return manifesteDeLHote(m);
+
+    const entree = lireJson(join(projet.sortie, 'remoteEntry.json'));
+    if (entree === null) {
+      return {
+        defauts: [`${projet.sortieRelative}/remoteEntry.json absent : construire d'abord.`],
+      };
+    }
+    const contrat = await contratDeFederation(projet.racine);
+    const defauts = [
+      ...jugerLesNoms(projet),
+      ...contrat.validerLeManifesteDeRemote(m, projet.nom),
+      ...validerSelonLeSchema(contrat.schema, m).map((probleme) => `schema : ${probleme}`),
+      ...jugerLaLivraison(m, {
+        attendu: { pleinePage: projet.pleinePage },
+        exposes: new Set((entree.exposes ?? []).map((expose) => expose.key)),
+        existe: (chemin) => existsSync(join(projet.sortie, chemin)),
+      }),
+    ];
+    return {
+      defauts,
+      resume:
+        `${String(m.nom)} ${String(m.version)}, ${String(m.routes?.length ?? 0)} route(s), ` +
+        `contrat et schema de @starterlib/core ${contrat.version}.`,
+    };
+  },
+};

package/src/etapes/outillage.mjs

@@ -0,0 +1,116 @@
+/**
+ * Les etapes qui DELEGUENT a l'outillage de la SPA : format, lint, test, contrat.
+ *
+ * Le CLI ne remplace ni Prettier, ni ESLint, ni le lanceur d'essais : il les appelle dans l'ordre du
+ * plan SPA §3, depuis le `node_modules` de la SPA (`pnpm exec`), pour que chacun lise la
+ * configuration du depot. Le lint verifie d'abord, lui-meme, le prefixe des selecteurs : c'est la
+ * regle de nommage du plan §4 (`<abrege>-*`, jamais `st-`), que chaque configuration ESLint
+ * recopiee ecrivait a sa facon jusqu'a `@starterlib/eslint-config` (lot 178).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { executer, fichiers, relatif } from '../commun.mjs';
+
+/** Un prefixe de selecteur : deux a huit minuscules ou chiffres, jamais celui du socle. */
+const PREFIXE = /^[a-z][a-z0-9]{1,7}$/;
+/** Le selecteur d'element d'un composant : `selector: 'ct-produits'`. */
+const SELECTEUR_D_ELEMENT = /\bselector\s*:\s*['"]([a-z][a-z0-9]*-[a-z0-9-]*)['"]/g;
+
+/** Les defauts de prefixe : `sources` est une liste de `{ nom, texte }`. */
+export function jugerLesSelecteurs(prefixe, sources) {
+  if (prefixe === null || prefixe === undefined) {
+    return ['prefixe de selecteur absent : prefix du projet dans angular.json, ou --prefixe.'];
+  }
+  if (prefixe === 'st') return ['prefixe "st" : reserve aux composants du socle.'];
+  if (!PREFIXE.test(prefixe)) return [`prefixe "${prefixe}" : deux a huit minuscules attendues.`];
+  const defauts = [];
+  for (const { nom, texte } of sources) {
+    for (const [, selecteur] of texte.matchAll(SELECTEUR_D_ELEMENT)) {
+      if (!selecteur.startsWith(`${prefixe}-`)) {
+        defauts.push(`${nom} : selecteur "${selecteur}" hors du prefixe "${prefixe}-".`);
+      }
+    }
+  }
+  return defauts;
+}
+
+/** Le resultat d'une commande deleguee : `resume` si elle reussit, son code sinon. */
+function deleguer(projet, arguments_, resume) {
+  const code = executer('pnpm', arguments_, projet.racine);
+  return code === 0
+    ? { defauts: [], resume }
+    : { defauts: [`pnpm ${arguments_.join(' ')} : code ${String(code)}.`] };
+}
+
+export const format = {
+  nom: 'format',
+  roles: ['remote', 'hote'],
+  executer: (projet) =>
+    deleguer(projet, ['exec', 'prettier', '--check', '.'], 'prettier --check . conforme.'),
+};
+
+/** Les fichiers de configuration que stylelint lit a la racine d'une SPA. */
+const CONFIGURATIONS_STYLELINT = [
+  '.stylelintrc.json',
+  '.stylelintrc',
+  'stylelint.config.mjs',
+  'stylelint.config.js',
+];
+
+export const lint = {
+  nom: 'lint',
+  roles: ['remote', 'hote'],
+  preparation: 'sprite',
+  executer(projet) {
+    const sources = fichiers(join(projet.racine, 'src'))
+      .filter((chemin) => chemin.endsWith('.ts') && !chemin.endsWith('.spec.ts'))
+      .map((chemin) => ({
+        nom: relatif(projet.racine, chemin),
+        texte: readFileSync(chemin, 'utf8'),
+      }));
+    const selecteurs = jugerLesSelecteurs(projet.prefixe, sources);
+    if (selecteurs.length > 0) return { defauts: selecteurs };
+    // Les feuilles sous stylelint (lot 178) : jetons, pixels, plans, ordre du DOM. La configuration
+    // etend celle du socle (@starterlib/eslint-config/stylelint) ; sans elle, rien n'est garde.
+    if (!CONFIGURATIONS_STYLELINT.some((nom) => existsSync(join(projet.racine, nom)))) {
+      return {
+        defauts: [
+          'configuration stylelint absente : .stylelintrc.json qui etend @starterlib/eslint-config/stylelint.',
+        ],
+      };
+    }
+    const eslint = deleguer(
+      projet,
+      ['exec', 'eslint', '.'],
+      `selecteurs en ${String(projet.prefixe)}-, eslint . conforme.`,
+    );
+    if (eslint.defauts.length > 0) return eslint;
+    return deleguer(
+      projet,
+      ['exec', 'stylelint', 'src/**/*.{scss,css}', '--allow-empty-input'],
+      `selecteurs en ${String(projet.prefixe)}-, eslint . et stylelint conformes.`,
+    );
+  },
+};
+
+export const test = {
+  nom: 'test',
+  roles: ['remote', 'hote'],
+  preparation: 'sprite',
+  executer: (projet) => deleguer(projet, ['exec', 'ng', 'test', '--no-watch'], 'ng test conforme.'),
+};
+
+/**
+ * `contrat` : le client d'API engendre depuis le contrat du service, sans difference (lot 175).
+ * Tant que la SPA n'a pas de script `contrat:check`, l'etape est sautee, et le dit.
+ */
+export const contrat = {
+  nom: 'contrat',
+  roles: ['remote', 'hote'],
+  executer(projet) {
+    if (projet.paquet.scripts?.['contrat:check'] === undefined) {
+      return { sautee: 'aucun script contrat:check (client engendre : lot 175).' };
+    }
+    return deleguer(projet, ['run', 'contrat:check'], 'client engendre sans difference.');
+  },
+};

package/src/etapes/securite.mjs

@@ -0,0 +1,239 @@
+/**
+ * Etape `securite` : ce qui est LIVRE (`dist/<nom>/browser`), pas les sources : c'est le code
+ * construit qui tourne sous la politique de securite du contenu, dependances transitives comprises
+ * — la ou le lint ne voit que les sources. Chaque motif ferme un risque nomme (ADR 0029).
+ *
+ * Pour tout fichier livre, cadre compris :
+ * - eval, new Function, stockage du navigateur, lecture de cookie ;
+ * - politiques Trusted Types comparees a la liste EXACTE du BFF
+ *   (`platform.web.headers.csp.trusted-types-policies`) ;
+ * - cartes de source (et leurs variantes compressees), script dans un SVG ;
+ * - dans une page HTML : balise meta de politique de securite, script ou feuille EN LIGNE.
+ *
+ * Pour le code de la SPA (tout ce que `remoteEntry.json` ne declare pas partage, lot 177, constats
+ * A0812, A0843, A0889) :
+ * - bypassSecurityTrust*, ecriture HTML (innerHTML, outerHTML, insertAdjacentHTML,
+ *   document.write), style pose par setAttribute, Function( et minuterie sur une chaine ;
+ * - feuilles et ressources d'un autre domaine (`@import`, `url(//...)`) ;
+ * - un remote seulement : fetch et XMLHttpRequest (tout passe par le HttpClient de l'hote, regle
+ *   13), `:root` et `!important` (un remote ne redefinit ni ne force la cascade du socle), et les
+ *   marqueurs de l'hote de developpement (A0840 : fixtures, comptes et backend simule livres).
+ *
+ * Le code du cadre (Angular, le socle, leurs morceaux internes) ecrit innerHTML, appelle fetch et
+ * pose `:root` : il n'est pas juge sur ces puits-la, et la garde de securite du socle juge deja ses
+ * paquets construits.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fichiers, lireJson, relatif } from '../commun.mjs';
+import { natureDesFichiers } from '../livraison.mjs';
+
+/** Les politiques que la CSP du BFF laisse creer (application.yml du BFF). */
+export const POLITIQUES_ADMISES = ['angular', 'angular#components', 'es-module-shims', 'nfo'];
+
+const CREATION_DE_POLITIQUE = /trustedTypes\s*\.\s*createPolicy\(\s*['"]([^'"]*)['"]/g;
+
+/** Pour tout fichier livre, cadre compris. */
+const MOTIFS = [
+  { motif: /\beval\(/, raison: 'eval : interdit par script-src' },
+  { motif: /new Function\(/, raison: 'new Function : interdit par script-src' },
+  { motif: /localStorage|sessionStorage|indexedDB/, raison: 'stockage navigateur (ADR 0014)' },
+  { motif: /document\.cookie/, raison: 'lecture de cookie : le cookie de session est HttpOnly' },
+];
+
+/** Un SVG peut porter du script : le sprite est servi en meme origine. */
+const MOTIFS_SVG = [
+  { motif: /<script/i, raison: 'script dans un SVG livre' },
+  { motif: /\son\w+\s*=/i, raison: "gestionnaire d'evenement en ligne dans un SVG" },
+  { motif: /javascript:/i, raison: 'adresse javascript: dans un SVG' },
+];
+
+/** Le code de la SPA, hote ou remote (ADR 0029, regle 6). */
+const PUITS_DE_LA_SPA = [
+  {
+    motif: /bypassSecurityTrust(?:Html|Style|Script|Url|ResourceUrl)\b/,
+    raison:
+      "bypassSecurityTrust* : la politique angular#unsafe-bypass n'est pas admise, et le desinfectant est contourne",
+  },
+  {
+    motif: /\.(?:innerHTML|outerHTML)\s*=(?!=)/,
+    raison: 'ecriture HTML directe : puits Trusted Types, et vecteur XSS',
+  },
+  { motif: /insertAdjacentHTML\s*\(|document\.write\s*\(/, raison: 'ecriture HTML directe' },
+  {
+    motif: /setAttribute\(\s*["']style["']/,
+    raison: "style pose par setAttribute : refuse sans 'unsafe-inline'",
+  },
+  { motif: /(?<![\w$.])Function\s*\(/, raison: 'Function( : execution de chaine, interdite' },
+  {
+    motif: /\bset(?:Timeout|Interval)\(\s*["'`]/,
+    raison: 'minuterie sur une chaine : execution de chaine, interdite',
+  },
+  {
+    motif: /@import\s+(?:url\()?\s*["']?(?:https?:)?\/\//,
+    raison: "feuille importee d'un autre domaine",
+  },
+  {
+    // Hors d'un `@import`, deja dit par la regle precedente.
+    motif: /(?<!@import\s*)url\(\s*["']?(?:https?:)?\/\//,
+    raison: "ressource d'un autre domaine dans une feuille",
+  },
+];
+
+/** Le code d'un remote seulement. */
+const PUITS_D_UN_REMOTE = [
+  {
+    motif: /\bfetch\(|new XMLHttpRequest\(/,
+    raison: "appel reseau hors du HttpClient de l'hote (ADR 0029, regle 13)",
+  },
+  { motif: /:root\b/, raison: ':root : un remote ne redefinit pas les jetons du socle' },
+  { motif: /!important/, raison: '!important : un remote ne force pas la cascade du socle' },
+  {
+    motif: /\bbootstrapApplication\b/,
+    raison:
+      "un remote ne demarre jamais seul en production : l'hote de developpement est livre (A0840)",
+  },
+  {
+    motif: /selectors:\[\["[a-z][a-z0-9]*-[a-z0-9-]*-dev"/,
+    raison: "composant de l'hote de developpement livre en production (A0840)",
+  },
+  { motif: /\bhote-dev\b/, raison: "marqueur de l'hote de developpement livre (A0840)" },
+];
+
+/**
+ * Les politiques que le CADRE declare sans que l'application les cree. `angular#unsafe-bypass` est
+ * ecrite dans le code d'Angular (morceau partage `_angular_core`), et n'est creee que si
+ * l'application appelle `bypassSecurityTrust*` — ce que le socle interdit : son absence de la liste
+ * du BFF fait echouer un tel appel a l'ecran, sous la politique reelle. La trouver ailleurs que dans
+ * ce morceau reste un defaut. (Vu au premier passage du CLI sur les quatre SPA, lot 174 : la copie
+ * la laissait passer par son filtre de prefixe.)
+ */
+const POLITIQUES_DU_CADRE = [{ fichier: /^_angular_core\./, politique: 'angular#unsafe-bypass' }];
+
+/**
+ * Ce que le CADRE lit, et que l'application ne lit pas. Un morceau partage par la federation
+ * (`_angular_*`) contient le code d'Angular tel quel ; chaque exception nomme le fichier ET le motif.
+ */
+const EXCEPTIONS_DU_CADRE = [
+  {
+    fichier: /^_angular_platform_browser\./,
+    motif: /document\.cookie/,
+    // `DomAdapter.getCookie` : lu par l'extracteur XSRF d'Angular, qui cherche un cookie
+    // `XSRF-TOKEN` que le BFF ne pose jamais (le jeton anti-falsification vient de /bff/session).
+    raison: 'lecture de cookie par le cadre, sans cookie lisible a lire',
+  },
+];
+
+/** Les types d'un script EN LIGNE qui ne s'executent pas : des donnees (`esms-options`, cartes). */
+const SCRIPTS_DE_DONNEES = new Set([
+  'esms-options',
+  'importmap',
+  'importmap-shim',
+  'application/json',
+  'application/ld+json',
+]);
+
+/** Directives qu'une balise meta ignore : les y ecrire laisse croire a une protection absente. */
+const IGNOREES_PAR_UNE_BALISE = ['frame-ancestors', 'report-uri', 'report-to', 'sandbox'];
+
+function jugerUnePage(nom, contenu) {
+  const defauts = [];
+  for (const [, attributs] of contenu.matchAll(/<script\b([^>]*)>/gi)) {
+    if (/\bsrc\s*=/i.test(attributs)) continue;
+    const type = /\btype\s*=\s*["']?([^"'\s>]+)/i.exec(attributs)?.[1]?.toLowerCase() ?? '';
+    if (!SCRIPTS_DE_DONNEES.has(type)) {
+      defauts.push(`${nom} : script en ligne (type "${type}") : refuse par script-src sans nonce.`);
+    }
+  }
+  if (/<style\b/i.test(contenu)) {
+    defauts.push(`${nom} : feuille en ligne (<style>) : refusee par style-src sans nonce.`);
+  }
+  for (const [balise] of contenu.matchAll(
+    /<meta[^>]+http-equiv=["']Content-Security-Policy[^>]*>/gi,
+  )) {
+    const ignorees = IGNOREES_PAR_UNE_BALISE.filter((directive) => balise.includes(directive));
+    defauts.push(
+      `${nom} : politique de securite du contenu en balise meta ecrite dans le livrable (ADR 0015 : ` +
+        'le serveur la pose ; lot 122)' +
+        (ignorees.length === 0 ? '.' : ` ; ${ignorees.join(', ')} y est ignore par le navigateur.`),
+    );
+  }
+  return defauts;
+}
+
+/**
+ * Les defauts d'un fichier livre `nom` (relatif au dossier livre) de contenu `contenu`. `role` :
+ * `remote` ou `hote` ; `partage` : le fichier est du code du cadre, partage par la federation.
+ */
+export function jugerUnFichierLivre(nom, contenu, { role = 'remote', partage = false } = {}) {
+  // Une carte, ou sa variante compressee : `/x.js.map.br` se servirait aussi bien que l'original.
+  if (/\.map(?:\.br|\.gz)?$/.test(nom)) {
+    return [`${nom} : carte de source livree (sourceMap doit rester false en production).`];
+  }
+  const defauts = [];
+  if (nom.endsWith('.svg')) {
+    for (const { motif, raison } of MOTIFS_SVG) {
+      if (motif.test(contenu)) defauts.push(`${nom} : ${raison}.`);
+    }
+    return defauts;
+  }
+  if (!/\.(?:m?js|html|css)$/.test(nom)) return defauts;
+
+  if (!nom.endsWith('.css')) {
+    for (const { motif, raison } of MOTIFS) {
+      const tolere = EXCEPTIONS_DU_CADRE.some(
+        (exception) => exception.fichier.test(nom) && exception.motif.source === motif.source,
+      );
+      if (!tolere && motif.test(contenu)) defauts.push(`${nom} : ${raison}.`);
+    }
+    for (const [, politique] of contenu.matchAll(CREATION_DE_POLITIQUE)) {
+      const duCadre = POLITIQUES_DU_CADRE.some(
+        (exception) => exception.fichier.test(nom) && exception.politique === politique,
+      );
+      if (!POLITIQUES_ADMISES.includes(politique) && !duCadre) {
+        defauts.push(
+          `${nom} : politique Trusted Types hors liste ("${politique}" ; admises : ` +
+            `${POLITIQUES_ADMISES.join(', ')}). La declarer au BFF avant livraison.`,
+        );
+      }
+    }
+  }
+  if (nom.endsWith('.html')) defauts.push(...jugerUnePage(nom, contenu));
+
+  if (!partage) {
+    const puits = role === 'remote' ? [...PUITS_DE_LA_SPA, ...PUITS_D_UN_REMOTE] : PUITS_DE_LA_SPA;
+    for (const { motif, raison } of puits) {
+      if (motif.test(contenu)) defauts.push(`${nom} : ${raison}.`);
+    }
+  }
+  return defauts;
+}
+
+export default {
+  nom: 'securite',
+  roles: ['remote', 'hote'],
+  executer(projet) {
+    // Les variantes precompressees derivent des fichiers lus ; celles d'une carte sont signalees.
+    const livres = fichiers(projet.sortie).filter(
+      (chemin) => !/\.(?:br|gz)$/.test(chemin) || /\.map\.(?:br|gz)$/.test(chemin),
+    );
+    if (livres.length === 0) {
+      return {
+        defauts: [`aucune construction dans ${projet.sortieRelative} : construire d'abord.`],
+      };
+    }
+    const { partages } = natureDesFichiers(lireJson(join(projet.sortie, 'remoteEntry.json')));
+    const defauts = [];
+    for (const chemin of livres) {
+      const nom = relatif(projet.sortie, chemin);
+      const contenu = /\.(?:m?js|html|svg|css)$/.test(nom) ? readFileSync(chemin, 'utf8') : '';
+      defauts.push(
+        ...jugerUnFichierLivre(nom, contenu, { role: projet.role, partage: partages.has(nom) }),
+      );
+    }
+    return {
+      defauts,
+      resume: `${String(livres.length)} fichier(s) livre(s) dont ${String(partages.size)} du cadre partage, rien a signaler.`,
+    };
+  },
+};