@starterlib/cli 0.10.13 → 0.11.0

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/budget.mjs

@@ -25,19 +25,23 @@ import { natureDesFichiers } from '../livraison.mjs';
 export const BUDGETS_DU_REMOTE = { pageKo: 60, totalKo: 250, catalogueKo: 30 };
 
 /**
- * Les seuils de l'hote, en Ko brotli (ADR 0031) : 301 pour le premier ecran reel, 282 pour la
- * charge initiale, ramenes au socle 0.10.0 (releves et historique dans l'ADR). La charge initiale
- * est passee de 280 a 281 le 2026-09-29, decision du proprietaire : 280,4 Ko mesures avec le socle
- * 0.10.9, dont les controles d'empreinte S05 du lot 272 tournent au demarrage. Puis, le meme jour,
- * 282 et 301 (decision de l'orchestrateur sur autorisation du proprietaire) : la coquille mesuree
- * contre le socle 0.10.11 construit, avant publication, 281,0 et 300,1 Ko (+0,4 Ko chacun : titre
- * de page, banniere collee, marque textuelle, creneau de marque, demarrage determine, amorce).
+ * Les seuils de l'hote, en Ko brotli (ADR 0031) : 309 pour le premier ecran reel, 288 pour la
+ * charge initiale (ADR web 0005, D167). Leur histoire : ramenes au socle 0.10.0 (releves dans
+ * l'ADR 0031) ; la charge initiale passee de 280 a 281 le 2026-09-29, decision du proprietaire :
+ * 280,4 Ko mesures avec le socle 0.10.9, dont les controles d'empreinte S05 du lot 272 tournent au
+ * demarrage. Puis, le meme jour, 282 et 301 (decision de l'orchestrateur sur autorisation du
+ * proprietaire) : la coquille mesuree contre le socle 0.10.11 construit, avant publication, 281,0
+ * et 300,1 Ko (+0,4 Ko chacun : titre de page, banniere collee, marque textuelle, creneau de
+ * marque, demarrage determine, amorce). Puis 288 et 309 le 2026-10-07 : la coquille d'Aplomb
+ * mesuree contre la 0.11.0 construite, avant publication, 286,96 et 307,86 Ko (+5,1 et +6,2 Ko sur
+ * la 0.10.14 : barre inferieure, action critique et raccourci, ressource rafraichie, tronc), puis
+ * 287,4 et 308,3 Ko avec sa feuille de marque et la feuille de sa police de titre (+0,44 Ko).
  *
  * ⚠️ 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: 301, chargeInitialeKo: 282, cibleDuPlanKo: 170 };
+export const BUDGETS_DE_L_HOTE = { premierEcranKo: 309, chargeInitialeKo: 288, cibleDuPlanKo: 170 };
 
 /** Les imports DYNAMIQUES d'un module : les pages qu'il charge a la demande. */
 const IMPORT_DYNAMIQUE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;

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/formulations.mjs

@@ -0,0 +1,182 @@
+/**
+ * Les formulations qu'une application interdit dans ses textes affiches : une recherche textuelle
+ * simple dans ses catalogues, a chaque `verify` ; ni un controle du design, ni un jugement du sens
+ * (lot P09-27 d'Aplomb, generalise). L'etape `i18n` la lance.
+ *
+ * L'application declare sa liste : `package.json#starterWeb.formulationsInterdites`, chemin d'un
+ * fichier JSON relatif a sa racine. Le socle n'en connait aucune ; sans reglage, rien n'est cherche.
+ *
+ *   {
+ *     "formulations": [
+ *       { "id": "F01", "textes": ["garanti", "garantie"], "langues": ["fr"] },
+ *       { "id": "F07", "motif": "(?<![\\p{L}\\p{N}])[A-Z]-\\d{2}(?![\\p{L}\\p{N}])" }
+ *     ],
+ *     "exceptions": [
+ *       { "formulation": "F01", "cle": "app.legal.absence", "raison": "...", "date": "2026-10-07" }
+ *     ]
+ *   }
+ *
+ * - `textes` : chaque forme se nomme (aucune flexion devinee) ; la recherche ignore la casse et les
+ *   accents, confond les blancs (espaces insecables compris) et les tirets, et ne trouve un texte
+ *   qu'en mots entiers : « garanti » ne se trouve pas dans « garantit ».
+ * - `motif` : une expression reguliere (drapeau `u`), appliquee au texte tel quel, casse comprise.
+ * - `langues` : parmi `fr` et `en` ; les deux par defaut.
+ * - une exception se nomme, se justifie et se date, pour une cle et une formulation ; celle dont la
+ *   cle appartient a un perimetre du projet sans y exister est perimee : refusee.
+ */
+
+/** Les blancs et les tirets, confondus en une espace. */
+const BLANCS_ET_TIRETS = /[\s\p{Pd}]+/gu;
+const BORD_AVANT = '(?<![\\p{L}\\p{N}])';
+const BORD_APRES = '(?![\\p{L}\\p{N}])';
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/** Le texte tel que la recherche le compare : sans casse ni accents, blancs et tirets confondus. */
+export function normaliser(texte) {
+  return texte.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase().replace(BLANCS_ET_TIRETS, ' ');
+}
+
+function echapper(texte) {
+  return texte.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function texteNonVide(valeur) {
+  return typeof valeur === 'string' && valeur.trim() !== '';
+}
+
+/** Une formulation lue : `{ formulation }` prete a chercher, ou `{ defaut }`. */
+function lireUneFormulation(entree, rang, langues, ids) {
+  const ou = `formulation ${String(rang + 1)}`;
+  if (entree === null || typeof entree !== 'object')
+    return { defaut: `${ou} : un objet est attendu.` };
+  const { id, textes, motif } = entree;
+  if (!texteNonVide(id)) return { defaut: `${ou} : "id" manquant.` };
+  if (ids.has(id)) return { defaut: `${id} : identifiant en double.` };
+  ids.add(id);
+  const cherchees = entree.langues ?? langues;
+  if (
+    !Array.isArray(cherchees) ||
+    cherchees.length === 0 ||
+    cherchees.some((langue) => !langues.includes(langue))
+  ) {
+    return { defaut: `${id} : "langues" parmi ${langues.join(', ')}.` };
+  }
+  const motifs = [];
+  if (textes !== undefined) {
+    if (
+      !Array.isArray(textes) ||
+      textes.length === 0 ||
+      textes.some((texte) => typeof texte !== 'string' || normaliser(texte).trim() === '')
+    ) {
+      return { defaut: `${id} : "textes", une liste de textes non vides, est attendu.` };
+    }
+    for (const texte of textes) {
+      const cherche = BORD_AVANT + echapper(normaliser(texte).trim()) + BORD_APRES;
+      motifs.push({ expression: new RegExp(cherche, 'u'), surLeTexteNormalise: true });
+    }
+  }
+  if (motif !== undefined) {
+    if (!texteNonVide(motif))
+      return { defaut: `${id} : "motif", une expression non vide, est attendu.` };
+    try {
+      motifs.push({ expression: new RegExp(motif, 'u'), surLeTexteNormalise: false });
+    } catch (erreur) {
+      return {
+        defaut: `${id} : motif illisible (${erreur instanceof Error ? erreur.message : String(erreur)}).`,
+      };
+    }
+  }
+  if (motifs.length === 0) return { defaut: `${id} : "textes" ou "motif" attendu.` };
+  return { formulation: { id, langues: cherchees, motifs } };
+}
+
+/**
+ * La liste lue et jugee : les formulations pretes a chercher, les exceptions, et les defauts du
+ * fichier. Une liste fautive se refuse entiere : elle ne cherche rien de travers.
+ */
+export function lireLesFormulations(liste, langues) {
+  const defauts = [];
+  const formulations = [];
+  const exceptions = [];
+  if (liste === null || typeof liste !== 'object' || !Array.isArray(liste.formulations)) {
+    return {
+      formulations,
+      exceptions,
+      defauts: ['un objet { "formulations": [...] } est attendu.'],
+    };
+  }
+  const ids = new Set();
+  for (const [rang, entree] of liste.formulations.entries()) {
+    const lue = lireUneFormulation(entree, rang, langues, ids);
+    if (lue.defaut === undefined) formulations.push(lue.formulation);
+    else defauts.push(lue.defaut);
+  }
+  if (liste.exceptions !== undefined && !Array.isArray(liste.exceptions)) {
+    defauts.push('"exceptions" : une liste est attendue.');
+  }
+  for (const [rang, exception] of (Array.isArray(liste.exceptions)
+    ? liste.exceptions
+    : []
+  ).entries()) {
+    const ou = `exception ${String(rang + 1)}`;
+    if (exception === null || typeof exception !== 'object') {
+      defauts.push(`${ou} : un objet est attendu.`);
+      continue;
+    }
+    const { formulation, cle, raison, date } = exception;
+    if (!ids.has(formulation))
+      defauts.push(`${ou} : formulation "${String(formulation)}" inconnue.`);
+    else if (!texteNonVide(cle)) defauts.push(`${ou} : "cle" manquante.`);
+    else if (!texteNonVide(raison))
+      defauts.push(`${ou} (${cle}) : "raison" manquante : une exception se justifie.`);
+    else if (typeof date !== 'string' || !DATE.test(date)) {
+      defauts.push(`${ou} (${cle}) : "date" AAAA-MM-JJ manquante : une exception se date.`);
+    } else exceptions.push({ formulation, cle });
+  }
+  return { formulations, exceptions, defauts };
+}
+
+/**
+ * Les textes des catalogues ou une formulation interdite se trouve, hors exception ; puis les
+ * exceptions perimees. `catalogues` : `{ <perimetre>: { fr: {...}, en: {...} } }`.
+ */
+export function jugerLesFormulations({ formulations, exceptions }, catalogues) {
+  const defauts = [];
+  const admises = new Set(exceptions.map(({ formulation, cle }) => `${formulation} ${cle}`));
+  for (const [perimetre, parLangue] of Object.entries(catalogues)) {
+    for (const [langue, catalogue] of Object.entries(parLangue)) {
+      if (catalogue === null || typeof catalogue !== 'object') continue;
+      for (const [cle, message] of Object.entries(catalogue)) {
+        if (typeof message !== 'string') continue;
+        const normalise = normaliser(message);
+        for (const { id, langues, motifs } of formulations) {
+          if (!langues.includes(langue) || admises.has(`${id} ${cle}`)) continue;
+          for (const { expression, surLeTexteNormalise } of motifs) {
+            const trouve = (surLeTexteNormalise ? normalise : message).match(expression);
+            if (trouve !== null) {
+              defauts.push(
+                `${perimetre}.${langue}.json : cle "${cle}", formulation interdite ${id} ("${trouve[0]}").`,
+              );
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  for (const { formulation, cle } of exceptions) {
+    const perimetre = cle.split('.')[0];
+    const parLangue = catalogues[perimetre];
+    if (parLangue === undefined) continue;
+    const presente = Object.values(parLangue).some(
+      (catalogue) =>
+        catalogue !== null && typeof catalogue === 'object' && Object.hasOwn(catalogue, cle),
+    );
+    if (!presente) {
+      defauts.push(
+        `exception ${formulation} : cle "${cle}" absente du perimetre "${perimetre}" (exception perimee, a retirer).`,
+      );
+    }
+  }
+  return defauts;
+}

package/src/etapes/i18n.mjs

@@ -18,13 +18,16 @@
  * - l'hote porte les cles que `@starterlib/core` traduit par son catalogue
  *   (`schemas/cles-exigees-du-socle.json`, constat A0837) ;
  * - le type des cles engendre (`src/app/i18n/cles.ts`, `starter-web i18n:types`) est a jour : une cle
- *   inconnue dans `t()` est alors une erreur de compilation.
+ *   inconnue dans `t()` est alors une erreur de compilation ;
+ * - aucun texte ne porte une formulation que l'application interdit
+ *   (`starterWeb.formulationsInterdites`, voir `formulations.mjs`), hors exception nommee et datee.
  */
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { fichiers, lireJson, relatif } from '../commun.mjs';
 import { dossierInstalle } from '../socle-installe.mjs';
 import { cheminDesTypesDeCles, typesDeCles } from '../construction/types-i18n.mjs';
+import { jugerLesFormulations, lireLesFormulations } from './formulations.mjs';
 
 export const LANGUES = ['fr', 'en'];
 
@@ -264,12 +267,50 @@ function lire(chemin) {
   }
 }
 
+/**
+ * La recherche des formulations interdites, si l'application en declare : `cherchees` vaut `null`
+ * sans reglage, le nombre de formulations cherchees sinon.
+ */
+export function rechercherLesFormulations(projet, catalogues) {
+  const reglage = projet.paquet?.starterWeb?.formulationsInterdites;
+  if (reglage === undefined) return { defauts: [], cherchees: null };
+  if (typeof reglage !== 'string' || reglage.trim() === '') {
+    return {
+      defauts: [
+        "package.json : starterWeb.formulationsInterdites, le chemin d'un fichier JSON, est attendu.",
+      ],
+      cherchees: 0,
+    };
+  }
+  const liste = lire(resolve(projet.racine, reglage));
+  if (liste === null) {
+    return {
+      defauts: [`${reglage} : absent ou illisible (starterWeb.formulationsInterdites).`],
+      cherchees: 0,
+    };
+  }
+  const lue = lireLesFormulations(liste, LANGUES);
+  if (lue.defauts.length > 0) {
+    return { defauts: lue.defauts.map((defaut) => `${reglage} : ${defaut}`), cherchees: 0 };
+  }
+  return { defauts: jugerLesFormulations(lue, catalogues), cherchees: lue.formulations.length };
+}
+
+/**
+ * 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 +346,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'));
@@ -321,6 +363,10 @@ export default {
       }
     }
 
+    // Les formulations que l'application interdit dans ses textes (P09-27 d'Aplomb, generalise).
+    const recherche = rechercherLesFormulations(projet, catalogues);
+    defauts.push(...recherche.defauts);
+
     // Le type des cles engendre, a jour.
     const cheminDesTypes = cheminDesTypesDeCles(projet.racine);
     const attendu = typesDeCles(perimetres, catalogues);
@@ -332,7 +378,11 @@ export default {
 
     return {
       defauts,
-      resume: `${String(perimetres.length)} perimetre(s), ${String(cles)} cle(s) en fr et en en, messages lisibles, cles appelees presentes.`,
+      resume:
+        `${String(perimetres.length)} perimetre(s), ${String(cles)} cle(s) en fr et en en, messages lisibles, cles appelees presentes` +
+        (recherche.cherchees === null
+          ? '.'
+          : `, ${String(recherche.cherchees)} formulation(s) interdite(s) cherchee(s).`),
     };
   },
 };

package/src/etapes/jetons.mjs

@@ -11,15 +11,24 @@
  *
  * Sont lues les feuilles `.scss` et `.css` sous `src/`, et les styles EN LIGNE des composants
  * (`styles: \`...\``), que la copie de la coquille ne voyait pas.
+ *
+ * La MARQUE de la SPA (niveau 2 bis : `marque.json`, `marque.ts` ou `marque.mjs` a la racine) est
+ * rejouee ici a chaque verification, par le moteur des jetons installe : une valeur reprise qui fait
+ * tomber une paire sous son seuil rougit `verify`, paire nommee, avant la construction.
  */
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fichiers, relatif } from '../commun.mjs';
+import { fichierDeMarque, jugerLaMarque } from '../marque.mjs';
 
 /** Poses a l'execution par un composant du socle, donc absents des feuilles engendrees. */
 const POSES_A_L_EXECUTION = new Set([
   // st-app-shell mesure l'en-tete collant et publie sa hauteur (scroll-padding de la page).
   '--st-hauteur-entete',
+  // st-bottom-nav (P08-05) et l'action permanente flottante de st-app-shell (P08-06) publient la
+  // hauteur qu'elles couvrent au bas de la fenetre.
+  '--st-hauteur-pied',
+  '--st-hauteur-action',
 ]);
 
 /** Une lecture de jeton : son nom, et le caractere qui suit (`,` : avec repli ; `)` : sans). */
@@ -67,8 +76,8 @@ export function jugerLesJetons(feuilles, definis) {
 
 export default {
   nom: 'jetons',
-  roles: ['remote', 'hote'],
-  executer(projet) {
+  roles: ['remote', 'hote', 'autonome'],
+  async executer(projet) {
     const socle = join(projet.racine, 'node_modules', '@starterlib', 'tokens', 'styles');
     const definis = new Set();
     for (const feuille of fichiers(socle).filter((chemin) => chemin.endsWith('.css'))) {
@@ -99,9 +108,19 @@ export default {
       };
     }
     const { defauts, lues } = jugerLesJetons(feuilles, definis);
+    let marque = '';
+    const chemin = fichierDeMarque(projet.racine);
+    if (chemin !== null) {
+      const nom = relatif(projet.racine, chemin);
+      const juge = await jugerLaMarque(projet.racine, chemin);
+      for (const defaut of juge.defauts) defauts.push(`${nom} : ${defaut}`);
+      if (juge.defauts.length === 0) marque = ` ; marque ${String(juge.valeurs.nom)} conforme`;
+    }
     return {
       defauts,
-      resume: `${String(lues)} lecture(s) sans repli dans ${String(feuilles.length)} feuille(s), toutes definies.`,
+      resume:
+        `${String(lues)} lecture(s) sans repli dans ${String(feuilles.length)} feuille(s), toutes ` +
+        `definies${marque}.`,
     };
   },
 };

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

@@ -34,6 +34,49 @@ export function jugerLesSelecteurs(prefixe, sources) {
   return defauts;
 }
 
+/**
+ * Les regles de style du socle (P08-11 : seul le socle fait le design) : stylelint pour les feuilles,
+ * le greffon pour les gabarits. Les lever exige une exemption NOMMEE et DATEE.
+ */
+const REGLES_DE_STYLE =
+  /\b(?:color-no-hex|color-named|declaration-property-value-(?:dis)?allowed-list|property-disallowed-list|socle\/no-style-literal|socle\/variantes-reservees)\b/;
+
+/** Un commentaire qui leve des regles : `stylelint-disable-next-line <regles> -- <raison>`. */
+const EXEMPTION = /(stylelint|eslint)-disable(?:-next-line|-line)?\b(.*?)(?:\*\/|-->|$)/gm;
+
+/** Une raison qui commence par sa date : `-- 2026-10-07 : <raison>`. */
+const DATEE = /--\s*\d{4}-\d{2}-\d{2}\s*:?\s*\S/;
+
+/**
+ * Les exemptions des regles de style (P08-11) dans les sources d'une SPA (`{ nom, texte }` : feuilles,
+ * gabarits, code) : chacune nommee ET datee (`-- AAAA-MM-JJ : <raison>`), pour se journaliser dans le
+ * CHANGELOG de l'application. Une levee de TOUTES les regles (sans liste) dans une feuille ou un
+ * gabarit compte comme une exemption de style. Rend `{ defauts, datees }`.
+ */
+export function jugerLesExemptions(sources) {
+  const defauts = [];
+  let datees = 0;
+  for (const { nom, texte } of sources) {
+    const codeSeul = nom.endsWith('.ts');
+    for (const exemption of texte.matchAll(EXEMPTION)) {
+      const suite = exemption[2] ?? '';
+      const regles = suite.split('--')[0] ?? '';
+      const toutes = regles.trim() === '';
+      if (toutes ? codeSeul : !REGLES_DE_STYLE.test(regles)) continue;
+      if (DATEE.test(suite)) {
+        datees += 1;
+        continue;
+      }
+      const ligne = texte.slice(0, exemption.index).split('\n').length;
+      defauts.push(
+        `${nom}:${String(ligne)} : exemption de style sans date ni raison ; ecrire ` +
+          '`-- AAAA-MM-JJ : <raison>` et la journaliser dans le CHANGELOG de l application.',
+      );
+    }
+  }
+  return { defauts, datees };
+}
+
 /** Le resultat d'une commande deleguee : `resume` si elle reussit, son code sinon. */
 function deleguer(projet, arguments_, resume) {
   const code = executer('pnpm', arguments_, projet.racine);
@@ -44,7 +87,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 +102,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'))
@@ -70,6 +113,21 @@ export const lint = {
       }));
     const selecteurs = jugerLesSelecteurs(projet.prefixe, sources);
     if (selecteurs.length > 0) return { defauts: selecteurs };
+    // P08-11 : une exemption de style est nommee et datee, jamais muette.
+    const exemptions = jugerLesExemptions(
+      fichiers(join(projet.racine, 'src'))
+        .filter((chemin) => /\.(scss|css|html|ts)$/.test(chemin))
+        .filter((chemin) => !chemin.includes(DOSSIER_DU_CLIENT_ENGENDRE))
+        .map((chemin) => ({
+          nom: relatif(projet.racine, chemin),
+          texte: readFileSync(chemin, 'utf8'),
+        })),
+    );
+    if (exemptions.defauts.length > 0) return { defauts: exemptions.defauts };
+    const ecartes =
+      exemptions.datees === 0
+        ? ''
+        : ` ; ${String(exemptions.datees)} exemption(s) de style datee(s), a journaliser dans le CHANGELOG`;
     // Les feuilles sous stylelint (lot 178) : jetons, pixels, plans, ordre du DOM. La configuration
     // etend celle du socle (@starterlib/eslint-config/stylelint) ; sans elle, rien n'est garde.
     if (!CONFIGURATIONS_STYLELINT.some((nom) => existsSync(join(projet.racine, nom)))) {
@@ -88,14 +146,14 @@ export const lint = {
     return deleguer(
       projet,
       ['exec', 'stylelint', 'src/**/*.{scss,css}', '--allow-empty-input'],
-      `selecteurs en ${String(projet.prefixe)}-, eslint . et stylelint conformes.`,
+      `selecteurs en ${String(projet.prefixe)}-, eslint . et stylelint conformes${ecartes}.`,
     );
   },
 };
 
 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 +194,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).' };