@starterlib/cli 0.10.13 → 0.11.0

package/src/etapes/securite.mjs

@@ -125,6 +125,33 @@ const EXCEPTIONS_DU_CADRE = [
   },
 ];
 
+/**
+ * La lecture de cookie du CADRE dans une application AUTONOME (lot 240) : sans federation, le code
+ * d'Angular n'est pas dans un morceau partage mais dans `main`, et l'exception par nom de fichier ne
+ * s'applique pas. `DomAdapter.getCookie`, de cette forme exacte, est neutralise UNE fois dans tout le
+ * livrable ; toute autre lecture de cookie, n'importe ou, reste un defaut.
+ */
+export const LECTURE_DE_COOKIE_DU_CADRE =
+  /getCookie\((\w+)\)\{return [\w$]+\(document\.cookie,\1\)\}/g;
+
+/**
+ * Les strategies de stockage de l'ORCHESTRATEUR de Native Federation
+ * (`@softarc/native-federation-orchestrator`, `options.mjs` : `localStorageEntry`,
+ * `sessionStorageEntry`), que le greffon 22.2.2 fait entrer dans le `main` d'un hote : deux fabriques
+ * etiquetees (`.type = "localStorage"`, `"sessionStorage"`) que l'orchestrateur n'appelle que si
+ * `initFederation` recoit un de ces stockages ; le defaut, `globalThis`, n'ecrit rien dans le
+ * navigateur. De cette forme exacte, chacune est neutralisee UNE fois dans tout le livrable ; tout
+ * autre acces au stockage, n'importe ou, reste un defaut (ADR 0014). Constat de la montee d'Aplomb
+ * a la 0.11.0, 2026-10-07.
+ */
+export const STOCKAGES_DE_L_ORCHESTRATEUR =
+  /([\w$]+)=([\w$]+)=>\(([\w$]+),([\w$]+)\)=>\{let ([\w$]+)=\{get\(\)\{let ([\w$]+)=(localStorage|sessionStorage)\.getItem\(`\$\{\2\}\.\$\{String\(\3\)\}`\);return \6\?JSON\.parse\(\6\):[\w$]+\(\3,\4\)\},set\(([\w$]+)\)\{return \7\.setItem\(`\$\{\2\}\.\$\{String\(\3\)\}`,JSON\.stringify\(\8\)\),\5\},clear\(\)\{return \7\.setItem\(`\$\{\2\}\.\$\{String\(\3\)\}`,JSON\.stringify\(\4\)\),this\}\};return \5\};\1\.type="\7";Object\.freeze\(\1\);/g;
+
+/** Les stockages qu'une fabrique de l'orchestrateur nomme, dans l'ordre ou le livrable les porte. */
+export function stockagesDeLOrchestrateur(contenu) {
+  return [...contenu.matchAll(STOCKAGES_DE_L_ORCHESTRATEUR)].map((trouve) => trouve[7]);
+}
+
 /** 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',
@@ -164,13 +191,28 @@ function jugerUnePage(nom, contenu) {
 
 /**
  * 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.
+ * `remote`, `hote` ou `autonome` ; `partage` : le fichier est du code du cadre, partage par la
+ * federation ; `cadreNeutralise` : la lecture de cookie du cadre d'une application autonome a deja
+ * ete comptee, et se neutralise ici (une fois par fichier) ; `orchestrateurNeutralise` : les
+ * strategies de stockage de l'orchestrateur de federation ont ete comptees, et se neutralisent ici.
  */
 export function jugerUnFichierLivre(
   nom,
   contenu,
-  { role = 'remote', partage = false, declarees = [] } = {},
+  {
+    role = 'remote',
+    partage = false,
+    declarees = [],
+    cadreNeutralise = false,
+    orchestrateurNeutralise = false,
+  } = {},
 ) {
+  if (cadreNeutralise) {
+    contenu = contenu.replace(LECTURE_DE_COOKIE_DU_CADRE, 'getCookie($1){return null}');
+  }
+  if (orchestrateurNeutralise) {
+    contenu = contenu.replace(STOCKAGES_DE_L_ORCHESTRATEUR, '$1=null;');
+  }
   // 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).`];
@@ -217,7 +259,7 @@ export function jugerUnFichierLivre(
 
 export default {
   nom: 'securite',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer(projet) {
     // Les variantes precompressees derivent des fichiers lus ; celles d'une carte sont signalees.
     const livres = fichiers(projet.sortie).filter(
@@ -240,21 +282,54 @@ export default {
           '(PLATFORM_WEB_CSP_TRUSTED_TYPES) : le BFF retire le remote tant qu elle n y est pas.',
       );
     const defauts = [];
+    // Application autonome : la lecture de cookie du cadre, une seule fois dans tout le livrable.
+    const autonome = projet.role === 'autonome';
+    let lecturesDuCadre = 0;
+    // Les strategies de stockage de l'orchestrateur : au plus une de chaque sorte dans le livrable.
+    const strategies = [];
     for (const chemin of livres) {
       const nom = relatif(projet.sortie, chemin);
       const contenu = /\.(?:m?js|html|svg|css)$/.test(nom) ? readFileSync(chemin, 'utf8') : '';
+      const duCadre =
+        autonome && /\.m?js$/.test(nom)
+          ? (contenu.match(LECTURE_DE_COOKIE_DU_CADRE)?.length ?? 0)
+          : 0;
+      lecturesDuCadre += duCadre;
+      const deLOrchestrateur = /\.m?js$/.test(nom) ? stockagesDeLOrchestrateur(contenu) : [];
+      strategies.push(...deLOrchestrateur);
       defauts.push(
         ...jugerUnFichierLivre(nom, contenu, {
           role: projet.role,
           partage: partages.has(nom),
           declarees,
+          cadreNeutralise: duCadre === 1,
+          orchestrateurNeutralise: deLOrchestrateur.length > 0,
         }),
       );
     }
+    if (lecturesDuCadre > 1) {
+      defauts.push(
+        `lecture de cookie du cadre : ${String(lecturesDuCadre)} occurrences (DomAdapter.getCookie) ; ` +
+          'une seule est admise dans une application autonome.',
+      );
+    }
+    for (const stockage of new Set(strategies)) {
+      const nombre = strategies.filter((nomme) => nomme === stockage).length;
+      if (nombre > 1) {
+        defauts.push(
+          `strategie ${stockage} de l'orchestrateur de federation : ${String(nombre)} occurrences ; ` +
+            'une seule est admise dans le livrable.',
+        );
+      }
+    }
     return {
       defauts,
       avertissements,
-      resume: `${String(livres.length)} fichier(s) livre(s) dont ${String(partages.size)} du cadre partage, rien a signaler.`,
+      resume:
+        `${String(livres.length)} fichier(s) livre(s) dont ${String(partages.size)} du cadre partage, rien a signaler` +
+        (strategies.length === 0
+          ? '.'
+          : ` (strategies de stockage de l'orchestrateur de federation : ${strategies.join(', ')}, neutralisees).`),
     };
   },
 };

package/src/etapes/simulations.mjs

@@ -5,24 +5,38 @@
  *
  * Un stub que l'hote ne sait pas rejouer est nomme en avertissement (le BFF en profil `mock` le sert
  * toujours) ; un fichier de stub illisible ou un corps introuvable est un defaut.
+ *
+ * P08-10 : le fichier de scenarios du remote (`src/hote-dev/scenarios.json`), s'il existe, est juge
+ * aussi ; un scenario que l'hote ne rejouerait pas est un defaut.
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { relatif } from '../commun.mjs';
+import { lireLesScenarios } from '../construction/scenarios.mjs';
 import { CHEMIN_DES_SIMULATIONS, engendrerLesSimulations } from '../construction/simulations.mjs';
 
 export default {
   nom: 'simulations',
   roles: ['remote'],
   async executer(projet) {
+    const scenarios = lireLesScenarios(projet);
+    const deScenarios = scenarios?.defauts ?? [];
     const resultat = await engendrerLesSimulations(projet);
     if (resultat === null) {
+      if (scenarios !== null) {
+        return {
+          defauts: deScenarios,
+          avertissements: [],
+          resume: `${String(scenarios.scenarios.length)} scenario(s) nomme(s) ; aucun simulateur WireMock.`,
+        };
+      }
       return {
         sautee:
           "aucun simulateur WireMock (../src/mock, ou starterWeb.simulations) : l'hote de developpement ne rejoue que ses simulations ecrites.",
       };
     }
-    const { texte, stubs, avertissements, defauts, racine } = resultat;
+    const { texte, stubs, avertissements, racine } = resultat;
+    const defauts = [...resultat.defauts, ...deScenarios];
     if (defauts.length > 0) return { defauts, avertissements };
     const cible = join(projet.racine, CHEMIN_DES_SIMULATIONS);
     const chemin = relatif(projet.racine, cible);
@@ -35,7 +49,11 @@ export default {
     return {
       defauts: [],
       avertissements,
-      resume: `${String(stubs.length)} stub(s) de ${relatif(projet.racine, racine)} rejoues par l'hote de developpement, a jour.`,
+      resume:
+        `${String(stubs.length)} stub(s) de ${relatif(projet.racine, racine)} rejoues par l'hote de developpement, a jour` +
+        (scenarios === null
+          ? '.'
+          : ` ; ${String(scenarios.scenarios.length)} scenario(s) nomme(s).`),
     };
   },
 };

package/src/etapes/versions.mjs

@@ -23,7 +23,7 @@ import { retardEnTrains, trainDe } from '../trains.mjs';
 const FEDERATION = '@angular-architects/native-federation';
 
 /** Exiges dans toute SPA : ce que la matrice epingle et sans quoi rien ne se construit. */
-const EXIGES = [
+export const EXIGES = [
   '@angular/core',
   '@angular/common',
   '@angular/compiler',
@@ -42,6 +42,12 @@ const EXIGES = [
   '@starterlib/util',
 ];
 
+/**
+ * Ce qu'une application AUTONOME (lot 240 : l'ecran anonyme d'identity, ADR 0031 decision 4) n'a
+ * pas : elle n'est ni hote ni remote, et ne charge aucun moteur de federation.
+ */
+const FEDERATION_ET_CHARGEUR = [FEDERATION, 'es-module-shims'];
+
 /** `22.1.7` donne `22.1` ; `null` pour ce qui n'est pas un numero. */
 function majeureMineure(version) {
   const trouve = /^(\d+)\.(\d+)\./.exec(version);
@@ -70,14 +76,23 @@ function trainDeReference(contexte) {
 }
 
 /** Les fautes et avertissements de `paquet` (le package.json) ; exporte pour les essais. */
-export function jugerLesVersions(paquet, { matrice, socle, reference }) {
+export function jugerLesVersions(paquet, { matrice, socle, reference, role = 'remote' }) {
   const declarees = { ...paquet.dependencies, ...paquet.devDependencies };
   const defauts = [];
   const avertissements = [];
 
+  const autonome = role === 'autonome';
   for (const nom of EXIGES) {
+    if (autonome && FEDERATION_ET_CHARGEUR.includes(nom)) continue;
     if (declarees[nom] === undefined) defauts.push(`${nom} : absent de package.json.`);
   }
+  if (autonome) {
+    for (const nom of FEDERATION_ET_CHARGEUR) {
+      if (declarees[nom] !== undefined) {
+        defauts.push(`${nom} : une application autonome ne charge aucun moteur de federation.`);
+      }
+    }
+  }
 
   for (const [nom, attendue] of Object.entries(matrice.paquets)) {
     const declaree = declarees[nom];
@@ -165,7 +180,7 @@ export function jugerLesVersions(paquet, { matrice, socle, reference }) {
 
 export default {
   nom: 'versions',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer(projet, contexte) {
     const matrice = matriceDuSocle();
     const socle = versionDuSocle();
@@ -174,6 +189,7 @@ export default {
       matrice,
       socle,
       reference,
+      role: projet.role,
     });
     return {
       defauts,

package/src/etapes/vulnerabilites.mjs

@@ -8,7 +8,7 @@ import { auditerLesDependances } from '../vulnerabilites.mjs';
 
 export default {
   nom: 'vulnerabilites',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer(projet) {
     try {
       const { defauts, exceptes, composants } = auditerLesDependances(projet.racine);

package/src/index.mjs

@@ -10,3 +10,11 @@ export { comparerLesTrains, retardEnTrains, trainDe } from './trains.mjs';
 export { precompresser } from './construction/precompresser.mjs';
 export { ecrireLeManifeste } from './construction/manifeste.mjs';
 export { poserLeSprite } from './construction/sprite.mjs';
+// Le type des cles, engendre ici et par `@starterlib/schematics` (lot 285) : une seule ecriture.
+export { cheminDesTypesDeCles, typesDeCles } from './construction/types-i18n.mjs';
+export {
+  ecrireLesNavigateurs,
+  jugerLesNavigateurs,
+  navigateursDeLaSpa,
+  navigateursDuSocle,
+} from './navigateurs.mjs';

package/src/lancer.mjs

@@ -9,12 +9,16 @@ import { demarrer } from './construction/demarrer.mjs';
 import { ecrireLeManifeste } from './construction/manifeste.mjs';
 import { juger, precompresser } from './construction/precompresser.mjs';
 import { poserLeSprite } from './construction/sprite.mjs';
+import { CHEMIN_DES_SCENARIOS, lireLesScenarios } from './construction/scenarios.mjs';
 import { ecrireLesSimulations } from './construction/simulations.mjs';
 import { ecrireLesTypesDeCles } from './construction/types-i18n.mjs';
 import { lireJson, relatif } from './commun.mjs';
+import { ecrireLaFeuilleDeMarque, fichierDeMarque } from './marque.mjs';
+import { ecrireLesNavigateurs } from './navigateurs.mjs';
 import { versionDuSocle } from './matrice.mjs';
 import { ProjetIllisible, lireLeProjet } from './projet.mjs';
 import { ETAPES, etapesInconnues, verifier } from './verifier.mjs';
+import { perimetresDuProjet } from './etapes/i18n.mjs';
 import { join, resolve } from 'node:path';
 
 const AIDE = `starter-web : la chaine d'une SPA du socle frontal (@starterlib/cli).
@@ -28,7 +32,12 @@ Commandes :
   precompresser   ecrit les variantes .br et .gz (dossier livre, ou le dossier donne)
   i18n:types      engendre le type des cles de chaque perimetre (src/app/i18n/cles.ts)
   simulations     recopie les stubs WireMock du service pour l'hote de developpement
-                  (src/hote-dev/simulations.engendre.json)
+                  (src/hote-dev/simulations.engendre.json) ; --scenarios liste et juge les
+                  scenarios nommes du remote (src/hote-dev/scenarios.json, ?scenario=<nom>)
+  navigateurs     ecrit la liste browserslist du socle (.browserslistrc, plancher de la matrice)
+  jetons          juge la marque de la SPA (marque.json, ou --marque <fichier>) par le moteur des
+                  jetons installe, et ecrit sa feuille starter-tokens-<nom>.css dans la sortie de
+                  construction (ou --sortie <dossier>) ; refuse une marque non conforme, paire nommee
   etapes          liste les etapes de verify
 
 Options de verify :
@@ -40,6 +49,30 @@ Options du projet (valeurs attendues, lues sinon dans ses fichiers) :
   --nom <nom>  --prefixe <prefixe>  --pleine-page | --pas-pleine-page
 `;
 
+/**
+ * `starter-web simulations --scenarios` (P08-10) : les scenarios nommes du remote, chacun avec
+ * l'adresse qui l'ouvre dans l'hote de developpement ; 1 sur un defaut du fichier.
+ */
+function listerLesScenarios(projet, sortie) {
+  const lus = lireLesScenarios(projet);
+  if (lus === null) {
+    sortie.info(`scenarios : aucun fichier de scenarios (${CHEMIN_DES_SCENARIOS}).`);
+    return 0;
+  }
+  for (const defaut of lus.defauts) sortie.erreur(`  - ${defaut}`);
+  sortie.info(
+    `scenarios : ${String(lus.scenarios.length)} dans ${relatif(projet.racine, lus.chemin)}`,
+  );
+  for (const scenario of lus.scenarios) {
+    const contenu = [
+      `${String(scenario.stubs)} stub(s)`,
+      ...(scenario.session ? ['session changee'] : []),
+    ].join(', ');
+    sortie.info(`  ?scenario=${scenario.nom} : ${scenario.description} (${contenu})`);
+  }
+  return lus.defauts.length > 0 ? 1 : 0;
+}
+
 /** Les arguments en `{ commande, positionnels, options }` ; leve sur une option inconnue. */
 export function lireLesArguments(argv) {
   const options = {};
@@ -82,6 +115,14 @@ export function lireLesArguments(argv) {
         options.port = valeur(indice, argument);
         indice += 1;
         break;
+      case '--marque':
+        options.marque = valeur(indice, argument);
+        indice += 1;
+        break;
+      case '--sortie':
+        options.sortie = valeur(indice, argument);
+        indice += 1;
+        break;
       case '--configuration':
         options.configuration = valeur(indice, argument);
         indice += 1;
@@ -89,6 +130,9 @@ export function lireLesArguments(argv) {
       case '--pleine-page':
         options.pleinePage = true;
         break;
+      case '--scenarios':
+        options.scenarios = true;
+        break;
       case '--pas-pleine-page':
         options.pleinePage = false;
         break;
@@ -109,6 +153,25 @@ export function lireLesArguments(argv) {
   return { commande, positionnels: reste, options };
 }
 
+/** `starter-web jetons` : juge la marque, ecrit sa feuille ; 1 et chaque defaut si elle echoue. */
+async function marquer(racine, marque, dossier, sortie) {
+  const chemin = marque ?? fichierDeMarque(racine);
+  if (chemin === null || chemin === undefined) {
+    sortie.erreur(
+      'starter-web jetons : aucune marque (marque.json a la racine, ou --marque <fichier>).',
+    );
+    return 2;
+  }
+  const { valeurs, defauts, feuille } = await ecrireLaFeuilleDeMarque(racine, chemin, dossier);
+  if (defauts.length > 0) {
+    sortie.erreur(`jetons : marque ${String(valeurs?.nom)} non conforme :`);
+    for (const defaut of defauts) sortie.erreur(`  - ${defaut}`);
+    return 1;
+  }
+  sortie.info(`jetons : marque ${valeurs.nom} conforme, ${relatif(racine, feuille)} ecrite.`);
+  return 0;
+}
+
 function precompresserEtDire(dossier, sortie) {
   const { resume, defauts } = juger(precompresser(dossier));
   sortie.info(`precompression : ${resume}`);
@@ -154,6 +217,19 @@ export async function lancer(argv, { racine = process.cwd(), journal } = {}) {
     return 2;
   }
 
+  // Une marque se juge et s'ecrit sans projet autour quand la sortie est donnee (un essai, un depot
+  // de marque) ; sinon la feuille part dans la sortie de construction du projet.
+  if (commande === 'jetons' && options.sortie !== undefined) {
+    try {
+      return await marquer(racine, options.marque, resolve(racine, options.sortie), sortie);
+    } catch (erreur) {
+      sortie.erreur(
+        `starter-web jetons : ${erreur instanceof Error ? erreur.message : String(erreur)}`,
+      );
+      return 1;
+    }
+  }
+
   // Un dossier donne se precompresse sans projet autour : une fixture reecrite, un dossier d'essai.
   if (commande === 'precompresser' && positionnels[0] !== undefined) {
     return precompresserEtDire(resolve(racine, positionnels[0]), sortie);
@@ -196,9 +272,15 @@ export async function lancer(argv, { racine = process.cwd(), journal } = {}) {
       }
       case 'precompresser':
         return precompresserEtDire(projet.sortie, sortie);
+      case 'jetons':
+        return await marquer(projet.racine, options.marque, projet.sortie, sortie);
+      case 'navigateurs': {
+        const chemin = ecrireLesNavigateurs(projet.racine);
+        sortie.info(`navigateurs : ${relatif(projet.racine, chemin)} (plancher du socle)`);
+        return 0;
+      }
       case 'i18n:types': {
-        const perimetres =
-          projet.role === 'remote' ? (projet.source?.i18n?.perimetres ?? []) : ['socle'];
+        const perimetres = perimetresDuProjet(projet);
         const catalogues = Object.fromEntries(
           perimetres.map((perimetre) => [
             perimetre,
@@ -210,6 +292,7 @@ export async function lancer(argv, { racine = process.cwd(), journal } = {}) {
         return 0;
       }
       case 'simulations': {
+        if (options.scenarios === true) return listerLesScenarios(projet, sortie);
         const resultat = await ecrireLesSimulations(projet);
         if (resultat === null) {
           sortie.info(

package/src/marque.mjs

@@ -0,0 +1,78 @@
+/**
+ * La marque d'une SPA (niveau 2 bis de `@starterlib/tokens`) : `starter-web jetons --marque <fichier>`
+ * lit une table de valeurs, la fait juger par le moteur des jetons INSTALLE (les gardes de contraste
+ * n'existent qu'a un seul endroit, le socle, a la version meme qui tournera dans la page), et ecrit la
+ * feuille `starter-tokens-<nom>.css` dans la sortie de construction. `starter-web verify` rejoue le
+ * meme jugement (etape `jetons`) a chaque verification, tant qu'un fichier de marque est a la racine.
+ *
+ * Fichier de marque : `marque.json`, ou un module `marque.ts` / `marque.mjs` qui exporte la table
+ * (`export default`, ou `export const marque`). Forme : `ValeursDeMarque` du moteur (README des jetons).
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { dossierInstalle } from './socle-installe.mjs';
+
+/** Les fichiers de marque reconnus a la racine de la SPA, dans l'ordre de recherche. */
+export const FICHIERS_DE_MARQUE = ['marque.json', 'marque.ts', 'marque.mjs'];
+
+/** Le fichier de marque de la SPA, `null` si elle n'en a pas. */
+export function fichierDeMarque(racine) {
+  for (const nom of FICHIERS_DE_MARQUE) {
+    const chemin = join(racine, nom);
+    if (existsSync(chemin)) return chemin;
+  }
+  return null;
+}
+
+/** La table de valeurs d'un fichier de marque (JSON, ou module : Node 24 retire les types a l'import). */
+export async function lireLaMarque(chemin) {
+  if (chemin.endsWith('.json')) return JSON.parse(readFileSync(chemin, 'utf8'));
+  const module = await import(pathToFileURL(chemin).href);
+  const valeurs = module.default ?? module.marque;
+  if (valeurs === undefined) {
+    throw new Error(`${chemin} n'exporte ni \`default\` ni \`marque\`.`);
+  }
+  return valeurs;
+}
+
+/** Le moteur des jetons de `@starterlib/tokens` INSTALLE ; leve s'il manque ou ne connait pas les marques. */
+export async function moteurInstalle(racine) {
+  const dossier = dossierInstalle(racine, '@starterlib/tokens');
+  if (dossier === null)
+    throw new Error("@starterlib/tokens n'est pas installe : pnpm install d'abord.");
+  const module = join(dossier, 'fesm2022', 'starterlib-tokens-moteur.mjs');
+  if (!existsSync(module)) {
+    throw new Error(`le moteur des jetons manque a @starterlib/tokens installe (${module}).`);
+  }
+  const moteur = await import(pathToFileURL(module).href);
+  if (
+    typeof moteur.defautsDeLaMarque !== 'function' ||
+    typeof moteur.feuilleDeMarque !== 'function'
+  ) {
+    throw new Error(
+      '@starterlib/tokens installe ne connait pas les marques (niveau 2 bis) : monter le socle.',
+    );
+  }
+  return moteur;
+}
+
+/** `{ valeurs, defauts }` : la marque du fichier, jugee par le moteur installe de la SPA. */
+export async function jugerLaMarque(racine, chemin) {
+  const moteur = await moteurInstalle(racine);
+  const valeurs = await lireLaMarque(chemin);
+  return { moteur, valeurs, defauts: [...moteur.defautsDeLaMarque(valeurs)] };
+}
+
+/**
+ * Juge la marque de `chemin` et, conforme, ecrit sa feuille dans `sortie`. Rend
+ * `{ valeurs, defauts, feuille }` (`feuille` : le chemin ecrit, absent s'il y a des defauts).
+ */
+export async function ecrireLaFeuilleDeMarque(racine, chemin, sortie) {
+  const { moteur, valeurs, defauts } = await jugerLaMarque(racine, resolve(racine, chemin));
+  if (defauts.length > 0) return { valeurs, defauts };
+  mkdirSync(sortie, { recursive: true });
+  const feuille = join(sortie, `starter-tokens-${valeurs.nom}.css`);
+  writeFileSync(feuille, moteur.feuilleDeMarque(valeurs));
+  return { valeurs, defauts, feuille };
+}

package/src/navigateurs.mjs

@@ -0,0 +1,128 @@
+/**
+ * La liste des navigateurs PARTAGEE (lot 276) : le plancher du socle, ecrit UNE fois dans
+ * `docs/matrice-compatibilite.md` (section « Navigateurs », ADR web 0005), traduit en requetes
+ * browserslist que chaque SPA pose a sa racine (`.browserslistrc`) et que la construction d'Angular
+ * lit pour ses cibles. `starter-web navigateurs` l'ecrit ; l'etape `navigateurs` de `starter-web
+ * verify` refuse une liste qui s'en ecarte : une SPA ne vise ni plus bas que le socle (elle
+ * promettrait ce que les feuilles ne tiennent pas), ni plus haut (elle refuserait sans le dire un
+ * navigateur que le socle prend en charge).
+ *
+ * Edge suit Chrome ; la WebView d'Android suit Chromium et WKWebView le Safari du systeme (ADR
+ * 0043 du socle `api/starter`) : memes planchers.
+ */
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { lireJson } from './commun.mjs';
+import { cheminDeLaMatrice } from './matrice.mjs';
+
+/** « Plancher du socle (ADR web 0005) : **Chrome 123, Safari 17.5, Firefox 129** ». */
+const LIGNE_DU_PLANCHER = /Plancher du socle[^*]*\*\*([^*]+)\*\*/;
+
+/** Le plancher que la matrice ecrit : `{ chrome: '123', safari: '17.5', firefox: '129' }`. */
+export function plancherDeLaMatrice(texte) {
+  const trouve = LIGNE_DU_PLANCHER.exec(texte);
+  if (trouve === null) {
+    throw new Error('matrice-compatibilite.md : aucune ligne « Plancher du socle ... **...** ».');
+  }
+  const plancher = {};
+  for (const morceau of (trouve[1] ?? '').split(',')) {
+    const [nom, version] = morceau.trim().split(/\s+/);
+    if (nom !== undefined && version !== undefined && /^\d+(\.\d+)?$/.test(version)) {
+      plancher[nom.toLowerCase()] = version;
+    }
+  }
+  for (const attendu of ['chrome', 'safari', 'firefox']) {
+    if (plancher[attendu] === undefined) {
+      throw new Error(`matrice-compatibilite.md : plancher sans ${attendu}.`);
+    }
+  }
+  return plancher;
+}
+
+/** Les requetes browserslist d'un plancher, dans un ordre fixe. */
+export function requetesDuPlancher({ chrome, safari, firefox }) {
+  return [
+    `Chrome >= ${chrome}`,
+    `Edge >= ${chrome}`,
+    `Firefox >= ${firefox}`,
+    `Safari >= ${safari}`,
+    `iOS >= ${safari}`,
+    `ChromeAndroid >= ${chrome}`,
+    `Android >= ${chrome}`,
+    `FirefoxAndroid >= ${firefox}`,
+  ];
+}
+
+/** Les requetes du socle, lues dans la matrice publiee avec ce CLI. */
+export function navigateursDuSocle() {
+  return requetesDuPlancher(plancherDeLaMatrice(readFileSync(cheminDeLaMatrice(), 'utf8')));
+}
+
+/** Une requete normalisee : espaces resserres, casse ignoree. */
+const normaliser = (requete) => requete.trim().replace(/\s+/g, ' ').toLowerCase();
+
+/** Les lignes utiles d'un `.browserslistrc` : sans commentaire ni ligne vide. */
+function lignesDuFichier(texte) {
+  return texte
+    .split(/\r?\n/)
+    .map((ligne) => ligne.replace(/#.*$/, '').trim())
+    .filter((ligne) => ligne !== '')
+    .flatMap((ligne) => ligne.split(','))
+    .map((ligne) => ligne.trim())
+    .filter((ligne) => ligne !== '');
+}
+
+/**
+ * La liste que la SPA declare : `.browserslistrc` a sa racine, sinon `browserslist` de son
+ * `package.json`. `null` si elle n'en declare aucune (la construction prendrait alors la cible par
+ * defaut d'Angular, plus basse que le plancher du socle).
+ */
+export function navigateursDeLaSpa(racine) {
+  const chemin = join(racine, '.browserslistrc');
+  if (existsSync(chemin)) {
+    return { origine: '.browserslistrc', requetes: lignesDuFichier(readFileSync(chemin, 'utf8')) };
+  }
+  const declares = lireJson(join(racine, 'package.json'))?.browserslist;
+  if (Array.isArray(declares)) return { origine: 'package.json', requetes: declares.map(String) };
+  if (typeof declares === 'string') {
+    return { origine: 'package.json', requetes: lignesDuFichier(declares) };
+  }
+  return null;
+}
+
+/** Les defauts d'une liste lue contre celle du socle (l'ordre ne compte pas). */
+export function jugerLesNavigateurs(lus, attendus) {
+  if (lus === null) {
+    return [
+      'aucune liste de navigateurs : poser celle du socle (starter-web navigateurs ecrit ' +
+        '.browserslistrc).',
+    ];
+  }
+  const voulus = new Map(attendus.map((requete) => [normaliser(requete), requete]));
+  const trouves = new Set(lus.requetes.map(normaliser));
+  const defauts = [];
+  for (const [cle, requete] of voulus) {
+    if (!trouves.has(cle)) defauts.push(`${lus.origine} : « ${requete} » manque.`);
+  }
+  for (const requete of lus.requetes) {
+    if (!voulus.has(normaliser(requete))) {
+      defauts.push(`${lus.origine} : « ${requete} » n'est pas dans la liste du socle.`);
+    }
+  }
+  return defauts;
+}
+
+/** Ecrit la liste du socle dans `.browserslistrc` ; rend son chemin. */
+export function ecrireLesNavigateurs(racine, requetes = navigateursDuSocle()) {
+  const chemin = join(racine, '.browserslistrc');
+  writeFileSync(
+    chemin,
+    [
+      '# Liste du socle frontal (docs/matrice-compatibilite.md, « Navigateurs »), ecrite par',
+      '# starter-web navigateurs et verifiee par starter-web verify : ne pas la modifier a la main.',
+      ...requetes,
+      '',
+    ].join('\n'),
+  );
+  return chemin;
+}

package/src/projet.mjs

@@ -5,8 +5,9 @@
  * (`dist/<nom>/browser`, `/ui/<nom>/`), le prefixe de ses selecteurs et `pleinePage`. Le CLI les lit
  * la ou elles vivent deja :
  *
- * - le role : `package.json#starterWeb.role` (`hote` pour la coquille), sinon `remote` des qu'un
- *   `manifest.source.json` existe ;
+ * - le role : `package.json#starterWeb.role` (`hote` pour la coquille, `autonome` pour une
+ *   application servie seule, sans federation : l'ecran anonyme d'identity, lot 240), sinon `remote`
+ *   des qu'un `manifest.source.json` existe ;
  * - le nom et `pleinePage` : `manifest.source.json` (un remote), `socle` pour l'hote ;
  * - le prefixe : `prefix` du projet d'`angular.json`, ou `starterWeb.prefixe` ;
  * - le dossier livre : `outputPath` de la cible `@angular/build:application`, plus `browser`.
@@ -62,8 +63,10 @@ export function lireLeProjet(racine, options = {}) {
 
   const cheminSource = join(racine, 'manifest.source.json');
   const role = options.role ?? reglages.role ?? (existsSync(cheminSource) ? 'remote' : 'hote');
-  if (role !== 'remote' && role !== 'hote') {
-    throw new ProjetIllisible(`starterWeb.role : "remote" ou "hote", recu "${String(role)}".`);
+  if (role !== 'remote' && role !== 'hote' && role !== 'autonome') {
+    throw new ProjetIllisible(
+      `starterWeb.role : "remote", "hote" ou "autonome", recu "${String(role)}".`,
+    );
   }
   const source = role === 'remote' ? lireJson(cheminSource) : null;
   if (role === 'remote' && source === null) {