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

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

@@ -8,6 +8,7 @@
  * FAUSSE en silence — exactement la classe de bug qu'une sonde ne peut pas se
  * permettre.
  */
+import path from "node:path";
 import { createHash } from "node:crypto";
 
 /**
@@ -25,8 +26,67 @@ export const FAMILIES = Object.freeze({
   perf: "temps de rendu — TTFB, FCP, LCP, CLS, tâches longues",
   stockage: "cookies (attributs, jamais les valeurs) et Web Storage",
   responsive: "débordement horizontal à plusieurs largeurs d'écran",
+  pli: "proportions — l'action principale visible sans défiler, la place du bloc principal dans l'écran",
 });
 
+/**
+ * Écrans nommés pour `NF_BROWSER_VIEWPORT` — les tailles qu'on vérifie le plus
+ * souvent, pour ne pas les réécrire (et les mal recopier) à chaque mesure.
+ * `mobile-court` est l'écran qui révèle un formulaire trop haut : un téléphone
+ * de 667 px de haut, encore courant.
+ */
+export const VIEWPORT_PRESETS = Object.freeze({
+  mobile: { width: 390, height: 844 },
+  "mobile-court": { width: 375, height: 667 },
+  tablette: { width: 820, height: 1180 },
+  bureau: { width: 1440, height: 900 },
+  large: { width: 1920, height: 1080 },
+  "tres-large": { width: 2560, height: 1440 },
+});
+
+/** En deçà de cette largeur, l'écran est émulé comme un TÉLÉPHONE (tactile, densité 2). */
+export const MOBILE_MAX_WIDTH = 600;
+
+/**
+ * Analyse l'écran demandé (`NF_BROWSER_VIEWPORT`) : un nom de
+ * {@link VIEWPORT_PRESETS} ou `LARGEURxHAUTEUR`. Absent = `bureau`, l'écran
+ * historique de la sonde.
+ *
+ * Un écran étroit n'est pas qu'une fenêtre réduite : un téléphone annonce un
+ * écran tactile et une densité de pixels, et certaines pages en dépendent
+ * (`@media (pointer: coarse)`, `hover`). Sous {@link MOBILE_MAX_WIDTH}, la sonde
+ * l'émule donc comme un téléphone.
+ *
+ * @param {string|undefined} raw - `mobile`, `390x844`…
+ * @returns {{ name: string, width: number, height: number, mobile: boolean } | { error: string }}
+ */
+export function parseViewport(raw) {
+  const value = (raw ?? "").trim().toLowerCase();
+  const named = Object.hasOwn(VIEWPORT_PRESETS, value || "bureau")
+    ? VIEWPORT_PRESETS[value || "bureau"]
+    : null;
+  let size = named;
+  if (size === null) {
+    const m = /^(\d{3,4})x(\d{3,4})$/.exec(value);
+    const width = m ? Number(m[1]) : NaN;
+    const height = m ? Number(m[2]) : NaN;
+    if (!(width >= 240 && width <= 4000 && height >= 240 && height <= 4000)) {
+      return {
+        error:
+          `écran « ${raw} » inconnu : ${Object.keys(VIEWPORT_PRESETS).join(", ")}, ` +
+          "ou LARGEURxHAUTEUR (240 à 4000 px)",
+      };
+    }
+    size = { width, height };
+  }
+  return {
+    name: named ? value || "bureau" : `${size.width}x${size.height}`,
+    width: size.width,
+    height: size.height,
+    mobile: size.width < MOBILE_MAX_WIDTH,
+  };
+}
+
 /**
  * Analyse la liste de familles demandée (`NF_BROWSER_FAMILIES`).
  *
@@ -85,7 +145,7 @@ export function parseProbes(raw) {
 }
 
 /** Verbes qui prennent une VALEUR après la cible. Les autres n'en ont aucune. */
-const VERBS_WITH_VALUE = new Set(["saisir"]);
+const VERBS_WITH_VALUE = new Set(["saisir", "choisir"]);
 
 /** Verbes reconnus d'une action, le premier étant celui par défaut. */
 export const ACTION_VERBS = [
@@ -94,6 +154,7 @@ export const ACTION_VERBS = [
   "droit",
   "survol",
   "saisir",
+  "choisir",
   "touche",
   "voir",
   "defiler",
@@ -113,7 +174,8 @@ export const ACTION_VERBS = [
  * s'arrêtait en annonçant un élément introuvable, ce qui envoyait chercher un
  * défaut dans la page. D'où deux règles :
  *
- * 1. seuls les verbes qui PRENNENT une valeur (`saisir`) découpent sur `=` ;
+ * 1. seuls les verbes qui PRENNENT une valeur (`saisir`, `choisir`) découpent
+ *    sur `=` ;
  *    pour tous les autres, la cible est le reste entier ;
  * 2. même pour ceux-là, la coupure ignore les `=` situés à l'intérieur de
  *    crochets — `saisir:input[name=q]=bonjour` saisit bien « bonjour » dans
@@ -178,6 +240,62 @@ export function parseColorScheme(raw) {
   return { schema: null, invalid: 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
+ * l'ouverture de la page et le rétablit 3 s plus tard.
+ *
+ * La coupure existe pour éprouver une REPRISE : un flux temps réel qui revient
+ * après une perte de réseau ne se constate sur aucune capture. Une valeur
+ * malformée est REFUSÉE : ignorée, elle ferait observer une page jamais coupée
+ * en croyant avoir éprouvé sa reprise.
+ *
+ * @param {string|undefined} raw - valeur brute (`"4000:3000"`, vide).
+ * @returns {{ cut: { at: number, duration: number }|null, invalid: string|null }}
+ *   `cut` à null quand rien n'est demandé.
+ */
+export function parseCut(raw) {
+  const v = (raw ?? "").trim();
+  if (!v) return { cut: null, invalid: null };
+  const m = /^(\d+):(\d+)$/.exec(v);
+  if (!m || Number(m[2]) === 0) return { cut: null, invalid: v };
+  return { cut: { at: Number(m[1]), duration: Number(m[2]) }, invalid: null };
+}
+
+/**
+ * Ramène un code de fermeture WebSocket à un code qu'un NAVIGATEUR peut
+ * émettre : 1000, ou 3000 à 4999 — tout autre lève `InvalidAccessError`.
+ *
+ * 🔴 Le côté serveur d'une route Playwright est un vrai WebSocket de page.
+ * Fermé avec 1001 ou 1006, il refuse, Playwright avale l'erreur et rend « ok » :
+ * la connexion réelle reste ouverte et le serveur continue de pousser vers un
+ * socket que la sonde dit fermé. Mesuré : 47 s sans fermeture côté serveur.
+ *
+ * @param {number} code - le code voulu.
+ * @returns {number} ce code s'il est émissible, 1000 sinon.
+ */
+export function sendableCloseCode(code) {
+  return code === 1000 || (code >= 3000 && code <= 4999) ? code : 1000;
+}
+
+/**
+ * Arguments de lancement qui imposent le schéma de couleurs AU MOTEUR.
+ *
+ * L'émulation du pilote (`colorScheme` d'un contexte) ne vaut que pour les
+ * pages qu'il ouvre lui-même. Lighthouse ouvre son onglet par le protocole de
+ * débogage : sans ce réglage, l'audit mesure le thème du SYSTÈME, sans le dire.
+ * Blink connaît deux valeurs (`0` sombre, `1` clair) — `no-preference` n'en a
+ * pas, et ne pose donc rien.
+ *
+ * @param {string|null} schema - schéma rendu par `parseColorScheme`.
+ * @returns {string[]} arguments à ajouter au lancement du navigateur.
+ */
+export function colorSchemeLaunchArgs(schema) {
+  if (schema === "dark") return ["--blink-settings=preferredColorScheme=0"];
+  if (schema === "light") return ["--blink-settings=preferredColorScheme=1"];
+  return [];
+}
+
 /**
  * Analyse les entrées de stockage à poser avant chargement (`NF_BROWSER_STORAGE`).
  *
@@ -224,21 +342,64 @@ export function parseStorage(raw) {
  * évite de faire dire à `process.platform` une chose qu'il ne sait pas. Une
  * capacité se constate ; c'est l'appelant qui constate, cette fonction décide.
  *
- * @param {{inContainer: boolean, base?: string, out?: string}} stage -
+ * Le dossier de sortie local s'ancre à la RACINE de l'application (`root`,
+ * constatée par l'appelant) : relatif au dossier courant, il semait un
+ * `tmp/browser/` dans chaque sous-dossier d'où l'on lançait la sonde.
+ *
+ * @param {{inContainer: boolean, base?: string, out?: string, root?: string | null}} stage -
  *   le constat, et les valeurs explicites qui l'emportent toujours.
  * @returns {{ base: string, out: string }} origine à joindre, dossier de sortie.
  */
-export function environmentDefaults({ inContainer, base, out } = {}) {
+export function environmentDefaults({ inContainer, base, out, root } = {}) {
   return {
     base:
       base ||
       (inContainer
         ? "https://host.docker.internal:5152"
         : "https://127.0.0.1:5152"),
-    out: out || (inContainer ? "/output" : "tmp/browser"),
+    out:
+      out ||
+      (inContainer
+        ? "/output"
+        : root
+          ? path.join(root, "tmp", "browser")
+          : "tmp/browser"),
   };
 }
 
+/**
+ * Verdict sur une session REPRISE, d'après le statut du point « qui suis-je ».
+ *
+ * Une session se PROUVE, elle ne se déduit pas : l'absence de renvoi vers le
+ * formulaire de connexion ne dit rien sur une page publique, qui se sert aussi
+ * bien à un anonyme. Vécu — après un redémarrage du serveur, la sonde mesurait
+ * une page en anonyme, sans un mot, avec un état de session mort.
+ *
+ * Un point « qui suis-je » peut répondre `200` à un anonyme en le DISANT dans
+ * son corps (`{ user: null }`) — c'est le contrat des bibliothèques qui livrent
+ * aussi le client de connexion. Juger au seul statut ferait alors reprendre une
+ * session morte, et mesurer en anonyme sans le dire.
+ *
+ * @param {number} status - statut HTTP rendu par `NF_BROWSER_WHOAMI`.
+ * @param {unknown} [body] - corps JSON de la réponse, s'il a pu être lu.
+ * @returns {"alive"|"dead"|"unproven"} `alive` (2xx sans `user: null`), `dead`
+ *   (401/403, ou 2xx dont le corps porte `user: null`), sinon `unproven` — le
+ *   point ne répond pas comme attendu, et une session qu'on ne sait pas
+ *   prouver ne se réutilise pas.
+ */
+export function sessionVerdict(status, body) {
+  if (status >= 200 && status < 300) {
+    const anonymous =
+      body !== null &&
+      typeof body === "object" &&
+      Object.hasOwn(body, "user") &&
+      body.user === null;
+    return anonymous ? "dead" : "alive";
+  }
+  if (status === 401 || status === 403) return "dead";
+  return "unproven";
+}
+
 /**
  * Nom du fichier d'état d'authentification, DÉRIVÉ de l'identifiant.
  *
@@ -255,20 +416,56 @@ export function environmentDefaults({ inContainer, base, out } = {}) {
  * fragment (`a@b` et `a-b`) — et une collision de nom rouvrirait exactement le
  * trou qu'on ferme.
  *
+ * L'ORIGINE entre dans l'empreinte : le même identifiant sur deux
+ * applications n'est pas la même session. Vécu — `admin` de la console
+ * d'administration (port 5152) et `admin` de Keycloak (port 8444) partageaient
+ * un fichier : la sonde reprenait l'un sur l'autre, retombait sur l'écran de
+ * connexion et le mesurait à la place de la page demandée.
+ *
  * @param {string|undefined} login - l'identifiant de connexion demandé.
+ * @param {string} [origin] - l'origine visée (`NF_BROWSER_BASE`).
  * @returns {string} le nom de fichier, sans dossier.
  */
-export function authStateName(login) {
+export function authStateName(login, origin = "") {
   const raw = login ?? "";
   const readable =
     raw.replace(/[^A-Za-z0-9._-]/gu, "_").slice(0, 40) || "anonyme";
   const fingerprint = createHash("sha256")
-    .update(raw)
+    .update(`${origin}\n${raw}`)
     .digest("hex")
     .slice(0, 8);
   return `.auth-state-${readable}-${fingerprint}.json`;
 }
 
+/**
+ * Nom de fichier d'une capture ou d'un rapport, DÉRIVÉ de la page visée.
+ *
+ * Le chemin donne un fragment LISIBLE ; la requête et le fragment d'URL n'y
+ * entrent jamais tels quels : une page d'autorisation OAuth en porte plusieurs
+ * centaines de caractères (`ENAMETOOLONG`), et `?`, `&`, `%` ou `:` sont
+ * refusés par certains systèmes de fichiers (Windows). Une requête présente
+ * laisse une EMPREINTE, pour que deux variantes d'une même page (`?ui_locales=fr`
+ * et `?ui_locales=en`) ne s'écrasent pas.
+ *
+ * @param {string} page - chemin demandé, requête comprise.
+ * @returns {string} le fragment de nom, sans dossier ni extension (≤ 80 caractères).
+ */
+export function captureSlug(page) {
+  const cut = page.search(/[?#]/u);
+  const pathname = cut === -1 ? page : page.slice(0, cut);
+  const readable =
+    pathname
+      .replace(/[^A-Za-z0-9._-]+/gu, "-")
+      .replace(/^-+|-+$/gu, "")
+      .slice(0, 70) || "racine";
+  if (cut === -1) return readable;
+  const fingerprint = createHash("sha256")
+    .update(page.slice(cut))
+    .digest("hex")
+    .slice(0, 8);
+  return `${readable}-${fingerprint}`;
+}
+
 /**
  * Analyse les largeurs d'écran de la famille `responsive` (`NF_BROWSER_WIDTHS`).
  *
@@ -324,6 +521,21 @@ export function median(values) {
   const m = Math.floor(sorted.length / 2);
   return sorted.length % 2 === 1 ? sorted[m] : (sorted[m - 1] + sorted[m]) / 2;
 }
+
+/**
+ * Arrondit une durée au centième de milliseconde — la précision d'un RTT local.
+ *
+ * Un arrondi à la milliseconde entière rend 0 pour tout aller-retour sous
+ * 0,5 ms : sur une même machine, la sonde annonçait une latence nulle. Le
+ * centième reste sous la résolution de `performance.now()` côté navigateur
+ * (~0,1 ms hors isolation), donc ne fabrique aucune précision qui n'existe pas.
+ *
+ * @param {number} ms - durée brute en millisecondes.
+ * @returns {number} la durée arrondie à 0,01 ms.
+ */
+export function roundMs(ms) {
+  return Math.round(ms * 100) / 100;
+}
 /**
  * Résume un rapport axe-core en un bloc lisible — le tri éditorial, pas la mesure.
  *

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

@@ -24,10 +24,10 @@
  * `@env` NF_BROWSER_PINGS nombre de mesures de latence (défaut 5)
  * `@requires` conteneur du profil `browser` démarré · serveur joignable · un endpoint temps réel exposé
  * `@output` un objet JSON sur stdout : accueil, abonnement, latence, api, reconnexion — un verdict par étape
- * `@exit` 0 scénario joué (les verdicts sont des DONNÉES) · 64 usage (endpoint manquant, params illisibles) · 65 accueil jamais reçu
+ * `@exit` 0 scénario joué (les verdicts sont des DONNÉES) · 64 usage (endpoint manquant, params illisibles) · 65 accueil jamais reçu (refus au handshake : JSON sur stdout, statut nommé)
  */
 import { open, goTo } from "./lib/browser.mjs";
-import { median } from "./lib/probes.mjs";
+import { median, roundMs } from "./lib/probes.mjs";
 
 const ENDPOINT = process.argv[2] ?? process.env.NF_BROWSER_SOCKET ?? "";
 if (!ENDPOINT.startsWith("/")) {
@@ -95,6 +95,13 @@ async function scenarioSocket(conf) {
   const openSocket = () =>
     new Promise((resolve, reject) => {
       const ws = new WebSocket(url);
+      // Une fermeture AVANT l'ouverture est un refus du HANDSHAKE (réponse
+      // non-101 : 401, 403, 404…) — rien à attendre, et surtout pas les huit
+      // secondes du garde, qui feraient lire un refus net comme un silence.
+      let opened = false;
+      ws.addEventListener("open", () => {
+        opened = true;
+      });
       const guard = setTimeout(() => {
         try {
           ws.close();
@@ -105,6 +112,14 @@ async function scenarioSocket(conf) {
       }, conf.timeoutMs);
       ws.addEventListener("close", (ev) => {
         closes.push({ a: a(), code: ev.code, reason: ev.reason });
+        if (!opened) {
+          clearTimeout(guard);
+          const refusal = new Error(
+            `accueil jamais reçu : connexion refusée au handshake sur ${url}`,
+          );
+          refusal.handshake = { afterMs: a(), closeCode: ev.code };
+          reject(refusal);
+        }
       });
       ws.addEventListener("message", (ev) => {
         let frame;
@@ -166,7 +181,8 @@ async function scenarioSocket(conf) {
       const settle = (value) => {
         if (settled) return;
         settled = true;
-        resolve({ ...value, ms: Math.round(performance.now() - start) });
+        // Durée BRUTE : l'arrondi se fait côté Node (`roundMs`), où il s'éprouve.
+        resolve({ ...value, ms: performance.now() - start });
       };
       const guard = setTimeout(() => {
         pending.delete(id);
@@ -181,8 +197,21 @@ async function scenarioSocket(conf) {
       ws.send(JSON.stringify(frame));
     });
 
-  const { ws, welcome } = await openSocket();
+  let first;
+  try {
+    first = await openSocket();
+  } catch (e) {
+    // Le refus au handshake est une RÉPONSE du serveur, pas une panne de la
+    // sonde : il se rend en données (le pilote y joint le statut HTTP que seul
+    // le navigateur connaît — la page ne voit qu'un code de fermeture 1006).
+    if (!e?.handshake) throw e;
+    result.welcome = { verdict: "REFUSÉ AU HANDSHAKE", ...e.handshake };
+    result.closes = closes;
+    return result;
+  }
+  const { ws, welcome } = first;
   result.welcome = {
+    verdict: "OK",
     receivedAfterMs: a(),
     protocol: welcome.protocol ?? null,
     channels: welcome.channels ?? [],
@@ -330,6 +359,19 @@ async function scenarioSocket(conf) {
 const { browser, ctx, page, reuse } = await open();
 await goTo(page, ctx, process.env.NF_BROWSER_PAGE ?? "/", reuse);
 
+// Le statut HTTP d'un handshake refusé n'existe que pour le NAVIGATEUR : la
+// page n'en reçoit qu'un code de fermeture 1006. Le pilote l'écoute là où le
+// navigateur le dit — l'erreur du socket et la console.
+const handshakeErrors = [];
+page.on("websocket", (socket) => {
+  socket.on("socketerror", (error) => handshakeErrors.push(String(error)));
+});
+page.on("console", (message) => {
+  if (message.type() === "error" && message.text().includes("WebSocket")) {
+    handshakeErrors.push(message.text());
+  }
+});
+
 let result;
 try {
   result = await page.evaluate(scenarioSocket, cfg);
@@ -344,11 +386,35 @@ try {
   process.exit(65); // EX_DATAERR
 }
 
+if (result.welcome?.verdict === "REFUSÉ AU HANDSHAKE") {
+  // Les messages du navigateur arrivent par le protocole de débogage, parfois
+  // juste APRÈS la fermeture vue par la page : une courte attente bornée.
+  if (handshakeErrors.length === 0) await page.waitForTimeout(500);
+  const reason = handshakeErrors[0]?.slice(0, 300) ?? null;
+  // Chromium nomme le code (« Unexpected response code: 404 ») SAUF pour un
+  // 401 porteur de `WWW-Authenticate` : il le traite en défi d'authentification
+  // qu'il ne sait pas satisfaire, et ne dit que cela.
+  const status = /HTTP Authentication failed/i.test(reason ?? "")
+    ? "401"
+    : /\b([1-5]\d\d)\b/.exec(reason ?? "")?.[1];
+  result.welcome.status = status ? Number(status) : null;
+  result.welcome.browserReason = reason;
+  console.log(JSON.stringify(result, null, 2));
+  console.error(
+    `Accueil jamais reçu : le serveur a REFUSÉ le handshake (statut ${result.welcome.status ?? "non communiqué par le navigateur"}).\n` +
+      `→ 401/403 : la page ${process.env.NF_BROWSER_PAGE ?? "/"} n'est pas authentifiée, ou le compte n'a pas le droit (NF_BROWSER_USER + NF_BROWSER_LOGIN) ; 404 : chemin du endpoint faux ; 403 sur une page authentifiée : Origin refusé.`,
+  );
+  await browser.close();
+  process.exit(65); // EX_DATAERR — l'accueil n'est pas venu, la cause est nommée
+}
+
 // La médiane se calcule ici, avec la fonction que les tests éprouvent — la
 // moyenne serait déplacée par un seul aller-retour aberrant.
 if (Array.isArray(result.latency?.measuresMs)) {
+  result.latency.measuresMs = result.latency.measuresMs.map(roundMs);
   result.latency.medianMs = median(result.latency.measuresMs);
 }
+if (typeof result.api?.ms === "number") result.api.ms = roundMs(result.api.ms);
 
 console.log(JSON.stringify(result, null, 2));
 await browser.close();

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

@@ -13,16 +13,27 @@
  * `@env` NF_BROWSER_USER identifiant ; sans lui, aucune authentification n'est tentée
  * `@env` NF_BROWSER_PASSWORD mot de passe associé
  * `@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)
  * `@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";
 
 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 { cut: CUT, invalid: invalidCut } = parseCut(process.env.NF_BROWSER_CUT);
+if (invalidCut) {
+  console.error(
+    `NF_BROWSER_CUT attend « <début>:<durée> » en ms (ex. 4000:3000), reçu « ${invalidCut} »`,
+  );
+  process.exit(64);
+}
+// 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();
 
@@ -39,6 +50,9 @@ const uncaughtErrors = [];
 // qu'on ne lit, et une sortie de plusieurs mégaoctets serait illisible — donc
 // inexploitable pour décider. On garde les premières de chaque sens.
 page.on("websocket", (ws) => {
+  // Un socket routé pour la coupure est enregistré par la route : l'écouter
+  // ici aussi le compterait deux fois.
+  if (CUT && isRouted(ws.url())) return;
   const rec = { url: ws.url(), openedAt: at(), sent: [], received: [] };
   sockets.push(rec);
   ws.on("framesent", (f) => {
@@ -72,8 +86,88 @@ page.on("pageerror", (e) => {
     uncaughtErrors.push({ a: at(), text: String(e).slice(0, 200) });
 });
 
+// ── La coupure réseau : éprouver une REPRISE ────────────────────────────────
+// `setOffline` seul ne suffit PAS : Chromium y coupe le HTTP mais laisse les
+// WebSockets déjà ouverts vivre — mesuré, aucun `close` n'est émis, et l'on
+// « éprouverait » une reprise sans qu'aucune connexion ait été perdue. Les
+// sockets passent donc par `routeWebSocket` : à la coupure, la sonde ferme
+// chaque connexion des deux côtés — 1006 vers la page, ce que voit un client
+// qui perd le réseau ; 1000 vers le serveur, qui libère la connexion au lieu de
+// la garder à demi ouverte — et refuse toute réouverture jusqu'au
+// rétablissement.
+// Le relais Vite (`/_vite/`) est épargné : son client de rechargement à chaud
+// RECHARGE la page quand il retrouve le serveur, et la reprise observée serait
+// celle d'une page neuve, pas celle de l'application.
+let cut = null;
+let cutActive = false;
+const cutTimers = [];
+const routed = new Set();
+// Le côté SERVEUR d'une route est un vrai WebSocket de navigateur : son code
+// de fermeture passe par `sendableCloseCode` (cf son TSDoc).
+if (CUT) {
+  cut = { requested: CUT, refused: 0 };
+  await ctx.routeWebSocket(isRouted, (route) => {
+    if (cutActive) {
+      cut.refused += 1;
+      route.close({ code: 1006, reason: "coupure réseau (sonde)" });
+      return;
+    }
+    const server = route.connectToServer();
+    const rec = { url: route.url(), openedAt: at(), sent: [], received: [] };
+    sockets.push(rec);
+    const pair = { route, server, rec };
+    routed.add(pair);
+    // Poser `onMessage` coupe le relais automatique : on relaie à la main.
+    route.onMessage((m) => {
+      if (rec.sent.length < MAX)
+        rec.sent.push({ a: at(), payload: String(m).slice(0, 160) });
+      server.send(m);
+    });
+    server.onMessage((m) => {
+      if (rec.received.length < MAX)
+        rec.received.push({ a: at(), payload: String(m).slice(0, 160) });
+      route.send(m);
+    });
+    const closed = (code) => {
+      rec.closedAt ??= at();
+      rec.closeCode ??= code;
+      routed.delete(pair);
+    };
+    route.onClose((code, reason) => {
+      closed(code);
+      server.close({ code: sendableCloseCode(code), reason });
+    });
+    server.onClose((code, reason) => {
+      closed(code);
+      route.close({ code, reason });
+    });
+  });
+}
+
 await goTo(page, ctx, PAGE, reuse);
 
+if (CUT) {
+  cutTimers.push(
+    setTimeout(() => {
+      cut.offlineAt = at();
+      cutActive = true;
+      ctx.setOffline(true).catch((e) => (cut.error = String(e)));
+      for (const { route, server, rec } of routed) {
+        rec.closedAt ??= at();
+        rec.closeCode ??= 1006;
+        server.close({ code: 1000, reason: "coupure réseau (sonde)" });
+        route.close({ code: 1006, reason: "coupure réseau (sonde)" });
+      }
+      routed.clear();
+    }, CUT.at),
+    setTimeout(() => {
+      cut.onlineAt = at();
+      cutActive = false;
+      ctx.setOffline(false).catch((e) => (cut.error = String(e)));
+    }, CUT.at + CUT.duration),
+  );
+}
+
 // ── 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é :
@@ -100,12 +194,19 @@ if (UNTIL) {
   await page.waitForTimeout(DURATION);
 }
 
+for (const t of cutTimers) clearTimeout(t);
+if (cut && cut.onlineAt === undefined) {
+  cutActive = false;
+  await ctx.setOffline(false);
+}
+
 console.log(
   JSON.stringify(
     {
       url: page.url(),
       observeForMs: at(),
       verdict,
+      cut,
       // Les totaux sont posés sur l'objet accumulé plutôt que recomposés par
       // étalement dans un `map` (règle `no-map-spread` : allocation inutile).
       sockets: sockets.map((s) =>