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

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

@@ -16,7 +16,7 @@
  * `@env` NF_BROWSER_PAGE chemin de la page à ouvrir (défaut /)
  * `@env` NF_BROWSER_EXPECT texte DISCRIMINANT attendu avant de mesurer (défaut : aucun, on mesure après domcontentloaded)
  * `@env` NF_BROWSER_FAMILIES familles de sondes à activer, séparées par des virgules (a11y, axe, rendu, reseau, perf, stockage, responsive — ou « toutes ») ; défaut : aucune, le socle seul
- * `@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) — un défaut peut n'exister que dans UN thème
  * `@env` NF_BROWSER_STORAGE entrées de stockage local posées AVANT chargement (`clé=valeur`) — pour une application qui MÉMORISE son thème
  * `@env` NF_BROWSER_LOGIN chemin du formulaire de connexion de TON application — requis dès qu'un identifiant est donné, aucun défaut n'est deviné
@@ -27,17 +27,21 @@
  *                        saisir, choisir, touche, voir, defiler, attendre. Un écran qui se déplie
  *                        au clic n'existe pas tant qu'on ne l'a pas ouvert.
  * `@env` NF_BROWSER_FULLPAGE 1 = capture la page ENTIÈRE (défaut : la fenêtre)
- * `@env` NF_BROWSER_PROBES sélecteurs CSS à sonder, séparés par des virgules (`libellé=sélecteur`)
+ * `@env` NF_BROWSER_PROBES sélecteurs CSS à sonder, séparés par des virgules (`libellé=sélecteur`) ;
+ *                        `hôte >>> sélecteur` entre dans le Shadow DOM ouvert de l'hôte
  * `@env` NF_BROWSER_WIDTHS largeurs de la famille responsive (défaut 360,768,1280)
  * `@env` NF_BROWSER_VIEWPORT écran mesuré : mobile, mobile-court, tablette, bureau (défaut), large, tres-large, ou LARGEURxHAUTEUR — sous 600 px, émulé en téléphone (tactile, densité 2)
  * `@env` NF_BROWSER_PRIMARY sélecteur de l'action principale pour la famille pli (défaut : le plus grand bouton de validation visible)
  * `@env` NF_BROWSER_SEUIL_LOURD bytes au-delà desquels une ressource est « lourde » (défaut 512000)
  * `@env` NF_BROWSER_SEUIL_LENT millisecondes au-delà desquelles une réponse est « lente » (défaut 1000)
+ * `@env` NF_BROWSER_EVAL expression JS évaluée DANS la page après les actions et les mesures (une forme fonction est appelée) ;
+ *                        son résultat sérialisé sort dans `evaluated` — l'état propre à l'application (store, socket)
  * `@requires` conteneur du profil `browser` démarré · serveur joignable depuis le conteneur
  * `@output` un objet JSON sur stdout + une capture PNG horodatée dans /output
  * `@exit` 0 mesure rendue (le verdict est une DONNÉE, pas un code de retour) · 64 usage (famille inconnue, identifiant sans chemin de connexion) · 65 texte attendu jamais apparu
  */
 import { existsSync, readFileSync } from "node:fs";
+import { playActions } from "./lib/actions.mjs";
 import path from "node:path";
 import * as decor from "./lib/browser.mjs";
 import { open, goTo, LOGIN, OUTPUT } from "./lib/browser.mjs";
@@ -47,14 +51,17 @@ import {
   captureSlug,
   parseActions,
   parseFamilies,
+  signsInMidway,
   parseProbes,
   parseWidths,
+  pageExpression,
   summarizeAxe,
   verdictGlobal,
 } from "./lib/probes.mjs";
 
 const PAGE = process.argv[2] ?? process.env.NF_BROWSER_PAGE ?? "/";
 const EXPECT = process.argv[3] ?? process.env.NF_BROWSER_EXPECT ?? "";
+const EVAL = pageExpression(process.env.NF_BROWSER_EVAL);
 /**
  * Ce qu'il faut FAIRE avant de mesurer — une séquence, pas un geste.
  *
@@ -80,6 +87,7 @@ const EXPECT = process.argv[3] ?? process.env.NF_BROWSER_EXPECT ?? "";
  * | `voir`     | amène dans la vue SANS cliquer                            |
  * | `defiler`  | fait défiler de N pixels (`defiler:600`), page ou conteneur |
  * | `attendre` | attend qu'un texte APPARAISSE (après une action lente)    |
+ * | `connecter` | se connecte dans un AUTRE onglet (`connecter:`), sans recharger |
  *
  * 🔴 `voir` existe parce qu'un clic n'est pas neutre : sur un formulaire, le
  * texte d'une question est un `label` — cliquer dessus COCHE la case qu'il
@@ -147,7 +155,9 @@ async function axeSource() {
 
 const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
 
-const { browser, ctx, page, reuse } = await open();
+// `connecter:` dans la séquence ⇒ la page s'ouvre ANONYME (cf signsInMidway).
+const ANONYMOUS = signsInMidway(ACTIONS);
+const { browser, ctx, page, reuse } = await open({ anonymous: ANONYMOUS });
 
 // ── Collecteurs — posés AVANT toute navigation ──────────────────────────────
 const consoleErrors = [];
@@ -229,7 +239,7 @@ if (active.has("reseau")) {
   });
 }
 
-await goTo(page, ctx, PAGE, reuse);
+await goTo(page, ctx, PAGE, reuse, { anonymous: ANONYMOUS });
 
 // Attendre un texte DISCRIMINANT, jamais `networkidle` : une application qui se
 // monte puis demande ses données passe par un état « réseau calme » où l'écran
@@ -258,84 +268,12 @@ if (EXPECT) {
 // toute mesure. Une action qui ne trouve pas sa cible ARRÊTE la sonde : la
 // mesure qui suivrait porterait sur un écran qu'on n'a pas ouvert, et rien ne
 // le dirait.
-for (const { verb, target, value } of ACTIONS) {
-  if (verb === "defiler") {
-    const pixels = Number.parseInt(target, 10);
-    if (!Number.isFinite(pixels)) {
-      console.error(`defiler attend un nombre de pixels, reçu « ${target} »`);
-      await browser.close();
-      process.exit(64); // EX_USAGE
-    }
-    // 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 {
-    console.error(
-      `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 « | »).",
-    );
+{
+  const failed = await playActions(page, ACTIONS);
+  if (failed !== null) {
+    console.error(failed.message);
     await browser.close();
-    process.exit(65); // EX_DATAERR
+    process.exit(failed.code);
   }
 }
 
@@ -384,7 +322,14 @@ function isVisible(el) {
 function effectiveBackground(el) {
   const layers = [];
   let opaqueLayer = null;
-  for (let n = el; n; n = n.parentElement) {
+  // Un élément posé à la racine d'un Shadow DOM n'a pas de parent : son fond
+  // est celui de l'HÔTE, et la remontée continue de l'autre côté.
+  const up = (n) => {
+    if (n.parentElement) return n.parentElement;
+    const root = n.getRootNode();
+    return root instanceof ShadowRoot ? root.host : null;
+  };
+  for (let n = el; n; n = up(n)) {
     const bg = getComputedStyle(n).backgroundColor;
     if (!bg || bg.includes("transparent")) continue;
     const { a } = parseColor(bg);
@@ -550,18 +495,44 @@ function probeA11y() {
  * Famille rendu — la page tient-elle dans son viewport, ses polices sont-elles
  * VRAIMENT arrivées. Les éléments hors viewport sont une INFO, pas le verdict :
  * carrousels et textes pour lecteurs d'écran en produisent légitimement.
+ *
+ * Le débordement se cherche AUSSI dans les Shadow DOM ouverts, et dans chaque
+ * conteneur défilant : un widget isolé (une barre de débogage) peut porter sa
+ * propre barre de défilement horizontale sans que la page, elle, déborde d'un
+ * pixel — la mesure du document seul la déclarait saine.
  */
 function probeRendering() {
   const doc = document.scrollingElement ?? document.documentElement;
   const overflowPx = Math.max(0, doc.scrollWidth - window.innerWidth);
   const outsideViewport = [];
   let totalOutside = 0;
-  for (const el of document.querySelectorAll("body *")) {
+  const scrollersX = [];
+  let totalScrollersX = 0;
+  const all = (root, out) => {
+    for (const el of root.querySelectorAll("*")) {
+      out.push(el);
+      if (el.shadowRoot) all(el.shadowRoot, out);
+    }
+    return out;
+  };
+  for (const el of all(document.body, [])) {
     const r = el.getBoundingClientRect();
-    if (r.width > 0 && r.right > window.innerWidth + 1) {
+    if (r.width === 0) continue;
+    if (r.right > window.innerWidth + 1 && totalOutside < 200) {
       totalOutside += 1;
       if (outsideViewport.length < 3) outsideViewport.push(describeElement(el));
-      if (totalOutside >= 200) break;
+    }
+    const ox = getComputedStyle(el).overflowX;
+    if (
+      (ox === "auto" || ox === "scroll") &&
+      el.scrollWidth > el.clientWidth + 1
+    ) {
+      totalScrollersX += 1;
+      if (scrollersX.length < 3)
+        scrollersX.push({
+          element: describeElement(el),
+          overflowPx: el.scrollWidth - el.clientWidth,
+        });
     }
   }
   const families = {};
@@ -571,8 +542,12 @@ function probeRendering() {
     if (f.status === "error") failedFonts += 1;
   }
   return {
-    verdict: overflowPx > 0 || failedFonts > 0 ? "ALERTE" : "OK",
+    verdict:
+      overflowPx > 0 || totalScrollersX > 0 || failedFonts > 0
+        ? "ALERTE"
+        : "OK",
     horizontalOverflow: { present: overflowPx > 0, overflowPx },
+    horizontalScrollers: { total: totalScrollersX, examples: scrollersX },
     elementsOutsideViewport: { total: totalOutside, examples: outsideViewport },
     fonts: {
       status: document.fonts.status,
@@ -659,7 +634,16 @@ async function measurePage(args) {
       s.getAttribute("src"),
     ),
     probes: args.probes.map(({ label, sel }) => {
-      const el = document.querySelector(sel);
+      // `hôte >>> sélecteur` traverse un Shadow DOM ouvert (un widget isolé,
+      // une barre de débogage) : chaque segment se cherche dans la racine
+      // fantôme de l'élément trouvé par le précédent.
+      let el = null;
+      let scope = document;
+      for (const part of sel.split(">>>")) {
+        el = scope?.querySelector(part.trim()) ?? null;
+        scope = el?.shadowRoot ?? null;
+        if (el === null) break;
+      }
       if (!el) return { label, absent: true, selector: sel };
       const cs = getComputedStyle(el);
       const r = el.getBoundingClientRect();
@@ -951,12 +935,34 @@ if (active.has("pli")) {
   }, primarySelector);
 }
 
+// ── Lire un ÉTAT de l'application — `NF_BROWSER_EVAL` ───────────────────────
+// Ce qu'aucune famille ne mesure parce que c'est propre à l'application : l'état
+// d'un store, l'instantané d'une socket, une valeur calculée par la page. Évalué
+// APRÈS les actions et les mesures, sur l'écran qu'on décrit. Une expression qui
+// lève rend son erreur, jamais un champ absent : un « rien » se lirait comme
+// « la page n'a pas cet état ».
+if (EVAL) {
+  try {
+    measured.evaluated = await page.evaluate(EVAL);
+  } catch (e) {
+    measured.evaluated = { error: String(e).slice(0, 300) };
+  }
+}
+
 // ── Capture — AVANT la famille responsive, qui déforme le viewport ──────────
 const slug = captureSlug(PAGE);
 const shot = path.join(OUTPUT, `${slug}-${stamp}.png`);
 // `NF_BROWSER_FULLPAGE=1` : la page ENTIÈRE, pas la fenêtre. Un formulaire long
 // (ou une page qu'on vient de déplier) a l'essentiel SOUS la ligne de flottaison
 // — la capture par défaut laisse alors conclure « ce n'est pas là ».
+//
+// La console se FIGE avant la capture : sous WebKit, le pilote injecte un
+// `<style>` pour capturer, et une politique de sécurité du contenu stricte le
+// refuse. Ce refus appartient à l'instrument, pas à la page — compté, il ferait
+// accuser l'application d'une violation qu'elle ne commet pas. (Le rapport, lui,
+// part quand même vers le serveur : une collecte de rapports sous WebKit doit
+// écarter les `style-src-elem` `inline` émis à l'instant de la capture.)
+const consoleFrozen = consoleErrors.slice();
 await page.screenshot({
   path: shot,
   fullPage: process.env.NF_BROWSER_FULLPAGE === "1",
@@ -1024,7 +1030,7 @@ console.log(
       // L'écran mesuré : une proportion sans son écran ne conclut rien.
       viewport: `${decor.VIEWPORT.name}${decor.VIEWPORT.mobile ? " (téléphone)" : ""}`,
       ...measured,
-      consoleErrors,
+      consoleErrors: consoleFrozen,
       uncaughtErrors,
       // Le chemin RENDU est celui où l'appelant trouvera l'image. Dans un
       // conteneur, `/output` est un volume monté et ne veut rien dire au

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() };
+}