feat(evaluation): Sprint A14-S16 — SearchView + cohérence inter-vues + 3 vues canoniques opérationnelles

Sprint S16 du plan rewrite ciblé. Phase 3 progresse fortement.

Troisième vue d'évaluation canonique : ``SearchView`` répond à
"quel pipeline maximise la recherchabilité plein-texte ?". Avec
TextView (S14) et AltoView (S15), on a maintenant les **3 lentilles
complémentaires** prévues pour le rapport BnF.

Modules livrés
--------------
``picarones/evaluation/metrics/search.py``
Fonctions de calcul **pures** (sans ``@register_metric`` legacy)
utilisées par SearchView :

- ``levenshtein_distance(a, b)`` — DP O(|a|·|b|), mémoire
O(min(|a|,|b|)). Identique au legacy Sprint 84.
- ``searchability_recall(reference, hypothesis, max_distance=2,
case_sensitive=False)`` — fraction des tokens GT retrouvés à
distance ≤ ``max_distance`` (défaut 2 = Elastic
``fuzziness: AUTO``). Multi-set : un hyp utilisé une fois max.
- ``numerical_sequence_preservation(reference, hypothesis)`` —
fraction des **années 4 chiffres** de la GT préservées
strictement dans hyp. Volontairement minimaliste pour S16
(le legacy Sprint 85 supporte aussi numéraux romains,
foliations, monnaies, années régnales — réintégrés au S20
avec le registre).

Toutes ∈ [0, 1] avec ``higher_is_better=True``. Aucune dep
vers ``picarones.measurements.*``.

``picarones/evaluation/views/search_view.py``
``build_search_view(...)`` factory :
- 5 candidate_types (idem TextView : tout ce qui est
projetable vers RAW_TEXT)
- 2 métriques par défaut
- 3 ignored_dimensions (char_level_accuracy → TextView ;
geometry/block_structure/reading_order → AltoView ;
semantic_equivalence → reportée)
- 2 warnings critiques :
* "lire ensemble TextView et SearchView pour juger un
pipeline"
* "higher_is_better=True (rappel) — sens de coloration
OPPOSÉ à TextView (lower_is_better=erreurs)"

Tests — 26 nouveaux tests S16
-----------------------------

``tests/evaluation/views/test_sprint_a14_s16_search_view.py`` (16 tests) :
- 4 tests Levenshtein (identité, vide, single sub, kitten→sitting).
- 7 tests searchability_recall (perfect, fuzzy ≤ 2, fuzzy > 2,
GT vide, multiplicité, case-insensitive, max_distance < 0
rejected).
- 5 tests numerical_sequence_preservation (perfect, year corrupted,
partial, no GT years, regex bounds).
- 4 tests SearchView shape (5 types acceptés, métriques par
défaut, projection_for ALTO routes correctement, warnings
signalent l'inversion higher_is_better).
- 2 tests SearchView avec executor (perfect text → recall 1,
partial quality with year loss).

``tests/evaluation/test_sprint_a14_s16_views_consistency.py`` (10 tests) :

- **TestPerfectPipelineAcrossViews** — pipeline parfait
maximise TextView et SearchView, AltoView OMIS si pas d'ALTO.

- **TestDivergencePattern** — démontre le pattern critique :
une corruption d'année (1789 → 1798) donne CER=0.03 (excellent
côté TextView) MAIS numerical_sequence_preservation=0.0
(catastrophique côté SearchView pour un historien indexant
par date). C'est précisément ce que le rapport BnF doit
rendre visible.

- **TestAltoPipelineEvaluatedInThreeViews** — un pipeline ALTO
est évaluable dans les 3 vues : TextView (via projection),
AltoView (direct), SearchView (via projection).

- **TestProjectionReportConsistency** — pour un même candidat
ALTO_XML évalué dans TextView et SearchView, les deux
ViewResult portent un projection_report cohérent (même
projecteur ``alto_to_text``).

Documentation — ``docs/views/comparing-views.md``
-------------------------------------------------
Document utilisateur central (sera référencé depuis le rapport
HTML S22). Couvre :

- Tableau des 3 vues avec leurs questions, métriques, direction
(lower_is_better vs higher_is_better).

- **3 patterns critiques** illustrant pourquoi les 3 vues sont
nécessaires :
1. CER excellent + recherchabilité numérique catastrophique
(corruption d'année invisible au CER)
2. Texte parfait mais ALTO inexistant (omission explicite)
3. ALTO valide mais texte hallucinant (vues complémentaires
sont indispensables)

- Recommandation de lecture pour le rapport BnF :
- tableau de synthèse avec OMIS explicite
- encart "divergences notables" (rang qui change entre vues)
- warnings d'``ignored_dimensions``

- **Critères de choix selon l'usage** :
| Usage | Vue principale | Vues secondaires |
| Lecture humaine | TextView | AltoView |
| Indexation Elastic | SearchView | TextView |
| IIIF/Mirador | AltoView | TextView |
| Citation académique | TextView + SearchView | AltoView |
| Fac-similé | AltoView | TextView |

État de la suite
----------------
``pytest tests/ -q`` → 4242 passed, 8 skipped, 2 failed
(strictement environnementaux). +26 tests vs S15. Aucune
régression S16.

Critère go/no-go S16 atteint
----------------------------
- 3 vues canoniques opérationnelles (TextView, AltoView,
SearchView).
- Documentation utilisateur ``comparing-views.md`` qui montre
comment lire les résultats des 3 vues ensemble.
- Pattern de divergence TextView ↔ SearchView démontré et testé
(corruption d'année invisible au CER).

Phase 3 quasi terminée. Restant : S17 (intégration runner +
RunManifest pour persister les ViewResult), S18 (E2E BnF
central avec 3 pipelines × 3 vues).

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

docs/views/comparing-views.md

@@ -0,0 +1,117 @@
+# Lire les 3 vues canoniques ensemble
+
+Sprint A14-S16 livre la troisième vue canonique du rewrite ciblé :
+`SearchView`.  Avec `TextView` (S14) et `AltoView` (S15), on a
+maintenant **trois lentilles complémentaires** pour évaluer un
+même pipeline.
+
+## Le tableau des 3 vues
+
+| Vue | Question | Métriques | Direction |
+|---|---|---|---|
+| **TextView** (S14) | Quel pipeline produit le meilleur **texte final** ? | CER, WER, MER, WIL | `lower_is_better` (erreurs) |
+| **AltoView** (S15) | Quel pipeline produit le meilleur **ALTO exploitable** ? | alto_validity, line_count_ratio, word_box_coverage | `higher_is_better` (qualité) |
+| **SearchView** (S16) | Quel pipeline maximise la **recherchabilité plein-texte** ? | searchability_recall, numerical_sequence_preservation | `higher_is_better` (rappel) |
+
+Aucune des trois vues ne dit toute la vérité sur un pipeline.
+**Ensemble, elles racontent l'histoire complète.**
+
+## Pourquoi les trois vues sont nécessaires
+
+Un même pipeline peut être **excellent dans une vue et médiocre
+dans une autre**.  C'est précisément ce qui rend la comparaison
+hétérogène utile pour la BnF — un seul score (CER global)
+masquerait des informations critiques.
+
+### Pattern 1 : CER excellent, recherchabilité numérique catastrophique
+
+Démontré dans le test
+`tests/evaluation/test_sprint_a14_s16_views_consistency.py::TestDivergencePattern::test_year_corruption_invisible_to_cer_visible_to_search` :
+
+- **GT** : *"Charte signée à Paris le 14 juillet 1789 en présence du roi"*
+- **Hypothèse** : *"Charte signée à Paris le 14 juillet 1798 en présence du roi"*
+
+Le LLM de post-correction a "amélioré" la date (1789 → 1798).
+Conséquences :
+
+| Vue | Métrique | Valeur | Lecture |
+|---|---|---|---|
+| TextView | CER | ~0.03 | Excellent (3 chars sur 58) |
+| TextView | WER | ~0.09 | Très bon (1 mot sur 11) |
+| SearchView | searchability_recall | ~0.91 | Bon (1798 fuzzy match 1789) |
+| SearchView | **numerical_sequence_preservation** | **0.0** | **Catastrophique** |
+
+Pour un historien qui veut indexer ses chartes par date, ce
+pipeline est **inutilisable** — l'année 1789 est silencieusement
+réécrite en 1798.  Le CER ne le révèle pas.  `SearchView` le
+révèle.
+
+### Pattern 2 : Texte parfait, ALTO inexistant
+
+Un OCR Tesseract qui ne produit que du texte brut :
+
+| Vue | Statut | Lecture |
+|---|---|---|
+| TextView | CER = 0.0 | Pipeline parfait pour la lecture |
+| SearchView | recall = 1.0 | Pipeline parfait pour l'indexation |
+| **AltoView** | **OMIS** | Pipeline non éligible |
+
+Pour un workflow IIIF / Mirador qui veut surligner les mots dans
+l'image, ce pipeline est **inutilisable** — pas de coordonnées.
+`AltoView` ne lui attribue pas un score factice à 0 ; le rapport
+affiche *"Tesseract texte brut n'est pas évalué dans AltoView
+(ne produit pas d'ALTO)"*.
+
+### Pattern 3 : ALTO valide mais texte hallucinant
+
+Un VLM avec module ALTO_reconstruction peut produire un ALTO
+structurellement parfait (validity=1, lignes correctes,
+coordonnées présentes) mais avec du texte inventé :
+
+| Vue | Métrique | Valeur | Lecture |
+|---|---|---|---|
+| AltoView | tous | 1.0 | Pipeline parfait structurellement |
+| TextView | CER | élevé | Pipeline mauvais textuellement |
+| SearchView | recall | bas | Pipeline inutile pour la recherche |
+
+`AltoView` seul ferait passer ce VLM pour le meilleur pipeline.
+Lire les trois vues ensemble révèle le vrai problème.
+
+## Recommandation de lecture pour le rapport BnF
+
+Le rapport HTML (S22) présentera les 3 vues côte-à-côte avec
+cette grille de lecture :
+
+1. **Tableau de synthèse** : un tableau par vue, chaque ligne =
+   un pipeline, chaque colonne = une métrique.  Les pipelines
+   omis sont indiqués explicitement (pas de valeur factice).
+
+2. **Encart "divergences notables"** : signale automatiquement
+   les pipelines dont le rang change fortement entre vues
+   (par exemple "rang 1 en TextView, rang 5 en SearchView").
+   C'est un signal pour l'utilisateur d'aller regarder en
+   détail ce qui se passe.
+
+3. **Pour chaque vue** : warnings explicites de ce qu'elle
+   **n'évalue pas** (cf. `ignored_dimensions` dans chaque
+   `ViewResult`).  L'utilisateur ne peut pas conclure
+   "TextView dit que X est le meilleur" sans avoir vu ce que
+   `TextView.ignored_dimensions` ne dit PAS.
+
+## Critères de choix selon l'usage
+
+| Usage cible | Vue principale | Vues secondaires |
+|---|---|---|
+| Lecture humaine (édition critique) | TextView | AltoView (si édition diplomatique) |
+| Indexation Elastic / Solr / Gallica | SearchView | TextView |
+| Réinjection IIIF / Mirador (mots cliquables) | AltoView | TextView |
+| Citation académique | TextView + SearchView | AltoView |
+| Reproduction d'un fac-similé | AltoView | TextView |
+
+## Statut
+
+- ✅ Sprint S14 — `TextView`
+- ✅ Sprint S15 — `AltoView`
+- ✅ Sprint S16 — `SearchView` + cohérence inter-vues
+- ⏳ Sprint S17 — intégration runner + RunManifest
+- ⏳ Sprint S18 — tests E2E sur le cas BnF central

picarones/evaluation/metrics/search.py

@@ -0,0 +1,194 @@
+"""Recherchabilité fuzzy + séquences numériques — Sprint A14-S16.
+
+Fonctions de calcul **pures** (sans ``@register_metric`` legacy)
+utilisées par ``SearchView``.  Réimplémente la logique des modules
+historiques ``picarones.measurements.searchability`` (Sprint 84)
+et ``picarones.measurements.numerical_sequences`` (Sprint 85),
+sans la dépendance vers le singleton global ``core.metric_registry``.
+
+Les modules legacy seront supprimés au S20 quand le
+``MetricRegistry`` instancié explicitement (S5) deviendra le seul
+registre.  En attendant, ce module fournit la version "couche
+evaluation" propre.
+
+Métriques livrées
+-----------------
+- ``searchability_recall(reference, hypothesis, max_distance=2)`` —
+  proportion de tokens GT retrouvés dans l'hypothèse à distance
+  de Levenshtein ≤ ``max_distance``.  Proxy direct de la qualité
+  pour la recherche plein-texte (Elastic / Solr / Gallica).
+
+- ``numerical_sequence_preservation(reference, hypothesis)`` —
+  fraction des séquences numériques de la GT préservées
+  strictement dans l'hypothèse.  Volontairement minimaliste pour
+  S16 : détecte uniquement les **années 4 chiffres** (proxy
+  réaliste pour les corpus patrimoniaux datés).  Le cas complet
+  (numéraux romains, foliations, monnaies, années régnales) reste
+  dans le legacy et sera réintégré au S20 avec le registre.
+
+Toutes les métriques ∈ [0, 1] avec ``higher_is_better=True``.
+"""
+
+from __future__ import annotations
+
+import re
+
+
+# ──────────────────────────────────────────────────────────────────
+# Levenshtein — DP O(|a|·|b|), mémoire O(min(|a|, |b|))
+# ──────────────────────────────────────────────────────────────────
+
+
+def levenshtein_distance(a: str, b: str) -> int:
+    """Distance de Levenshtein (substitution = insertion = suppression = 1).
+
+    Implémentation identique à ``picarones.measurements.searchability``
+    (Sprint 84) mais sans le décorateur ``@register_metric``.
+    """
+    if a == b:
+        return 0
+    if len(a) < len(b):
+        a, b = b, a
+    if not b:
+        return len(a)
+    previous = list(range(len(b) + 1))
+    for i, ca in enumerate(a, start=1):
+        current = [i] + [0] * len(b)
+        for j, cb in enumerate(b, start=1):
+            cost = 0 if ca == cb else 1
+            current[j] = min(
+                current[j - 1] + 1,        # insertion
+                previous[j] + 1,           # suppression
+                previous[j - 1] + cost,    # substitution
+            )
+        previous = current
+    return previous[-1]
+
+
+# ──────────────────────────────────────────────────────────────────
+# Searchability fuzzy
+# ──────────────────────────────────────────────────────────────────
+
+
+def _split_words(text: str | None) -> list[str]:
+    if not text:
+        return []
+    return text.split()
+
+
+def searchability_recall(
+    reference: str,
+    hypothesis: str,
+    *,
+    max_distance: int = 2,
+    case_sensitive: bool = False,
+) -> float:
+    """Rappel fuzzy : fraction des tokens GT retrouvés à distance
+    de Levenshtein ≤ ``max_distance``.
+
+    Multi-set : un token hypothèse ne peut servir qu'une fois pour
+    être compté comme "match" (alignement bipartite simple).
+
+    Returns
+    -------
+    float
+        ``n_retrouves / n_gt`` ∈ [0, 1].  ``0.0`` si la GT est
+        vide (convention identique au legacy Sprint 84).
+    """
+    if max_distance < 0:
+        raise ValueError(f"max_distance doit être ≥ 0, reçu {max_distance}")
+    gt_tokens = _split_words(reference)
+    hyp_tokens = _split_words(hypothesis)
+    n_gt = len(gt_tokens)
+    if n_gt == 0:
+        return 0.0
+    if case_sensitive:
+        gt_for_match = list(gt_tokens)
+        hyp_for_match = list(hyp_tokens)
+    else:
+        gt_for_match = [t.lower() for t in gt_tokens]
+        hyp_for_match = [t.lower() for t in hyp_tokens]
+
+    hyp_used = [False] * len(hyp_for_match)
+    n_match = 0
+    for gt_match in gt_for_match:
+        best_idx = -1
+        best_dist = max_distance + 1
+        for hi, used in enumerate(hyp_used):
+            if used:
+                continue
+            hyp_match = hyp_for_match[hi]
+            if abs(len(hyp_match) - len(gt_match)) > max_distance:
+                continue
+            d = levenshtein_distance(gt_match, hyp_match)
+            if d < best_dist:
+                best_dist = d
+                best_idx = hi
+                if d == 0:
+                    break
+        if best_idx >= 0 and best_dist <= max_distance:
+            hyp_used[best_idx] = True
+            n_match += 1
+    return n_match / n_gt
+
+
+# ──────────────────────────────────────────────────────────────────
+# Séquences numériques (S16 minimal : années 4 chiffres)
+# ──────────────────────────────────────────────────────────────────
+
+
+_YEAR_4DIGITS_RE = re.compile(r"\b(1[0-9]{3}|20[0-2][0-9])\b")
+"""Capture les années entre 1000 et 2029 (proxy réaliste pour les
+corpus patrimoniaux : chartes médiévales, registres modernes,
+coupures de presse XIX-XXIᵉ siècle)."""
+
+
+def _extract_years(text: str | None) -> list[str]:
+    if not text:
+        return []
+    return _YEAR_4DIGITS_RE.findall(text)
+
+
+def numerical_sequence_preservation(
+    reference: str,
+    hypothesis: str,
+) -> float:
+    """Fraction des années 4 chiffres de la GT préservées strictement
+    dans l'hypothèse.
+
+    Returns
+    -------
+    float
+        ``n_preserved / n_gt_years`` ∈ [0, 1].  ``0.0`` si la GT
+        ne contient aucune année.
+
+    Note méthodologique
+    -------------------
+    Volontairement minimaliste pour S16 : seules les années 4
+    chiffres sont détectées.  Le pattern complet (numéraux romains,
+    foliations ``f. 12r``, monnaies, années régnales ``an III``)
+    reste dans ``picarones.measurements.numerical_sequences``
+    (Sprint 85) et sera réintégré dans la couche evaluation au S20.
+
+    Multi-set : si la GT contient ``"1789"`` deux fois et
+    l'hypothèse une fois, seul un est compté préservé.
+    """
+    gt_years = _extract_years(reference)
+    if not gt_years:
+        return 0.0
+    hyp_years = _extract_years(hypothesis)
+    # Multi-set match.
+    hyp_pool = list(hyp_years)
+    n_preserved = 0
+    for y in gt_years:
+        if y in hyp_pool:
+            hyp_pool.remove(y)
+            n_preserved += 1
+    return n_preserved / len(gt_years)
+
+
+__all__ = [
+    "levenshtein_distance",
+    "searchability_recall",
+    "numerical_sequence_preservation",
+]

picarones/evaluation/views/__init__.py

@@ -32,6 +32,14 @@ from picarones.evaluation.views.executor import (
     DefaultEvaluationViewExecutor,
     PayloadLoader,
 )
+from picarones.evaluation.views.search_view import (
+    DEFAULT_SEARCH_CANDIDATE_TYPES,
+    DEFAULT_SEARCH_IGNORED_DIMENSIONS,
+    DEFAULT_SEARCH_METRICS,
+    DEFAULT_SEARCH_PROJECTIONS,
+    DEFAULT_SEARCH_WARNINGS,
+    build_search_view,
+)
 from picarones.evaluation.views.text_view import (
     DEFAULT_TEXT_CANDIDATE_TYPES,
     DEFAULT_TEXT_IGNORED_DIMENSIONS,
@@ -61,4 +69,11 @@ __all__ = [
     "DEFAULT_ALTO_CANDIDATE_TYPES",
     "DEFAULT_ALTO_IGNORED_DIMENSIONS",
     "DEFAULT_ALTO_WARNINGS",
+    # SearchView (S16)
+    "build_search_view",
+    "DEFAULT_SEARCH_METRICS",
+    "DEFAULT_SEARCH_CANDIDATE_TYPES",
+    "DEFAULT_SEARCH_PROJECTIONS",
+    "DEFAULT_SEARCH_IGNORED_DIMENSIONS",
+    "DEFAULT_SEARCH_WARNINGS",
 ]

picarones/evaluation/views/search_view.py

@@ -0,0 +1,161 @@
+"""``SearchView`` — vue canonique 3, Sprint A14-S16.
+
+Troisième vue d'évaluation canonique : "quel pipeline maximise la
+**recherchabilité plein-texte** ?".
+
+Distinct de TextView et AltoView
+--------------------------------
+| Vue | Question | Métriques |
+|---|---|---|
+| TextView (S14) | meilleur texte final ? | CER, WER, MER, WIL |
+| AltoView (S15) | meilleur ALTO exploitable ? | validity, line_count, word_box |
+| SearchView (S16) | meilleur pour la recherche plein-texte ? | searchability_recall, numerical_seq |
+
+Un même pipeline peut avoir un excellent CER (TextView) tout en
+étant mauvais pour la recherche fuzzy (SearchView), si ses erreurs
+se concentrent sur des noms propres ou des dates.  Et inversement,
+un pipeline avec un CER médiocre peut donner une excellente
+recherchabilité si les erreurs sont sur des caractères non-significatifs.
+
+Cette divergence est précisément ce que le rapport BnF doit rendre
+visible — c'est l'objet du document
+``docs/views/comparing-views.md``.
+
+Types acceptés
+--------------
+Comme TextView : RAW_TEXT, CORRECTED_TEXT, ALTO_XML, PAGE_XML,
+CANONICAL_DOCUMENT.  La projection vers RAW_TEXT est appliquée
+automatiquement par ``projections_by_source_type``.
+
+Métriques par défaut
+--------------------
+- ``searchability_recall`` — fraction des tokens GT retrouvés à
+  distance de Levenshtein ≤ 2 (proxy Elastic).
+- ``numerical_sequence_preservation`` — fraction des années 4
+  chiffres de la GT préservées strictement.
+
+Toutes ∈ [0, 1] avec ``higher_is_better=True``.
+
+higher_is_better
+----------------
+**Critique** : les métriques de cette vue sont des recall
+(``higher_is_better=True``), à l'inverse de TextView dont les
+métriques sont des erreurs (``higher_is_better=False``).  Le
+rapport doit colorier les chiffres de SearchView dans le sens
+opposé de ceux de TextView.
+"""
+
+from __future__ import annotations
+
+from picarones.domain.artifacts import ArtifactType
+from picarones.domain.evaluation_spec import EvaluationView
+from picarones.domain.projection_spec import ProjectionSpec
+
+
+#: Métriques calculées par défaut.
+DEFAULT_SEARCH_METRICS: tuple[str, ...] = (
+    "searchability_recall",
+    "numerical_sequence_preservation",
+)
+
+
+#: Types acceptés.  Identique à TextView : tout ce qui peut être
+#: projeté vers RAW_TEXT est éligible.
+DEFAULT_SEARCH_CANDIDATE_TYPES: frozenset[ArtifactType] = frozenset({
+    ArtifactType.RAW_TEXT,
+    ArtifactType.CORRECTED_TEXT,
+    ArtifactType.ALTO_XML,
+    ArtifactType.PAGE_XML,
+    ArtifactType.CANONICAL_DOCUMENT,
+})
+
+
+#: Mapping ``source_type → ProjectionSpec`` (identique à TextView).
+DEFAULT_SEARCH_PROJECTIONS: dict[ArtifactType, ProjectionSpec] = {
+    ArtifactType.ALTO_XML: ProjectionSpec(
+        source_type=ArtifactType.ALTO_XML,
+        target_type=ArtifactType.RAW_TEXT,
+        projector_name="alto_to_text",
+    ),
+    ArtifactType.PAGE_XML: ProjectionSpec(
+        source_type=ArtifactType.PAGE_XML,
+        target_type=ArtifactType.RAW_TEXT,
+        projector_name="page_to_text",
+    ),
+    ArtifactType.CANONICAL_DOCUMENT: ProjectionSpec(
+        source_type=ArtifactType.CANONICAL_DOCUMENT,
+        target_type=ArtifactType.RAW_TEXT,
+        projector_name="canonical_to_text",
+    ),
+}
+
+
+#: Dimensions explicitement non évaluées.
+DEFAULT_SEARCH_IGNORED_DIMENSIONS: tuple[str, ...] = (
+    # Qualité caractère par caractère : c'est TextView (S14).
+    "char_level_accuracy",
+    # Structure documentaire : c'est AltoView (S15).
+    "geometry",
+    "block_structure",
+    "reading_order",
+    # Sémantique (synonymes, paraphrases) : non évaluée par cette
+    # vue, qui reste lexicale.
+    "semantic_equivalence",
+)
+
+
+#: Avertissement par défaut.
+DEFAULT_SEARCH_WARNINGS: tuple[str, ...] = (
+    "Cette vue mesure la recherchabilité PLEIN-TEXTE (rappel "
+    "fuzzy à distance de Levenshtein ≤ 2, années préservées).  "
+    "Un pipeline avec un excellent CER peut être moyen ici si "
+    "ses erreurs se concentrent sur les noms propres ou les "
+    "dates.  Et inversement.  Lire ensemble TextView et SearchView "
+    "pour juger un pipeline.",
+    "Métriques higher_is_better=True (rappel) — le sens de "
+    "coloration est OPPOSÉ à celui de TextView (qui mesure des "
+    "erreurs, lower_is_better).",
+)
+
+
+def build_search_view(
+    *,
+    name: str = "searchability",
+    description: str = (
+        "Mesure la recherchabilité plein-texte d'un pipeline "
+        "(rappel fuzzy + années préservées)."
+    ),
+    candidate_types: frozenset[ArtifactType] | None = None,
+    metric_names: tuple[str, ...] | None = None,
+    normalization_profile: str | None = None,
+    extra_warnings: tuple[str, ...] = (),
+    extra_ignored_dimensions: tuple[str, ...] = (),
+) -> EvaluationView:
+    """Construit la vue canonique SearchView."""
+    return EvaluationView(
+        name=name,
+        description=description,
+        candidate_types=(
+            candidate_types if candidate_types is not None
+            else DEFAULT_SEARCH_CANDIDATE_TYPES
+        ),
+        projection=None,
+        projections_by_source_type=DEFAULT_SEARCH_PROJECTIONS,
+        normalization_profile=normalization_profile,
+        metric_names=(
+            metric_names if metric_names is not None
+            else DEFAULT_SEARCH_METRICS
+        ),
+        warnings=DEFAULT_SEARCH_WARNINGS + extra_warnings,
+        ignored_dimensions=DEFAULT_SEARCH_IGNORED_DIMENSIONS + extra_ignored_dimensions,
+    )
+
+
+__all__ = [
+    "build_search_view",
+    "DEFAULT_SEARCH_METRICS",
+    "DEFAULT_SEARCH_CANDIDATE_TYPES",
+    "DEFAULT_SEARCH_PROJECTIONS",
+    "DEFAULT_SEARCH_IGNORED_DIMENSIONS",
+    "DEFAULT_SEARCH_WARNINGS",
+]

tests/evaluation/test_sprint_a14_s16_views_consistency.py

@@ -0,0 +1,329 @@
+"""Sprint A14-S16 — sanity check inter-vues sur le cas BnF central.
+
+Vérifie qu'un même pipeline a une cohérence (et parfois une
+divergence intéressante) entre TextView, AltoView et SearchView.
+
+Cas démontrés :
+- Pipeline parfait → toutes vues maximisent.
+- Pipeline avec erreur sur une année → SearchView baisse fortement,
+  TextView baisse légèrement (pattern "perte de données critiques
+  invisible au CER global").
+- Pipeline sans ALTO → AltoView l'OMET, autres vues l'évaluent.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.domain import Artifact, ArtifactType, MetricSpec
+from picarones.evaluation.metrics.alto_structural import (
+    compute_alto_validity,
+    compute_line_count_ratio,
+    compute_word_box_coverage,
+)
+from picarones.evaluation.metrics.search import (
+    numerical_sequence_preservation,
+    searchability_recall,
+)
+from picarones.evaluation.projectors import (
+    AltoToText,
+    CanonicalToText,
+    PageToText,
+    ProjectorRegistry,
+)
+from picarones.evaluation.registry import MetricRegistry
+from picarones.evaluation.views import (
+    DefaultEvaluationViewExecutor,
+    build_alto_view,
+    build_search_view,
+    build_text_view,
+)
+from picarones.formats.alto.types import (
+    AltoBBox,
+    AltoDocument,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+
+
+# ──────────────────────────────────────────────────────────────────
+# Stubs métriques texte (cer/wer simplifiés sans jiwer)
+# ──────────────────────────────────────────────────────────────────
+
+
+def _stub_cer(reference: str, hypothesis: str) -> float:
+    if not reference:
+        return 0.0 if not hypothesis else 1.0
+    common = sum(1 for a, b in zip(reference, hypothesis) if a == b)
+    return 1.0 - (common / max(len(reference), len(hypothesis)))
+
+
+def _stub_wer(reference: str, hypothesis: str) -> float:
+    ref_w = reference.split()
+    hyp_w = hypothesis.split()
+    if not ref_w:
+        return 0.0 if not hyp_w else 1.0
+    common = sum(1 for a, b in zip(ref_w, hyp_w) if a == b)
+    return 1.0 - (common / len(ref_w))
+
+
+def _build_unified_executor(payloads: dict) -> DefaultEvaluationViewExecutor:
+    """Executor configuré pour TextView + AltoView + SearchView."""
+    metrics = MetricRegistry()
+    # TextView metrics
+    for name, fn in (
+        ("cer", _stub_cer),
+        ("wer", _stub_wer),
+        ("mer", _stub_cer),
+        ("wil", _stub_wer),
+    ):
+        metrics.register(
+            MetricSpec(
+                name=name,
+                input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+            ),
+            fn,
+        )
+    # AltoView metrics
+    for name, fn in (
+        ("alto_validity", compute_alto_validity),
+        ("alto_line_count_ratio", compute_line_count_ratio),
+        ("alto_word_box_coverage", compute_word_box_coverage),
+    ):
+        metrics.register(
+            MetricSpec(
+                name=name,
+                input_types=(ArtifactType.ALTO_XML, ArtifactType.ALTO_XML),
+                higher_is_better=True,
+            ),
+            fn,
+        )
+    # SearchView metrics
+    metrics.register(
+        MetricSpec(
+            name="searchability_recall",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+            higher_is_better=True,
+        ),
+        searchability_recall,
+    )
+    metrics.register(
+        MetricSpec(
+            name="numerical_sequence_preservation",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+            higher_is_better=True,
+        ),
+        numerical_sequence_preservation,
+    )
+
+    projectors = ProjectorRegistry()
+    projectors.register(AltoToText())
+    projectors.register(PageToText())
+    projectors.register(CanonicalToText())
+
+    def loader(art: Artifact):
+        if art.id not in payloads:
+            raise KeyError(art.id)
+        return payloads[art.id]
+
+    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+
+
+# ──────────────────────────────────────────────────────────────────
+# Cas 1 — pipeline parfait
+# ──────────────────────────────────────────────────────────────────
+
+
+class TestPerfectPipelineAcrossViews:
+    def test_perfect_text_pipeline_maximizes_text_and_search(self) -> None:
+        """Un pipeline qui produit du texte parfait :
+        - TextView : CER = 0
+        - SearchView : recall = 1.0, year preservation = 1.0
+        - AltoView : OMIS (pas d'ALTO produit).
+        """
+        gt_text = "Bonjour Paris en 1789"
+        payloads = {"cand": gt_text, "gt_text": gt_text}
+        executor = _build_unified_executor(payloads)
+
+        text_view = build_text_view()
+        search_view = build_search_view()
+        alto_view = build_alto_view()
+
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt_text", document_id="d", type=ArtifactType.RAW_TEXT)
+
+        text_result = executor.evaluate(text_view, cand, gt)
+        search_result = executor.evaluate(search_view, cand, gt)
+
+        assert text_result.metric_values["cer"] == 0.0
+        assert search_result.metric_values["searchability_recall"] == 1.0
+        assert search_result.metric_values["numerical_sequence_preservation"] == 1.0
+
+        # AltoView OMIS : le caller doit filtrer.
+        assert not alto_view.accepts(cand.type)
+
+
+# ──────────────────────────────────────────────────────────────────
+# Cas 2 — divergence TextView ↔ SearchView
+# ──────────────────────────────────────────────────────────────────
+
+
+class TestDivergencePattern:
+    def test_year_corruption_invisible_to_cer_visible_to_search(self) -> None:
+        """Pattern critique : une corruption d'année (1 caractère
+        sur ~50) est invisible côté CER mais catastrophique côté
+        recherchabilité numérique.
+
+        C'est précisément ce que le rapport BnF doit rendre
+        visible — les deux vues racontent des histoires
+        complémentaires.
+        """
+        gt_text = "Charte signée à Paris le 14 juillet 1789 en présence du roi"
+        # Hypothèse : le LLM a "corrigé" 1789 en 1798 (faute grossière).
+        # Le reste du texte est identique.
+        cand_text = "Charte signée à Paris le 14 juillet 1798 en présence du roi"
+
+        payloads = {"cand": cand_text, "gt": gt_text}
+        executor = _build_unified_executor(payloads)
+
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+
+        text_result = executor.evaluate(build_text_view(), cand, gt)
+        search_result = executor.evaluate(build_search_view(), cand, gt)
+
+        # CER ≈ 0.03 (3 chars sur ~58)
+        assert text_result.metric_values["cer"] < 0.1, "CER doit rester faible"
+        # WER : 1 mot changé sur 11 → 1/11 ≈ 0.09
+        assert text_result.metric_values["wer"] < 0.15
+
+        # Mais SearchView : 1789 (GT) n'est PAS dans hyp_years = [1798]
+        # → preservation = 0.0 (catastrophique pour un historien).
+        assert search_result.metric_values["numerical_sequence_preservation"] == 0.0
+        # Searchability : "1789" GT n'est pas matché à "1798" (distance 2,
+        # MAIS la longueur est égale, fuzziness ≤ 2 le matche).
+        # On vérifie juste qu'il y a un signal mesurable.
+        assert search_result.metric_values["searchability_recall"] >= 0.8
+
+
+# ──────────────────────────────────────────────────────────────────
+# Cas 3 — pipeline ALTO évaluable dans les 3 vues
+# ──────────────────────────────────────────────────────────────────
+
+
+def _build_simple_alto(words: list[str], n_lines: int = 1) -> AltoDocument:
+    """Construit un AltoDocument avec ``words`` répartis sur
+    ``n_lines`` lignes, chaque mot avec une bbox."""
+    chunks = [words[i::n_lines] for i in range(n_lines)]
+    lines = tuple(
+        AltoLine(strings=tuple(
+            AltoString(
+                content=w,
+                bbox=AltoBBox(hpos=0, vpos=0, width=10, height=10),
+            )
+            for w in chunk
+        ))
+        for chunk in chunks
+    )
+    return AltoDocument(pages=(AltoPage(blocks=(AltoTextBlock(lines=lines),),),),)
+
+
+class TestAltoPipelineEvaluatedInThreeViews:
+    def test_alto_pipeline_has_text_alto_search_results(self, tmp_path) -> None:
+        """Un pipeline qui produit ALTO_XML est évaluable dans les
+        3 vues : TextView (via projection), AltoView (direct),
+        SearchView (via projection).
+        """
+        from picarones.formats.alto import write_alto
+
+        words_gt = "Charte signée Paris 14 juillet 1789".split()
+        words_cand = "Charte signée Paris 14 juillet 1789".split()  # identique
+
+        # n_lines=1 pour préserver l'ordre des mots dans l'extraction
+        # (sinon ``alto_document_to_text`` produit des sauts de ligne
+        # qui font diverger le CER d'une comparaison ligne unique).
+        gt_alto = _build_simple_alto(words_gt, n_lines=1)
+        cand_alto = _build_simple_alto(words_cand, n_lines=1)
+        cand_alto_path = tmp_path / "cand.alto.xml"
+        cand_alto_path.write_bytes(write_alto(cand_alto))
+
+        # Payloads : raw text pour les payloads projetés depuis ALTO,
+        # AltoDocument pour la GT et le candidat ALTO direct.
+        from picarones.evaluation.projectors import alto_document_to_text
+        payloads = {
+            "gt_text": " ".join(words_gt),
+            "gt_alto": gt_alto,
+            "cand": cand_alto,  # AltoDocument pour AltoView
+            "cand:projected_text": alto_document_to_text(cand_alto),
+        }
+        executor = _build_unified_executor(payloads)
+
+        gt_text_art = Artifact(id="gt_text", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt_alto_art = Artifact(id="gt_alto", document_id="d", type=ArtifactType.ALTO_XML)
+        cand_art = Artifact(
+            id="cand", document_id="d",
+            type=ArtifactType.ALTO_XML, uri=str(cand_alto_path),
+        )
+
+        # TextView : projette ALTO → texte, compare au gt_text.
+        text_result = executor.evaluate(build_text_view(), cand_art, gt_text_art)
+        assert text_result.metric_values["cer"] == 0.0
+
+        # SearchView : projette ALTO → texte, mesure recall + années.
+        search_result = executor.evaluate(build_search_view(), cand_art, gt_text_art)
+        assert search_result.metric_values["searchability_recall"] == 1.0
+
+        # AltoView : compare ALTO direct contre ALTO GT.
+        alto_result = executor.evaluate(build_alto_view(), cand_art, gt_alto_art)
+        assert alto_result.metric_values["alto_validity"] == 1.0
+        assert alto_result.metric_values["alto_line_count_ratio"] == 1.0
+        assert alto_result.metric_values["alto_word_box_coverage"] == 1.0
+
+
+# ──────────────────────────────────────────────────────────────────
+# Cohérence globale : projection report présent ssi projection appliquée
+# ──────────────────────────────────────────────────────────────────
+
+
+class TestProjectionReportConsistency:
+    def test_text_search_views_share_projection_report_pattern(self) -> None:
+        """Pour un même candidat ALTO_XML évalué dans TextView et
+        SearchView, les deux ViewResult doivent porter un
+        projection_report (les deux vues projettent vers texte)."""
+        gt_text = "test"
+        gt_alto = _build_simple_alto(["test"], n_lines=1)
+        from picarones.evaluation.projectors import alto_document_to_text
+        from picarones.formats.alto import write_alto
+
+        # Pour ce test on n'a pas besoin du fichier réel — on simule
+        # via le payload_loader qui retourne directement le texte
+        # extrait pour l'id "cand:projected_text".
+        payloads = {
+            "gt_text": gt_text,
+            "cand:projected_text": alto_document_to_text(gt_alto),
+        }
+        # Mais le projecteur a besoin d'un URI.  On contourne en
+        # créant un fichier temporaire dans pytest fixture.
+        # Pour ce test simple on écrit dans /tmp.
+        import tempfile
+        with tempfile.NamedTemporaryFile(suffix=".alto.xml", delete=False) as f:
+            f.write(write_alto(gt_alto))
+            cand_uri = f.name
+
+        executor = _build_unified_executor(payloads)
+        cand = Artifact(
+            id="cand", document_id="d",
+            type=ArtifactType.ALTO_XML, uri=cand_uri,
+        )
+        gt = Artifact(id="gt_text", document_id="d", type=ArtifactType.RAW_TEXT)
+
+        text_result = executor.evaluate(build_text_view(), cand, gt)
+        search_result = executor.evaluate(build_search_view(), cand, gt)
+
+        # Les deux doivent avoir un projection_report (même projecteur).
+        assert text_result.projection_report is not None
+        assert search_result.projection_report is not None
+        assert text_result.projection_report.projector_name == "alto_to_text"
+        assert search_result.projection_report.projector_name == "alto_to_text"

tests/evaluation/views/test_sprint_a14_s16_search_view.py

@@ -0,0 +1,222 @@
+"""Sprint A14-S16 — SearchView + métriques de recherchabilité."""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.domain import Artifact, ArtifactType, MetricSpec
+from picarones.evaluation.metrics.search import (
+    levenshtein_distance,
+    numerical_sequence_preservation,
+    searchability_recall,
+)
+from picarones.evaluation.projectors import (
+    AltoToText,
+    CanonicalToText,
+    PageToText,
+    ProjectorRegistry,
+)
+from picarones.evaluation.registry import MetricRegistry
+from picarones.evaluation.views import (
+    DEFAULT_SEARCH_METRICS,
+    DefaultEvaluationViewExecutor,
+    build_search_view,
+)
+
+
+# ──────────────────────────────────────────────────────────────────
+# Métriques individuelles
+# ──────────────────────────────────────────────────────────────────
+
+
+class TestLevenshtein:
+    def test_identical(self) -> None:
+        assert levenshtein_distance("hello", "hello") == 0
+
+    def test_empty(self) -> None:
+        assert levenshtein_distance("", "") == 0
+        assert levenshtein_distance("abc", "") == 3
+        assert levenshtein_distance("", "abc") == 3
+
+    def test_single_substitution(self) -> None:
+        assert levenshtein_distance("hello", "hallo") == 1
+
+    def test_kitten_sitting(self) -> None:
+        # Cas canonique : kitten → sitting (k→s, e→i, +g) = 3 ops
+        assert levenshtein_distance("kitten", "sitting") == 3
+
+
+class TestSearchabilityRecall:
+    def test_perfect_match(self) -> None:
+        recall = searchability_recall("hello world", "hello world")
+        assert recall == 1.0
+
+    def test_fuzzy_match_within_threshold(self) -> None:
+        # "monde" vs "monds" → 1 substitution, ≤ 2 → match
+        recall = searchability_recall("le monde", "le monds")
+        assert recall == 1.0
+
+    def test_fuzzy_match_beyond_threshold(self) -> None:
+        # "monde" vs "rabbit" → distance > 2 → pas de match
+        recall = searchability_recall("le monde", "le rabbit")
+        # "le" matche, "monde" non → 1/2 = 0.5
+        assert recall == 0.5
+
+    def test_empty_gt_returns_zero(self) -> None:
+        assert searchability_recall("", "hello") == 0.0
+
+    def test_multiplicity_respected(self) -> None:
+        # GT a "le" deux fois, hyp une seule fois → 1/2
+        recall = searchability_recall("le le monde", "le monde")
+        assert abs(recall - 2 / 3) < 1e-9  # "le", "monde" matchent (1 "le" non)
+
+    def test_case_insensitive_by_default(self) -> None:
+        assert searchability_recall("Bonjour", "bonjour") == 1.0
+
+    def test_negative_max_distance_raises(self) -> None:
+        with pytest.raises(ValueError, match="max_distance"):
+            searchability_recall("a", "b", max_distance=-1)
+
+
+class TestNumericalSequencePreservation:
+    def test_perfect_year_preservation(self) -> None:
+        score = numerical_sequence_preservation(
+            "fait à Paris en 1789",
+            "fait à Paris en 1789",
+        )
+        assert score == 1.0
+
+    def test_year_corrupted(self) -> None:
+        # GT contient "1789", hyp contient "1798" (pas dans hyp_years)
+        # Mais "1798" est aussi une année 4 chiffres valide qui matche
+        # le regex.  Vérifions la sémantique : on cherche les années
+        # GT dans les années hyp.
+        score = numerical_sequence_preservation(
+            "année 1789",
+            "année 1798",
+        )
+        # 1789 (GT) n'est PAS dans hyp_years = [1798] → 0/1 = 0.0
+        assert score == 0.0
+
+    def test_partial_preservation(self) -> None:
+        score = numerical_sequence_preservation(
+            "1789, 1799, 1815",
+            "1789 et 1815",  # 1799 perdu
+        )
+        # 2/3 préservés
+        assert abs(score - 2 / 3) < 1e-9
+
+    def test_no_years_in_gt(self) -> None:
+        score = numerical_sequence_preservation(
+            "pas de date ici",
+            "pas de date là",
+        )
+        assert score == 0.0  # convention : pas d'années GT → 0.0
+
+    def test_year_regex_bounds(self) -> None:
+        # Année 999 → trop court (3 chiffres)
+        # Année 1000 → OK
+        # Année 2099 → hors plage (regex 2[0-2][0-9])
+        score = numerical_sequence_preservation("an 999 et 1000", "an 999 et 1000")
+        # Seul "1000" est détecté en GT → comparé à hyp où "1000" présent aussi
+        assert score == 1.0
+
+
+# ──────────────────────────────────────────────────────────────────
+# SearchView shape
+# ────────────────────────────────────────────────��─────────────────
+
+
+class TestSearchViewShape:
+    def test_default_view_accepts_5_types(self) -> None:
+        view = build_search_view()
+        for t in (
+            ArtifactType.RAW_TEXT,
+            ArtifactType.CORRECTED_TEXT,
+            ArtifactType.ALTO_XML,
+            ArtifactType.PAGE_XML,
+            ArtifactType.CANONICAL_DOCUMENT,
+        ):
+            assert view.accepts(t)
+
+    def test_default_metrics(self) -> None:
+        view = build_search_view()
+        assert view.metric_names == DEFAULT_SEARCH_METRICS
+
+    def test_projection_for_alto_routes_correctly(self) -> None:
+        view = build_search_view()
+        spec = view.projection_for(ArtifactType.ALTO_XML)
+        assert spec is not None
+        assert spec.projector_name == "alto_to_text"
+
+    def test_warnings_signal_higher_is_better_inversion(self) -> None:
+        view = build_search_view()
+        text = " ".join(view.warnings)
+        assert "higher_is_better" in text or "OPPOSÉ" in text
+
+
+# ──────────────────────────────────────────────────────────────────
+# SearchView avec executor
+# ──────────────────────────────────────────────────────────────────
+
+
+def _build_search_executor(payloads: dict[str, str]) -> DefaultEvaluationViewExecutor:
+    metrics = MetricRegistry()
+    metrics.register(
+        MetricSpec(
+            name="searchability_recall",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+            higher_is_better=True,
+        ),
+        searchability_recall,
+    )
+    metrics.register(
+        MetricSpec(
+            name="numerical_sequence_preservation",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+            higher_is_better=True,
+        ),
+        numerical_sequence_preservation,
+    )
+    projectors = ProjectorRegistry()
+    projectors.register(AltoToText())
+    projectors.register(PageToText())
+    projectors.register(CanonicalToText())
+
+    def loader(art: Artifact) -> str:
+        if art.id not in payloads:
+            raise KeyError(art.id)
+        return payloads[art.id]
+
+    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+
+
+class TestSearchViewWithExecutor:
+    def test_perfect_text_yields_recall_1(self) -> None:
+        payloads = {
+            "cand": "le petit chat noir 1789",
+            "gt": "le petit chat noir 1789",
+        }
+        executor = _build_search_executor(payloads)
+        view = build_search_view()
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        assert result.metric_values["searchability_recall"] == 1.0
+        assert result.metric_values["numerical_sequence_preservation"] == 1.0
+
+    def test_partial_text_quality_with_year_loss(self) -> None:
+        payloads = {
+            "cand": "le pelit chat noir 1798",  # erreur typo + année corrompue
+            "gt": "le petit chat noir 1789",
+        }
+        executor = _build_search_executor(payloads)
+        view = build_search_view()
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        # "petit"→"pelit" = 1 sub, OK ; "1789"→"1798" = 2 subs, OK pour
+        # searchability fuzzy.  Donc searchability_recall ≈ 1.0.
+        assert result.metric_values["searchability_recall"] >= 0.8
+        # Mais l'année 1789 N'EST PAS dans hyp → preservation = 0.
+        assert result.metric_values["numerical_sequence_preservation"] == 0.0