@mostajs/geste-film 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog — @mostajs/geste-film
+
+Format [Keep a Changelog](https://keepachangelog.com/fr/1.0.0/) · [SemVer](https://semver.org/lang/fr/).
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+
+## [0.1.0] — 2026-11-07
+### Added
+- Scénario déclaratif `geste-film/1` : actions `aller`, `cliquer`, `saisir`, `choisir`, `cocher`, `attendre`, `montrer`,
+  `defiler`, et `legende` seule ; sélecteurs CSS ou `texte=…` (libellé visible).
+- `verifierScenario`, `empreinteScenario` (SHA-256 du scénario normalisé), `actionDe`, `ACTIONS`, `FORMAT`.
+- `tourner(scenarios, options)` : un Chrome sans écran par série, piloté par le protocole DevTools sur tube
+  (`--remote-debugging-pipe`), sans dépendance npm ; un onglet par scénario ; marques (rond, cadre, légende, code) posées
+  par le CSSOM sans lever la CSP de la page ; images prises à des moments choisis.
+- Assemblage par ffmpeg : MP4 (H.264, `yuv420p`, `+faststart`), GIF à palette calculée par film, affiche PNG.
+- Bilan `films.json` (`geste-film-bilan/1`, `FORMAT_BILAN`), `ligneJournal`, `trouverChrome`.
+- Erreurs renseignées : `E_INTROUVABLE`, `E_HTTP`, `E_INACTIF`, `E_SCENARIO`, `E_CHROME`, `E_FFMPEG`, `E_STRICT` ; la
+  ligne en échec dit l'étape, l'action, le sélecteur, l'adresse et laisse une capture `<code>-echec.png` ; la série continue.
+- Ligne de commande `geste-film verifier|tourner` (code 1 s'il y a un échec).
+- Exemple exécutable `examples/run.mjs` (serveur sous CSP stricte : EX-A1 filmé, EX-A2 en `E_INTROUVABLE`).
+- Essais T-GFM-1 à 10 (3 unitaires, 7 avec Chrome et ffmpeg).
+- Origine : demande du Maître d'ouvrage du 07/11/2026 (un film par ligne de formation). Premier usage : Guerway, fiches
+  CFG-A, pilote de 10 lignes, montrées dans ValiTrax par `@mostajs/recette` 0.10.0 (`illustration` par ligne).
+- Livrables DEVRULES §9 (01 à 17), plan Dev+Test, SBOM.
+
+### Changed (pendant le développement, avant publication)
+- Le plan prévoyait `Page.setBypassCSP` ; les marques passent finalement par le CSSOM et la CSP de la page reste
+  intacte (essai T-GFM-7).

package/LICENSE

@@ -0,0 +1,15 @@
+@mostajs/geste-film
+Copyright (C) 2026 Dr Hamid MADANI <drmdh@msn.com>
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the Free
+Software Foundation, either version 3 of the License, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/agpl-3.0.html>.

package/README.md

@@ -1,3 +1,64 @@
-# Temporary Holding Version
+# @mostajs/geste-film
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · Licence AGPL-3.0-or-later · Niveau N1 · aucune dépendance à l'exécution
+
+**Filmer un geste d'utilisation d'une application web** : une ligne de fiche de formation = un scénario JSON = un film.
+Chrome sans écran est piloté par son protocole DevTools **sur tube** (`--remote-debugging-pipe`, ni WebSocket ni
+bibliothèque) ; `ffmpeg` assemble les images en MP4, GIF et affiche. Programmes requis : `google-chrome` ou `chromium`, `ffmpeg`.
+
+```json
+{ "format": "geste-film/1", "code": "EX-A1", "titre": "Renommer l’agence et enregistrer",
+  "adresse": "http://exemple.banc.test/",
+  "etapes": [
+    { "legende": "Les réglages de l’agence" },
+    { "saisir": "#nom", "valeur": "Agence d’Oran centre", "legende": "Changer le nom" },
+    { "cliquer": "texte=Enregistrer", "legende": "« Enregistrer »" },
+    { "attendre": "texte=Enregistré", "legende": "Le réglage est enregistré" }
+  ] }
+```
+
+```js
+import { tourner, verifierScenario } from '@mostajs/geste-film';
+const bilan = await tourner(scenarios, { sortie: 'films', regles: 'MAP *.banc.test 127.0.0.1:5555', journal: console.log });
+// films/EX-A1.mp4, films/EX-A1.gif, films/EX-A1.png (affiche), films/films.json (bilan geste-film-bilan/1)
+```
+
+```bash
+geste-film verifier scenarios/          # validation seule, sans Chrome
+geste-film tourner scenarios/ --sortie films --regles "MAP *.banc.test 127.0.0.1:5555"   # code 1 s'il y a un échec
+```
+
+- **Actions** : `aller`, `cliquer`, `saisir` + `valeur`, `choisir` + `valeur`, `cocher`, `attendre`, `montrer`, `defiler`, et `legende` seule.
+- **Sélecteurs** : CSS (`#nom`, `[name=prix]`) ou `texte=…`, le libellé visible que la fiche cite entre « ».
+- **Marques** : rond rouge sur l'élément visé, cadre, bandeau de légende, code de la ligne en coin. Elles sont posées par le
+  CSSOM, sans jamais lever la CSP de la page, et retirées après chaque prise de vue.
+- **Images à des moments choisis**, jamais un flux : deux tournages du même scénario donnent les mêmes images (T-GFM-10).
+- **Bilan** `films.json` : statut, fichiers, images, durée, octets, empreinte SHA-256 du scénario, avertissements (CSP, exceptions).
+
+## Un échec qui renseigne
+
+Quand une étape échoue, seule sa ligne s'arrête ; la série continue. La ligne dit le code, l'étape, l'action, le sélecteur,
+l'adresse, et montre la page (`<code>-echec.png`) :
+
+```
+✗ EX-A2, étape 2 sur 2 (cliquer « texte=Publier ce service ») : introuvable après 5 s
+  sur http://exemple.banc.test/ ; capture : EX-A2-echec.png
+```
+
+Codes : `E_INTROUVABLE`, `E_HTTP`, `E_INACTIF`, `E_SCENARIO`, `E_CHROME`, `E_FFMPEG`, `E_STRICT`.
+
+## Exemple et essais
+
+`node examples/run.mjs` : un petit serveur sous CSP stricte (`examples/formulaire/`) ; EX-A1 est filmé (7 images,
+MP4 d'environ 26 ko, GIF d'environ 32 ko), EX-A2 finit en `E_INTROUVABLE`.
+
+`npm test` : 3 essais unitaires (T-GFM-1 à 3) et 7 essais avec Chrome et ffmpeg (T-GFM-4 à 10), puis l'exemple.
+
+Le module ne crée aucune session et ne sème aucune donnée : l'application filme **son banc, sur des données fictives**
+(`docs/16-DPIA-CONFORMITE-GESTE-FILM.md`). Premier usage : Guerway, fiches de formation CFG-A (pilote de 10 lignes).
+
+## Documentation
+
+Livrables DEVRULES §9 dans `docs/` : étude (01), audit (02), plan (03, 03bis), plan Dev+Test (JSON), tests (04), suivi (05),
+SEO (08), publication (09), présentation commerciale (10, 11), documentation technique (12, 13), image (14), sécurité (15),
+DPIA (16), article (`docs/articles/17-…`). Diaporamas PDF et PPTX dans `docs/slides/`. SBOM : `sbom.cyclonedx.json`.

package/bin/geste-film.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// geste-film — ligne de commande de @mostajs/geste-film.
+//   geste-film tourner <dossier-des-scénarios> [--sortie films] [--regles "MAP *.x 127.0.0.1:5555"] [--delai 5000]
+//                      [--largeur 960] [--hauteur 600] [--strict] [--garder-images]
+//   geste-film verifier <dossier-des-scénarios>
+// Code de sortie 1 s'il y a au moins un échec.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tourner, verifierScenario } from '../src/index.js';
+
+const [cmd, dossier, ...reste] = process.argv.slice(2);
+const opt = {};
+for (let i = 0; i < reste.length; i++) {
+  const k = reste[i];
+  if (k === '--strict') opt.strict = true;
+  else if (k === '--garder-images') opt.garderImages = true;
+  else if (k.startsWith('--')) opt[k.slice(2)] = reste[++i];
+}
+if (!['tourner', 'verifier'].includes(cmd) || !dossier) {
+  console.error('usage : geste-film tourner|verifier <dossier-des-scénarios> [--sortie films] [--regles "…"] [--delai ms]');
+  process.exit(2);
+}
+const fichiers = readdirSync(dossier).filter((f) => f.endsWith('.json')).sort();
+const scenarios = fichiers.map((f) => { try { return JSON.parse(readFileSync(join(dossier, f), 'utf8')); } catch (e) { return { code: f, _illisible: e.message }; } });
+if (cmd === 'verifier') {
+  let n = 0;
+  scenarios.forEach((s, i) => { const f = verifierScenario(s); if (f.length) { n++; console.log(`✗ ${fichiers[i]} : ${f.join(' ; ')}`); } else console.log(`✓ ${fichiers[i]}`); });
+  process.exit(n ? 1 : 0);
+}
+const bilan = await tourner(scenarios, {
+  sortie: opt.sortie || 'films', regles: opt.regles || '', delaiMs: Number(opt.delai) || 5000,
+  largeur: Number(opt.largeur) || 960, hauteur: Number(opt.hauteur) || 600, strict: Boolean(opt.strict), garderImages: Boolean(opt.garderImages),
+  journal: (l) => console.log(l),
+});
+process.exit(bilan.echecs ? 1 : 0);

package/llms.txt

@@ -0,0 +1,41 @@
+# @mostajs/geste-film — fiche LLM
+> Filmer un geste d'utilisation d'une application web : un scénario JSON (geste-film/1) par ligne de formation → MP4, GIF, affiche PNG. N1, outil. Aucune dépendance npm à l'exécution ; programmes du système : google-chrome|chromium, ffmpeg. Node >= 20. Auteur : Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+
+## RÔLE
+Lance UN Chrome sans écran par série (--headless=new, --remote-debugging-pipe, profil temporaire), ouvre un onglet par scénario, joue les étapes, pose des marques (rond, cadre, légende, code) par le CSSOM, prend des PNG à des moments choisis (Page.captureScreenshot), assemble par ffmpeg, écrit <sortie>/films.json. Un échec n'arrête que sa ligne. Ne crée aucune session, ne sème aucune donnée, ne téléverse rien.
+
+## EXPORTS
+- `tourner(scenarios, opts?)` → Promise<bilan> (écrit aussi <sortie>/films.json)
+- `verifierScenario(s)` → string[] (défauts en clair ; [] si juste) — sans Chrome
+- `empreinteScenario(s)` → SHA-256 hex du scénario normalisé (clés triées, espaces réduits)
+- `ligneJournal(film)` → « ✓ code (n images, x ko) » ou « ✗ code, étape n sur m (action « sélecteur ») : message\n  sur <adresse> ; capture : <fichier> »
+- `actionDe(etape)` → nom de l'action, 'legende', ou null
+- `trouverChrome(chemin?)` → chemin : option, sinon $CHROME, sinon google-chrome, google-chrome-stable, chromium, chromium-browser (via `which`) ; sinon erreur E_CHROME
+- `ACTIONS` = ['aller','cliquer','saisir','choisir','cocher','attendre','montrer','defiler'] (gelé) · `FORMAT` = 'geste-film/1' · `FORMAT_BILAN` = 'geste-film-bilan/1'
+- Bin : `geste-film verifier <dossier>` | `geste-film tourner <dossier> [--sortie films] [--regles "…"] [--delai ms] [--largeur 960] [--hauteur 600] [--strict] [--garder-images]` ; code 1 s'il y a un échec, 2 si usage faux.
+
+## API — options de tourner (défauts)
+sortie='films' · chrome (chemin) · ffmpeg='ffmpeg' · largeur=960 · hauteur=600 · largeurFilm=960 · regles='' (--host-resolver-rules) · delaiMs=5000 · formats=['mp4','gif'] (l'affiche est toujours produite) · strict=false · garderImages=false (PNG dans <sortie>/images/<code>/) · dureeImageMs=1200 · dureeFinMs=2000 (dernière image) · journal=(ligne)=>{}
+
+## TYPES
+- Scénario : { format:'geste-film/1', code:/^[A-Za-z][A-Za-z0-9]*(-[A-Za-z0-9]+)*$/, titre?, adresse:'http(s)://…', etapes:[Etape≥1] }
+- Etape : UNE action parmi ACTIONS (valeur = sélecteur ; pour `aller` : adresse absolue http(s) ou relative « /… ») + valeur? + legende? ; ou { legende } seule. `saisir`/`choisir` exigent `valeur` ; `cocher` : valeur true|false (défaut true). Toute autre clé = défaut.
+- Sélecteur : CSS, ou `texte=<libellé>` (texte visible, casse et espaces ignorés, guillemets « » " retirés ; égalité d'abord, puis inclusion ; l'élément le plus intérieur ; pour un INPUT : value ou aria-label).
+- Images par action : legende 1 · aller 1 · cliquer 2 · saisir 3 · choisir 2 · cocher 2 · attendre 1 · montrer 1 · defiler 1 (l'ouverture de `adresse` n'en prend pas).
+- Bilan : { format, date, outil:'@mostajs/geste-film@<v>', largeur, hauteur, echecs, films:[{ code, titre, statut:'ok'|'echec', images, dureeMs, octets:{mp4?,gif?,affiche?}, fichiers:{mp4?,gif?,affiche?,images?}, empreinte, avertissements:[{type:'csp'|'exception'|'marques',…}], erreur?:{ code, message, etapes, etape?, action?, selecteur?, adresse?, capture?, statut? } }] }
+- Codes : E_SCENARIO (scénario fautif, avant Chrome ; ou sélecteur CSS invalide, vu dans Chrome) · E_INTROUVABLE (absent après delaiMs) · E_INACTIF (caché, ou désactivé pour cliquer/saisir/choisir/cocher) · E_HTTP (document ≥ 400, ou page qui ne s'ouvre pas) · E_CHROME (absent, ne répond pas, perdu : les lignes suivantes « non tourné ») · E_FFMPEG (PNG gardés dans images/<code>/) · E_STRICT (avertissements en mode strict).
+
+## PIÈGES
+- La légende est COLLANTE : une étape sans `legende` garde celle d'avant (au départ : `titre`).
+- Aucune option pour poser un cookie ou un en-tête : l'application rend l'adresse filmable (banc, session ouverte par son propre mécanisme).
+- Filmer seulement un banc à DONNÉES FICTIVES : le film montre tout ce que la page affiche, et `saisir.valeur` est en clair dans le JSON.
+- `aller` accepte toute adresse http(s) : un scénario est une entrée de confiance, à relire comme du code.
+- `code` sert de nom de fichier (<code>.mp4, <code>-echec.png) : deux scénarios de même code s'écrasent.
+- En mode strict, les fichiers sont produits puis la ligne passe en échec E_STRICT.
+- `<code>-echec.png` est effacé quand la ligne réussit ensuite. Un dossier `.travail-*` vit dans <sortie> pendant la série.
+- Chrome introuvable : chaque ligne tente de nouveau et finit en E_CHROME. `trouverChrome` utilise `which` (Linux, macOS).
+- La CSP de la page n'est jamais levée (pas de Page.setBypassCSP) ; ses violations deviennent des avertissements.
+- La ligne de commande n'expose ni --chrome (utiliser CHROME=…), ni --ffmpeg, ni --formats.
+
+## EXEMPLE
+`node examples/run.mjs` : serveur sous CSP `script-src 'self'` ; EX-A1 filmé (7 images), EX-A2 en échec E_INTROUVABLE. `npm test` : T-GFM-1 à 10 + l'exemple.

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@mostajs/geste-film",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Filmer un geste d'utilisation d'une application web : un scénario déclaratif par ligne de formation, Chrome piloté sur tube DevTools (sans dépendance), pointeur et légende, MP4, GIF et affiche par ffmpeg ; un échec dit la ligne, l'étape, l'élément manquant et montre la page.",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "bin": {
+    "geste-film": "bin/geste-film.mjs"
+  },
+  "files": [
+    "src",
+    "bin",
+    "README.md",
+    "llms.txt",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "formation",
+    "tutoriel",
+    "gif",
+    "screencast",
+    "chrome-devtools-protocol",
+    "recette",
+    "mostajs"
+  ],
+  "scripts": {
+    "test": "node test-scripts/unit/geste-film.test.mjs && node test-scripts/integration/geste-film-chrome.test.mjs && node examples/run.mjs"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.13.1"
+  },
+  "mostajs": {
+    "niveau": "N1",
+    "nature": "outil",
+    "reutilisabilite": "multi-domaine",
+    "depend_de": [],
+    "programmes": [
+      "google-chrome|chromium",
+      "ffmpeg"
+    ]
+  }
+}

package/src/assemblage.js

@@ -0,0 +1,43 @@
+// @mostajs/geste-film — assembler les images en MP4 et GIF par ffmpeg ; l'affiche est la première image.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+import { spawn } from 'node:child_process';
+import { writeFileSync, copyFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+const lancer = (ffmpeg, args) => new Promise((resoudre, rejeter) => {
+  let err = '';
+  let p;
+  try { p = spawn(ffmpeg, args, { stdio: ['ignore', 'ignore', 'pipe'] }); } catch (e) { return rejeter(e); }
+  p.stderr.on('data', (d) => { err = (err + d).slice(-2000); });
+  p.once('error', rejeter);
+  p.once('close', (c) => (c === 0 ? resoudre() : rejeter(new Error(err.trim().split('\n').at(-1) || `ffmpeg code ${c}`))));
+});
+
+/**
+ * @param {{ images: {fichier:string,dureeMs:number}[], dossierImages: string, sortie: string, code: string, ffmpeg: string,
+ *   formats: string[], largeurFilm: number }} o → { mp4?, gif?, affiche } (chemins relatifs à `sortie`)
+ */
+export async function assembler({ images, dossierImages, sortie, code, ffmpeg = 'ffmpeg', formats = ['mp4', 'gif'], largeurFilm = 960 }) {
+  const affiche = `${code}.png`;
+  copyFileSync(images[0].fichier, join(sortie, affiche));
+  // Démultiplexeur « concat » : chaque image a sa durée ; la dernière est répétée (règle du démultiplexeur).
+  const liste = join(dossierImages, 'liste.txt');
+  writeFileSync(liste, images.map((i) => `file '${basename(i.fichier)}'\nduration ${(i.dureeMs / 1000).toFixed(3)}\n`).join('') + `file '${basename(images.at(-1).fichier)}'\n`);
+  const entree = ['-y', '-v', 'error', '-f', 'concat', '-safe', '0', '-i', liste];
+  const fichiers = { affiche };
+  try {
+    if (formats.includes('mp4')) {
+      fichiers.mp4 = `${code}.mp4`;
+      await lancer(ffmpeg, [...entree, '-vf', `fps=10,scale=${largeurFilm}:-2:flags=lanczos,format=yuv420p`, '-c:v', 'libx264', '-preset', 'slow',
+        '-tune', 'stillimage', '-crf', '28', '-movflags', '+faststart', '-an', join(sortie, fichiers.mp4)]);
+    }
+    if (formats.includes('gif')) {
+      fichiers.gif = `${code}.gif`;
+      await lancer(ffmpeg, [...entree, '-vf', `scale=${largeurFilm}:-1:flags=lanczos,split[a][b];[a]palettegen=max_colors=128:stats_mode=full[p];[b][p]paletteuse=dither=none`,
+        '-vsync', 'vfr', '-loop', '0', join(sortie, fichiers.gif)]);
+    }
+  } catch (e) {
+    throw Object.assign(new Error(e.code === 'ENOENT' ? `ffmpeg introuvable (${ffmpeg})` : `ffmpeg : ${e.message}`), { code: 'E_FFMPEG' });
+  }
+  return fichiers;
+}

package/src/cdp.js

@@ -0,0 +1,59 @@
+// @mostajs/geste-film — client du protocole DevTools de Chrome sur TUBE (--remote-debugging-pipe) :
+// messages JSON séparés par NUL ; ni WebSocket, ni dépendance.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+
+/**
+ * @param {{ entree: import('node:stream').Readable, sortie: import('node:stream').Writable }} o
+ *   entree : ce que Chrome écrit (fd 4) ; sortie : ce que Chrome lit (fd 3).
+ */
+export function creerClientCdp({ entree, sortie }) {
+  let suivant = 1, tampon = '', ferme = false;
+  const attente = new Map();
+  const abonnes = new Map();
+
+  const fermer = (motif = 'tube DevTools fermé') => {
+    if (ferme) return;
+    ferme = true;
+    for (const { rejeter, method } of attente.values()) rejeter(new Error(`${method} : ${motif}`));
+    attente.clear();
+  };
+
+  entree.on('data', (morceau) => {
+    tampon += morceau.toString('utf8');
+    let i;
+    while ((i = tampon.indexOf('\0')) >= 0) {
+      const brut = tampon.slice(0, i); tampon = tampon.slice(i + 1);
+      let m; try { m = JSON.parse(brut); } catch { continue; }
+      if (m.id != null && attente.has(m.id)) {
+        const a = attente.get(m.id); attente.delete(m.id);
+        if (m.error) a.rejeter(Object.assign(new Error(`${a.method} : ${m.error.message}${m.error.data ? ` (${m.error.data})` : ''}`), { cdp: m.error }));
+        else a.resoudre(m.result || {});
+      } else if (m.method) {
+        for (const fn of abonnes.get(m.method) || []) { try { fn(m.params || {}, m.sessionId || null); } catch { /* un abonné fautif n'arrête pas le tube */ } }
+      }
+    }
+  });
+  entree.on('end', () => fermer());
+  entree.on('close', () => fermer());
+  entree.on('error', (e) => fermer(`tube DevTools fermé (${e.message})`));
+
+  return {
+    /** Envoie une commande ; → son résultat, ou une erreur qui nomme la commande. */
+    envoyer(method, params = {}, sessionId = null) {
+      if (ferme) return Promise.reject(new Error(`${method} : tube DevTools fermé`));
+      const id = suivant++;
+      return new Promise((resoudre, rejeter) => {
+        attente.set(id, { resoudre, rejeter, method });
+        sortie.write(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }) + '\0');
+      });
+    },
+    /** S'abonne à un événement ; → une fonction de désabonnement. */
+    sur(method, fn) {
+      if (!abonnes.has(method)) abonnes.set(method, new Set());
+      abonnes.get(method).add(fn);
+      return () => abonnes.get(method)?.delete(fn);
+    },
+    fermer,
+    get ferme() { return ferme; },
+  };
+}

package/src/chrome.js

@@ -0,0 +1,57 @@
+// @mostajs/geste-film — trouver et lancer Chrome sans écran, piloté sur tube.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+import { spawn, execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { creerClientCdp } from './cdp.js';
+
+const erreur = (code, message) => Object.assign(new Error(message), { code });
+
+/** Le chemin de Chrome : l'option, sinon CHROME, sinon google-chrome, chromium, chromium-browser. */
+export function trouverChrome(chemin) {
+  if (chemin) return chemin;
+  if (process.env.CHROME) return process.env.CHROME;
+  for (const c of ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser']) {
+    try { execFileSync('which', [c], { stdio: 'ignore' }); return c; } catch { /* suivant */ }
+  }
+  throw erreur('E_CHROME', 'Chrome introuvable : poser l’option chrome ou CHROME=/chemin');
+}
+
+/** Lance Chrome ; → { cdp, fermer, journal() } (journal : les dernières lignes d'erreur de Chrome). */
+export async function lancerChrome({ chrome, largeur = 960, hauteur = 600, regles = '' } = {}) {
+  const nav = trouverChrome(chrome);
+  const profil = mkdtempSync(join(tmpdir(), 'geste-film-chrome-'));
+  const args = ['--headless=new', '--remote-debugging-pipe', `--user-data-dir=${profil}`, '--no-first-run', '--no-default-browser-check',
+    '--hide-scrollbars', '--mute-audio', '--force-device-scale-factor=1', '--font-render-hinting=none', '--disable-lcd-text',
+    '--enable-unsafe-swiftshader', '--use-angle=swiftshader', '--disable-background-networking', '--disable-extensions',
+    '--disable-sync', '--metrics-recording-only', `--window-size=${largeur},${hauteur}`,
+    ...(regles ? [`--host-resolver-rules=${regles}`] : []), 'about:blank'];
+  const p = spawn(nav, args, { stdio: ['ignore', 'ignore', 'pipe', 'pipe', 'pipe'], detached: true });
+  const tuer = () => { try { process.kill(-p.pid, 'SIGKILL'); } catch { try { p.kill('SIGKILL'); } catch { /* déjà mort */ } } };
+  let journal = '';
+  p.stderr.on('data', (d) => { journal = (journal + d).slice(-4000); });
+  const demarre = new Promise((resoudre, rejeter) => {
+    p.once('error', (e) => rejeter(erreur('E_CHROME', `Chrome ne démarre pas (${nav}) : ${e.message}`)));
+    p.once('spawn', resoudre);
+  });
+  await demarre;
+  const cdp = creerClientCdp({ entree: p.stdio[4], sortie: p.stdio[3] });
+  p.once('exit', (c) => cdp.fermer(`Chrome s'est arrêté (code ${c})`));
+  try {
+    await Promise.race([cdp.envoyer('Browser.getVersion'), new Promise((_, r) => setTimeout(() => r(new Error('Chrome ne répond pas')), 30000))]);
+  } catch (e) {
+    tuer(); rmSync(profil, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    throw erreur('E_CHROME', `Chrome ne répond pas sur le tube DevTools : ${e.message}${journal ? ` — ${journal.trim().split('\n').at(-1)}` : ''}`);
+  }
+  const fermer = async () => {
+    // Fermeture propre, puis tout le groupe de processus de Chrome (ses enfants écrivent dans le profil jusqu'au bout).
+    const fini = p.exitCode != null || p.signalCode != null ? Promise.resolve() : new Promise((r) => p.once('exit', r));
+    cdp.envoyer('Browser.close').catch(() => null);
+    await Promise.race([fini, new Promise((r) => setTimeout(r, 5000))]);
+    tuer();
+    await new Promise((r) => setTimeout(r, 100));
+    try { rmSync(profil, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 }); } catch { /* profil temporaire : le système le videra */ }
+  };
+  return { cdp, fermer, journal: () => journal };
+}

package/src/index.js

@@ -0,0 +1,86 @@
+// @mostajs/geste-film — filmer un geste d'utilisation d'une application web : une ligne de formation = un film.
+// Plan : docs/03-PLAN-DEV-GESTE-FILM.md. Aucune dépendance : Chrome sur tube DevTools, ffmpeg.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync, statSync, readFileSync, renameSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { verifierScenario, empreinteScenario } from './scenario.js';
+import { lancerChrome } from './chrome.js';
+import { tournerScenario } from './tournage.js';
+import { assembler } from './assemblage.js';
+
+export { verifierScenario, empreinteScenario, actionDe, ACTIONS, FORMAT } from './scenario.js';
+export { trouverChrome } from './chrome.js';
+
+const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+export const FORMAT_BILAN = 'geste-film-bilan/1';
+const taille = (f) => { try { return statSync(f).size; } catch { return 0; } };
+
+/** La ligne de journal d'un film : « ✓ code (n images, x ko) » ou « ✗ code, étape n sur m (action « sélecteur ») : … ». */
+export function ligneJournal(f) {
+  if (f.statut === 'ok') return `✓ ${f.code} (${f.images} images, ${Math.round((f.octets.mp4 || f.octets.gif || 0) / 1024)} ko)`;
+  const e = f.erreur || {};
+  const ou = e.etape ? `, étape ${e.etape} sur ${e.etapes}` : '';
+  const quoi = e.action ? ` (${e.action}${e.selecteur ? ` « ${e.selecteur} »` : ''})` : '';
+  return `✗ ${f.code}${ou}${quoi} : ${e.message}${e.adresse && e.adresse !== 'about:blank' ? `\n  sur ${e.adresse}` : ''}${e.capture ? ` ; capture : ${e.capture}` : ''}`;
+}
+
+/**
+ * Tourne une série de scénarios dans UN Chrome. Un échec n'arrête que sa ligne (sauf Chrome perdu : E_CHROME).
+ * → le bilan `geste-film-bilan/1`, écrit aussi dans <sortie>/films.json.
+ */
+export async function tourner(scenarios, {
+  sortie = 'films', chrome, ffmpeg = 'ffmpeg', largeur = 960, hauteur = 600, largeurFilm = 960, regles = '', delaiMs = 5000,
+  formats = ['mp4', 'gif'], strict = false, garderImages = false, dureeImageMs = 1200, dureeFinMs = 2000, journal = () => {},
+} = {}) {
+  sortie = resolve(sortie);
+  mkdirSync(sortie, { recursive: true });
+  const bilan = { format: FORMAT_BILAN, date: new Date().toISOString(), outil: `@mostajs/geste-film@${VERSION}`, largeur, hauteur, films: [], echecs: 0 };
+  const travail = mkdtempSync(join(sortie, '.travail-'));
+  let nav = null, perdu = null;
+  try {
+    for (const s of scenarios) {
+      const code = typeof s?.code === 'string' ? s.code : '(sans code)';
+      const film = { code, titre: s?.titre || '', statut: 'ok', images: 0, dureeMs: 0, octets: {}, fichiers: {}, empreinte: s ? empreinteScenario(s) : null, avertissements: [] };
+      const etapes = Array.isArray(s?.etapes) ? s.etapes.length : 0;
+      const fautes = verifierScenario(s);
+      try {
+        if (fautes.length) throw Object.assign(new Error(`scénario fautif : ${fautes.join(' ; ')}`), { code: 'E_SCENARIO' });
+        if (perdu) throw Object.assign(new Error(`non tourné : ${perdu}`), { code: 'E_CHROME' });
+        if (!nav) { try { nav = await lancerChrome({ chrome, largeur, hauteur, regles }); } catch (e) { perdu = e.message; throw e; } }
+        const dossierImages = join(travail, code);
+        mkdirSync(dossierImages, { recursive: true });
+        let r;
+        try {
+          r = await tournerScenario(nav.cdp, s, { dossierImages, sortie, largeur, hauteur, delaiMs, dureeImageMs, dureeFinMs });
+        } catch (e) {
+          if (nav.cdp.ferme) { perdu = `Chrome perdu pendant ${code}`; e.code = 'E_CHROME'; }
+          film.avertissements = e.avertissements || [];
+          throw e;
+        }
+        film.avertissements = r.avertissements;
+        film.images = r.images.length;
+        film.dureeMs = r.images.reduce((t, i) => t + i.dureeMs, 0);
+        const garder = () => { const d = join(sortie, 'images', code); rmSync(d, { recursive: true, force: true }); mkdirSync(join(sortie, 'images'), { recursive: true }); renameSync(dossierImages, d); film.fichiers.images = join('images', code); };
+        try {
+          Object.assign(film.fichiers, await assembler({ images: r.images, dossierImages, sortie, code, ffmpeg, formats, largeurFilm }));
+        } catch (e) { garder(); film.fichiers.affiche = `${code}.png`; throw e; }
+        for (const k of ['mp4', 'gif', 'affiche']) if (film.fichiers[k]) film.octets[k] = taille(join(sortie, film.fichiers[k]));
+        if (garderImages) garder();
+        if (strict && film.avertissements.length) throw Object.assign(new Error(`${film.avertissements.length} avertissement(s) en mode strict`), { code: 'E_STRICT' });
+        rmSync(join(sortie, `${code}-echec.png`), { force: true });
+      } catch (e) {
+        film.statut = 'echec';
+        film.erreur = { code: e.code || 'E_CHROME', message: e.message, etapes, ...(e.plus || {}) };
+        bilan.echecs += 1;
+      }
+      bilan.films.push(film);
+      journal(ligneJournal(film));
+    }
+  } finally {
+    await nav?.fermer();
+    rmSync(travail, { recursive: true, force: true });
+  }
+  writeFileSync(join(sortie, 'films.json'), JSON.stringify(bilan, null, 2) + '\n');
+  journal(`bilan : ${bilan.films.length} film(s), ${bilan.echecs} échec(s)${bilan.echecs ? ` (${bilan.films.filter((f) => f.statut !== 'ok').map((f) => f.code).join(', ')})` : ''}`);
+  return bilan;
+}

package/src/page.js

@@ -0,0 +1,88 @@
+// @mostajs/geste-film — fonctions exécutées DANS la page (Runtime.evaluate). Autonomes : aucune variable globale.
+// Les marques sont construites par le CSSOM (element.style.x = …), que la CSP de la page n'interdit pas : la CSP
+// n'est jamais levée (pas de Page.setBypassCSP).
+// @author Dr Hamid MADANI <drmdh@msn.com>
+
+/** Trouve l'élément d'un sélecteur (CSS ou « texte=… ») ; selon `quoi`, agit dessus. → { etat, rect?, … } */
+export function agir(sel, quoi, valeur) {
+  const norm = (t) => String(t || '').replace(/[‘’ʼ]/g, "'").replace(/[«»"]/g, '').replace(/\s+/g, ' ').trim().toLowerCase();
+  const visible = (el) => {
+    const r = el.getBoundingClientRect(); const st = getComputedStyle(el);
+    return r.width > 0 && r.height > 0 && st.visibility !== 'hidden' && st.display !== 'none' && Number(st.opacity) !== 0;
+  };
+  let cands;
+  try {
+    if (sel.startsWith('texte=')) {
+      const t = norm(sel.slice(6));
+      const tous = [...document.querySelectorAll('body *')].filter((e) => !e.closest('[data-geste-film]') && !['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEMPLATE'].includes(e.tagName));
+      const txt = (e) => norm(e.tagName === 'INPUT' ? (e.value || e.getAttribute('aria-label') || '') : (e.textContent || ''));
+      let liste = tous.filter((e) => txt(e) === t);
+      if (!liste.length) liste = tous.filter((e) => txt(e).includes(t));
+      cands = liste.filter((e) => !liste.some((o) => o !== e && e.contains(o)));
+    } else cands = [...document.querySelectorAll(sel)];
+  } catch (e) { return { etat: 'invalide', message: String(e.message || e) }; }
+  if (!cands.length) return { etat: 'absent' };
+  let el = cands.find(visible) || cands[0];
+  if (quoi === 'choisir' && el.tagName === 'INPUT' && el.type === 'radio') {
+    const r = [...document.querySelectorAll(`input[type=radio][name="${CSS.escape(el.name)}"]`)].find((x) => x.value === String(valeur));
+    if (!r) return { etat: 'absent', message: `aucune option « ${valeur} »` };
+    el = r.labels?.[0] && visible(r.labels[0]) ? r.labels[0] : r;
+  }
+  if (!visible(el)) return { etat: 'cache' };
+  const champ = el.closest('label')?.control || el;
+  const inactif = el.disabled || champ.disabled || el.getAttribute('aria-disabled') === 'true' || Boolean(el.closest('fieldset[disabled]'));
+  el.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
+  const b = el.getBoundingClientRect();
+  const rect = { x: b.left, y: b.top, w: b.width, h: b.height };
+  if (quoi !== 'montrer' && quoi !== 'attendre' && quoi !== 'defiler' && inactif) return { etat: 'inactif', rect };
+  if (quoi === 'vider') { champ.focus(); if (typeof champ.select === 'function') champ.select(); return { etat: 'ok', rect }; }
+  if (quoi === 'choisir' && champ.tagName === 'SELECT') {
+    const o = [...champ.options].find((x) => x.value === String(valeur) || norm(x.textContent) === norm(valeur));
+    if (!o) return { etat: 'absent', message: `aucune option « ${valeur} »` };
+    champ.value = o.value;
+    champ.dispatchEvent(new Event('input', { bubbles: true })); champ.dispatchEvent(new Event('change', { bubbles: true }));
+    return { etat: 'ok', rect, fait: true };
+  }
+  if (quoi === 'cocher') return { etat: 'ok', rect, coche: Boolean(champ.checked) };
+  return { etat: 'ok', rect };
+}
+
+/** Pose les marques du film : rond sur l'élément, cadre, bandeau de légende, code en coin. */
+export function marquer({ rect, rond, cadre, legende, code }) {
+  const css = (el, s) => { for (const [k, v] of Object.entries(s)) el.style[k] = v; return el; };
+  const div = () => { const d = document.createElement('div'); d.setAttribute('data-geste-film', ''); return d; };
+  document.querySelectorAll('[data-geste-film]').forEach((e) => e.remove());
+  document.documentElement.style.caretColor = 'transparent';
+  const racine = css(div(), { position: 'fixed', left: '0', top: '0', right: '0', bottom: '0', pointerEvents: 'none', zIndex: '2147483647' });
+  if (rect && cadre) racine.append(css(div(), { position: 'fixed', left: `${rect.x - 5}px`, top: `${rect.y - 5}px`, width: `${rect.w + 10}px`, height: `${rect.h + 10}px`, border: '3px solid #E0262B', borderRadius: '8px', boxSizing: 'border-box' }));
+  if (rect && rond) racine.append(css(div(), { position: 'fixed', left: `${rect.x + rect.w / 2 - 22}px`, top: `${rect.y + rect.h / 2 - 22}px`, width: '44px', height: '44px', border: '4px solid #E0262B', background: 'rgba(224,38,43,0.18)', borderRadius: '50%', boxSizing: 'border-box' }));
+  if (legende) {
+    const b = css(div(), { position: 'fixed', left: '0', right: '0', bottom: '0', padding: '10px 16px', background: 'rgba(19,40,66,0.9)', color: '#fff', font: '600 17px/1.35 system-ui, sans-serif', textAlign: 'center' });
+    b.textContent = legende; racine.append(b);
+  }
+  if (code) {
+    const c = css(div(), { position: 'fixed', top: '8px', right: '8px', padding: '3px 10px', background: '#0757CA', color: '#fff', font: '700 13px/1.4 system-ui, sans-serif', borderRadius: '999px' });
+    c.textContent = code; racine.append(c);
+  }
+  document.body.append(racine);
+  return true;
+}
+
+/** Retire les marques ; → le nombre de marques restées (0 attendu). */
+export function retirer() {
+  document.querySelectorAll('[data-geste-film]').forEach((e) => e.remove());
+  return document.querySelectorAll('[data-geste-film]').length;
+}
+
+/** Les violations de CSP relevées par l'écouteur posé avant chaque document ; vidées à la lecture. */
+export function violations() {
+  const v = window.__gesteFilmViolations || []; window.__gesteFilmViolations = []; return v;
+}
+
+/** Posé avant chaque document (Page.addScriptToEvaluateOnNewDocument). */
+export const ECOUTEUR = `document.addEventListener('securitypolicyviolation', (e) => {
+  (window.__gesteFilmViolations = window.__gesteFilmViolations || []).push({ directive: e.effectiveDirective || e.violatedDirective, bloque: String(e.blockedURI || ''), adresse: location.href });
+});`;
+
+/** L'expression qui appelle une fonction de page avec ses arguments (JSON). */
+export const appel = (fn, ...args) => `(${fn.toString()})(${args.map((a) => JSON.stringify(a ?? null)).join(',')})`;

package/src/scenario.js

@@ -0,0 +1,64 @@
+// @mostajs/geste-film — le scénario `geste-film/1` : validation avant tout tournage, empreinte.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+import { createHash } from 'node:crypto';
+
+export const FORMAT = 'geste-film/1';
+/** Les actions d'une étape. `legende` seule est aussi une étape (une image avec la légende). */
+export const ACTIONS = Object.freeze(['aller', 'cliquer', 'saisir', 'choisir', 'cocher', 'attendre', 'montrer', 'defiler']);
+const AVEC_VALEUR = new Set(['saisir', 'choisir']);
+const CODE = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*$/;
+const CLES = new Set([...ACTIONS, 'valeur', 'legende']);
+
+const adresseValide = (u, relative = false) => {
+  if (typeof u !== 'string' || !u.trim()) return false;
+  if (relative && u.startsWith('/') && !u.startsWith('//')) return true;
+  try { return ['http:', 'https:'].includes(new URL(u).protocol); } catch { return false; }
+};
+
+/** L'action d'une étape : son nom, ou 'legende' pour une étape qui n'a que sa légende, ou null. */
+export function actionDe(e) {
+  const a = ACTIONS.filter((k) => e && Object.hasOwn(e, k));
+  if (a.length === 1) return a[0];
+  if (!a.length && e && typeof e.legende === 'string') return 'legende';
+  return null;
+}
+
+/** → la liste des défauts du scénario, en clair ; vide s'il est juste. */
+export function verifierScenario(s) {
+  if (!s || typeof s !== 'object' || Array.isArray(s)) return ['le scénario doit être un objet JSON'];
+  const f = [];
+  if (s.format !== FORMAT) f.push(`format « ${s.format ?? '(absent)'} » : attendu « ${FORMAT} »`);
+  if (typeof s.code !== 'string' || !CODE.test(s.code)) f.push(`code « ${s.code ?? '(absent)'} » : lettres, chiffres et tirets seulement (ex. CFG-A4)`);
+  if (s.titre != null && typeof s.titre !== 'string') f.push('titre : texte attendu');
+  if (!adresseValide(s.adresse)) f.push(`adresse « ${s.adresse ?? '(absente)'} » : http:// ou https:// attendu`);
+  if (!Array.isArray(s.etapes) || !s.etapes.length) { f.push('aucune étape'); return f; }
+  s.etapes.forEach((e, i) => {
+    const n = `étape ${i + 1}`;
+    if (!e || typeof e !== 'object' || Array.isArray(e)) { f.push(`${n} : objet attendu`); return; }
+    const presentes = ACTIONS.filter((k) => Object.hasOwn(e, k));
+    if (presentes.length > 1) { f.push(`${n} : une seule action par étape (${presentes.join(', ')})`); return; }
+    const inconnues = Object.keys(e).filter((k) => !CLES.has(k));
+    if (inconnues.length) f.push(`${n} : action inconnue « ${inconnues.join(', ')} » (connues : ${ACTIONS.join(', ')}, legende)`);
+    const a = actionDe(e);
+    if (!a) { if (!inconnues.length) f.push(`${n} : aucune action`); return; }
+    if (e.legende != null && typeof e.legende !== 'string') f.push(`${n} : légende : texte attendu`);
+    if (a === 'legende') return;
+    const cible = e[a];
+    if (a === 'aller') { if (!adresseValide(cible, true)) f.push(`${n} : adresse « ${cible} » : absolue http(s) ou relative commençant par /`); return; }
+    if (typeof cible !== 'string' || !cible.trim() || cible.trim() === 'texte=') f.push(`${n} : sélecteur vide`);
+    if (AVEC_VALEUR.has(a) && (e.valeur == null || typeof e.valeur === 'object')) f.push(`${n} : « ${a} » demande une valeur`);
+    if (a === 'cocher' && e.valeur != null && typeof e.valeur !== 'boolean') f.push(`${n} : « cocher » : valeur true ou false`);
+  });
+  return f;
+}
+
+const canonique = (v) => {
+  if (Array.isArray(v)) return v.map(canonique);
+  if (v && typeof v === 'object') return Object.fromEntries(Object.keys(v).sort().map((k) => [k, canonique(v[k])]));
+  return typeof v === 'string' ? v.trim().replace(/\s+/g, ' ') : v;
+};
+
+/** SHA-256 du scénario normalisé (clés triées, espaces réduits) : dit si un film est à refaire. */
+export function empreinteScenario(s) {
+  return createHash('sha256').update(JSON.stringify(canonique(s))).digest('hex');
+}

package/src/tournage.js

@@ -0,0 +1,169 @@
+// @mostajs/geste-film — tourner UN scénario dans un onglet : étapes, marques, images, erreurs renseignées.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { actionDe } from './scenario.js';
+import { agir, marquer, retirer, violations, ECOUTEUR, appel } from './page.js';
+
+const pause = (ms) => new Promise((r) => setTimeout(r, ms));
+const echec = (code, message, plus = {}) => Object.assign(new Error(message), { code, plus });
+const MESSAGES = { absent: 'introuvable', cache: 'présent mais caché', inactif: 'présent mais désactivé', invalide: 'sélecteur invalide' };
+const CODES = { absent: 'E_INTROUVABLE', cache: 'E_INACTIF', inactif: 'E_INACTIF', invalide: 'E_SCENARIO' };
+
+/**
+ * @param {*} cdp client du tube
+ * @param {object} s scénario validé
+ * @param {{ dossierImages: string, sortie: string, largeur: number, hauteur: number, delaiMs: number, dureeImageMs: number, dureeFinMs: number }} o
+ * → { images: [{ fichier, dureeMs }], avertissements, adresse }
+ */
+export async function tournerScenario(cdp, s, o) {
+  const { targetId } = await cdp.envoyer('Target.createTarget', { url: 'about:blank' });
+  const { sessionId } = await cdp.envoyer('Target.attachToTarget', { targetId, flatten: true });
+  const env = (m, p) => cdp.envoyer(m, p, sessionId);
+  const desabonner = [];
+  const sur = (m, fn) => desabonner.push(cdp.sur(m, (p, sid) => { if (sid === sessionId) fn(p); }));
+  const avertissements = [];
+  const vus = new Set();
+  const avertir = (a) => { const k = JSON.stringify(a); if (!vus.has(k)) { vus.add(k); avertissements.push(a); } };
+  let cadre = null, enCours = false, statut = 0, adresse = 'about:blank';
+  const images = [];
+  let legende = s.titre || '';
+  let etape = 0;
+  try {
+    await env('Page.enable'); await env('Runtime.enable'); await env('Network.enable');
+    await env('Emulation.setDeviceMetricsOverride', { width: o.largeur, height: o.hauteur, deviceScaleFactor: 1, mobile: false });
+    await env('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-reduced-motion', value: 'reduce' }] });
+    await env('Page.addScriptToEvaluateOnNewDocument', { source: ECOUTEUR });
+    cadre = (await env('Page.getFrameTree')).frameTree.frame.id;
+    sur('Page.frameStartedLoading', (p) => { if (p.frameId === cadre) enCours = true; });
+    sur('Page.frameStoppedLoading', (p) => { if (p.frameId === cadre) enCours = false; });
+    sur('Network.responseReceived', (p) => { if (p.type === 'Document' && p.frameId === cadre) { statut = p.response.status; adresse = p.response.url; } });
+    sur('Runtime.exceptionThrown', (p) => avertir({ type: 'exception', message: p.exceptionDetails?.exception?.description?.split('\n')[0] || p.exceptionDetails?.text || 'exception' }));
+
+    const evaluer = async (expr) => {
+      const r = await env('Runtime.evaluate', { expression: expr, returnByValue: true, awaitPromise: true });
+      if (r.exceptionDetails) throw echec('E_CHROME', `évaluation dans la page : ${r.exceptionDetails.exception?.description || r.exceptionDetails.text}`);
+      return r.result.value;
+    };
+    const releverViolations = async () => {
+      for (const v of (await evaluer(appel(violations)).catch(() => [])) || []) avertir({ type: 'csp', directive: v.directive, bloque: v.bloque, adresse: v.adresse });
+    };
+    // La page se pose : chargement fini, polices prêtes. Puis le statut HTTP du document.
+    const poser = async () => {
+      await pause(150);
+      const fin = Date.now() + o.delaiMs * 3;
+      while (enCours && Date.now() < fin) await pause(50);
+      await evaluer('document.fonts ? document.fonts.ready.then(() => true) : true').catch(() => null);
+      await pause(60);
+      if (statut >= 400) throw echec('E_HTTP', `la page répond ${statut}`, { statut });
+    };
+    const aller = async (url) => {
+      const cible = new URL(url, adresse === 'about:blank' ? s.adresse : adresse).href;
+      enCours = true;
+      const r = await env('Page.navigate', { url: cible });
+      if (r.errorText) throw echec('E_HTTP', `la page ne s’ouvre pas : ${r.errorText}`, { statut: 0 });
+      adresse = cible;
+      await poser();
+    };
+    const prendre = async ({ rect = null, rond = false, cadre: encadre = false } = {}) => {
+      await evaluer(appel(marquer, { rect, rond, cadre: encadre, legende, code: s.code }));
+      const { data } = await env('Page.captureScreenshot', { format: 'png', captureBeyondViewport: false, fromSurface: true });
+      const reste = await evaluer(appel(retirer));
+      if (reste) avertir({ type: 'marques', message: `${reste} marque(s) restée(s) dans la page` });
+      const fichier = join(o.dossierImages, `${String(images.length + 1).padStart(3, '0')}.png`);
+      writeFileSync(fichier, Buffer.from(data, 'base64'));
+      images.push({ fichier, dureeMs: o.dureeImageMs });
+      await releverViolations();
+    };
+    // Attend l'élément jusqu'au délai ; l'erreur dit pourquoi il ne convient pas.
+    const reperer = async (sel, quoi = 'reperer', valeur = null) => {
+      const fin = Date.now() + o.delaiMs;
+      let r;
+      for (;;) {
+        r = await evaluer(appel(agir, sel, quoi, valeur));
+        if (r.etat === 'ok' || r.etat === 'invalide' || Date.now() >= fin) break;
+        await pause(100);
+      }
+      if (r.etat !== 'ok') {
+        const delai = r.etat === 'absent' ? ` après ${(o.delaiMs / 1000).toLocaleString('fr-FR')} s` : '';
+        throw echec(CODES[r.etat] || 'E_INTROUVABLE', `${MESSAGES[r.etat] || r.etat}${delai}${r.message ? ` (${r.message})` : ''}`);
+      }
+      await pause(40);
+      return (await evaluer(appel(agir, sel, 'reperer', valeur))).rect || r.rect;
+    };
+    const cliquerA = async (rect) => {
+      const x = rect.x + rect.w / 2, y = rect.y + rect.h / 2;
+      enCours = false;
+      await releverViolations();
+      await env('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+      await env('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+      await env('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+    };
+
+    await aller(s.adresse);
+    for (const e of s.etapes) {
+      etape += 1;
+      if (typeof e.legende === 'string') legende = e.legende;
+      const a = actionDe(e);
+      const sel = e[a];
+      try {
+        if (a === 'legende') await prendre();
+        else if (a === 'aller') { await aller(sel); await prendre(); }
+        else if (a === 'cliquer') {
+          const rect = await reperer(sel);
+          await prendre({ rect, rond: true, cadre: true });
+          await cliquerA(rect); await poser(); await prendre();
+        } else if (a === 'saisir') {
+          const rect = await reperer(sel);
+          await prendre({ rect, rond: true, cadre: true });
+          await reperer(sel, 'vider');
+          const t = String(e.valeur), m = Math.ceil(t.length / 2);
+          await env('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 });
+          await env('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 });
+          if (t.slice(0, m)) await env('Input.insertText', { text: t.slice(0, m) });
+          await prendre({ rect, cadre: true });
+          if (t.slice(m)) await env('Input.insertText', { text: t.slice(m) });
+          await prendre({ rect, cadre: true });
+        } else if (a === 'choisir') {
+          const rect = await reperer(sel, 'reperer', e.valeur);
+          await prendre({ rect, rond: true, cadre: true });
+          const r = await evaluer(appel(agir, sel, 'choisir', e.valeur));
+          if (r.etat !== 'ok') throw echec(CODES[r.etat] || 'E_INTROUVABLE', `${MESSAGES[r.etat] || r.etat}${r.message ? ` (${r.message})` : ''}`);
+          if (!r.fait) await cliquerA(r.rect);
+          await poser(); await prendre({ rect: r.rect, cadre: true });
+        } else if (a === 'cocher') {
+          const rect = await reperer(sel);
+          await prendre({ rect, rond: true, cadre: true });
+          const voulu = e.valeur == null ? true : e.valeur;
+          const r = await evaluer(appel(agir, sel, 'cocher'));
+          if (r.coche !== voulu) await cliquerA(rect);
+          await poser(); await prendre({ rect, cadre: true });
+        } else if (a === 'attendre' || a === 'montrer' || a === 'defiler') {
+          const rect = await reperer(sel, a);
+          await prendre(a === 'defiler' ? {} : { rect, cadre: true });
+        }
+      } catch (err) {
+        err.plus = { ...(err.plus || {}), etape, action: a, selecteur: typeof sel === 'string' ? sel : null };
+        throw err;
+      }
+    }
+    await releverViolations();
+    if (images.length) images.at(-1).dureeMs = o.dureeFinMs;
+    return { images, avertissements, adresse };
+  } catch (err) {
+    // Montrer la page telle que le robot l'a trouvée.
+    try {
+      await env('Runtime.evaluate', { expression: appel(retirer), returnByValue: true });
+      const { data } = await env('Page.captureScreenshot', { format: 'png' });
+      const capture = `${s.code}-echec.png`;
+      writeFileSync(join(o.sortie, capture), Buffer.from(data, 'base64'));
+      err.plus = { ...(err.plus || {}), capture };
+    } catch { /* l'onglet ne répond plus : pas de capture */ }
+    err.plus = { ...(err.plus || {}), adresse, etape: err.plus?.etape ?? etape };
+    err.images = images; err.avertissements = avertissements;
+    throw err;
+  } finally {
+    for (const d of desabonner) d();
+    await cdp.envoyer('Target.closeTarget', { targetId }).catch(() => null);
+  }
+}