test(integration): Sprint A14-S12 — équivalence numérique runner ↔ pipeline

Sprint S12 du plan rewrite ciblé. **Critère go/no-go fin de
Phase 2** atteint.

Vérifie que le ``CorpusRunner`` (S8) + ``PipelineExecutor`` (S7)
produisent **les mêmes** CER/WER que l'ancien
``measurements.runner.run_benchmark`` quand on leur injecte des
textes hypothèses identiques sur le même corpus.

Méthode
-------
Construit deux orchestrations consommant le même corpus :

- ``_FakeOCREngine`` (héritant de ``BaseOCREngine``) pour
l'ancien runner.
- ``_FakeStepExecutor`` (satisfaisant le protocole
``StepExecutor``) pour le nouveau ``CorpusRunner``.

Les deux retournent le **même texte** par document, indexé par
``doc_id``. Le test calcule CER/WER avec le même
``compute_metrics`` sur les sorties des deux et compare.

Tolérance assumée : 1e-6 (et non 1e-9 du plan original)
-------------------------------------------------------
Les valeurs brutes sont identiques bit-à-bit entre les deux
runners. La divergence observée (~1e-7) provient strictement de
``aggregate_metrics`` de l'ancien runner qui arrondit ``mean`` à
6 décimales (cf. ``picarones/core/metrics.py:_stats``).

La tolérance ``1e-6`` est cohérente avec ces 6 décimales. Quand
l'agrégation finale passera par les types non-arrondis du nouveau
code (S22), la tolérance pourra être resserrée à 1e-9.

Documentation associée
----------------------
``docs/migration/executor-equivalence.md`` documente :

- L'architecture des deux orchestrations en parallèle.
- La méthode de vérification.
- La justification de la tolérance 1e-6.
- Les 5 fixtures patrimoniales testées + 2 cas limites.
- Les conséquences pour la migration BnF.
- Les limites du S12 et ce qui reste à vérifier en S13/S15/S20.

7 nouveaux tests
----------------
``tests/integration/test_sprint_a14_s12_executor_equivalence.py`` :

- 5 tests paramétrés sur des fixtures de difficulté croissante :
* fixture_1_court : mots isolés, hypothèse parfaite
* fixture_2_paragraphe : phrase avec coquille
* fixture_3_multi_lignes : multi-lignes + accents perdus
* fixture_4_abreviations : bibliographie + date erronée
* fixture_5_mix_langues : latin + français, multiples coquilles

- 2 cas limites :
* test_equivalence_with_perfect_hypothesis : CER == WER == 0
* test_equivalence_with_empty_hypothesis : texte produit vide

Tous passent à 1e-6 près sur les 7 cas.

Conséquence pour la migration BnF
---------------------------------
À partir du S12, on peut affirmer que basculer un benchmark BnF
du runner legacy vers ``CorpusRunner`` :

- ne change PAS les chiffres rapportés au-delà de l'arrondi 6 déc.
- apporte 3 améliorations non visibles dans les chiffres :
1. Backpressure (RAM bornée même sur 1000+ docs).
2. Timeout depuis le **début d'exécution** (pas la queue).
3. Annulation propre via ``threading.Event``.

Limites assumées (à lever en S13-S20)
-------------------------------------
L'équivalence S12 porte uniquement sur :
- Pipeline OCR mono-step (1 texte produit → CER/WER).
- Métriques principales ``mean_cer`` / ``mean_wer``.

Restent à vérifier :
- S13 : équivalence projecteurs ALTO → texte (vs
``alto_metrics.extract_text_from_alto`` legacy).
- S15 : équivalence métriques structurelles (Layout F1, RO F1).
- S20 : équivalence métriques philologiques (MUFI, etc.) — bloqué
par migration des fichiers ``@register_metric``.

État de la suite
----------------
``pytest tests/ -q`` → 4170 passed, 8 skipped, 2 failed
(strictement environnementaux). +7 tests vs S11. Aucune
régression S12.

**Phase 2 du rewrite terminée.** Prêt pour S13 (vues
d'évaluation : EvaluationViewExecutor + TextView).

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

docs/migration/executor-equivalence.md

@@ -0,0 +1,165 @@
+# Équivalence numérique — ancien runner ↔ nouveau pipeline executor
+
+Ce document décrit comment le `CorpusRunner` introduit au Sprint S8
+(combiné au `PipelineExecutor` du S7) reproduit les mêmes chiffres
+CER/WER que l'ancien `picarones.measurements.runner.run_benchmark`.
+
+C'est le **critère go/no-go de fin de Phase 2** du rewrite ciblé
+(cf. `docs/roadmap/rewrite-2026.md`).  Sans cette équivalence, on
+ne peut pas basculer la BnF vers le nouveau runner sans surprise.
+
+## Architecture des deux orchestrations
+
+### Ancien runner (`picarones.measurements.runner`)
+
+```
+Corpus[Document(image, GT)]
+     │
+     ▼
+run_benchmark(corpus, [BaseOCREngine])
+     │
+     ▼ ProcessPoolExecutor / ThreadPoolExecutor
+BaseOCREngine.run(image)  →  EngineResult(text, ...)
+     │
+     ▼
+compute_metrics(GT, text)  →  MetricsResult(cer, wer, ...)
+     │
+     ▼
+aggregate_metrics([MetricsResult, ...])  →  {"cer": {"mean": 0.05}, ...}
+     │
+     ▼
+EngineReport(mean_cer=0.05, ...)
+```
+
+### Nouveau pipeline (`picarones.pipeline`)
+
+```
+[DocumentRef], initial_inputs={IMAGE: Artifact}
+     │
+     ▼
+CorpusRunner.run(spec, docs, factory_inputs, factory_ctx)
+     │
+     ▼ ThreadPoolExecutor avec backpressure
+PipelineExecutor.run(spec, doc, inputs, ctx)
+     │
+     ▼ pour chaque step
+StepExecutor.execute(inputs, params, ctx)  →  {RAW_TEXT: Artifact}
+     │
+     ▼ (S13+ : EvaluationViewExecutor)
+TextView.evaluate(candidate, ground_truth)  →  ViewResult(metric_values)
+```
+
+Le S12 ne livre pas encore l'`EvaluationViewExecutor` — il vérifie
+juste que **si on appelle ``compute_metrics`` directement sur les
+artefacts produits par le nouveau pipeline**, on obtient les mêmes
+valeurs.  Le S13-S14 livrera la couche `TextView` qui fera ce
+calcul automatiquement.
+
+## Méthode de vérification (test d'équivalence)
+
+Le test `tests/integration/test_sprint_a14_s12_executor_equivalence.py`
+implémente l'équivalence :
+
+1. **Construit deux orchestrations** consommant exactement le même
+   corpus :
+   - `_FakeOCREngine` (héritant de `BaseOCREngine`) pour l'ancien
+     runner.
+   - `_FakeStepExecutor` (satisfaisant le protocole `StepExecutor`)
+     pour le nouveau.
+   - Les deux retournent **le même texte** par document, indexé par
+     `doc_id`.
+
+2. **Lance les deux runners** sur le même corpus.
+
+3. **Calcule CER/WER avec le même `compute_metrics`** sur les
+   sorties des deux runners.
+
+4. **Compare** les moyennes CER et WER.
+
+## Tolérance : 1e-6, pas 1e-9
+
+Le plan d'origine prévoyait une tolérance de **1e-9** ("équivalence
+numérique stricte").  La réalité du code montre une divergence de
+l'ordre de **1e-7** sur certaines fixtures, **uniquement à cause
+d'un arrondi à 6 décimales** dans `aggregate_metrics` de l'ancien
+runner :
+
+```python
+# picarones/core/metrics.py — _stats()
+return {
+    "mean": round(statistics.mean(values), 6),
+    "median": round(statistics.median(values), 6),
+    ...
+}
+```
+
+Les valeurs brutes (avant `round`) sont identiques bit-à-bit
+entre les deux runners.  La divergence observée provient
+strictement du `round(..., 6)`.
+
+Le test S12 utilise donc une tolérance **1e-6** (cohérente avec les
+6 décimales d'arrondi) et documente cette décision.  Quand
+l'agrégation finale passera par les types non-arrondis du nouveau
+code (S22), la tolérance pourra être resserrée à 1e-9.
+
+## 5 fixtures patrimoniales testées
+
+Le test couvre 5 cas de difficulté croissante :
+
+| Fixture | Description |
+|---|---|
+| `fixture_1_court` | Mots isolés, hypothèse parfaite |
+| `fixture_2_paragraphe` | Phrases avec une coquille |
+| `fixture_3_multi_lignes` | Multi-lignes + accents perdus |
+| `fixture_4_abreviations` | Bibliographie + date erronée |
+| `fixture_5_mix_langues` | Latin + français, multiples coquilles |
+
+Plus deux cas limites :
+
+- `test_equivalence_with_perfect_hypothesis` — CER == WER == 0
+- `test_equivalence_with_empty_hypothesis` — texte produit vide
+
+Total : **7 tests d'équivalence**, tous verts.
+
+## Conséquences pour la migration BnF
+
+À partir du S12, on peut affirmer que :
+
+- Basculer un benchmark BnF du runner legacy vers le nouveau
+  `CorpusRunner` ne change pas les chiffres rapportés au-delà de
+  l'arrondi à 6 décimales.
+- Les rapports HTML produits depuis le nouveau pipeline (S22)
+  afficheront les mêmes CER que les rapports historiques (modulo
+  arrondi).
+- Le nouveau `CorpusRunner` apporte **trois améliorations** non
+  visibles côté chiffres :
+  1. Backpressure (RAM bornée même sur 1000+ docs).
+  2. Timeout depuis le **début d'exécution** (pas la queue).
+  3. Annulation propre via `threading.Event`.
+
+## Limites du S12
+
+L'équivalence vérifiée ici porte uniquement sur :
+
+- Le pipeline OCR seul (un step → un texte → CER/WER).
+- Les métriques principales `mean_cer` / `mean_wer`.
+
+Restent à vérifier dans des sprints suivants :
+
+- **S13** : équivalence des projecteurs (ALTO → texte) — couvert
+  par les tests unitaires de `formats.alto.projector` mais pas
+  encore comparé à `extract_text_from_alto` legacy.
+- **S15** : équivalence des métriques structurelles (Layout F1,
+  reading order F1) — non testées en S12 car elles vivent dans
+  des fichiers `measurements/*.py` non encore migrés.
+- **S20** : équivalence des métriques philologiques (MUFI,
+  abbreviations, etc.) — idem.
+
+Quand ces sprints ajouteront leurs tests d'équivalence, le critère
+"équivalence numérique fin Phase 3 / Phase 4" sera complet.
+
+## Statut
+
+- **Fin de Phase 2 (S12)** — équivalence runner OCR ✅
+- **Fin de Phase 3 (S18)** — équivalence views ouverte (S13-S18)
+- **Fin de Phase 4 (S22)** — équivalence rapport HTML ouverte

tests/integration/test_sprint_a14_s12_executor_equivalence.py

@@ -0,0 +1,374 @@
+"""Sprint A14-S12 — équivalence numérique nouveau runner ↔ ancien runner.
+
+Critère go/no-go fin de Phase 2 : sur 5 fixtures patrimoniales
+synthétiques, le ``CorpusRunner`` (S8) doit produire **exactement
+les mêmes** CER/WER que l'ancien ``measurements.runner.run_benchmark``
+quand on lui injecte des textes hypothèses identiques.
+
+Méthode
+-------
+On construit deux orchestrations qui consomment exactement la même
+``Corpus`` et produisent exactement les mêmes textes hypothèses :
+
+- **Ancien runner** : ``FakeOCREngine`` héritant de ``BaseOCREngine``
+  retourne le texte mappé pour chaque document.
+  ``measurements.runner.run_benchmark`` calcule CER/WER via
+  ``compute_metrics`` (jiwer).
+- **Nouveau runner** : ``FakeStepExecutor`` satisfait le protocole
+  ``StepExecutor`` du S6 et retourne un ``Artifact`` RAW_TEXT avec le
+  même texte (stocké dans un dict partagé pour pouvoir le récupérer
+  côté test).  ``CorpusRunner.run`` orchestre en threads avec
+  backpressure, on récupère le texte produit par chaque doc et on
+  calcule CER/WER avec **le même** ``compute_metrics``.
+
+Si les deux produisent le même texte sur les mêmes documents,
+``compute_metrics`` doit produire exactement les mêmes valeurs CER
+et WER (jiwer est déterministe).  Le test vérifie cette équivalence
+à 1e-9 près sur 5 fixtures de difficulté croissante.
+
+Bénéfice scientifique
+---------------------
+Tant que ce test passe, on peut affirmer que basculer de l'ancien
+au nouveau runner ne change PAS les chiffres rapportés.  C'est la
+condition nécessaire pour bascular les utilisateurs (BnF) vers le
+nouveau runner sans surprise.
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any
+
+import pytest
+
+from picarones.core.corpus import Corpus, Document
+from picarones.domain import Artifact, ArtifactType, DocumentRef
+from picarones.engines.base import BaseOCREngine, EngineResult
+from picarones.measurements.metrics import compute_metrics
+from picarones.measurements.runner import run_benchmark
+from picarones.pipeline import (
+    CorpusRunner,
+    PipelineExecutor,
+    PipelineSpec,
+    PipelineStep,
+    RunContext,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Stubs partagés entre les deux orchestrations
+# ──────────────────────────────────────────────────────────────────────
+
+
+class _FakeOCREngine(BaseOCREngine):
+    """OCR fake pour le runner legacy.  Retourne un texte fixe par
+    document, indexé par ``doc_id``."""
+
+    @property
+    def name(self) -> str:
+        return "fake_ocr"
+
+    def version(self) -> str:
+        return "fake-1.0"
+
+    def __init__(self, text_per_doc: dict[str, str]) -> None:
+        super().__init__(config={})
+        self._text_per_doc = text_per_doc
+        self._lookup_lock = threading.Lock()
+
+    def _run_ocr(self, image_path: Any) -> str:
+        # Pour le test, on encode le ``doc_id`` dans le nom du fichier
+        # ``<doc_id>.png`` que le caller du test crée dans tmp_path.
+        from pathlib import Path
+        doc_id = Path(image_path).stem
+        with self._lookup_lock:
+            return self._text_per_doc.get(doc_id, "")
+
+
+class _FakeStepExecutor:
+    """Adapter fake pour le nouveau runner.  Retourne un ``Artifact``
+    RAW_TEXT avec un texte fixe par document, partagé via dict
+    externe pour récupération côté test."""
+
+    name = "fake_ocr"
+    input_types = frozenset({ArtifactType.IMAGE})
+    output_types = frozenset({ArtifactType.RAW_TEXT})
+    execution_mode = "io"
+
+    def __init__(
+        self,
+        text_per_doc: dict[str, str],
+        produced_text_log: dict[str, str],
+    ) -> None:
+        self._text_per_doc = text_per_doc
+        self._produced = produced_text_log
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict,
+        context: RunContext,
+    ) -> dict[ArtifactType, Artifact]:
+        text = self._text_per_doc.get(context.document_id, "")
+        artifact_id = f"{context.document_id}:fake_ocr:raw_text"
+        # Stocke le texte côté test pour le calcul CER/WER hors orchestrateur.
+        self._produced[context.document_id] = text
+        return {
+            ArtifactType.RAW_TEXT: Artifact(
+                id=artifact_id,
+                document_id=context.document_id,
+                type=ArtifactType.RAW_TEXT,
+                produced_by_step="fake_ocr",
+            ),
+        }
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Fixtures patrimoniales (5 cas de difficulté croissante)
+# ──────────────────────────────────────────────────────────────────────
+
+
+_FIXTURES: list[tuple[str, dict[str, str], dict[str, str]]] = [
+    # (nom, GT_par_doc, hypothèse_par_doc)
+    (
+        "fixture_1_court",
+        {
+            "doc01": "Bonjour",
+            "doc02": "Monde",
+        },
+        {
+            "doc01": "Bonjour",
+            "doc02": "Monde",  # parfait
+        },
+    ),
+    (
+        "fixture_2_paragraphe",
+        {
+            "doc01": "Le petit chat noir court dans le jardin verdoyant.",
+            "doc02": "Une vieille horloge sonne au lointain de la rue.",
+        },
+        {
+            "doc01": "Le pelit chat noir court dans le jardin verdoyant.",
+            "doc02": "Une vieille horloge sonne au lointain de la rue.",
+        },
+    ),
+    (
+        "fixture_3_multi_lignes",
+        {
+            "doc01": "Première ligne\nDeuxième ligne\nTroisième ligne",
+            "doc02": "Texte sur\ndeux lignes",
+        },
+        {
+            "doc01": "Premiere ligne\nDeuxieme ligne\nTroisieme ligne",
+            "doc02": "Texte sur\ndeux lignes",
+        },
+    ),
+    (
+        "fixture_4_abreviations",
+        {
+            "doc01": "M. Dupont, p. 12, vol. III, art. cit.",
+            "doc02": "fait à Paris le 1er janvier 1789.",
+        },
+        {
+            "doc01": "M. Dupont, p. 12, vol. III, art. cit.",
+            "doc02": "fait à Paris le 1er janvier 1798.",  # erreur date
+        },
+    ),
+    (
+        "fixture_5_mix_langues",
+        {
+            "doc01": "In nomine patris et filii et spiritus sancti",
+            "doc02": "L'amour vainc tout, et nous cédons à l'amour",
+        },
+        {
+            "doc01": "In nomne patris et filii et spritus sancti",
+            "doc02": "L'amour vainc tout, et nous cedons à l'amour",
+        },
+    ),
+]
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────
+
+
+def _build_corpus(
+    tmp_path: Any,
+    gt_per_doc: dict[str, str],
+) -> tuple[Corpus, list[DocumentRef]]:
+    """Construit un Corpus legacy + une liste de DocumentRef nouvelle.
+
+    Crée des fichiers PNG vides pour satisfaire les contrats fs.
+    """
+    from pathlib import Path
+    docs_legacy = []
+    docs_new = []
+    for doc_id, gt in gt_per_doc.items():
+        img_path = Path(tmp_path) / f"{doc_id}.png"
+        img_path.write_bytes(b"\x89PNG\r\n\x1a\n")  # entête PNG minimal
+        docs_legacy.append(Document(
+            image_path=img_path,
+            ground_truth=gt,
+        ))
+        docs_new.append(DocumentRef(
+            id=doc_id,
+            image_uri=str(img_path),
+        ))
+    corpus = Corpus(
+        name="equivalence_test",
+        documents=docs_legacy,
+        source_path=str(tmp_path),
+    )
+    return corpus, docs_new
+
+
+def _run_old_runner(
+    corpus: Corpus,
+    hypothesis_per_doc: dict[str, str],
+) -> tuple[float | None, float | None]:
+    """Exécute l'ancien runner et retourne (mean_cer, mean_wer)."""
+    engine = _FakeOCREngine(text_per_doc=hypothesis_per_doc)
+    result = run_benchmark(
+        corpus=corpus,
+        engines=[engine],
+        show_progress=False,
+        max_workers=2,
+    )
+    report = result.engine_reports[0]
+    return report.mean_cer, report.mean_wer
+
+
+def _run_new_runner(
+    docs: list[DocumentRef],
+    hypothesis_per_doc: dict[str, str],
+    gt_per_doc: dict[str, str],
+) -> tuple[float | None, float | None]:
+    """Exécute le nouveau runner et retourne (mean_cer, mean_wer)
+    calculé avec le **même** ``compute_metrics`` que l'ancien."""
+    produced: dict[str, str] = {}
+    fake = _FakeStepExecutor(
+        text_per_doc=hypothesis_per_doc,
+        produced_text_log=produced,
+    )
+    registry = {"fake_ocr": fake}
+    executor = PipelineExecutor(adapter_resolver=lambda n: registry[n])
+    runner = CorpusRunner(
+        executor,
+        max_in_flight=2,
+        timeout_seconds_per_doc=60.0,
+        poll_interval_seconds=0.005,
+    )
+    spec = PipelineSpec(
+        name="equivalence",
+        initial_inputs=(ArtifactType.IMAGE,),
+        steps=(PipelineStep(
+            id="ocr", kind="ocr", adapter_name="fake_ocr",
+            input_types=(ArtifactType.IMAGE,),
+            output_types=(ArtifactType.RAW_TEXT,),
+        ),),
+    )
+
+    def _factory_inputs(doc: DocumentRef) -> dict[ArtifactType, Artifact]:
+        return {ArtifactType.IMAGE: Artifact(
+            id=f"{doc.id}:image", document_id=doc.id,
+            type=ArtifactType.IMAGE, uri=doc.image_uri,
+        )}
+
+    def _factory_ctx(doc: DocumentRef) -> RunContext:
+        return RunContext(
+            document_id=doc.id,
+            code_version="1.0.0",
+            pipeline_name="equivalence",
+        )
+
+    result = runner.run(
+        spec, docs, _factory_inputs, _factory_ctx,
+        corpus_name="equivalence_test",
+    )
+    assert result.n_succeeded == len(docs), result
+
+    # Calcule CER/WER avec le même compute_metrics que l'ancien runner.
+    cers, wers = [], []
+    for doc in docs:
+        gt = gt_per_doc[doc.id]
+        hyp = produced[doc.id]
+        m = compute_metrics(gt, hyp)
+        if m.error is None and m.cer is not None:
+            cers.append(m.cer)
+        if m.error is None and m.wer is not None:
+            wers.append(m.wer)
+    mean_cer = sum(cers) / len(cers) if cers else None
+    mean_wer = sum(wers) / len(wers) if wers else None
+    return mean_cer, mean_wer
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Tests d'équivalence
+# ──────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    ("name", "gt_per_doc", "hyp_per_doc"),
+    _FIXTURES,
+    ids=[f[0] for f in _FIXTURES],
+)
+def test_old_and_new_runner_produce_same_cer_wer(
+    tmp_path,
+    name: str,
+    gt_per_doc: dict[str, str],
+    hyp_per_doc: dict[str, str],
+) -> None:
+    """Sur la fixture ``name``, l'ancien et le nouveau runner doivent
+    produire des CER/WER identiques à 1e-9 près."""
+    corpus, docs = _build_corpus(tmp_path, gt_per_doc)
+
+    old_cer, old_wer = _run_old_runner(corpus, hyp_per_doc)
+    new_cer, new_wer = _run_new_runner(docs, hyp_per_doc, gt_per_doc)
+
+    assert old_cer is not None and new_cer is not None
+    assert old_wer is not None and new_wer is not None
+
+    # Tolérance 1e-6 (et non 1e-9 du plan original) parce que
+    # ``aggregate_metrics`` de l'ancien runner arrondit ``mean`` à
+    # 6 décimales (cf. ``picarones/core/metrics.py:_stats``).  Les
+    # valeurs brutes sont identiques bit-à-bit avant arrondi ; la
+    # divergence observée (~1e-7) provient strictement de cet arrondi.
+    # Le critère "équivalence numérique" est donc satisfait sur le
+    # pipeline de bout en bout — la précision réelle du calcul jiwer
+    # est préservée, l'arrondi est un détail de rendu côté ancien
+    # runner qui disparaîtra quand l'agrégation passera par les types
+    # non-arrondis du nouveau code (S22).
+    assert abs(old_cer - new_cer) < 1e-6, (
+        f"[{name}] CER divergent : ancien={old_cer!r}, "
+        f"nouveau={new_cer!r}, écart={abs(old_cer - new_cer):.3e}"
+    )
+    assert abs(old_wer - new_wer) < 1e-6, (
+        f"[{name}] WER divergent : ancien={old_wer!r}, "
+        f"nouveau={new_wer!r}, écart={abs(old_wer - new_wer):.3e}"
+    )
+
+
+def test_equivalence_with_perfect_hypothesis(tmp_path) -> None:
+    """Garde-fou : si l'OCR retourne exactement la GT, CER = WER = 0
+    pour les deux runners."""
+    gt = {"d1": "Texte parfait", "d2": "Identique aux deux"}
+    corpus, docs = _build_corpus(tmp_path, gt)
+    old_cer, old_wer = _run_old_runner(corpus, gt)
+    new_cer, new_wer = _run_new_runner(docs, gt, gt)
+    assert old_cer == 0.0
+    assert new_cer == 0.0
+    assert old_wer == 0.0
+    assert new_wer == 0.0
+
+
+def test_equivalence_with_empty_hypothesis(tmp_path) -> None:
+    """Cas limite : OCR retourne du vide → les deux runners doivent
+    le gérer de façon identique (CER élevé mais cohérent)."""
+    gt = {"d1": "Quelque chose"}
+    hyp = {"d1": ""}
+    corpus, docs = _build_corpus(tmp_path, gt)
+    old_cer, old_wer = _run_old_runner(corpus, hyp)
+    new_cer, new_wer = _run_new_runner(docs, hyp, gt)
+    assert old_cer is not None and new_cer is not None
+    assert abs(old_cer - new_cer) < 1e-9