@sylad/cadence 1.8.0 → 1.10.0

package/dist/ref/check.js

@@ -0,0 +1,338 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { RafError } from '../plan.js';
+/** Les onze types d'élément d'un inventaire (design §2), dans l'ordre du résumé. */
+export const TYPES = ['ecran', 'composant', 'etat', 'texte', 'jeton', 'table', 'gabarit', 'schema', 'lien', 'statut', 'silence'];
+const CONFIANCES = ['mesure', 'lu', 'incertain'];
+const CATEGORIES = ['couleur', 'taille_police', 'espacement', 'rayon', 'opacite'];
+const DIRECTIONS = ['de_vers', 'bidirectionnel'];
+const CONSTATS = ['confirme', 'precise', 'contredit'];
+/** Le vocabulaire fermé des rôles d'un `texte` et d'un `composant` : le rôle décide de l'identité et de la justesse d'un élément, donc il est écrit ici, une ligne par rôle (repris dans templates/inventaire.json et docs/ref.md). Fermée mais large : celle de la conception (titre, bouton, message_erreur…), celle du corpus et celle d'un écran réel. */
+export const ROLES = {
+    titre: "titre d'un document, d'une page ou d'une section",
+    'titre-panneau': "titre d'un panneau ou d'une fenêtre d'interface",
+    paragraphe: "phrase ou bloc de texte courant",
+    legende: "texte qui désigne une figure, un tableau ou une échelle de couleurs (« Figure 1 — … »)",
+    'etiquette-figure': "mot ou valeur écrit dans une figure (flèche, axe, courbe, seuil)",
+    exigence: "énoncé d'une exigence dans une liste d'exigences",
+    ligne: "ligne d'un relevé ou d'un formulaire, sans autre fonction",
+    message_erreur: "message qui signale une erreur ou un refus à l'utilisateur",
+    unite: "unité accolée à une valeur (kt, hPa, m)",
+    info_bulle: "texte court qui apparaît au survol ou au focus d'un élément",
+    bouton: "contrôle sur lequel on agit (composant), ou son libellé (texte)",
+    champ: "zone où l'on saisit une valeur (composant), ou son libellé (texte)",
+    case_a_cocher: "contrôle à deux états, coché ou non, indépendant des autres",
+    selecteur: "contrôle qui fait choisir une valeur dans une liste fermée (liste déroulante, boutons radio)",
+    onglet: "entrée d'une barre qui bascule entre des vues de même niveau",
+    menu: "liste d'actions ou de destinations qui s'ouvre depuis un contrôle",
+    liste: "suite d'éléments de même nature affichés les uns sous les autres",
+    panneau: "zone d'interface qui regroupe des contrôles (composant)",
+    carte: "zone d'affichage cartographique ou graphique (composant)",
+    icone: "pictogramme sans texte qui représente une action ou un objet",
+    badge: "pastille ou marque qui qualifie un élément (statut, compteur)",
+};
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isInt = (v, min) => typeof v === 'number' && Number.isInteger(v) && v >= min;
+const isText = (v) => typeof v === 'string' && v.trim() !== '';
+const isList = (v) => Array.isArray(v) && v.length > 0;
+const isPct = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 100;
+const zoneOk = (z) => isObj(z) && isInt(z.x, 0) && isInt(z.y, 0) && isInt(z.l, 1) && isInt(z.h, 1);
+/** Lit un fichier JSON ; absent, dossier, vide ou illisible (BOM compris) est une erreur d'usage (code 2), pas un écart. */
+export function readInventaire(path) {
+    if (!existsSync(path))
+        throw new RafError(`ref : fichier introuvable : ${path}`);
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch {
+        throw new RafError(`ref : ${path} n'est pas un fichier lisible`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (e) {
+        throw new RafError(`ref : ${path} n'est pas du JSON lisible : ${e.message.split('\n')[0]}`);
+    }
+}
+/** Valide un inventaire ou une lecture (schéma version 1) : une ligne par écart, « chemin : raison ». Forme seulement, jamais la justesse des mesures. */
+export function checkInventaire(root) {
+    if (!isObj(root))
+        return ['racine : un objet est attendu'];
+    const problems = [];
+    const bad = (path, reason) => problems.push(`${path} : ${reason}`);
+    if (root.version !== 1)
+        bad('version', '1 attendu');
+    if (root.genre !== 'inventaire' && root.genre !== 'lecture')
+        bad('genre', '« inventaire » ou « lecture » attendu');
+    const document = isObj(root.document) ? root.document : {};
+    const slug = document.slug;
+    if (typeof slug !== 'string' || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug))
+        bad('document.slug', 'kebab-case attendu');
+    if (typeof document.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(document.sha256))
+        bad('document.sha256', '64 caractères hexadécimaux minuscules attendus');
+    if (!isList(root.elements)) {
+        bad('elements', 'un tableau non vide est attendu');
+        return problems;
+    }
+    const elements = root.elements;
+    const typeOf = new Map();
+    const firstWith = new Map();
+    elements.forEach((e, i) => {
+        if (!isObj(e) || typeof e.id !== 'string')
+            return;
+        if (!firstWith.has(e.id)) {
+            firstWith.set(e.id, i);
+            if (typeof e.type === 'string')
+                typeOf.set(e.id, e.type);
+        }
+    });
+    elements.forEach((e, i) => {
+        const at = `elements[${i}]`;
+        if (!isObj(e))
+            return bad(`${at}.type`, "l'un des onze types attendu");
+        const type = typeof e.type === 'string' && TYPES.includes(e.type) ? e.type : undefined;
+        if (type === undefined)
+            bad(`${at}.type`, "l'un des onze types attendu");
+        checkId(e, i, type, typeof slug === 'string' ? slug : undefined, firstWith, bad);
+        const champ = (path) => bad(path, `champ du type ${type ?? 'inconnu'} manquant ou invalide`);
+        checkSource(e, at, type, bad, champ);
+        checkConfiance(e, at, root.genre === 'lecture', bad, champ);
+        if (type !== undefined)
+            checkFields(e, at, type, (field) => bad(`${at}.${field}`, `champ du type ${type} manquant ou invalide`), bad);
+    });
+    elements.forEach((e, i) => {
+        if (isObj(e))
+            checkRefs(e, `elements[${i}]`, typeOf, firstWith, bad);
+    });
+    return problems;
+}
+function checkId(e, i, type, slug, firstWith, bad) {
+    const at = `elements[${i}].id`;
+    const id = e.id;
+    // le slug attendu est celui de document tel quel : invalide, il donne un écart de plus, pas un masquage
+    const ok = typeof id === 'string' && (slug !== undefined && type !== undefined ? id.startsWith(`${slug}#${type}-`) && /^[1-9]\d*$/.test(id.slice(`${slug}#${type}-`.length)) : /^[^#]+#[a-z]+-[1-9]\d*$/.test(id));
+    if (!ok)
+        bad(at, '<slug>#<type>-<n> attendu');
+    const first = typeof id === 'string' ? firstWith.get(id) : undefined;
+    if (first !== undefined && first !== i)
+        bad(at, `déjà porté par elements[${first}]`);
+}
+function checkSource(e, at, type, bad, champ) {
+    const source = isObj(e.source) ? e.source : {};
+    if (!isInt(source.page, 1))
+        champ(`${at}.source.page`);
+    // seul un silence peut n'avoir pas de zone ; s'il en porte une, elle est validée
+    if (!(type === 'silence' && source.zone === undefined) && !zoneOk(source.zone))
+        bad(`${at}.source.zone`, 'x, y, l, h entiers attendus (l et h ≥ 1)');
+    if (e.citations !== undefined) {
+        if (!Array.isArray(e.citations))
+            return champ(`${at}.citations`);
+        e.citations.forEach((c, j) => {
+            const o = isObj(c) ? c : {};
+            if (!isInt(o.page, 1))
+                champ(`${at}.citations[${j}].page`);
+            if (!isInt(o.ligne, 1))
+                champ(`${at}.citations[${j}].ligne`);
+            if (!isText(o.extrait))
+                champ(`${at}.citations[${j}].extrait`);
+        });
+    }
+}
+function checkConfiance(e, at, lecture, bad, champ) {
+    const confiance = e.confiance;
+    if (typeof confiance !== 'string' || !CONFIANCES.includes(confiance))
+        bad(`${at}.confiance`, 'mesure, lu ou incertain attendu');
+    if (e.ocr !== undefined && typeof e.ocr !== 'boolean')
+        champ(`${at}.ocr`);
+    if (confiance === 'incertain') {
+        if (!isText(e.cause))
+            bad(`${at}.cause`, 'obligatoire pour un élément incertain');
+    }
+    else if (e.cause !== undefined && CONFIANCES.includes(confiance)) {
+        champ(`${at}.cause`);
+    }
+    if (lecture && e.ocr === true && confiance === 'lu')
+        bad(`${at}.confiance`, "un texte ocr n'est jamais lu dans une lecture");
+}
+/** Les champs propres au type : `fail(chemin)` écrit l'écart « champ du type … manquant ou invalide » ; `bad` sert aux raisons propres. */
+function checkFields(e, at, type, fail, bad) {
+    const need = (field, ok) => {
+        if (!ok)
+            fail(field);
+    };
+    const sub = (v) => (isObj(v) ? v : {});
+    switch (type) {
+        case 'ecran': {
+            need('largeur_reference', isInt(e.largeur_reference, 1));
+            if (!isList(e.zones))
+                return fail('zones');
+            e.zones.forEach((z, j) => {
+                const o = sub(z);
+                const p = `zones[${j}]`;
+                need(`${p}.nom`, isText(o.nom));
+                for (const k of ['x', 'y'])
+                    need(`${p}.${k}`, isInt(o[k], 0));
+                for (const k of ['l', 'h'])
+                    need(`${p}.${k}`, isInt(o[k], 1));
+                if (!isObj(o.pct))
+                    return fail(`${p}.pct`);
+                for (const k of ['x', 'y', 'l', 'h'])
+                    need(`${p}.pct.${k}`, isPct(o.pct[k]));
+            });
+            return;
+        }
+        case 'composant': {
+            need('role', isText(e.role));
+            checkRole(e, at, bad);
+            const position = sub(e.position);
+            const taille = sub(e.taille);
+            for (const k of ['x', 'y'])
+                need(`position.${k}`, isInt(position[k], 0));
+            for (const k of ['l', 'h'])
+                need(`taille.${k}`, isInt(taille[k], 1));
+            need('contenu', typeof e.contenu === 'string');
+            need('ecran', typeof e.ecran === 'string');
+            return;
+        }
+        case 'etat':
+            need('nom', isText(e.nom));
+            need('cible', typeof e.cible === 'string');
+            return;
+        case 'texte':
+            // un libellé recopié tel quel n'a ni blanc en tête ni blanc en fin (R33)
+            need('libelle', isText(e.libelle) && e.libelle === e.libelle.trim());
+            need('role', isText(e.role));
+            checkRole(e, at, bad);
+            return;
+        case 'jeton': {
+            need('categorie', typeof e.categorie === 'string' && CATEGORIES.includes(e.categorie));
+            need('valeur', isText(e.valeur) || (typeof e.valeur === 'number' && Number.isFinite(e.valeur)));
+            const point = e.point;
+            if (e.confiance === 'mesure' || point !== undefined) {
+                const carre = isObj(point) && isInt(point.x, 0) && isInt(point.y, 0);
+                need('point', carre && (point.l === undefined && point.h === undefined ? true : zoneOk(point)));
+            }
+            if (e.contraste !== undefined) {
+                const c = sub(e.contraste);
+                need('contraste.texte', isText(c.texte));
+                need('contraste.fond', isText(c.fond));
+                need('contraste.ratio', typeof c.ratio === 'number' && c.ratio >= 1 && c.ratio <= 21);
+            }
+            return;
+        }
+        case 'table': {
+            need('colonnes', isList(e.colonnes) && e.colonnes.every((c) => typeof c === 'string'));
+            if (!isList(e.lignes))
+                return fail('lignes');
+            const largeur = Array.isArray(e.colonnes) ? e.colonnes.length : -1;
+            e.lignes.forEach((l, j) => need(`lignes[${j}]`, Array.isArray(l) && l.length === largeur && l.every((c) => typeof c === 'string')));
+            return;
+        }
+        case 'gabarit': {
+            need('nom', isText(e.nom));
+            if (!isList(e.champs))
+                return fail('champs');
+            e.champs.forEach((c, j) => {
+                const o = sub(c);
+                const p = `champs[${j}]`;
+                need(`${p}.nom`, isText(o.nom));
+                need(`${p}.obligatoire`, typeof o.obligatoire === 'boolean');
+                need(`${p}.format`, isText(o.format));
+                const num = (v) => v === undefined || (typeof v === 'number' && Number.isFinite(v));
+                need(`${p}.min`, num(o.min) && !(typeof o.min === 'number' && typeof o.max === 'number' && o.min > o.max));
+                need(`${p}.max`, num(o.max));
+            });
+            return;
+        }
+        case 'schema': {
+            const ids = new Set();
+            if (!isList(e.noeuds))
+                fail('noeuds');
+            else
+                e.noeuds.forEach((n, j) => {
+                    const o = sub(n);
+                    need(`noeuds[${j}].id`, isText(o.id) && !ids.has(o.id));
+                    if (isText(o.id))
+                        ids.add(o.id);
+                    need(`noeuds[${j}].libelle`, isText(o.libelle));
+                });
+            if (!Array.isArray(e.flux))
+                return fail('flux');
+            e.flux.forEach((f, j) => {
+                const o = sub(f);
+                need(`flux[${j}].de`, typeof o.de === 'string');
+                need(`flux[${j}].vers`, typeof o.vers === 'string');
+                need(`flux[${j}].libelle`, isText(o.libelle));
+                need(`flux[${j}].direction`, typeof o.direction === 'string' && DIRECTIONS.includes(o.direction));
+            });
+            return;
+        }
+        case 'lien': {
+            need('figure', isText(e.figure));
+            if (!isObj(e.passage))
+                fail('passage');
+            else {
+                need('passage.page', isInt(e.passage.page, 1));
+                need('passage.ligne', isInt(e.passage.ligne, 1));
+                need('passage.extrait', isText(e.passage.extrait));
+            }
+            if (typeof e.constat !== 'string' || !CONSTATS.includes(e.constat))
+                return fail('constat');
+            if (e.constat === 'precise')
+                for (const k of ['lecture_ambigue', 'interpretation', 'raison'])
+                    need(k, isText(e[k]));
+            if (e.constat === 'contredit') {
+                need('enonces', Array.isArray(e.enonces) && e.enonces.length === 2 && e.enonces.every(isText));
+                if (e.interpretation !== undefined)
+                    bad(`${at}.interpretation`, 'un lien contredit ne tranche pas');
+            }
+            return;
+        }
+        case 'statut':
+            need('libelle', isText(e.libelle));
+            need('couvre', isList(e.couvre) && e.couvre.every((c) => typeof c === 'string'));
+            return;
+        case 'silence':
+            // rédigée en question : elle se termine par « ? » (R35)
+            need('question', isText(e.question) && e.question.trimEnd().endsWith('?'));
+            return;
+    }
+}
+/** Un rôle non vide hors de la liste est un écart de schéma, jamais une erreur de lecture mesurée plus tard. */
+function checkRole(e, at, bad) {
+    if (isText(e.role) && !Object.hasOwn(ROLES, e.role))
+        bad(`${at}.role`, `« ${e.role} » n'est pas un rôle de la liste : ${Object.keys(ROLES).join(', ')}`);
+}
+/** Les références d'un élément, résolues sur la liste complète des ids (R27) et sur les noeuds du schéma (R23). */
+function checkRefs(e, at, typeOf, ids, bad) {
+    const expect = (path, id, types) => {
+        if (typeof id === 'string' && !types.includes(typeOf.get(id) ?? ''))
+            bad(path, `${id} ne désigne aucun élément de type ${types.join(' ou ')}`);
+    };
+    if (e.type === 'composant')
+        expect(`${at}.ecran`, e.ecran, ['ecran']);
+    if (e.type === 'etat')
+        expect(`${at}.cible`, e.cible, ['composant', 'ecran']);
+    if (e.type === 'statut' && Array.isArray(e.couvre)) {
+        e.couvre.forEach((id, j) => {
+            if (typeof id === 'string' && !ids.has(id))
+                bad(`${at}.couvre[${j}]`, `${id} ne désigne aucun élément de type ${TYPES.slice(0, -1).join(', ')} ou ${TYPES[TYPES.length - 1]}`);
+        });
+    }
+    if (e.type === 'schema' && Array.isArray(e.noeuds) && Array.isArray(e.flux)) {
+        const noeuds = new Set(e.noeuds.map((n) => (isObj(n) ? n.id : undefined)));
+        e.flux.forEach((f, j) => {
+            if (!isObj(f))
+                return;
+            for (const k of ['de', 'vers'])
+                if (typeof f[k] === 'string' && !noeuds.has(f[k]))
+                    bad(`${at}.flux[${j}].${k}`, `${f[k]} ne désigne aucun élément de type noeud`);
+        });
+    }
+}
+/** « inventaire valide : N éléments (ecran: n, …) », les types présents dans l'ordre des onze ; le genre dit « inventaire » ou « lecture ». */
+export function summaryInventaire(root) {
+    const elements = root.elements;
+    const parts = TYPES.map((t) => [t, elements.filter((e) => e.type === t).length]).filter(([, n]) => n > 0).map(([t, n]) => `${t}: ${n}`);
+    return `${root.genre} valide : ${elements.length} éléments (${parts.join(', ')})`;
+}

package/dist/ref/command.js

@@ -0,0 +1,92 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { RafError } from '../plan.js';
+import { AGENTS_DIR } from '../skills.js';
+import { realClaude, readAgents } from '../orchestrate/launch.js';
+import { add } from './add.js';
+import { analyse } from './analyse.js';
+import { checkInventaire, readInventaire, summaryInventaire } from './check.js';
+import { buildCorpus } from './corpus.js';
+import { diffLectures } from './diff.js';
+import { chargerPlaywright, lancer, rendre } from './corpus-render.js';
+import { evaluer, formatEvaluation } from './evaluate.js';
+import { measure } from './measure.js';
+import { referencesDir } from './store.js';
+const USAGE_ADD = 'usage : cadence ref add <document.pdf> [--sections 3-5,9] [--slug nom]';
+const USAGE_ANALYSE = 'usage : cadence ref analyse <document.pdf> [--sections 3-5,9] [--slug nom] [--model sonnet|opus|haiku] [--model-b sonnet|opus|haiku] [--seuil 30] [--double]';
+const USAGE_CHECK = 'usage : cadence ref check <inventaire.json | lecture.json>';
+const USAGE_DIFF = 'usage : cadence ref diff <lecture-a.json> <lecture-b.json> [--out inventaire.json] [--seuil 30]';
+const USAGE_EVAL = 'usage : cadence ref eval <attendu.json | dossier> <lecture.json | dossier> [--json]';
+const USAGE_CORPUS = 'usage : cadence ref corpus <dossier> [--sans-rendu]';
+const USAGE_MEASURE = 'usage : cadence ref measure <slug> <page> <page | x,y | x,y,l,h> [--quoi couleurs|contraste|boites|texte] [--largeur 1440] [--json]';
+/** `cadence ref <sous-verbe> …` : les documents de référence (issue #14) ; `check` valide un inventaire ou une lecture. */
+export function refCommand(rest, values, root, io) {
+    const [verb, ...args] = rest;
+    const configPath = resolve(io.cwd, values.config ?? join(root, 'cadence.yaml'));
+    const refsDir = () => referencesDir(root, configPath, io.env);
+    if (verb === 'add' && args.length === 1) {
+        add({ document: args[0], slug: values.slug, sections: values.sections, env: io.env, cwd: io.cwd, refsDir, now: io.now(), out: io.out });
+        return 0;
+    }
+    if (verb === 'analyse' && args.length === 1) {
+        const claude = realClaude(io.env.CADENCE_CLAUDE_BIN || 'claude', io.env);
+        return analyse({ document: args[0], slug: values.slug, sections: values.sections, model: values.model, modelB: values['model-b'], double: values.double === true, seuil: values.seuil, env: io.env, cwd: io.cwd, refsDir, configPath, claudeHome: io.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), now: io.now(), out: io.out, err: io.err, claude, agents: readAgents(AGENTS_DIR) });
+    }
+    if (verb === 'measure' && args.length === 3) {
+        measure({ slug: args[0], page: args[1], zone: args[2], quoi: values.quoi, largeur: values.largeur, env: io.env, refsDir, json: values.json === true, out: io.out });
+        return 0;
+    }
+    if (verb === 'check' && args.length === 1) {
+        // pas d'outil système ni de references.dir : seul le fichier donné est lu (R30)
+        const inventaire = readInventaire(resolve(io.cwd, args[0]));
+        const problems = checkInventaire(inventaire);
+        for (const m of problems)
+            io.out(`✗ ${m}`);
+        if (problems.length > 0) {
+            io.out(`${problems.length} écart(s)`);
+            return 1;
+        }
+        io.out(summaryInventaire(inventaire));
+        return 0;
+    }
+    if (verb === 'diff' && args.length === 2) {
+        return diffLectures({ a: resolve(io.cwd, args[0]), b: resolve(io.cwd, args[1]), seuil: values.seuil, out: values.out === undefined ? undefined : resolve(io.cwd, values.out), log: io.out });
+    }
+    if (verb === 'eval' && args.length === 2) {
+        const ev = evaluer(resolve(io.cwd, args[0]), resolve(io.cwd, args[1]));
+        if (values.json === true)
+            io.out(JSON.stringify(ev, null, 2));
+        else
+            for (const l of formatEvaluation(ev))
+                io.out(l);
+        return 0;
+    }
+    if (verb === 'corpus' && args.length === 1)
+        return corpus(resolve(io.cwd, args[0]), values['sans-rendu'] === true, io);
+    const others = (u) => u.replace('usage : ', '');
+    throw new RafError(verb === 'add' ? USAGE_ADD : verb === 'analyse' ? USAGE_ANALYSE : verb === 'measure' ? USAGE_MEASURE : verb === 'check' ? USAGE_CHECK : verb === 'diff' ? USAGE_DIFF : verb === 'eval' ? USAGE_EVAL : verb === 'corpus' ? USAGE_CORPUS : `${USAGE_ADD}\n       ${others(USAGE_ANALYSE)}\n       ${others(USAGE_MEASURE)}\n       ${others(USAGE_CHECK)}\n       ${others(USAGE_DIFF)}\n       ${others(USAGE_EVAL)}\n       ${others(USAGE_CORPUS)}`);
+}
+/** `ref corpus <dossier>` : un sous-dossier par piège (document.html, attendu.json, puis document.pdf et page-<n>.png sauf --sans-rendu). */
+async function corpus(dossier, sansRendu, io) {
+    if (existsSync(dossier))
+        throw new RafError(`ref corpus : ${dossier} existe déjà (un corpus n'est jamais mêlé à un autre : choisissez un dossier neuf)`);
+    const navigateur = sansRendu ? null : await lancer(chargerPlaywright(io.env, io.cwd));
+    const cas = buildCorpus();
+    for (const c of cas) {
+        mkdirSync(join(dossier, c.nom), { recursive: true });
+        writeFileSync(join(dossier, c.nom, 'document.html'), c.html);
+        writeFileSync(join(dossier, c.nom, 'attendu.json'), `${JSON.stringify(c.inventaire, null, 2)}\n`);
+    }
+    if (navigateur) {
+        await rendre(navigateur, dossier, cas);
+        // `ref add` empreint le PDF, qui change à chaque rendu : l'attendu porte celle du PDF écrit
+        for (const c of cas) {
+            c.inventaire.document.sha256 = createHash('sha256').update(readFileSync(join(dossier, c.nom, 'document.pdf'))).digest('hex');
+            writeFileSync(join(dossier, c.nom, 'attendu.json'), `${JSON.stringify(c.inventaire, null, 2)}\n`);
+        }
+    }
+    io.out(`corpus : ${cas.length} cas, ${cas.reduce((n, c) => n + c.pages, 0)} pages, ${cas.reduce((n, c) => n + c.inventaire.elements.length, 0)} éléments attendus dans ${dossier}${sansRendu ? ' (sans rendu : ni PDF ni PNG)' : ''}`);
+    return 0;
+}

package/dist/ref/corpus-render.js

@@ -0,0 +1,83 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { RafError } from '../plan.js';
+/** 816×1056 px CSS = 8,5×11 in ; à 200 dpi, 1700×2200 px : le repère des zones de l'inventaire. */
+const ECHELLE = 200 / 96;
+const BRUIT = `<svg style="position:absolute" width="0" height="0"><filter id="bruit" x="0" y="0" width="100%" height="100%">
+<feTurbulence type="fractalNoise" baseFrequency="0.9" numOctaves="2" seed="7" result="t"/>
+<feColorMatrix in="t" type="matrix" values="0 0 0 0 .25  0 0 0 0 .25  0 0 0 0 .25  1.2 0 0 0 -.38" result="grain"/>
+<feMerge><feMergeNode in="SourceGraphic"/><feMergeNode in="grain"/></feMerge></filter></svg>`;
+/** Playwright, d'où `CADENCE_PLAYWRIGHT` (dossier du paquet) le désigne, sinon depuis le dossier courant : le dépôt n'en dépend pas. */
+export function chargerPlaywright(env, cwd) {
+    const aide = 'installez-le (npm i -D playwright, puis npx playwright install chromium) ou pointez CADENCE_PLAYWRIGHT vers le dossier du paquet playwright, ou ajoutez --sans-rendu';
+    const cible = env.CADENCE_PLAYWRIGHT;
+    try {
+        return createRequire(join(cwd, 'noop.js'))(cible ?? 'playwright');
+    }
+    catch {
+        throw new RafError(cible ? `ref corpus : CADENCE_PLAYWRIGHT (${cible}) ne désigne pas un paquet playwright lisible : ${aide}` : `ref corpus : Playwright est introuvable : ${aide}`);
+    }
+}
+/** Lance Chromium : un navigateur absent ou d'une autre version est un refus, avant que le moindre fichier soit écrit. */
+export async function lancer(playwright) {
+    try {
+        return await playwright.chromium.launch();
+    }
+    catch (e) {
+        throw new RafError(`ref corpus : Chromium ne se lance pas (${e.message.split('\n')[0]}) : installez-le avec npx playwright install chromium, ou ajoutez --sans-rendu`);
+    }
+}
+/** Rend chaque cas dans `<dossier>/<nom>/` (le HTML et l'attendu y sont déjà), puis ferme le navigateur. */
+export async function rendre(navigateur, dossier, cas) {
+    try {
+        for (const c of cas)
+            await rendreCas(navigateur, join(dossier, c.nom), c);
+    }
+    finally {
+        await navigateur.close();
+    }
+}
+/** Écrit `document.pdf` et `page-<n>.png` (1700×2200) d'un cas : tables en image rastérisées, scan rastérisé puis bruité. */
+async function rendreCas(navigateur, dossier, cas) {
+    const contexte = await navigateur.newContext({ viewport: { width: 816, height: 1056 }, deviceScaleFactor: ECHELLE });
+    try {
+        const page = await contexte.newPage();
+        await page.setContent(cas.html);
+        for (const el of await page.locator('.raster').all()) {
+            const src = `data:image/png;base64,${(await el.screenshot()).toString('base64')}`;
+            await el.evaluate((n, s) => {
+                const r = n.getBoundingClientRect();
+                n.outerHTML = `<img src="${s}" style="display:block;width:${r.width}px;height:${r.height}px">`;
+            }, src);
+        }
+        if (cas.scan) {
+            await page.evaluate((bruit) => {
+                document.body.insertAdjacentHTML('afterbegin', bruit);
+                document.querySelectorAll('.page').forEach((p) => {
+                    p.innerHTML = `<div style="position:relative;width:816px;height:1056px;transform:rotate(0.6deg)">${p.innerHTML}</div>`;
+                    p.style.filter = 'url(#bruit) grayscale(1) blur(0.6px) contrast(1.15)';
+                });
+            }, BRUIT);
+        }
+        const sections = page.locator('.page');
+        const prises = [];
+        for (let i = 0; i < cas.pages; i++)
+            prises.push(await sections.nth(i).screenshot());
+        if (cas.scan) {
+            // le PDF d'un scan ne porte que l'image de chaque page, jamais la couche texte
+            await page.evaluate((images) => {
+                document.querySelectorAll('.page').forEach((p, i) => {
+                    p.style.cssText = '';
+                    p.innerHTML = `<img src="${images[i]}" style="display:block;width:816px;height:1056px">`;
+                });
+            }, prises.map((b) => `data:image/png;base64,${b.toString('base64')}`));
+        }
+        mkdirSync(dossier, { recursive: true });
+        prises.forEach((b, i) => writeFileSync(join(dossier, `page-${i + 1}.png`), b));
+        writeFileSync(join(dossier, 'document.pdf'), await page.pdf({ width: '8.5in', height: '11in', printBackground: true, margin: { top: '0', right: '0', bottom: '0', left: '0' } }));
+    }
+    finally {
+        await contexte.close();
+    }
+}