@starterlib/cli 0.10.2

package/src/construction/manifeste.mjs

@@ -0,0 +1,159 @@
+/**
+ * `starter-web manifeste` : engendre `manifest.json` dans le dossier livre, apres la construction.
+ *
+ * Un remote : ce que le service sert a `/ui/<nom>/manifest.json`, et que le BFF agrege (ADR 0028,
+ * plan SPA §2.3). Tout ce qui se DEDUIT du build est calcule ici, jamais ecrit a la main : les
+ * catalogues i18n sont renommes avec leur empreinte (caches un an), le sprite metier est retrouve
+ * par la sienne, les modules des routes doivent etre exposes, et l'empreinte de l'arborescence signe
+ * ce qui est livre. Le reste (routes, perimetres, API exigee) vient de `manifest.source.json`.
+ *
+ * Le train REQUIS et le socle CONSTRUIT se lisent dans `remoteEntry.json` : la plage que la
+ * federation exige pour `@starterlib/core`, et la version qu'elle a embarquee. Les copies lisaient le
+ * train dans `federation.config.mjs` par expression reguliere, sous deux formes deja divergentes ; la
+ * plage annoncee au BFF est desormais, par construction, celle que la federation applique.
+ *
+ * ⚠️ IDEMPOTENTE (lot 174) : relancee apres une premiere passe, elle retrouve les catalogues deja
+ * haches au lieu d'echouer sur un fichier renomme, et retire une empreinte perimee avec ses variantes
+ * compressees.
+ *
+ * L'hote : le manifeste de la coquille, que le BFF lit pour dire aux remotes quel train il embarque.
+ */
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { empreinteCourte, fichiers, lireJson, relatif } from '../commun.mjs';
+
+const LANGUES = ['fr', 'en'];
+
+function commit(racine) {
+  if (process.env.GIT_COMMIT) return process.env.GIT_COMMIT;
+  try {
+    return execFileSync('git', ['rev-parse', '--short', 'HEAD'], {
+      cwd: racine,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return 'local';
+  }
+}
+
+/** Le partage de `paquet` dans `remoteEntry.json` : plage exigee et version embarquee. */
+function partage(entree, paquet) {
+  const trouve = (entree.shared ?? []).find((element) => element.packageName === paquet);
+  if (trouve === undefined) {
+    throw new Error(
+      `${paquet} n'est pas partage par remoteEntry.json : federation.config.mjs doit appeler ` +
+        'partageDuSocle(train) et partager Angular (plan SPA, section 2.4).',
+    );
+  }
+  return trouve;
+}
+
+/** Retire un fichier et ses variantes precompressees. */
+function retirer(chemin) {
+  for (const variante of [chemin, `${chemin}.br`, `${chemin}.gz`])
+    rmSync(variante, { force: true });
+}
+
+/** Le catalogue `langue` du perimetre `nom`, hache ; idempotent. Rend son nom de fichier. */
+function hacherLeCatalogue(dossier, nom, langue) {
+  const brut = join(dossier, `${nom}.${langue}.json`);
+  const motif = new RegExp(`^${nom}\\.${langue}-[A-Z0-9]{8}\\.json$`);
+  const haches = existsSync(dossier)
+    ? readdirSync(dossier).filter((fichier) => motif.test(fichier))
+    : [];
+  if (existsSync(brut)) {
+    const hache = `${nom}.${langue}-${empreinteCourte(readFileSync(brut))}.json`;
+    for (const ancien of haches) if (ancien !== hache) retirer(join(dossier, ancien));
+    renameSync(brut, join(dossier, hache));
+    return hache;
+  }
+  if (haches.length === 1) return haches[0];
+  throw new Error(
+    `i18n/${nom}.${langue}.json absent de la construction (${String(haches.length)} variante(s) hachee(s)).`,
+  );
+}
+
+/** L'empreinte SRI de l'arborescence livree, hors manifeste et variantes precompressees. */
+function empreinteDeLArborescence(sortie) {
+  const hachage = createHash('sha256');
+  for (const fichier of fichiers(sortie)) {
+    const nom = relatif(sortie, fichier);
+    // Les variantes derivent des fichiers deja haches : les compter ferait dependre l'empreinte de
+    // l'ordre des etapes.
+    if (nom === 'manifest.json' || nom.endsWith('.br') || nom.endsWith('.gz')) continue;
+    hachage.update(nom).update('\0').update(readFileSync(fichier)).update('\0');
+  }
+  return `sha256-${hachage.digest('base64')}`;
+}
+
+/** Ecrit le manifeste ; rend l'objet ecrit. */
+export function ecrireLeManifeste(projet) {
+  const entree = lireJson(join(projet.sortie, 'remoteEntry.json'));
+  if (entree === null) {
+    throw new Error(`${projet.sortieRelative}/remoteEntry.json absent : construire d'abord.`);
+  }
+  const core = partage(entree, '@starterlib/core');
+  const angular = partage(entree, '@angular/core').version.split('.').slice(0, 2).join('.');
+  const version = process.env.VERSION ?? '0.0.0-local';
+
+  if (projet.role === 'hote') {
+    const manifeste = {
+      nom: 'socle',
+      version,
+      construitLe: new Date().toISOString(),
+      socle: { construit: core.version },
+      angular,
+    };
+    writeFileSync(join(projet.sortie, 'manifest.json'), `${JSON.stringify(manifeste, null, 2)}\n`);
+    return manifeste;
+  }
+
+  const { source, nom } = projet;
+  const prefixe = `/ui/${nom}`;
+  const exposes = new Set((entree.exposes ?? []).map((expose) => expose.key));
+  for (const route of source.routes ?? []) {
+    if (!exposes.has(route.module)) {
+      throw new Error(
+        `route ${String(route.prefixe)} : module ${String(route.module)} absent des exposes (${[...exposes].join(', ')}).`,
+      );
+    }
+  }
+
+  const catalogues = {};
+  for (const langue of LANGUES) {
+    catalogues[langue] =
+      `${prefixe}/i18n/${hacherLeCatalogue(join(projet.sortie, 'i18n'), nom, langue)}`;
+  }
+
+  const icones = join(projet.sortie, 'icones');
+  const sprite = existsSync(icones)
+    ? readdirSync(icones).find((fichier) => /^sprite-[A-Z0-9]{8}\.svg$/.test(fichier))
+    : undefined;
+  if (sprite === undefined) {
+    throw new Error(
+      `sprite metier absent de ${projet.sortieRelative}/icones : starter-web sprite d'abord.`,
+    );
+  }
+
+  const manifeste = {
+    nom,
+    version,
+    commit: commit(projet.racine),
+    construitLe: new Date().toISOString(),
+    // Format SRI (`sha256-<base64>`), celui que le BFF valide (ValidationDuManifeste.java).
+    empreinte: empreinteDeLArborescence(projet.sortie),
+    remoteEntry: `${prefixe}/remoteEntry.json`,
+    socle: { requis: core.requiredVersion, construit: core.version },
+    angular,
+    pleinePage: projet.pleinePage,
+    routes: source.routes,
+    i18n: { perimetres: source.i18n?.perimetres, catalogues },
+    sprite: `${prefixe}/icones/${sprite}`,
+    apiExigee: source.apiExigee,
+  };
+  writeFileSync(join(projet.sortie, 'manifest.json'), `${JSON.stringify(manifeste, null, 2)}\n`);
+  return manifeste;
+}

package/src/construction/precompresser.mjs

@@ -0,0 +1,127 @@
+/**
+ * `starter-web precompresser [dossier]` : ecrit les variantes `.br` et `.gz` a cote de chaque actif
+ * livre.
+ *
+ * POURQUOI CETTE ETAPE EXISTE
+ *
+ * Le serveur sait DEJA servir une variante precompressee : `ActifsStatiques.servir()` cherche
+ * `<chemin>.br` puis `<chemin>.gz` selon l'`Accept-Encoding`, pose `Content-Encoding`, `Vary` et un
+ * ETag qui porte l'encodage. Il ne compresse rien lui-meme, par choix. Seulement, aucune chaine de
+ * build n'ecrivait ces fichiers — mesure du 2026-09-19 sur le BFF reel : le point d'entree de la
+ * coquille partait en 77 547 octets, la ou le brotli en rend environ 21 000.
+ *
+ * DEUX REGLES QUI ONT UNE RAISON
+ *
+ *   - `index.html` est EXCLU : le serveur le reecrit a chaque reponse (nonce de la politique de
+ *     securite, absolutisation des adresses, preferences de la personne). Une variante figee serait
+ *     perimee des la premiere reponse.
+ *   - une variante n'est ecrite que si elle est PLUS PETITE que l'original : sur un fichier
+ *     minuscule, l'en-tete de compression coute plus qu'il ne rapporte.
+ *
+ * CORRIGE PAR RAPPORT AUX COPIES (lot 174)
+ *
+ *   - le dossier se DONNE (argument, ou le dossier livre du projet) : les copies le derivaient de
+ *     leur propre emplacement, et rien ne pouvait recompresser une fixture reecrite, ni eprouver la
+ *     garde sur un dossier d'essai ;
+ *   - une variante ORPHELINE (son original a disparu : un catalogue renomme par le manifeste, un
+ *     morceau d'une construction precedente) est retiree, et une variante devenue inutile aussi :
+ *     le serveur servirait sinon un contenu que plus rien ne produit.
+ *
+ * L'etape vient APRES la generation du manifeste, qui renomme les catalogues i18n.
+ */
+import { brotliCompressSync, constants, gzipSync } from 'node:zlib';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { fichiers, ko, relatif } from '../commun.mjs';
+
+/** Exactement ce que le serveur declare compressible (ActifsStatiques.EXTENSIONS_COMPRESSIBLES). */
+export const COMPRESSIBLES = new Set([
+  '.js',
+  '.mjs',
+  '.css',
+  '.json',
+  '.svg',
+  '.webmanifest',
+  '.txt',
+]);
+
+/** Reecrit a chaque reponse par le serveur : une variante figee serait fausse. */
+const EXCLUS = new Set(['index.html']);
+
+/**
+ * Precompresse `dossier`. Rend `{ compresses, orphelines, octetsAvant, octetsBrotli, sansVariante }`,
+ * `sansVariante` listant les `.js` qui devraient avoir une variante brotli et n'en ont pas.
+ */
+export function precompresser(dossier) {
+  const tous = fichiers(dossier);
+  let orphelines = 0;
+  for (const fichier of tous) {
+    const extension = extname(fichier);
+    if (extension !== '.br' && extension !== '.gz') continue;
+    const original = fichier.slice(0, -extension.length);
+    if (!existsSync(original) || EXCLUS.has(relatif(dossier, original))) {
+      rmSync(fichier);
+      orphelines += 1;
+    }
+  }
+
+  let compresses = 0;
+  let octetsAvant = 0;
+  let octetsBrotli = 0;
+  const sansGain = new Set();
+  for (const fichier of fichiers(dossier)) {
+    const extension = extname(fichier);
+    if (extension === '.br' || extension === '.gz') continue;
+    if (!COMPRESSIBLES.has(extension) || EXCLUS.has(relatif(dossier, fichier))) continue;
+    const contenu = readFileSync(fichier);
+    const brotli = brotliCompressSync(contenu, {
+      params: {
+        [constants.BROTLI_PARAM_QUALITY]: constants.BROTLI_MAX_QUALITY,
+        [constants.BROTLI_PARAM_SIZE_HINT]: contenu.length,
+      },
+    });
+    const gzip = gzipSync(contenu, { level: 9 });
+    let ecrit = false;
+    for (const [variante, compresse] of [
+      [`${fichier}.br`, brotli],
+      [`${fichier}.gz`, gzip],
+    ]) {
+      if (compresse.length < contenu.length) {
+        writeFileSync(variante, compresse);
+        ecrit = true;
+      } else {
+        // Une variante d'une passe precedente, devenue plus lourde que l'original : retiree.
+        rmSync(variante, { force: true });
+      }
+    }
+    if (ecrit) {
+      compresses += 1;
+      octetsAvant += contenu.length;
+      octetsBrotli += Math.min(brotli.length, contenu.length);
+    } else {
+      sansGain.add(fichier);
+    }
+  }
+
+  const sansVariante = fichiers(dossier)
+    .filter((fichier) => extname(fichier) === '.js' && !sansGain.has(fichier))
+    .filter((fichier) => !existsSync(`${fichier}.br`))
+    .map((fichier) => relatif(dossier, fichier));
+  return { compresses, orphelines, octetsAvant, octetsBrotli, sansVariante };
+}
+
+/** Le compte rendu d'une precompression, et ses defauts (une etape devenue inutile en est un). */
+export function juger({ compresses, orphelines, octetsAvant, octetsBrotli, sansVariante }) {
+  const gain = octetsAvant === 0 ? 0 : Math.round((1 - octetsBrotli / octetsAvant) * 100);
+  const resume =
+    `${String(compresses)} actif(s), ${String(ko(octetsAvant))} Ko bruts -> ` +
+    `${String(ko(octetsBrotli))} Ko en brotli (-${String(gain)} %)` +
+    (orphelines > 0 ? `, ${String(orphelines)} variante(s) orpheline(s) retiree(s).` : '.');
+  const defauts = [];
+  // Une etape qui ne compresserait plus rien est une faute ; un actif que la compression n'allege
+  // pas (un morceau de 60 octets) n'a pas de variante, par la seconde regle.
+  if (compresses === 0) defauts.push('aucun actif compresse : l etape est devenue inutile.');
+  if (sansVariante.length > 0)
+    defauts.push(`actifs .js sans variante brotli : ${sansVariante.join(', ')}.`);
+  return { resume, defauts };
+}

package/src/construction/sprite.mjs

@@ -0,0 +1,73 @@
+/**
+ * `starter-web sprite` : pose l'empreinte du sprite avant la construction, et la donne au code.
+ *
+ * - Un remote : son sprite METIER (`src/icones/sprite.svg`) est copie sous
+ *   `public/icones/sprite-<empreinte>.svg`, et `src/app/icones/sprite-genere.ts` engendre
+ *   `CHEMIN_DU_SPRITE_METIER` : le code du remote et son manifeste pointent sur le MEME fichier,
+ *   cache un an (plan SPA §2.8, F15).
+ * - L'hote : le sprite du SOCLE (`@starterlib/ui/assets/icones/sprite.svg`) est copie sous
+ *   `public/assets/icones/sprite-<empreinte>.svg`, et `src/app/sprite-genere.ts` engendre
+ *   `CHEMIN_DU_SPRITE`, que `provideStarterUi` recoit hache.
+ *
+ * Les sorties sont ignorees par git ; `start`, `build`, `test` et `lint` relancent cette commande.
+ * Une ancienne empreinte est retiree : deux sprites livres, et le manifeste pourrait annoncer le
+ * mauvais.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { empreinteCourte } from '../commun.mjs';
+
+const SPRITE_HACHE = /^sprite-[A-Z0-9]{8}\.svg$/;
+
+/** Les chemins du sprite selon le role. */
+function reglages(projet) {
+  if (projet.role === 'hote') {
+    return {
+      source: join(
+        projet.racine,
+        'node_modules',
+        '@starterlib',
+        'ui',
+        'assets',
+        'icones',
+        'sprite.svg',
+      ),
+      dossier: join(projet.racine, 'public', 'assets', 'icones'),
+      adresse: (fichier) => `/ui/${projet.nom}/assets/icones/${fichier}`,
+      genere: join(projet.racine, 'src', 'app', 'sprite-genere.ts'),
+      constante: 'CHEMIN_DU_SPRITE',
+    };
+  }
+  return {
+    source: join(projet.racine, 'src', 'icones', 'sprite.svg'),
+    dossier: join(projet.racine, 'public', 'icones'),
+    adresse: (fichier) => `/ui/${projet.nom}/icones/${fichier}`,
+    genere: join(projet.racine, 'src', 'app', 'icones', 'sprite-genere.ts'),
+    constante: 'CHEMIN_DU_SPRITE_METIER',
+  };
+}
+
+/** Pose le sprite hache et sa constante ; rend l'adresse servie. */
+export function poserLeSprite(projet) {
+  const { source, dossier, adresse, genere, constante } = reglages(projet);
+  if (!existsSync(source)) {
+    throw new Error(
+      `sprite absent : ${source}${projet.role === 'hote' ? " (pnpm install d'abord)" : ''}.`,
+    );
+  }
+  const contenu = readFileSync(source);
+  const fichier = `sprite-${empreinteCourte(contenu)}.svg`;
+  mkdirSync(dossier, { recursive: true });
+  for (const existant of readdirSync(dossier)) {
+    if (SPRITE_HACHE.test(existant) && existant !== fichier) rmSync(join(dossier, existant));
+  }
+  writeFileSync(join(dossier, fichier), contenu);
+  const chemin = adresse(fichier);
+  mkdirSync(join(genere, '..'), { recursive: true });
+  writeFileSync(
+    genere,
+    '// Engendre par starter-web sprite (@starterlib/cli) : ne pas modifier, ne pas versionner.\n' +
+      `export const ${constante} = '${chemin}';\n`,
+  );
+  return chemin;
+}

package/src/construction/types-i18n.mjs

@@ -0,0 +1,60 @@
+/**
+ * `starter-web i18n:types` (lot 178, constat N21) : le type des cles de chaque perimetre, engendre
+ * depuis son catalogue francais, dans `src/app/i18n/cles.ts`.
+ *
+ * `injecterTraduction('catalog')` rendait `(cle: string) => string` : une faute de frappe dans
+ * `t('catalog.pages.produts')` compilait, et n'apparaissait qu'a l'ecran. Avec le type engendre,
+ * `injecterTraduction<CleCatalog>('catalog')` refuse a la compilation une cle que le catalogue ne
+ * porte pas. Le fichier est versionne (une cle ajoutee se lit a la revue) ; l'etape `i18n` le veut a
+ * jour.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+/** Ou vit le type engendre. */
+export function cheminDesTypesDeCles(racine) {
+  return join(racine, 'src', 'app', 'i18n', 'cles.ts');
+}
+
+/** `catalog` donne `CleCatalog` ; `mon-remote`, `CleMonRemote`. */
+export function nomDuType(perimetre) {
+  return `Cle${perimetre
+    .split(/[^a-zA-Z0-9]+/)
+    .filter((morceau) => morceau !== '')
+    .map((morceau) => morceau[0].toUpperCase() + morceau.slice(1))
+    .join('')}`;
+}
+
+/** Le contenu du fichier : un type par perimetre, les cles dans l'ordre alphabetique. */
+export function typesDeCles(perimetres, catalogues) {
+  const lignes = [
+    '// Engendre par starter-web i18n:types (@starterlib/cli) depuis public/i18n/<perimetre>.fr.json :',
+    '// ne pas modifier a la main. Une cle absente du catalogue est une erreur de compilation.',
+  ];
+  for (const perimetre of perimetres) {
+    const cles = Object.keys(catalogues[perimetre]?.fr ?? {}).sort();
+    lignes.push('', `/** Les cles du perimetre ${perimetre}. */`);
+    const enLigne = `export type ${nomDuType(perimetre)} = ${
+      cles.length === 0 ? 'never' : cles.map((cle) => `'${cle}'`).join(' | ')
+    };`;
+    // La forme que Prettier (largeur 100) donnerait : une ligne si elle tient, une cle par ligne
+    // sinon. Le fichier engendre passe ainsi `prettier --check` sans etre ecarte.
+    if (enLigne.length <= 100) {
+      lignes.push(enLigne);
+      continue;
+    }
+    lignes.push(`export type ${nomDuType(perimetre)} =`);
+    cles.forEach((cle, indice) => {
+      lignes.push(`  | '${cle}'${indice === cles.length - 1 ? ';' : ''}`);
+    });
+  }
+  return `${lignes.join('\n')}\n`;
+}
+
+/** Ecrit le fichier ; rend son chemin. */
+export function ecrireLesTypesDeCles(racine, perimetres, catalogues) {
+  const chemin = cheminDesTypesDeCles(racine);
+  mkdirSync(dirname(chemin), { recursive: true });
+  writeFileSync(chemin, typesDeCles(perimetres, catalogues));
+  return chemin;
+}

package/src/etapes/budget.mjs

@@ -0,0 +1,194 @@
+/**
+ * Etape `budget` : les tailles LIVREES, dans l'unite que le serveur envoie — la variante `.br`
+ * quand elle existe (ADR 0031, decision 5 : « deux budgets, dans l'unite que le navigateur
+ * telecharge »), le brotli qualite maximale sinon.
+ *
+ * Un remote (lot 177, constats A0905, A0920, A0968, A0831) : les copies ne pesaient que le module
+ * expose (`routes-*.js`, 0,3 Ko), jamais les pages qu'il charge paresseusement, et en gzip. Une page
+ * qui tirerait un paquet entier passait sans alerte. L'etape suit desormais le graphe : chaque
+ * module expose et chaque morceau LOCAL qu'un import dynamique atteint est une PAGE, pesee avec la
+ * cloture statique de ses morceaux locaux (60 Ko), et l'union de tout ce qui est charge ne depasse
+ * pas 250 Ko (plan SPA §2.8). Les paquets partages n'y sont pas : la coquille les paie une fois pour
+ * toutes. Chaque catalogue i18n : 30 Ko.
+ *
+ * L'hote : ce que le navigateur TELECHARGE avant le premier ecran (voir `cloture.mjs`), les paquets
+ * partages resolus par la carte d'importation.
+ */
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { brotliCompressSync, constants } from 'node:zlib';
+import { cloture, departDeLaPage, totaux } from '../cloture.mjs';
+import { fichiers, ko, lireJson, relatif } from '../commun.mjs';
+import { natureDesFichiers } from '../livraison.mjs';
+
+/** Les budgets d'un remote, en Ko brotli (plan SPA §2.8). */
+export const BUDGETS_DU_REMOTE = { pageKo: 60, totalKo: 250, catalogueKo: 30 };
+
+/**
+ * Les seuils de l'hote, en Ko brotli (ADR 0031) : 300 pour le premier ecran reel, 280 pour la
+ * charge initiale, ramenes au socle 0.10.0 (releves et historique dans l'ADR).
+ *
+ * ⚠️ Ce ne sont pas la cible du plan SPA §2.8 (170 Ko). L'ecart restant est STRUCTUREL : un paquet
+ * partage en singleton part ENTIER, parce que n'importe quel remote peut en avoir besoin. Un seuil
+ * se baisse ; il ne se leve jamais sans mesure ecrite et sans date.
+ */
+export const BUDGETS_DE_L_HOTE = { premierEcranKo: 300, chargeInitialeKo: 280, cibleDuPlanKo: 170 };
+
+/** Les imports DYNAMIQUES d'un module : les pages qu'il charge a la demande. */
+const IMPORT_DYNAMIQUE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+
+/**
+ * La carte des morceaux LOCAUX d'un remote : avec `denseChunking`, la federation les importe par
+ * `@nf-internal/<morceau>`, que la carte d'importation resout (`import("@nf-internal/produits-X")`),
+ * et non par un chemin relatif. Les morceaux partages n'y sont pas : la coquille les paie.
+ */
+export function carteDesMorceauxLocaux(sortie, partages) {
+  const carte = {};
+  for (const chemin of fichiers(sortie)) {
+    const nom = relatif(sortie, chemin);
+    if (!nom.endsWith('.js') || partages.has(nom)) continue;
+    carte[`@nf-internal/${nom.slice(0, -'.js'.length)}`] = nom;
+  }
+  return carte;
+}
+
+/** Ce que le reseau transporte d'un fichier : sa variante brotli, ou sa compression maximale. */
+function brotliDe(chemin) {
+  if (existsSync(`${chemin}.br`)) return statSync(`${chemin}.br`).size;
+  return brotliCompressSync(readFileSync(chemin), {
+    params: { [constants.BROTLI_PARAM_QUALITY]: constants.BROTLI_MAX_QUALITY },
+  }).length;
+}
+
+/**
+ * Les pages d'un remote : chaque module expose, puis chaque morceau local qu'un import dynamique
+ * atteint, avec la cloture statique de ses morceaux locaux. `partages` : les fichiers du cadre
+ * partage, jamais suivis. Rend une Map du fichier de la page vers `{ nom, poids }` (`poids` : la Map
+ * de `cloture`).
+ */
+export function pagesDuRemote(sortie, exposes, partages = new Set()) {
+  const carte = carteDesMorceauxLocaux(sortie, partages);
+  const local = (specificateur) =>
+    specificateur.startsWith('.')
+      ? specificateur.replace(/^\.\//, '')
+      : (carte[specificateur] ?? null);
+  const pages = new Map();
+  const aVisiter = exposes.map((expose) => ({ fichier: expose.outFileName, nom: expose.key }));
+  while (aVisiter.length > 0) {
+    const { fichier, nom } = aVisiter.shift();
+    if (pages.has(fichier) || !existsSync(join(sortie, fichier))) continue;
+    // Un specificateur nu hors de la carte (un paquet partage) n'est pas suivi : la coquille le paie.
+    const poids = cloture(sortie, [fichier], carte, 0);
+    pages.set(fichier, { nom, poids });
+    for (const chemin of poids.keys()) {
+      if (!chemin.endsWith('.js')) continue;
+      for (const [, cible] of readFileSync(join(sortie, chemin), 'utf8').matchAll(
+        IMPORT_DYNAMIQUE,
+      )) {
+        const page = local(cible);
+        if (page !== null) aVisiter.push({ fichier: page, nom: page });
+      }
+    }
+  }
+  return pages;
+}
+
+function budgetDuRemote(projet) {
+  const entree = lireJson(join(projet.sortie, 'remoteEntry.json'));
+  if (entree === null) {
+    return { defauts: [`${projet.sortieRelative}/remoteEntry.json absent : construire d'abord.`] };
+  }
+  const defauts = [];
+  const details = [];
+  for (const expose of entree.exposes ?? []) {
+    if (!existsSync(join(projet.sortie, expose.outFileName))) {
+      defauts.push(`${expose.key} : ${expose.outFileName} annonce par remoteEntry.json, absent.`);
+    }
+  }
+  const pages = pagesDuRemote(
+    projet.sortie,
+    entree.exposes ?? [],
+    natureDesFichiers(entree).partages,
+  );
+  const charges = new Map();
+  for (const [fichier, { nom, poids }] of pages) {
+    const page = totaux(poids);
+    for (const [chemin, taille] of poids) charges.set(chemin, taille);
+    details.push(
+      `page ${nom} : ${String(ko(page.brotli))} Ko br (${String(page.fichiers)} fichiers)`,
+    );
+    if (ko(page.brotli) > BUDGETS_DU_REMOTE.pageKo) {
+      defauts.push(
+        `page ${nom} (${fichier}) : ${String(ko(page.brotli))} Ko br > ${String(BUDGETS_DU_REMOTE.pageKo)} Ko.`,
+      );
+    }
+  }
+  const total = totaux(charges);
+  if (ko(total.brotli) > BUDGETS_DU_REMOTE.totalKo) {
+    defauts.push(
+      `total charge : ${String(ko(total.brotli))} Ko br > ${String(BUDGETS_DU_REMOTE.totalKo)} Ko.`,
+    );
+  }
+  const dossierI18n = join(projet.sortie, 'i18n');
+  const catalogues = existsSync(dossierI18n)
+    ? readdirSync(dossierI18n).filter((fichier) => fichier.endsWith('.json'))
+    : [];
+  for (const catalogue of catalogues) {
+    const taille = brotliDe(join(dossierI18n, catalogue));
+    details.push(`i18n/${catalogue} : ${String(ko(taille))} Ko br`);
+    if (ko(taille) > BUDGETS_DU_REMOTE.catalogueKo) {
+      defauts.push(
+        `i18n/${catalogue} : ${String(ko(taille))} Ko br > ${String(BUDGETS_DU_REMOTE.catalogueKo)} Ko.`,
+      );
+    }
+  }
+  return {
+    defauts,
+    details,
+    resume: `${String(pages.size)} page(s), ${String(ko(total.brotli))} Ko br au total, dans leurs seuils.`,
+  };
+}
+
+function budgetDeLHote(projet) {
+  const index = join(projet.sortie, 'index.html');
+  if (!existsSync(index)) {
+    return { defauts: [`${projet.sortieRelative}/index.html absent : construire d'abord.`] };
+  }
+  const carte = lireJson(join(projet.sortie, 'importmap.json'))?.imports ?? {};
+  const depart = departDeLaPage(readFileSync(index, 'utf8'));
+  const initiale = totaux(cloture(projet.sortie, depart, carte, 1));
+  const premierEcran = cloture(projet.sortie, depart, carte, 2);
+  const ecran = totaux(premierEcran);
+  const details = [
+    `charge initiale ${String(ko(initiale.brotli))} Ko br (${String(initiale.fichiers)} fichiers)`,
+    `premier ecran reel ${String(ko(ecran.brotli))} Ko br (${String(ecran.fichiers)} fichiers)`,
+    ...[...premierEcran.entries()]
+      .sort((a, b) => b[1].brotli - a[1].brotli)
+      .slice(0, 5)
+      .map(([chemin, taille]) => `  ${String(ko(taille.brotli))} Ko br ${chemin}`),
+  ];
+  const defauts = [];
+  if (ko(initiale.brotli) > BUDGETS_DE_L_HOTE.chargeInitialeKo) {
+    defauts.push(
+      `charge initiale : ${String(ko(initiale.brotli))} Ko br > ${String(BUDGETS_DE_L_HOTE.chargeInitialeKo)} Ko.`,
+    );
+  }
+  if (ko(ecran.brotli) > BUDGETS_DE_L_HOTE.premierEcranKo) {
+    defauts.push(
+      `premier ecran : ${String(ko(ecran.brotli))} Ko br > ${String(BUDGETS_DE_L_HOTE.premierEcranKo)} Ko (garde de non-regression).`,
+    );
+  }
+  const avertissements =
+    ko(ecran.brotli) > BUDGETS_DE_L_HOTE.cibleDuPlanKo
+      ? [
+          `cible du plan SPA (section 2.8) : ${String(BUDGETS_DE_L_HOTE.cibleDuPlanKo)} Ko, ecart assume (ADR 0031).`,
+        ]
+      : [];
+  return { defauts, avertissements, details, resume: 'premier ecran dans ses seuils.' };
+}
+
+export default {
+  nom: 'budget',
+  roles: ['remote', 'hote'],
+  executer: (projet) => (projet.role === 'hote' ? budgetDeLHote(projet) : budgetDuRemote(projet)),
+};