@starterlib/cli 0.10.12 → 0.10.14

package/README.md

@@ -41,6 +41,7 @@ Scripts d'une SPA :
 | `starter-web precompresser` | Ecrit les variantes `.br` et `.gz`, et `precompression.index` (chaque variante et le condense de son source, que le serveur confronte) ; `starter-web precompresser <dossier>` pour un autre dossier |
 | `starter-web i18n:types`    | Engendre `src/app/i18n/cles.ts`, le type des cles de chaque perimetre (`injecterTraduction<C>`)                                                                                                      |
 | `starter-web simulations`   | Recopie les stubs WireMock du service (`../src/mock`), corps compris, pour l'hote de developpement (`src/hote-dev/simulations.engendre.json`)                                                        |
+| `starter-web navigateurs`   | Ecrit `.browserslistrc` : la liste browserslist du socle, tiree du plancher de la matrice (lot 276)                                                                                                  |
 | `starter-web etapes`        | Liste les etapes et les roles qu'elles concernent                                                                                                                                                    |
 
 Codes de sortie : `0` conforme ; `1` une etape a echoue ; `2` la commande ne peut pas s'executer
@@ -48,24 +49,27 @@ Codes de sortie : `0` conforme ; `1` une etape a echoue ; `2` la commande ne peu
 
 ## Les etapes de `verify`
 
-| Etape         | Role     | Ce qu'elle garde                                                                                                                                                |
-| ------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `versions`    | les deux | Versions exactes de la matrice, greffon de federation lie a Angular, pnpm, Node, train du socle                                                                 |
-| `dependances` | les deux | Dependances de production revues, paquets interdits, aucun outil du socle recopie sous `tools/`                                                                 |
-| `jetons`      | les deux | Chaque `var(--st-*)` sans repli existe dans `@starterlib/tokens` (feuilles et styles en ligne)                                                                  |
-| `format`      | les deux | `prettier --check .`                                                                                                                                            |
-| `lint`        | les deux | Prefixe des selecteurs (jamais `st-`), `eslint .`, puis stylelint (configuration du socle exigee)                                                               |
-| `i18n`        | les deux | Memes cles et arguments en fr et en, messages lisibles, cles appelees presentes, aide de chaque page (`<perimetre>.aide.<page>`), types a jour                  |
-| `test`        | les deux | `ng test --no-watch`                                                                                                                                            |
-| `contrat`     | les deux | `pnpm run contrat:check` s'il existe (client d'API engendre, lot 175), sinon sautee en le disant                                                                |
-| `simulations` | remote   | Les stubs WireMock du service, tels que l'hote de developpement les rejoue, a jour (lot 269) ; sautee sans simulateur ; un stub hors du sous-ensemble est nomme |
-| `build`       | les deux | `starter-web construire`                                                                                                                                        |
-| `manifeste`   | les deux | `validerLeManifesteDeRemote` et le schema de `@starterlib/core` INSTALLE ; le nom partout le meme                                                               |
-| `federation`  | les deux | Partage en singleton strict a plage explicite, Angular et le socle partages, aucun import nu orphelin                                                           |
-| `entree`      | hote     | Aucun paquet partage importe statiquement avant `initFederation`                                                                                                |
-| `budget`      | les deux | En brotli. Remote : chaque page (60 Ko), le total (250 Ko), les catalogues. Hote : premier ecran                                                                |
-| `amorcage`    | hote     | Aucun pair lourd (CDK, aria, formulaires, surfaces) dans le premier ecran                                                                                       |
-| `securite`    | les deux | Puits de l'ADR 0029 dans le code de la SPA, politiques Trusted Types exactes, cartes, SVG, meta CSP                                                             |
+| Etape            | Role     | Ce qu'elle garde                                                                                                                                                                                                                                                                    |
+| ---------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `versions`       | tous     | Versions exactes de la matrice, greffon de federation lie a Angular, pnpm, Node, train du socle                                                                                                                                                                                     |
+| `navigateurs`    | tous     | La liste browserslist de la SPA (`.browserslistrc`, ou `browserslist` de `package.json`) est celle du plancher de la matrice : ni absente, ni plus basse, ni plus large (lot 276)                                                                                                   |
+| `dependances`    | tous     | Dependances de production revues, paquets interdits, aucun outil du socle recopie sous `tools/`                                                                                                                                                                                     |
+| `jetons`         | tous     | Chaque `var(--st-*)` sans repli existe dans `@starterlib/tokens` (feuilles et styles en ligne)                                                                                                                                                                                      |
+| `format`         | tous     | `prettier --check .`                                                                                                                                                                                                                                                                |
+| `lint`           | tous     | Prefixe des selecteurs (jamais `st-`), `eslint .`, puis stylelint (configuration du socle exigee)                                                                                                                                                                                   |
+| `i18n`           | tous     | Memes cles et arguments en fr et en, messages lisibles, cles appelees presentes, aide de chaque page (`<perimetre>.aide.<page>`), types a jour                                                                                                                                      |
+| `test`           | tous     | `ng test --no-watch`                                                                                                                                                                                                                                                                |
+| `contrat`        | tous     | `pnpm run contrat:check` s'il existe (client d'API engendre, lot 175), sinon sautee en le disant                                                                                                                                                                                    |
+| `simulations`    | remote   | Les stubs WireMock du service, tels que l'hote de developpement les rejoue, a jour (lot 269) ; sautee sans simulateur ; un stub hors du sous-ensemble est nomme                                                                                                                     |
+| `build`          | tous     | `starter-web construire`                                                                                                                                                                                                                                                            |
+| `vulnerabilites` | tous     | `pnpm audit --prod` : HIGH et CRITICAL bloquent sauf exception DATEE de `securite/exceptions-npm.json` (un trimestre au plus) ; SBOM CycloneDX dans `dist/sbom-front.cdx.json`, a cote du dossier livre (jamais servie) ; licences AGPL, SSPL et inconnues refusees (lot 139)       |
+| `manifeste`      | les deux | `validerLeManifesteDeRemote` et le schema de `@starterlib/core` INSTALLE ; le nom partout le meme                                                                                                                                                                                   |
+| `federation`     | les deux | Partage en singleton strict a plage explicite, Angular et le socle partages, aucun import nu orphelin                                                                                                                                                                               |
+| `entree`         | hote     | Aucun paquet partage importe statiquement avant `initFederation`                                                                                                                                                                                                                    |
+| `budget`         | les deux | En brotli. Remote : chaque page (60 Ko), le total (250 Ko), les catalogues. Hote : premier ecran                                                                                                                                                                                    |
+| `autonome`       | autonome | Aucune federation livree (`remoteEntry`, carte d'importation, `es-module-shims`) ; versions d'Angular et du socle egales a celles du jumeau (`starterWeb.jumeau`) ; poids de l'ecran (`starterWeb.ecran` : entree et seuil en Ko br), lu dans la carte de la construction (lot 240) |
+| `amorcage`       | hote     | Aucun pair lourd (CDK, aria, formulaires, surfaces) dans le premier ecran                                                                                                                                                                                                           |
+| `securite`       | tous     | Puits de l'ADR 0029 dans le code de la SPA, politiques Trusted Types exactes, cartes, SVG, meta CSP                                                                                                                                                                                 |
 
 `--etapes a,b` n'en joue que certaines ; `--sauter a,b` en retire.
 
@@ -80,8 +84,15 @@ par un point d'entree vide dans la configuration `production`).
 
 ## Ce que le CLI lit, et d'ou
 
-- 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 ;
+- pour une application autonome, dans `starterWeb` : `nom` (le projet d'`angular.json`),
+  `i18n.perimetres` (ses catalogues), `jumeau` (le dossier du remote du meme service, dont elle
+  partage les versions) et `ecran` (`{ "entree": "src/app/pages/connexion.ts", "seuilKo": 155 }`) ;
+  `starter-web construire` n'y ecrit pas de manifeste, et pose `--stats-json` ; `securite` y
+  neutralise UNE lecture de cookie du cadre (`DomAdapter.getCookie`, dans `main` faute de morceau
+  partage), toute autre restant un defaut ;
 - le nom et `pleinePage` : `manifest.source.json` (un remote), `socle` pour l'hote ;
 - le prefixe des selecteurs : `prefix` du projet d'`angular.json` (ou `starterWeb.prefixe`) ;
 - le dossier livre : `outputPath` de la cible `@angular/build:application`, plus `browser` ;

package/matrice-compatibilite.md

@@ -19,7 +19,9 @@ proprietaire du 2026-09-26).
 | -------------------------------------------------------------------------------------------- | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `@angular/core`, `common`, `compiler`, `compiler-cli`, `forms`, `platform-browser`, `router` | `22.2.0`           | Premiere de la ligne 22.2, publiee le 2026-09-23 (plus de trois jours au 2026-09-27)                                                                                                                |
 | `@angular/cdk`, `aria`                                                                       | `22.2.0`           | Le paquet `aria` est stable depuis la 22 ; il porte les primitives sans style. `@angular/material` est retire : aucun composant du socle ne l'importe                                               |
+| `@angular/elements`                                                                          | `22.2.0`           | Les custom elements de `@starterlib/elements` seulement (lot 299, decision du proprietaire du 2026-10-01) ; son pair exige le numero exact de `@angular/core`, d'ou 22.2.0 et non la 22.2.1 publiee |
 | `@angular/build`, `@angular/cli`                                                             | `22.2.0`           | ⚠️ **Cadence differente de `core`.** L'outillage recoit des correctifs que le coeur ne recoit pas. Une matrice qui ne porterait qu'un seul numero mentirait des le premier correctif                |
+| `@angular-devkit/schematics`                                                                 | `22.2.0`           | Le moteur des schematics du CLI d'Angular, au meme numero : `@starterlib/schematics` (lot 285) n'en importe rien a l'execution, ses essais le lancent (`SchematicTestRunner`)                       |
 | `ng-packagr`                                                                                 | `22.2.1`           | Derniere stable de la ligne 22.2 (2026-09-23)                                                                                                                                                       |
 | `typescript`                                                                                 | `6.0.3`            | ⚠️ **Piege.** La 7.0.2 est publiee, mais `@angular/compiler-cli@22.2.0` exige `>=6.0 <6.1`. Installer la derniere casse la compilation                                                              |
 | `node`                                                                                       | `>=24.15.0`        | 24.x LTS, declare dans `engines` ; le meme plancher que la construction Maven des SPA (`frontend.node.version`)                                                                                     |
@@ -31,6 +33,18 @@ proprietaire du 2026-09-26).
 | `stylelint`, `postcss-scss`                                                                  | `17.15.0`, `4.0.9` | Les feuilles du socle et des SPA (lot 178, `@starterlib/eslint-config/stylelint`) ; `postcss-scss` lit le SCSS                                                                                      |
 | `jsdom`, `axe-core`                                                                          | `30.0.1`, `4.13.0` | Le DOM des essais unitaires et le controle d'accessibilite : un correctif change ce qu'un essai voit                                                                                                |
 
+## Prochain train : `2026.2` (prevu, non applique)
+
+Lot 297 : le train suivant se monte a la promotion LTS de Node 26 (calendrier de Node : fin octobre
+2026), et pas avant. Ce que la montee changera, dans un commit par depot (socle puis les quatre
+interfaces), avec `pnpm verify` et `banc-d-assemblage.sh --construire` verts :
+
+- `engines.node` exact sur Node 26, `setup-node` des workflows, `build-spa.yml` et
+  `frontend.node.version` de `platform-parent` ;
+- pnpm 12 une fois publie et age de trois jours (`packageManager`, `frontend.pnpm.version`) ;
+- reevaluation des API de la section 3 de `regles-front.md` (`withViewTransitions`, `debounced`,
+  `@boundary`, ancrage CSS avec le banc sur trois moteurs).
+
 ## A destination des depots de SPA (pas de ce depot)
 
 | Element                                 | Version  | Avertissement                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -53,8 +67,33 @@ maximum, fonction par fonction, de ce que les feuilles et le noyau emploient san
 | `transition-behavior: allow-discrete` | 117    | 17.4   | 129     | admis pour une sortie qui anime `display`                  |
 
 Sous ce plancher, rien ne casse sans le dire : une surface sans `@starting-style` apparait d'un coup ; une
-couleur sans `light-dark()` n'existe pas, d'ou le plancher. Le banc tourne sur Chromium ; Firefox et WebKit
-entrent au banc d'assemblage (lot 276).
+couleur sans `light-dark()` n'existe pas, d'ou le plancher.
+
+Ce plancher est plus haut que celui d'Angular 22.2 (« baseline widely available » au 2026-05-07 : Chrome et
+Edge 119, Firefox 119, Safari et iOS 17) : la construction ne vise pas plus bas que le socle n'en a besoin.
+
+**Liste partagee (lot 276, 0.10.14).** La liste browserslist de chaque SPA DERIVE de la ligne du plancher
+ci-dessus, que `@starterlib/cli` lit dans ce document publie avec lui : Chrome, Edge, Chrome Android et la
+WebView d'Android au plancher de Chrome, Firefox et Firefox Android a celui de Firefox, Safari et iOS a
+celui de Safari. `starter-web navigateurs` l'ecrit dans `.browserslistrc` ; l'etape `navigateurs` de
+`starter-web verify` refuse une liste absente, plus basse ou plus large. Sous le plancher, l'hote montre
+la page « navigateur non pris en charge » de `@starterlib/core/navigateur` au lieu de demarrer
+(detection par fonction, jamais par l'agent utilisateur).
+
+**Mesure (banc d'assemblage du BFF, lot 276, 2026-10-01).** Playwright 1.63 : Chromium 153, Firefox 155,
+WebKit 26.6, Pixel 7 et iPhone 15 emules. Chromium et le telephone Android jouent tout le banc a chaque
+poussee ; Firefox, WebKit et l'iPhone jouent les scenarios `@moteurs` et `@mobile` chaque semaine
+(`BANC_MOTEURS=tous`).
+
+| Moteur        | Version mesuree | Plancher | Ce qui se degrade entre le plancher et la mesure                                   |
+| ------------- | --------------- | -------- | ---------------------------------------------------------------------------------- |
+| Chromium/Edge | 153             | 123      | rien de connu : les types de confiance y sont appliques depuis bien avant 123      |
+| Firefox       | 155             | 129      | la protection des puits DOM par les types de confiance, si la version ne les a pas |
+| Safari/iOS    | 26.6            | 17.5     | idem ; la politique bloque toujours les scripts sans nonce                         |
+
+**WebView.** Android System WebView suit Chromium, WKWebView suit le Safari du systeme : memes planchers
+(decisions mobiles, ADR 0043 du socle `api/starter`). **Revision** : a chaque montee de Playwright (nouveaux moteurs) et au plus
+tard a chaque majeure d'Angular.
 
 ## Regle de retard
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starterlib/cli",
-  "version": "0.10.12",
+  "version": "0.10.14",
   "description": "Chaine de verification et de construction des SPA du socle frontal starter : starter-web verify, construire, sprite, manifeste, precompresser. Jamais en dependance de production.",
   "license": "UNLICENSED",
   "type": "module",

package/src/construction/construire.mjs

@@ -50,21 +50,28 @@ export function construire(
   { configuration = 'production', journal = console, sprite = true } = {},
 ) {
   if (sprite) journal.info(`  sprite : ${poserLeSprite(projet)}`);
+  // Une application autonome ecrit la carte de sa construction : l'etape `autonome` y lit le
+  // morceau de la route de son ecran (lot 240).
+  const carte = projet.role === 'autonome' ? ['--stats-json'] : [];
   const code = executer(
     'pnpm',
-    ['exec', 'ng', 'build', '--configuration', configuration],
+    ['exec', 'ng', 'build', '--configuration', configuration, ...carte],
     projet.racine,
   );
   if (code !== 0) {
     journal.erreur(`  ng build --configuration ${configuration} : code ${String(code)}.`);
     return code;
   }
-  if (projet.role === 'hote')
+  // L'hote et l'application autonome peignent un premier ecran : la police s'y precharge.
+  if (projet.role === 'hote' || projet.role === 'autonome')
     journal.info(`  police prechargee : ${prechargerLaPolice(projet.sortie)}`);
-  const manifeste = ecrireLeManifeste(projet);
-  journal.info(
-    `  manifest.json : ${manifeste.nom} ${manifeste.version}, socle ${manifeste.socle.construit}`,
-  );
+  // Une application autonome n'est pas assemblee : aucun manifeste (lot 240).
+  if (projet.role !== 'autonome') {
+    const manifeste = ecrireLeManifeste(projet);
+    journal.info(
+      `  manifest.json : ${manifeste.nom} ${manifeste.version}, socle ${manifeste.socle.construit}`,
+    );
+  }
   const { resume, defauts } = juger(precompresser(projet.sortie));
   journal.info(`  precompression : ${resume}`);
   for (const defaut of defauts) journal.erreur(`  - ${defaut}`);

package/src/construction/sprite.mjs

@@ -20,9 +20,14 @@ import { empreinteCourte } from '../commun.mjs';
 
 const SPRITE_HACHE = /^sprite-[A-Z0-9]{8}\.svg$/;
 
-/** Les chemins du sprite selon le role. */
+/**
+ * Les chemins du sprite selon le role. Une application autonome (lot 240) peint le sprite du SOCLE,
+ * comme l'hote : elle n'a ni remote ni sprite metier.
+ */
+const duSocle = (projet) => projet.role === 'hote' || projet.role === 'autonome';
+
 function reglages(projet) {
-  if (projet.role === 'hote') {
+  if (duSocle(projet)) {
     return {
       source: join(
         projet.racine,
@@ -74,11 +79,11 @@ 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)" : ''}.`,
+      `sprite absent : ${source}${duSocle(projet) ? " (pnpm install d'abord)" : ''}.`,
     );
   }
   const contenu = readFileSync(source);
-  if (projet.role === 'hote') verifierLeSpriteDuSocle(source, contenu);
+  if (duSocle(projet)) verifierLeSpriteDuSocle(source, contenu);
   const fichier = `sprite-${empreinteCourte(contenu)}.svg`;
   mkdirSync(dossier, { recursive: true });
   for (const existant of readdirSync(dossier)) {

package/src/etapes/autonome.mjs

@@ -0,0 +1,131 @@
+/**
+ * Etape `autonome` (lot 240) : ce qu'une application AUTONOME doit tenir, et que les etapes d'un hote
+ * ou d'un remote ne voient pas. Une application autonome est servie seule, sans federation : l'ecran
+ * anonyme d'identity (`ui-auth`, ADR 0031 decision 4), que le BFF rend sur `/auth/**`.
+ *
+ * 1. AUCUNE FEDERATION LIVREE : ni `remoteEntry.json`, ni carte d'importation, ni `es-module-shims`,
+ *    ni le moteur de Native Federation.
+ * 2. LES MEMES VERSIONS QUE SON JUMEAU (`starterWeb.jumeau`, le dossier du remote du meme service) :
+ *    Angular et le socle frontal, pour que deux applications d'un service ne divergent pas en silence.
+ * 3. LE POIDS DE SON ECRAN (`starterWeb.ecran` : `{ "entree": "src/app/pages/connexion.ts",
+ *    "seuilKo": 155 }`) : le chargement initial et la route de l'ecran, tout ce qu'ils importent
+ *    statiquement, en brotli, lus dans la carte de la construction (`ng build --stats-json`, que
+ *    `starter-web construire` pose pour ce role). Un seuil se baisse ; il ne se leve jamais sans
+ *    mesure ecrite et datee (ADR 0031).
+ *
+ * Remplace `verification/application-autonome.mjs` que l'ecran anonyme d'identity tenait seul.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { cloture, departDeLaPage, totaux } from '../cloture.mjs';
+import { fichiers, ko, lireJson, relatif } from '../commun.mjs';
+
+/** Ce qui trahit un moteur de federation dans un fichier livre. */
+const MOTEUR_DE_FEDERATION =
+  /es-module-shims|importShim|__NATIVE_FEDERATION__|@angular-architects\/native-federation/;
+
+/** Les defauts de federation d'un dossier livre. */
+export function federationLivree(sortie) {
+  const defauts = [];
+  for (const chemin of fichiers(sortie)) {
+    const nom = relatif(sortie, chemin);
+    if (/^remoteEntry/.test(nom)) {
+      defauts.push(`${nom} livre : une application autonome n'est pas un remote.`);
+      continue;
+    }
+    if (/\.(?:m?js|html)$/.test(nom) && MOTEUR_DE_FEDERATION.test(readFileSync(chemin, 'utf8'))) {
+      defauts.push(`${nom} : moteur de federation livre (es-module-shims ou Native Federation).`);
+    }
+  }
+  const index = join(sortie, 'index.html');
+  if (existsSync(index) && /<script[^>]*type=["']?importmap/i.test(readFileSync(index, 'utf8'))) {
+    defauts.push("index.html : carte d'importation livree.");
+  }
+  return defauts;
+}
+
+/** Les versions d'Angular et du socle qui different de celles du jumeau. */
+export function versionsDuJumeau(paquet, jumeau) {
+  const siennes = { ...jumeau.dependencies, ...jumeau.devDependencies };
+  const defauts = [];
+  for (const [nom, version] of Object.entries({
+    ...paquet.dependencies,
+    ...paquet.devDependencies,
+  })) {
+    if (!nom.startsWith('@angular/') && !nom.startsWith('@starterlib/')) continue;
+    const duJumeau = siennes[nom];
+    if (duJumeau !== undefined && duJumeau !== version) {
+      defauts.push(
+        `${nom} ${String(version)} : le jumeau est en ${String(duJumeau)} (meme service, memes versions).`,
+      );
+    }
+  }
+  return defauts;
+}
+
+/** Le morceau de l'entree `entree` dans la carte de la construction, ou `null`. */
+export function morceauDeLEntree(carte, entree) {
+  for (const [sortie, description] of Object.entries(carte?.outputs ?? {})) {
+    if (description.entryPoint === entree && sortie.endsWith('.js')) {
+      return sortie.replace(/^.*browser\//, '');
+    }
+  }
+  return null;
+}
+
+/** Le poids de l'ecran : chargement initial, et initial plus la route de l'ecran. */
+export function poidsDeLEcran(sortie, morceau) {
+  const depart = departDeLaPage(readFileSync(join(sortie, 'index.html'), 'utf8'));
+  const initial = totaux(cloture(sortie, depart, {}, 0));
+  const ecran = totaux(cloture(sortie, morceau === null ? depart : [...depart, morceau], {}, 0));
+  return { initial, ecran };
+}
+
+export default {
+  nom: 'autonome',
+  roles: ['autonome'],
+  executer(projet) {
+    if (!existsSync(join(projet.sortie, 'index.html'))) {
+      return { defauts: [`${projet.sortieRelative}/index.html absent : construire d'abord.`] };
+    }
+    const reglages = projet.paquet.starterWeb ?? {};
+    const defauts = [...federationLivree(projet.sortie)];
+    const details = [];
+
+    if (typeof reglages.jumeau === 'string') {
+      const jumeau = lireJson(join(resolve(projet.racine, reglages.jumeau), 'package.json'));
+      if (jumeau === null)
+        defauts.push(`starterWeb.jumeau : ${reglages.jumeau}/package.json illisible.`);
+      else defauts.push(...versionsDuJumeau(projet.paquet, jumeau));
+    }
+
+    const ecran = reglages.ecran;
+    if (ecran !== undefined) {
+      const carte = lireJson(join(dirname(projet.sortie), 'browser-stats.json'));
+      const morceau = carte === null ? null : morceauDeLEntree(carte, ecran.entree);
+      if (morceau === null) {
+        defauts.push(
+          `starterWeb.ecran : la route ${String(ecran.entree)} est introuvable dans browser-stats.json ` +
+            '(starter-web construire la pose : ng build --stats-json).',
+        );
+      } else {
+        const { initial, ecran: poids } = poidsDeLEcran(projet.sortie, morceau);
+        details.push(
+          `chargement initial ${String(ko(initial.brotli))} Ko br (${String(initial.fichiers)} fichiers)`,
+          `ecran ${String(ecran.entree)} ${String(ko(poids.brotli))} Ko br (${String(poids.fichiers)} fichiers, seuil ${String(ecran.seuilKo)} Ko br)`,
+        );
+        if (typeof ecran.seuilKo === 'number' && ko(poids.brotli) > ecran.seuilKo) {
+          defauts.push(
+            `ecran : ${String(ko(poids.brotli))} Ko br > ${String(ecran.seuilKo)} Ko br (un seuil ne se ` +
+              'leve jamais sans mesure ecrite et datee, ADR 0031).',
+          );
+        }
+      }
+    }
+    return {
+      defauts,
+      details,
+      resume: 'aucune federation livree, versions du jumeau et poids de l ecran conformes.',
+    };
+  },
+};

package/src/etapes/dependances.mjs

@@ -97,7 +97,7 @@ export function jugerLesDependances(paquet, outils = []) {
 
 export default {
   nom: 'dependances',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer(projet) {
     const dossier = join(projet.racine, 'tools');
     const outils = existsSync(dossier) ? readdirSync(dossier) : [];

package/src/etapes/i18n.mjs

@@ -264,12 +264,21 @@ function lire(chemin) {
   }
 }
 
+/**
+ * Les perimetres de catalogues d'un projet : ceux du manifeste (remote), ceux de
+ * `starterWeb.i18n.perimetres` (application autonome, lot 240), `socle` pour l'hote.
+ */
+export function perimetresDuProjet(projet) {
+  if (projet.role === 'remote') return projet.source?.i18n?.perimetres ?? [];
+  if (projet.role === 'autonome') return projet.paquet.starterWeb?.i18n?.perimetres ?? ['socle'];
+  return ['socle'];
+}
+
 export default {
   nom: 'i18n',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer(projet) {
-    const perimetres =
-      projet.role === 'remote' ? (projet.source?.i18n?.perimetres ?? []) : ['socle'];
+    const perimetres = perimetresDuProjet(projet);
     if (perimetres.length === 0) {
       return { defauts: ['manifest.source.json : i18n.perimetres vide, aucun catalogue a lire.'] };
     }
@@ -305,8 +314,9 @@ export default {
     // L'aide contextuelle de chaque page du manifeste, et aucune aide sans page (lot 280).
     defauts.push(...jugerLesAides(catalogues, projet.source?.routes ?? []));
 
-    // L'hote porte les cles que le noyau traduit par son catalogue.
-    if (projet.role === 'hote') {
+    // L'hote, et l'application autonome qui pose le noyau comme lui, portent les cles que le noyau
+    // traduit par son catalogue.
+    if (projet.role === 'hote' || projet.role === 'autonome') {
       const dossier = dossierInstalle(projet.racine, '@starterlib/core');
       const exigees =
         dossier === null ? null : lireJson(join(dossier, 'schemas', 'cles-exigees-du-socle.json'));

package/src/etapes/jetons.mjs

@@ -67,7 +67,7 @@ export function jugerLesJetons(feuilles, definis) {
 
 export default {
   nom: 'jetons',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer(projet) {
     const socle = join(projet.racine, 'node_modules', '@starterlib', 'tokens', 'styles');
     const definis = new Set();

package/src/etapes/navigateurs.mjs

@@ -0,0 +1,21 @@
+/**
+ * Etape `navigateurs` (lot 276) : la liste browserslist de la SPA est celle du socle, lue dans la
+ * matrice publiee avec ce CLI (`src/navigateurs.mjs`). Ni plus bas, ni plus haut, ni absente.
+ */
+import { jugerLesNavigateurs, navigateursDeLaSpa, navigateursDuSocle } from '../navigateurs.mjs';
+
+export default {
+  nom: 'navigateurs',
+  roles: ['remote', 'hote', 'autonome'],
+  executer(projet) {
+    const attendus = navigateursDuSocle();
+    const lus = navigateursDeLaSpa(projet.racine);
+    const defauts = jugerLesNavigateurs(lus, attendus);
+    return defauts.length > 0
+      ? { defauts }
+      : {
+          defauts,
+          resume: `${lus?.origine ?? ''} conforme au plancher du socle (${String(attendus.length)} requetes).`,
+        };
+  },
+};

package/src/etapes/outillage.mjs

@@ -44,7 +44,7 @@ function deleguer(projet, arguments_, resume) {
 
 export const format = {
   nom: 'format',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer: (projet) =>
     deleguer(projet, ['exec', 'prettier', '--check', '.'], 'prettier --check . conforme.'),
 };
@@ -59,7 +59,7 @@ const CONFIGURATIONS_STYLELINT = [
 
 export const lint = {
   nom: 'lint',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   preparation: 'sprite',
   executer(projet) {
     const sources = fichiers(join(projet.racine, 'src'))
@@ -95,7 +95,7 @@ export const lint = {
 
 export const test = {
   nom: 'test',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   preparation: 'sprite',
   executer: (projet) => deleguer(projet, ['exec', 'ng', 'test', '--no-watch'], 'ng test conforme.'),
 };
@@ -136,7 +136,7 @@ export function motifsNonPortables(racine) {
  */
 export const contrat = {
   nom: 'contrat',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   executer(projet) {
     if (projet.paquet.scripts?.['contrat:check'] === undefined) {
       return { sautee: 'aucun script contrat:check : pas de client engendre (ADR web 0008).' };

package/src/etapes/securite.mjs

@@ -125,6 +125,15 @@ 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 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 +173,18 @@ 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).
  */
 export function jugerUnFichierLivre(
   nom,
   contenu,
-  { role = 'remote', partage = false, declarees = [] } = {},
+  { role = 'remote', partage = false, declarees = [], cadreNeutralise = false } = {},
 ) {
+  if (cadreNeutralise) {
+    contenu = contenu.replace(LECTURE_DE_COOKIE_DU_CADRE, 'getCookie($1){return 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 +231,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,17 +254,32 @@ 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;
     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;
       defauts.push(
         ...jugerUnFichierLivre(nom, contenu, {
           role: projet.role,
           partage: partages.has(nom),
           declarees,
+          cadreNeutralise: duCadre === 1,
         }),
       );
     }
+    if (lecturesDuCadre > 1) {
+      defauts.push(
+        `lecture de cookie du cadre : ${String(lecturesDuCadre)} occurrences (DomAdapter.getCookie) ; ` +
+          'une seule est admise dans une application autonome.',
+      );
+    }
     return {
       defauts,
       avertissements,

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

@@ -0,0 +1,24 @@
+/**
+ * Etape `vulnerabilites` (lot 139) : `pnpm audit --prod` bloquant sur HIGH et CRITICAL, sauf
+ * exception datee de `securite/exceptions-npm.json` ; SBOM CycloneDX des dependances de production
+ * dans `dist/sbom-front.cdx.json` (a cote du dossier livre, jamais servie) ; licences AGPL, SSPL et
+ * inconnues refusees. Le registre npm doit repondre : sans lui, on refuse plutot que supposer.
+ */
+import { auditerLesDependances } from '../vulnerabilites.mjs';
+
+export default {
+  nom: 'vulnerabilites',
+  roles: ['remote', 'hote', 'autonome'],
+  executer(projet) {
+    try {
+      const { defauts, exceptes, composants } = auditerLesDependances(projet.racine);
+      const sous = exceptes.length > 0 ? `, ${String(exceptes.length)} avis excepte(s)` : '';
+      return {
+        defauts,
+        resume: `${String(composants)} composant(s) de production audites et sous licence admise${sous} (dist/sbom-front.cdx.json).`,
+      };
+    } catch (erreur) {
+      return { defauts: [erreur instanceof Error ? erreur.message : String(erreur)] };
+    }
+  },
+};

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

@@ -12,9 +12,11 @@ import { poserLeSprite } from './construction/sprite.mjs';
 import { ecrireLesSimulations } from './construction/simulations.mjs';
 import { ecrireLesTypesDeCles } from './construction/types-i18n.mjs';
 import { lireJson, relatif } from './commun.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).
@@ -29,6 +31,7 @@ Commandes :
   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)
+  navigateurs     ecrit la liste browserslist du socle (.browserslistrc, plancher de la matrice)
   etapes          liste les etapes de verify
 
 Options de verify :
@@ -196,9 +199,13 @@ export async function lancer(argv, { racine = process.cwd(), journal } = {}) {
       }
       case 'precompresser':
         return precompresserEtDire(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,

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) {

package/src/verifier.mjs

@@ -2,14 +2,15 @@
  * `starter-web verify` : les etapes d'une SPA, dans l'ordre du plan SPA §3, arretees a la premiere
  * qui echoue — et qui la NOMME : un « Command failed » ne dit pas quoi corriger.
  *
- * versions -> dependances -> jetons -> format -> lint -> i18n -> test -> contrat -> simulations
- * (remote) -> build -> manifeste -> federation -> entree (hote) -> budget -> amorcage (hote) ->
- * securite.
+ * versions -> navigateurs -> dependances -> jetons -> format -> lint -> i18n -> test -> contrat -> simulations
+ * (remote) -> build -> manifeste -> federation -> entree (hote) -> budget -> autonome (autonome) ->
+ * amorcage (hote) -> securite.
  *
  * Le sprite est pose une fois, avant la premiere etape qui lit le code (lint, test, build).
  */
 import { construire } from './construction/construire.mjs';
 import { poserLeSprite } from './construction/sprite.mjs';
+import autonome from './etapes/autonome.mjs';
 import budget from './etapes/budget.mjs';
 import dependances from './etapes/dependances.mjs';
 import federation from './etapes/federation.mjs';
@@ -17,14 +18,16 @@ import { amorcage, entree } from './etapes/hote.mjs';
 import i18n from './etapes/i18n.mjs';
 import jetons from './etapes/jetons.mjs';
 import manifeste from './etapes/manifeste.mjs';
+import navigateurs from './etapes/navigateurs.mjs';
 import { contrat, format, lint, test } from './etapes/outillage.mjs';
 import securite from './etapes/securite.mjs';
 import simulations from './etapes/simulations.mjs';
 import versions from './etapes/versions.mjs';
+import vulnerabilites from './etapes/vulnerabilites.mjs';
 
 const build = {
   nom: 'build',
-  roles: ['remote', 'hote'],
+  roles: ['remote', 'hote', 'autonome'],
   preparation: 'sprite',
   executer(projet, contexte) {
     const code = construire(projet, { journal: contexte.journal, sprite: false });
@@ -37,6 +40,7 @@ const build = {
 /** Les etapes, dans leur ordre. */
 export const ETAPES = [
   versions,
+  navigateurs,
   dependances,
   jetons,
   format,
@@ -46,10 +50,12 @@ export const ETAPES = [
   contrat,
   simulations,
   build,
+  vulnerabilites,
   manifeste,
   federation,
   entree,
   budget,
+  autonome,
   amorcage,
   securite,
 ];

package/src/vulnerabilites.mjs

@@ -0,0 +1,139 @@
+/**
+ * Vulnerabilites et licences des dependances npm (lot 139), partagees par le socle frontal
+ * (`tools/verifier-dependances.mjs`) et chaque SPA (etape `vulnerabilites` de `starter-web verify`).
+ *
+ *  - `pnpm audit --prod` : tout avis HIGH ou CRITICAL bloque, sauf exception DATEE du registre
+ *    `securite/exceptions-npm.json` ; une exception sans date, perimee ou a plus d'un trimestre
+ *    bloque aussi (politique commune : api/starter docs/security/gestion-des-vulnerabilites.md) ;
+ *  - `pnpm sbom` : la SBOM CycloneDX des dependances de production, ecrite dans
+ *    `dist/sbom-front.cdx.json`, A COTE du dossier livre (jamais servie : elle dirait a un attaquant
+ *    chaque version installee) ;
+ *  - licences : AGPL, SSPL ou inconnue interdites dans les dependances de production.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** Une exception ne vaut qu'un trimestre : au-dela, elle se renouvelle, justification relue. */
+export const HORIZON_JOURS = 92;
+const GRAVES = new Set(['high', 'critical']);
+const IDENTIFIANT = /^(GHSA(-[23456789cfghjmpqrvwx]{4}){3}|CVE-\d{4}-\d{4,})$/;
+const LICENCE_INTERDITE = /\b(AGPL|SSPL)/i;
+
+const jour = (date) => date.toISOString().slice(0, 10);
+
+/** Lit le registre : les exceptions valables, et les defauts de celles qui ne le sont pas. */
+export function lireExceptions(registre, aujourdHui = new Date()) {
+  const defauts = [];
+  const valables = [];
+  const limite = new Date(aujourdHui.getTime() + HORIZON_JOURS * 86_400_000);
+  for (const [indice, exception] of (registre.exceptions ?? []).entries()) {
+    const nom = `exception ${String(indice + 1)} (${String(exception.avis)})`;
+    if (typeof exception.avis !== 'string' || !IDENTIFIANT.test(exception.avis)) {
+      defauts.push(`${nom} : avis absent ou illisible (GHSA-xxxx-xxxx-xxxx ou CVE-AAAA-NNNN)`);
+    } else if (
+      typeof exception.justification !== 'string' ||
+      exception.justification.trim().length < 20
+    ) {
+      defauts.push(`${nom} : justification absente ou trop courte`);
+    } else if (
+      typeof exception.echeance !== 'string' ||
+      !/^\d{4}-\d{2}-\d{2}$/.test(exception.echeance) ||
+      Number.isNaN(Date.parse(exception.echeance))
+    ) {
+      defauts.push(`${nom} : sans echeance datee (AAAA-MM-JJ)`);
+    } else if (exception.echeance < jour(aujourdHui)) {
+      defauts.push(`${nom} : perimee depuis le ${exception.echeance}`);
+    } else if (exception.echeance > jour(limite)) {
+      defauts.push(
+        `${nom} : echeance a plus de ${String(HORIZON_JOURS)} jours (${exception.echeance})`,
+      );
+    } else {
+      valables.push(exception);
+    }
+  }
+  return { valables, defauts };
+}
+
+/** Les avis graves de `pnpm audit --json` : bloquants, ou couverts par une exception valable. */
+export function trierLesAvis(audit, exceptions) {
+  const bloquants = [];
+  const exceptes = [];
+  for (const avis of Object.values(audit.advisories ?? {})) {
+    if (!GRAVES.has(String(avis.severity).toLowerCase())) continue;
+    const identifiants = [avis.github_advisory_id, ...(avis.cves ?? [])].filter(Boolean);
+    const exception = exceptions.find((candidate) => identifiants.includes(candidate.avis));
+    const ligne =
+      `${String(avis.severity).toUpperCase()} ${String(avis.module_name)} ` +
+      `${identifiants.join(' ')} (corrige : ${String(avis.patched_versions)})`;
+    if (exception === undefined) bloquants.push(ligne);
+    else exceptes.push(`${ligne}, excepte jusqu'au ${String(exception.echeance)}`);
+  }
+  return { bloquants, exceptes };
+}
+
+/** Les composants de la SBOM dont la licence est interdite ou inconnue. */
+export function licencesRefusees(sbom) {
+  const refus = [];
+  for (const composant of sbom.components ?? []) {
+    const licences = (composant.licenses ?? [])
+      .map((entree) => entree.expression ?? entree.license?.id ?? entree.license?.name)
+      .filter((licence) => typeof licence === 'string' && licence.trim() !== '');
+    const nom =
+      `${composant.group ? `${String(composant.group)}/` : ''}` +
+      `${String(composant.name)}@${String(composant.version)}`;
+    if (licences.length === 0) refus.push(`${nom} : licence inconnue`);
+    else if (licences.some((licence) => LICENCE_INTERDITE.test(licence))) {
+      refus.push(`${nom} : licence interdite (${licences.join(', ')})`);
+    }
+  }
+  return refus;
+}
+
+/** `pnpm` en sortie capturee ; sous Windows, un script `.cmd`, d'ou l'interpreteur. */
+function pnpm(arguments_, racine) {
+  const resultat = spawnSync('pnpm', arguments_, {
+    cwd: racine,
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: process.platform === 'win32',
+  });
+  return {
+    code: resultat.status ?? 2,
+    stdout: resultat.stdout ?? '',
+    stderr: resultat.stderr ?? '',
+  };
+}
+
+/**
+ * Audit, SBOM et licences d'un projet pnpm. Rend `{ defauts, exceptes, composants, sbom }` ;
+ * `sbom` est le chemin ecrit. Leve une erreur quand le registre ne repond pas (on refuse plutot
+ * que supposer).
+ */
+export function auditerLesDependances(racine, { lancer = pnpm, aujourdHui = new Date() } = {}) {
+  const chemin = join(racine, 'securite/exceptions-npm.json');
+  const registre = existsSync(chemin) ? JSON.parse(readFileSync(chemin, 'utf8')) : {};
+  const { valables, defauts } = lireExceptions(registre, aujourdHui);
+
+  // `pnpm audit` rend 1 quand il trouve des avis : seule une sortie illisible empeche de juger.
+  const audit = lancer(['audit', '--prod', '--json'], racine);
+  let rapport;
+  try {
+    rapport = JSON.parse(audit.stdout);
+  } catch {
+    throw new Error(`pnpm audit illisible (registre injoignable ?) : ${audit.stderr.trim()}`);
+  }
+  const { bloquants, exceptes } = trierLesAvis(rapport, valables);
+  defauts.push(...bloquants.map((ligne) => `avis non excepte : ${ligne}`));
+
+  const sbom = lancer(['sbom', '--sbom-format', 'cyclonedx', '--prod'], racine);
+  if (sbom.code !== 0) throw new Error(`pnpm sbom a echoue : ${sbom.stderr.trim()}`);
+  const document = JSON.parse(sbom.stdout);
+  mkdirSync(join(racine, 'dist'), { recursive: true });
+  const sortie = join(racine, 'dist/sbom-front.cdx.json');
+  writeFileSync(sortie, `${JSON.stringify(document, null, 2)}\n`);
+  defauts.push(...licencesRefusees(document));
+
+  return { defauts, exceptes, composants: document.components?.length ?? 0, sbom: sortie };
+}