@starterlib/cli 0.10.4 → 0.10.5

package/README.md

@@ -31,38 +31,41 @@ Scripts d'une SPA :
 
 ## Commandes
 
-| Commande                    | Ce qu'elle fait                                                                                  |
-| --------------------------- | ------------------------------------------------------------------------------------------------ |
-| `starter-web verify`        | Les etapes ci-dessous, dans l'ordre, arretees a la premiere qui echoue, dont le nom est ecrit    |
-| `starter-web construire`    | Sprite, `ng build`, prechargement de la police (hote), manifeste, precompression                 |
-| `starter-web sprite`        | Pose le sprite hache (`public/`) et sa constante engendree (`sprite-genere.ts`)                  |
-| `starter-web manifeste`     | Engendre `manifest.json` dans le dossier livre ; idempotent                                      |
-| `starter-web precompresser` | Ecrit les variantes `.br` et `.gz` ; `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 etapes`        | Liste les etapes et les roles qu'elles concernent                                                |
+| Commande                    | Ce qu'elle fait                                                                                                                               |
+| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| `starter-web start`         | L'hote de developpement : sprite, simulations (remote), puis `ng serve` sous `STARTER_WEB_HOTE_DEV=1` (`--port N`)                            |
+| `starter-web verify`        | Les etapes ci-dessous, dans l'ordre, arretees a la premiere qui echoue, dont le nom est ecrit                                                 |
+| `starter-web construire`    | Sprite, `ng build`, prechargement de la police (hote), manifeste, precompression                                                              |
+| `starter-web sprite`        | Pose le sprite hache (`public/`) et sa constante engendree (`sprite-genere.ts`)                                                               |
+| `starter-web manifeste`     | Engendre `manifest.json` dans le dossier livre ; idempotent                                                                                   |
+| `starter-web precompresser` | Ecrit les variantes `.br` et `.gz` ; `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 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
 (argument inconnu, projet illisible).
 
 ## 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, 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      |
-| `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`    | 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                                                             |
 
 `--etapes a,b` n'en joue que certaines ; `--sauter a,b` en retire.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starterlib/cli",
-  "version": "0.10.4",
+  "version": "0.10.5",
   "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/demarrer.mjs

@@ -0,0 +1,52 @@
+/**
+ * `starter-web start` (lot 269) : l'hote de developpement d'une SPA, sans BFF ni coquille. Le sprite,
+ * puis (remote adosse a un service) les stubs WireMock recopies, puis `ng serve`, avec
+ * `STARTER_WEB_HOTE_DEV=1`.
+ *
+ * Pourquoi la variable : la federation ne partage que ce que les modules EXPOSES atteignent
+ * (`ignoreUnusedDeps`), et l'hote de developpement importe des points d'entree du socle que les
+ * routes d'un remote n'importent pas (la navigation, l'anglais du tronc). Sous cette variable,
+ * `exposesDeLHoteDeDeveloppement()` (`@starterlib/core/federation`) expose aussi l'amorce de l'hote :
+ * ce qu'elle importe est partage, donc resolu par la carte d'importation. Hors de `starter-web
+ * start`, rien n'est expose de plus : le livrable ne porte jamais l'hote.
+ */
+import { spawnSync } from 'node:child_process';
+import { relatif } from '../commun.mjs';
+import { ecrireLesSimulations } from './simulations.mjs';
+import { poserLeSprite } from './sprite.mjs';
+
+/** Le nom de la variable ; le meme que celui de `@starterlib/core/federation` (essai du CLI). */
+export const VARIABLE_DE_L_HOTE_DE_DEVELOPPEMENT = 'STARTER_WEB_HOTE_DEV';
+
+/** Lance l'hote de developpement ; rend le code de sortie de `ng serve`. */
+export async function demarrer(projet, { port, journal = console } = {}) {
+  journal.info(`  sprite : ${poserLeSprite(projet)}`);
+  if (projet.role === 'remote') {
+    const simulations = await ecrireLesSimulations(projet);
+    if (simulations !== null) {
+      for (const avertissement of simulations.avertissements) journal.info(`  ! ${avertissement}`);
+      if (simulations.defauts.length > 0) {
+        for (const defaut of simulations.defauts) journal.erreur(`  - ${defaut}`);
+        return 1;
+      }
+      journal.info(
+        `  simulations : ${String(simulations.stubs.length)} stub(s) de ${relatif(projet.racine, simulations.racine)}`,
+      );
+    }
+  }
+  const resultat = spawnSync(
+    'pnpm',
+    ['exec', 'ng', 'serve', ...(port === undefined ? [] : ['--port', port])],
+    {
+      cwd: projet.racine,
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+      env: { ...process.env, [VARIABLE_DE_L_HOTE_DE_DEVELOPPEMENT]: '1' },
+    },
+  );
+  if (resultat.error !== undefined) {
+    journal.erreur(`  ng serve : ${resultat.error.message}`);
+    return 1;
+  }
+  return resultat.status ?? 1;
+}

package/src/construction/simulations.mjs

@@ -0,0 +1,270 @@
+/**
+ * `starter-web simulations` (lot 269) : les stubs WireMock du service (`../src/mock` par defaut,
+ * `starterWeb.simulations` sinon), recopies avec leurs corps dans
+ * `src/hote-dev/simulations.engendre.json`, que l'hote de developpement du remote rejoue dans le
+ * navigateur (`@starterlib/testing/hote-dev`).
+ *
+ * UNE simulation : celle que le BFF sert en profil `mock`, et que `make mock-check` confronte au
+ * contrat OpenAPI du service. Les hotes de developpement en ecrivaient une seconde a la main, qui
+ * derivait (47 produits pagines d'un cote, une page fixe de l'autre) sans que rien le dise.
+ *
+ * Le fichier est versionne (un stub ajoute se lit a la revue) et formate par le Prettier de la SPA :
+ * il passe `prettier --check` sans etre ecarte. L'etape `simulations` de `verify` le veut a jour.
+ *
+ * Un stub hors du sous-ensemble que l'hote rejoue (scenario, condition inconnue, chemin JSON hors
+ * grammaire, faute ou mandataire) est ECARTE du fichier, et nomme en avertissement : le BFF le sert
+ * toujours, l'hote de developpement non. Un fichier illisible ou un corps introuvable est un DEFAUT :
+ * WireMock lui-meme ne le servirait pas.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { fichiers } from '../commun.mjs';
+
+/** Ou vit le fichier engendre, depuis la racine de la SPA. */
+export const CHEMIN_DES_SIMULATIONS = join('src', 'hote-dev', 'simulations.engendre.json');
+
+/** La racine WireMock par defaut : celle du service, voisine de son interface. */
+const RACINE_PAR_DEFAUT = join('..', 'src', 'mock');
+
+const CLES_DU_STUB = new Set([
+  'name',
+  'id',
+  'uuid',
+  'priority',
+  'request',
+  'response',
+  'metadata',
+  'persistent',
+]);
+const CLES_DE_REQUETE = new Set([
+  'method',
+  'url',
+  'urlPattern',
+  'urlPath',
+  'urlPathPattern',
+  'queryParameters',
+  'headers',
+  'bodyPatterns',
+]);
+const CLES_DE_CONDITION = new Set(['equalTo', 'contains', 'matches', 'absent', 'caseInsensitive']);
+const CLES_DE_CORPS = new Set(['equalTo', 'contains', 'matches', 'equalToJson', 'matchesJsonPath']);
+const CLES_DE_REPONSE = new Set([
+  'status',
+  'headers',
+  'jsonBody',
+  'body',
+  'bodyFileName',
+  'fixedDelayMilliseconds',
+  'transformers',
+]);
+
+const NOM = /^[A-Za-z_$][\w$-]*/;
+const FILTRE =
+  /^\[\?\(@((?:\.[A-Za-z_$][\w$-]*)+)\s*(?:(==|!=|<=|>=|<|>)\s*('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?|true|false|null)\s*)?\)\]/;
+
+/**
+ * `null` si l'hote de developpement comprend le chemin JSON, sinon la raison. Meme grammaire que
+ * `lireUnCheminJson` (`@starterlib/testing/hote-dev`), eprouvee sur le meme corpus.
+ */
+export function cheminJsonIncompris(expression) {
+  if (typeof expression !== 'string' || !expression.startsWith('$')) {
+    return `chemin JSON "${String(expression)}" : il commence par $.`;
+  }
+  let reste = expression.slice(1);
+  while (reste !== '') {
+    if (reste.startsWith('..'))
+      return `chemin JSON "${expression}" : la descente .. n'est pas comprise.`;
+    if (reste.startsWith('.*')) {
+      reste = reste.slice(2);
+      continue;
+    }
+    if (reste.startsWith('.')) {
+      const nom = NOM.exec(reste.slice(1));
+      if (nom === null || reste.slice(1 + nom[0].length).startsWith('(')) {
+        return `chemin JSON "${expression}" : pas illisible apres ".".`;
+      }
+      reste = reste.slice(1 + nom[0].length);
+      continue;
+    }
+    const pas =
+      /^\[(?:'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*")\]/.exec(reste) ??
+      /^\[\d+\]/.exec(reste) ??
+      /^\[\*\]/.exec(reste) ??
+      FILTRE.exec(reste);
+    if (pas === null) return `chemin JSON "${expression}" : "${reste}" n'est pas compris.`;
+    reste = reste.slice(pas[0].length);
+  }
+  return null;
+}
+
+/** La racine WireMock de la SPA (`mappings/` dedans), ou `null` si elle n'en a pas. */
+export function racineDesStubs(projet) {
+  const reglage = projet.paquet?.starterWeb?.simulations;
+  const racine = resolve(projet.racine, reglage ?? RACINE_PAR_DEFAUT);
+  if (existsSync(join(racine, 'mappings'))) return racine;
+  if (reglage !== undefined) {
+    throw new Error(`starterWeb.simulations : "${reglage}" ne contient pas de dossier mappings/.`);
+  }
+  return null;
+}
+
+/** Les raisons pour lesquelles l'hote ne rejouerait pas ce stub (vide : il le rejoue). */
+function horsDuSousEnsemble(stub) {
+  const raisons = [];
+  const inconnues = (objet, admises, ou) => {
+    for (const cle of Object.keys(objet ?? {})) {
+      if (!admises.has(cle)) raisons.push(`${ou}${cle}`);
+    }
+  };
+  inconnues(stub, CLES_DU_STUB, '');
+  inconnues(stub.request, CLES_DE_REQUETE, 'request.');
+  inconnues(stub.response, CLES_DE_REPONSE, 'response.');
+  for (const famille of ['queryParameters', 'headers']) {
+    for (const [nom, condition] of Object.entries(stub.request?.[famille] ?? {})) {
+      inconnues(condition, CLES_DE_CONDITION, `request.${famille}.${nom}.`);
+    }
+  }
+  for (const [indice, motif] of (stub.request?.bodyPatterns ?? []).entries()) {
+    inconnues(motif, CLES_DE_CORPS, `request.bodyPatterns[${String(indice)}].`);
+    if (motif.matchesJsonPath !== undefined) {
+      const raison = cheminJsonIncompris(motif.matchesJsonPath);
+      if (raison !== null) raisons.push(raison);
+    }
+  }
+  for (const motif of [stub.request?.urlPattern, stub.request?.urlPathPattern]) {
+    if (motif === undefined) continue;
+    try {
+      new RegExp(`^(?:${motif})$`);
+    } catch {
+      raisons.push(`motif "${motif}" hors ECMA-262`);
+    }
+  }
+  return raisons;
+}
+
+/** Les stubs d'un fichier de `mappings/` (un stub, ou `{ mappings: [...] }`). */
+function stubsDuFichier(chemin) {
+  const contenu = JSON.parse(readFileSync(chemin, 'utf8'));
+  if (Array.isArray(contenu?.mappings)) return contenu.mappings;
+  if (contenu?.request !== undefined) return [contenu];
+  throw new Error('ni stub (request), ni liste (mappings)');
+}
+
+/**
+ * Lit les stubs de `racine` : `{ stubs, avertissements, defauts }`, les stubs dans l'ordre des
+ * fichiers (celui dans lequel WireMock les charge : a priorite egale, le dernier l'emporte), leurs
+ * corps de `__files/` en ligne.
+ */
+export function lireLesStubs(racine) {
+  const stubs = [];
+  const avertissements = [];
+  const defauts = [];
+  const mappings = join(racine, 'mappings');
+  const chemins = fichiers(mappings)
+    .filter((chemin) => chemin.endsWith('.json'))
+    .map((chemin) => relative(mappings, chemin).split(sep).join('/'))
+    .sort();
+  for (const nomDeFichier of chemins) {
+    let lus;
+    try {
+      lus = stubsDuFichier(join(mappings, nomDeFichier));
+    } catch (erreur) {
+      defauts.push(
+        `mappings/${nomDeFichier} illisible : ${erreur instanceof Error ? erreur.message : String(erreur)}.`,
+      );
+      continue;
+    }
+    for (const stub of lus) {
+      const nom = stub.name ?? nomDeFichier;
+      const raisons = horsDuSousEnsemble(stub);
+      if (raisons.length > 0) {
+        avertissements.push(
+          `stub "${nom}" (mappings/${nomDeFichier}) ecarte de l'hote : ${raisons.join(', ')}.`,
+        );
+        continue;
+      }
+      const { bodyFileName, transformers, ...reponse } = stub.response ?? {};
+      if ((transformers ?? []).length > 0) {
+        avertissements.push(
+          `stub "${nom}" : gabarit de reponse (${transformers.join(', ')}) servi tel quel par l'hote.`,
+        );
+      }
+      if (bodyFileName !== undefined) {
+        const cheminDuCorps = join(racine, '__files', bodyFileName);
+        if (!existsSync(cheminDuCorps)) {
+          defauts.push(
+            `stub "${nom}" (mappings/${nomDeFichier}) : __files/${bodyFileName} introuvable.`,
+          );
+          continue;
+        }
+        const texte = readFileSync(cheminDuCorps, 'utf8');
+        try {
+          if (!bodyFileName.endsWith('.json')) throw new Error('texte');
+          reponse.jsonBody = JSON.parse(texte);
+        } catch {
+          reponse.body = texte;
+        }
+      }
+      stubs.push({
+        name: nom,
+        ...(stub.priority === undefined ? {} : { priority: stub.priority }),
+        request: stub.request,
+        response: reponse,
+      });
+    }
+  }
+  return { stubs, avertissements, defauts };
+}
+
+/** Le Prettier de la SPA (celui de son `format`), ou `null`. */
+async function prettierDe(racine) {
+  for (const depuis of [join(racine, 'package.json'), import.meta.url]) {
+    try {
+      const chemin = createRequire(depuis).resolve('prettier');
+      const module = await import(pathToFileURL(chemin).href);
+      // Resolu par `require`, Prettier est son entree CommonJS : ses fonctions sont sous `default`.
+      return typeof module.resolveConfig === 'function' ? module : module.default;
+    } catch {
+      // Le suivant : la SPA d'abord, puis le CLI (essais du socle).
+    }
+  }
+  return null;
+}
+
+/**
+ * Le texte du fichier engendre pour `projet` : `{ texte, stubs, avertissements, defauts, racine }`,
+ * ou `null` si la SPA n'a pas de simulateur WireMock.
+ */
+export async function engendrerLesSimulations(projet) {
+  const racine = racineDesStubs(projet);
+  if (racine === null) return null;
+  const { stubs, avertissements, defauts } = lireLesStubs(racine);
+  const contenu = {
+    $comment:
+      'Engendre par starter-web simulations (@starterlib/cli) depuis les stubs WireMock du service : ne pas modifier a la main.',
+    source: relative(projet.racine, racine).split(sep).join('/'),
+    stubs,
+  };
+  let texte = `${JSON.stringify(contenu, null, 2)}\n`;
+  const cible = join(projet.racine, CHEMIN_DES_SIMULATIONS);
+  const prettier = await prettierDe(projet.racine);
+  if (prettier === null) {
+    avertissements.push('prettier introuvable depuis la SPA : fichier engendre non formate.');
+  } else {
+    const options = (await prettier.resolveConfig(cible)) ?? {};
+    texte = await prettier.format(texte, { ...options, filepath: cible });
+  }
+  return { texte, stubs, avertissements, defauts, racine };
+}
+
+/** Ecrit le fichier ; rend le resultat d'`engendrerLesSimulations` (ou `null`). */
+export async function ecrireLesSimulations(projet) {
+  const resultat = await engendrerLesSimulations(projet);
+  if (resultat === null || resultat.defauts.length > 0) return resultat;
+  const cible = join(projet.racine, CHEMIN_DES_SIMULATIONS);
+  mkdirSync(dirname(cible), { recursive: true });
+  writeFileSync(cible, resultat.texte);
+  return resultat;
+}

package/src/etapes/i18n.mjs

@@ -12,6 +12,9 @@
  * - un message porte les MEMES arguments en fr et en en : un `{nom}` traduit `{name}` reste un trou ;
  * - chaque cle que le code appelle (`t('catalog.x')`) et chaque titre de route du manifeste existent
  *   au catalogue : une cle absente s'affiche telle quelle, a l'ecran ;
+ * - chaque route du manifeste porte son aide contextuelle (lot 280) : son titre suit la convention
+ *   `<perimetre>.pages.<page>`, et la cle soeur `<perimetre>.aide.<page>` existe (le texte de
+ *   l'aide que `st-page-header` pose a cote du titre) ; une aide sans page est une faute de frappe ;
  * - 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
@@ -202,6 +205,56 @@ export function clesAppelees(racine) {
   return appelees;
 }
 
+/** Un titre de page selon la convention : `catalog.pages.produits` -> perimetre et page. */
+const TITRE_DE_PAGE = /^([a-z][\w-]*)\.pages\.([\w-]+(?:\.[\w-]+)*)$/;
+
+/**
+ * La cle d'aide contextuelle d'un titre de page (lot 280) : `catalog.pages.produits` ->
+ * `catalog.aide.produits` ; `null` pour un titre hors convention.
+ */
+export function cleDAide(titre) {
+  const morceaux = TITRE_DE_PAGE.exec(titre);
+  return morceaux === null ? null : `${morceaux[1]}.aide.${morceaux[2]}`;
+}
+
+/**
+ * Les defauts de l'aide contextuelle (lot 280), `catalogues` etant `{ perimetre: { fr, en } }` et
+ * `routes` celles du manifeste : chaque route titree `<perimetre>.pages.<page>` a sa cle
+ * `<perimetre>.aide.<page>` ; chaque cle `<perimetre>.aide.<page>` a sa page. L'anglais suit par
+ * l'egalite des jeux de cles, deja jugee.
+ */
+export function jugerLesAides(catalogues, routes) {
+  const defauts = [];
+  for (const route of routes) {
+    if (typeof route.titre !== 'string') continue;
+    const catalogue = catalogues[route.titre.split('.')[0]]?.fr;
+    if (catalogue === undefined || catalogue === null) continue;
+    const cle = cleDAide(route.titre);
+    if (cle === null) {
+      defauts.push(
+        `manifest.source.json : titre "${route.titre}" hors de la convention <perimetre>.pages.<page> : l'aide de la page ne se deduit pas.`,
+      );
+    } else if (!Object.hasOwn(catalogue, cle)) {
+      defauts.push(
+        `manifest.source.json : route "${String(route.prefixe)}", aide "${cle}" absente du catalogue (aide contextuelle de st-page-header).`,
+      );
+    }
+  }
+  for (const [perimetre, parLangue] of Object.entries(catalogues)) {
+    const catalogue = parLangue?.fr;
+    if (catalogue === undefined || catalogue === null) continue;
+    const prefixe = `${perimetre}.aide.`;
+    for (const cle of Object.keys(catalogue)) {
+      if (!cle.startsWith(prefixe)) continue;
+      const page = `${perimetre}.pages.${cle.slice(prefixe.length)}`;
+      if (!Object.hasOwn(catalogue, page)) {
+        defauts.push(`${perimetre}.fr.json : aide "${cle}" sans page "${page}".`);
+      }
+    }
+  }
+  return defauts;
+}
+
 function lire(chemin) {
   if (!existsSync(chemin)) return null;
   try {
@@ -249,6 +302,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') {
       const dossier = dossierInstalle(projet.racine, '@starterlib/core');

package/src/etapes/simulations.mjs

@@ -0,0 +1,41 @@
+/**
+ * Etape `simulations` (lot 269) : les stubs WireMock du service, tels que l'hote de developpement
+ * du remote les rejoue (`src/hote-dev/simulations.engendre.json`), sont A JOUR. Sautee pour un
+ * remote sans simulateur (le temoin : aucun service derriere lui).
+ *
+ * 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.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { relatif } from '../commun.mjs';
+import { CHEMIN_DES_SIMULATIONS, engendrerLesSimulations } from '../construction/simulations.mjs';
+
+export default {
+  nom: 'simulations',
+  roles: ['remote'],
+  async executer(projet) {
+    const resultat = await engendrerLesSimulations(projet);
+    if (resultat === null) {
+      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;
+    if (defauts.length > 0) return { defauts, avertissements };
+    const cible = join(projet.racine, CHEMIN_DES_SIMULATIONS);
+    const chemin = relatif(projet.racine, cible);
+    if (!existsSync(cible)) {
+      return { defauts: [`${chemin} absent : starter-web simulations.`], avertissements };
+    }
+    if (readFileSync(cible, 'utf8') !== texte) {
+      return { defauts: [`${chemin} perime : starter-web simulations.`], avertissements };
+    }
+    return {
+      defauts: [],
+      avertissements,
+      resume: `${String(stubs.length)} stub(s) de ${relatif(projet.racine, racine)} rejoues par l'hote de developpement, a jour.`,
+    };
+  },
+};

package/src/lancer.mjs

@@ -5,9 +5,11 @@
  * pas s'executer (argument inconnu, projet illisible).
  */
 import { construire } from './construction/construire.mjs';
+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 { ecrireLesSimulations } from './construction/simulations.mjs';
 import { ecrireLesTypesDeCles } from './construction/types-i18n.mjs';
 import { lireJson, relatif } from './commun.mjs';
 import { versionDuSocle } from './matrice.mjs';
@@ -19,11 +21,14 @@ const AIDE = `starter-web : la chaine d'une SPA du socle frontal (@starterlib/cl
 
 Commandes :
   verify          les etapes, dans l'ordre, arretees a la premiere qui echoue
+  start           l'hote de developpement : sprite, simulations, ng serve (--port N)
   construire      sprite, ng build, manifeste, precompression (--configuration development)
   sprite          pose le sprite hache et sa constante
   manifeste       engendre manifest.json dans le dossier livre
   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)
   etapes          liste les etapes de verify
 
 Options de verify :
@@ -73,6 +78,10 @@ export function lireLesArguments(argv) {
         options.prefixe = valeur(indice, argument);
         indice += 1;
         break;
+      case '--port':
+        options.port = valeur(indice, argument);
+        indice += 1;
+        break;
       case '--configuration':
         options.configuration = valeur(indice, argument);
         indice += 1;
@@ -171,6 +180,8 @@ export async function lancer(argv, { racine = process.cwd(), journal } = {}) {
         );
         return await verifier(projet, { ...options, journal: sortie });
       }
+      case 'start':
+        return await demarrer(projet, { port: options.port, journal: sortie });
       case 'construire':
         return construire(projet, { configuration: options.configuration, journal: sortie });
       case 'sprite':
@@ -198,6 +209,22 @@ export async function lancer(argv, { racine = process.cwd(), journal } = {}) {
         sortie.info(`i18n:types : ${relatif(projet.racine, chemin)} (${perimetres.join(', ')})`);
         return 0;
       }
+      case 'simulations': {
+        const resultat = await ecrireLesSimulations(projet);
+        if (resultat === null) {
+          sortie.info(
+            'simulations : aucun simulateur WireMock (../src/mock, ou starterWeb.simulations).',
+          );
+          return 0;
+        }
+        for (const avertissement of resultat.avertissements) sortie.info(`  ! ${avertissement}`);
+        for (const defaut of resultat.defauts) sortie.erreur(`  - ${defaut}`);
+        if (resultat.defauts.length > 0) return 1;
+        sortie.info(
+          `simulations : ${String(resultat.stubs.length)} stub(s) de ${relatif(projet.racine, resultat.racine)}`,
+        );
+        return 0;
+      }
       default:
         sortie.erreur(`starter-web : commande inconnue : ${commande}\n\n${AIDE}`);
         return 2;

package/src/verifier.mjs

@@ -2,8 +2,9 @@
  * `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 -> build ->
- * manifeste -> federation -> entree (hote) -> budget -> amorcage (hote) -> securite.
+ * versions -> dependances -> jetons -> format -> lint -> i18n -> test -> contrat -> simulations
+ * (remote) -> build -> manifeste -> federation -> entree (hote) -> budget -> amorcage (hote) ->
+ * securite.
  *
  * Le sprite est pose une fois, avant la premiere etape qui lit le code (lint, test, build).
  */
@@ -18,6 +19,7 @@ import jetons from './etapes/jetons.mjs';
 import manifeste from './etapes/manifeste.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';
 
 const build = {
@@ -42,6 +44,7 @@ export const ETAPES = [
   i18n,
   test,
   contrat,
+  simulations,
   build,
   manifeste,
   federation,