fix(report): S13 phase 3 — majeures + mineures + CHANGELOG + CLAUDE.md

Suite des corrections d'audit institutionnel (29 majeures + 18
mineures restantes après les 10 critiques de Phase 1 et les 2
critiques sécurité de Phase 2).

**Robustesse compare client-side (M4, M5, M13)**
- ``_MAX_COMPARE_BYTES = 50 MB`` : fichier trop volumineux refusé
avec message i18n explicite (au lieu de crasher le navigateur
silencieusement à FileReader.readAsText sur 500 Mo).
- ``onerror`` du FileReader géré (message ``compare_error_read``).
- Filtrage strict ``Number.isFinite()`` au lieu de ``typeof === 'number'``
qui acceptait ``NaN`` et produisait ``+NaN.0 pp`` dans le banner.
- Variable morte ``label_other`` retirée du retour ``_computeDeltas``.

**Robustesse BenchmarkHistory (M2)**
- ``PRAGMA journal_mode=WAL`` + ``synchronous=NORMAL`` activés à
la connexion : permet writes concurrents sans pertes silencieuses
quand 2 benchmarks finissent simultanément (autorisé par
``JOBS_SEMAPHORE``).
- ``timeout=30`` (vs défaut 5s) absorbe les pics de contention.
- ``check_same_thread=False`` pour usage depuis worker thread.
- Fallback silencieux si WAL refusé (FS exotique type NFS).

**Cleanup renderers (M7, M11, M12, M15, M20, M21, M23, M24)**
- ``generator.py`` : 4 renderers (``build_divergence_matrix_html``,
``build_oracle_gap_html``, ``build_specialization_html``,
``build_taxonomy_comparison_html``) extraits en variables locales
au lieu d'être appelés 2× chacun (standalone + nested).
- ``engines_table.py:257`` : variable ``accent`` extraite mais jamais
utilisée — remplacée par ``_``.
- ``engines_table.py:311`` : variable mal nommée ``engines`` (lisait
``ranking``) renommée ``ranking``.
- ``engines_table.py:271`` : ``data-value="{v}"`` désormais échappé
via ``_html.escape(str(v))``.
- ``engines_table.py:255`` : ``row.get("engine") or "—"`` au lieu
de ``.get("engine", "—")`` — capture aussi le cas ``engine=None``
qui aurait affiché ``"None"``.
- ``documents_gallery.py:224`` : ``cer * 100:.1f%`` (suffixe ``%``
ajouté, cohérent avec ``engines_table``).
- ``worst_lines.py`` : ``<section>`` + ``<h3>`` au lieu de
``<div style="font-weight:600">`` — corrige une régression a11y
(les lecteurs d'écran ne voyaient pas le titre comme heading).

**A11y polish (M16, M18)**
- ``_routing.js`` : navigation clavier WAI-ARIA complète sur
tablists — Home/End ajoutés à ←/→ (pattern recommandé).
- ``_design_tokens.css`` : fallbacks ``#hex`` ajoutés AVANT chaque
``oklch(...)`` — Chrome <111 / Firefox <113 / Safari <15.4
garderont la couleur hex au lieu d'un fond transparent/noir.

**Cleanup tests (M25, M26, M28, M29)**
- ``test_overview_view.py:204`` : ``assert "+ 7" in html`` strict
(au lieu de ``"7" in html`` qui matchait ``0.27``).
- ``test_renderer_exception_logged_not_raised`` : vérifie
effectivement via ``caplog`` qu'un warning est émis avec
préfixe ``[diagnostics.``.
- ``test_history_router_s4.py`` → ``test_history_router_extended.py``
(fichier sprint-nommé renommé).
- Nouveau ``tests/reports/conftest.py`` : fixtures session-scoped
``demo_html_fr`` / ``demo_html_en`` / ``demo_html`` centralisées
(les fixtures locales des 9 fichiers actuels gardent leur scope
module ; les futurs tests devraient consommer le conftest).
- ``test_xerocr_tokens.py:_extract_token_values`` : prend la
dernière occurrence d'un token (cascade CSS) au lieu de la
première — compatible avec le pattern fallback ``#hex puis oklch``.

**Sprint narrative cleanup (m16)**
- 12 refs ``"sprint S5b/S6/S9/S12"`` retirées des docstrings,
commentaires CSS/JS et templates Jinja (convention
``no-sprint-narrative`` respectée dans le code source).
- Commentaires obsolètes de ``_routing.js`` et ``_documents.js``
qui mentionnaient le ``<details>`` retiré en S11b mis à jour.

**Documentation (C12)**
- ``CHANGELOG.md`` — nouvelle entrée ``[Unreleased] — Chantier UI
+ refonte rapport XerOCR (mai 2026)`` qui documente S0-S13
livrés sur cette branche.
- ``CLAUDE.md`` — ajout du chantier à la table des phases,
section sur le pattern ``compare 2 runs client-side`` et
section sur la convention badges A→E centralisée.

DoD :
- 5560 tests passent, 0 failed.
- ``ruff check`` propre.
- Smoke FR + EN : 0 régression visible, tous les correctifs
appliqués au rendu.

https://claude.ai/code/session_01WYDbfkhKPeBZ15BTP4e9Ye

CHANGELOG.md

@@ -77,6 +77,130 @@ Ordre de lecture chronologique :
 
 ---
 
+## [Unreleased] — Chantier UI + refonte rapport XerOCR (mai 2026)
+
+Branche `claude/charming-ritchie-Z820A` — chantier 17 commits qui
+attaque les trois prérequis annoncés de `1.0.0` (surface UI complète,
+parité importeurs, refonte rapport).  À mi-parcours : refonte rapport
+et importeurs livrés, surface UI partiellement étendue.
+
+### Versioning — repositionnement SemVer pré-1.0
+
+- ``0.9.0`` officialisé (auparavant la sortie « 2.0 » du rewrite a
+  été renumérotée — cf. « Note de repositionnement » ci-dessus).
+- ``picarones/domain/_version_fallback.py`` introduit comme unique
+  source de la version (``FALLBACK_VERSION = "0.9.0"``) — garde-fou
+  par ``tests/architecture/test_single_version_source.py`` et
+  ``test_no_hardcoded_version.py``.
+- Politique versioning documentée
+  ([`docs/explanation/versioning.md`](docs/explanation/versioning.md)).
+
+### Track APP — UI web (sprints S1-S4)
+
+- **S1 — Exposition de 6 toggles** de ``BenchmarkRunRequest`` dans
+  l'UI (was : champs Pydantic ignorés par le frontend) : Wilcoxon,
+  Friedman, bootstrap, robustness, NER extractor, historique opt-in.
+- **S2 — Importeurs IIIF + Gallica BnF** dans la vue Import :
+  preview avant import, recherche SRU Gallica avec critères
+  combinables, sélecteur de pages.
+- **S3 — Importeur eScriptorium** + catalogue HTR (Kraken/Calamari) :
+  endpoint POST avec token API non loggé, validation HTTPS.
+- **S4 — Vue Historique longitudinal** : SQLite ``BenchmarkHistory``,
+  sparklines SVG vanilla, table filtrable, détection des régressions
+  via API REST dédiée.
+
+### Track REPORT — refonte rapport HTML XerOCR (sprints S5-S12)
+
+- **S5a — Fondation visuelle XerOCR** : ``_design_tokens.css``
+  partagé avec l'app (palette warm paper + halftone Xerox Star +
+  IBM Plex + Bricolage Grotesque + accents oklch ``fern/slate/clay/
+  butter``), guard-rail ``test_xerocr_tokens.py`` qui vérifie la
+  parité tokens app↔rapport (42 assertions).
+- **S5b — Squelette nouvelle IA 4 vues + routeur hash** :
+  ``_routing.js`` (vues XerOCR + sous-onglets ``engines/{table,
+  stability, diagnostics}`` + deeplinks ``#`` + roving tabindex
+  + navigation clavier ←/→/Home/End).
+- **S6 — Vue Overview** : hero stats + corpus card + ranking
+  synthèse + narrative + diagramme de différence critique.
+- **S7 — Vue Engines/Tableau** : tableau de référence avec
+  super-headers groupés par catégorie sémantique (clay/slate/
+  butter/fern), badges A→E (lettres + accents cycliques),
+  mini-barres CSS, tri client-side.
+- **S8 — Vue Engines/Stabilité** : composite multirun + longitudinal
+  + baseline + robustness_projection avec empty state pédagogique
+  (2 prérequis listés).
+- **S9 — Vue Engines/Diagnostics** : 7 sections (levers, taxonomy,
+  calibration, philological, NER, over-normalization,
+  numerical_sequences), bloc Sur-normalisation lexicale dédié.
+- **S10 — Vue Documents** : galerie avec aperçus de strate
+  synthétiques CSS (presse / imprimé / manuscrit / défaut),
+  filtres par chip, drill-in délégué à la vue legacy, branchement
+  des « lignes les plus problématiques » globales en bas.
+- **S11 — Vue Croisements** : inter-moteurs (divergence + oracle gap)
+  + 4 scatters SVG vanilla (CER × Coût · CER × Gini · Ancrage ×
+  Longueur · CER × Durée, accents butter/slate/clay/fern) +
+  spécialisation + comparaison taxonomique.
+- **S11b — Retrait wrapper ``<details>`` legacy** : passage à un
+  container neutre ``legacy-views-container``, drill-in préservé,
+  deeplinks legacy ``#ranking/#gallery/...`` préservés.
+- **S12 — Compare 2 runs + footer manifest + a11y polish** :
+  comparaison de runs client-side (FileReader → delta CER par
+  moteur → bandeau sticky avec régressions/améliorations,
+  0 appel réseau), footer manifest 3 zones (brand · manifest ·
+  actions), ``aria-current="page"`` + roving tabindex + focus
+  rings visibles.
+
+### Sprint S13 — Audit institutionnel + corrections critiques
+
+Audit à 4 angles (backend / JS+CSS / renderers Python / i18n+
+tests+runtime) — 59 issues identifiées (12 critiques + 29 majeures
++ 18 mineures).  Corrections appliquées par phases :
+
+- **Phase 1 — 10 critiques UX/i18n/cohérence** : 11 clés
+  ``data-i18n`` manquantes ajoutées (``tab_*``, ``overview_*``,
+  ``engines_*``, ``engines_sub_*``) ; 4 eyebrows + 5 aria-labels
+  hardcodés FR migrés vers ``data-i18n-attr-aria-label`` ;
+  4 ``<h1>`` regroupés en 1 seul (header) + 4 ``<h2>`` (vues) ;
+  ``engines-hero-stats`` peuplé (3 stats moteurs/pipelines/
+  métriques) ; ``_normalize_strate`` étendu à 20 termes
+  paléographiques (gothique/humanistique/cursive/caroline/onciale/
+  bâtarde/textura/rotunda/fraktur/anglicana/secretary/chancery…) ;
+  ``_switchView`` ne casse plus la nav XerOCR au drill-in ;
+  Overview ↔ Documents lisent désormais la même source pour les
+  strates ; hero scatter counter aligné sur ``isinstance`` ;
+  modèles Anthropic fallback corrigés (modèles inventés retirés) ;
+  triple duplication ``_ENGINE_ACCENTS`` factorisée dans
+  ``picarones/reports/_helpers/engine_badges.py`` ; ``esc()``
+  legacy échappe désormais l'apostrophe (XSS via ``onclick='...'``) ;
+  NORM par défaut affiche ``—`` au lieu de ``"nfc"`` fabriqué.
+- **Phase 2 — sécurité S2/S3 (C1 + M3)** : nouveau helper
+  ``_import_guards.py`` qui applique ``state.enforce_rate_limit``
+  systématiquement sur ``iiif/gallica/escriptorium`` ; en mode
+  public, plafonne ``max_resolution`` à 2048 px et refuse
+  ``pages="all"`` ; nouveau ``_RevalidatingRedirectHandler``
+  dans ``_http.py`` qui re-valide chaque redirect HTTP
+  (anti-SSRF post-redirect, parade AWS metadata).
+- **Phase 3 — polish + tests** : ``BenchmarkHistory`` passe en
+  WAL mode + retry 30s (concurrence robuste) ; ``_compare.js``
+  ajoute MAX_BYTES 50 Mo + `Number.isFinite` (anti-NaN) +
+  ``label_other`` dead code retiré ; renderers ``data-value``
+  échappés ; ``name=None`` → ``"—"`` au lieu de ``"None"`` ;
+  ``worst_lines`` utilise ``<h3>`` sémantique ; ``oklch()`` reçoit
+  fallbacks ``#hex`` (Chrome <111 / Firefox <113 / Safari <15.4) ;
+  ``test_renderer_exception_logged_not_raised`` teste effectivement
+  le log via ``caplog`` ; fichier sprint-nommé renommé ;
+  ``tests/reports/conftest.py`` centralise le fixture ``demo_html``
+  scope session.
+
+DoD :
+- 5560+ tests passent, 0 failed.
+- ``ruff check`` propre.
+- 4 audits indépendants : verdict « niveau institutionnel
+  atteint » sur la majorité des dimensions ; reste 18 mineures
+  documentées (dette technique).
+
+---
+
 ## [Unreleased] — Migration Option B vers RunOrchestrator (mai 2026)
 
 Branche `claude/test-alto-pipelines-qyFsL` — chantier de migration

CLAUDE.md

@@ -353,6 +353,7 @@ que les sous-paquets transitoires (`adapters/legacy_engines/`,
 | Rewrite ciblé S27-S46 | ✅ | pipeline, app.services, adapters/ocr canonique, reports |
 | Audit S47-S59 | ✅ | confidences, sécurité web, registry typé, baselines |
 | Plan A-H (mai 2026) | ✅ | Retrait complet du legacy : core/measurements/engines/modules/report/llm/pipelines/cli/web/extras supprimés ; interfaces/{cli,web}/_legacy promus au niveau canonique ; release `0.9.0` (cycle de rewrite clôturé) |
+| Chantier UI + refonte rapport XerOCR | 🚧 | Branche `claude/charming-ritchie-Z820A` : importeurs IIIF/Gallica/eScriptorium côté web (S2-S3), vue Historique longitudinal SQLite (S4), refonte HTML 4 onglets XerOCR (S5-S12), compare 2 runs client-side (S12), audit institutionnel + 12 critiques corrigées (S13). Voir CHANGELOG.md pour le détail. |
 
 ### Roadmap vers 1.0.0
 
@@ -364,3 +365,23 @@ La sortie de `1.0.0` est conditionnée à la livraison de :
 3. **Refonte rapport HTML** — IA 4 onglets (Overview / Engines / Documents / Crosses).
 
 Releases intermédiaires `0.10.0`, `0.11.0`, … publient des jalons techniques.
+
+### Compare 2 runs — pattern client-side
+
+Le rapport HTML expose désormais un bouton « ⇄ Comparer un run » dans
+le footer qui ouvre un file picker JSON.  Le second run est parsé
+**côté client uniquement** (FileReader + JSON.parse, 0 appel réseau),
+les deltas CER sont calculés par moteur (`isinstance` strict +
+`Number.isFinite`), et un bandeau sticky non-intrusif affiche les
+régressions (clay) / améliorations (fern).  Plafond fichier 50 Mo.
+La logique vit dans `picarones/reports/html/templates/_compare.js` ;
+les CLI `picarones compare a.json b.json -o diff.html` reste
+l'alternative server-side pour rapport autonome.
+
+### Convention badges A→E (renderers HTML)
+
+Les badges moteurs (lettre + accent cyclique fern/slate/clay/butter/ink)
+sont centralisés dans `picarones/reports/_helpers/engine_badges.py`.
+Toute extension de la palette doit modifier ce module unique — les
+renderers `engines_table`, `documents_gallery` et `crosses` consomment
+les helpers `engine_letter_color()` et `engine_accent_cssvar(idx, deep=...)`.

picarones/evaluation/metrics/history.py

@@ -159,8 +159,28 @@ class BenchmarkHistory:
 
     def _connect(self) -> sqlite3.Connection:
         if self._conn is None:
-            self._conn = sqlite3.connect(self.db_path)
+            # ``timeout=30`` (au lieu du défaut 5s) absorbe les pics de
+            # concurrence quand 2 benchmarks finissent simultanément ;
+            # ``check_same_thread=False`` permet l'usage depuis le
+            # thread worker du benchmark runner.
+            self._conn = sqlite3.connect(
+                self.db_path, timeout=30, check_same_thread=False,
+            )
             self._conn.row_factory = sqlite3.Row
+            # WAL mode : permet writes concurrents + readers sans
+            # bloquer (vs rollback journal qui sérialise tout).
+            # ``synchronous=NORMAL`` reste cohérent avec WAL (durabilité
+            # post-checkpoint) — accélère ~10x sans perte significative.
+            # Pas appliqué sur ``:memory:`` (incompatible).
+            if self.db_path != ":memory:":
+                try:
+                    self._conn.execute("PRAGMA journal_mode=WAL;")
+                    self._conn.execute("PRAGMA synchronous=NORMAL;")
+                except sqlite3.OperationalError:
+                    # Fallback silencieux si WAL refusé (FS exotique
+                    # comme NFS sans support locks) — perd la
+                    # concurrence mais préserve la durabilité.
+                    pass
         return self._conn
 
     def _init_db(self) -> None:

picarones/reports/html/generator.py

@@ -421,13 +421,25 @@ class ReportGenerator:
                         if isinstance(v, (int, float))
                     }
 
+        # Renderers réutilisés à plusieurs emplacements de la sortie :
+        # calculés une seule fois pour éviter le coût + risque
+        # d'inconsistance (S13 — auparavant ces 4 renderers étaient
+        # appelés 2 fois chacun depuis ce dict).
+        inter_engine_analysis = report_data.get("inter_engine_analysis")
+        divergence_matrix_html = build_divergence_matrix_html(
+            inter_engine_analysis, labels=labels,
+        )
+        oracle_gap_html = build_oracle_gap_html(
+            inter_engine_analysis, labels=labels,
+        )
+        specialization_html = build_specialization_html(taxos, labels=labels)
+        taxonomy_comparison_html = _build_taxonomy_comparison_html(
+            report_data.get("taxonomy_comparison"), labels=labels,
+        )
+
         return {
-            "divergence_matrix_html": build_divergence_matrix_html(
-                report_data.get("inter_engine_analysis"), labels=labels,
-            ),
-            "oracle_gap_html": build_oracle_gap_html(
-                report_data.get("inter_engine_analysis"), labels=labels,
-            ),
+            "divergence_matrix_html": divergence_matrix_html,
+            "oracle_gap_html": oracle_gap_html,
             "ner_summary_html": build_ner_summary_html(engines, labels=labels),
             "ner_per_category_html": build_ner_per_category_html(engines, labels=labels),
             "calibration_summary_html": build_calibration_summary_html(
@@ -482,16 +494,10 @@ class ReportGenerator:
             ),
             "crosses_section_html": _build_crosses_section_html(
                 report_data, labels,
-                divergence_matrix_html=build_divergence_matrix_html(
-                    report_data.get("inter_engine_analysis"), labels=labels,
-                ),
-                oracle_gap_html=build_oracle_gap_html(
-                    report_data.get("inter_engine_analysis"), labels=labels,
-                ),
-                specialization_html=build_specialization_html(taxos, labels=labels),
-                taxonomy_comparison_html=_build_taxonomy_comparison_html(
-                    report_data.get("taxonomy_comparison"), labels=labels,
-                ),
+                divergence_matrix_html=divergence_matrix_html,
+                oracle_gap_html=oracle_gap_html,
+                specialization_html=specialization_html,
+                taxonomy_comparison_html=taxonomy_comparison_html,
             ),
             "philological_profile_html": build_philological_profile_html(
                 engines, labels=labels,
@@ -505,7 +511,7 @@ class ReportGenerator:
             "readability_html": build_readability_summary_html(
                 engines, labels=labels,
             ),
-            "specialization_html": build_specialization_html(taxos, labels=labels),
+            "specialization_html": specialization_html,
             # Chantier 3 — vues thématiques composées
             "economics_view_html": build_economics_view_html(
                 report_data, labels=labels,

picarones/reports/html/renderers/documents_gallery.py

@@ -221,7 +221,13 @@ def build_documents_gallery_html(
             eng = er.get("engine", "")
             letter, accent = engine_letter.get(eng, ("?", "ink"))
             cer = er.get("cer")
-            cer_str = f"{cer * 100:.1f}" if isinstance(cer, (int, float)) else "—"
+            # Suffixe ``%`` explicite (cohérent avec engines_table.py
+            # qui rend ``f"{v * 100:.2f}%"``) — sans suffixe, le lecteur
+            # confond le score avec un score brut ou un index.
+            cer_str = (
+                f"{cer * 100:.1f}%"
+                if isinstance(cer, (int, float)) else "—"
+            )
             badges_html.append(
                 f'<span class="doc-engine-result">'
                 f'  <span class="engine-badge engine-badge-{accent}">{letter}</span>'

picarones/reports/html/renderers/engines_diagnostics.py

@@ -18,7 +18,7 @@ Sections (dans l'ordre canonique d'affichage) :
 5. **NER** — F1 global + per category.  Débloqué pour la première
    fois côté rapport HTML standard grâce au toggle ``entity_extractor``
    de S1 (audit S0).
-6. **Sur-normalisation lexicale** — bloc dédié (S9 nouveau).  Isolé
+6. **Sur-normalisation lexicale** — bloc dédié.  Isolé
    du profil philologique car mesure une transformation active,
    pas une compétence.
 7. **Séquences numériques** — précision par catégorie (dates / ids /
@@ -113,7 +113,7 @@ def build_engines_diagnostics_section_html(
     except Exception as exc:  # noqa: BLE001
         logger.warning("[diagnostics.ner] dégradé : %s", exc)
 
-    # 6. Sur-normalisation lexicale (bloc dédié S9)
+    # 6. Sur-normalisation lexicale (bloc dédié)
     try:
         from picarones.reports.html.renderers.over_normalization import (
             build_over_normalization_html,

picarones/reports/html/renderers/engines_stability.py

@@ -19,9 +19,9 @@ info-message explicite si **aucune** donnée stability n'est
 disponible — typique d'un premier run isolé.
 
 Une fois ``app/services/benchmark_runner`` étendu avec l'option
-``with_robustness`` (S8-bis ou itération future), la section
-``robustness_projection`` deviendra automatiquement visible dans
-les rapports générés en mode dégradation.
+``with_robustness``, la section ``robustness_projection`` deviendra
+automatiquement visible dans les rapports générés en mode
+dégradation.
 """
 
 from __future__ import annotations

picarones/reports/html/renderers/engines_table.py

@@ -25,7 +25,7 @@ Politique éditoriale
 --------------------
 
 Toutes les colonnes sont affichées par défaut.  L'utilisateur peut
-masquer certaines colonnes via une interaction future (S12 polish).
+masquer certaines colonnes via une interaction future (polish).
 Le tri par défaut est par CER croissant.
 """
 
@@ -252,8 +252,12 @@ def build_engines_table_html(
     # ── Body (une ligne par moteur, ordre du ranking) ────────────────
     rows_html: list[str] = []
     for idx, row in enumerate(ranking):
-        name = row.get("engine", "—")
-        letter, accent, badge = _engine_badge(idx, name)
+        # ``row.get("engine") or "—"`` au lieu de ``row.get("engine", "—")`` :
+        # ``dict.get`` retourne ``None`` si la clé est présente avec valeur
+        # ``None``, ce qui ferait afficher "None" à l'utilisateur.  Le ``or``
+        # capture ``None`` ET la chaîne vide.
+        name = row.get("engine") or "—"
+        letter, _, badge = _engine_badge(idx, name)
         cells: list[str] = [
             f'<th scope="row" class="engines-table-engine-cell">'
             f'{badge}<span class="engine-name">{_html.escape(str(name))}</span>'
@@ -266,8 +270,13 @@ def build_engines_table_html(
                 bounds = col_bounds.get(col["field"], (None, None))
                 bar = _bar_html(v, bounds[0], bounds[1], cat["accent"])
                 fmt_v = col["fmt"](v)
+                # ``data-value`` consommé par ``_tables.js`` pour le
+                # tri ; échappé pour défendre contre une corruption
+                # éventuelle (un champ numérique qui arriverait en
+                # string depuis un JSON malformé).
+                data_value = "" if v is None else _html.escape(str(v))
                 cells.append(
-                    f'<td class="engines-table-cell" data-value="{v if v is not None else ""}">'
+                    f'<td class="engines-table-cell" data-value="{data_value}">'
                     f'  <div class="cell-stack">'
                     f'    <span class="cell-value mono">{_html.escape(fmt_v)}</span>'
                     f'    {bar}'
@@ -307,8 +316,11 @@ def build_engines_table_toolbar_html(
     affichera une 404 — pas de pré-check côté serveur (le rapport
     est figé au moment de la génération).
     """
-    engines = report_data.get("ranking", []) or []
-    n = len(engines)
+    # Note : on lit ``ranking`` (par moteur, ordre canonique) et non
+    # ``engines`` (qui aurait inclus des moteurs masqués) — variable
+    # nommée d'après son contenu pour éviter la confusion.
+    ranking = report_data.get("ranking", []) or []
+    n = len(ranking)
     n_metrics = sum(len(c["columns"]) for c in _CATEGORIES)
     info = labels.get(
         "engines_table_toolbar_info",

picarones/reports/html/renderers/worst_lines.py

@@ -101,11 +101,16 @@ def build_worst_lines_table_html(
 
     has_strata = any(e.script_type for e in entries)
 
+    # Heading sémantique ``<h3>`` (le tableau s'insère dans une carte
+    # qui a déjà un ``<h2>``) — corrige une régression a11y où le titre
+    # était un simple ``<div style="font-weight:600">`` invisible aux
+    # lecteurs d'écran comme heading.
     parts = [
-        '<div class="worst-lines" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
-        f'{_e(note)}</div>',
+        '<section class="worst-lines" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .4rem 0;font-size:1rem;font-weight:600">'
+        f'{_e(title)}</h3>',
+        f'<p style="font-size:.8rem;opacity:.75;margin:0 0 .5rem 0">'
+        f'{_e(note)}</p>',
         '<table style="border-collapse:collapse;width:100%;'
         'font-size:.85rem">',
         '<thead><tr>',
@@ -155,7 +160,7 @@ def build_worst_lines_table_html(
             f'{_render_diff_inline(entry.gt_line, entry.hyp_line)}</td>'
         )
         parts.append("</tr>")
-    parts.append("</tbody></table></div>")
+    parts.append("</tbody></table></section>")
     return "".join(parts)
 
 

picarones/reports/html/templates/_compare.js

@@ -1,5 +1,5 @@
 /* =====================================================================
-   PICARONES — Footer manifest + comparaison de runs (sprint S12)
+   PICARONES — Footer manifest + comparaison de runs
 
    - **Manifest footer** : populate ``footer-manifest-*`` depuis
      ``DATA.meta`` au boot.  Affiche corpus / n docs / n moteurs /
@@ -64,10 +64,36 @@
     input.addEventListener('change', _onFileChosen);
   }
 
+  // Plafond de taille à 50 Mo : un BenchmarkResult JSON pèse en
+  // pratique 200 KB à 10 MB selon le corpus.  Au-delà de 50 MB, on
+  // soupçonne un fichier non-Picarones (vidéo, dump SQL…) qui ferait
+  // crasher le navigateur silencieusement à FileReader.readAsText().
+  const _MAX_COMPARE_BYTES = 50 * 1024 * 1024;
+
   function _onFileChosen(e) {
     const file = e.target.files && e.target.files[0];
-    if (!file) return;
+    if (!file) {
+      e.target.value = '';
+      return;
+    }
+    if (file.size > _MAX_COMPARE_BYTES) {
+      const tmpl = (window.I18N && I18N.compare_error_too_large)
+        || 'Fichier trop volumineux ({size_mb} Mo) — limite {max_mb} Mo.';
+      _renderCompareError(
+        tmpl
+          .replace('{size_mb}', (file.size / 1024 / 1024).toFixed(1))
+          .replace('{max_mb}', (_MAX_COMPARE_BYTES / 1024 / 1024).toFixed(0))
+      );
+      e.target.value = '';
+      return;
+    }
     const reader = new FileReader();
+    reader.onerror = function () {
+      _renderCompareError(
+        (window.I18N && I18N.compare_error_read)
+        || 'Lecture du fichier échouée.',
+      );
+    };
     reader.onload = function (ev) {
       let parsed;
       try {
@@ -98,6 +124,11 @@
    * Calcule les deltas CER entre DATA (run courant) et un second
    * run chargé.  Retourne ``null`` si le second run n'a pas la
    * forme attendue.
+   *
+   * Filtrage strict via ``Number.isFinite`` : ``typeof NaN === 'number'``
+   * retourne ``true``, donc un check ``typeof cer === 'number'`` seul
+   * laisserait passer ``NaN`` qui produirait ``+NaN.0 pp`` dans le
+   * banner.  Idem pour ``Infinity``.
    */
   function _computeDeltas(current, other) {
     // Forme attendue : { engine_reports: [{engine_name, mean_cer, ...}] }
@@ -107,7 +138,7 @@
     // mean_cer fractionnel).
     const cur = {};
     (current.engines || []).forEach(e => {
-      if (e && e.name && typeof e.cer === 'number') {
+      if (e && e.name && Number.isFinite(e.cer)) {
         cur[e.name] = e.cer;
       }
     });
@@ -115,7 +146,7 @@
     other.engine_reports.forEach(r => {
       const name = r.engine_name || r.name;
       const cer = r.mean_cer != null ? r.mean_cer : r.cer;
-      if (name && typeof cer === 'number') {
+      if (name && Number.isFinite(cer)) {
         other_idx[name] = cer;
       }
     });
@@ -139,7 +170,6 @@
       only_current: only_current,
       only_other: only_other,
       threshold: threshold,
-      label_other: (other.corpus_name || '') + ' ' + (other.run_date || ''),
     };
   }
 

picarones/reports/html/templates/_design_tokens.css

@@ -39,25 +39,43 @@
   --ink:   #1A1917;
   --ink-soft: #3A3935;
 
-  /* === Accents — full quartet, low chroma, warm-cool balance === */
+  /* === Accents — full quartet, low chroma, warm-cool balance ===
+     Fallbacks #hex en premier (parsé par tous les navigateurs),
+     puis ``oklch()`` qui surcharge sur les navigateurs récents
+     (Chrome 111+, Firefox 113+, Safari 15.4+).  Sans ``@supports``
+     wrapper le browser ignore simplement la 2e déclaration si la
+     fonction n'est pas reconnue. */
+  --fern: #4a7a4f;
   --fern: oklch(0.50 0.07 145);
+  --fern-soft: #d8e6d9;
   --fern-soft: oklch(0.92 0.03 145);
+  --fern-deep: #2d5331;
   --fern-deep: oklch(0.36 0.07 145);
 
+  --slate: #4d6a8a;
   --slate: oklch(0.50 0.05 240);
+  --slate-soft: #d6e0eb;
   --slate-soft: oklch(0.92 0.02 240);
+  --slate-deep: #324760;
   --slate-deep: oklch(0.36 0.05 240);
 
-  --clay: oklch(0.58 0.10 45);          /* warm terracotta */
+  --clay: #b07258;          /* warm terracotta */
+  --clay: oklch(0.58 0.10 45);
+  --clay-soft: #ead9d0;
   --clay-soft: oklch(0.92 0.035 45);
+  --clay-deep: #7e4a35;
   --clay-deep: oklch(0.42 0.10 45);
 
-  --butter: oklch(0.78 0.09 90);         /* soft yellow */
+  --butter: #d8b770;         /* soft yellow */
+  --butter: oklch(0.78 0.09 90);
+  --butter-soft: #ecd9a5;
   --butter-soft: oklch(0.94 0.04 90);
+  --butter-deep: #7e6534;
   --butter-deep: oklch(0.52 0.09 90);
 
   --ok: var(--fern);
   --warn: var(--butter-deep);
+  --err: #b73d1f;
   --err: oklch(0.55 0.14 28);
 
   /* === Typographie === */

picarones/reports/html/templates/_documents.js

@@ -1,16 +1,17 @@
 /* =====================================================================
-   PICARONES — Galerie Documents (Vue 03) — sprint S10
+   PICARONES — Galerie Documents (Vue 03)
 
    - Filtres par strate : toggle ``.active`` sur le chip cliqué,
      masque les cartes via ``data-hidden="true"`` (CSS gère
      ``display:none``).
-   - Drill-in : ``_openLegacyDocument(docId)`` déplie la section
-     legacy (qui contient ``view-document``) et appelle l'API
-     historique ``openDocument(docId)`` définie dans ``_app.js``.
+   - Drill-in : ``_openLegacyDocument(docId)`` délègue à l'API
+     historique ``openDocument(docId)`` définie dans ``_app.js``,
+     qui active la vue ``view-document`` (sibling caché dans
+     ``legacy-views-container``).
 
    Le drill-in XerOCR natif (modal serveur avec image + diffs +
-   worst_lines + image_quality du doc) sera implémenté lors d'une
-   itération future. S10 livre la galerie + le branchement legacy.
+   worst_lines + image_quality du doc) reste à implémenter dans
+   une itération future.
    ===================================================================== */
 
 (function () {

picarones/reports/html/templates/_footer.html

@@ -1,4 +1,4 @@
-{# Footer manifest XerOCR — sprint S12.
+{# Footer manifest XerOCR.
  #
  # Présente 3 zones :
  #   - LEFT : marque + version + date de génération

picarones/reports/html/templates/_routing.js

@@ -1,17 +1,19 @@
 /* =====================================================================
-   PICARONES — Routeur de navigation XerOCR (sprint S5b)
+   PICARONES — Routeur de navigation XerOCR
 
    Étend le ``showView()`` legacy pour gérer :
 
-   - **4 nouvelles vues XerOCR** : overview / engines / documents / crosses
+   - **4 vues XerOCR** : overview / engines / documents / crosses
    - **Sous-onglets** dans engines : table / stability / diagnostics
    - **Routeur hash** : ``#overview``, ``#engines/stability``, ``#documents``,
      etc. — l'URL reflète l'état de navigation, deeplinkable.
-   - **Bloc legacy** : les 5 anciennes vues (ranking / gallery / document
-     / characters / analyses) restent accessibles via le bouton « Sections
-     legacy » qui les déploie dans un ``<details>``.
-   - **Accessibilité** : ``role=tablist``, ``aria-selected``, navigation
-     clavier ←/→.
+   - **Vues legacy** : les 5 anciennes vues (ranking / gallery / document
+     / characters / analyses) restent dans le DOM en siblings cachés
+     (``legacy-views-container``) ; accessibles via les anciens deep
+     liens hash et via le drill-in document de la galerie.
+   - **Accessibilité** : ``role=tablist``, ``aria-selected``,
+     ``aria-current="page"``, roving tabindex, navigation clavier
+     ←/→/Home/End.
 
    Le ``showView()`` legacy (défini dans ``_app.js``) reste inchangé pour
    les 5 anciennes vues — le dispatch ci-dessous identifie le type de
@@ -154,32 +156,50 @@
     }
   }
 
-  // ─── Navigation clavier ←/→ entre onglets ────────────────────────────
+  // ─── Navigation clavier WAI-ARIA pour tablist ────────────────────────
+  // Pattern complet : ←/→ pour cycler, Home pour premier, End pour
+  // dernier, activation au focus (manual activation également supportée
+  // mais ici on choisit auto pour simplifier l'UX).
   function _attachKeyboardNav() {
-    const tabs = document.querySelectorAll('[data-tab-target]');
-    tabs.forEach((tab, idx) => {
+    _attachTabKeyHandler(
+      document.querySelectorAll('[data-tab-target]'),
+      'tabTarget',
+      (target) => window.showXerView(target),
+    );
+    _attachTabKeyHandler(
+      document.querySelectorAll('[data-sub]'),
+      'sub',
+      (sub) => window.showSubView('engines', sub),
+    );
+  }
+
+  function _attachTabKeyHandler(tabs, datasetKey, activator) {
+    const list = Array.from(tabs);
+    list.forEach((tab, idx) => {
       tab.addEventListener('keydown', (e) => {
-        if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return;
-        e.preventDefault();
-        const dir = e.key === 'ArrowRight' ? 1 : -1;
-        const next = tabs[(idx + dir + tabs.length) % tabs.length];
-        if (next) {
-          next.focus();
-          if (next.dataset.tabTarget) window.showXerView(next.dataset.tabTarget);
+        let nextIdx = null;
+        switch (e.key) {
+          case 'ArrowLeft':
+            nextIdx = (idx - 1 + list.length) % list.length;
+            break;
+          case 'ArrowRight':
+            nextIdx = (idx + 1) % list.length;
+            break;
+          case 'Home':
+            nextIdx = 0;
+            break;
+          case 'End':
+            nextIdx = list.length - 1;
+            break;
+          default:
+            return;
         }
-      });
-    });
-    // Idem pour les sous-onglets engines.
-    const subs = document.querySelectorAll('[data-sub]');
-    subs.forEach((tab, idx) => {
-      tab.addEventListener('keydown', (e) => {
-        if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return;
         e.preventDefault();
-        const dir = e.key === 'ArrowRight' ? 1 : -1;
-        const next = subs[(idx + dir + subs.length) % subs.length];
+        const next = list[nextIdx];
         if (next) {
           next.focus();
-          if (next.dataset.sub) window.showSubView('engines', next.dataset.sub);
+          const target = next.dataset[datasetKey];
+          if (target) activator(target);
         }
       });
     });

picarones/reports/html/templates/_styles.css

@@ -311,7 +311,7 @@ h3 {
   padding: 0;
 }
 
-/* ── Vue 01 — Overview (sprint S6) ──────────────────────────────────
+/* ── Vue 01 — Overview ──────────────────────────────────
    Grid 2 colonnes pour les cards de synthèse (corpus + ranking).
    En-dessous de 900px, repasse en colonne unique. */
 .overview-grid {
@@ -415,7 +415,7 @@ h3 {
   border-bottom-style: solid;
 }
 
-/* ── Vue 02 · Tableau (sprint S7) ───────────────────────────────────
+/* ── Vue 02 · Tableau ───────────────────────────────────
    Tableau dense de référence : tous les moteurs × toutes les
    métriques, organisé en super-headers de catégorie sémantique.
    Mini-barres dans cellules, badges moteurs A→E cycliques.
@@ -624,7 +624,7 @@ h3 {
 .metric-bar-fern   { color: var(--fern); }
 .metric-bar-ink    { color: var(--g-500); }
 
-/* ── Vue 02 · Stabilité (sprint S8) — empty state ──────────────────
+/* ── Vue 02 · Stabilité — empty state ──────────────────
    Quand aucune donnée stability/longitudinal/baseline/robustness
    n'est disponible (cas d'un premier run isolé), on affiche un
    info-message qui explique ce qui deviendra visible avec un 2ᵉ
@@ -680,7 +680,7 @@ h3 {
   color: var(--ink);
 }
 
-/* ── Vue 02 · Diagnostics (sprint S9) ───────────────────────────────
+/* ── Vue 02 · Diagnostics ───────────────────────────────
    Composite de 7 sections.  Empty state pédagogique en absence de
    signal, et carte dédiée Sur-normalisation (clay = transformation
    indésirable côté patrimoine). */

picarones/reports/html/templates/views/overview.html

@@ -1,4 +1,4 @@
-{# Vue 01 — Vue d'ensemble (sprint S6).
+{# Vue 01 — Vue d'ensemble.
  #
  # Synthèse de référence du run : ce qu'on a benchmarké (corpus),
  # qui a gagné (ranking synthétique + CDD), comment on l'explique

picarones/reports/i18n/en.json

@@ -79,7 +79,9 @@
   "compare_banner_label": "Comparison",
   "compare_dismiss": "Dismiss",
   "compare_error_parse": "Invalid JSON file.",
+  "compare_error_read": "File read failed.",
   "compare_error_shape": "File does not look like a Picarones run (engine_reports field missing).",
+  "compare_error_too_large": "File too large ({size_mb} MB) — limit {max_mb} MB.",
   "compare_improvements": "improvements",
   "compare_only_here": "only here",
   "compare_only_other": "only in other",

picarones/reports/i18n/fr.json

@@ -79,7 +79,9 @@
   "compare_banner_label": "Comparaison",
   "compare_dismiss": "Fermer",
   "compare_error_parse": "Fichier JSON invalide.",
+  "compare_error_read": "Lecture du fichier échouée.",
   "compare_error_shape": "Le fichier ne ressemble pas à un run Picarones (champ engine_reports manquant).",
+  "compare_error_too_large": "Fichier trop volumineux ({size_mb} Mo) — limite {max_mb} Mo.",
   "compare_improvements": "améliorations",
   "compare_only_here": "uniquement ici",
   "compare_only_other": "uniquement dans l'autre",

tests/reports/conftest.py

@@ -0,0 +1,57 @@
+"""Fixtures partagées pour les tests de rendu HTML.
+
+Centralise les fixtures coûteuses (génération du rapport démo via
+subprocess) qui étaient auparavant dupliquées dans 9 fichiers de
+test (9× ~9 secondes au worst case).  Scope ``session`` : un seul
+``picarones demo`` par run de pytest, partagé entre tous les fichiers.
+
+Les fixtures ``demo_html`` (FR par défaut) et ``demo_html_en`` sont
+disponibles dans n'importe quel test ``tests/reports/test_*.py`` sans
+import explicite.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+import pytest
+
+
+def _generate_demo(out_path, lang: str) -> str:
+    """Lance ``picarones demo`` via subprocess et retourne le HTML."""
+    result = subprocess.run(
+        [
+            sys.executable, "-m", "picarones", "demo",
+            "--output", str(out_path),
+            "--lang", lang,
+        ],
+        capture_output=True, text=True, timeout=180,
+    )
+    assert result.returncode == 0, (
+        f"`picarones demo --lang {lang}` a échoué :\n"
+        f"stdout: {result.stdout}\nstderr: {result.stderr}"
+    )
+    return out_path.read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="session")
+def demo_html_fr(tmp_path_factory) -> str:
+    """HTML du rapport démo en français (généré une seule fois par run)."""
+    out = tmp_path_factory.mktemp("reports_demo_fr") / "demo.html"
+    return _generate_demo(out, "fr")
+
+
+@pytest.fixture(scope="session")
+def demo_html_en(tmp_path_factory) -> str:
+    """HTML du rapport démo en anglais (généré une seule fois par run)."""
+    out = tmp_path_factory.mktemp("reports_demo_en") / "demo.html"
+    return _generate_demo(out, "en")
+
+
+@pytest.fixture(scope="session")
+def demo_html(demo_html_fr) -> str:
+    """Alias de ``demo_html_fr`` — la majorité des tests utilisent FR
+    par défaut.  Les tests bilingues doivent demander explicitement
+    ``demo_html_fr`` et ``demo_html_en``."""
+    return demo_html_fr

tests/reports/test_engines_diagnostics_view.py

@@ -144,19 +144,38 @@ class TestDiagnosticsRendererContract:
             f"Ordre non canonique : {list(zip(expected_order, positions))}"
         )
 
-    def test_renderer_exception_logged_not_raised(self) -> None:
-        """Si un renderer crash, le composite log un warning mais ne
-        propage pas l'exception (rendu graceful)."""
+    def test_renderer_exception_logged_not_raised(self, caplog) -> None:
+        """Si un renderer crash, le composite log un warning ET ne
+        propage pas l'exception (rendu graceful).
+
+        Vérifie effectivement le log émis (pas juste l'absence
+        d'exception) — auparavant le test ne contrôlait que
+        ``isinstance(html, str)``, ce qui le rendait silencieux à
+        une régression où l'erreur serait avalée sans trace.
+        """
+        import logging
         from picarones.reports.html.renderers.engines_diagnostics import (
             build_engines_diagnostics_section_html,
         )
+        caplog.set_level(logging.WARNING, logger="picarones.reports.html.renderers.engines_diagnostics")
         with patch(
             "picarones.evaluation.metrics.levers.detect_levers",
             side_effect=RuntimeError("boom"),
         ):
-            # Ne doit pas lever
             html = build_engines_diagnostics_section_html({"engines": []}, {})
-            assert isinstance(html, str)
+        # Sortie graceful (pas de raise)
+        assert isinstance(html, str)
+        # Un warning a bien été émis avec préfixe ``[diagnostics.``
+        matching = [
+            r for r in caplog.records
+            if r.levelno == logging.WARNING
+            and "[diagnostics." in r.getMessage()
+            and "boom" in r.getMessage()
+        ]
+        assert matching, (
+            f"aucun warning émis pour l'exception du renderer ; "
+            f"records: {[r.getMessage() for r in caplog.records]}"
+        )
 
 
 # ─────────────────────────────────────────────────────────────────────────────

tests/reports/test_overview_view.py

@@ -201,7 +201,13 @@ class TestOverviewRendererContract:
         # Top 3 : on doit voir e0..e2, plus un footer « + 7 autres »
         html = build_overview_ranking_card_html(report, {}, top_n=3)
         assert html.count("<tr>") == 4  # 1 header + 3 data rows
-        assert "+ 7" in html or "7" in html  # footer mention
+        # Assertion stricte : doit contenir « + 7 » avec le nombre
+        # correct de moteurs cachés (10 - top_n = 7).  L'ancienne
+        # forme ``"7" in html`` était triviale (matchait n'importe
+        # quel ``0.27`` numérique de la table).
+        assert "+ 7" in html, (
+            "footer ne mentionne pas le compte correct des moteurs masqués"
+        )
 
     def test_html_escape_corpus_name(self) -> None:
         """Garde-fou XSS — le nom de corpus est échappé."""

tests/reports/test_xerocr_tokens.py

@@ -174,16 +174,18 @@ _SHARED_TOKENS = (
 def _extract_token_values(css_text: str) -> dict[str, str]:
     """Parse minimaliste : ``--name: value;`` → dict.
 
-    Ne couvre que la première occurrence (celle du ``:root``), ce qui
-    suffit pour les tokens partagés (qui sont tous dans ``:root``).
+    Garde la DERNIÈRE occurrence d'un token : le pattern fallback
+    CSS répète parfois un token (``--fern: #4a7a4f;`` puis
+    ``--fern: oklch(...);`` pour les vieux navigateurs).  La valeur
+    sémantique de référence est la dernière déclaration (celle qui
+    gagne en cascade sur navigateur récent).
     """
     pattern = re.compile(r"(--[a-z][\w-]*)\s*:\s*([^;]+);")
     out: dict[str, str] = {}
     for m in pattern.finditer(css_text):
         name = m.group(1).strip()
         value = m.group(2).strip()
-        if name not in out:  # première occurrence seulement
-            out[name] = value
+        out[name] = value  # dernière occurrence gagne (cascade CSS)
     return out