@starterlib/cli 0.10.2

package/src/etapes/dependances.mjs

@@ -0,0 +1,108 @@
+/**
+ * Etape `dependances` : ce qu'une SPA a le droit d'installer (plan SPA §4, « Dependances »).
+ *
+ * - En production (`dependencies`), une liste REVUE : Angular, les paquets du socle servis a la page,
+ *   rxjs, tslib et es-module-shims. Tout autre paquet s'ajoute par `starterWeb.dependancesAdmises`,
+ *   avec sa raison ECRITE (quarante caracteres au moins) : la revue se lit dans le depot.
+ * - Nulle part : zone.js, TanStack, Angular Material, une bibliotheque de traduction concurrente,
+ *   une bibliotheque d'icones (le sprite du socle et celui du remote suffisent).
+ * - En developpement seulement : le harnais de test et ce CLI, jamais servis a une page.
+ * - Aucun outil du socle recopie sous `tools/` : une copie est une dependance cachee, que le socle
+ *   ne peut plus corriger (les huit copies divergeaient deja, audit du 2026-09-20).
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const LONGUEUR_MINIMALE_D_UNE_RAISON = 40;
+
+/** Ce qu'une page peut charger sans revue. */
+const ADMIS_EN_PRODUCTION = [
+  /^@angular\/(?:core|common|compiler|forms|platform-browser|router|cdk|aria)$/,
+  /^@starterlib\/(?:core|tokens|ui|util)$/,
+  /^rxjs$/,
+  /^tslib$/,
+  /^es-module-shims$/,
+];
+
+/** Ce qui n'entre nulle part, avec la raison. */
+const INTERDITS = [
+  { motif: /^zone\.js$/, raison: 'le socle est zoneless' },
+  { motif: /^@tanstack\//, raison: 'la lecture de donnees passe par httpResource()' },
+  { motif: /^@angular\/material$/, raison: 'les composants sont ceux du socle (st-*)' },
+  {
+    motif: /transloco|^@ngx-translate\//,
+    raison: 'la langue et les catalogues sont ceux du socle (langue globale, ADR web 0007)',
+  },
+  {
+    motif:
+      /^(?:lucide.*|@ng-icons\/.+|@fortawesome\/.+|@material-design-icons\/.+|@material-symbols\/.+|material-symbols|@tabler\/.+|@heroicons\/.+|@phosphor-icons\/.+)$/,
+    raison: "aucune bibliotheque d'icones : le sprite du socle et le sprite metier du remote",
+  },
+];
+
+/** Jamais en production : du code de test ou d'outillage servi a une page. */
+const DEVELOPPEMENT_SEULEMENT = [/^@starterlib\/(?:testing|cli|eslint-config|eslint-plugin)$/];
+
+/** Les outils que le CLI remplace : leur copie ne doit plus exister (lot 174). */
+const COPIES_D_OUTILS = [
+  /^verifier-[a-z-]+\.mjs$/,
+  /^(?:manifeste|precompresser|sprite|empreinte|cloture|precharger-la-police)\.mjs$/,
+];
+
+export function jugerLesDependances(paquet, outils = []) {
+  const defauts = [];
+  const admises = paquet.starterWeb?.dependancesAdmises ?? {};
+
+  for (const [nom, raison] of Object.entries(admises)) {
+    if (typeof raison !== 'string' || raison.trim().length < LONGUEUR_MINIMALE_D_UNE_RAISON) {
+      defauts.push(
+        `starterWeb.dependancesAdmises["${nom}"] : une raison ecrite d'au moins ` +
+          `${String(LONGUEUR_MINIMALE_D_UNE_RAISON)} caracteres est exigee.`,
+      );
+    }
+  }
+
+  const production = Object.keys(paquet.dependencies ?? {});
+  const developpement = Object.keys(paquet.devDependencies ?? {});
+  for (const nom of [...production, ...developpement]) {
+    const interdit = INTERDITS.find(({ motif }) => motif.test(nom));
+    if (interdit !== undefined) defauts.push(`${nom} : interdit, ${interdit.raison}.`);
+  }
+  for (const nom of production) {
+    if (DEVELOPPEMENT_SEULEMENT.some((motif) => motif.test(nom))) {
+      defauts.push(
+        `${nom} : en dependencies, il partirait avec la page ; le mettre en devDependencies.`,
+      );
+      continue;
+    }
+    if (INTERDITS.some(({ motif }) => motif.test(nom))) continue;
+    if (ADMIS_EN_PRODUCTION.some((motif) => motif.test(nom))) continue;
+    if (Object.hasOwn(admises, nom)) continue;
+    defauts.push(
+      `${nom} : dependance de production hors de la liste revue. L'admettre par ` +
+        'starterWeb.dependancesAdmises, avec sa raison, ou la retirer.',
+    );
+  }
+
+  for (const fichier of outils) {
+    if (COPIES_D_OUTILS.some((motif) => motif.test(fichier))) {
+      defauts.push(
+        `tools/${fichier} : copie d'un outil du socle, remplacee par @starterlib/cli. La retirer, ` +
+          'et appeler starter-web dans package.json.',
+      );
+    }
+  }
+  return defauts;
+}
+
+export default {
+  nom: 'dependances',
+  roles: ['remote', 'hote'],
+  executer(projet) {
+    const dossier = join(projet.racine, 'tools');
+    const outils = existsSync(dossier) ? readdirSync(dossier) : [];
+    const defauts = jugerLesDependances(projet.paquet, outils);
+    const nombre = Object.keys(projet.paquet.dependencies ?? {}).length;
+    return { defauts, resume: `${String(nombre)} dependance(s) de production, toutes revues.` };
+  },
+};

package/src/etapes/federation.mjs

@@ -0,0 +1,94 @@
+/**
+ * Etape `federation` (lot 177, ADR 0029 regle 3, constat A0898) : ce que la federation partage, lu
+ * dans `remoteEntry.json` construit.
+ *
+ * - chaque paquet partage l'est en SINGLETON, version STRICTE, avec une plage EXPLICITE (ADR 0028,
+ *   plan SPA §2.4) : `auto` ou `*` ferait de chaque correctif un conflit, ou n'en verrait aucun ;
+ * - Angular et le socle SONT partages : un `@starterlib/core` oublie serait duplique dans le
+ *   remote, avec son propre etat — une seconde session, une seconde langue, des requetes sans jeton
+ *   anti-falsification — et le formulaire s'afficherait quand meme, sans le moindre message ;
+ * - aucun module de la SPA n'importe un specificateur nu que la federation ne partage pas : la carte
+ *   d'importation ne le resoudrait pas, et la page casserait au chargement de ce module. Le code du
+ *   cadre n'est pas lu : Angular importe dynamiquement `zone.js/plugins/task-tracking`, que le
+ *   socle zoneless n'execute jamais.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fichiers, lireJson, relatif } from '../commun.mjs';
+import { SPECIFICATEUR_NU, natureDesFichiers, specificateurs } from '../livraison.mjs';
+
+/** Ce qui DOIT etre partage : Angular, rxjs et les points d'entree d'etat du socle. */
+export const PARTAGES_EXIGES = [
+  '@angular/core',
+  '@angular/common',
+  '@angular/router',
+  '@angular/platform-browser',
+  'rxjs',
+  '@starterlib/core',
+  '@starterlib/tokens',
+  '@starterlib/util',
+];
+
+/** Les defauts du partage `shared` (le tableau de `remoteEntry.json`). */
+export function jugerLePartage(shared) {
+  const defauts = [];
+  for (const partage of shared) {
+    const nom = String(partage.packageName);
+    if (partage.singleton !== true) defauts.push(`${nom} : partage sans singleton: true.`);
+    if (partage.strictVersion !== true) defauts.push(`${nom} : partage sans strictVersion: true.`);
+    const plage = partage.requiredVersion;
+    if (typeof plage !== 'string' || plage === '' || plage === 'auto' || plage === '*') {
+      defauts.push(`${nom} : requiredVersion "${String(plage)}", une plage explicite est exigee.`);
+    }
+  }
+  const noms = new Set(shared.map((partage) => partage.packageName));
+  for (const exige of PARTAGES_EXIGES) {
+    if (!noms.has(exige)) {
+      defauts.push(
+        `${exige} n'est pas partage : il serait duplique dans cette SPA, avec son propre etat ` +
+          '(federation.config.mjs : partageDuSocle(train) et le partage d Angular).',
+      );
+    }
+  }
+  return defauts;
+}
+
+export default {
+  nom: 'federation',
+  roles: ['remote', 'hote'],
+  executer(projet) {
+    const entree = lireJson(join(projet.sortie, 'remoteEntry.json'));
+    if (entree === null) {
+      return {
+        defauts: [`${projet.sortieRelative}/remoteEntry.json absent : construire d'abord.`],
+      };
+    }
+    const shared = entree.shared ?? [];
+    const defauts = jugerLePartage(shared);
+    const noms = new Set(shared.map((partage) => partage.packageName));
+    const { partages } = natureDesFichiers(entree);
+    let modules = 0;
+    for (const chemin of fichiers(projet.sortie).filter((fichier) => fichier.endsWith('.js'))) {
+      if (partages.has(relatif(projet.sortie, chemin))) continue;
+      modules += 1;
+      const nonPartages = new Set(
+        specificateurs(readFileSync(chemin, 'utf8')).filter(
+          (specificateur) =>
+            SPECIFICATEUR_NU.test(specificateur) &&
+            !specificateur.startsWith('@nf-internal/') &&
+            !noms.has(specificateur),
+        ),
+      );
+      for (const specificateur of nonPartages) {
+        defauts.push(
+          `${relatif(projet.sortie, chemin)} importe "${specificateur}", que la federation ne partage ` +
+            'pas : la carte d importation ne le resoudra pas.',
+        );
+      }
+    }
+    return {
+      defauts,
+      resume: `${String(shared.length)} paquet(s) partage(s) en singleton strict, ${String(modules)} module(s) sans import nu orphelin.`,
+    };
+  },
+};

package/src/etapes/hote.mjs

@@ -0,0 +1,112 @@
+/**
+ * Les deux etapes propres a l'hote (la coquille), venues de ses outils recopies (lot 174).
+ *
+ * `entree` : le point d'entree ne depend d'AUCUN paquet partage avant `initFederation`. `main.ts`
+ * s'execute avant que la carte d'importation existe : c'est lui qui la construit. Tout import
+ * STATIQUE d'un specificateur nu dans son graphe est evalue avant cette construction, ne se resout
+ * pas, et laisse une page blanche — sans erreur serveur (constate le 2026-09-19 avec
+ * `@starterlib/core/federation`). Les imports DYNAMIQUES sont evalues apres, ils sont permis.
+ *
+ * `amorcage` : aucun PAIR LOURD n'entre dans le premier ecran (ADR 0031). Le defaut qui a coute
+ * 67 Ko tenait en une ligne raisonnable a lire : un composant de dialogue importe dans la
+ * configuration. Ce qu'aucun lecteur ne voit, un outil le voit.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join, posix } from 'node:path';
+import { cloture, departDeLaPage } from '../cloture.mjs';
+import { lireJson } from '../commun.mjs';
+
+// Imports statiques d'un module ES minifie : `import{a}from"x"`, `import"x"`, `export*from"x"`.
+// `import("x")` (dynamique) ne correspond pas : aucune parenthese n'est admise avant la chaine.
+const SPECIFICATEUR = /^(?:\.{1,2}\/|@?[a-z0-9])[\w@./-]*$/i;
+const STATIQUES = /(?:^|[;\n}])\s*(?:import|export)\s*(?:[^"'()]*?\bfrom\s*)?["']([^"']+)["']/g;
+const SCRIPTS_MODULES =
+  /<script[^>]*\bsrc="([^"]+)"[^>]*type="module(?:-shim)?"|<script[^>]*type="module(?:-shim)?"[^>]*\bsrc="([^"]+)"/g;
+
+export const entree = {
+  nom: 'entree',
+  roles: ['hote'],
+  executer(projet) {
+    const cheminIndex = join(projet.sortie, 'index.html');
+    if (!existsSync(cheminIndex)) {
+      return { defauts: [`${projet.sortieRelative}/index.html absent : construire d'abord.`] };
+    }
+    // `module` pour les polyfills, `module-shim` pour l'entree (mode shim d'es-module-shims).
+    const entrees = [...readFileSync(cheminIndex, 'utf8').matchAll(SCRIPTS_MODULES)]
+      .map((trouve) => trouve[1] ?? trouve[2])
+      .filter((src) => src !== undefined && !src.startsWith('http'))
+      .map((src) => posix.basename(src));
+    if (entrees.length === 0) {
+      return { defauts: ["aucun script module dans index.html : la verification n'a rien vu."] };
+    }
+    const defauts = [];
+    const vus = new Set();
+    const aVisiter = [...entrees];
+    while (aVisiter.length > 0) {
+      const fichier = aVisiter.pop();
+      if (vus.has(fichier)) continue;
+      vus.add(fichier);
+      const chemin = join(projet.sortie, fichier);
+      if (!existsSync(chemin)) continue;
+      for (const [, specificateur] of readFileSync(chemin, 'utf8').matchAll(STATIQUES)) {
+        // Une chaine qui n'a pas la forme d'un specificateur (modele `${...}` du shim) n'en est pas un.
+        if (!SPECIFICATEUR.test(specificateur)) continue;
+        if (specificateur.startsWith('./') || specificateur.startsWith('../')) {
+          aVisiter.push(posix.normalize(posix.join(posix.dirname(fichier), specificateur)));
+        } else if (!specificateur.startsWith('/') && !specificateur.startsWith('http')) {
+          defauts.push(
+            `${fichier} importe statiquement "${specificateur}" avant initFederation : l'embarquer ` +
+              "(federation.config.mjs, skip) ou l'importer apres initFederation.",
+          );
+        }
+      }
+    }
+    return {
+      defauts,
+      resume: `${String(vus.size)} module(s) du graphe statique, aucun paquet partage avant initFederation.`,
+    };
+  },
+};
+
+/** Ce qui n'a rien a faire dans le premier ecran, par prefixe de nom de morceau. */
+const PAIRS_LOURDS = [
+  { prefixe: '_angular_cdk', raison: 'la CDK : calque, dialogue, defilement virtuel' },
+  { prefixe: '_angular_aria', raison: 'les primitives aria : menu, onglets, arbre, selection' },
+  { prefixe: '_angular_forms', raison: 'les formulaires : aucun champ au premier ecran' },
+  { prefixe: '_starterlib_ui_surfaces', raison: 'les surfaces : dialogue, porte-messages' },
+];
+
+/**
+ * Le seul pair lourd ADMIS au premier ecran : `@angular/cdk/layout`, pair declare de
+ * `@starterlib/ui/navigation` (le panneau lateral sait s'il se replie). Un demi-kilo-octet, la ou
+ * le reste de la CDK en pese cinquante.
+ */
+const ADMIS = ['_angular_cdk_layout'];
+
+export const amorcage = {
+  nom: 'amorcage',
+  roles: ['hote'],
+  executer(projet) {
+    const cheminIndex = join(projet.sortie, 'index.html');
+    if (!existsSync(cheminIndex)) {
+      return { defauts: [`${projet.sortieRelative}/index.html absent : construire d'abord.`] };
+    }
+    const carte = lireJson(join(projet.sortie, 'importmap.json'))?.imports ?? {};
+    const premierEcran = cloture(
+      projet.sortie,
+      departDeLaPage(readFileSync(cheminIndex, 'utf8')),
+      carte,
+      2,
+    );
+    const defauts = [];
+    for (const [chemin, details] of premierEcran) {
+      if (ADMIS.some((admis) => chemin.startsWith(admis))) continue;
+      const pair = PAIRS_LOURDS.find((candidat) => chemin.startsWith(candidat.prefixe));
+      if (pair === undefined) continue;
+      defauts.push(
+        `${chemin} (${pair.raison}) tire par ${details.parent} : une arete STATIQUE l'y traine (ADR 0031, decision 3).`,
+      );
+    }
+    return { defauts, resume: 'aucun pair lourd dans le premier ecran.' };
+  },
+};

package/src/etapes/i18n.mjs

@@ -0,0 +1,282 @@
+/**
+ * Etape `i18n` : les catalogues de la SPA, lus AVANT la construction (plan SPA §3 ; lots 174, 178).
+ *
+ * Pour chaque perimetre (`manifest.source.json#i18n.perimetres` d'un remote, `socle` pour l'hote) :
+ * - `public/i18n/<perimetre>.fr.json` et `.en.json` existent, sont des objets plats de textes non
+ *   vides, portent le meme jeu de cles, chacune prefixee par `<perimetre>.` ;
+ * - chaque message est lisible par le formateur du socle (`@starterlib/core`, `message.ts`) : des
+ *   accolades equilibrees, `{nom}`, `{n, plural, =0 {..} one {..} other {..}}`,
+ *   `{g, select, a {..} other {..}}`, chaque choix avec sa branche `other` ;
+ * - un nombre de minutes, de secondes, d'heures, de jours, un compte ne s'ecrit pas `{compte}` nu :
+ *   `{compte, plural, ...}`, sans quoi « 1 minutes » s'affiche (constat A1039) ;
+ * - un message porte les MEMES arguments en fr et en en : un `{nom}` traduit `{name}` reste un trou ;
+ * - chaque cle que le code appelle (`t('catalog.x')`) et chaque titre de route du manifeste existent
+ *   au catalogue : une cle absente s'affiche telle quelle, a l'ecran ;
+ * - l'hote porte les cles que `@starterlib/core` traduit par son catalogue
+ *   (`schemas/cles-exigees-du-socle.json`, constat A0837) ;
+ * - le type des cles engendre (`src/app/i18n/cles.ts`, `starter-web i18n:types`) est a jour : une cle
+ *   inconnue dans `t()` est alors une erreur de compilation.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fichiers, lireJson, relatif } from '../commun.mjs';
+import { dossierInstalle } from '../socle-installe.mjs';
+import { cheminDesTypesDeCles, typesDeCles } from '../construction/types-i18n.mjs';
+
+export const LANGUES = ['fr', 'en'];
+
+/** Les arguments qui comptent : ils exigent un pluriel. */
+const ARGUMENTS_NUMERIQUES = new Set([
+  'minutes',
+  'secondes',
+  'heures',
+  'jours',
+  'compte',
+  'nombre',
+]);
+const CATEGORIES_DE_PLURIEL = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
+const NOM_D_ARGUMENT = /^[A-Za-z_]\w*$/;
+
+/** Lit un bloc `{...}` en comptant les accolades imbriquees ; `null` s'il ne se ferme pas. */
+function lireBloc(modele, depuis) {
+  let profondeur = 0;
+  for (let indice = depuis; indice < modele.length; indice += 1) {
+    if (modele[indice] === '{') profondeur += 1;
+    else if (modele[indice] === '}') {
+      profondeur -= 1;
+      if (profondeur === 0) return { contenu: modele.slice(depuis + 1, indice), suite: indice + 1 };
+    }
+  }
+  return null;
+}
+
+/** Decoupe `cle {contenu} autre {contenu}` ; `null` si un morceau ne se lit pas. */
+function lireOptions(source) {
+  const options = new Map();
+  let indice = 0;
+  while (indice < source.length) {
+    while (indice < source.length && /\s/.test(source[indice])) indice += 1;
+    if (indice >= source.length) break;
+    const debut = indice;
+    while (indice < source.length && !/[\s{]/.test(source[indice])) indice += 1;
+    const cle = source.slice(debut, indice);
+    while (indice < source.length && /\s/.test(source[indice])) indice += 1;
+    const bloc = source[indice] === '{' ? lireBloc(source, indice) : null;
+    if (cle === '' || bloc === null) return null;
+    options.set(cle, bloc.contenu);
+    indice = bloc.suite;
+  }
+  return options;
+}
+
+/**
+ * Les defauts d'un message, et ses arguments. Rend `{ defauts, arguments }` ; `arguments` : les noms
+ * lus, pluriels et choix compris.
+ */
+export function lireUnMessage(modele) {
+  const defauts = [];
+  const noms = new Set();
+  const parcourir = (texte) => {
+    let indice = 0;
+    while (indice < texte.length) {
+      const caractere = texte[indice];
+      if (caractere === '}') {
+        defauts.push('accolade fermante sans ouvrante');
+        return;
+      }
+      if (caractere !== '{') {
+        indice += 1;
+        continue;
+      }
+      const bloc = lireBloc(texte, indice);
+      if (bloc === null) {
+        defauts.push('accolade jamais fermee');
+        return;
+      }
+      lireUnArgument(bloc.contenu);
+      indice = bloc.suite;
+    }
+  };
+  const lireUnArgument = (contenu) => {
+    const [nom = '', type, ...reste] = contenu.split(',');
+    const argument = nom.trim();
+    if (!NOM_D_ARGUMENT.test(argument)) {
+      defauts.push(`argument "${argument}" illisible`);
+      return;
+    }
+    noms.add(argument);
+    if (type === undefined) {
+      if (ARGUMENTS_NUMERIQUES.has(argument)) {
+        defauts.push(
+          `{${argument}} compte : l'ecrire {${argument}, plural, one {...} other {...}}`,
+        );
+      }
+      return;
+    }
+    const genre = type.trim();
+    if (genre !== 'plural' && genre !== 'select') {
+      defauts.push(`{${argument}, ${genre}} : plural ou select attendu`);
+      return;
+    }
+    const options = lireOptions(reste.join(','));
+    if (options === null || options.size === 0) {
+      defauts.push(`{${argument}, ${genre}} : choix illisibles`);
+      return;
+    }
+    if (!options.has('other')) defauts.push(`{${argument}, ${genre}} sans branche other`);
+    for (const [cle, texte] of options) {
+      if (genre === 'plural' && !CATEGORIES_DE_PLURIEL.has(cle) && !/^=\d+$/.test(cle)) {
+        defauts.push(`{${argument}, plural} : categorie "${cle}" inconnue`);
+      }
+      parcourir(texte);
+    }
+  };
+  parcourir(modele);
+  return { defauts, arguments: noms };
+}
+
+/** Les defauts d'un perimetre, `catalogues` etant `{ fr: objet | null, en: objet | null }`. */
+export function jugerLesCatalogues(perimetre, catalogues) {
+  const defauts = [];
+  const cles = {};
+  const argumentsParLangue = { fr: new Map(), en: new Map() };
+  for (const langue of LANGUES) {
+    const catalogue = catalogues[langue];
+    const nom = `${perimetre}.${langue}.json`;
+    if (catalogue === undefined || catalogue === null) {
+      defauts.push(`${nom} : absent ou illisible (public/i18n/).`);
+      continue;
+    }
+    if (typeof catalogue !== 'object' || Array.isArray(catalogue)) {
+      defauts.push(`${nom} : un objet de cles est attendu.`);
+      continue;
+    }
+    cles[langue] = new Set(Object.keys(catalogue));
+    for (const [cle, texte] of Object.entries(catalogue)) {
+      if (!cle.startsWith(`${perimetre}.`)) {
+        defauts.push(`${nom} : cle "${cle}" sans le prefixe "${perimetre}.".`);
+      }
+      if (typeof texte !== 'string' || texte.trim() === '') {
+        defauts.push(`${nom} : cle "${cle}", texte vide ou qui n'est pas une chaine.`);
+        continue;
+      }
+      const message = lireUnMessage(texte);
+      for (const defaut of message.defauts) defauts.push(`${nom} : cle "${cle}", ${defaut}.`);
+      argumentsParLangue[langue].set(cle, message.arguments);
+    }
+  }
+  if (cles.fr !== undefined && cles.en !== undefined) {
+    for (const [langue, autre] of [
+      ['fr', 'en'],
+      ['en', 'fr'],
+    ]) {
+      for (const cle of cles[langue]) {
+        if (!cles[autre].has(cle)) {
+          defauts.push(`${perimetre} : cle "${cle}" presente en ${langue}, absente de ${autre}.`);
+        }
+      }
+    }
+    for (const [cle, enFrancais] of argumentsParLangue.fr) {
+      const enAnglais = argumentsParLangue.en.get(cle);
+      if (enAnglais === undefined) continue;
+      const fr = [...enFrancais].sort().join(', ');
+      const en = [...enAnglais].sort().join(', ');
+      if (fr !== en) {
+        defauts.push(`${perimetre} : cle "${cle}", arguments {${fr}} en fr et {${en}} en en.`);
+      }
+    }
+  }
+  return defauts;
+}
+
+/** Les cles appelees par le code : `t('perimetre.cle')` dans les sources (essais exclus). */
+export function clesAppelees(racine) {
+  const appelees = new Map();
+  for (const chemin of fichiers(join(racine, 'src'))) {
+    if (!/\.(?:ts|html)$/.test(chemin) || chemin.endsWith('.spec.ts')) continue;
+    const texte = readFileSync(chemin, 'utf8');
+    for (const [, cle] of texte.matchAll(/\bt\(\s*['"]([a-z][\w-]*(?:\.[\w-]+)+)['"]/g)) {
+      if (!appelees.has(cle)) appelees.set(cle, relatif(racine, chemin));
+    }
+  }
+  return appelees;
+}
+
+function lire(chemin) {
+  if (!existsSync(chemin)) return null;
+  try {
+    return JSON.parse(readFileSync(chemin, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export default {
+  nom: 'i18n',
+  roles: ['remote', 'hote'],
+  executer(projet) {
+    const perimetres =
+      projet.role === 'remote' ? (projet.source?.i18n?.perimetres ?? []) : ['socle'];
+    if (perimetres.length === 0) {
+      return { defauts: ['manifest.source.json : i18n.perimetres vide, aucun catalogue a lire.'] };
+    }
+    const defauts = [];
+    const catalogues = {};
+    let cles = 0;
+    for (const perimetre of perimetres) {
+      catalogues[perimetre] = Object.fromEntries(
+        LANGUES.map((langue) => [
+          langue,
+          lire(join(projet.racine, 'public', 'i18n', `${perimetre}.${langue}.json`)),
+        ]),
+      );
+      defauts.push(...jugerLesCatalogues(perimetre, catalogues[perimetre]));
+      cles += Object.keys(catalogues[perimetre].fr ?? {}).length;
+    }
+
+    // Les cles appelees, et les titres des routes, existent au catalogue de leur perimetre.
+    const connue = (cle) => {
+      const perimetre = cle.split('.')[0];
+      const catalogue = catalogues[perimetre]?.fr;
+      return catalogue === undefined || catalogue === null ? null : Object.hasOwn(catalogue, cle);
+    };
+    for (const [cle, ou] of clesAppelees(projet.racine)) {
+      if (connue(cle) === false) defauts.push(`${ou} : t('${cle}'), cle absente du catalogue.`);
+    }
+    for (const route of projet.source?.routes ?? []) {
+      if (typeof route.titre === 'string' && connue(route.titre) === false) {
+        defauts.push(`manifest.source.json : titre "${route.titre}" absent du catalogue.`);
+      }
+    }
+
+    // L'hote porte les cles que le noyau traduit par son catalogue.
+    if (projet.role === 'hote') {
+      const dossier = dossierInstalle(projet.racine, '@starterlib/core');
+      const exigees =
+        dossier === null ? null : lireJson(join(dossier, 'schemas', 'cles-exigees-du-socle.json'));
+      for (const cle of exigees?.cles ?? []) {
+        for (const langue of LANGUES) {
+          if (!Object.hasOwn(catalogues.socle?.[langue] ?? {}, cle)) {
+            defauts.push(
+              `socle.${langue}.json : cle "${cle}", exigee par @starterlib/core, absente.`,
+            );
+          }
+        }
+      }
+    }
+
+    // Le type des cles engendre, a jour.
+    const cheminDesTypes = cheminDesTypesDeCles(projet.racine);
+    const attendu = typesDeCles(perimetres, catalogues);
+    if (!existsSync(cheminDesTypes)) {
+      defauts.push(`${relatif(projet.racine, cheminDesTypes)} absent : starter-web i18n:types.`);
+    } else if (readFileSync(cheminDesTypes, 'utf8') !== attendu) {
+      defauts.push(`${relatif(projet.racine, cheminDesTypes)} perime : starter-web i18n:types.`);
+    }
+
+    return {
+      defauts,
+      resume: `${String(perimetres.length)} perimetre(s), ${String(cles)} cle(s) en fr et en en, messages lisibles, cles appelees presentes.`,
+    };
+  },
+};