@nodefony/devkit 10.0.0-beta.5 → 10.0.0-beta.6

package/skills/nodefony-browser/scripts/lib/actions.mjs

@@ -0,0 +1,113 @@
+import { USER, signInElsewhere } from "./browser.mjs";
+
+/**
+ * Joue une séquence d'interactions (`NF_BROWSER_ACTIONS`, analysée par
+ * `parseActions`) sur une page — la seule implémentation, partagée par
+ * `inspect.mjs` (agir PUIS photographier) et `watch.mjs` (agir PENDANT qu'on
+ * observe le trafic).
+ *
+ * Une action qui ne trouve pas sa cible ARRÊTE la séquence : une mesure faite
+ * sur un écran qu'on n'a pas ouvert est pire qu'aucune mesure.
+ *
+ * @param {import("playwright").Page} page - la page pilotée.
+ * @param {{ verb: string, target: string, value?: string }[]} actions - la séquence.
+ * @returns {Promise<{ code: number, message: string } | null>} `null` si tout a
+ *   été joué ; sinon le code de sortie à rendre (64 usage, 65 cible
+ *   introuvable) et le message qui nomme l'action.
+ */
+export async function playActions(page, actions) {
+  for (const { verb, target, value } of actions) {
+    if (verb === "connecter") {
+      if (!USER) {
+        return {
+          code: 64, // EX_USAGE
+          message:
+            "connecter: exige NF_BROWSER_USER, NF_BROWSER_PASSWORD et NF_BROWSER_LOGIN",
+        };
+      }
+      await signInElsewhere(page.context());
+      continue;
+    }
+    if (verb === "defiler") {
+      const pixels = Number.parseInt(target, 10);
+      if (!Number.isFinite(pixels)) {
+        return {
+          code: 64, // EX_USAGE
+          message: `defiler attend un nombre de pixels, reçu « ${target} »`,
+        };
+      }
+      // Le conteneur qui défile RÉELLEMENT, pas la fenêtre : sur une console à
+      // barre latérale fixe, `window.scrollBy` ne bouge rien du tout.
+      await page.evaluate((dy) => {
+        const scrollable = [...document.querySelectorAll("*")].find(
+          (el) =>
+            el.scrollHeight > el.clientHeight + 40 && el.clientHeight > 200,
+        );
+        (scrollable ?? window).scrollBy(0, dy);
+      }, pixels);
+      continue;
+    }
+    // Le premier candidat VISIBLE, pas le premier du DOM : un libellé apparaît
+    // souvent d'abord dans un menu replié ou un gabarit caché, et agir là ne fait
+    // rien tout en passant pour un succès.
+    const candidates = page.getByText(target, { exact: false });
+    let locator = null;
+    const total = await candidates.count();
+    for (let i = 0; i < total; i += 1) {
+      const c = candidates.nth(i);
+      if (await c.isVisible().catch(() => false)) {
+        locator = c;
+        break;
+      }
+    }
+    // Aucun candidat visible À CET INSTANT ne dit pas que la cible est un
+    // sélecteur : juste après un clic qui navigue, la page suivante n'est pas
+    // encore rendue. On attend donc le texte OU le sélecteur — et le texte seul
+    // quand la cible n'est pas du CSS valide. Trancher sur l'instant faisait
+    // chercher une balise `<FreeOTP>` une fois sur trois.
+    if (locator === null) {
+      // Une navigation en vol détruirait le contexte de l'évaluation ci-dessous.
+      await page.waitForLoadState("domcontentloaded").catch(() => {});
+      const isCss = await page
+        .evaluate((s) => {
+          try {
+            document.querySelector(s);
+            return true;
+          } catch {
+            return false;
+          }
+        }, target)
+        .catch(() => false);
+      locator = isCss
+        ? candidates.or(page.locator(target)).first()
+        : candidates.first();
+    }
+    try {
+      await locator.waitFor({ timeout: 15000 });
+      if (verb === "clic") await locator.click();
+      else if (verb === "double") await locator.dblclick();
+      else if (verb === "droit") await locator.click({ button: "right" });
+      else if (verb === "survol") await locator.hover();
+      else if (verb === "saisir") await locator.fill(value);
+      // `choisir` : la cible peut être le `<label>` qui ENVELOPPE la liste —
+      // Playwright reporte alors le choix sur son contrôle. La valeur est celle
+      // de l'option (`value`), sinon son libellé.
+      else if (verb === "choisir") {
+        const chosen = await locator.selectOption(value);
+        if (chosen.length === 0) throw new Error(`option « ${value} » absente`);
+      } else if (verb === "touche") await locator.press(value || "Enter");
+      else if (verb === "voir") await locator.scrollIntoViewIfNeeded();
+      // `attendre` : le `waitFor` ci-dessus EST l'action.
+    } catch {
+      return {
+        code: 65, // EX_DATAERR
+        message:
+          `Action « ${verb}:${target} » impossible\n` +
+          `Page réellement ouverte : ${page.url()}\n` +
+          "→ le libellé a changé, l'élément n'est pas encore rendu, ou il faut " +
+          "agir sur autre chose avant lui (NF_BROWSER_ACTIONS accepte une séquence, séparée par « | »).",
+      };
+    }
+  }
+  return null;
+}

package/skills/nodefony-browser/scripts/lib/browser.mjs

@@ -13,7 +13,7 @@
  * `@env` NF_BROWSER_USER identifiant ; sans lui, aucune authentification n'est tentée
  * `@env` NF_BROWSER_PASSWORD mot de passe associé
  * `@env` NF_BROWSER_WHOAMI chemin qui répond 2xx à une session authentifiée, et 401/403 ou un 2xx portant `{ user: null }` sinon — prouve une session reprise (défaut `/nodefony/security/api/auth/me` ; vide = aucune reprise)
- * `@env` NF_BROWSER_ENGINE navigateur imposé (chromium, chrome, msedge) ; sans lui, le premier qui répond
+ * `@env` NF_BROWSER_ENGINE navigateur imposé (chromium, chrome, msedge, firefox, webkit) ; sans lui, le premier qui répond
  * `@env` NF_BROWSER_COLOR_SCHEME schéma de couleurs émulé (light, dark, no-preference) ; sans lui, celui du navigateur
  * `@env` NF_BROWSER_STORAGE entrées de stockage local posées AVANT chargement (`clé=valeur`, séparées par des virgules)
  */
@@ -22,6 +22,7 @@ import path from "node:path";
 import {
   environmentDefaults,
   authStateName,
+  browserEngine,
   browserOrder,
   sessionVerdict,
   parseColorScheme,
@@ -38,9 +39,10 @@ import {
  * en pair optionnel — et un `MODULE_NOT_FOUND` nu, qui ne dit ni quoi
  * installer ni pourquoi, n'est pas une réponse acceptable.
  */
-let chromium;
+let launchers;
 try {
-  ({ chromium } = await import("playwright"));
+  const { chromium, firefox, webkit } = await import("playwright");
+  launchers = { chromium, firefox, webkit };
 } catch {
   console.error(
     "Playwright est absent — c'est lui qui pilote le navigateur.\n\n" +
@@ -205,10 +207,12 @@ if (storageRejected.length > 0) {
 /**
  * Ouvre un navigateur et un contexte prêts à mesurer.
  *
+ * @param options.anonymous - ne reprendre AUCUN état d'authentification : la
+ *   séquence se connecte elle-même en route (`connecter:`).
  * @returns `{ browser, ctx, page, reuse }` — `reuse` dit si un état
  *   d'authentification a été repris, ce qui décide s'il faut se connecter.
  */
-export async function open() {
+export async function open({ anonymous = false } = {}) {
   // On CONSTATE quel navigateur répond, au lieu de supposer lequel est là.
   //
   // `channel` demande un navigateur COMPLET plutôt que le
@@ -222,10 +226,14 @@ export async function open() {
   const failures = [];
   for (const channel of BROWSERS) {
     try {
-      browser = await chromium.launch({
-        channel: channel,
-        args: ["--no-sandbox"],
-      });
+      // `--no-sandbox` est un drapeau de Chromium : Firefox et WebKit n'en
+      // ont pas l'usage, et le pilote ne leur passe aucun canal.
+      const { engine, channel: variant } = browserEngine(channel);
+      browser = await launchers[engine].launch(
+        engine === "chromium"
+          ? { channel: variant, args: ["--no-sandbox"] }
+          : {},
+      );
       browserUsed = channel;
       break;
     } catch (e) {
@@ -238,7 +246,8 @@ export async function open() {
         `${failures.join("\n")}\n\n` +
         "Installer celui du pilote (une fois par machine, partagé par tous tes projets) :\n\n" +
         "  npx playwright install chromium\n\n" +
-        "Ou viser un navigateur déjà présent : NF_BROWSER_ENGINE=chrome (ou msedge).",
+        "Ou viser un navigateur déjà présent : NF_BROWSER_ENGINE=chrome (ou msedge).\n" +
+        "Autre moteur : NF_BROWSER_ENGINE=firefox (ou webkit), après npx playwright install firefox.",
     );
     process.exit(69); // EX_UNAVAILABLE
   }
@@ -253,7 +262,7 @@ export async function open() {
       : {}),
     ...(COLOR_SCHEME ? { colorScheme: COLOR_SCHEME } : {}),
   };
-  let reuse = Boolean(USER) && existsSync(STATE);
+  let reuse = !anonymous && Boolean(USER) && existsSync(STATE);
   let ctx = null;
   if (reuse) {
     try {
@@ -411,6 +420,24 @@ export async function signIn(page, ctx) {
   await ctx.storageState({ path: STATE });
 }
 
+/**
+ * Se connecte dans un AUTRE onglet du même contexte, puis le referme — la page
+ * mesurée n'est ni rechargée ni quittée. C'est le geste d'un utilisateur qui
+ * ouvre sa session ailleurs (console, autre onglet) pendant qu'une page déjà
+ * ouverte doit le constater d'elle-même : les cookies sont partagés, rien
+ * d'autre.
+ *
+ * @param ctx - le contexte de la page mesurée.
+ */
+export async function signInElsewhere(ctx) {
+  const tab = await ctx.newPage();
+  try {
+    await signIn(tab, ctx);
+  } finally {
+    await tab.close();
+  }
+}
+
 /**
  * Ouvre la page demandée, en garantissant que c'est bien ELLE qu'on mesure.
  *
@@ -424,8 +451,20 @@ export async function signIn(page, ctx) {
  * @param ctx - son contexte.
  * @param pathname - le chemin à ouvrir, relatif à l'origine.
  * @param reuse - un état d'authentification a-t-il été repris au lancement.
+ * @param options.anonymous - ouvrir la page SANS se connecter d'abord : la
+ *   séquence s'en charge en route (`connecter:`).
  */
-export async function goTo(page, ctx, pathname, reuse) {
+export async function goTo(
+  page,
+  ctx,
+  pathname,
+  reuse,
+  { anonymous = false } = {},
+) {
+  if (anonymous) {
+    await page.goto(`${BASE}${pathname}`, { waitUntil: "domcontentloaded" });
+    return;
+  }
   if (USER && !reuse) await signIn(page, ctx);
   await page.goto(`${BASE}${pathname}`, { waitUntil: "domcontentloaded" });
   if (USER && reuse) {

package/skills/nodefony-browser/scripts/lib/probes.mjs

@@ -159,8 +159,24 @@ export const ACTION_VERBS = [
   "voir",
   "defiler",
   "attendre",
+  "connecter",
 ];
 
+/**
+ * La séquence se connecte-t-elle EN COURS de route (`connecter:`) ?
+ *
+ * Alors la page doit s'ouvrir ANONYME — ni état d'authentification repris, ni
+ * connexion préalable : c'est précisément le passage « sans session » →
+ * « avec session », sans recharger, qu'on veut observer. Se connecter avant
+ * aurait rendu l'action sans objet, et la mesure verte pour la mauvaise raison.
+ *
+ * @param actions - la séquence analysée par `parseActions`.
+ * @returns `true` si une action `connecter` y figure.
+ */
+export function signsInMidway(actions) {
+  return actions.some((a) => a.verb === "connecter");
+}
+
 /**
  * Analyse une séquence d'actions (`NF_BROWSER_ACTIONS`).
  *
@@ -240,6 +256,25 @@ export function parseColorScheme(raw) {
   return { schema: null, invalid: v };
 }
 
+/**
+ * Rend une expression JS fournie par l'utilisateur ÉVALUABLE dans la page —
+ * une forme fonction (`() => x`, `function`, `async`) y est APPELÉE.
+ *
+ * Le piège est réel : `page.evaluate` et `waitForFunction` évaluent une chaîne
+ * comme une EXPRESSION. Donner « () => x » y définit une fonction sans jamais
+ * l'appeler : l'objet fonction est truthy (une attente réussit TOUJOURS) et ne
+ * se sérialise pas (une lecture rend `undefined`). Faux vert vécu, découvert
+ * seulement en éprouvant le sens négatif.
+ *
+ * @param {string|undefined} raw - expression brute (`NF_BROWSER_UNTIL`, `NF_BROWSER_EVAL`).
+ * @returns {string} l'expression à évaluer, vide si rien n'est demandé.
+ */
+export function pageExpression(raw) {
+  const v = (raw ?? "").trim();
+  if (!v) return "";
+  return /^(\(|function\b|async\b)/.test(v) ? `(${v})()` : v;
+}
+
 /**
  * Analyse une coupure réseau demandée (`NF_BROWSER_CUT`), au format
  * `<début>:<durée>` en millisecondes — `4000:3000` coupe le réseau 4 s après
@@ -709,3 +744,24 @@ export function browserOrder(explicit) {
   if (v) return [v];
   return ["chromium", "chrome", "msedge"];
 }
+
+/**
+ * Traduit un nom de navigateur en MOTEUR du pilote et, pour Chromium, en canal.
+ *
+ * Un comportement que dicte une norme — la politique de sécurité du contenu, le
+ * rapport de violation, un cookie `SameSite` — diverge d'un moteur à l'autre :
+ * le constater sous Chromium seul ne dit rien de Firefox ni de Safari. `firefox`
+ * et `webkit` désignent donc les moteurs que le pilote installe lui-même
+ * (`npx playwright install firefox`) ; tout autre nom reste un canal de
+ * Chromium (`chrome`, `msedge`, `chrome-beta`…), comme avant.
+ *
+ * @param {string} name - un nom rendu par `browserOrder`.
+ * @returns {{ engine: "chromium"|"firefox"|"webkit", channel: string|undefined }}
+ *   le moteur à lancer, et le canal Chromium (absent pour les deux autres).
+ */
+export function browserEngine(name) {
+  const v = name.trim().toLowerCase();
+  if (v === "firefox" || v === "webkit")
+    return { engine: v, channel: undefined };
+  return { engine: "chromium", channel: name.trim() };
+}

package/skills/nodefony-browser/scripts/watch.mjs

@@ -15,16 +15,25 @@
  * `@env` NF_BROWSER_UNTIL expression JS évaluée DANS la page ; l'observation s'arrête dès qu'elle est vraie (point d'arrêt applicatif)
  * `@env` NF_BROWSER_CUT coupure réseau `<début>:<durée>` en ms (`4000:3000`), comptée depuis l'ouverture de la page — éprouve la REPRISE d'un flux ; chaque socket dit alors quand il s'est fermé et rouvert
  * `@env` NF_BROWSER_MAXFRAMES nombre de frames WebSocket conservées par sens (défaut 12)
+ * `@env` NF_BROWSER_ACTIONS séquence d'interactions jouée UNE FOIS la page ouverte, PENDANT l'observation — même grammaire que `inspect.mjs` (`clic`, `saisir:Nom=x`, `attendre`…). C'est ce qui fait voir la trame qu'un GESTE envoie : un bouton qui écrit par la socket, un formulaire soumis
  * `@requires` conteneur du profil `browser` démarré · serveur Nodefony joignable
  * `@output` JSON : sockets et leurs frames (horodatées), requêtes non-2xx, erreurs console, verdict de la condition
  */
 import { open, goTo } from "./lib/browser.mjs";
-import { parseCut, sendableCloseCode } from "./lib/probes.mjs";
+import {
+  parseActions,
+  parseCut,
+  pageExpression,
+  sendableCloseCode,
+  signsInMidway,
+} from "./lib/probes.mjs";
+import { playActions } from "./lib/actions.mjs";
 
 const PAGE = process.argv[2] ?? process.env.NF_BROWSER_PAGE ?? "/";
 const DURATION = Number(process.argv[3] ?? 8000);
 const UNTIL = process.env.NF_BROWSER_UNTIL ?? "";
 const MAX = Number(process.env.NF_BROWSER_MAXFRAMES ?? 12);
+const ACTIONS = parseActions(process.env.NF_BROWSER_ACTIONS);
 const { cut: CUT, invalid: invalidCut } = parseCut(process.env.NF_BROWSER_CUT);
 if (invalidCut) {
   console.error(
@@ -35,7 +44,8 @@ if (invalidCut) {
 // Sockets que la coupure FERME (cf « La coupure réseau » plus bas).
 const isRouted = (url) => !new URL(url).pathname.startsWith("/_vite/");
 
-const { browser, ctx, page, reuse } = await open();
+const ANONYMOUS = signsInMidway(ACTIONS);
+const { browser, ctx, page, reuse } = await open({ anonymous: ANONYMOUS });
 
 const t0 = Date.now();
 const at = () => Date.now() - t0;
@@ -144,7 +154,7 @@ if (CUT) {
   });
 }
 
-await goTo(page, ctx, PAGE, reuse);
+await goTo(page, ctx, PAGE, reuse, { anonymous: ANONYMOUS });
 
 if (CUT) {
   cutTimers.push(
@@ -168,6 +178,17 @@ if (CUT) {
   );
 }
 
+// ── Les gestes : joués PENDANT l'observation ───────────────────────────────
+// Les écouteurs sont déjà posés : la trame qu'un clic envoie est enregistrée
+// comme les autres. Une cible introuvable arrête la sonde (code 65), comme
+// `inspect.mjs` — observer un geste qui n'a pas eu lieu ne prouve rien.
+const failed = await playActions(page, ACTIONS);
+if (failed !== null) {
+  console.error(failed.message);
+  await browser.close();
+  process.exit(failed.code);
+}
+
 // ── Le « point d'arrêt » : une CONDITION, pas une ligne de code ──────────────
 // `waitForFunction` réévalue l'expression dans la page à chaque animation frame.
 // C'est ce qui remplace utilement un breakpoint dans un pilotage automatisé :
@@ -176,14 +197,9 @@ if (CUT) {
 // observe simplement pendant la durée demandée.
 let verdict = "durée écoulée";
 if (UNTIL) {
-  // ⚠️ Une chaîne passée à `waitForFunction` est évaluée comme une EXPRESSION.
-  // Donner « () => x » y définit une fonction sans jamais l'appeler : l'objet
-  // fonction est truthy, donc l'attente réussit TOUJOURS — y compris sur une
-  // condition impossible. Faux vert vécu, découvert seulement en éprouvant le
-  // sens négatif. On invoque donc explicitement les formes fonction.
-  const expr = /^\s*(\(|function\b|async\b)/.test(UNTIL)
-    ? `(${UNTIL})()`
-    : UNTIL;
+  // Une forme fonction est APPELÉE (cf `pageExpression`) : passée telle quelle,
+  // l'attente réussirait TOUJOURS, condition impossible comprise.
+  const expr = pageExpression(UNTIL);
   try {
     await page.waitForFunction(expr, null, { timeout: DURATION });
     verdict = `condition VRAIE après ${at()} ms`;

package/skills/nodefony-dev/SKILL.md

@@ -456,6 +456,13 @@ Ne concerne qu'une application qui a un frontend. Sauf mention, **vaut pour les
   sur les scripts, et le navigateur refuse un `<script>` en ligne qui n'en porte pas (« Refused to
   execute inline script »). Un `curl` ne le voit JAMAIS, il ne lit que le corps. Signe le script
   (valeur `this.context?.cspNonce`) ou sors-le dans un fichier servi ; ne desserre PAS la politique.
+- **Une image, une police ou une API tierce est bloquée** (« violates the following Content
+  Security Policy directive ») : AJOUTE l'origine exacte par `headers.cspSources` de
+  `@nodefony/security` (`{ cdn: { "img-src": ["https://cdn.example.com"] } }`), ou sur la seule
+  route qui en a besoin par `@Csp` — ne réécris pas `headers.csp`. Une socket servie depuis une
+  AUTRE origine se déclare par `realtime.publicOrigin`. Ce que les navigateurs ont bloqué se lit,
+  en administrateur, sur `GET /nodefony/security/api/csp-reports` (`headers.cspReport`) — Brave
+  n'envoie aucun rapport, éprouve sous Chrome ou Firefox.
 - **En production, la modification front n'apparaît jamais** : hors développement il n'y a PAS de
   rechargement à chaud, et le manifeste est lu AU BOOT. `npm run build`, puis **redémarre le
   serveur**, puis rechargement forcé.
@@ -474,6 +481,10 @@ npm run verify        # types, style, mise en forme, .env.example, tests, build,
 npm run test:e2e      # boot réel + HTTP/WS — le gate LENT, hors `verify`
 ```
 
+Ton diff change ce que le build produit (taille, dépendance, build plus lent) ? Chaque build
+écrit un rapport : lis [`references/rapport-de-build.md`](references/rapport-de-build.md) avant de
+recalculer quoi que ce soit à la main.
+
 Ton diff ajoute une route, une requête ou touche la sécurité ? Relis-le AVANT de commiter :
 skill `nodefony-security-review` — un script y nomme, ligne par ligne, ce qu'un œil laisse passer.
 

package/skills/nodefony-dev/references/rapport-de-build.md

@@ -0,0 +1,19 @@
+# Le rapport de build — ce que pèse ce que tu bâtis
+
+> Chargé depuis `nodefony-dev` §10, quand un changement touche ce que le build produit.
+
+Chaque build (`npm run build` : serveur ET front) écrit, sans rien demander, un rapport sous
+`node_modules/.rolldown/report/<dossier de sortie>/` — le chemin relatif au projet, chaque `..`
+devenu `__` (le front bâti dans `public/dist` → `node_modules/.rolldown/report/public/dist/`).
+
+- **Quand le lire** : une taille qui change, une dépendance qui entre, un paquet présent en deux
+  versions, un build qui ralentit. Pas pour savoir si le build passe : son code de sortie le dit.
+- **Comment** : `entry.md` d'abord (une vingtaine de lignes, il nomme le fichier à ouvrir
+  ensuite). Pour juger TON changement, épingle la base AVANT de modifier
+  (`cp .state.json baseline.json` dans ce dossier), rebâtis, lis `delta.md`. Un chiffre :
+  `jq '.metrics["output.total_bytes"]' metrics.json` — ne lis pas les `.json` en entier.
+- **Ce qu'il ne dit pas** : ses octets sont comptés AVANT minification et compression, jamais
+  un poids réseau ; il ne vérifie aucun type (`npm run typecheck`) ; le mode watch et le serveur
+  de développement n'en écrivent pas ; une installation propre l'efface, base comprise.
+- **Le couper** (côté serveur) : `defineNodefonyRolldownConfig({ buildReport: false })` dans
+  `rolldown.config.ts`.

package/skills/nodefony-devops/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: nodefony-devops
 metadata:
-  version: 1.1.0
+  version: 1.2.0
 description: >
   Exploite CETTE application Nodefony en conteneur : image, compose, frontal (nginx, HAProxy, h2c,
   Ingress), secrets, variables, Kubernetes, Podman, nombre de pods. N'enseigne pas Docker — il
@@ -80,6 +80,12 @@ Ce que l'application ne peut pas deviner. Chacun de ces oublis produit une dégr
   clair »), le cookie de session perd son préfixe `__Host-`, et l'adresse cliente devient celle du
   frontal — donc une vague de reconnexions WebSocket épuise **un seul** quota. Sans le moindre
   message. Détail et preuve → [`references/frontal.md`](references/frontal.md).
+- **Une seule CSP, et c'est l'application qui la pose.** Elle porte un nonce neuf par page, que le
+  frontal ne peut pas connaître. N'ajoute pas de `Content-Security-Policy` dans nginx, haproxy ou
+  une annotation d'ingress : le navigateur appliquerait les deux, et les scripts signés seraient
+  bloqués — page blanche. La poser au frontal quand même : `headers: { csp: "" }` dans la config
+  de `@nodefony/security`, puis une politique SANS nonce au frontal →
+  `node_modules/@nodefony/security/docs/headers.md` § « Poser la CSP au proxy ».
 - **Une inactivité de frontal ≥ 300 s.** Plus courte que le battement, elle coupe des WebSocket et
   des flux SSE **vivants**. `proxy:generate` la dérive ; un contrôleur d'entrée Kubernetes, non.
 - **Un bus temps réel partagé dès deux exemplaires** : `NF_REALTIME_DRIVER=redis`. Sans lui, un
@@ -116,26 +122,27 @@ Chaque ligne a la commande qui la **prouve**. Une case cochée sans commande est
 
 Le tableau qu'on lit en urgence.
 
-| Symptôme                                                        | Cause                                                                                                                                             | Correction                                                                                                                                                                |
-| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| L'exemplaire redémarre en boucle, journaux muets                | La sonde de vivacité tombe avant la fin du démarrage                                                                                              | Sonde de démarrage sur `/readyz`, dimensionnée sur le **pire** cas                                                                                                        |
-| Le conteneur sort en **137** à l'arrêt                          | Il a été tué : la fenêtre d'arrêt est ≤ au drain                                                                                                  | Fenêtre ≥ 30 s (Podman : `--stop-timeout 20`, son défaut est **10 s**)                                                                                                    |
-| Des `5xx` **pendant** chaque déploiement                        | Le répartiteur envoie encore du trafic quand le drain a commencé                                                                                  | Un délai avant drain, et un court arrêt avant terminaison                                                                                                                 |
-| Le cookie de session n'a pas le préfixe `__Host-` en production | Schéma constaté `http` derrière le frontal                                                                                                        | `NF__HTTP__TRUSTPROXY`                                                                                                                                                    |
-| La WebSocket se ferme seule au bout d'une minute                | L'inactivité du frontal est plus courte que le battement                                                                                          | Régénérer le frontal ; sur un contrôleur d'entrée, `proxy-read-timeout` ≥ 300 s → [`references/frontal.md`](references/frontal.md)                                        |
-| Un message temps réel n'arrive qu'à une partie des clients      | Plusieurs exemplaires, bus local : chaque pod ne diffuse qu'à ses propres clients                                                                 | `NF_REALTIME_DRIVER=redis` + `NF_REDIS_URL` → [`references/dimensionnement.md`](references/dimensionnement.md)                                                            |
-| Depuis l'activation de h2c, le pod n'est jamais prêt            | La sonde vise le port h2c (5153), qui refuse HTTP/1.1                                                                                             | Sonder le port HTTP (5151)                                                                                                                                                |
-| Depuis l'activation de h2c, les WebSocket ne s'ouvrent plus     | Le frontal les envoie au port h2c                                                                                                                 | Router `Upgrade: websocket` vers le port HTTP → [`references/frontal.md`](references/frontal.md) §8                                                                       |
-| `DB_SQLITE_FALLBACK` en production alors que la base est posée  | Le nom de la variable est faux d'un caractère, ou le Secret n'est pas monté dans CE conteneur                                                     | `npx nodefony doctor --env production` nomme la variable lue (`NF_DATABASE_URL` ou `NF_DATABASE_URL_FILE`)                                                                |
-| Le pod est tué (`OOMKilled`) avec peu de connexions             | La contre-pression : des clients lents retiennent jusqu'à 4 Mio chacun                                                                            | Baisser `maxBackpressure` sur `websocket` **et** `websocketSecure` → [`references/dimensionnement.md`](references/dimensionnement.md)                                     |
-| Toutes les connexions répondent `403` « doit passer par HTTPS » | Même cause : le mot de passe arrive sur une requête que l'application croit en clair                                                              | `NF__HTTP__TRUSTPROXY` — jamais `allowInsecureCredentials`                                                                                                                |
-| Sortie **78** au démarrage, une clé ou une variable nommée      | Faute de configuration : clé inconnue (ou retirée par une mise à jour), valeur invalide, secret requis absent (`NF_CSRF_SECRET`, `NF_JWT_KEYSET`) | Lire la ligne qui la nomme ; `npx nodefony doctor --env production` annonce AVANT les variables requises (pas `NF_JWT_KEYSET`, exigée seulement si l'app émet des jetons) |
-| Les journaux d'audit montrent tous la **même adresse**          | L'adresse du client n'est pas propagée, ou le frontal n'est pas de confiance                                                                      | `trustProxy` ; en Podman sans privilèges, **c'est irréparable** (§7)                                                                                                      |
-| `EACCES` au premier démarrage sur un volume                     | Le volume est né `root:root` : monté **par-dessus** un dossier dont l'image avait fixé le porteur                                                 | Volume nommé (il hérite du porteur) ou groupe de système de fichiers                                                                                                      |
-| La base refuse des connexions dès qu'on monte en exemplaires    | Une base administrée les compte ; le pool n'est pas borné                                                                                         | Réduire les exemplaires — le plafond n'est pas encore réglable (§6)                                                                                                       |
-| La sonde répond `429`                                           | Ce n'est **pas** la sonde : c'est la limitation de débit — donc l'appel n'a pas pris le raccourci                                                 | Interroger `/livez` et `/readyz` nus, sans en-tête ni préfixe ajouté                                                                                                      |
-| Un secret retiré du `Dockerfile` reste dans l'image             | Une couche antérieure le contient encore ; l'effacer plus loin ne l'enlève pas                                                                    | `npx nodefony image:check`, et reconstruire sans jamais l'avoir copié                                                                                                     |
-| La variable posée « ne fait rien »                              | Le nom est faux d'un caractère — une variable inconnue est **ignorée**, pas refusée                                                               | `npx nodefony doctor` → [`references/variables.md`](references/variables.md)                                                                                              |
+| Symptôme                                                                         | Cause                                                                                                                                             | Correction                                                                                                                                                                |
+| -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| L'exemplaire redémarre en boucle, journaux muets                                 | La sonde de vivacité tombe avant la fin du démarrage                                                                                              | Sonde de démarrage sur `/readyz`, dimensionnée sur le **pire** cas                                                                                                        |
+| Page blanche derrière le frontal, console « Refused to execute… blocked by CSP » | Deux CSP : celle de l'application et une ajoutée au frontal                                                                                       | Retirer celle du frontal, ou `headers.csp: ""` dans l'application                                                                                                         |
+| Le conteneur sort en **137** à l'arrêt                                           | Il a été tué : la fenêtre d'arrêt est ≤ au drain                                                                                                  | Fenêtre ≥ 30 s (Podman : `--stop-timeout 20`, son défaut est **10 s**)                                                                                                    |
+| Des `5xx` **pendant** chaque déploiement                                         | Le répartiteur envoie encore du trafic quand le drain a commencé                                                                                  | Un délai avant drain, et un court arrêt avant terminaison                                                                                                                 |
+| Le cookie de session n'a pas le préfixe `__Host-` en production                  | Schéma constaté `http` derrière le frontal                                                                                                        | `NF__HTTP__TRUSTPROXY`                                                                                                                                                    |
+| La WebSocket se ferme seule au bout d'une minute                                 | L'inactivité du frontal est plus courte que le battement                                                                                          | Régénérer le frontal ; sur un contrôleur d'entrée, `proxy-read-timeout` ≥ 300 s → [`references/frontal.md`](references/frontal.md)                                        |
+| Un message temps réel n'arrive qu'à une partie des clients                       | Plusieurs exemplaires, bus local : chaque pod ne diffuse qu'à ses propres clients                                                                 | `NF_REALTIME_DRIVER=redis` + `NF_REDIS_URL` → [`references/dimensionnement.md`](references/dimensionnement.md)                                                            |
+| Depuis l'activation de h2c, le pod n'est jamais prêt                             | La sonde vise le port h2c (5153), qui refuse HTTP/1.1                                                                                             | Sonder le port HTTP (5151)                                                                                                                                                |
+| Depuis l'activation de h2c, les WebSocket ne s'ouvrent plus                      | Le frontal les envoie au port h2c                                                                                                                 | Router `Upgrade: websocket` vers le port HTTP → [`references/frontal.md`](references/frontal.md) §8                                                                       |
+| `DB_SQLITE_FALLBACK` en production alors que la base est posée                   | Le nom de la variable est faux d'un caractère, ou le Secret n'est pas monté dans CE conteneur                                                     | `npx nodefony doctor --env production` nomme la variable lue (`NF_DATABASE_URL` ou `NF_DATABASE_URL_FILE`)                                                                |
+| Le pod est tué (`OOMKilled`) avec peu de connexions                              | La contre-pression : des clients lents retiennent jusqu'à 4 Mio chacun                                                                            | Baisser `maxBackpressure` sur `websocket` **et** `websocketSecure` → [`references/dimensionnement.md`](references/dimensionnement.md)                                     |
+| Toutes les connexions répondent `403` « doit passer par HTTPS »                  | Même cause : le mot de passe arrive sur une requête que l'application croit en clair                                                              | `NF__HTTP__TRUSTPROXY` — jamais `allowInsecureCredentials`                                                                                                                |
+| Sortie **78** au démarrage, une clé ou une variable nommée                       | Faute de configuration : clé inconnue (ou retirée par une mise à jour), valeur invalide, secret requis absent (`NF_CSRF_SECRET`, `NF_JWT_KEYSET`) | Lire la ligne qui la nomme ; `npx nodefony doctor --env production` annonce AVANT les variables requises (pas `NF_JWT_KEYSET`, exigée seulement si l'app émet des jetons) |
+| Les journaux d'audit montrent tous la **même adresse**                           | L'adresse du client n'est pas propagée, ou le frontal n'est pas de confiance                                                                      | `trustProxy` ; en Podman sans privilèges, **c'est irréparable** (§7)                                                                                                      |
+| `EACCES` au premier démarrage sur un volume                                      | Le volume est né `root:root` : monté **par-dessus** un dossier dont l'image avait fixé le porteur                                                 | Volume nommé (il hérite du porteur) ou groupe de système de fichiers                                                                                                      |
+| La base refuse des connexions dès qu'on monte en exemplaires                     | Une base administrée les compte ; le pool n'est pas borné                                                                                         | Réduire les exemplaires — le plafond n'est pas encore réglable (§6)                                                                                                       |
+| La sonde répond `429`                                                            | Ce n'est **pas** la sonde : c'est la limitation de débit — donc l'appel n'a pas pris le raccourci                                                 | Interroger `/livez` et `/readyz` nus, sans en-tête ni préfixe ajouté                                                                                                      |
+| Un secret retiré du `Dockerfile` reste dans l'image                              | Une couche antérieure le contient encore ; l'effacer plus loin ne l'enlève pas                                                                    | `npx nodefony image:check`, et reconstruire sans jamais l'avoir copié                                                                                                     |
+| La variable posée « ne fait rien »                                               | Le nom est faux d'un caractère — une variable inconnue est **ignorée**, pas refusée                                                               | `npx nodefony doctor` → [`references/variables.md`](references/variables.md)                                                                                              |
 
 ## 6. Kubernetes — ce qui est rendu, et ce qui te reste