@sylad/cadence 1.8.0 → 1.9.0

package/dist/ref/corpus.js

@@ -0,0 +1,201 @@
+import { createHash } from 'node:crypto';
+/** Pixels CSS (96 dpi) → pixels de la page rendue à 200 dpi : le repère des zones d'un inventaire. */
+const K = 200 / 96;
+const zone = (b) => ({ x: Math.round(b.x * K), y: Math.round(b.y * K), l: Math.round(b.l * K), h: Math.round(b.h * K) });
+const CSS = `@page{size:8.5in 11in;margin:0}html,body{margin:0}
+.page{position:relative;width:816px;height:1056px;overflow:hidden;background:#fff;font-family:Arial,Helvetica,sans-serif;color:#111;page-break-after:always}
+.page:last-child{page-break-after:auto}.b{position:absolute;box-sizing:border-box}
+h1{margin:0;font-size:28px}p{margin:0;font-size:16px}table{border-collapse:collapse;font-size:15px}td,th{border:1px solid #333;padding:6px 10px;text-align:left}th{background:#e6e6e6}`;
+const bloc = (b, contenu, style = '') => `<div class="b" style="left:${b.x}px;top:${b.y}px;width:${b.l}px;height:${b.h}px;${style}">${contenu}</div>`;
+const assemble = (titre, pages) => `<!doctype html>\n<html lang="en"><head><meta charset="utf-8"><title>${titre}</title><style>${CSS}</style></head><body>\n${pages.map((p) => `<section class="page">\n${p}\n</section>`).join('\n')}\n</body></html>\n`;
+/** Construit l'inventaire d'un cas : ids `corpus-<nom>#<type>-<n>` numérotés par type, zones en repère 200 dpi. */
+class Inventaire {
+    nom;
+    n = new Map();
+    elements = [];
+    constructor(nom) {
+        this.nom = nom;
+    }
+    add(type, page, boite, champs, piege = false) {
+        const k = (this.n.get(type) ?? 0) + 1;
+        this.n.set(type, k);
+        const id = `corpus-${this.nom}#${type}-${k}`;
+        this.elements.push({ type, id, confiance: 'lu', source: boite ? { page, zone: zone(boite) } : { page }, ...champs, ...(piege ? { piege: this.nom } : {}) });
+        return id;
+    }
+    texte(page, boite, libelle, role, extra = {}, piege = false) {
+        return this.add('texte', page, boite, { libelle, role, ...extra }, piege);
+    }
+    /** Écran à la largeur de référence 1440 : la zone « page » couvre toute la page. */
+    ecran(page) {
+        return this.add('ecran', page, { x: 0, y: 0, l: 816, h: 1056 }, { largeur_reference: 1440, zones: [{ nom: 'page', x: 0, y: 0, l: 1440, h: 1863, pct: { x: 0, y: 0, l: 100, h: 100 } }] });
+    }
+}
+function fini(nom, titre, pages, inv, scan = false) {
+    const html = assemble(titre, pages);
+    const inventaire = {
+        version: 1,
+        genre: 'inventaire',
+        document: { slug: `corpus-${nom}`, sha256: createHash('sha256').update(html).digest('hex') },
+        pages: pages.length,
+        elements: inv.elements,
+    };
+    return { nom, html, pages: pages.length, scan, inventaire };
+}
+const TITRE = { x: 60, y: 50, l: 696, h: 40 };
+const PARA = { x: 60, y: 110, l: 696, h: 24 };
+const FIGURE = { x: 60, y: 170, l: 696, h: 300 };
+const LEGENDE = { x: 60, y: 482, l: 696, h: 24 };
+/** Texte ambigu que seule la figure lève : « à côté de la flèche » (tête ou queue ?) ; la figure met l'étiquette à la queue. */
+function texteAmbigu() {
+    const nom = 'texte-ambigu-leve-par-figure';
+    const inv = new Inventaire(nom);
+    const legende = 'Figure 1 — Jet arrow with its speed label';
+    const phrase = 'Wind speed is written beside the arrow, in knots (Figure 1).';
+    const svg = `<svg width="696" height="300" viewBox="0 0 696 300" xmlns="http://www.w3.org/2000/svg" font-family="Arial,Helvetica,sans-serif">
+<defs><marker id="t" markerWidth="12" markerHeight="12" refX="10" refY="6" orient="auto"><path d="M0,0 L12,6 L0,12 z" fill="#111"/></marker></defs>
+<line x1="90" y1="160" x2="600" y2="160" stroke="#111" stroke-width="6" marker-end="url(#t)"/>
+<text x="90" y="125" font-size="26" font-weight="bold">120 KT</text><text x="90" y="205" font-size="16">tail</text><text x="560" y="205" font-size="16">head</text></svg>`;
+    inv.texte(1, TITRE, 'Jet arrow annotation', 'titre');
+    inv.texte(1, PARA, phrase, 'paragraphe');
+    inv.texte(1, { x: 150, y: 270, l: 90, h: 34 }, '120 KT', 'etiquette-figure');
+    inv.texte(1, { x: 148, y: 358, l: 26, h: 24 }, 'tail', 'etiquette-figure');
+    inv.texte(1, { x: 618, y: 358, l: 40, h: 24 }, 'head', 'etiquette-figure');
+    inv.texte(1, LEGENDE, legende, 'legende');
+    inv.add('lien', 1, FIGURE, {
+        figure: legende,
+        passage: { page: 1, ligne: 2, extrait: 'Wind speed is written beside the arrow' },
+        constat: 'precise',
+        lecture_ambigue: 'À côté de la flèche : à la tête ou à la queue ?',
+        interpretation: "L'étiquette de vitesse se place au-dessus de la queue de la flèche",
+        raison: 'Dans la Figure 1, « 120 KT » est écrit au-dessus de la queue (tail), pas de la tête (head)',
+    }, true);
+    return fini(nom, 'Jet arrow annotation', [bloc(TITRE, '<h1>Jet arrow annotation</h1>') + bloc(PARA, `<p>${phrase}</p>`) + bloc(FIGURE, svg) + bloc(LEGENDE, `<p>${legende}</p>`)], inv);
+}
+/** Figure qui contredit le texte : le texte donne 80 kt, la figure trace le seuil à 100 kt. */
+function figureContredit() {
+    const nom = 'figure-contredit-texte';
+    const inv = new Inventaire(nom);
+    const legende = 'Figure 1 — Reporting threshold';
+    const phrase = 'Turbulence is reported above 80 kt of jet speed (Figure 1).';
+    const svg = `<svg width="696" height="300" viewBox="0 0 696 300" xmlns="http://www.w3.org/2000/svg" font-family="Arial,Helvetica,sans-serif">
+<rect x="90" y="190" width="420" height="60" fill="#9bb7d4"/><rect x="90" y="110" width="420" height="4" fill="#c0392b"/>
+<text x="520" y="120" font-size="22" font-weight="bold">100 kt</text><text x="90" y="280" font-size="18">Jet speed</text></svg>`;
+    inv.texte(1, TITRE, 'Turbulence reporting', 'titre');
+    inv.texte(1, PARA, phrase, 'paragraphe');
+    inv.texte(1, { x: 578, y: 268, l: 68, h: 30 }, '100 kt', 'etiquette-figure');
+    inv.texte(1, { x: 148, y: 432, l: 84, h: 26 }, 'Jet speed', 'etiquette-figure');
+    inv.texte(1, LEGENDE, legende, 'legende');
+    inv.add('lien', 1, FIGURE, {
+        figure: legende,
+        passage: { page: 1, ligne: 2, extrait: 'Turbulence is reported above 80 kt' },
+        constat: 'contredit',
+        enonces: ['Texte : la turbulence est signalée au-dessus de 80 kt', 'Figure 1 : le seuil est tracé à 100 kt'],
+    }, true);
+    return fini(nom, 'Turbulence reporting', [bloc(TITRE, '<h1>Turbulence reporting</h1>') + bloc(PARA, `<p>${phrase}</p>`) + bloc(FIGURE, svg) + bloc(LEGENDE, `<p>${legende}</p>`)], inv);
+}
+/** Table en image : dessinée en HTML puis rastérisée au rendu, absente de la couche texte du PDF. */
+function tableEnImage() {
+    const nom = 'table-en-image';
+    const inv = new Inventaire(nom);
+    const colonnes = ['Code', 'Meaning', 'Oktas'];
+    const lignes = [['0', 'Clear', '0'], ['1', 'Few', '1-2'], ['3', 'Scattered', '3-4'], ['5', 'Broken', '5-7'], ['8', 'Overcast', '8']];
+    const legende = 'Table 1 — Cloud amount';
+    const phrase = 'The codes are listed in Table 1.';
+    const zoneTable = { x: 60, y: 190, l: 400, h: 230 };
+    const html = `<table class="raster"><tr>${colonnes.map((c) => `<th>${c}</th>`).join('')}</tr>${lignes.map((l) => `<tr>${l.map((c) => `<td>${c}</td>`).join('')}</tr>`).join('')}</table>`;
+    inv.texte(1, TITRE, 'Cloud amount codes', 'titre');
+    inv.texte(1, PARA, phrase, 'paragraphe');
+    inv.texte(1, { x: 60, y: 156, l: 300, h: 24 }, legende, 'legende');
+    inv.add('table', 1, zoneTable, { colonnes, lignes }, true);
+    return fini(nom, 'Cloud amount codes', [bloc(TITRE, '<h1>Cloud amount codes</h1>') + bloc(PARA, `<p>${phrase}</p>`) + bloc({ x: 60, y: 156, l: 300, h: 24 }, `<p>${legende}</p>`) + bloc(zoneTable, html)], inv);
+}
+/** Gabarit de type BUFR (section 1) : champs ordonnés, obligatoires ou facultatifs, format et bornes. */
+function gabaritBufr() {
+    const nom = 'gabarit-type-bufr';
+    const inv = new Inventaire(nom);
+    const champs = [
+        { octets: '1-3', nom: 'Length of section', format: 'uint24', statut: 'Mandatory', min: 0, max: 16777215 },
+        { octets: '4', nom: 'Master table', format: 'uint8', statut: 'Mandatory', min: 0, max: 255 },
+        { octets: '5-6', nom: 'Originating centre', format: 'uint16', statut: 'Mandatory', min: 0, max: 65535 },
+        { octets: '7', nom: 'Update sequence', format: 'uint8', statut: 'Optional', min: 0, max: 255 },
+        { octets: '8', nom: 'Optional section flag', format: 'bit', statut: 'Optional', min: 0, max: 1 },
+    ];
+    const zoneTable = { x: 60, y: 130, l: 696, h: 250 };
+    const rangs = champs.map((c) => `<tr><td>${c.octets}</td><td>${c.nom}</td><td>${c.format}</td><td>${c.statut}</td><td>${c.min}-${c.max}</td></tr>`).join('');
+    const html = `<table><tr><th>Octet</th><th>Field</th><th>Format</th><th>Status</th><th>Range</th></tr>${rangs}</table>`;
+    inv.texte(1, TITRE, 'BUFR section 1', 'titre');
+    inv.add('gabarit', 1, zoneTable, { nom: 'BUFR section 1', champs: champs.map((c) => ({ nom: c.nom, obligatoire: c.statut === 'Mandatory', format: c.format, min: c.min, max: c.max })) }, true);
+    return fini(nom, 'BUFR section 1', [bloc(TITRE, '<h1>BUFR section 1</h1>') + bloc(zoneTable, html)], inv);
+}
+/** Contrôle translucide sur fond chargé : un bouton blanc à 25 % d'opacité sur une carte à bandes, à côté d'un bouton opaque. */
+function controleTranslucide() {
+    const nom = 'controle-translucide';
+    const inv = new Inventaire(nom);
+    const fond = 'background:linear-gradient(135deg,#0b3d91 0%,#2e8b57 50%,#f2c14e 100%),repeating-linear-gradient(45deg,#ffffff 0 10px,#000000 10px 20px);background-blend-mode:multiply;';
+    const layers = { x: 300, y: 400, l: 160, h: 44 };
+    const zoom = { x: 500, y: 400, l: 120, h: 44 };
+    const ecran = inv.ecran(1);
+    inv.add('composant', 1, layers, { role: 'bouton', position: { x: Math.round(layers.x * K), y: Math.round(layers.y * K) }, taille: { l: Math.round(layers.l * K), h: Math.round(layers.h * K) }, contenu: 'Layers', ecran });
+    inv.add('composant', 1, zoom, { role: 'bouton', position: { x: Math.round(zoom.x * K), y: Math.round(zoom.y * K) }, taille: { l: Math.round(zoom.l * K), h: Math.round(zoom.h * K) }, contenu: 'Zoom', ecran });
+    inv.texte(1, { x: 340, y: 410, l: 90, h: 24 }, 'Layers', 'bouton');
+    inv.texte(1, { x: 535, y: 410, l: 60, h: 24 }, 'Zoom', 'bouton');
+    inv.add('jeton', 1, layers, { categorie: 'opacite', valeur: '0.25', point: { x: Math.round((layers.x + 10) * K), y: Math.round((layers.y + 10) * K) } }, true);
+    inv.add('jeton', 1, zoom, { categorie: 'couleur', valeur: '#1e3a8a', point: { x: Math.round((zoom.x + 10) * K), y: Math.round((zoom.y + 10) * K) } });
+    const bouton = (b, texte, style) => bloc(b, `<span style="font-size:18px;color:#fff;line-height:44px">${texte}</span>`, `text-align:center;border-radius:6px;${style}`);
+    const page = bloc({ x: 0, y: 0, l: 816, h: 1056 }, '', fond) + bouton(layers, 'Layers', 'background:rgba(255, 255, 255, 0.25);') + bouton(zoom, 'Zoom', 'background:#1e3a8a;');
+    return fini(nom, 'Map controls', [page], inv);
+}
+/** Page « Proposal » parmi des pages exigées : les exigences (page 1) et une maquette de panneau marquée Proposal (page 2). */
+function pageProposal() {
+    const nom = 'page-proposal';
+    const inv = new Inventaire(nom);
+    const exigences = ['REQ-1 The map shall show the layer panel.', 'REQ-2 The panel shall list every active layer.'];
+    const panneau = { x: 60, y: 160, l: 300, h: 420 };
+    const badge = { x: 600, y: 50, l: 150, h: 36 };
+    const legendePanneau = 'Figure 1 — Layer panel';
+    const LEGENDE_PANNEAU = { x: 60, y: 592, l: 300, h: 24 };
+    inv.texte(1, TITRE, 'Requirements', 'titre');
+    exigences.forEach((t, i) => inv.texte(1, { x: 60, y: 110 + i * 40, l: 696, h: 24 }, t, 'exigence'));
+    const ecran = inv.ecran(2);
+    inv.texte(2, { x: 60, y: 50, l: 400, h: 40 }, 'Layer panel mock-up', 'titre');
+    const comp = inv.add('composant', 2, panneau, { role: 'panneau', position: { x: Math.round(panneau.x * K), y: Math.round(panneau.y * K) }, taille: { l: Math.round(panneau.l * K), h: Math.round(panneau.h * K) }, contenu: 'Layers', ecran });
+    inv.texte(2, { x: 80, y: 176, l: 100, h: 26 }, 'Layers', 'titre-panneau');
+    // deux lignes du panneau : « Wind » dessinée sélectionnée (fond bleu, bordure), « Waves » dessinée grisée (désactivée)
+    const wind = { x: 80, y: 230, l: 240, h: 36 };
+    const waves = { x: 80, y: 280, l: 240, h: 36 };
+    const ligne = (b, contenu) => inv.add('composant', 2, b, { role: 'case_a_cocher', position: { x: Math.round(b.x * K), y: Math.round(b.y * K) }, taille: { l: Math.round(b.l * K), h: Math.round(b.h * K) }, contenu, ecran });
+    const compWind = ligne(wind, 'Wind');
+    const compWaves = ligne(waves, 'Waves');
+    inv.add('etat', 2, wind, { nom: 'selectionne', cible: compWind });
+    inv.add('etat', 2, waves, { nom: 'desactive', cible: compWaves });
+    // convention du corpus : tout libellé visible d'un composant est attendu aussi comme `texte`, avec le rôle du composant
+    inv.texte(2, { x: 90, y: 234, l: 70, h: 28 }, 'Wind', 'case_a_cocher');
+    inv.texte(2, { x: 90, y: 284, l: 70, h: 28 }, 'Waves', 'case_a_cocher');
+    inv.texte(2, LEGENDE_PANNEAU, legendePanneau, 'legende');
+    inv.texte(2, { x: 625, y: 54, l: 100, h: 28 }, 'Proposal', 'badge');
+    inv.add('lien', 2, panneau, { figure: legendePanneau, passage: { page: 1, ligne: 3, extrait: 'REQ-2 The panel shall list every active layer.' }, constat: 'confirme' });
+    inv.add('statut', 2, badge, { libelle: 'Proposal', couvre: [comp] }, true);
+    const page1 = bloc(TITRE, '<h1>Requirements</h1>') + exigences.map((t, i) => bloc({ x: 60, y: 110 + i * 40, l: 696, h: 24 }, `<p>${t}</p>`)).join('');
+    const page2 = bloc({ x: 60, y: 50, l: 400, h: 40 }, '<h1>Layer panel mock-up</h1>') +
+        bloc(badge, '<span style="font-size:18px;font-weight:bold;color:#fff;line-height:36px">Proposal</span>', 'background:#e67e22;border-radius:18px;text-align:center') +
+        bloc(panneau, '<p style="font-size:20px;font-weight:bold;margin:16px 20px">Layers</p>', 'background:#f4f4f4;border:2px solid #333') +
+        bloc(wind, '<p style="font-size:16px;line-height:32px;padding-left:12px;color:#0b2a66">Wind</p>', 'background:#cfe3ff;border:2px solid #1e5fd0') +
+        bloc(waves, '<p style="font-size:16px;line-height:32px;padding-left:12px;color:#999">Waves</p>', 'background:#e6e6e6;border:2px solid #cfcfcf') +
+        bloc(LEGENDE_PANNEAU, `<p>${legendePanneau}</p>`);
+    return fini(nom, 'Layer panel', [page1, page2], inv);
+}
+/** Version scannée : une fiche de station dessinée puis rastérisée, bruitée et légèrement penchée au rendu ; texte attendu issu d'un OCR. */
+function scanBruite() {
+    const nom = 'scan-bruite';
+    const inv = new Inventaire(nom);
+    const lignes = ['Station: LFPG', 'Visibility: 9999 m', 'Wind: 240/12 KT'];
+    inv.texte(1, TITRE, 'Station report', 'titre', { ocr: true }, true);
+    lignes.forEach((t, i) => inv.texte(1, { x: 60, y: 130 + i * 50, l: 400, h: 30 }, t, 'ligne', { ocr: true }, true));
+    const page = bloc(TITRE, '<h1>Station report</h1>') + lignes.map((t, i) => bloc({ x: 60, y: 130 + i * 50, l: 400, h: 30 }, `<p style="font-size:22px">${t}</p>`)).join('');
+    return fini(nom, 'Station report', [page], inv, true);
+}
+/** Le corpus synthétique à vérité connue : un cas par piège de la conception, dans l'ordre (design « Évaluation »). */
+export function buildCorpus() {
+    return [texteAmbigu(), figureContredit(), tableEnImage(), gabaritBufr(), controleTranslucide(), pageProposal(), scanBruite()];
+}

package/dist/ref/evaluate.js

@@ -0,0 +1,241 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { RafError } from '../plan.js';
+import { TYPES, checkInventaire, readInventaire } from './check.js';
+const norm = (v) => {
+    const s = String(v ?? '').normalize('NFC').toLowerCase().replace(/\s+/g, ' ').trim();
+    return /^-?\d+(\.\d+)?$/.test(s) ? String(Number(s)) : s;
+};
+/** Le libellé d'un `texte` est verbatim : seuls les blancs sont normalisés, la casse compte (`120 KT` n'est pas `120 kt`). */
+const normTexte = (v) => String(v ?? '').normalize('NFC').replace(/\s+/g, ' ').trim();
+const noms = (xs, cle) => (Array.isArray(xs) ? xs.map((x) => norm(x?.[cle])) : []);
+/** Ce qui désigne un élément, indépendamment de son id, de sa zone et de sa confiance : deux lectures indépendantes numérotent à leur façon. */
+function identite(e, parId) {
+    const cible = (id) => {
+        const t = typeof id === 'string' ? parId.get(id) : undefined;
+        return t ? `${t.type}:${identite(t, new Map())}` : '?';
+    };
+    switch (e.type) {
+        case 'ecran':
+            return 'ecran';
+        case 'composant':
+            return `${norm(e.role)}|${norm(e.contenu)}`;
+        case 'etat':
+            return `${norm(e.nom)}>${cible(e.cible)}`;
+        case 'texte':
+            return normTexte(e.libelle);
+        case 'statut':
+            return norm(e.libelle);
+        case 'jeton':
+            return `${norm(e.categorie)}=${norm(e.valeur)}`;
+        case 'table':
+            return e.colonnes.map(norm).join('|');
+        case 'gabarit':
+            return norm(e.nom);
+        case 'schema':
+            return noms(e.noeuds, 'libelle').sort().join('|');
+        case 'lien':
+            return norm(e.figure);
+        default:
+            return norm(e.question);
+    }
+}
+/** Ce que l'élément affirme une fois retrouvé : une identité juste avec une affirmation fausse est un faux lu, pas un rappel. */
+function affirmation(e, parId) {
+    switch (e.type) {
+        case 'ecran':
+            return String(e.largeur_reference);
+        case 'texte':
+            return norm(e.role);
+        case 'table':
+            return JSON.stringify(e.lignes.map((l) => l.map(norm)));
+        case 'gabarit':
+            return JSON.stringify(e.champs.map((c) => [norm(c.nom), c.obligatoire, norm(c.format), c.min ?? null, c.max ?? null]));
+        case 'schema': {
+            const libelle = new Map(e.noeuds.map((n) => [n.id, norm(n.libelle)]));
+            return JSON.stringify(e.flux.map((f) => `${libelle.get(f.de)}>${libelle.get(f.vers)}:${norm(f.libelle)}:${f.direction}`).sort());
+        }
+        case 'lien':
+            return String(e.constat);
+        case 'statut':
+            return JSON.stringify(e.couvre.map((id) => {
+                const t = parId.get(id);
+                return t ? `${t.type}:${identite(t, new Map())}` : '?';
+            }).sort());
+        default:
+            return '';
+    }
+}
+const compteVide = () => ({ attendus: 0, lus: 0, justes: 0, sures: 0, faux_lu: 0 });
+const ratio = (a, b) => (b === 0 ? null : a / b);
+/** Apparie lus et attendus par type et identité, un attendu une seule fois ; les appariements à l'affirmation exacte passent d'abord. */
+export function evaluerCas(nom, attendu, lecture) {
+    const types = {};
+    const compte = (t) => (types[t] ??= compteVide());
+    const parIdAttendu = new Map(attendu.elements.map((e) => [e.id, e]));
+    const lus = lecture ? lecture.elements : [];
+    const parIdLu = new Map(lus.map((e) => [e.id, e]));
+    const trouve = new Set();
+    const juste = new Set();
+    const justeAtt = new Set();
+    const libre = new Set(attendu.elements);
+    const cle = (e, par) => `${e.type}\u0000${identite(e, par)}`;
+    const apparier = (exact) => {
+        for (const lu of lus) {
+            if (juste.has(lu) || trouve.has(lu))
+                continue;
+            for (const att of libre) {
+                if (cle(att, parIdAttendu) !== cle(lu, parIdLu))
+                    continue;
+                const pareil = affirmation(att, parIdAttendu) === affirmation(lu, parIdLu);
+                if (exact && !pareil)
+                    continue;
+                libre.delete(att);
+                trouve.add(lu);
+                if (pareil) {
+                    juste.add(lu);
+                    justeAtt.add(att);
+                }
+                break;
+            }
+        }
+    };
+    apparier(true);
+    apparier(false);
+    for (const e of attendu.elements)
+        compte(e.type).attendus++;
+    for (const lu of lus) {
+        const c = compte(lu.type);
+        c.lus++;
+        if (lu.confiance !== 'incertain')
+            c.sures++;
+        if (juste.has(lu))
+            c.justes++;
+        else if (lu.confiance !== 'incertain')
+            c.faux_lu++;
+    }
+    const parPiege = new Map();
+    for (const e of attendu.elements) {
+        if (typeof e.piege !== 'string')
+            continue;
+        const p = parPiege.get(e.piege) ?? { piege: e.piege, attendus: 0, trouves: 0 };
+        p.attendus++;
+        if (justeAtt.has(e))
+            p.trouves++;
+        parPiege.set(e.piege, p);
+    }
+    const tokens = typeof lecture?.usage?.tokens === 'number' && lecture.usage.tokens >= 0 ? lecture.usage.tokens : null;
+    return { cas: nom, lecture: lecture !== null, pages: Number.isInteger(attendu.pages) && attendu.pages > 0 ? attendu.pages : null, tokens, types, pieges: [...parPiege.values()] };
+}
+function taux(c) {
+    return { ...c, rappel: ratio(c.justes, c.attendus), precision: ratio(c.justes, c.lus), taux_faux_lu: ratio(c.faux_lu, c.sures) };
+}
+/** Additionne les cas : par type, au total, par piège (même nom d'un cas à l'autre) et en tokens par page (cas qui ont une mesure seulement). */
+export function agreger(cas) {
+    const types = {};
+    const total = compteVide();
+    const pieges = new Map();
+    let tokens = null;
+    let pages = 0;
+    const exclus = [];
+    for (const r of cas) {
+        for (const [t, c] of Object.entries(r.types)) {
+            const a = (types[t] ??= compteVide());
+            for (const k of Object.keys(a)) {
+                a[k] += c[k];
+                total[k] += c[k];
+            }
+        }
+        for (const p of r.pieges) {
+            const a = pieges.get(p.piege) ?? { piege: p.piege, attendus: 0, trouves: 0 };
+            a.attendus += p.attendus;
+            a.trouves += p.trouves;
+            pieges.set(p.piege, a);
+        }
+        if (r.tokens !== null && r.pages === null)
+            exclus.push(r.cas);
+        else if (r.tokens !== null && r.pages !== null) {
+            tokens = (tokens ?? 0) + r.tokens;
+            pages += r.pages;
+        }
+    }
+    const ordre = (t) => TYPES.indexOf(t);
+    const triee = Object.fromEntries(Object.entries(types).sort(([a], [b]) => ordre(a) - ordre(b)).map(([t, c]) => [t, taux(c)]));
+    return {
+        total: taux(total),
+        types: triee,
+        pieges: [...pieges.values()],
+        tokens: tokens === null || pages === 0 ? { total: null, pages: null, par_page: null, exclus } : { total: tokens, pages, par_page: tokens / pages, exclus },
+        cas,
+    };
+}
+const pct = (x) => (x === null ? 'n/a' : `${Number((x * 100).toFixed(1))} %`);
+export function formatEvaluation(ev) {
+    const t = ev.total;
+    const lignes = [
+        `${ev.cas.length} cas · ${t.attendus} éléments attendus · ${t.lus} lus`,
+        `rappel : ${pct(t.rappel)} (${t.justes}/${t.attendus}) · précision : ${pct(t.precision)} (${t.justes}/${t.lus})`,
+        `faux lu : ${pct(t.taux_faux_lu)} (${t.faux_lu}/${t.sures} sûrs)`,
+        ev.tokens.par_page === null ? 'tokens par page : non mesurés' : `tokens par page : ${Number(ev.tokens.par_page.toFixed(1))} (${ev.tokens.total} sur ${ev.tokens.pages} pages)`,
+    ];
+    if (ev.tokens.exclus.length > 0)
+        lignes.push(`tokens par page : ${ev.tokens.exclus.length} cas sans \`pages\` exclus (${ev.tokens.exclus.join(', ')})`);
+    lignes.push('par type :');
+    for (const [type, c] of Object.entries(ev.types))
+        lignes.push(`  ${type.padEnd(10)} rappel ${pct(c.rappel)} (${c.justes}/${c.attendus}) · précision ${pct(c.precision)} (${c.justes}/${c.lus}) · faux lu ${c.faux_lu}/${c.sures}`);
+    if (ev.pieges.length > 0) {
+        lignes.push('pièges :');
+        for (const p of ev.pieges)
+            lignes.push(`  ${p.trouves === p.attendus ? '✓' : '✗'} ${p.piege} : ${p.trouves}/${p.attendus}`);
+    }
+    const sans = ev.cas.filter((c) => !c.lecture).map((c) => c.cas);
+    if (sans.length > 0)
+        lignes.push(`sans lecture : ${sans.join(', ')}`);
+    return lignes;
+}
+function charger(path, genres, role) {
+    const doc = readInventaire(path);
+    const problems = checkInventaire(doc);
+    if (problems.length > 0)
+        throw new RafError(`ref eval : ${role} ${path} n'est pas valide (${problems.length} écart(s), voir cadence ref check) : ${problems[0]}`);
+    if (!genres.includes(doc.genre))
+        throw new RafError(`ref eval : ${role} ${path} doit être ${genres.length === 1 ? `un ${genres[0]}` : `une lecture ou un inventaire`}, pas « ${doc.genre} »`);
+    return doc;
+}
+/** Les cas d'un chemin : un fichier est un cas, un dossier en a un par sous-dossier qui porte `fichier` (ordre alphabétique). */
+function cheminsDeCas(chemin, fichier) {
+    if (!existsSync(chemin))
+        throw new RafError(`ref : fichier introuvable : ${chemin}`);
+    if (!statSync(chemin).isDirectory())
+        return [{ nom: 'document', fichier: chemin }];
+    return readdirSync(chemin)
+        .sort()
+        .filter((n) => existsSync(join(chemin, n, fichier)))
+        .map((n) => ({ nom: n, fichier: join(chemin, n, fichier) }));
+}
+/** `ref eval <attendu> <lecture>` : deux fichiers, ou deux dossiers (`<cas>/attendu.json`, `<cas>/lecture.json`). */
+export function evaluer(attendu, lecture) {
+    const attendus = cheminsDeCas(attendu, 'attendu.json');
+    const lecturesTrouvees = cheminsDeCas(lecture, 'lecture.json');
+    const dossier = statSync(attendu).isDirectory();
+    // un fichier contre un dossier ne s'apparie à aucun cas : la lecture serait ignorée, la mesure fausse
+    if (dossier !== statSync(lecture).isDirectory()) {
+        throw new RafError(`ref eval : combinaisons acceptées : deux fichiers (attendu.json lecture.json) ou deux dossiers (<cas>/attendu.json, <cas>/lecture.json) ; reçu ${dossier ? 'un dossier et un fichier' : 'un fichier et un dossier'}`);
+    }
+    if (dossier && attendus.length === 0)
+        throw new RafError(`ref eval : aucun attendu.json dans les sous-dossiers de ${attendu}`);
+    const lectures = new Map(lecturesTrouvees.map((c) => [c.nom, c.fichier]));
+    const cas = attendus.map((a) => {
+        const att = charger(a.fichier, ['inventaire'], "l'attendu");
+        const fichier = dossier ? lectures.get(a.nom) : lecture;
+        if (fichier === undefined)
+            return evaluerCas(a.nom, att, null);
+        const lu = charger(fichier, ['lecture', 'inventaire'], 'la lecture');
+        if (lu.document.slug !== att.document.slug)
+            throw new RafError(`ref eval : le slug de la lecture (${lu.document.slug}) n'est pas celui de l'attendu (${att.document.slug})`);
+        if (lu.document.sha256 !== att.document.sha256)
+            throw new RafError(`ref eval : l'empreinte de la lecture n'est pas celle de l'attendu pour ${att.document.slug} : pas la même version du document`);
+        return evaluerCas(a.nom, att, lu);
+    });
+    return agreger(cas);
+}

package/dist/ref/figures.js

@@ -0,0 +1,179 @@
+const WORDS = {
+    figure: { kind: 'figure', word: 'Figure' },
+    figures: { kind: 'figure', word: 'Figure' },
+    fig: { kind: 'figure', word: 'Figure' },
+    figs: { kind: 'figure', word: 'Figure' },
+    table: { kind: 'table', word: 'Table' },
+    tables: { kind: 'table', word: 'Table' },
+    tableau: { kind: 'table', word: 'Tableau' },
+    tableaux: { kind: 'table', word: 'Tableau' },
+    planche: { kind: 'planche', word: 'Planche' },
+    planches: { kind: 'planche', word: 'Planche' },
+};
+const NUMBER = String.raw `[A-Z]{0,2}[-.]?\d+(?:[.-](?:\d+|[A-Z](?![a-z])))*[a-z]?`;
+/** Ce qui sépare deux numéros d'une énumération au pluriel : « 2, 3 », « 2 and 3 », « 4 to 6 ». */
+const SEPARATOR = String.raw `(?:\s*,\s*(?:(?:and|et)\s+)?|\s+(?:and|et|to|à|&)\s+)`;
+const REFERENCE = new RegExp(String.raw `\b(Figures?|Figs?|Tables?|Tableaux|Tableau|Planches?)\.?\s+(${NUMBER}(?:${SEPARATOR}${NUMBER})*)(?![\w])`, 'gi');
+const PLURAL = /^(?:figures|figs|tables|tableaux|planches)$/i;
+const NUMBER_ONLY = new RegExp(NUMBER, 'g');
+/** « Figure n » en début de ligne, puis le séparateur éventuel (tiret, deux-points, point) et le reste de la ligne. */
+const CAPTION = new RegExp(String.raw `^(Figure|Fig|Table|Tableau|Planche)\.?\s+(${NUMBER})(?![\w])\s*([:.–—-])?\s*(.*)$`, 'i');
+/** Le reste d'une ligne qui n'est qu'une parenthèse fermée : « (in accordance with 4.3.11) ». */
+const WHOLE_PARENTHESIS = /^\([^()]*\)$/;
+const DEICTIC = /\b(as shown (?:below|above)|shown (?:below|above)|illustrated (?:below|above)|ci-(?:dessous|dessus))\b/i;
+/** Points de conduite d'un sommaire : « Figure 1 Titre ..... 12 ». */
+const LEADER = /\.{4,}|(?:\.\s){4,}/;
+/** Numéro de page en fin de titre d'un sommaire sans points de conduite : « Figure 1 Titre 12 » (le titre est « Titre 12 », le numéro de la figure n'en est pas un). */
+const TRAILING_PAGE = /(?:^|\s)(\d{1,4})\s*$/;
+const labelOf = (word, num) => {
+    const w = WORDS[word.toLowerCase()];
+    return { label: `${w.word} ${num}`, kind: w.kind };
+};
+const key = (label) => label.toLowerCase();
+/**
+ * Une ligne a la forme d'une légende quand elle COMMENCE par « Figure n » / « Table n » et que ce qui suit n'est pas une phrase en
+ * cours. Après un séparateur (« Figure 1 — titre en minuscule », « Table 2: codes ») c'est une légende quelle que soit la casse ;
+ * sans séparateur, une minuscule (« Figure 3 shows … »), une virgule ou une parenthèse (« Figure 5, which … », « Figure 5 (page 4) and … »)
+ * en font une citation. Un séparateur suivi d'un titre vide (« figure 24. » en fin de phrase) n'est pas une légende non plus.
+ * Exception : une ligne faite UNIQUEMENT du numéro et d'une parenthèse fermée (« Table IV.3 (in accordance with 4.3.11) ») a la forme
+ * d'une légende, `parenthetical` ; `indexText` ne la retient que si aucune autre ligne ne l'est pour ce numéro.
+ * « Table 2 The WMO … » a la forme d'une légende : `indexText` la départage des autres lignes de même forme.
+ */
+function captionForm(text) {
+    const m = CAPTION.exec(text.trim());
+    if (!m)
+        return null;
+    const parenthetical = m[3] === undefined && WHOLE_PARENTHESIS.test(m[4]);
+    if (m[3] === undefined && !parenthetical && /^[a-zà-ÿ,;(\[]/.test(m[4]))
+        return null;
+    if (m[3] !== undefined && m[4] === '')
+        return null;
+    return { ...labelOf(m[1], m[2]), separated: m[3] !== undefined, parenthetical, title: m[4] };
+}
+/**
+ * Lignes d'une page qui sont des entrées de sommaire (liste des figures, des tables). Une ligne à points de conduite (sur elle ou
+ * sur la suivante, titre coupé) en est une. Un numéro final ne suffit jamais : « Table 4.1. … presented in Chapter 4 » est une
+ * vraie légende ; il ne compte que dans une page de sommaire, où plus de la moitié des lignes (deux au moins) sont des entrées à
+ * points de conduite ou des lignes de forme de légende qui finissent par un numéro de page possible. Toutes les lignes d'une page
+ * de sommaire en sont.
+ */
+function tocLines(page, lastPage) {
+    const leaders = page.lines.map((l, i) => LEADER.test(l.text) || LEADER.test(page.lines[i + 1]?.text ?? ''));
+    const numbered = page.lines.map((l) => {
+        const number = TRAILING_PAGE.exec(captionForm(l.text)?.title ?? '')?.[1];
+        return number !== undefined && Number(number) <= lastPage;
+    });
+    const candidates = page.lines.filter((_, i) => leaders[i] || numbered[i]).length;
+    const contents = candidates >= 2 && candidates * 2 > page.lines.length;
+    return leaders.map((e) => e || contents);
+}
+/** Numéros nommés par une référence : le seul numéro au singulier ; au pluriel la liste, et « 4 to 6 » donne 4, 5, 6 quand ce sont des entiers. */
+function numbersOf(head, list) {
+    const nums = list.match(NUMBER_ONLY) ?? [];
+    if (!PLURAL.test(head))
+        return nums.slice(0, 1);
+    const range = /^(\d+)\s+(?:to|à)\s+(\d+)$/i.exec(list.trim());
+    if (range && Number(range[2]) >= Number(range[1]) && Number(range[2]) - Number(range[1]) < 50) {
+        return Array.from({ length: Number(range[2]) - Number(range[1]) + 1 }, (_, i) => String(Number(range[1]) + i));
+    }
+    return nums;
+}
+/**
+ * Légendes, citations et liens non résolus, d'après le texte seul ; les images viennent après (`attachRegions`).
+ * Une légende est une ligne de forme de légende (`captionForm`) qui n'est pas une entrée de sommaire ; une entrée de sommaire ne
+ * cite rien non plus. Quand plusieurs lignes ont la forme de la légende d'une même figure, on ne garde que celles qui ont un titre
+ * (« Figure 5 Jet speed » plutôt que « Figure 5 » seul), s'il y en a ; parmi elles la première qui est sur une page portant une image
+ * (`imagePages`), à défaut la première qui a un séparateur (« Table 3 — Mapping… » contre « Table 3 Identifies… »), à défaut la
+ * première du document.
+ */
+export function indexText(pages, imagePages = new Set()) {
+    const last = pages.reduce((m, p) => Math.max(m, p.n), 0);
+    const toc = new Map(pages.map((p) => [p.n, tocLines(p, last)]));
+    const candidates = new Map();
+    for (const p of pages) {
+        p.lines.forEach((l, i) => {
+            const c = toc.get(p.n)[i] ? null : captionForm(l.text);
+            if (!c)
+                return;
+            const list = candidates.get(key(c.label)) ?? [];
+            list.push({ ...c, page: p.n, line: i + 1, text: l.text.trim(), box: { x: l.x, y: l.y, l: l.l, h: l.h } });
+            candidates.set(key(c.label), list);
+        });
+    }
+    const chosen = [...candidates.values()]
+        .map((candidatesOfLabel) => {
+        // une ligne « Table n (…) » n'est une légende que si elle est la seule ligne de forme de légende de ce numéro
+        const all = candidatesOfLabel.filter((c) => !c.parenthetical || candidatesOfLabel.length === 1);
+        if (all.length === 0)
+            return null;
+        const list = all.some((c) => c.title !== '') ? all.filter((c) => c.title !== '') : all;
+        return list.find((c) => imagePages.has(c.page)) ?? list.find((c) => c.separated) ?? list[0];
+    })
+        .filter((c) => c !== null)
+        .sort((a, b) => a.page - b.page || a.line - b.line);
+    const figures = new Map(chosen.map((c) => [key(c.label), { label: c.label, kind: c.kind, page: c.page, line: c.line, caption: c.text, box: c.box, regions: [], citations: [] }]));
+    const captionLine = new Set(chosen.map((c) => `${c.page}:${c.line}`));
+    const unresolved = [];
+    for (const p of pages) {
+        const captions = [...figures.values()].filter((f) => f.page === p.n);
+        p.lines.forEach((l, i) => {
+            if (toc.get(p.n)[i])
+                return;
+            const line = i + 1;
+            const own = captionLine.has(`${p.n}:${line}`);
+            const seen = new Set();
+            for (const m of l.text.matchAll(REFERENCE)) {
+                // la légende ne se cite pas elle-même
+                if (own && m.index === 0)
+                    continue;
+                for (const num of numbersOf(m[1], m[2])) {
+                    const { label } = labelOf(m[1], num);
+                    if (seen.has(key(label)))
+                        continue;
+                    seen.add(key(label));
+                    const fig = figures.get(key(label));
+                    if (fig)
+                        fig.citations.push({ page: p.n, line, extrait: l.text.trim(), type: 'nommee' });
+                    else
+                        unresolved.push({ label, page: p.n, extrait: l.text.trim() });
+                }
+            }
+            const d = DEICTIC.exec(l.text);
+            if (!d)
+                return;
+            const nearest = captions.reduce((best, f) => (best === null || Math.abs(f.line - line) < Math.abs(best.line - line) ? f : best), null);
+            if (nearest)
+                nearest.citations.push({ page: p.n, line, extrait: l.text.trim(), type: 'designee' });
+            else
+                unresolved.push({ label: d[1].toLowerCase(), page: p.n, extrait: l.text.trim() });
+        });
+    }
+    // une figure que rien ne cite est aussi à résoudre
+    for (const f of figures.values())
+        if (f.citations.length === 0)
+            unresolved.push({ label: f.label, page: f.page, extrait: f.caption });
+    return { figures: [...figures.values()], unresolved };
+}
+/** Pages à rendre en plus de celles visées : celles des figures que les pages visées citent par leur nom. */
+export function citedPages(index, wanted) {
+    const out = new Set();
+    for (const f of index.figures)
+        if (f.citations.some((c) => c.type === 'nommee' && wanted.has(c.page)))
+            out.add(f.page);
+    return out;
+}
+const centre = (b) => b.y + b.h / 2;
+/** Relie chaque image à la légende de sa page la plus proche (en hauteur) ; une page sans région connue ne la donne qu'à sa seule légende. Une image sur une page sans légende est un lien non résolu. */
+export function attachRegions(index, images) {
+    images.forEach((img, rank) => {
+        const captions = index.figures.filter((f) => f.page === img.page);
+        const target = img.box
+            ? captions.reduce((best, f) => (best === null || Math.abs(centre(f.box) - centre(img.box)) < Math.abs(centre(best.box) - centre(img.box)) ? f : best), null)
+            : captions.length === 1
+                ? captions[0]
+                : null;
+        target?.regions.push(rank);
+        if (captions.length === 0)
+            index.unresolved.push({ label: 'image sans légende', page: img.page, extrait: '' });
+    });
+}