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

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

@@ -41,9 +41,11 @@ import {
   USER,
 } from "./lib/browser.mjs";
 import {
+  browserEngine,
   browserOrder,
   captureSlug,
   colorSchemeLaunchArgs,
+  stampedName,
   summarizeLighthouse,
 } from "./lib/probes.mjs";
 
@@ -104,6 +106,17 @@ const profile = mkdtempSync(path.join(tmpdir(), "nf-audit-"));
 // seul Chrome est installé — là même où `inspect.mjs` passait.
 let ctx = null;
 const failures = [];
+// Lighthouse parle au navigateur par le protocole de débogage de Chromium :
+// Firefox et WebKit ne l'exposent pas. Refuser en le disant, plutôt que de se
+// rabattre sur Chromium et d'attribuer l'audit au moteur qu'on n'a pas lancé.
+const wanted = (process.env.NF_BROWSER_ENGINE ?? "").trim();
+if (wanted && browserEngine(wanted).engine !== "chromium") {
+  console.error(
+    `L'audit exige un navigateur de la famille Chromium (protocole de débogage) — « ${wanted} » n'en est pas un.\n` +
+      "Pour regarder la page sous ce moteur : inspect.mjs avec le même NF_BROWSER_ENGINE.",
+  );
+  process.exit(64); // EX_USAGE
+}
 for (const channel of browserOrder(process.env.NF_BROWSER_ENGINE)) {
   try {
     ctx = await chromium.launchPersistentContext(profile, {
@@ -194,9 +207,11 @@ try {
   // Le rapport COMPLET est conservé : le résumé sert à décider, l'original à
   // vérifier — et à comparer dans le temps.
   mkdirSync(OUTPUT, { recursive: true });
-  const stamp = new Date().toISOString().replace(/[:.]/gu, "-").slice(0, 19);
   const slug = captureSlug(PAGE);
-  const fullPath = path.join(OUTPUT, `lighthouse-${slug}-${stamp}.json`);
+  const fullPath = path.join(
+    OUTPUT,
+    stampedName(`lighthouse-${slug}`, new Date(), process.pid, "json"),
+  );
   writeFileSync(fullPath, JSON.stringify(lhr), "utf8");
 
   console.log(

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

@@ -15,16 +15,18 @@
  * `@env` NF_BROWSER_OUT dossier des captures et de l'état d'authentification (défaut constaté de la même façon)
  * `@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_FAMILIES familles de sondes à activer, séparées par des virgules (a11y, axe, rendu, reseau, perf, stockage, responsive, pli, notifications — ou « toutes ») ; défaut : aucune, le socle seul
+ * `@env` NF_BROWSER_AWAY `1` : la page se croit AILLEURS (onglet caché, autre application au premier plan) — pour mesurer ce qu'elle ne fait qu'en l'absence de la personne
+ * `@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_REDUCED_MOTION préférence de mouvement émulée (reduce, no-preference) — `reduce` mesure au repos une page à fondus au défilement
  * `@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é
  * `@env` NF_BROWSER_USER identifiant de connexion ; si absent, aucune authentification n'est tentée
  * `@env` NF_BROWSER_PASSWORD mot de passe associé
  * `@env` NF_BROWSER_ACTIONS séquence d'interactions AVANT mesure, séparées par `|` —
  *                        `verbe:cible[=valeur]` : clic (défaut), double, droit, survol,
- *                        saisir, choisir, touche, voir, defiler, attendre. Un écran qui se déplie
+ *                        saisir, choisir, deposer, touche, voir, defiler, molette, 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`) ;
@@ -34,11 +36,14 @@
  * `@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";
@@ -48,14 +53,18 @@ import {
   captureSlug,
   parseActions,
   parseFamilies,
+  signsInMidway,
   parseProbes,
+  stampedName,
   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.
  *
@@ -77,10 +86,13 @@ const EXPECT = process.argv[3] ?? process.env.NF_BROWSER_EXPECT ?? "";
  * | `survol`   | survol : révèle une infobulle, un menu déroulant          |
  * | `saisir`   | remplit un champ (`saisir:Nom=mon-app`)                   |
  * | `choisir`  | choisit une option d'une liste (`choisir:Habillage=dots`) |
- * | `touche`   | frappe une touche (`touche:Enter`, `touche:Escape`)       |
+ * | `deposer`  | joint un fichier à un champ, même caché (`deposer:input[type=file]=tmp/a.png`) |
+ * | `touche`   | frappe une touche sur le focus (`touche:Escape`), ou sur une cible (`touche:#onglet=End`) |
  * | `voir`     | amène dans la vue SANS cliquer                            |
  * | `defiler`  | fait défiler de N pixels (`defiler:600`), page ou conteneur |
+ * | `molette`  | une vraie molette de N pixels sous le pointeur (`survol:` avant) |
  * | `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
@@ -107,6 +119,8 @@ if (unknown.length > 0) {
   process.exit(64); // EX_USAGE
 }
 const active = new Set(kept);
+/** `NF_BROWSER_AWAY=1` : la page se croit cachée et sans le focus. */
+const AWAY = process.env.NF_BROWSER_AWAY === "1";
 
 /**
  * Sondes de style par défaut — surchargées par NF_BROWSER_PROBES.
@@ -146,9 +160,12 @@ async function axeSource() {
   return axe.source;
 }
 
-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,
+  permissions: active.has("notifications") ? ["notifications"] : [],
+});
 
 // ── Collecteurs — posés AVANT toute navigation ──────────────────────────────
 const consoleErrors = [];
@@ -166,6 +183,39 @@ page.on("pageerror", (e) => {
 // Les violations CSP ne sont visibles QUE depuis la page : le réseau montre la
 // requête absente, jamais la raison. L'init script est réinjecté à chaque
 // navigation — c'est l'état de la DERNIÈRE page qu'on lit, celle qu'on mesure.
+// Famille notifications : chaque `new Notification()` est RELEVÉE, puis
+// créée pour de vrai — la page garde son comportement, on lit ce qu'elle a
+// levé. Le pilote n'affiche aucune notification : sans ce relevé, une
+// notification réussie et une notification jamais levée se ressemblent.
+if (active.has("notifications")) {
+  await page.addInitScript(() => {
+    window.__nfNotifications = [];
+    const Native = window.Notification;
+    if (typeof Native !== "function") return;
+    class Recorded extends Native {
+      constructor(title, options) {
+        super(title, options);
+        if (window.__nfNotifications.length < 20)
+          window.__nfNotifications.push({
+            title: String(title).slice(0, 140),
+            body: String(options?.body ?? "").slice(0, 140),
+            tag: options?.tag ?? null,
+          });
+      }
+    }
+    window.Notification = Recorded;
+  });
+}
+// `NF_BROWSER_AWAY=1` : la personne est AILLEURS — onglet caché, autre
+// application au premier plan. Une page qui ne notifie qu'en son absence ne
+// se mesure pas autrement : la fenêtre pilotée est toujours au premier plan.
+if (AWAY) {
+  await page.addInitScript(() => {
+    Object.defineProperty(document, "visibilityState", { get: () => "hidden" });
+    Object.defineProperty(document, "hidden", { get: () => true });
+    document.hasFocus = () => false;
+  });
+}
 await page.addInitScript(() => {
   window.__nfCsp = [];
   document.addEventListener("securitypolicyviolation", (e) => {
@@ -230,7 +280,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
@@ -259,84 +309,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);
   }
 }
 
@@ -890,6 +868,24 @@ if (active.has("reseau")) {
   };
 }
 
+// ── Famille notifications — ce que la page a levé ──────────────────────────
+if (active.has("notifications")) {
+  const raised = await page.evaluate(() => ({
+    permission:
+      typeof Notification === "function" ? Notification.permission : "absente",
+    list: window.__nfNotifications ?? [],
+  }));
+  measured.notifications = {
+    // Une DONNÉE, pas un jugement : aucune notification peut être le bon
+    // résultat (la personne était là).
+    verdict: raised.list.length > 0 ? "LEVÉES" : "AUCUNE",
+    permission: raised.permission,
+    away: AWAY,
+    count: raised.list.length,
+    list: raised.list.slice(0, 3),
+  };
+}
+
 // ── Famille stockage — volet cookies, lu hors page ──────────────────────────
 if (active.has("stockage")) {
   const cookies = await ctx.cookies();
@@ -998,12 +994,37 @@ 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`);
+const shot = path.join(
+  OUTPUT,
+  stampedName(slug, new Date(), process.pid, "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",
@@ -1071,7 +1092,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,164 @@
+import { USER, signInElsewhere } from "./browser.mjs";
+
+/**
+ * Attend que le défilement se pose : la position de la fenêtre ne bouge plus
+ * pendant trois images (une molette peut défiler en douceur). Borné à une
+ * seconde environ — jamais une attente aveugle.
+ *
+ * @param {import("playwright").Page} page - la page pilotée.
+ */
+async function settleScroll(page) {
+  await page.evaluate(
+    () =>
+      new Promise((resolve) => {
+        let last = window.scrollY;
+        let still = 0;
+        let frames = 0;
+        const tick = () => {
+          frames += 1;
+          still = window.scrollY === last ? still + 1 : 0;
+          last = window.scrollY;
+          if (still >= 3 || frames >= 60) resolve(undefined);
+          else requestAnimationFrame(tick);
+        };
+        requestAnimationFrame(tick);
+      }),
+  );
+}
+
+/**
+ * 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" || verb === "molette") {
+      const pixels = Number.parseInt(target, 10);
+      if (!Number.isFinite(pixels)) {
+        return {
+          code: 64, // EX_USAGE
+          message: `${verb} attend un nombre de pixels, reçu « ${target} »`,
+        };
+      }
+      if (verb === "molette") {
+        // Une VRAIE molette, là où est le pointeur (`survol:` avant) : c'est
+        // le navigateur qui choisit quoi faire défiler, et qui passe à la page
+        // quand le conteneur est en bout — ce que `defiler`, qui appelle
+        // `scrollBy` sur un élément choisi, ne peut pas montrer.
+        await page.mouse.wheel(0, pixels);
+        await settleScroll(page);
+        continue;
+      }
+      // 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;
+    }
+    // Une touche sans cible part à l'élément qui a le focus (onglets,
+    // listes, menus : c'est lui que le clavier pilote).
+    if (verb === "touche" && target === "") {
+      await page.keyboard.press(value || "Enter");
+      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 {
+      // Un champ de fichier est presque toujours CACHÉ derrière un bouton
+      // (trombone, zone de dépôt) : l'attendre visible échouerait sur un champ
+      // pourtant présent. Il suffit qu'il soit attaché au document.
+      await locator.waitFor({
+        state: verb === "deposer" ? "attached" : "visible",
+        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();
+      // `deposer` : le fichier passe par le champ lui-même, comme un choix dans
+      // la boîte du système — la page reçoit le même `change` qu'à la main. Un
+      // chemin relatif part du répertoire courant.
+      else if (verb === "deposer") await locator.setInputFiles(value);
+      // `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,8 +13,9 @@
  * `@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_REDUCED_MOTION préférence de mouvement émulée (reduce, no-preference) — `reduce` mesure une page à fondus au repos
  * `@env` NF_BROWSER_STORAGE entrées de stockage local posées AVANT chargement (`clé=valeur`, séparées par des virgules)
  */
 import { existsSync, mkdirSync, rmSync } from "node:fs";
@@ -22,9 +23,11 @@ import path from "node:path";
 import {
   environmentDefaults,
   authStateName,
+  browserEngine,
   browserOrder,
   sessionVerdict,
   parseColorScheme,
+  parseReducedMotion,
   parseStorage,
   parseViewport,
 } from "./probes.mjs";
@@ -38,9 +41,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" +
@@ -191,6 +195,16 @@ if (invalidScheme) {
   );
   process.exit(64); // EX_USAGE
 }
+const { motion: REDUCED_MOTION, invalid: invalidMotion } = parseReducedMotion(
+  process.env.NF_BROWSER_REDUCED_MOTION,
+);
+if (invalidMotion) {
+  console.error(
+    `NF_BROWSER_REDUCED_MOTION inconnu : « ${invalidMotion} ».\n` +
+      "Valeurs acceptées (celles de la média query standard) : reduce, no-preference.",
+  );
+  process.exit(64); // EX_USAGE
+}
 const { entries: STORAGE, rejected: storageRejected } = parseStorage(
   process.env.NF_BROWSER_STORAGE,
 );
@@ -205,10 +219,15 @@ 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:`).
+ * @param options.permissions - permissions accordées d'avance à toutes les
+ *   origines (`notifications`…) : une page qui les DEMANDE les reçoit sans
+ *   boîte de dialogue — un navigateur piloté n'en montre aucune.
  * @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, permissions = [] } = {}) {
   // On CONSTATE quel navigateur répond, au lieu de supposer lequel est là.
   //
   // `channel` demande un navigateur COMPLET plutôt que le
@@ -222,10 +241,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 +261,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
   }
@@ -252,8 +276,10 @@ export async function open() {
       ? { isMobile: true, hasTouch: true, deviceScaleFactor: 2 }
       : {}),
     ...(COLOR_SCHEME ? { colorScheme: COLOR_SCHEME } : {}),
+    ...(REDUCED_MOTION ? { reducedMotion: REDUCED_MOTION } : {}),
+    ...(permissions.length > 0 ? { permissions } : {}),
   };
-  let reuse = Boolean(USER) && existsSync(STATE);
+  let reuse = !anonymous && Boolean(USER) && existsSync(STATE);
   let ctx = null;
   if (reuse) {
     try {
@@ -411,6 +437,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 +468,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) {