@sylad/cadence 1.8.0 → 1.10.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/diff.js

@@ -0,0 +1,262 @@
+import { writeFileSync } from 'node:fs';
+import { RafError } from '../plan.js';
+import { TYPES, checkInventaire, readInventaire } from './check.js';
+import { affirmation, identite } from './evaluate.js';
+/** Au-delà de cette part d'éléments non appariés, les deux lectures ne décrivent pas le même document : pas de réconciliation (design §3, hypothèse H3). */
+export const SEUIL_NON_APPARIES = 0.3;
+/** Recouvrement minimal (intersection sur union) de deux zones du même type et de la même page pour que deux lectures parlent du même élément lu autrement. */
+const RECOUVREMENT_MIN = 0.5;
+const zoneOf = (e) => e.source?.zone;
+/** Intersection sur union de deux zones ; 0 quand l'une manque. */
+function recouvrement(a, b) {
+    const p = zoneOf(a);
+    const q = zoneOf(b);
+    if (!p || !q)
+        return 0;
+    const l = Math.min(p.x + p.l, q.x + q.l) - Math.max(p.x, q.x);
+    const h = Math.min(p.y + p.h, q.y + q.h) - Math.max(p.y, q.y);
+    if (l <= 0 || h <= 0)
+        return 0;
+    const inter = l * h;
+    return inter / (p.l * p.h + q.l * q.h - inter);
+}
+const SKIP = new Set(['id', 'type', 'source', 'confiance', 'cause', 'ocr', 'citations', 'ecran', 'cible', 'couvre', 'usage']);
+const show = (v) => {
+    const s = v === undefined ? 'absent' : typeof v === 'string' ? v : JSON.stringify(v);
+    return s.length > 60 ? `${s.slice(0, 59)}…` : s;
+};
+/** Les champs qui diffèrent, « champ : A « … » ≠ B « … » » : les ids et les renvois sont numérotés par chaque lecture, ils ne comptent pas. */
+function detailDivergence(a, b) {
+    const out = [];
+    for (const k of new Set([...Object.keys(a), ...Object.keys(b)])) {
+        if (SKIP.has(k) || JSON.stringify(a[k]) === JSON.stringify(b[k]))
+            continue;
+        out.push(`${k} : A « ${show(a[k])} » ≠ B « ${show(b[k])} »`);
+    }
+    return out.length > 0 ? out.join(' ; ') : 'affirmations différentes';
+}
+/**
+ * Apparie deux lectures du même document, par type, page, identité (ce qui désigne l'élément, comme `ref eval`) et recouvrement de zone :
+ * concordant (même identité, même affirmation), divergent (même identité et affirmation différente, ou même zone et identité différente), seul.
+ * Les silences sont réunis, une même question une seule fois. `seuil` : part de non appariés au-delà de laquelle `refuse` est vrai.
+ */
+export function reconcilier(a, b, seuil = SEUIL_NON_APPARIES) {
+    const parIdA = new Map(a.elements.map((e) => [e.id, e]));
+    const parIdB = new Map(b.elements.map((e) => [e.id, e]));
+    const cle = (e, par) => `${e.source?.page}\u0000${identite(e, par)}`;
+    const items = new Map();
+    const pairedB = new Set();
+    for (const type of TYPES.filter((t) => t !== 'silence')) {
+        const as = a.elements.filter((e) => e.type === type);
+        const bs = b.elements.filter((e) => e.type === type);
+        const libresB = () => bs.filter((e) => !pairedB.has(e));
+        const lier = (ea, eb, statut) => {
+            pairedB.add(eb);
+            items.set(ea, { statut, element: ea, a: ea, b: eb, ...(statut === 'divergent' ? { detail: detailDivergence(ea, eb) } : {}) });
+        };
+        const meilleur = (ea, candidats) => candidats.reduce((best, c) => (best === undefined || recouvrement(ea, c) > recouvrement(ea, best) ? c : best), undefined);
+        // 1. même identité et même affirmation ; 2. même identité, affirmation différente ; 3. identité différente mais même zone
+        for (const ea of as) {
+            const eb = meilleur(ea, libresB().filter((c) => cle(c, parIdB) === cle(ea, parIdA) && affirmation(c, parIdB) === affirmation(ea, parIdA)));
+            if (eb)
+                lier(ea, eb, 'concordant');
+        }
+        for (const ea of as.filter((e) => !items.has(e))) {
+            const eb = meilleur(ea, libresB().filter((c) => cle(c, parIdB) === cle(ea, parIdA)));
+            if (eb)
+                lier(ea, eb, 'divergent');
+        }
+        for (const ea of as.filter((e) => !items.has(e))) {
+            const eb = meilleur(ea, libresB().filter((c) => c.source?.page === ea.source?.page && recouvrement(ea, c) >= RECOUVREMENT_MIN));
+            if (eb)
+                lier(ea, eb, 'divergent');
+        }
+        for (const ea of as.filter((e) => !items.has(e)))
+            items.set(ea, { statut: 'seul', element: ea, a: ea, lecture: 'a' });
+    }
+    // l'ordre de l'inventaire : la lecture A dans son ordre, puis ce que B seule porte dans son ordre
+    const ordered = [];
+    for (const e of a.elements)
+        if (e.type !== 'silence')
+            ordered.push(items.get(e));
+    for (const e of b.elements)
+        if (e.type !== 'silence' && !pairedB.has(e))
+            ordered.push({ statut: 'seul', element: e, b: e, lecture: 'b' });
+    const vues = new Map();
+    for (const [e, lecture] of [...a.elements.map((e) => [e, 'a']), ...b.elements.map((e) => [e, 'b'])]) {
+        if (e.type !== 'silence')
+            continue;
+        const k = identite(e, new Map());
+        const deja = vues.get(k);
+        if (deja) {
+            (deja.alias ??= []).push(`${lecture}:${e.id}`); // un statut peut couvrir ce silence-ci : son renvoi suit le silence réuni
+            continue;
+        }
+        const item = { statut: 'silence', element: e, ...(lecture === 'a' ? { a: e } : { b: e }) };
+        vues.set(k, item);
+        ordered.push(item);
+    }
+    const compte = (s) => ordered.filter((i) => i.statut === s).length;
+    const concordants = compte('concordant');
+    const divergents = compte('divergent');
+    const seuls = compte('seul');
+    const total = concordants + divergents + seuls;
+    const ratio = total === 0 ? null : seuls / total;
+    return { items: ordered, concordants, divergents, seuls, silences: compte('silence'), nonApparies: seuls, ratio, refuse: ratio !== null && ratio > seuil };
+}
+/** Les renvois d'un élément à d'autres éléments de sa lecture : (champ, ids). `ecran` et `cible` sont obligatoires, `couvre` se réduit. */
+const renvois = (e) => (e.type === 'composant' ? [e.ecran] : e.type === 'etat' ? [e.cible] : e.type === 'statut' ? e.couvre : []);
+const lectureLabel = (l) => l.toUpperCase();
+/** La confiance d'un élément concordant : un doute d'une lecture est un doute ; sinon `mesure` si l'une des deux a mesuré, `lu` sinon. */
+function confianceConcordant(ea, eb) {
+    if (ea.confiance === 'incertain' || eb.confiance === 'incertain') {
+        const causes = [ea, eb].filter((e) => e.confiance === 'incertain').map((e) => e.cause);
+        return { confiance: 'incertain', cause: [...new Set(causes)].join(' ; ') };
+    }
+    return { confiance: ea.confiance === 'mesure' || eb.confiance === 'mesure' ? 'mesure' : 'lu' };
+}
+/**
+ * L'inventaire réconcilié (genre « inventaire »), ids renumérotés `<slug>#<type>-<n>` et renvois suivis. Un divergent est `incertain` avec les deux
+ * versions ; un seul écarté par le troisième regard disparaît (avec ce qui ne tient plus sans lui), un seul confirmé garde sa confiance (un doute
+ * reste un doute), un seul sans décision reste `incertain` : `regard` dit si le troisième regard a eu lieu (sa cause le dit).
+ * Un élément apparié tient tant que l'une de ses deux versions renvoie à des éléments gardés (la lecture A d'abord) : quand l'autre version renvoyait à un
+ * élément écarté, il est gardé, rattaché d'après la version qui tient, et `incertain` avec la cause du rattachement ; il disparaît quand aucune ne tient.
+ */
+export function assembler(a, b, rec, regard = false) {
+    const entrees = rec.items.map((item) => ({ item, supprimee: item.statut === 'seul' && item.decision?.verdict === 'ecarte' }));
+    const proprietaire = new Map();
+    for (const en of entrees) {
+        if (en.item.a)
+            proprietaire.set(`a:${en.item.a.id}`, en);
+        if (en.item.b)
+            proprietaire.set(`b:${en.item.b.id}`, en);
+        for (const k of en.item.alias ?? [])
+            proprietaire.set(k, en);
+    }
+    const versionsDe = (en) => ['a', 'b'].filter((v) => en.item[v] !== undefined);
+    const cible = (v, id) => proprietaire.get(`${v}:${id}`);
+    const vivant = (v, id) => {
+        const t = cible(v, id);
+        return t !== undefined && !t.supprimee;
+    };
+    /** Une version tient quand ses renvois tiennent : tous pour un composant ou un état, au moins un pour un statut. */
+    const tient = (en, v) => {
+        const element = en.item[v];
+        const ids = renvois(element);
+        const vivants = ids.filter((id) => vivant(v, id)).length;
+        return ids.length === 0 || (element.type === 'statut' ? vivants > 0 : vivants === ids.length);
+    };
+    // ce qui renvoie à un élément écarté ne tient plus : un point fixe, un écarté pouvant en entraîner d'autres. Un élément apparié tient dès que l'une de
+    // ses deux versions tient (la lecture A d'abord) : la lecture B peut le rattacher à un écran conservé quand A le rattache à un écran écarté.
+    for (let change = true; change;) {
+        change = false;
+        for (const en of entrees) {
+            if (en.supprimee)
+                continue;
+            const v = versionsDe(en).find((x) => tient(en, x));
+            if (v === undefined) {
+                en.supprimee = true;
+                change = true;
+            }
+            else
+                en.version = v;
+        }
+    }
+    const compteur = new Map();
+    const nouvelId = new Map();
+    for (const en of entrees) {
+        if (en.supprimee)
+            continue;
+        const type = en.item.element.type;
+        const n = (compteur.get(type) ?? 0) + 1;
+        compteur.set(type, n);
+        nouvelId.set(en, `${a.document.slug}#${type}-${n}`);
+    }
+    const elements = entrees.filter((en) => !en.supprimee).map((en) => {
+        const { item } = en;
+        const v = en.version;
+        const e = { ...item.element, id: nouvelId.get(en) };
+        const id = (ancien) => nouvelId.get(cible(v, ancien));
+        // les renvois sont ceux de la version qui tient (pour un élément apparié, parfois celle de la lecture B)
+        const source = item[v];
+        if (e.type === 'composant')
+            e.ecran = id(source.ecran);
+        if (e.type === 'etat')
+            e.cible = id(source.cible);
+        if (e.type === 'statut')
+            e.couvre = source.couvre.filter((x) => vivant(v, x)).map(id);
+        const doute = (cause) => {
+            e.confiance = 'incertain';
+            e.cause = cause;
+        };
+        if (item.statut === 'concordant') {
+            const { confiance, cause } = confianceConcordant(item.a, item.b);
+            e.confiance = confiance;
+            if (cause === undefined)
+                delete e.cause;
+            else
+                e.cause = cause;
+        }
+        else if (item.statut === 'divergent') {
+            doute(`lectures divergentes — ${item.detail}`);
+        }
+        else if (item.statut === 'seul' && item.decision?.verdict !== 'confirme') {
+            const base = `lu dans la lecture ${lectureLabel(item.lecture)} seulement, troisième regard ${regard ? 'sans réponse' : 'non fait'}`;
+            doute(item.element.confiance === 'incertain' ? `${base} ; ${item.element.cause}` : base);
+        }
+        // les deux lectures ne le rattachent plus au même élément : l'une renvoyait à un élément écarté par le troisième regard, l'élément est gardé
+        // par l'autre (il est lu, ou mesuré, par les deux) mais son rattachement n'est plus qu'une lecture : un doute, avec sa cause
+        const autre = v === 'a' ? 'b' : 'a';
+        if (item.a && item.b && !tient(en, autre)) {
+            const note = `rattachement : la lecture ${lectureLabel(autre)} le rattachait à un élément écarté par le troisième regard, rattaché d'après la lecture ${lectureLabel(v)}`;
+            doute(e.confiance === 'incertain' ? `${e.cause} ; ${note}` : note);
+        }
+        return e;
+    });
+    return { version: 1, genre: 'inventaire', document: { slug: a.document.slug, sha256: a.document.sha256 }, elements };
+}
+function lireLecture(path) {
+    const doc = readInventaire(path);
+    const problems = checkInventaire(doc);
+    if (problems.length > 0)
+        throw new RafError(`ref diff : ${path} n'est pas valide (${problems.length} écart(s), voir cadence ref check) : ${problems[0]}`);
+    if (doc.genre !== 'lecture')
+        throw new RafError(`ref diff : ${path} doit être une lecture, pas un « ${doc.genre} »`);
+    return doc;
+}
+/** `--seuil` : une part en pour cent (0 à 100) rendue en fraction ; absent, le seuil de la conception. */
+export function parseSeuil(text, commande) {
+    if (text === undefined)
+        return SEUIL_NON_APPARIES;
+    if (!/^\d+(\.\d+)?$/.test(text) || Number(text) > 100)
+        throw new RafError(`${commande} : --seuil invalide : « ${text} » (une part en pour cent, de 0 à 100)`);
+    return Number(text) / 100;
+}
+/** `ref diff <a> <b> [--out inventaire.json] [--seuil 30]` : 0 réconcilié, 1 trop d'éléments non appariés (rien d'écrit), 2 fichier ou appel refusé. */
+export function diffLectures(o) {
+    const seuil = parseSeuil(o.seuil, 'ref diff');
+    const a = lireLecture(o.a);
+    const b = lireLecture(o.b);
+    if (a.document.slug !== b.document.slug)
+        throw new RafError(`ref diff : les deux lectures ne sont pas du même document : slug ${a.document.slug} et ${b.document.slug}`);
+    if (a.document.sha256 !== b.document.sha256)
+        throw new RafError(`ref diff : l'empreinte des deux lectures diffère pour ${a.document.slug} : pas la même version du document (jamais deux versions mêlées)`);
+    const rec = reconcilier(a, b, seuil);
+    const sa = rec.items.filter((i) => i.statut === 'seul' && i.lecture === 'a').length;
+    const pct = (x) => `${Number((x * 100).toFixed(1))} %`;
+    o.log(`concordants : ${rec.concordants} · divergents : ${rec.divergents} · seuls : ${rec.seuls} (A : ${sa}, B : ${rec.seuls - sa}) · silences : ${rec.silences}`);
+    o.log(`non appariés : ${rec.ratio === null ? 'n/a' : pct(rec.ratio)} (seuil ${pct(seuil)})`);
+    for (const i of rec.items) {
+        if (i.statut === 'divergent')
+            o.log(`divergent : ${i.element.type} p.${i.element.source.page} : ${i.detail}`);
+        if (i.statut === 'seul')
+            o.log(`seul (${lectureLabel(i.lecture)}) : ${i.element.type} p.${i.element.source.page} : ${identite(i.element, new Map())}`);
+    }
+    if (rec.refuse) {
+        o.log(`plus de ${pct(seuil)} d'éléments non appariés (${rec.nonApparies} sur ${rec.concordants + rec.divergents + rec.seuls}) : les deux lectures ne décrivent pas le même document — question au lead, aucune réconciliation`);
+        return 1;
+    }
+    if (o.out !== undefined)
+        writeFileSync(o.out, `${JSON.stringify(assembler(a, b, rec), null, 2)}\n`);
+    return 0;
+}