feat(reports): Phase B6 — rapport HTML multi-vues + extension AltoView

Phase B6 du chantier Option B (mai 2026). La valeur métier ALTO/
documentaire est maintenant visible dans le rapport HTML.

**B6.1 — Extension DEFAULT_ALTO_METRICS (alto_view.py)**
Les métriques textuelles ``alto_text_cer/wer/mer/wil`` (déjà
enregistrées dans le MetricRegistry depuis le Chantier 1) sont
ajoutées aux defaults de ``build_alto_view()``. Total : 7 métriques
(3 structurelles + 4 textuelles). ``reading_order_f1`` reste opt-in
car nécessite une GT READING_ORDER non systématiquement disponible.

**B6.2.a — BenchmarkResult.view_results + converter**
``BenchmarkResult`` a un nouveau champ optionnel
``view_results: dict[str, dict[str, dict[str, dict[str, float]]]]``
indexé ``{view: {engine: {doc: {metric: value}}}}``. Vide pour les
runs legacy ``run_benchmark_via_service``.

``run_result_to_benchmark_result`` (converter) transpose désormais
les ``ViewResult`` du ``RunResult`` vers ce champ : permet au
rapport HTML d'accéder aux métriques par vue sans interroger les
fichiers JSONL natifs.

**B6.2.b — Renderer build_view_results_html (nouveau)**
``picarones/reports/html/renderers/view_results.py`` :
- Une section ``<div class="chart-card view-results-section">`` par
vue présente.
- Titre + note méthodologique FR/EN par vue (text_final,
alto_documentary, searchability) — fallback générique pour les
vues custom.
- Tableau ``Métrique × engine`` avec moyennes par engine
(% si métrique ∈ [0, 1]).
- **Pipelines OMIS listés explicitement** : pattern critique pour
AltoView (un OCR sans expose_alto produit RAW_TEXT seul →
omission silencieuse serait trompeuse).
- Échappement HTML strict (résistance XSS via noms d'engine
custom).
- Adaptive : ``""`` si ``benchmark.view_results`` vide.

Intégration dans ``ReportGenerator._build_section_html`` +
``view_analyses.html`` (placeholder ``view_results_html``).

Tests : 13 cas dans test_view_sections.py
- TestEmptyViewResults (2) : None/dict vide → "".
- TestSingleViewRendering (3) : titre, métriques, "tous éligibles".
- TestOmittedPipelines (1) : OCR text-only listé comme omis
d'AltoView.
- TestMultipleViews (1) : 3 vues canoniques rendues simultanément.
- TestXssEscaping (2) : noms d'engine + métrique avec HTML brut
sont échappés.
- TestI18n (2) : libellés FR/EN.
- TestReportGeneratorIntegration (2) : section présente quand
view_results renseigné, absente sinon (compat ascendante).

État du chantier : checkpoint C3 atteint (valeur métier
documentaire visible dans le rapport HTML). Reste B7 (deprecation
finale) + B8 (suppression legacy).

picarones/app/services/_benchmark_converter.py

@@ -188,12 +188,31 @@ def run_result_to_benchmark_result(
     if fallbacks:
         metadata["importer_fallbacks"] = fallbacks
 
+    # Phase B6 — transpose les ViewResult du RunResult en
+    # ``view_results`` indexé : ``{view: {engine: {doc: {metric: value}}}}``.
+    # Permet au rapport HTML de rendre des sections par vue
+    # (TextView/AltoView/SearchView) avec le détail par pipeline.
+    view_results_by_view: dict[str, dict[str, dict[str, dict[str, float]]]] = {}
+    for doc_idx, run_doc in enumerate(run_result.document_results):
+        if doc_idx >= len(documents):
+            break
+        doc_id = documents[doc_idx].doc_id
+        for vr in run_doc.view_results:
+            view_bucket = view_results_by_view.setdefault(vr.view_name, {})
+            engine_bucket = view_bucket.setdefault(vr.pipeline_name, {})
+            engine_bucket[doc_id] = {
+                metric: float(value)
+                for metric, value in vr.metric_values.items()
+                if isinstance(value, (int, float))
+            }
+
     return BenchmarkResult(
         corpus_name=corpus.name,
         corpus_source=str(corpus.source_path) if corpus.source_path else None,
         document_count=len(documents),
         engine_reports=engine_reports,
         metadata=metadata,
+        view_results=view_results_by_view,
     )
 
 

picarones/evaluation/benchmark_result.py

@@ -527,6 +527,17 @@ class BenchmarkResult:
     # ``None`` si aucun document n'expose de ``script_type`` dans son
     # ``image_quality.script_type`` ou ``metadata.script_type``.
     doc_strata: Optional[dict[str, str]] = None
+    # Phase B6 (mai 2026) — résultats des EvaluationView du
+    # RunOrchestrator (text_final, alto_documentary, searchability).
+    # Structure : ``{view_name: {engine_name: {doc_id: {metric: value}}}}``.
+    # Vide si le run a été lancé sans vues (cas legacy
+    # ``run_benchmark_via_service`` sans RunOrchestrator).
+    # Consommé par le rapport HTML (sections multi-vues) et par le
+    # narrative engine pour mettre en avant les pipelines qui
+    # produisent un ALTO valide vs ceux qui restent en RAW_TEXT seul.
+    view_results: dict[str, dict[str, dict[str, dict[str, float]]]] = field(
+        default_factory=dict,
+    )
 
     def ranking(self) -> list[dict]:
         """Retourne le classement des moteurs trié par **médiane CER** croissante.

picarones/evaluation/views/alto_view.py

@@ -31,6 +31,8 @@ filtre les pipelines dont l'artefact n'est pas dans
 
 Métriques par défaut
 --------------------
+**Structurelles** (typées ``(ALTO_XML, ALTO_XML)``) :
+
 - ``alto_validity`` — l'hypothèse est-elle structurellement
   cohérente ? (≥ 1 page, ≥ 1 bloc, ≥ 1 ligne).
 - ``alto_line_count_ratio`` — ratio min/max du nombre de lignes.
@@ -38,12 +40,24 @@ Métriques par défaut
 
 Toutes ∈ [0, 1] avec ``higher_is_better=True``.
 
+**Textuelles** (Phase B6 — opérent sur le texte extrait de l'ALTO via
+``extract_text_from_alto``) :
+
+- ``alto_text_cer`` — CER calculé sur le texte plat extrait des deux
+  ALTO (référence + hypothèse).  Permet de détecter une régression
+  textuelle même quand la structure est préservée.
+- ``alto_text_wer`` / ``alto_text_mer`` / ``alto_text_wil`` — variantes
+  WER/MER/WIL sur le même texte extrait.
+
 Reportées à un sprint suivant
 -----------------------------
 - ``textline_alignment`` (IoU des bbox de lignes).
 - ``reading_order_consistency`` (Kendall tau sur les IDs).
 - ``layout_f1`` (ICDAR 2015) via wrapper de
   ``evaluation/metrics/layout.py``.
+- ``reading_order_f1`` — nécessite une GT ``READING_ORDER`` qui n'est
+  pas systématiquement disponible dans les corpus.  Opt-in via
+  ``build_alto_view(metric_names=(..., "reading_order_f1"))``.
 """
 
 from __future__ import annotations
@@ -52,12 +66,26 @@ from picarones.domain.artifacts import ArtifactType
 from picarones.domain.evaluation_spec import EvaluationView
 
 
-#: Métriques calculées par défaut.  Toutes typées
-#: ``(ALTO_XML, ALTO_XML)``.
+#: Métriques calculées par défaut.  7 métriques :
+#:
+#: - 3 structurelles ``(ALTO_XML, ALTO_XML)`` (Sprint A14-S15).
+#: - 4 textuelles ``(ALTO_XML, ALTO_XML)`` qui extraient le texte
+#:   plat de l'ALTO via ``extract_text_from_alto`` puis appliquent
+#:   les opérateurs jiwer (Phase B6 mai 2026).
+#:
+#: Les métriques sont enregistrées dans le ``MetricRegistry`` via
+#: ``register_metric`` (cf. ``evaluation/metrics/alto_metrics.py`` et
+#: ``evaluation/metrics/alto_structural.py``).
 DEFAULT_ALTO_METRICS: tuple[str, ...] = (
+    # Structurelles (Sprint A14-S15)
     "alto_validity",
     "alto_line_count_ratio",
     "alto_word_box_coverage",
+    # Textuelles (Phase B6 — extraction texte de l'ALTO)
+    "alto_text_cer",
+    "alto_text_wer",
+    "alto_text_mer",
+    "alto_text_wil",
 )
 
 

picarones/reports/html/generator.py

@@ -345,6 +345,13 @@ class ReportGenerator:
         from picarones.reports.html.renderers.taxonomy_intra_doc import (
             build_taxonomy_intra_doc_html,
         )
+        # Phase B6 (mai 2026) — sections par vue d'évaluation
+        # (text_final, alto_documentary, searchability) issues du
+        # RunOrchestrator.  Adaptive : "" si benchmark.view_results
+        # est vide (chemin legacy sans vues).
+        from picarones.reports.html.renderers.view_results import (
+            build_view_results_html,
+        )
 
         # Spécialisation : construit une map {engine: counts} depuis les
         # ``aggregated_taxonomy`` ; un moteur sans taxonomie est exclu.
@@ -427,6 +434,14 @@ class ReportGenerator:
             "marginal_cost_html": build_marginal_cost_html(
                 report_data.get("marginal_cost"), labels=labels,
             ),
+            # Phase B6 (mai 2026) — sections par vue d'évaluation.
+            "view_results_html": build_view_results_html(
+                self.benchmark.view_results,
+                all_engine_names=[
+                    r.engine_name for r in self.benchmark.engine_reports
+                ],
+                lang=self.lang,
+            ),
         }
 
     @classmethod

picarones/reports/html/renderers/view_results.py

@@ -0,0 +1,262 @@
+"""Phase B6 — rendu HTML des ``BenchmarkResult.view_results``.
+
+Présente les ViewResult produits par le ``RunOrchestrator`` (vues
+canoniques ``text_final``, ``alto_documentary``, ``searchability``)
+sous forme de sections HTML par vue.
+
+Pour chaque vue présente dans ``benchmark.view_results`` :
+
+- Tableau ``engine × moyenne_par_metric`` des métriques de la vue.
+- Liste explicite des **pipelines omis** (qui ne produisent pas
+  d'artefact éligible — typiquement un OCR sans ALTO_XML omis de
+  ``alto_documentary``).
+- Note méthodologique en tête (rappel : ALTO != texte plat).
+
+Adaptive
+--------
+Le renderer retourne ``""`` si ``benchmark.view_results`` est vide
+(cas legacy ``run_benchmark_via_service`` sans RunOrchestrator).
+"""
+
+from __future__ import annotations
+
+import html
+from statistics import mean
+
+
+# Vues canoniques : libellés FR/EN par défaut + warnings courts.
+_VIEW_DESCRIPTORS: dict[str, dict[str, dict[str, str]]] = {
+    "text_final": {
+        "fr": {
+            "title": "Vue textuelle (TextView)",
+            "note": (
+                "Compare les sorties textuelles finales (RAW_TEXT, "
+                "CORRECTED_TEXT) ou projetées (ALTO/PAGE/markdown → "
+                "texte plat).  Les pipelines structurés sont projetés "
+                "vers du texte avant comparaison ; leur structure "
+                "spatiale est ignorée ici."
+            ),
+        },
+        "en": {
+            "title": "Text view (TextView)",
+            "note": (
+                "Compares final text outputs (RAW_TEXT, CORRECTED_TEXT) "
+                "or projected ones (ALTO/PAGE/markdown → flat text).  "
+                "Structured pipelines are projected to flat text before "
+                "comparison ; their spatial structure is ignored here."
+            ),
+        },
+    },
+    "alto_documentary": {
+        "fr": {
+            "title": "Vue documentaire ALTO (AltoView)",
+            "note": (
+                "Mesure la fidélité STRUCTURELLE et TEXTUELLE de l'ALTO "
+                "produit (validité, lignes, bbox, CER/WER sur le texte "
+                "extrait).  Les pipelines qui ne produisent pas d'ALTO "
+                "sont OMIS de cette vue (pas de score factice)."
+            ),
+        },
+        "en": {
+            "title": "ALTO documentary view (AltoView)",
+            "note": (
+                "Measures STRUCTURAL and TEXTUAL fidelity of the "
+                "produced ALTO (validity, lines, bbox, CER/WER on "
+                "extracted text).  Pipelines that don't produce ALTO "
+                "are OMITTED from this view (no fake score)."
+            ),
+        },
+    },
+    "searchability": {
+        "fr": {
+            "title": "Recherchabilité (SearchView)",
+            "note": (
+                "Mesure le rappel fuzzy (Levenshtein ≤ 2) et la "
+                "préservation des séquences numériques (années, "
+                "cotes).  Pertinent pour estimer l'impact d'un pipeline "
+                "sur les moteurs de recherche plein texte (Elastic, Solr)."
+            ),
+        },
+        "en": {
+            "title": "Searchability (SearchView)",
+            "note": (
+                "Measures fuzzy recall (Levenshtein ≤ 2) and "
+                "numerical-sequence preservation (years, call numbers).  "
+                "Relevant to estimate a pipeline's impact on full-text "
+                "search engines (Elastic, Solr)."
+            ),
+        },
+    },
+}
+
+
+def _section_descriptor(view_name: str, lang: str) -> dict[str, str]:
+    """Retourne ``{title, note}`` pour une vue.  Fallback générique
+    pour les vues custom non connues."""
+    descriptor = _VIEW_DESCRIPTORS.get(view_name, {}).get(lang)
+    if descriptor is not None:
+        return descriptor
+    if lang == "en":
+        return {
+            "title": f"View: {view_name}",
+            "note": "Custom view — see runner spec for details.",
+        }
+    return {
+        "title": f"Vue : {view_name}",
+        "note": "Vue custom — voir la spec du runner pour détails.",
+    }
+
+
+def _format_metric(value: float) -> str:
+    """Formate une métrique en pourcentage si ∈ [0, 1], sinon
+    notation courte à 4 décimales."""
+    if 0.0 <= value <= 1.0:
+        return f"{value * 100:.2f}%"
+    return f"{value:.4f}"
+
+
+def _aggregate_view_metrics(
+    engine_buckets: dict[str, dict[str, dict[str, float]]],
+) -> dict[str, dict[str, float]]:
+    """Pour chaque engine, calcule la moyenne de chaque métrique sur
+    tous les documents.  Retourne ``{engine: {metric: mean}}``.
+
+    Une métrique absente d'un doc spécifique est ignorée pour la
+    moyenne (tolérance aux ``failed_metrics`` de la vue).
+    """
+    out: dict[str, dict[str, float]] = {}
+    for engine, doc_buckets in engine_buckets.items():
+        per_metric: dict[str, list[float]] = {}
+        for doc_metrics in doc_buckets.values():
+            for metric, value in doc_metrics.items():
+                if isinstance(value, (int, float)):
+                    per_metric.setdefault(metric, []).append(float(value))
+        out[engine] = {
+            metric: mean(values)
+            for metric, values in per_metric.items()
+            if values
+        }
+    return out
+
+
+def build_view_results_html(
+    view_results: dict[str, dict[str, dict[str, dict[str, float]]]] | None,
+    all_engine_names: list[str],
+    *,
+    lang: str = "fr",
+) -> str:
+    """Construit le HTML des sections par vue.
+
+    Parameters
+    ----------
+    view_results:
+        Map ``{view_name: {engine_name: {doc_id: {metric: value}}}}``
+        produite par ``run_result_to_benchmark_result`` (Phase B6).
+        ``None`` ou vide → retour ``""`` (rapport legacy intact).
+    all_engine_names:
+        Liste de tous les noms d'engines du benchmark, pour identifier
+        les **pipelines omis** par chaque vue.
+    lang:
+        ``"fr"`` (défaut) ou ``"en"`` pour les libellés.
+
+    Returns
+    -------
+    HTML string prêt à être splatté dans ``base.html.j2`` via le
+    placeholder ``{{ view_results_html | safe }}``.
+    """
+    if not view_results:
+        return ""
+
+    sections: list[str] = []
+    all_engines_set = set(all_engine_names)
+    omitted_label = "Pipelines omis" if lang == "fr" else "Omitted pipelines"
+    no_omission_label = (
+        "Tous les pipelines éligibles."
+        if lang == "fr"
+        else "All pipelines eligible."
+    )
+    metric_label = "Métrique" if lang == "fr" else "Metric"
+
+    for view_name in sorted(view_results.keys()):
+        descriptor = _section_descriptor(view_name, lang)
+        engine_buckets = view_results[view_name]
+        aggregated = _aggregate_view_metrics(engine_buckets)
+        eligible_engines = sorted(aggregated.keys())
+        omitted = sorted(all_engines_set - set(eligible_engines))
+
+        # Set de toutes les métriques observées (union sur engines).
+        all_metrics: set[str] = set()
+        for engine_metrics in aggregated.values():
+            all_metrics.update(engine_metrics.keys())
+        sorted_metrics = sorted(all_metrics)
+
+        # En-tête + note méthodologique.
+        section_lines: list[str] = [
+            '<div class="chart-card view-results-section"'
+            ' style="grid-column:1/-1">',
+            f'<h3>{html.escape(descriptor["title"])}</h3>',
+            f'<p class="view-note"><em>{html.escape(descriptor["note"])}'
+            '</em></p>',
+        ]
+
+        if not eligible_engines:
+            section_lines.append(
+                '<p class="view-no-data">'
+                + html.escape(
+                    "Aucun pipeline éligible pour cette vue."
+                    if lang == "fr"
+                    else "No pipeline eligible for this view.",
+                )
+                + "</p>",
+            )
+        else:
+            # Tableau engine × metric.
+            section_lines.append('<table class="view-results-table">')
+            section_lines.append("<thead><tr>")
+            section_lines.append(
+                f'<th>{html.escape(metric_label)}</th>',
+            )
+            for engine in eligible_engines:
+                section_lines.append(
+                    f'<th>{html.escape(engine)}</th>',
+                )
+            section_lines.append("</tr></thead>")
+            section_lines.append("<tbody>")
+            for metric in sorted_metrics:
+                section_lines.append("<tr>")
+                section_lines.append(
+                    f'<td><code>{html.escape(metric)}</code></td>',
+                )
+                for engine in eligible_engines:
+                    value = aggregated.get(engine, {}).get(metric)
+                    cell = (
+                        _format_metric(value)
+                        if value is not None
+                        else "—"
+                    )
+                    section_lines.append(f"<td>{html.escape(cell)}</td>")
+                section_lines.append("</tr>")
+            section_lines.append("</tbody></table>")
+
+        # Pipelines omis (toujours affiché — explicite > silencieux).
+        section_lines.append(
+            f'<p class="view-omitted"><strong>{html.escape(omitted_label)} :'
+            "</strong> ",
+        )
+        if omitted:
+            section_lines.append(
+                ", ".join(f"<code>{html.escape(e)}</code>" for e in omitted),
+            )
+        else:
+            section_lines.append(
+                f"<em>{html.escape(no_omission_label)}</em>",
+            )
+        section_lines.append("</p>")
+
+        section_lines.append("</div>")
+        sections.append("\n".join(section_lines))
+
+    return "\n".join(sections)
+
+
+__all__ = ["build_view_results_html"]

picarones/reports/html/templates/view_analyses.html

@@ -209,6 +209,14 @@
     </div>
     {% endif %}
 
+    <!-- Phase B6 (mai 2026) — sections par EvaluationView du
+         RunOrchestrator (text_final, alto_documentary, searchability).
+         Adaptive : n'apparaît que si benchmark.view_results est non
+         vide (chemin via RunOrchestrator). -->
+    {% if view_results_html %}
+    {{ view_results_html | safe }}
+    {% endif %}
+
     <!-- Sprint 86 — A.II.5 : recherchabilité fuzzy + précision sur
          séquences numériques. Adaptive : n'apparaît que si au moins
          un moteur a du signal. -->

tests/evaluation/views/test_sprint_a14_s15_alto_view.py

@@ -13,6 +13,12 @@ from picarones.domain import (
     ArtifactType,
     MetricSpec,
 )
+from picarones.evaluation.metrics.alto_metrics import (
+    alto_text_cer,
+    alto_text_mer,
+    alto_text_wer,
+    alto_text_wil,
+)
 from picarones.evaluation.metrics.alto_structural import (
     compute_alto_validity,
     compute_line_count_ratio,
@@ -133,9 +139,16 @@ class TestAltoViewShape:
     def test_default_metrics(self) -> None:
         view = build_alto_view()
         assert view.metric_names == DEFAULT_ALTO_METRICS
+        # 3 métriques structurelles (Sprint A14-S15).
         assert "alto_validity" in view.metric_names
         assert "alto_line_count_ratio" in view.metric_names
         assert "alto_word_box_coverage" in view.metric_names
+        # 4 métriques textuelles ajoutées en Phase B6 — opèrent sur le
+        # texte plat extrait de l'ALTO via ``extract_text_from_alto``.
+        assert "alto_text_cer" in view.metric_names
+        assert "alto_text_wer" in view.metric_names
+        assert "alto_text_mer" in view.metric_names
+        assert "alto_text_wil" in view.metric_names
 
     def test_no_projection(self) -> None:
         view = build_alto_view()
@@ -180,6 +193,44 @@ def _build_alto_executor(payloads: dict[str, AltoDocument]) -> DefaultEvaluation
         ),
         compute_word_box_coverage,
     )
+    # Phase B6 — métriques textuelles ajoutées aux defaults AltoView.
+    # Elles attendent un payload qui expose ``xml_content`` ou un
+    # str XML brut (cf. ``extract_text_from_alto``).  Les payloads
+    # ``AltoDocument`` typés du test échouent silencieusement dans
+    # cette extraction → CER 1.0.  On les enregistre quand même pour
+    # vérifier le wiring registry/executor.
+    metrics.register(
+        MetricSpec(
+            name="alto_text_cer",
+            input_types=(ArtifactType.ALTO_XML, ArtifactType.ALTO_XML),
+            higher_is_better=False,
+        ),
+        alto_text_cer,
+    )
+    metrics.register(
+        MetricSpec(
+            name="alto_text_wer",
+            input_types=(ArtifactType.ALTO_XML, ArtifactType.ALTO_XML),
+            higher_is_better=False,
+        ),
+        alto_text_wer,
+    )
+    metrics.register(
+        MetricSpec(
+            name="alto_text_mer",
+            input_types=(ArtifactType.ALTO_XML, ArtifactType.ALTO_XML),
+            higher_is_better=False,
+        ),
+        alto_text_mer,
+    )
+    metrics.register(
+        MetricSpec(
+            name="alto_text_wil",
+            input_types=(ArtifactType.ALTO_XML, ArtifactType.ALTO_XML),
+            higher_is_better=False,
+        ),
+        alto_text_wil,
+    )
     projectors = ProjectorRegistry()  # AltoView n'a pas besoin de projecteur
 
     def loader(art: Artifact) -> AltoDocument:

tests/reports/test_view_sections.py

@@ -0,0 +1,292 @@
+"""Phase B6 — rendu HTML des ``BenchmarkResult.view_results``.
+
+Vérifie que le renderer ``build_view_results_html`` :
+
+1. Retourne ``""`` quand ``view_results`` est vide ou ``None`` (compat
+   ascendante : un BenchmarkResult issu de
+   ``run_benchmark_via_service`` sans RunOrchestrator n'a pas de
+   ``view_results``).
+2. Génère une section par vue présente, avec titre + note
+   méthodologique + tableau engine × moyenne_par_metric.
+3. Liste explicitement les pipelines OMIS de chaque vue (= ceux qui
+   n'ont pas produit d'artefact éligible).
+4. Échappe le HTML correctement (résistance XSS via noms d'engine
+   custom).
+5. S'intègre proprement dans le rapport HTML complet (test bout-en-bout
+   via ``ReportGenerator``).
+"""
+
+from __future__ import annotations
+
+from picarones.evaluation.benchmark_result import BenchmarkResult, EngineReport
+from picarones.evaluation.metric_result import MetricsResult
+from picarones.reports.html.renderers.view_results import (
+    build_view_results_html,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────
+
+
+def _make_engine_report(name: str) -> EngineReport:
+    return EngineReport(
+        engine_name=name,
+        engine_version="test",
+        engine_config={},
+        document_results=[],
+        aggregated_metrics={},
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Renderer adaptatif (cas vides)
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestEmptyViewResults:
+    def test_none_returns_empty_string(self) -> None:
+        assert build_view_results_html(None, all_engine_names=["t"]) == ""
+
+    def test_empty_dict_returns_empty_string(self) -> None:
+        assert build_view_results_html({}, all_engine_names=["t"]) == ""
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Rendu d'une vue avec données
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestSingleViewRendering:
+    def _sample_view_results(
+        self,
+    ) -> dict[str, dict[str, dict[str, dict[str, float]]]]:
+        return {
+            "text_final": {
+                "tesseract": {
+                    "doc1": {"cer": 0.05, "wer": 0.10},
+                    "doc2": {"cer": 0.03, "wer": 0.08},
+                },
+            },
+        }
+
+    def test_section_contains_view_title(self) -> None:
+        html = build_view_results_html(
+            self._sample_view_results(), all_engine_names=["tesseract"],
+        )
+        assert "TextView" in html
+        # Note méthodologique présente.
+        assert "projetées" in html.lower() or "projeté" in html.lower()
+
+    def test_section_contains_engine_metrics_table(self) -> None:
+        html = build_view_results_html(
+            self._sample_view_results(), all_engine_names=["tesseract"],
+        )
+        # Header + métrique + valeur.
+        assert "tesseract" in html
+        assert "cer" in html
+        assert "wer" in html
+        # Moyenne CER : (0.05 + 0.03) / 2 = 0.04 → 4.00%.
+        assert "4.00%" in html
+        # Moyenne WER : (0.10 + 0.08) / 2 = 0.09 → 9.00%.
+        assert "9.00%" in html
+
+    def test_no_omitted_when_all_eligible(self) -> None:
+        html = build_view_results_html(
+            self._sample_view_results(), all_engine_names=["tesseract"],
+        )
+        # "Tous les pipelines éligibles" affiché car aucun n'est omis.
+        assert "éligibles" in html or "eligible" in html.lower()
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Pipelines omis (cas AltoView avec engine OCR pur)
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestOmittedPipelines:
+    def test_alto_view_omits_text_only_engine(self) -> None:
+        """Cas typique : AltoView ne reçoit que des résultats du
+        pipeline qui produit ALTO.  Un pipeline OCR seul est omis."""
+        view_results = {
+            "alto_documentary": {
+                "tesseract_alto": {
+                    "doc1": {"alto_validity": 1.0},
+                },
+                # Pas de "tesseract_text_only" → omis de cette vue
+            },
+        }
+        html = build_view_results_html(
+            view_results,
+            all_engine_names=["tesseract_alto", "tesseract_text_only"],
+        )
+        assert "tesseract_alto" in html
+        # tesseract_text_only listé dans Pipelines omis.
+        assert "tesseract_text_only" in html
+        # Le label "Pipelines omis" est présent.
+        assert "omis" in html.lower() or "omitted" in html.lower()
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Multi-vues (le cas typique de production)
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestMultipleViews:
+    def test_renders_three_canonical_views(self) -> None:
+        view_results = {
+            "text_final": {
+                "tesseract": {"doc1": {"cer": 0.1}},
+            },
+            "alto_documentary": {
+                "tesseract": {"doc1": {"alto_validity": 1.0}},
+            },
+            "searchability": {
+                "tesseract": {"doc1": {"searchability_recall": 0.95}},
+            },
+        }
+        html = build_view_results_html(
+            view_results, all_engine_names=["tesseract"],
+        )
+        assert "TextView" in html
+        assert "AltoView" in html
+        assert "SearchView" in html
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Sécurité — XSS via noms d'engine custom
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestXssEscaping:
+    def test_engine_name_with_html_chars_is_escaped(self) -> None:
+        view_results = {
+            "text_final": {
+                "<script>alert(1)</script>": {"doc1": {"cer": 0.1}},
+            },
+        }
+        html = build_view_results_html(
+            view_results, all_engine_names=["<script>alert(1)</script>"],
+        )
+        # Le HTML brut ne doit pas apparaître non échappé.
+        assert "<script>" not in html
+        # L'entité échappée est présente.
+        assert "&lt;script&gt;" in html
+
+    def test_metric_name_with_html_chars_is_escaped(self) -> None:
+        view_results = {
+            "text_final": {
+                "tesseract": {"doc1": {"<weird>": 0.1}},
+            },
+        }
+        html = build_view_results_html(
+            view_results, all_engine_names=["tesseract"],
+        )
+        assert "<weird>" not in html
+        assert "&lt;weird&gt;" in html
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Internationalization
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestI18n:
+    def _sample(self) -> dict:
+        return {
+            "alto_documentary": {
+                "tess": {"doc1": {"alto_validity": 1.0}},
+            },
+        }
+
+    def test_french_default_labels(self) -> None:
+        html = build_view_results_html(
+            self._sample(), all_engine_names=["tess", "other"], lang="fr",
+        )
+        assert "documentaire" in html.lower()
+        assert "pipelines omis" in html.lower()
+
+    def test_english_labels(self) -> None:
+        html = build_view_results_html(
+            self._sample(), all_engine_names=["tess", "other"], lang="en",
+        )
+        assert "documentary" in html.lower()
+        assert "omitted pipelines" in html.lower()
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Intégration avec ReportGenerator
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestReportGeneratorIntegration:
+    def _make_benchmark(
+        self, with_view_results: bool,
+    ) -> BenchmarkResult:
+        # Document minimal.  Les hooks et agrégats sont vides — on
+        # teste juste la présence/absence de la section view_results.
+        from picarones.evaluation.benchmark_result import DocumentResult
+
+        engine = EngineReport(
+            engine_name="tesseract",
+            engine_version="5.x",
+            engine_config={},
+            document_results=[
+                DocumentResult(
+                    doc_id="doc1",
+                    image_path="/tmp/doc1.png",
+                    ground_truth="Bonjour",
+                    hypothesis="Bonjour",
+                    metrics=MetricsResult(
+                        cer=0.0, cer_nfc=0.0, cer_caseless=0.0,
+                        wer=0.0, wer_normalized=0.0, mer=0.0, wil=0.0,
+                        reference_length=7, hypothesis_length=7,
+                    ),
+                    duration_seconds=0.1,
+                ),
+            ],
+            aggregated_metrics={},
+        )
+        view_results: dict = {}
+        if with_view_results:
+            view_results = {
+                "text_final": {
+                    "tesseract": {"doc1": {"cer": 0.0, "wer": 0.0}},
+                },
+                "alto_documentary": {
+                    # Aucun engine n'a produit d'ALTO ici → vue vide
+                    # mais tesseract est listé comme omis.
+                },
+            }
+        return BenchmarkResult(
+            corpus_name="test_corpus",
+            corpus_source=None,
+            document_count=1,
+            engine_reports=[engine],
+            view_results=view_results,
+        )
+
+    def test_report_includes_view_section_when_present(self, tmp_path) -> None:
+        from picarones.reports.html.generator import ReportGenerator
+
+        bm = self._make_benchmark(with_view_results=True)
+        out = tmp_path / "report.html"
+        ReportGenerator(bm, lang="fr").generate(out)
+
+        html = out.read_text(encoding="utf-8")
+        assert "TextView" in html
+        assert "AltoView" in html
+
+    def test_report_omits_view_section_when_absent(self, tmp_path) -> None:
+        """Compat ascendante : sans view_results, le rapport HTML
+        legacy est intact (aucune section `view-results-section`)."""
+        from picarones.reports.html.generator import ReportGenerator
+
+        bm = self._make_benchmark(with_view_results=False)
+        out = tmp_path / "report.html"
+        ReportGenerator(bm, lang="fr").generate(out)
+
+        html = out.read_text(encoding="utf-8")
+        # Le marker CSS du renderer view_results doit être absent.
+        assert "view-results-section" not in html