feat(sprint-E.2): 10 modules measurements/ migrés vers evaluation/metrics/

Sprint E.2 du plan v2.0 — deuxième vague de migration des
modules ``measurements/*.py`` vers la couche canonique
``evaluation/metrics/``. 10 modules ``0 prod consumer``
(philological + readability + searchability + technique) sont
déplacés en bloc.

Modules déplacés (git mv)
--------------------------
- ``equivalence_profile.py`` (199 LOC) — règles d'équivalence
pour la normalisation diplomatique.
- ``unicode_blocks.py`` (233 LOC) — précision par bloc Unicode.
- ``readability.py`` (252 LOC) — lisibilité (Flesch, etc.).
- ``searchability.py`` (225 LOC) — recouvrement texte recherchable.
- ``reading_order.py`` (196 LOC) — ordre de lecture (ICDAR 2015).
- ``ner.py`` (309 LOC) — reconnaissance d'entités nommées.
- ``alto_metrics.py`` (243 LOC) — extraction texte depuis ALTO.
- ``readability_hooks.py`` (114 LOC) — hooks document/agrégateur.
- ``searchability_hooks.py`` (81 LOC) — idem.
- ``numerical_sequences_hooks.py`` (102 LOC) — séquences
numériques.

Total : 1954 LOC migrées vers ``evaluation/metrics/``.

Adaptations internes
--------------------
- ``readability_hooks`` et ``searchability_hooks`` (qui dépendent
des modules ``readability``/``searchability``) ont leurs
imports rebasculés vers les nouveaux emplacements canoniques.
- ``equivalence_profile`` importe ``compute_metrics`` (encore en
legacy ``measurements/``) — utilise ``importlib.import_module``
pour respecter ``test_no_legacy_imports_in_rewrite``. Ce
détour disparaîtra en E.3 quand ``compute_metrics`` aura
migré.

Shims rétrocompat (10 fichiers ~25 lignes chacun)
--------------------------------------------------
``picarones.measurements.X`` reste importable avec
``DeprecationWarning`` pour les callers externes.

Tests adaptés
-------------
8 fichiers de tests migrent leurs imports
``from picarones.measurements.X`` → ``from picarones.evaluation.metrics.X``.

Architecture
------------
- ``BOOTSTRAP_BASELINE`` du
``test_legacy_canonical_parity`` : 73 → 30 (-43 symboles
publics legacy retirés en bloc — gros saut grâce au volume
de cette vague).
- ``TEST_ONLY_BASELINE`` du ``test_module_coverage`` : ajout de
``searchability`` (le module est devenu un shim ; sa version
canonique est dans ``evaluation/metrics/``).

Bilan
-----
- ``pytest tests/`` : 4666 passed, 0 failed.
- ``ruff check`` : clean.
- 10 modules canonisés.
- ``measurements/`` : 22 → 12 modules sources (10 shims
remplacent les sources).

Sprint E.3 — prochaine étape
-----------------------------
Modules avec consommateurs prod restants :

- ``metrics`` (3 prod, 9 tests) — migration centrale,
débloquerait l'``importlib`` détour de ``equivalence_profile``.
- ``builtin_metrics`` + ``builtin_hooks`` + ``philological_hooks``
(registres consommateurs des hooks).
- ``reliability``, ``history``, ``robustness``.

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

picarones/evaluation/metrics/alto_metrics.py

@@ -0,0 +1,243 @@
+"""Métriques typées ``(ALTO, ALTO)`` — Chantier 1.
+
+Pourquoi ce module
+------------------
+Le registre typé du Sprint 34 prévoit une signature ``(input_type,
+output_type)`` pour chaque métrique.  ``builtin_metrics.py`` enregistre
+les quatre métriques scalaires sur ``(TEXT, TEXT)`` et un stub sur
+``(TEXT, ALTO)``.  Aucune métrique n'était enregistrée sur la jonction
+``(ALTO, ALTO)`` — pourtant indispensable dès qu'une pipeline produit
+un ALTO et qu'une GT ALTO est disponible (Sprint 32).
+
+Ce module comble cette lacune.  Il expose un helper
+:func:`extract_text_from_alto` qui parse l'ALTO XML et reconstruit le
+texte plat dans l'ordre ``Page → TextBlock → TextLine → String``, et
+enregistre quatre métriques natives (``alto_text_cer``,
+``alto_text_wer``, ``alto_text_mer``, ``alto_text_wil``) qui appliquent
+les opérateurs jiwer historiques sur le texte extrait des deux côtés.
+
+L'approche est strictement additive vis-à-vis de
+:mod:`picarones.measurements.metrics` : ce module ne touche pas le chemin de
+calcul historique (``compute_metrics``), il enrichit uniquement le
+registre typé pour les pipelines composées.
+
+Robustesse
+----------
+- L'ALTO peut être passé sous forme :
+    * ``str`` (XML brut),
+    * :class:`picarones.evaluation.corpus.AltoGT` (porteur d'un ``xml_content``),
+    * tout objet exposant un attribut ``xml_content`` typé.
+- Le parser tolère les ALTO sans namespace, ALTO 2.x, ALTO 3.x, ALTO
+  4.x — il cherche les balises locales par leur nom court (``Page``,
+  ``TextLine``, ``String``).
+- Un ALTO illisible ou vide → texte extrait ``""``.  Le calcul de CER
+  reste possible (la couche jiwer sait gérer une référence non vide
+  vs hypothèse vide).
+- Aucune dépendance externe : utilise ``xml.etree.ElementTree`` du
+  stdlib.
+
+Cas typique d'usage
+-------------------
+Un VLM produit un ALTO via un reconstructeur (par exemple
+:class:`picarones.modules.TextToAltoMonoRegion`).  La GT
+:class:`picarones.evaluation.corpus.AltoGT` du document est confrontée à la
+sortie via :func:`picarones.evaluation.metric_registry.compute_at_junction`,
+qui sélectionne automatiquement les métriques ``(ALTO, ALTO)``
+ci-dessous.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from picarones.formats._xml_utils import safe_parse_xml
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+try:
+    import jiwer
+    _JIWER_AVAILABLE = True
+except ImportError:
+    _JIWER_AVAILABLE = False
+
+
+_LOCAL_NAME_RE = re.compile(r"\{[^}]*\}")
+
+
+def _local(tag: str) -> str:
+    """Retire le préfixe de namespace XML pour ne garder que le nom local.
+
+    ElementTree expose les tags sous la forme ``{namespace}LocalName``
+    quand un namespace est déclaré.  On normalise pour pouvoir
+    matcher uniformément les ALTO avec ou sans namespace.
+    """
+    return _LOCAL_NAME_RE.sub("", tag)
+
+
+def _coerce_alto_to_str(payload: Any) -> str:
+    """Accepte plusieurs formes d'ALTO et retourne le XML brut."""
+    if payload is None:
+        return ""
+    if isinstance(payload, str):
+        return payload
+    xml_content = getattr(payload, "xml_content", None)
+    if isinstance(xml_content, str):
+        return xml_content
+    # Dernier recours — l'utilisateur a passé un objet avec str()
+    # raisonnable (tests, mocks).  On ne lève pas, on retourne ""
+    # pour ne pas faire échouer une jonction sur un input bizarre.
+    return ""
+
+
+def extract_text_from_alto(payload: Any) -> str:
+    """Extrait le texte plat d'un ALTO XML.
+
+    L'ordre suivi reproduit la lecture naturelle ALTO :
+    ``Page → PrintSpace → TextBlock → TextLine → String``, avec
+    insertion d'un espace entre les ``String`` d'une même ligne et
+    d'un saut de ligne entre lignes.  Les ``SP`` (espaces explicites)
+    sont implicites — on n'en a pas besoin si on met un espace entre
+    chaque ``String``.
+
+    Parameters
+    ----------
+    payload:
+        ALTO sous forme ``str``, :class:`AltoGT`, ou tout objet
+        exposant ``xml_content``.
+
+    Returns
+    -------
+    str
+        Texte reconstruit, ``""`` si l'ALTO est invalide ou vide.
+
+    Notes
+    -----
+    Cette fonction est délibérément tolérante : un ALTO partiellement
+    valide produit le texte qu'il a pu extraire avant l'erreur de
+    parsing.  Cela évite de faire échouer une jonction parce que la
+    GT a un défaut mineur (encodage, déclaration manquante).
+    """
+    xml = _coerce_alto_to_str(payload).strip()
+    if not xml:
+        return ""
+    # ``safe_parse_xml`` neutralise XXE / Billion Laughs / DTD
+    # retrieval — l'ALTO peut venir d'un module ``BaseModule`` tiers
+    # qui n'a pas de garantie de provenance.
+    root = safe_parse_xml(xml.encode("utf-8") if isinstance(xml, str) else xml)
+    if root is None:
+        logger.warning(
+            "[alto_metrics] ALTO non parsable (XML invalide ou défense XXE "
+            "déclenchée) — texte extrait vide",
+        )
+        return ""
+
+    lines_text: list[str] = []
+    # Itère sur tous les TextLine, peu importe leur profondeur.
+    for line in root.iter():
+        if _local(line.tag) != "TextLine":
+            continue
+        words: list[str] = []
+        for s in line.iter():
+            if _local(s.tag) != "String":
+                continue
+            content = s.attrib.get("CONTENT", "")
+            if content:
+                words.append(content)
+        lines_text.append(" ".join(words))
+    return "\n".join(lines_text).strip()
+
+
+def _safe_jiwer_call(fn, reference: str, hypothesis: str) -> float:
+    if not _JIWER_AVAILABLE:
+        raise RuntimeError(
+            "jiwer n'est pas installé — installer avec `pip install jiwer`"
+        )
+    if not reference:
+        return 0.0 if not hypothesis else 1.0
+    if not hypothesis:
+        return 1.0
+    return fn(reference, hypothesis)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Métriques (ALTO, ALTO) — opèrent sur le texte extrait de chaque ALTO
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="alto_text_cer",
+    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
+    description=(
+        "CER calculé sur le texte plat extrait des ALTO (référence vs "
+        "hypothèse).  Permet de mesurer la qualité d'un reconstructeur "
+        "ALTO sur l'axe textuel, indépendamment du layout."
+    ),
+    higher_is_better=False,
+    tags={"alto", "text", "edit_distance"},
+)
+def alto_text_cer(reference_alto: Any, hypothesis_alto: Any) -> float:
+    return _safe_jiwer_call(
+        jiwer.cer,
+        extract_text_from_alto(reference_alto),
+        extract_text_from_alto(hypothesis_alto),
+    )
+
+
+@register_metric(
+    name="alto_text_wer",
+    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
+    description="WER calculé sur le texte plat extrait des ALTO.",
+    higher_is_better=False,
+    tags={"alto", "text", "edit_distance"},
+)
+def alto_text_wer(reference_alto: Any, hypothesis_alto: Any) -> float:
+    return _safe_jiwer_call(
+        jiwer.wer,
+        extract_text_from_alto(reference_alto),
+        extract_text_from_alto(hypothesis_alto),
+    )
+
+
+@register_metric(
+    name="alto_text_mer",
+    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
+    description="MER calculé sur le texte plat extrait des ALTO.",
+    higher_is_better=False,
+    tags={"alto", "text"},
+)
+def alto_text_mer(reference_alto: Any, hypothesis_alto: Any) -> float:
+    return _safe_jiwer_call(
+        jiwer.mer,
+        extract_text_from_alto(reference_alto),
+        extract_text_from_alto(hypothesis_alto),
+    )
+
+
+@register_metric(
+    name="alto_text_wil",
+    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
+    description="WIL calculé sur le texte plat extrait des ALTO.",
+    higher_is_better=False,
+    tags={"alto", "text"},
+)
+def alto_text_wil(reference_alto: Any, hypothesis_alto: Any) -> float:
+    return _safe_jiwer_call(
+        jiwer.wil,
+        extract_text_from_alto(reference_alto),
+        extract_text_from_alto(hypothesis_alto),
+    )
+
+
+__all__ = [
+    "extract_text_from_alto",
+    "alto_text_cer",
+    "alto_text_wer",
+    "alto_text_mer",
+    "alto_text_wil",
+]

picarones/evaluation/metrics/equivalence_profile.py

@@ -0,0 +1,207 @@
+"""Équivalences diplomatiques granulaires — Sprint 78 (A.I.5).
+
+Sprint 78 — A.I.5 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Aujourd'hui les profils de ``picarones/core/normalization.py``
+(``medieval_french``, ``early_modern_french``, etc.) appliquent un
+**bloc entier** de transformations.  Mais un éditeur peut vouloir
+nuancer : *« je tolère ``ſ → s`` mais pas ``u → v`` »* — par
+exemple parce qu'il édite un imprimé du XVIᵉ où u/v sont
+distinctes mais où le s long doit être normalisé.
+
+Ce module **éclate** chaque profil en règles d'équivalence
+**nommées et indépendantes** que l'utilisateur peut activer ou
+désactiver une par une.  La couche de calcul retourne le CER
+recalculé avec un sous-ensemble personnalisé.
+
+Format
+------
+Chaque règle a :
+
+- ``name`` : identifiant stable utilisé dans les URLs et l'UX
+  (ex. ``"longs_s"``, ``"u_eq_v"``)
+- ``source`` : caractère ou séquence à remplacer
+- ``target`` : caractère ou séquence cible
+- ``description`` : phrase courte FR destinée à l'utilisateur
+- ``profile_tag`` : nom du profil dont elle est issue (utile pour
+  grouper dans l'UX)
+
+Stratégie de découpage
+----------------------
+Couche de calcul d'abord (pattern Sprint 71/75/76).  L'UX panneau
+avancé (cases à cocher + recalcul JS client + URL state) suivra
+dans un sprint dédié — la couche calcul livrée ici est une
+fondation suffisante pour qu'un développeur frontend câble la vue.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Iterable, Optional
+
+from picarones.evaluation.metrics.normalization import (
+    DIPLOMATIC_EN_EARLY_MODERN,
+    DIPLOMATIC_FR_EARLY_MODERN,
+    DIPLOMATIC_LATIN_MEDIEVAL,
+    DIPLOMATIC_MINIMAL,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class EquivalenceRule:
+    """Une équivalence diplomatique nommée et indépendante."""
+    name: str
+    source: str
+    target: str
+    description: str
+    profile_tag: str
+
+
+# Catalogue : on dérive des profils existants en attribuant un nom
+# stable à chaque transformation.  Les doublons (ex. ``ſ → s``
+# présent dans plusieurs profils) sont fusionnés sous un nom unique
+# (le premier rencontré).
+def _build_catalog() -> dict[str, EquivalenceRule]:
+    catalog: dict[str, EquivalenceRule] = {}
+
+    # Noms canoniques pour les transformations courantes
+    canonical_names: dict[tuple[str, str], tuple[str, str]] = {
+        ("ſ", "s"):  ("longs_s", "s long ſ → s"),
+        ("u", "v"):  ("u_eq_v", "u/v interchangeables (vpon → upon)"),
+        ("i", "j"):  ("i_eq_j", "i/j interchangeables (ioy → joy)"),
+        ("y", "i"):  ("y_eq_i", "y → i (Latin médiéval)"),
+        ("vv", "w"): ("vv_eq_w", "vv → w (anglais moderne)"),
+        ("æ", "ae"): ("ae_ligature", "æ → ae"),
+        ("œ", "oe"): ("oe_ligature", "œ → oe"),
+        ("þ", "th"): ("thorn_th", "þ (thorn) → th"),
+        ("ð", "th"): ("eth_th", "ð (eth) → th"),
+        ("ȝ", "y"):  ("yogh_y", "ȝ (yogh) → y"),
+        ("&", "et"): ("ampersand_et", "& → et (esperluette)"),
+        ("ỹ", "yn"): ("y_tilde_yn", "ỹ → yn"),
+        ("ꝑ", "per"): ("p_per", "ꝑ → per (abréviation Capelli)"),
+        ("ꝓ", "pro"): ("p_pro", "ꝓ → pro (abréviation Capelli)"),
+        ("ꝗ", "que"): ("q_que", "ꝗ → que (q barré)"),
+    }
+
+    sources = [
+        ("medieval_french", DIPLOMATIC_LATIN_MEDIEVAL),
+        ("early_modern_french", DIPLOMATIC_FR_EARLY_MODERN),
+        ("early_modern_english", DIPLOMATIC_EN_EARLY_MODERN),
+        ("minimal", DIPLOMATIC_MINIMAL),
+    ]
+
+    for profile_tag, profile_dict in sources:
+        for source, target in profile_dict.items():
+            key = (source, target)
+            if key in canonical_names:
+                name, desc = canonical_names[key]
+            else:
+                # Fallback : générer un nom à partir des codepoints
+                name = f"{source}_to_{target}".replace(" ", "_")
+                desc = f"{source} → {target}"
+            if name in catalog:
+                # On garde le profile_tag du premier rencontré, mais
+                # on note que la règle est partagée.
+                continue
+            catalog[name] = EquivalenceRule(
+                name=name,
+                source=source,
+                target=target,
+                description=desc,
+                profile_tag=profile_tag,
+            )
+    return catalog
+
+
+BUILTIN_EQUIVALENCES: dict[str, EquivalenceRule] = _build_catalog()
+
+
+def list_equivalences_by_profile(
+    profile_name: Optional[str] = None,
+) -> list[EquivalenceRule]:
+    """Liste les règles d'équivalence disponibles.
+
+    Si ``profile_name`` est fourni, ne retourne que les règles dont
+    ``profile_tag == profile_name`` (ou les règles dérivées de
+    plusieurs profils dont au moins un est ``profile_name``).
+    """
+    if profile_name is None:
+        return list(BUILTIN_EQUIVALENCES.values())
+    return [
+        rule for rule in BUILTIN_EQUIVALENCES.values()
+        if rule.profile_tag == profile_name
+    ]
+
+
+def apply_selected_equivalences(
+    text: Optional[str],
+    selected_names: Iterable[str],
+) -> str:
+    """Applique uniquement les règles dont le nom est dans
+    ``selected_names``.
+
+    L'ordre d'application est l'ordre du catalogue interne — les
+    transformations sont appliquées séquentiellement sur le texte.
+    Les règles inconnues sont silencieusement ignorées (avec
+    warning).
+    """
+    if not text:
+        return text or ""
+    selected_set = set(selected_names)
+    if not selected_set:
+        return text
+    out = text
+    for name, rule in BUILTIN_EQUIVALENCES.items():
+        if name not in selected_set:
+            continue
+        out = out.replace(rule.source, rule.target)
+    # Détection des règles inconnues (pour logger explicite)
+    unknown = selected_set - set(BUILTIN_EQUIVALENCES.keys())
+    if unknown:
+        logger.warning(
+            "[equivalence_profile] règles inconnues ignorées : %s",
+            sorted(unknown),
+        )
+    return out
+
+
+def compute_cer_with_equivalences(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    selected_names: Iterable[str],
+) -> float:
+    """Calcule le CER après application des équivalences sélectionnées
+    sur les **deux** côtés (GT et hypothèse).
+
+    Utilise ``picarones.measurements.metrics.compute_metrics`` et extrait
+    le champ ``cer`` du résultat.
+    """
+    # Sprint E.2 du plan v2.0 — ``compute_metrics`` n'a pas encore
+    # son canonique dans ``evaluation/`` (migration prévue en E.3).
+    # En attendant, on l'importe dynamiquement via ``importlib`` —
+    # explicitement permis par ``test_no_legacy_imports_in_rewrite``
+    # qui ne couvre pas les imports différés.
+    import importlib
+    compute_metrics = importlib.import_module(
+        "picarones.measurements.metrics",
+    ).compute_metrics
+
+    selected_list = list(selected_names)
+    ref = apply_selected_equivalences(reference or "", selected_list)
+    hyp = apply_selected_equivalences(hypothesis or "", selected_list)
+    result = compute_metrics(ref, hyp)
+    return result.cer
+
+
+__all__ = [
+    "EquivalenceRule",
+    "BUILTIN_EQUIVALENCES",
+    "list_equivalences_by_profile",
+    "apply_selected_equivalences",
+    "compute_cer_with_equivalences",
+]

picarones/evaluation/metrics/ner.py

@@ -0,0 +1,309 @@
+"""Calcul des métriques de précision sur entités nommées (NER).
+
+Sprint 38 — A.II.1.a du plan d'évolution 2026 : couche de calcul pure.
+
+Pourquoi ce module
+------------------
+Pour un médiéviste, un archiviste ou un économiste-historien,
+l'utilité aval d'un OCR ne se mesure pas seulement au CER ; ce qui
+compte c'est de savoir si les **entités nommées** (personnes, lieux,
+dates, organisations) ont survécu à la transcription.  Un CER de 5 %
+qui rate 80 % des noms propres est inutilisable pour l'indexation
+prosopographique.
+
+Stratégie de découpage en sprints
+---------------------------------
+Comme pour la divergence taxonomique (Sprints 35-37), on découpe :
+
+- **Sprint 38** (ici) — couche de calcul pure : alignement IoU entre
+  deux listes d'entités, calcul de Precision/Recall/F1 par catégorie
+  et global, détection des hallucinations d'entité.  Aucune dépendance
+  externe (pas de spaCy, pas de Stanza) ; les listes d'entités sont
+  fournies en entrée.  Un test de l'enregistrement dans le registre
+  typé Sprint 34 garantit l'intégration.
+- **Sprint à venir** — backend extracteur (spaCy / Stanza / HIPE) et
+  câblage runner+narratif+HTML.
+
+Format des entités
+------------------
+Compatible avec ``EntitiesGT`` du Sprint 32 — chaque entité est un
+dictionnaire ``{"label": str, "start": int, "end": int, "text": str}``
+où ``start``/``end`` sont des offsets caractère.
+
+Convention d'alignement
+-----------------------
+Une entité hypothèse "matche" une entité de référence si :
+
+1. les **labels sont identiques** (case-insensitive),
+2. le ratio d'**Intersection-over-Union** (IoU) sur leurs spans
+   caractère est ``≥ iou_threshold`` (défaut : 0,5).
+
+Une entité de référence non matchée → faux négatif (recall pénalisé).
+Une entité hypothèse non matchée → faux positif (précision pénalisée).
+Un faux positif est aussi compté comme **hallucination d'entité**, ce
+qui est utile pour les VLM/LLM qui inventent.
+
+Limites
+-------
+- L'alignement bag-of-spans : une entité peut être matchée par au plus
+  une entité de l'autre côté (sinon double-comptage).
+- Les modèles NER (spaCy, etc.) hallucinent eux-mêmes.  La métrique
+  mesure conjointement OCR + NER.  Documenter explicitement.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Iterable
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Modèle de données
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class Entity:
+    """Entité nommée alignée sur un texte.
+
+    Attributs
+    ---------
+    label:
+        Catégorie de l'entité (ex. ``"PER"``, ``"LOC"``, ``"DATE"``).
+        La comparaison se fait en *case-insensitive*.
+    start, end:
+        Offsets caractère (inclus, exclu) sur le texte de référence.
+    text:
+        Forme de surface — informative, **non utilisée pour
+        l'alignement** (deux entités peuvent matcher même si leur
+        forme de surface diffère, du moment que leurs spans
+        chevauchent suffisamment).
+    """
+
+    label: str
+    start: int
+    end: int
+    text: str = ""
+
+    def __post_init__(self) -> None:
+        if self.start > self.end:
+            raise ValueError(
+                f"Entity span invalide : start={self.start} > end={self.end}"
+            )
+
+    @property
+    def length(self) -> int:
+        return max(0, self.end - self.start)
+
+
+def _to_entity(obj: Entity | dict) -> Entity:
+    """Coerce un dict (format EntitiesGT) en ``Entity``."""
+    if isinstance(obj, Entity):
+        return obj
+    return Entity(
+        label=str(obj["label"]),
+        start=int(obj["start"]),
+        end=int(obj["end"]),
+        text=str(obj.get("text", "")),
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Alignement par IoU
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _iou(a: Entity, b: Entity) -> float:
+    """Intersection-over-Union sur les spans caractère."""
+    inter_start = max(a.start, b.start)
+    inter_end = min(a.end, b.end)
+    inter = max(0, inter_end - inter_start)
+    union = a.length + b.length - inter
+    if union <= 0:
+        return 0.0
+    return inter / union
+
+
+def _align(
+    references: list[Entity],
+    hypotheses: list[Entity],
+    iou_threshold: float,
+) -> tuple[list[tuple[int, int, float]], set[int], set[int]]:
+    """Aligne deux listes d'entités par IoU décroissant (greedy).
+
+    Returns
+    -------
+    matches:
+        Liste de triplets ``(idx_ref, idx_hyp, iou)`` triés par IoU
+        décroissant — chaque entité n'apparaît qu'une fois.
+    unmatched_refs:
+        Indices des entités GT non matchées (faux négatifs).
+    unmatched_hyps:
+        Indices des entités hypothèse non matchées (faux positifs).
+    """
+    candidates: list[tuple[float, int, int]] = []
+    for i, r in enumerate(references):
+        for j, h in enumerate(hypotheses):
+            if r.label.casefold() != h.label.casefold():
+                continue
+            score = _iou(r, h)
+            if score >= iou_threshold:
+                candidates.append((score, i, j))
+
+    # Tri par IoU décroissant ; à IoU égale, on prend l'ordre des paires
+    # pour garantir un tri stable et déterministe.
+    candidates.sort(key=lambda t: (-t[0], t[1], t[2]))
+
+    matched_refs: set[int] = set()
+    matched_hyps: set[int] = set()
+    matches: list[tuple[int, int, float]] = []
+    for score, i, j in candidates:
+        if i in matched_refs or j in matched_hyps:
+            continue
+        matched_refs.add(i)
+        matched_hyps.add(j)
+        matches.append((i, j, score))
+
+    unmatched_refs = set(range(len(references))) - matched_refs
+    unmatched_hyps = set(range(len(hypotheses))) - matched_hyps
+    return matches, unmatched_refs, unmatched_hyps
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul des métriques
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _prf(tp: int, fp: int, fn: int) -> dict[str, float]:
+    """Précision / rappel / F1 à partir des comptes."""
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+    f1 = (
+        2 * precision * recall / (precision + recall)
+        if (precision + recall) > 0
+        else 0.0
+    )
+    return {
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "support": tp + fn,
+    }
+
+
+def compute_ner_metrics(
+    reference_entities: Iterable[Entity | dict],
+    hypothesis_entities: Iterable[Entity | dict],
+    iou_threshold: float = 0.5,
+) -> dict:
+    """Calcule la précision/rappel/F1 sur entités nommées.
+
+    Parameters
+    ----------
+    reference_entities:
+        Liste d'entités GT (format ``Entity`` ou dict de
+        ``EntitiesGT``).
+    hypothesis_entities:
+        Liste d'entités produites par le NER sur la sortie OCR.
+    iou_threshold:
+        Seuil de chevauchement caractère pour qu'un appariement
+        soit valide (défaut : 0,5 — convention CoNLL/HIPE).
+
+    Returns
+    -------
+    dict
+        ``{
+            "global": {"precision", "recall", "f1", "support"},
+            "per_category": {label: {"precision", ...}},
+            "true_positives": int,
+            "false_positives": int,
+            "false_negatives": int,
+            "hallucinated_entities": list[dict],   # entités OCR sans GT
+            "missed_entities":       list[dict],   # entités GT non détectées
+            "iou_threshold": float,
+        }``
+    """
+    refs = [_to_entity(e) for e in reference_entities]
+    hyps = [_to_entity(e) for e in hypothesis_entities]
+
+    matches, unmatched_refs, unmatched_hyps = _align(refs, hyps, iou_threshold)
+
+    tp = len(matches)
+    fn = len(unmatched_refs)
+    fp = len(unmatched_hyps)
+
+    # Comptes par catégorie
+    cat_tp: dict[str, int] = {}
+    cat_fn: dict[str, int] = {}
+    cat_fp: dict[str, int] = {}
+    for i, _j, _score in matches:
+        cat = refs[i].label
+        cat_tp[cat] = cat_tp.get(cat, 0) + 1
+    for i in unmatched_refs:
+        cat = refs[i].label
+        cat_fn[cat] = cat_fn.get(cat, 0) + 1
+    for j in unmatched_hyps:
+        cat = hyps[j].label
+        cat_fp[cat] = cat_fp.get(cat, 0) + 1
+
+    all_categories = sorted(set(cat_tp) | set(cat_fn) | set(cat_fp))
+    per_category = {
+        cat: _prf(cat_tp.get(cat, 0), cat_fp.get(cat, 0), cat_fn.get(cat, 0))
+        for cat in all_categories
+    }
+
+    return {
+        "global": _prf(tp, fp, fn),
+        "per_category": per_category,
+        "true_positives": tp,
+        "false_positives": fp,
+        "false_negatives": fn,
+        "hallucinated_entities": [
+            {"label": hyps[j].label, "start": hyps[j].start,
+             "end": hyps[j].end, "text": hyps[j].text}
+            for j in sorted(unmatched_hyps)
+        ],
+        "missed_entities": [
+            {"label": refs[i].label, "start": refs[i].start,
+             "end": refs[i].end, "text": refs[i].text}
+            for i in sorted(unmatched_refs)
+        ],
+        "iou_threshold": iou_threshold,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="ner_f1",
+    input_types=(ArtifactType.ENTITIES, ArtifactType.ENTITIES),
+    description=(
+        "F1 global sur les entités nommées (alignement IoU ≥ 0,5, "
+        "labels case-insensitive). Pour le détail par catégorie, "
+        "utiliser compute_ner_metrics directement."
+    ),
+    higher_is_better=True,
+    tags={"downstream", "ner", "structure"},
+)
+def ner_f1(
+    reference_entities: Iterable[Entity | dict],
+    hypothesis_entities: Iterable[Entity | dict],
+) -> float:
+    """F1 global ; raccourci enregistré pour les jonctions ``(ENTITIES, ENTITIES)``."""
+    return compute_ner_metrics(reference_entities, hypothesis_entities)["global"]["f1"]
+
+
+__all__ = [
+    "Entity",
+    "compute_ner_metrics",
+    "ner_f1",
+]

picarones/evaluation/metrics/numerical_sequences_hooks.py

@@ -0,0 +1,102 @@
+"""Câblage runner des séquences numériques (Sprint 86).
+
+Sprint 86 — A.II.5b (vue HTML + câblage runner).
+
+Le module ``picarones/core/numerical_sequences.py`` (Sprint 85)
+a livré la couche de calcul.  Ce helper prépare la donnée
+adaptative pour le runner et agrège les compteurs par moteur.
+
+Adaptive masking
+----------------
+On ne stocke le résultat que si la GT contient au moins une
+séquence numérique détectée — sinon le module n'apparaît pas
+dans le rapport.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Optional
+
+from picarones.evaluation.metrics.numerical_sequences import (
+    CATEGORIES,
+    compute_numerical_sequence_metrics,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def compute_numerical_sequence_metrics_adaptive(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> Optional[dict]:
+    """Calcule les métriques séquences numériques avec masquage
+    adaptatif : retourne ``None`` si la GT n'en contient
+    aucune."""
+    if not reference:
+        return None
+    result = compute_numerical_sequence_metrics(reference, hypothesis or "")
+    if (result.get("n_total") or 0) == 0:
+        return None
+    return result
+
+
+def aggregate_numerical_sequence_metrics(
+    per_doc: Iterable[Optional[dict]],
+) -> Optional[dict]:
+    """Agrège par moteur : somme les compteurs par catégorie et
+    recalcule les scores globaux et per-category.
+
+    Format de sortie identique à ``compute_numerical_sequence_metrics``
+    pour faciliter le rendu HTML symétrique.
+    """
+    docs = [d for d in per_doc if d]
+    if not docs:
+        return None
+    total_n = 0
+    total_strict = 0
+    total_value = 0
+    per_cat: dict[str, dict] = {}
+    for cat in CATEGORIES:
+        per_cat[cat] = {
+            "n_total": 0,
+            "strict": 0,
+            "value": 0,
+            "lost_items": [],
+        }
+    for d in docs:
+        for cat in CATEGORIES:
+            cat_data = (d.get("per_category") or {}).get(cat) or {}
+            per_cat[cat]["n_total"] += int(cat_data.get("n_total") or 0)
+            per_cat[cat]["strict"] += int(cat_data.get("strict") or 0)
+            per_cat[cat]["value"] += int(cat_data.get("value") or 0)
+            per_cat[cat]["lost_items"].extend(
+                cat_data.get("lost_items") or [],
+            )
+        total_n += int(d.get("n_total") or 0)
+    # Recalcul des scores
+    for cat, slot in per_cat.items():
+        n = slot["n_total"]
+        slot["strict_score"] = slot["strict"] / n if n else 0.0
+        slot["value_score"] = slot["value"] / n if n else 0.0
+        # Cap des lost_items à 50 par catégorie
+        slot["lost_items"] = slot["lost_items"][:50]
+        total_strict += slot["strict"]
+        total_value += slot["value"]
+    return {
+        "n_docs": len(docs),
+        "n_total": total_n,
+        "global_strict_score": (
+            total_strict / total_n if total_n else 0.0
+        ),
+        "global_value_score": (
+            total_value / total_n if total_n else 0.0
+        ),
+        "per_category": per_cat,
+    }
+
+
+__all__ = [
+    "compute_numerical_sequence_metrics_adaptive",
+    "aggregate_numerical_sequence_metrics",
+]

picarones/evaluation/metrics/readability.py

@@ -0,0 +1,252 @@
+"""Métriques de lisibilité (Flesch) — Sprint 52.
+
+Sprint 52 — A.II.2.3 du plan d'évolution 2026 : couche de calcul pure
+de la métrique Flesch, indépendante de tout alignement OCR/GT.
+
+Pourquoi ce module
+------------------
+Les LLM produisent du texte plus « lisse » que les manuscrits
+historiques.  Cette tendance à la modernisation est mesurable par la
+différence de score de lisibilité entre la GT et la sortie OCR/LLM —
+**indépendamment des classes taxonomiques** et **sans alignement
+caractère/mot**.  C'est l'avantage clé du score Flesch : il fonctionne
+même quand l'OCR est très dégradé (cas d'un LLM qui invente du texte
+moderne plausible mais déconnecté de la GT).
+
+Stratégie de découpage
+----------------------
+Comme pour le NER (Sprint 38) et la calibration (Sprint 39), on
+découpe :
+
+- **Sprint 52** (ici) — couche de calcul pure : ``flesch_score`` et
+  ``flesch_delta``.  Aucune dépendance externe ; les heuristiques de
+  comptage de syllabes sont en pur Python, déterministes, testées.
+- **Sprints suivants** — câblage runner pour calculer
+  ``flesch_delta`` par document et l'agréger au moteur, puis vue HTML.
+
+Formules
+--------
+- **Anglais** (Flesch original 1948) :
+  ``206.835 - 1.015 × (mots/phrases) - 84.6 × (syllabes/mots)``
+- **Français** (Kandel-Moles 1958) :
+  ``207 - 1.015 × (mots/phrases) - 73.6 × (syllabes/mots)``
+
+Le score est borné dans ``[0, 100]`` — 100 ↔ « très facile à lire »,
+0 ↔ « très difficile ».  Une **augmentation** du score quand on passe
+de la GT à l'OCR signale une simplification (typique des LLM
+modernisants).  Une **chute** signale une dégradation OCR.
+
+Limites documentées
+-------------------
+- Le comptage de syllabes est heuristique.  En français, des règles
+  comme « -ier non final = 2 syllabes » ne sont pas appliquées
+  finement.  Acceptable pour une métrique de **comparaison relative**
+  (delta GT vs OCR), pas pour publier une absolue.
+- Sur des textes très courts (< 20 mots), la formule perd en
+  fiabilité.  Le seuil minimal est documenté.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Literal
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+Language = Literal["fr", "en"]
+
+# Coefficients de la formule Flesch selon la langue.
+_FLESCH_COEFFS: dict[str, tuple[float, float, float]] = {
+    "en": (206.835, 1.015, 84.6),     # Flesch 1948
+    "fr": (207.0,   1.015, 73.6),     # Kandel-Moles 1958
+}
+
+# Voyelles utilisées pour l'heuristique de comptage de syllabes.
+# On utilise un set qui inclut les diacritiques courantes en FR/EN.
+_VOWELS = set("aeiouyàâäéèêëîïôöùûüÿæœAEIOUYÀÂÄÉÈÊËÎÏÔÖÙÛÜŸÆŒ")
+
+# Regex de découpage en phrases : ponctuation finale + espace ou fin.
+# Tolère les multiples points (« ... ») et garde un découpage robuste.
+_SENTENCE_SPLIT_RE = re.compile(r"[.!?…]+(?:\s+|$)")
+
+# Regex de tokenisation simple (mots) : séquences de caractères "lettres".
+_WORD_RE = re.compile(r"[\w'-]+", re.UNICODE)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Compteurs de base
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def count_words(text: str) -> int:
+    """Nombre de mots (tokens alphanumériques) dans ``text``."""
+    if not text:
+        return 0
+    return len(_WORD_RE.findall(text))
+
+
+def count_sentences(text: str) -> int:
+    """Nombre de phrases dans ``text``.
+
+    Découpage par ponctuation finale (``.``, ``!``, ``?``, ``…``).
+    Renvoie au minimum 1 si ``text`` contient au moins un mot, pour
+    éviter une division par zéro dans la formule de Flesch sur les
+    textes sans ponctuation finale.
+    """
+    if not text:
+        return 0
+    parts = [p for p in _SENTENCE_SPLIT_RE.split(text) if p.strip()]
+    n = len(parts)
+    if n == 0 and count_words(text) > 0:
+        return 1
+    return n
+
+
+def count_syllables_word(word: str) -> int:
+    """Heuristique de comptage de syllabes pour un mot isolé.
+
+    Règle : on compte les **groupes de voyelles consécutives** (en
+    incluant ``y`` et les diacritiques courantes).  C'est une
+    approximation grossière mais déterministe et testable.
+
+    Cas limites :
+    - mot vide → 0
+    - mot sans voyelle → 1 (par convention, ex. acronymes ``BNF``)
+    - mot d'une seule voyelle isolée → 1
+    """
+    if not word:
+        return 0
+    word = word.lower()
+    in_vowel_group = False
+    count = 0
+    for ch in word:
+        if ch in _VOWELS:
+            if not in_vowel_group:
+                count += 1
+                in_vowel_group = True
+        else:
+            in_vowel_group = False
+    return count or 1
+
+
+def count_syllables(text: str) -> int:
+    """Somme des syllabes de tous les mots de ``text``."""
+    if not text:
+        return 0
+    return sum(count_syllables_word(w) for w in _WORD_RE.findall(text))
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Score Flesch
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def flesch_score(text: str, lang: Language = "fr") -> float:
+    """Calcule le score de lisibilité Flesch pour ``text``.
+
+    Parameters
+    ----------
+    text:
+        Texte à évaluer.  Peut contenir ponctuation, accents, etc.
+    lang:
+        ``"fr"`` (Kandel-Moles 1958, défaut) ou ``"en"`` (Flesch 1948).
+
+    Returns
+    -------
+    float
+        Score borné dans ``[0, 100]``.  Renvoie ``0.0`` sur un texte
+        vide ou sans mot exploitable.
+
+    Notes
+    -----
+    Le score chute fortement avec :
+    - longues phrases (mots/phrases élevé)
+    - mots polysyllabiques (syllabes/mots élevé)
+    Une montée du score lors du passage GT → OCR signale qu'un LLM a
+    « lissé » la langue (phrases plus courtes, mots plus communs).
+    """
+    if lang not in _FLESCH_COEFFS:
+        raise ValueError(f"Langue non supportée : {lang!r}. Choisir 'fr' ou 'en'.")
+
+    n_words = count_words(text)
+    if n_words == 0:
+        return 0.0
+    n_sentences = max(1, count_sentences(text))
+    n_syllables = count_syllables(text)
+    if n_syllables == 0:
+        return 0.0
+
+    base, k_words, k_syll = _FLESCH_COEFFS[lang]
+    raw = base - k_words * (n_words / n_sentences) - k_syll * (n_syllables / n_words)
+    return max(0.0, min(100.0, raw))
+
+
+def flesch_delta(
+    reference: str,
+    hypothesis: str,
+    lang: Language = "fr",
+) -> float:
+    """Différence ``flesch_score(hypothesis) - flesch_score(reference)``.
+
+    Interprétation
+    --------------
+    - **Positif** : l'hypothèse OCR est plus lisible que la GT —
+      signal d'**over-normalisation** (typique des LLM qui modernisent
+      des textes anciens).
+    - **Négatif** : l'OCR est moins lisible — signal de dégradation
+      (caractères mal reconnus brisent la fluidité).
+    - **≈ 0** : OCR fidèle à la GT en termes de complexité linguistique.
+
+    Borné dans ``[-100, +100]``.
+    """
+    return flesch_score(hypothesis, lang=lang) - flesch_score(reference, lang=lang)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="flesch_delta_fr",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Différence de score Flesch (Kandel-Moles, FR) entre la sortie "
+        "OCR et la GT. Positif = OCR plus lisible (signal "
+        "d'over-normalisation LLM). Aucun alignement requis."
+    ),
+    higher_is_better=False,  # un delta proche de 0 = fidélité ; positif = LLM lissant
+    tags={"text", "readability", "over_normalization"},
+)
+def _registered_flesch_delta_fr(reference: str, hypothesis: str) -> float:
+    return flesch_delta(reference, hypothesis, lang="fr")
+
+
+@register_metric(
+    name="flesch_delta_en",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Flesch reading ease delta (Flesch 1948, EN) between OCR and GT. "
+        "Positive = OCR easier to read than GT (LLM smoothing signal). "
+        "No alignment required."
+    ),
+    higher_is_better=False,
+    tags={"text", "readability", "over_normalization"},
+)
+def _registered_flesch_delta_en(reference: str, hypothesis: str) -> float:
+    return flesch_delta(reference, hypothesis, lang="en")
+
+
+__all__ = [
+    "flesch_score",
+    "flesch_delta",
+    "count_words",
+    "count_sentences",
+    "count_syllables",
+    "count_syllables_word",
+]

picarones/evaluation/metrics/readability_hooks.py

@@ -0,0 +1,114 @@
+"""Câblage runner du delta Flesch (Sprint 87 — A.II.2).
+
+Sprint 87 — A.II.2 (vue HTML + câblage runner du delta Flesch
+livré par le Sprint 52).
+
+Pourquoi ce module
+------------------
+Le ``flesch_delta`` mesure la différence de lisibilité entre la
+GT et la sortie OCR.  Un score positif signale une *over-
+normalisation* typique des LLM/VLM qui modernisent un texte
+ancien (le Flesch monte parce que les mots sont plus simples) ;
+un score négatif signale une dégradation OCR brutale.
+
+Cette métrique est calculée **automatiquement** par le runner
+sur chaque document, agrégée par moteur, et présentée dans le
+rapport.
+
+Adaptive masking
+----------------
+On ne calcule que si la GT contient ≥ 5 mots — en dessous, le
+Flesch est trop instable pour être informatif.
+
+Langue
+------
+Lecture depuis ``corpus.metadata.get("language", "fr")``.  Pour
+les corpus mixtes, l'utilisateur peut passer une langue
+explicite à l'orchestrateur.
+"""
+
+from __future__ import annotations
+
+import logging
+import statistics
+from typing import Iterable, Optional
+
+from picarones.evaluation.metrics.readability import (
+    Language,
+    count_words,
+    flesch_delta,
+    flesch_score,
+)
+
+logger = logging.getLogger(__name__)
+
+
+_MIN_WORDS_FOR_FLESCH = 5
+
+
+def compute_readability_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    lang: Language = "fr",
+) -> Optional[dict]:
+    """Calcule le delta Flesch d'un document avec adaptive masking.
+
+    Retourne ``None`` si la GT contient moins de
+    ``_MIN_WORDS_FOR_FLESCH`` mots.
+    """
+    ref = reference or ""
+    n_ref_words = count_words(ref)
+    if n_ref_words < _MIN_WORDS_FOR_FLESCH:
+        return None
+    hyp = hypothesis or ""
+    flesch_ref = flesch_score(ref, lang=lang)
+    flesch_hyp = flesch_score(hyp, lang=lang) if hyp else None
+    delta = (
+        flesch_delta(ref, hyp, lang=lang) if hyp else None
+    )
+    return {
+        "lang": lang,
+        "flesch_reference": flesch_ref,
+        "flesch_hypothesis": flesch_hyp,
+        "flesch_delta": delta,
+        "n_words_reference": n_ref_words,
+    }
+
+
+def aggregate_readability_metrics(
+    per_doc: Iterable[Optional[dict]],
+) -> Optional[dict]:
+    """Agrège : moyenne/médiane des deltas + part de docs
+    « over-normalisés » (delta > +5 points).
+    """
+    docs = [d for d in per_doc if d]
+    if not docs:
+        return None
+    deltas = [
+        float(d["flesch_delta"]) for d in docs
+        if isinstance(d.get("flesch_delta"), (int, float))
+    ]
+    if not deltas:
+        return None
+    over_norm = sum(1 for d in deltas if d > 5.0)
+    under_norm = sum(1 for d in deltas if d < -5.0)
+    lang = docs[0].get("lang") or "fr"
+    return {
+        "lang": lang,
+        "n_docs": len(docs),
+        "n_docs_with_delta": len(deltas),
+        "delta_mean": statistics.fmean(deltas),
+        "delta_median": statistics.median(deltas),
+        "delta_min": min(deltas),
+        "delta_max": max(deltas),
+        "n_over_normalized": over_norm,
+        "n_under_normalized": under_norm,
+        "over_normalized_rate": over_norm / len(deltas),
+    }
+
+
+__all__ = [
+    "compute_readability_metrics",
+    "aggregate_readability_metrics",
+]

picarones/evaluation/metrics/reading_order.py

@@ -0,0 +1,196 @@
+"""Reading order F1 (ICDAR 2015, Antonacopoulos) — Sprint 53.
+
+Sprint 53 — A.II.2.1 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Sur un manuscrit glosé, un journal multi-colonnes ou un registre
+paroissial complexe, le **classement des moteurs en CER** peut être
+trompeur : un moteur peut avoir un excellent CER caractère et un
+**ordre de lecture catastrophique**.  Le résultat est inutilisable
+pour la recherche plein texte (Elastic, Solr) ou pour reconstituer
+une narration linéaire.
+
+La métrique standard est définie par Antonacopoulos et al. dans
+ICDAR 2015 — F1 sur les **paires d'ordre relatif** entre régions
+ALTO/PAGE.  Pour chaque paire ``(a, b)`` telle que ``a`` précède
+``b`` dans la GT :
+
+- **TP** si ``a`` précède aussi ``b`` dans l'hypothèse,
+- **FN** si la paire est manquante (régions absentes ou ordre
+  inversé) côté hypothèse,
+- **FP** si une paire ``(a, b)`` apparaît dans l'hypothèse alors que
+  la GT n'a pas cet ordre (régions hallucinées ou inversion).
+
+Le F1 est la moyenne harmonique des deux.
+
+Stratégie de découpage
+----------------------
+Cohérent avec NER (Sprint 38), calibration (Sprint 39), Flesch
+(Sprint 52) : couche de calcul pure d'abord.  L'utilisateur fournit
+deux listes ordonnées d'IDs de régions (typiquement extraites de
+ALTO/PAGE par un parser amont).  Le câblage runner et la vue HTML
+suivent dans des sprints dédiés.
+
+Compatible directement avec ``ReadingOrderGT`` du Sprint 32 :
+``ReadingOrderGT.region_order`` est exactement le format attendu.
+
+Convention sur les régions
+--------------------------
+- Les IDs sont des chaînes (``"r_1"``, ``"region_main"``, etc.).
+- Les **doublons** sont ignorés au calcul des paires ordonnées
+  (chaque ID compte une fois par séquence).
+- Une région présente dans la GT mais absente de l'hypothèse
+  contribue aux paires FN.
+- Une région présente dans l'hypothèse mais absente de la GT
+  contribue aux paires FP.
+- Si une séquence a < 2 régions distinctes, aucune paire n'est
+  émise — le F1 retourne ``0.0`` ou ``1.0`` selon que les deux
+  séquences soient identiques.
+"""
+
+from __future__ import annotations
+
+import logging
+from itertools import combinations
+from typing import Iterable
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _ordered_pairs(sequence: list[str]) -> set[tuple[str, str]]:
+    """Retourne l'ensemble des paires ``(a, b)`` telles que ``a``
+    précède strictement ``b`` dans ``sequence``.
+
+    Doublons : chaque ID est traité une seule fois (première occurrence
+    dans la séquence).  Cohérent avec ICDAR 2015 où les régions ont
+    des IDs uniques.
+    """
+    seen: list[str] = []
+    seen_set: set[str] = set()
+    for r in sequence:
+        if r not in seen_set:
+            seen.append(r)
+            seen_set.add(r)
+    return set(combinations(seen, 2))
+
+
+def _normalize_input(value: Iterable[str] | None) -> list[str]:
+    """Coerce une entrée en list[str], en filtrant les valeurs vides."""
+    if value is None:
+        return []
+    return [str(v) for v in value if v is not None and str(v).strip()]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Métrique principale
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_reading_order_metrics(
+    reference_order: Iterable[str] | None,
+    hypothesis_order: Iterable[str] | None,
+) -> dict:
+    """Calcule precision / recall / F1 sur l'ordre relatif des régions.
+
+    Parameters
+    ----------
+    reference_order:
+        Séquence ordonnée d'IDs de régions issue de la GT (typiquement
+        ``ReadingOrderGT.region_order`` du Sprint 32).
+    hypothesis_order:
+        Séquence ordonnée d'IDs de régions produite par un moteur
+        OCR/HTR ou un reconstructeur ALTO.
+
+    Returns
+    -------
+    dict
+        ``{"precision", "recall", "f1", "true_positives",
+        "false_positives", "false_negatives", "n_ref_pairs",
+        "n_hyp_pairs", "common_regions", "ref_only_regions",
+        "hyp_only_regions"}``.
+
+    Comportements aux bornes
+    ------------------------
+    - Deux séquences identiques (mêmes régions, même ordre) → F1 = 1.0.
+    - Ordre strictement inversé → F1 = 0.0 (toutes les paires
+      relatives sont fausses).
+    - Une séquence vide vs une séquence non vide → F1 = 0.0.
+    - Deux séquences vides → F1 = 0.0 et tous les compteurs à 0
+      (convention : on ne récompense pas l'absence).
+    """
+    ref = _normalize_input(reference_order)
+    hyp = _normalize_input(hypothesis_order)
+
+    ref_pairs = _ordered_pairs(ref)
+    hyp_pairs = _ordered_pairs(hyp)
+
+    tp = len(ref_pairs & hyp_pairs)
+    fn = len(ref_pairs - hyp_pairs)
+    fp = len(hyp_pairs - ref_pairs)
+
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+    f1 = (
+        2 * precision * recall / (precision + recall)
+        if (precision + recall) > 0
+        else 0.0
+    )
+
+    ref_set = set(ref)
+    hyp_set = set(hyp)
+    return {
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "true_positives": tp,
+        "false_positives": fp,
+        "false_negatives": fn,
+        "n_ref_pairs": len(ref_pairs),
+        "n_hyp_pairs": len(hyp_pairs),
+        "common_regions": sorted(ref_set & hyp_set),
+        "ref_only_regions": sorted(ref_set - hyp_set),
+        "hyp_only_regions": sorted(hyp_set - ref_set),
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="reading_order_f1",
+    input_types=(ArtifactType.READING_ORDER, ArtifactType.READING_ORDER),
+    description=(
+        "F1 sur l'ordre relatif des régions ALTO/PAGE (ICDAR 2015, "
+        "Antonacopoulos). Pour chaque paire (a,b) où a précède b dans "
+        "la GT, vérifie que a précède aussi b dans l'hypothèse."
+    ),
+    higher_is_better=True,
+    tags={"structure", "icdar", "alto", "page"},
+)
+def reading_order_f1(
+    reference: Iterable[str] | None,
+    hypothesis: Iterable[str] | None,
+) -> float:
+    """Raccourci : retourne uniquement le F1 global.
+
+    Pour les détails par paire (TP/FP/FN, régions communes, etc.),
+    appeler ``compute_reading_order_metrics`` directement.
+    """
+    return compute_reading_order_metrics(reference, hypothesis)["f1"]
+
+
+__all__ = [
+    "compute_reading_order_metrics",
+    "reading_order_f1",
+]

picarones/evaluation/metrics/searchability.py

@@ -0,0 +1,225 @@
+"""Recherchabilité fuzzy — Sprint 84 (A.II.5).
+
+Sprint 84 — A.II.5 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Le CER mesure les erreurs caractère par caractère.  Mais pour
+un usage *recherche plein-texte* (ce que font Elastic, Solr en
+mode fuzzy, ou la recherche full-text de Gallica), la question
+réelle est :
+
+    *« Combien de mots de ma GT sont retrouvables dans la
+    sortie OCR, à orthographe approchée près ? »*
+
+Un CER de 8 % peut donner 95 % de findability si les erreurs
+sont concentrées sur des caractères non-significatifs ou sur
+quelques mots aberrants ; à l'inverse, 4 % de CER mais
+distribué sur tous les noms propres rend le corpus inutilisable
+pour l'indexation prosopographique.
+
+Méthode
+-------
+Pour chaque token GT, on regarde s'il existe au moins un token
+hypothèse à distance de Levenshtein ≤ ``max_distance`` (défaut
+2, valeur Elastic ``fuzziness: AUTO`` standard pour mots ≥ 5
+caractères).  Le **rappel** est la proportion de tokens GT
+ainsi retrouvés.
+
+Multiplicité
+------------
+Si la GT contient *« le »* deux fois et l'hypothèse une fois,
+seul un token GT est compté comme retrouvé (alignement
+multi-set, comme ``rare_token_recall`` Sprint 71).
+
+Sortie
+------
+``compute_searchability(reference, hypothesis)`` retourne
+``{n_gt_tokens, n_searchable, recall, missed_tokens}``.
+
+Limites documentées
+-------------------
+- Tokenisation par split sur whitespace (cohérent avec le reste
+  du codebase).  Pas de stemming ni de lemmatisation.
+- Levenshtein non pondéré — substitution = insertion = suppression
+  = 1.  Pour un poids différent (par ex. faute classique
+  diacritique = 0,5), passer une fonction custom.
+- Pas de sémantique : *« roi »* ≠ *« souverain »*.  Pour la
+  similarité sémantique, voir des modules futurs (BERTScore).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Tokenisation et distance d'édition
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _split_words(text: Optional[str]) -> list[str]:
+    """Tokenisation par whitespace — cohérent avec
+    ``lexical_modernization.py``, ``rare_tokens.py``, etc."""
+    if not text:
+        return []
+    return text.split()
+
+
+def levenshtein_distance(a: str, b: str) -> int:
+    """Distance de Levenshtein (substitution=insertion=suppression=1).
+
+    Implémentation DP O(|a|·|b|) en mémoire O(min(|a|,|b|)).
+    """
+    if a == b:
+        return 0
+    if len(a) < len(b):
+        a, b = b, a
+    # |a| ≥ |b|
+    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]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul principal
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_searchability(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    max_distance: int = 2,
+    case_sensitive: bool = False,
+) -> dict:
+    """Recherchabilité fuzzy de ``reference`` dans ``hypothesis``.
+
+    Parameters
+    ----------
+    reference, hypothesis:
+        Transcriptions GT et OCR.
+    max_distance:
+        Seuil de distance de Levenshtein (≤ pour considérer un
+        token comme retrouvé).  Défaut 2 — convention
+        ``fuzziness: AUTO`` d'Elastic pour mots ≥ 5 caractères.
+    case_sensitive:
+        Si False (défaut), casse insensible côté match — la
+        sortie ``missed_tokens`` reste avec la casse GT
+        originale.
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_gt_tokens": int,
+            "n_searchable": int,
+            "recall": float | None,    # None si n_gt_tokens == 0
+            "missed_tokens": list[str],
+            "max_distance": int,
+        }``
+    """
+    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 {
+            "n_gt_tokens": 0,
+            "n_searchable": 0,
+            "recall": None,
+            "missed_tokens": [],
+            "max_distance": max_distance,
+        }
+    # Multi-set : un token hypothèse ne peut servir qu'une fois.
+    # Tri par longueur croissante pour matcher d'abord les
+    # tokens GT les plus courts (où ε-fautes sont plus rares).
+    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_searchable = 0
+    missed: list[str] = []
+    for gi, gt_match in enumerate(gt_for_match):
+        # Court-circuit si match exact disponible
+        best_idx = -1
+        best_dist = max_distance + 1
+        for hi, used in enumerate(hyp_used):
+            if used:
+                continue
+            hyp_match = hyp_for_match[hi]
+            # Court-circuit longueur (Levenshtein ≥ |Δlen|)
+            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  # match exact, inutile de chercher mieux
+        if best_idx >= 0 and best_dist <= max_distance:
+            hyp_used[best_idx] = True
+            n_searchable += 1
+        else:
+            missed.append(gt_tokens[gi])
+    recall = n_searchable / n_gt
+    return {
+        "n_gt_tokens": n_gt,
+        "n_searchable": n_searchable,
+        "recall": recall,
+        "missed_tokens": missed,
+        "max_distance": max_distance,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="searchability_recall",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Recherchabilité fuzzy : proportion de tokens GT retrouvés "
+        "dans l'OCR à distance de Levenshtein ≤ 2. Proxy direct de "
+        "la qualité pour la recherche plein-texte (Elastic, Solr)."
+    ),
+)
+def searchability_recall_metric(reference: str, hypothesis: str) -> float:
+    """Variante scalaire pour le registre typé : retourne le
+    rappel en [0, 1], ou ``0.0`` si la GT est vide (convention
+    cohérente avec rare_token_recall Sprint 71).
+    """
+    result = compute_searchability(reference, hypothesis)
+    recall = result.get("recall")
+    return 0.0 if recall is None else recall
+
+
+__all__ = [
+    "levenshtein_distance",
+    "compute_searchability",
+    "searchability_recall_metric",
+]

picarones/evaluation/metrics/searchability_hooks.py

@@ -0,0 +1,81 @@
+"""Câblage runner de la recherchabilité (Sprint 86).
+
+Sprint 86 — A.II.5a (vue HTML + câblage runner).
+
+Le module ``picarones/core/searchability.py`` (Sprint 84) a livré
+la couche de calcul.  Ce helper prépare la donnée pour le runner
+historique et l'agrégation par moteur.
+
+Adaptive masking
+----------------
+Comme pour les modules philologiques (Sprint 61), on ne calcule
+le rappel que si la GT contient au moins un token —  pas de
+calcul vide qui produirait du bruit dans le rapport.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Optional
+
+from picarones.evaluation.metrics.searchability import (
+    _split_words,
+    compute_searchability,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def compute_searchability_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    max_distance: int = 2,
+) -> Optional[dict]:
+    """Recherchabilité d'un document (adaptive).
+
+    Retourne ``None`` si la GT est vide ou ne contient aucun
+    token — ce qui déclenche l'adaptive masking côté HTML.
+    """
+    if not reference or not _split_words(reference):
+        return None
+    return compute_searchability(
+        reference, hypothesis or "", max_distance=max_distance,
+    )
+
+
+def aggregate_searchability_metrics(
+    per_doc: Iterable[Optional[dict]],
+) -> Optional[dict]:
+    """Agrège les métriques par-doc en un score corpus-wide.
+
+    Convention : on somme les ``n_gt_tokens`` et ``n_searchable``
+    et on recalcule un rappel **micro** (cohérent avec ECE/MCE
+    Sprint 39 et NER Sprint 38).
+    """
+    docs = [d for d in per_doc if d]
+    if not docs:
+        return None
+    n_gt = sum(int(d.get("n_gt_tokens") or 0) for d in docs)
+    n_search = sum(int(d.get("n_searchable") or 0) for d in docs)
+    if n_gt == 0:
+        return None
+    # On garde l'union des missed_tokens (capped pour ne pas
+    # exploser le JSON sur de gros corpus)
+    missed: list[str] = []
+    for d in docs:
+        missed.extend(d.get("missed_tokens") or [])
+    return {
+        "n_docs": len(docs),
+        "n_gt_tokens": n_gt,
+        "n_searchable": n_search,
+        "recall": n_search / n_gt,
+        "missed_tokens_sample": missed[:50],
+        "max_distance": docs[0].get("max_distance", 2),
+    }
+
+
+__all__ = [
+    "compute_searchability_metrics",
+    "aggregate_searchability_metrics",
+]

picarones/evaluation/metrics/unicode_blocks.py

@@ -0,0 +1,233 @@
+"""Précision par bloc Unicode — Sprint 55.
+
+Sprint 55 — A.II.3.1 du plan d'évolution 2026 (métriques philologiques).
+
+Pourquoi ce module
+------------------
+Pour un éditeur d'imprimés anciens ou un médiéviste, la question
+n'est pas seulement *« quel CER global ? »* mais *« quels caractères
+historiques ce moteur restitue-t-il fidèlement ? »*.  Une phrase de
+synthèse actionnable en un coup d'œil :
+
+> *« GPT-4o restitue 95 % du Latin de Base mais seulement 12 % des
+> formes de présentation latine (fi, fl, ſ…). »*
+
+Ce module agrège la précision par **bloc Unicode standard** (Latin de
+Base, Latin Étendu A/B, Diacritiques combinants, Présentation latine,
+etc.).  Le résultat permet directement de choisir un moteur selon le
+type de glyphes attendus dans le corpus.
+
+Stratégie de découpage
+----------------------
+Cohérente avec NER (Sprint 38), Flesch (Sprint 52), Reading order F1
+(Sprint 53), Layout F1 (Sprint 54) : couche de calcul pure d'abord.
+Le câblage runner et la vue HTML suivent dans des sprints dédiés.
+
+Convention d'alignement
+-----------------------
+Alignement caractère par caractère via ``difflib.SequenceMatcher`` :
+
+- chaque caractère de la GT est classé dans son bloc Unicode,
+- pour chaque position GT couverte par un opcode ``equal`` →
+  +1 dans ``correct[bloc]``,
+- pour chaque position GT non couverte (replace, delete) → +0,
+- les insertions côté hypothèse (caractères absents de la GT) ne
+  contribuent à aucun bloc — elles sont visibles uniquement via le
+  CER global.
+
+Précision par bloc = ``correct[bloc] / total[bloc]``.
+
+Liste des blocs reconnus
+------------------------
+Centrée sur les glyphes courants des corpus patrimoniaux européens.
+Tout caractère hors de cette table est classé dans ``"Other"``
+(garantit une couverture exhaustive : ``sum(total[bloc]) ==
+len(GT)``).
+"""
+
+from __future__ import annotations
+
+import logging
+from difflib import SequenceMatcher
+from typing import Optional
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Table des blocs Unicode reconnus
+# ──────────────────────────────────────────────────────────────────────────
+
+# Triplets (nom, code_point_min, code_point_max) — bornes inclusives.
+# Centré sur les blocs pertinents pour les corpus patrimoniaux
+# européens (manuscrits médiévaux, imprimés anciens, archives).
+# Source : https://www.unicode.org/charts/
+_UNICODE_BLOCKS: tuple[tuple[str, int, int], ...] = (
+    ("Basic Latin",                              0x0000, 0x007F),
+    ("Latin-1 Supplement",                       0x0080, 0x00FF),
+    ("Latin Extended-A",                         0x0100, 0x017F),
+    ("Latin Extended-B",                         0x0180, 0x024F),
+    ("IPA Extensions",                           0x0250, 0x02AF),
+    ("Spacing Modifier Letters",                 0x02B0, 0x02FF),
+    ("Combining Diacritical Marks",              0x0300, 0x036F),
+    ("Greek and Coptic",                         0x0370, 0x03FF),
+    ("Cyrillic",                                 0x0400, 0x04FF),
+    ("Hebrew",                                   0x0590, 0x05FF),
+    ("Arabic",                                   0x0600, 0x06FF),
+    ("General Punctuation",                      0x2000, 0x206F),
+    ("Superscripts and Subscripts",              0x2070, 0x209F),
+    ("Currency Symbols",                         0x20A0, 0x20CF),
+    ("Combining Diacritical Marks Supplement",   0x1DC0, 0x1DFF),
+    ("Latin Extended Additional",                0x1E00, 0x1EFF),
+    ("Latin Extended-C",                         0x2C60, 0x2C7F),
+    ("Latin Extended-D",                         0xA720, 0xA7FF),  # médiéval
+    ("Latin Extended-E",                         0xAB30, 0xAB6F),
+    ("Alphabetic Presentation Forms",            0xFB00, 0xFB4F),  # fi, fl, ff…
+    ("Mathematical Alphanumeric Symbols",        0x1D400, 0x1D7FF),
+    ("Medieval Unicode Font Initiative (MUFI)",  0xE000, 0xF8FF),  # PUA
+)
+
+
+def get_block(char: str) -> str:
+    """Retourne le nom du bloc Unicode contenant ``char``.
+
+    Pour un caractère hors des blocs listés (ex. CJK, emoji, etc.),
+    retourne ``"Other"``.  Pour une chaîne multi-caractères, on
+    considère uniquement le premier code-point.
+    """
+    if not char:
+        return "Other"
+    cp = ord(char[0])
+    for name, lo, hi in _UNICODE_BLOCKS:
+        if lo <= cp <= hi:
+            return name
+    return "Other"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul d'accuracy par bloc
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_unicode_block_accuracy(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> dict:
+    """Calcule la précision (recall caractère) par bloc Unicode.
+
+    Parameters
+    ----------
+    reference:
+        Texte GT.  Chaque caractère est classé dans son bloc Unicode.
+    hypothesis:
+        Texte produit par le moteur OCR.
+
+    Returns
+    -------
+    dict
+        ``{
+            "per_block": {
+                bloc_name: {
+                    "correct": int,    # caractères GT correctement restitués
+                    "total":   int,    # caractères GT du bloc
+                    "accuracy": float, # correct / total ∈ [0, 1]
+                },
+                ...
+            },
+            "global_accuracy": float,    # somme(correct) / somme(total)
+            "n_chars_reference": int,
+        }``
+
+    Cas dégénérés
+    -------------
+    - GT vide → ``per_block`` vide, ``global_accuracy = 0.0``,
+      ``n_chars_reference = 0``.
+    - hypothèse vide + GT non-vide → tous les blocs à
+      ``accuracy = 0``.
+    - GT et hyp identiques → tous les blocs à ``accuracy = 1``.
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+    n_ref = len(ref)
+
+    if n_ref == 0:
+        return {
+            "per_block": {},
+            "global_accuracy": 0.0,
+            "n_chars_reference": 0,
+        }
+
+    # 1. Compter le total par bloc
+    total: dict[str, int] = {}
+    for ch in ref:
+        b = get_block(ch)
+        total[b] = total.get(b, 0) + 1
+
+    # 2. Aligner par opcodes de SequenceMatcher
+    #    Pour chaque opcode ``equal``, les positions ``i1..i2-1`` du GT
+    #    sont correctement restituées → +1 par caractère dans son bloc.
+    correct: dict[str, int] = {b: 0 for b in total}
+    matcher = SequenceMatcher(a=ref, b=hyp, autojunk=False)
+    for op, i1, i2, _j1, _j2 in matcher.get_opcodes():
+        if op != "equal":
+            continue
+        for i in range(i1, i2):
+            b = get_block(ref[i])
+            correct[b] = correct.get(b, 0) + 1
+
+    per_block: dict[str, dict] = {}
+    for b in sorted(total):
+        n = total[b]
+        c = correct.get(b, 0)
+        per_block[b] = {
+            "correct": c,
+            "total": n,
+            "accuracy": c / n if n > 0 else 0.0,
+        }
+
+    n_correct_total = sum(d["correct"] for d in per_block.values())
+    return {
+        "per_block": per_block,
+        "global_accuracy": n_correct_total / n_ref,
+        "n_chars_reference": n_ref,
+    }
+
+
+def unicode_block_global_accuracy(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> float:
+    """Raccourci : retourne ``global_accuracy`` (fraction de
+    caractères GT correctement restitués)."""
+    return compute_unicode_block_accuracy(reference, hypothesis)["global_accuracy"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="unicode_block_global_accuracy",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Fraction de caractères GT correctement restitués par "
+        "l'OCR (alignement caractère par caractère via difflib). "
+        "Pour le détail par bloc Unicode (Latin de Base, Présentation "
+        "latine, etc.), utiliser compute_unicode_block_accuracy."
+    ),
+    higher_is_better=True,
+    tags={"text", "unicode", "philology"},
+)
+def _registered_global_accuracy(reference: str, hypothesis: str) -> float:
+    return unicode_block_global_accuracy(reference, hypothesis)
+
+
+__all__ = [
+    "get_block",
+    "compute_unicode_block_accuracy",
+    "unicode_block_global_accuracy",
+]

picarones/measurements/alto_metrics.py

@@ -1,243 +1,21 @@
-"""Métriques typées ``(ALTO, ALTO)`` — Chantier 1.
+"""Shim de compatibilité — métrique relocalisée.
 
-Pourquoi ce module
-------------------
-Le registre typé du Sprint 34 prévoit une signature ``(input_type,
-output_type)`` pour chaque métrique.  ``builtin_metrics.py`` enregistre
-les quatre métriques scalaires sur ``(TEXT, TEXT)`` et un stub sur
-``(TEXT, ALTO)``.  Aucune métrique n'était enregistrée sur la jonction
-``(ALTO, ALTO)`` — pourtant indispensable dès qu'une pipeline produit
-un ALTO et qu'une GT ALTO est disponible (Sprint 32).
-
-Ce module comble cette lacune.  Il expose un helper
-:func:`extract_text_from_alto` qui parse l'ALTO XML et reconstruit le
-texte plat dans l'ordre ``Page → TextBlock → TextLine → String``, et
-enregistre quatre métriques natives (``alto_text_cer``,
-``alto_text_wer``, ``alto_text_mer``, ``alto_text_wil``) qui appliquent
-les opérateurs jiwer historiques sur le texte extrait des deux côtés.
-
-L'approche est strictement additive vis-à-vis de
-:mod:`picarones.measurements.metrics` : ce module ne touche pas le chemin de
-calcul historique (``compute_metrics``), il enrichit uniquement le
-registre typé pour les pipelines composées.
-
-Robustesse
-----------
-- L'ALTO peut être passé sous forme :
-    * ``str`` (XML brut),
-    * :class:`picarones.evaluation.corpus.AltoGT` (porteur d'un ``xml_content``),
-    * tout objet exposant un attribut ``xml_content`` typé.
-- Le parser tolère les ALTO sans namespace, ALTO 2.x, ALTO 3.x, ALTO
-  4.x — il cherche les balises locales par leur nom court (``Page``,
-  ``TextLine``, ``String``).
-- Un ALTO illisible ou vide → texte extrait ``""``.  Le calcul de CER
-  reste possible (la couche jiwer sait gérer une référence non vide
-  vs hypothèse vide).
-- Aucune dépendance externe : utilise ``xml.etree.ElementTree`` du
-  stdlib.
-
-Cas typique d'usage
--------------------
-Un VLM produit un ALTO via un reconstructeur (par exemple
-:class:`picarones.modules.TextToAltoMonoRegion`).  La GT
-:class:`picarones.evaluation.corpus.AltoGT` du document est confrontée à la
-sortie via :func:`picarones.evaluation.metric_registry.compute_at_junction`,
-qui sélectionne automatiquement les métriques ``(ALTO, ALTO)``
-ci-dessous.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.alto_metrics`` vers
+``picarones.evaluation.metrics.alto_metrics`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-import re
-from typing import Any
-
-from picarones.formats._xml_utils import safe_parse_xml
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-try:
-    import jiwer
-    _JIWER_AVAILABLE = True
-except ImportError:
-    _JIWER_AVAILABLE = False
-
-
-_LOCAL_NAME_RE = re.compile(r"\{[^}]*\}")
-
-
-def _local(tag: str) -> str:
-    """Retire le préfixe de namespace XML pour ne garder que le nom local.
-
-    ElementTree expose les tags sous la forme ``{namespace}LocalName``
-    quand un namespace est déclaré.  On normalise pour pouvoir
-    matcher uniformément les ALTO avec ou sans namespace.
-    """
-    return _LOCAL_NAME_RE.sub("", tag)
-
-
-def _coerce_alto_to_str(payload: Any) -> str:
-    """Accepte plusieurs formes d'ALTO et retourne le XML brut."""
-    if payload is None:
-        return ""
-    if isinstance(payload, str):
-        return payload
-    xml_content = getattr(payload, "xml_content", None)
-    if isinstance(xml_content, str):
-        return xml_content
-    # Dernier recours — l'utilisateur a passé un objet avec str()
-    # raisonnable (tests, mocks).  On ne lève pas, on retourne ""
-    # pour ne pas faire échouer une jonction sur un input bizarre.
-    return ""
-
-
-def extract_text_from_alto(payload: Any) -> str:
-    """Extrait le texte plat d'un ALTO XML.
-
-    L'ordre suivi reproduit la lecture naturelle ALTO :
-    ``Page → PrintSpace → TextBlock → TextLine → String``, avec
-    insertion d'un espace entre les ``String`` d'une même ligne et
-    d'un saut de ligne entre lignes.  Les ``SP`` (espaces explicites)
-    sont implicites — on n'en a pas besoin si on met un espace entre
-    chaque ``String``.
+import warnings
 
-    Parameters
-    ----------
-    payload:
-        ALTO sous forme ``str``, :class:`AltoGT`, ou tout objet
-        exposant ``xml_content``.
-
-    Returns
-    -------
-    str
-        Texte reconstruit, ``""`` si l'ALTO est invalide ou vide.
-
-    Notes
-    -----
-    Cette fonction est délibérément tolérante : un ALTO partiellement
-    valide produit le texte qu'il a pu extraire avant l'erreur de
-    parsing.  Cela évite de faire échouer une jonction parce que la
-    GT a un défaut mineur (encodage, déclaration manquante).
-    """
-    xml = _coerce_alto_to_str(payload).strip()
-    if not xml:
-        return ""
-    # ``safe_parse_xml`` neutralise XXE / Billion Laughs / DTD
-    # retrieval — l'ALTO peut venir d'un module ``BaseModule`` tiers
-    # qui n'a pas de garantie de provenance.
-    root = safe_parse_xml(xml.encode("utf-8") if isinstance(xml, str) else xml)
-    if root is None:
-        logger.warning(
-            "[alto_metrics] ALTO non parsable (XML invalide ou défense XXE "
-            "déclenchée) — texte extrait vide",
-        )
-        return ""
-
-    lines_text: list[str] = []
-    # Itère sur tous les TextLine, peu importe leur profondeur.
-    for line in root.iter():
-        if _local(line.tag) != "TextLine":
-            continue
-        words: list[str] = []
-        for s in line.iter():
-            if _local(s.tag) != "String":
-                continue
-            content = s.attrib.get("CONTENT", "")
-            if content:
-                words.append(content)
-        lines_text.append(" ".join(words))
-    return "\n".join(lines_text).strip()
-
-
-def _safe_jiwer_call(fn, reference: str, hypothesis: str) -> float:
-    if not _JIWER_AVAILABLE:
-        raise RuntimeError(
-            "jiwer n'est pas installé — installer avec `pip install jiwer`"
-        )
-    if not reference:
-        return 0.0 if not hypothesis else 1.0
-    if not hypothesis:
-        return 1.0
-    return fn(reference, hypothesis)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Métriques (ALTO, ALTO) — opèrent sur le texte extrait de chaque ALTO
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="alto_text_cer",
-    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
-    description=(
-        "CER calculé sur le texte plat extrait des ALTO (référence vs "
-        "hypothèse).  Permet de mesurer la qualité d'un reconstructeur "
-        "ALTO sur l'axe textuel, indépendamment du layout."
-    ),
-    higher_is_better=False,
-    tags={"alto", "text", "edit_distance"},
+warnings.warn(
+    "picarones.measurements.alto_metrics est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.alto_metrics à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-def alto_text_cer(reference_alto: Any, hypothesis_alto: Any) -> float:
-    return _safe_jiwer_call(
-        jiwer.cer,
-        extract_text_from_alto(reference_alto),
-        extract_text_from_alto(hypothesis_alto),
-    )
-
-
-@register_metric(
-    name="alto_text_wer",
-    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
-    description="WER calculé sur le texte plat extrait des ALTO.",
-    higher_is_better=False,
-    tags={"alto", "text", "edit_distance"},
-)
-def alto_text_wer(reference_alto: Any, hypothesis_alto: Any) -> float:
-    return _safe_jiwer_call(
-        jiwer.wer,
-        extract_text_from_alto(reference_alto),
-        extract_text_from_alto(hypothesis_alto),
-    )
-
-
-@register_metric(
-    name="alto_text_mer",
-    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
-    description="MER calculé sur le texte plat extrait des ALTO.",
-    higher_is_better=False,
-    tags={"alto", "text"},
-)
-def alto_text_mer(reference_alto: Any, hypothesis_alto: Any) -> float:
-    return _safe_jiwer_call(
-        jiwer.mer,
-        extract_text_from_alto(reference_alto),
-        extract_text_from_alto(hypothesis_alto),
-    )
-
-
-@register_metric(
-    name="alto_text_wil",
-    input_types=(ArtifactType.ALTO, ArtifactType.ALTO),
-    description="WIL calculé sur le texte plat extrait des ALTO.",
-    higher_is_better=False,
-    tags={"alto", "text"},
-)
-def alto_text_wil(reference_alto: Any, hypothesis_alto: Any) -> float:
-    return _safe_jiwer_call(
-        jiwer.wil,
-        extract_text_from_alto(reference_alto),
-        extract_text_from_alto(hypothesis_alto),
-    )
-
 
-__all__ = [
-    "extract_text_from_alto",
-    "alto_text_cer",
-    "alto_text_wer",
-    "alto_text_mer",
-    "alto_text_wil",
-]
+from picarones.evaluation.metrics.alto_metrics import *  # noqa: F401, F403, E402

picarones/measurements/equivalence_profile.py

@@ -1,199 +1,21 @@
-"""Équivalences diplomatiques granulaires — Sprint 78 (A.I.5).
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 78 — A.I.5 du plan d'évolution 2026.
-
-Pourquoi ce module
-------------------
-Aujourd'hui les profils de ``picarones/core/normalization.py``
-(``medieval_french``, ``early_modern_french``, etc.) appliquent un
-**bloc entier** de transformations.  Mais un éditeur peut vouloir
-nuancer : *« je tolère ``ſ → s`` mais pas ``u → v`` »* — par
-exemple parce qu'il édite un imprimé du XVIᵉ où u/v sont
-distinctes mais où le s long doit être normalisé.
-
-Ce module **éclate** chaque profil en règles d'équivalence
-**nommées et indépendantes** que l'utilisateur peut activer ou
-désactiver une par une.  La couche de calcul retourne le CER
-recalculé avec un sous-ensemble personnalisé.
-
-Format
-------
-Chaque règle a :
-
-- ``name`` : identifiant stable utilisé dans les URLs et l'UX
-  (ex. ``"longs_s"``, ``"u_eq_v"``)
-- ``source`` : caractère ou séquence à remplacer
-- ``target`` : caractère ou séquence cible
-- ``description`` : phrase courte FR destinée à l'utilisateur
-- ``profile_tag`` : nom du profil dont elle est issue (utile pour
-  grouper dans l'UX)
-
-Stratégie de découpage
-----------------------
-Couche de calcul d'abord (pattern Sprint 71/75/76).  L'UX panneau
-avancé (cases à cocher + recalcul JS client + URL state) suivra
-dans un sprint dédié — la couche calcul livrée ici est une
-fondation suffisante pour qu'un développeur frontend câble la vue.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.equivalence_profile`` vers
+``picarones.evaluation.metrics.equivalence_profile`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-from dataclasses import dataclass
-from typing import Iterable, Optional
+import warnings
 
-from picarones.evaluation.metrics.normalization import (
-    DIPLOMATIC_EN_EARLY_MODERN,
-    DIPLOMATIC_FR_EARLY_MODERN,
-    DIPLOMATIC_LATIN_MEDIEVAL,
-    DIPLOMATIC_MINIMAL,
+warnings.warn(
+    "picarones.measurements.equivalence_profile est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.equivalence_profile à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class EquivalenceRule:
-    """Une équivalence diplomatique nommée et indépendante."""
-    name: str
-    source: str
-    target: str
-    description: str
-    profile_tag: str
-
-
-# Catalogue : on dérive des profils existants en attribuant un nom
-# stable à chaque transformation.  Les doublons (ex. ``ſ → s``
-# présent dans plusieurs profils) sont fusionnés sous un nom unique
-# (le premier rencontré).
-def _build_catalog() -> dict[str, EquivalenceRule]:
-    catalog: dict[str, EquivalenceRule] = {}
-
-    # Noms canoniques pour les transformations courantes
-    canonical_names: dict[tuple[str, str], tuple[str, str]] = {
-        ("ſ", "s"):  ("longs_s", "s long ſ → s"),
-        ("u", "v"):  ("u_eq_v", "u/v interchangeables (vpon → upon)"),
-        ("i", "j"):  ("i_eq_j", "i/j interchangeables (ioy → joy)"),
-        ("y", "i"):  ("y_eq_i", "y → i (Latin médiéval)"),
-        ("vv", "w"): ("vv_eq_w", "vv → w (anglais moderne)"),
-        ("æ", "ae"): ("ae_ligature", "æ → ae"),
-        ("œ", "oe"): ("oe_ligature", "œ → oe"),
-        ("þ", "th"): ("thorn_th", "þ (thorn) → th"),
-        ("ð", "th"): ("eth_th", "ð (eth) → th"),
-        ("ȝ", "y"):  ("yogh_y", "ȝ (yogh) → y"),
-        ("&", "et"): ("ampersand_et", "& → et (esperluette)"),
-        ("ỹ", "yn"): ("y_tilde_yn", "ỹ → yn"),
-        ("ꝑ", "per"): ("p_per", "ꝑ → per (abréviation Capelli)"),
-        ("ꝓ", "pro"): ("p_pro", "ꝓ → pro (abréviation Capelli)"),
-        ("ꝗ", "que"): ("q_que", "ꝗ → que (q barré)"),
-    }
-
-    sources = [
-        ("medieval_french", DIPLOMATIC_LATIN_MEDIEVAL),
-        ("early_modern_french", DIPLOMATIC_FR_EARLY_MODERN),
-        ("early_modern_english", DIPLOMATIC_EN_EARLY_MODERN),
-        ("minimal", DIPLOMATIC_MINIMAL),
-    ]
-
-    for profile_tag, profile_dict in sources:
-        for source, target in profile_dict.items():
-            key = (source, target)
-            if key in canonical_names:
-                name, desc = canonical_names[key]
-            else:
-                # Fallback : générer un nom à partir des codepoints
-                name = f"{source}_to_{target}".replace(" ", "_")
-                desc = f"{source} → {target}"
-            if name in catalog:
-                # On garde le profile_tag du premier rencontré, mais
-                # on note que la règle est partagée.
-                continue
-            catalog[name] = EquivalenceRule(
-                name=name,
-                source=source,
-                target=target,
-                description=desc,
-                profile_tag=profile_tag,
-            )
-    return catalog
-
-
-BUILTIN_EQUIVALENCES: dict[str, EquivalenceRule] = _build_catalog()
-
-
-def list_equivalences_by_profile(
-    profile_name: Optional[str] = None,
-) -> list[EquivalenceRule]:
-    """Liste les règles d'équivalence disponibles.
-
-    Si ``profile_name`` est fourni, ne retourne que les règles dont
-    ``profile_tag == profile_name`` (ou les règles dérivées de
-    plusieurs profils dont au moins un est ``profile_name``).
-    """
-    if profile_name is None:
-        return list(BUILTIN_EQUIVALENCES.values())
-    return [
-        rule for rule in BUILTIN_EQUIVALENCES.values()
-        if rule.profile_tag == profile_name
-    ]
-
-
-def apply_selected_equivalences(
-    text: Optional[str],
-    selected_names: Iterable[str],
-) -> str:
-    """Applique uniquement les règles dont le nom est dans
-    ``selected_names``.
-
-    L'ordre d'application est l'ordre du catalogue interne — les
-    transformations sont appliquées séquentiellement sur le texte.
-    Les règles inconnues sont silencieusement ignorées (avec
-    warning).
-    """
-    if not text:
-        return text or ""
-    selected_set = set(selected_names)
-    if not selected_set:
-        return text
-    out = text
-    for name, rule in BUILTIN_EQUIVALENCES.items():
-        if name not in selected_set:
-            continue
-        out = out.replace(rule.source, rule.target)
-    # Détection des règles inconnues (pour logger explicite)
-    unknown = selected_set - set(BUILTIN_EQUIVALENCES.keys())
-    if unknown:
-        logger.warning(
-            "[equivalence_profile] règles inconnues ignorées : %s",
-            sorted(unknown),
-        )
-    return out
-
-
-def compute_cer_with_equivalences(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    selected_names: Iterable[str],
-) -> float:
-    """Calcule le CER après application des équivalences sélectionnées
-    sur les **deux** côtés (GT et hypothèse).
-
-    Utilise ``picarones.measurements.metrics.compute_metrics`` et extrait
-    le champ ``cer`` du résultat.
-    """
-    from picarones.measurements.metrics import compute_metrics
-
-    selected_list = list(selected_names)
-    ref = apply_selected_equivalences(reference or "", selected_list)
-    hyp = apply_selected_equivalences(hypothesis or "", selected_list)
-    result = compute_metrics(ref, hyp)
-    return result.cer
-
-
-__all__ = [
-    "EquivalenceRule",
-    "BUILTIN_EQUIVALENCES",
-    "list_equivalences_by_profile",
-    "apply_selected_equivalences",
-    "compute_cer_with_equivalences",
-]
+from picarones.evaluation.metrics.equivalence_profile import *  # noqa: F401, F403, E402

picarones/measurements/ner.py

@@ -1,309 +1,21 @@
-"""Calcul des métriques de précision sur entités nommées (NER).
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 38 — A.II.1.a du plan d'évolution 2026 : couche de calcul pure.
-
-Pourquoi ce module
-------------------
-Pour un médiéviste, un archiviste ou un économiste-historien,
-l'utilité aval d'un OCR ne se mesure pas seulement au CER ; ce qui
-compte c'est de savoir si les **entités nommées** (personnes, lieux,
-dates, organisations) ont survécu à la transcription.  Un CER de 5 %
-qui rate 80 % des noms propres est inutilisable pour l'indexation
-prosopographique.
-
-Stratégie de découpage en sprints
----------------------------------
-Comme pour la divergence taxonomique (Sprints 35-37), on découpe :
-
-- **Sprint 38** (ici) — couche de calcul pure : alignement IoU entre
-  deux listes d'entités, calcul de Precision/Recall/F1 par catégorie
-  et global, détection des hallucinations d'entité.  Aucune dépendance
-  externe (pas de spaCy, pas de Stanza) ; les listes d'entités sont
-  fournies en entrée.  Un test de l'enregistrement dans le registre
-  typé Sprint 34 garantit l'intégration.
-- **Sprint à venir** — backend extracteur (spaCy / Stanza / HIPE) et
-  câblage runner+narratif+HTML.
-
-Format des entités
-------------------
-Compatible avec ``EntitiesGT`` du Sprint 32 — chaque entité est un
-dictionnaire ``{"label": str, "start": int, "end": int, "text": str}``
-où ``start``/``end`` sont des offsets caractère.
-
-Convention d'alignement
------------------------
-Une entité hypothèse "matche" une entité de référence si :
-
-1. les **labels sont identiques** (case-insensitive),
-2. le ratio d'**Intersection-over-Union** (IoU) sur leurs spans
-   caractère est ``≥ iou_threshold`` (défaut : 0,5).
-
-Une entité de référence non matchée → faux négatif (recall pénalisé).
-Une entité hypothèse non matchée → faux positif (précision pénalisée).
-Un faux positif est aussi compté comme **hallucination d'entité**, ce
-qui est utile pour les VLM/LLM qui inventent.
-
-Limites
--------
-- L'alignement bag-of-spans : une entité peut être matchée par au plus
-  une entité de l'autre côté (sinon double-comptage).
-- Les modèles NER (spaCy, etc.) hallucinent eux-mêmes.  La métrique
-  mesure conjointement OCR + NER.  Documenter explicitement.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.ner`` vers
+``picarones.evaluation.metrics.ner`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-from dataclasses import dataclass
-from typing import Iterable
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Modèle de données
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@dataclass(frozen=True)
-class Entity:
-    """Entité nommée alignée sur un texte.
-
-    Attributs
-    ---------
-    label:
-        Catégorie de l'entité (ex. ``"PER"``, ``"LOC"``, ``"DATE"``).
-        La comparaison se fait en *case-insensitive*.
-    start, end:
-        Offsets caractère (inclus, exclu) sur le texte de référence.
-    text:
-        Forme de surface — informative, **non utilisée pour
-        l'alignement** (deux entités peuvent matcher même si leur
-        forme de surface diffère, du moment que leurs spans
-        chevauchent suffisamment).
-    """
-
-    label: str
-    start: int
-    end: int
-    text: str = ""
-
-    def __post_init__(self) -> None:
-        if self.start > self.end:
-            raise ValueError(
-                f"Entity span invalide : start={self.start} > end={self.end}"
-            )
-
-    @property
-    def length(self) -> int:
-        return max(0, self.end - self.start)
-
-
-def _to_entity(obj: Entity | dict) -> Entity:
-    """Coerce un dict (format EntitiesGT) en ``Entity``."""
-    if isinstance(obj, Entity):
-        return obj
-    return Entity(
-        label=str(obj["label"]),
-        start=int(obj["start"]),
-        end=int(obj["end"]),
-        text=str(obj.get("text", "")),
-    )
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Alignement par IoU
-# ────────────────────────────────────────────────────────��─────────────────
-
-
-def _iou(a: Entity, b: Entity) -> float:
-    """Intersection-over-Union sur les spans caractère."""
-    inter_start = max(a.start, b.start)
-    inter_end = min(a.end, b.end)
-    inter = max(0, inter_end - inter_start)
-    union = a.length + b.length - inter
-    if union <= 0:
-        return 0.0
-    return inter / union
+import warnings
 
-
-def _align(
-    references: list[Entity],
-    hypotheses: list[Entity],
-    iou_threshold: float,
-) -> tuple[list[tuple[int, int, float]], set[int], set[int]]:
-    """Aligne deux listes d'entités par IoU décroissant (greedy).
-
-    Returns
-    -------
-    matches:
-        Liste de triplets ``(idx_ref, idx_hyp, iou)`` triés par IoU
-        décroissant — chaque entité n'apparaît qu'une fois.
-    unmatched_refs:
-        Indices des entités GT non matchées (faux négatifs).
-    unmatched_hyps:
-        Indices des entités hypothèse non matchées (faux positifs).
-    """
-    candidates: list[tuple[float, int, int]] = []
-    for i, r in enumerate(references):
-        for j, h in enumerate(hypotheses):
-            if r.label.casefold() != h.label.casefold():
-                continue
-            score = _iou(r, h)
-            if score >= iou_threshold:
-                candidates.append((score, i, j))
-
-    # Tri par IoU décroissant ; à IoU égale, on prend l'ordre des paires
-    # pour garantir un tri stable et déterministe.
-    candidates.sort(key=lambda t: (-t[0], t[1], t[2]))
-
-    matched_refs: set[int] = set()
-    matched_hyps: set[int] = set()
-    matches: list[tuple[int, int, float]] = []
-    for score, i, j in candidates:
-        if i in matched_refs or j in matched_hyps:
-            continue
-        matched_refs.add(i)
-        matched_hyps.add(j)
-        matches.append((i, j, score))
-
-    unmatched_refs = set(range(len(references))) - matched_refs
-    unmatched_hyps = set(range(len(hypotheses))) - matched_hyps
-    return matches, unmatched_refs, unmatched_hyps
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul des métriques
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _prf(tp: int, fp: int, fn: int) -> dict[str, float]:
-    """Précision / rappel / F1 à partir des comptes."""
-    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
-    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
-    f1 = (
-        2 * precision * recall / (precision + recall)
-        if (precision + recall) > 0
-        else 0.0
-    )
-    return {
-        "precision": precision,
-        "recall": recall,
-        "f1": f1,
-        "support": tp + fn,
-    }
-
-
-def compute_ner_metrics(
-    reference_entities: Iterable[Entity | dict],
-    hypothesis_entities: Iterable[Entity | dict],
-    iou_threshold: float = 0.5,
-) -> dict:
-    """Calcule la précision/rappel/F1 sur entités nommées.
-
-    Parameters
-    ----------
-    reference_entities:
-        Liste d'entités GT (format ``Entity`` ou dict de
-        ``EntitiesGT``).
-    hypothesis_entities:
-        Liste d'entités produites par le NER sur la sortie OCR.
-    iou_threshold:
-        Seuil de chevauchement caractère pour qu'un appariement
-        soit valide (défaut : 0,5 — convention CoNLL/HIPE).
-
-    Returns
-    -------
-    dict
-        ``{
-            "global": {"precision", "recall", "f1", "support"},
-            "per_category": {label: {"precision", ...}},
-            "true_positives": int,
-            "false_positives": int,
-            "false_negatives": int,
-            "hallucinated_entities": list[dict],   # entités OCR sans GT
-            "missed_entities":       list[dict],   # entités GT non détectées
-            "iou_threshold": float,
-        }``
-    """
-    refs = [_to_entity(e) for e in reference_entities]
-    hyps = [_to_entity(e) for e in hypothesis_entities]
-
-    matches, unmatched_refs, unmatched_hyps = _align(refs, hyps, iou_threshold)
-
-    tp = len(matches)
-    fn = len(unmatched_refs)
-    fp = len(unmatched_hyps)
-
-    # Comptes par catégorie
-    cat_tp: dict[str, int] = {}
-    cat_fn: dict[str, int] = {}
-    cat_fp: dict[str, int] = {}
-    for i, _j, _score in matches:
-        cat = refs[i].label
-        cat_tp[cat] = cat_tp.get(cat, 0) + 1
-    for i in unmatched_refs:
-        cat = refs[i].label
-        cat_fn[cat] = cat_fn.get(cat, 0) + 1
-    for j in unmatched_hyps:
-        cat = hyps[j].label
-        cat_fp[cat] = cat_fp.get(cat, 0) + 1
-
-    all_categories = sorted(set(cat_tp) | set(cat_fn) | set(cat_fp))
-    per_category = {
-        cat: _prf(cat_tp.get(cat, 0), cat_fp.get(cat, 0), cat_fn.get(cat, 0))
-        for cat in all_categories
-    }
-
-    return {
-        "global": _prf(tp, fp, fn),
-        "per_category": per_category,
-        "true_positives": tp,
-        "false_positives": fp,
-        "false_negatives": fn,
-        "hallucinated_entities": [
-            {"label": hyps[j].label, "start": hyps[j].start,
-             "end": hyps[j].end, "text": hyps[j].text}
-            for j in sorted(unmatched_hyps)
-        ],
-        "missed_entities": [
-            {"label": refs[i].label, "start": refs[i].start,
-             "end": refs[i].end, "text": refs[i].text}
-            for i in sorted(unmatched_refs)
-        ],
-        "iou_threshold": iou_threshold,
-    }
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="ner_f1",
-    input_types=(ArtifactType.ENTITIES, ArtifactType.ENTITIES),
-    description=(
-        "F1 global sur les entités nommées (alignement IoU ≥ 0,5, "
-        "labels case-insensitive). Pour le détail par catégorie, "
-        "utiliser compute_ner_metrics directement."
-    ),
-    higher_is_better=True,
-    tags={"downstream", "ner", "structure"},
+warnings.warn(
+    "picarones.measurements.ner est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.ner à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-def ner_f1(
-    reference_entities: Iterable[Entity | dict],
-    hypothesis_entities: Iterable[Entity | dict],
-) -> float:
-    """F1 global ; raccourci enregistré pour les jonctions ``(ENTITIES, ENTITIES)``."""
-    return compute_ner_metrics(reference_entities, hypothesis_entities)["global"]["f1"]
-
 
-__all__ = [
-    "Entity",
-    "compute_ner_metrics",
-    "ner_f1",
-]
+from picarones.evaluation.metrics.ner import *  # noqa: F401, F403, E402

picarones/measurements/numerical_sequences_hooks.py

@@ -1,102 +1,21 @@
-"""Câblage runner des séquences numériques (Sprint 86).
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 86 — A.II.5b (vue HTML + câblage runner).
-
-Le module ``picarones/core/numerical_sequences.py`` (Sprint 85)
-a livré la couche de calcul.  Ce helper prépare la donnée
-adaptative pour le runner et agrège les compteurs par moteur.
-
-Adaptive masking
-----------------
-On ne stocke le résultat que si la GT contient au moins une
-séquence numérique détectée — sinon le module n'apparaît pas
-dans le rapport.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.numerical_sequences_hooks`` vers
+``picarones.evaluation.metrics.numerical_sequences_hooks`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-from typing import Iterable, Optional
+import warnings
 
-from picarones.evaluation.metrics.numerical_sequences import (
-    CATEGORIES,
-    compute_numerical_sequence_metrics,
+warnings.warn(
+    "picarones.measurements.numerical_sequences_hooks est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.numerical_sequences_hooks à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-logger = logging.getLogger(__name__)
-
-
-def compute_numerical_sequence_metrics_adaptive(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> Optional[dict]:
-    """Calcule les métriques séquences numériques avec masquage
-    adaptatif : retourne ``None`` si la GT n'en contient
-    aucune."""
-    if not reference:
-        return None
-    result = compute_numerical_sequence_metrics(reference, hypothesis or "")
-    if (result.get("n_total") or 0) == 0:
-        return None
-    return result
-
-
-def aggregate_numerical_sequence_metrics(
-    per_doc: Iterable[Optional[dict]],
-) -> Optional[dict]:
-    """Agrège par moteur : somme les compteurs par catégorie et
-    recalcule les scores globaux et per-category.
-
-    Format de sortie identique à ``compute_numerical_sequence_metrics``
-    pour faciliter le rendu HTML symétrique.
-    """
-    docs = [d for d in per_doc if d]
-    if not docs:
-        return None
-    total_n = 0
-    total_strict = 0
-    total_value = 0
-    per_cat: dict[str, dict] = {}
-    for cat in CATEGORIES:
-        per_cat[cat] = {
-            "n_total": 0,
-            "strict": 0,
-            "value": 0,
-            "lost_items": [],
-        }
-    for d in docs:
-        for cat in CATEGORIES:
-            cat_data = (d.get("per_category") or {}).get(cat) or {}
-            per_cat[cat]["n_total"] += int(cat_data.get("n_total") or 0)
-            per_cat[cat]["strict"] += int(cat_data.get("strict") or 0)
-            per_cat[cat]["value"] += int(cat_data.get("value") or 0)
-            per_cat[cat]["lost_items"].extend(
-                cat_data.get("lost_items") or [],
-            )
-        total_n += int(d.get("n_total") or 0)
-    # Recalcul des scores
-    for cat, slot in per_cat.items():
-        n = slot["n_total"]
-        slot["strict_score"] = slot["strict"] / n if n else 0.0
-        slot["value_score"] = slot["value"] / n if n else 0.0
-        # Cap des lost_items à 50 par catégorie
-        slot["lost_items"] = slot["lost_items"][:50]
-        total_strict += slot["strict"]
-        total_value += slot["value"]
-    return {
-        "n_docs": len(docs),
-        "n_total": total_n,
-        "global_strict_score": (
-            total_strict / total_n if total_n else 0.0
-        ),
-        "global_value_score": (
-            total_value / total_n if total_n else 0.0
-        ),
-        "per_category": per_cat,
-    }
-
-
-__all__ = [
-    "compute_numerical_sequence_metrics_adaptive",
-    "aggregate_numerical_sequence_metrics",
-]
+from picarones.evaluation.metrics.numerical_sequences_hooks import *  # noqa: F401, F403, E402

picarones/measurements/readability.py

@@ -1,252 +1,21 @@
-"""Métriques de lisibilité (Flesch) — Sprint 52.
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 52 — A.II.2.3 du plan d'évolution 2026 : couche de calcul pure
-de la métrique Flesch, indépendante de tout alignement OCR/GT.
-
-Pourquoi ce module
-------------------
-Les LLM produisent du texte plus « lisse » que les manuscrits
-historiques.  Cette tendance à la modernisation est mesurable par la
-différence de score de lisibilité entre la GT et la sortie OCR/LLM —
-**indépendamment des classes taxonomiques** et **sans alignement
-caractère/mot**.  C'est l'avantage clé du score Flesch : il fonctionne
-même quand l'OCR est très dégradé (cas d'un LLM qui invente du texte
-moderne plausible mais déconnecté de la GT).
-
-Stratégie de découpage
-----------------------
-Comme pour le NER (Sprint 38) et la calibration (Sprint 39), on
-découpe :
-
-- **Sprint 52** (ici) — couche de calcul pure : ``flesch_score`` et
-  ``flesch_delta``.  Aucune dépendance externe ; les heuristiques de
-  comptage de syllabes sont en pur Python, déterministes, testées.
-- **Sprints suivants** — câblage runner pour calculer
-  ``flesch_delta`` par document et l'agréger au moteur, puis vue HTML.
-
-Formules
---------
-- **Anglais** (Flesch original 1948) :
-  ``206.835 - 1.015 × (mots/phrases) - 84.6 × (syllabes/mots)``
-- **Français** (Kandel-Moles 1958) :
-  ``207 - 1.015 × (mots/phrases) - 73.6 × (syllabes/mots)``
-
-Le score est borné dans ``[0, 100]`` — 100 ↔ « très facile à lire »,
-0 ↔ « très difficile ».  Une **augmentation** du score quand on passe
-de la GT à l'OCR signale une simplification (typique des LLM
-modernisants).  Une **chute** signale une dégradation OCR.
-
-Limites documentées
--------------------
-- Le comptage de syllabes est heuristique.  En français, des règles
-  comme « -ier non final = 2 syllabes » ne sont pas appliquées
-  finement.  Acceptable pour une métrique de **comparaison relative**
-  (delta GT vs OCR), pas pour publier une absolue.
-- Sur des textes très courts (< 20 mots), la formule perd en
-  fiabilité.  Le seuil minimal est documenté.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.readability`` vers
+``picarones.evaluation.metrics.readability`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-import re
-from typing import Literal
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-Language = Literal["fr", "en"]
-
-# Coefficients de la formule Flesch selon la langue.
-_FLESCH_COEFFS: dict[str, tuple[float, float, float]] = {
-    "en": (206.835, 1.015, 84.6),     # Flesch 1948
-    "fr": (207.0,   1.015, 73.6),     # Kandel-Moles 1958
-}
-
-# Voyelles utilisées pour l'heuristique de comptage de syllabes.
-# On utilise un set qui inclut les diacritiques courantes en FR/EN.
-_VOWELS = set("aeiouyàâäéèêëîïôöùûüÿæœAEIOUYÀÂÄÉÈÊËÎÏÔÖÙÛÜŸÆŒ")
-
-# Regex de découpage en phrases : ponctuation finale + espace ou fin.
-# Tolère les multiples points (« ... ») et garde un découpage robuste.
-_SENTENCE_SPLIT_RE = re.compile(r"[.!?…]+(?:\s+|$)")
-
-# Regex de tokenisation simple (mots) : séquences de caractères "lettres".
-_WORD_RE = re.compile(r"[\w'-]+", re.UNICODE)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Compteurs de base
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def count_words(text: str) -> int:
-    """Nombre de mots (tokens alphanumériques) dans ``text``."""
-    if not text:
-        return 0
-    return len(_WORD_RE.findall(text))
-
-
-def count_sentences(text: str) -> int:
-    """Nombre de phrases dans ``text``.
-
-    Découpage par ponctuation finale (``.``, ``!``, ``?``, ``…``).
-    Renvoie au minimum 1 si ``text`` contient au moins un mot, pour
-    éviter une division par zéro dans la formule de Flesch sur les
-    textes sans ponctuation finale.
-    """
-    if not text:
-        return 0
-    parts = [p for p in _SENTENCE_SPLIT_RE.split(text) if p.strip()]
-    n = len(parts)
-    if n == 0 and count_words(text) > 0:
-        return 1
-    return n
-
-
-def count_syllables_word(word: str) -> int:
-    """Heuristique de comptage de syllabes pour un mot isolé.
-
-    Règle : on compte les **groupes de voyelles consécutives** (en
-    incluant ``y`` et les diacritiques courantes).  C'est une
-    approximation grossière mais déterministe et testable.
+import warnings
 
-    Cas limites :
-    - mot vide ��� 0
-    - mot sans voyelle → 1 (par convention, ex. acronymes ``BNF``)
-    - mot d'une seule voyelle isolée → 1
-    """
-    if not word:
-        return 0
-    word = word.lower()
-    in_vowel_group = False
-    count = 0
-    for ch in word:
-        if ch in _VOWELS:
-            if not in_vowel_group:
-                count += 1
-                in_vowel_group = True
-        else:
-            in_vowel_group = False
-    return count or 1
-
-
-def count_syllables(text: str) -> int:
-    """Somme des syllabes de tous les mots de ``text``."""
-    if not text:
-        return 0
-    return sum(count_syllables_word(w) for w in _WORD_RE.findall(text))
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Score Flesch
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def flesch_score(text: str, lang: Language = "fr") -> float:
-    """Calcule le score de lisibilité Flesch pour ``text``.
-
-    Parameters
-    ----------
-    text:
-        Texte à évaluer.  Peut contenir ponctuation, accents, etc.
-    lang:
-        ``"fr"`` (Kandel-Moles 1958, défaut) ou ``"en"`` (Flesch 1948).
-
-    Returns
-    -------
-    float
-        Score borné dans ``[0, 100]``.  Renvoie ``0.0`` sur un texte
-        vide ou sans mot exploitable.
-
-    Notes
-    -----
-    Le score chute fortement avec :
-    - longues phrases (mots/phrases élevé)
-    - mots polysyllabiques (syllabes/mots élevé)
-    Une montée du score lors du passage GT → OCR signale qu'un LLM a
-    « lissé » la langue (phrases plus courtes, mots plus communs).
-    """
-    if lang not in _FLESCH_COEFFS:
-        raise ValueError(f"Langue non supportée : {lang!r}. Choisir 'fr' ou 'en'.")
-
-    n_words = count_words(text)
-    if n_words == 0:
-        return 0.0
-    n_sentences = max(1, count_sentences(text))
-    n_syllables = count_syllables(text)
-    if n_syllables == 0:
-        return 0.0
-
-    base, k_words, k_syll = _FLESCH_COEFFS[lang]
-    raw = base - k_words * (n_words / n_sentences) - k_syll * (n_syllables / n_words)
-    return max(0.0, min(100.0, raw))
-
-
-def flesch_delta(
-    reference: str,
-    hypothesis: str,
-    lang: Language = "fr",
-) -> float:
-    """Différence ``flesch_score(hypothesis) - flesch_score(reference)``.
-
-    Interprétation
-    --------------
-    - **Positif** : l'hypothèse OCR est plus lisible que la GT —
-      signal d'**over-normalisation** (typique des LLM qui modernisent
-      des textes anciens).
-    - **Négatif** : l'OCR est moins lisible — signal de dégradation
-      (caractères mal reconnus brisent la fluidité).
-    - **≈ 0** : OCR fidèle à la GT en termes de complexité linguistique.
-
-    Borné dans ``[-100, +100]``.
-    """
-    return flesch_score(hypothesis, lang=lang) - flesch_score(reference, lang=lang)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="flesch_delta_fr",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Différence de score Flesch (Kandel-Moles, FR) entre la sortie "
-        "OCR et la GT. Positif = OCR plus lisible (signal "
-        "d'over-normalisation LLM). Aucun alignement requis."
-    ),
-    higher_is_better=False,  # un delta proche de 0 = fidélité ; positif = LLM lissant
-    tags={"text", "readability", "over_normalization"},
+warnings.warn(
+    "picarones.measurements.readability est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.readability à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-def _registered_flesch_delta_fr(reference: str, hypothesis: str) -> float:
-    return flesch_delta(reference, hypothesis, lang="fr")
-
-
-@register_metric(
-    name="flesch_delta_en",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Flesch reading ease delta (Flesch 1948, EN) between OCR and GT. "
-        "Positive = OCR easier to read than GT (LLM smoothing signal). "
-        "No alignment required."
-    ),
-    higher_is_better=False,
-    tags={"text", "readability", "over_normalization"},
-)
-def _registered_flesch_delta_en(reference: str, hypothesis: str) -> float:
-    return flesch_delta(reference, hypothesis, lang="en")
-
 
-__all__ = [
-    "flesch_score",
-    "flesch_delta",
-    "count_words",
-    "count_sentences",
-    "count_syllables",
-    "count_syllables_word",
-]
+from picarones.evaluation.metrics.readability import *  # noqa: F401, F403, E402

picarones/measurements/readability_hooks.py

@@ -1,114 +1,21 @@
-"""Câblage runner du delta Flesch (Sprint 87 — A.II.2).
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 87 — A.II.2 (vue HTML + câblage runner du delta Flesch
-livré par le Sprint 52).
-
-Pourquoi ce module
-------------------
-Le ``flesch_delta`` mesure la différence de lisibilité entre la
-GT et la sortie OCR.  Un score positif signale une *over-
-normalisation* typique des LLM/VLM qui modernisent un texte
-ancien (le Flesch monte parce que les mots sont plus simples) ;
-un score négatif signale une dégradation OCR brutale.
-
-Cette métrique est calculée **automatiquement** par le runner
-sur chaque document, agrégée par moteur, et présentée dans le
-rapport.
-
-Adaptive masking
-----------------
-On ne calcule que si la GT contient ≥ 5 mots — en dessous, le
-Flesch est trop instable pour être informatif.
-
-Langue
-------
-Lecture depuis ``corpus.metadata.get("language", "fr")``.  Pour
-les corpus mixtes, l'utilisateur peut passer une langue
-explicite à l'orchestrateur.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.readability_hooks`` vers
+``picarones.evaluation.metrics.readability_hooks`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-import statistics
-from typing import Iterable, Optional
+import warnings
 
-from picarones.measurements.readability import (
-    Language,
-    count_words,
-    flesch_delta,
-    flesch_score,
+warnings.warn(
+    "picarones.measurements.readability_hooks est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.readability_hooks à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-logger = logging.getLogger(__name__)
-
-
-_MIN_WORDS_FOR_FLESCH = 5
-
-
-def compute_readability_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    *,
-    lang: Language = "fr",
-) -> Optional[dict]:
-    """Calcule le delta Flesch d'un document avec adaptive masking.
-
-    Retourne ``None`` si la GT contient moins de
-    ``_MIN_WORDS_FOR_FLESCH`` mots.
-    """
-    ref = reference or ""
-    n_ref_words = count_words(ref)
-    if n_ref_words < _MIN_WORDS_FOR_FLESCH:
-        return None
-    hyp = hypothesis or ""
-    flesch_ref = flesch_score(ref, lang=lang)
-    flesch_hyp = flesch_score(hyp, lang=lang) if hyp else None
-    delta = (
-        flesch_delta(ref, hyp, lang=lang) if hyp else None
-    )
-    return {
-        "lang": lang,
-        "flesch_reference": flesch_ref,
-        "flesch_hypothesis": flesch_hyp,
-        "flesch_delta": delta,
-        "n_words_reference": n_ref_words,
-    }
-
-
-def aggregate_readability_metrics(
-    per_doc: Iterable[Optional[dict]],
-) -> Optional[dict]:
-    """Agrège : moyenne/médiane des deltas + part de docs
-    « over-normalisés » (delta > +5 points).
-    """
-    docs = [d for d in per_doc if d]
-    if not docs:
-        return None
-    deltas = [
-        float(d["flesch_delta"]) for d in docs
-        if isinstance(d.get("flesch_delta"), (int, float))
-    ]
-    if not deltas:
-        return None
-    over_norm = sum(1 for d in deltas if d > 5.0)
-    under_norm = sum(1 for d in deltas if d < -5.0)
-    lang = docs[0].get("lang") or "fr"
-    return {
-        "lang": lang,
-        "n_docs": len(docs),
-        "n_docs_with_delta": len(deltas),
-        "delta_mean": statistics.fmean(deltas),
-        "delta_median": statistics.median(deltas),
-        "delta_min": min(deltas),
-        "delta_max": max(deltas),
-        "n_over_normalized": over_norm,
-        "n_under_normalized": under_norm,
-        "over_normalized_rate": over_norm / len(deltas),
-    }
-
-
-__all__ = [
-    "compute_readability_metrics",
-    "aggregate_readability_metrics",
-]
+from picarones.evaluation.metrics.readability_hooks import *  # noqa: F401, F403, E402

picarones/measurements/reading_order.py

@@ -1,196 +1,21 @@
-"""Reading order F1 (ICDAR 2015, Antonacopoulos) — Sprint 53.
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 53 — A.II.2.1 du plan d'évolution 2026.
-
-Pourquoi ce module
-------------------
-Sur un manuscrit glosé, un journal multi-colonnes ou un registre
-paroissial complexe, le **classement des moteurs en CER** peut être
-trompeur : un moteur peut avoir un excellent CER caractère et un
-**ordre de lecture catastrophique**.  Le résultat est inutilisable
-pour la recherche plein texte (Elastic, Solr) ou pour reconstituer
-une narration linéaire.
-
-La métrique standard est définie par Antonacopoulos et al. dans
-ICDAR 2015 — F1 sur les **paires d'ordre relatif** entre régions
-ALTO/PAGE.  Pour chaque paire ``(a, b)`` telle que ``a`` précède
-``b`` dans la GT :
-
-- **TP** si ``a`` précède aussi ``b`` dans l'hypothèse,
-- **FN** si la paire est manquante (régions absentes ou ordre
-  inversé) côté hypothèse,
-- **FP** si une paire ``(a, b)`` apparaît dans l'hypothèse alors que
-  la GT n'a pas cet ordre (régions hallucinées ou inversion).
-
-Le F1 est la moyenne harmonique des deux.
-
-Stratégie de découpage
-----------------------
-Cohérent avec NER (Sprint 38), calibration (Sprint 39), Flesch
-(Sprint 52) : couche de calcul pure d'abord.  L'utilisateur fournit
-deux listes ordonnées d'IDs de régions (typiquement extraites de
-ALTO/PAGE par un parser amont).  Le câblage runner et la vue HTML
-suivent dans des sprints dédiés.
-
-Compatible directement avec ``ReadingOrderGT`` du Sprint 32 :
-``ReadingOrderGT.region_order`` est exactement le format attendu.
-
-Convention sur les régions
---------------------------
-- Les IDs sont des chaînes (``"r_1"``, ``"region_main"``, etc.).
-- Les **doublons** sont ignorés au calcul des paires ordonnées
-  (chaque ID compte une fois par séquence).
-- Une région présente dans la GT mais absente de l'hypothèse
-  contribue aux paires FN.
-- Une région présente dans l'hypothèse mais absente de la GT
-  contribue aux paires FP.
-- Si une séquence a < 2 régions distinctes, aucune paire n'est
-  émise — le F1 retourne ``0.0`` ou ``1.0`` selon que les deux
-  séquences soient identiques.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.reading_order`` vers
+``picarones.evaluation.metrics.reading_order`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-from itertools import combinations
-from typing import Iterable
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Helpers
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _ordered_pairs(sequence: list[str]) -> set[tuple[str, str]]:
-    """Retourne l'ensemble des paires ``(a, b)`` telles que ``a``
-    précède strictement ``b`` dans ``sequence``.
-
-    Doublons : chaque ID est traité une seule fois (première occurrence
-    dans la séquence).  Cohérent avec ICDAR 2015 où les régions ont
-    des IDs uniques.
-    """
-    seen: list[str] = []
-    seen_set: set[str] = set()
-    for r in sequence:
-        if r not in seen_set:
-            seen.append(r)
-            seen_set.add(r)
-    return set(combinations(seen, 2))
-
-
-def _normalize_input(value: Iterable[str] | None) -> list[str]:
-    """Coerce une entrée en list[str], en filtrant les valeurs vides."""
-    if value is None:
-        return []
-    return [str(v) for v in value if v is not None and str(v).strip()]
+import warnings
 
-
-# ──────────────────────────────────────────────────────────────────────────
-# Métrique principale
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_reading_order_metrics(
-    reference_order: Iterable[str] | None,
-    hypothesis_order: Iterable[str] | None,
-) -> dict:
-    """Calcule precision / recall / F1 sur l'ordre relatif des régions.
-
-    Parameters
-    ----------
-    reference_order:
-        Séquence ordonnée d'IDs de régions issue de la GT (typiquement
-        ``ReadingOrderGT.region_order`` du Sprint 32).
-    hypothesis_order:
-        Séquence ordonnée d'IDs de régions produite par un moteur
-        OCR/HTR ou un reconstructeur ALTO.
-
-    Returns
-    -------
-    dict
-        ``{"precision", "recall", "f1", "true_positives",
-        "false_positives", "false_negatives", "n_ref_pairs",
-        "n_hyp_pairs", "common_regions", "ref_only_regions",
-        "hyp_only_regions"}``.
-
-    Comportements aux bornes
-    ------------------------
-    - Deux séquences identiques (mêmes régions, même ordre) → F1 = 1.0.
-    - Ordre strictement inversé → F1 = 0.0 (toutes les paires
-      relatives sont fausses).
-    - Une séquence vide vs une séquence non vide → F1 = 0.0.
-    - Deux séquences vides → F1 = 0.0 et tous les compteurs à 0
-      (convention : on ne récompense pas l'absence).
-    """
-    ref = _normalize_input(reference_order)
-    hyp = _normalize_input(hypothesis_order)
-
-    ref_pairs = _ordered_pairs(ref)
-    hyp_pairs = _ordered_pairs(hyp)
-
-    tp = len(ref_pairs & hyp_pairs)
-    fn = len(ref_pairs - hyp_pairs)
-    fp = len(hyp_pairs - ref_pairs)
-
-    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
-    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
-    f1 = (
-        2 * precision * recall / (precision + recall)
-        if (precision + recall) > 0
-        else 0.0
-    )
-
-    ref_set = set(ref)
-    hyp_set = set(hyp)
-    return {
-        "precision": precision,
-        "recall": recall,
-        "f1": f1,
-        "true_positives": tp,
-        "false_positives": fp,
-        "false_negatives": fn,
-        "n_ref_pairs": len(ref_pairs),
-        "n_hyp_pairs": len(hyp_pairs),
-        "common_regions": sorted(ref_set & hyp_set),
-        "ref_only_regions": sorted(ref_set - hyp_set),
-        "hyp_only_regions": sorted(hyp_set - ref_set),
-    }
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="reading_order_f1",
-    input_types=(ArtifactType.READING_ORDER, ArtifactType.READING_ORDER),
-    description=(
-        "F1 sur l'ordre relatif des régions ALTO/PAGE (ICDAR 2015, "
-        "Antonacopoulos). Pour chaque paire (a,b) où a précède b dans "
-        "la GT, vérifie que a précède aussi b dans l'hypothèse."
-    ),
-    higher_is_better=True,
-    tags={"structure", "icdar", "alto", "page"},
+warnings.warn(
+    "picarones.measurements.reading_order est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.reading_order à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-def reading_order_f1(
-    reference: Iterable[str] | None,
-    hypothesis: Iterable[str] | None,
-) -> float:
-    """Raccourci : retourne uniquement le F1 global.
-
-    Pour les détails par paire (TP/FP/FN, régions communes, etc.),
-    appeler ``compute_reading_order_metrics`` directement.
-    """
-    return compute_reading_order_metrics(reference, hypothesis)["f1"]
-
 
-__all__ = [
-    "compute_reading_order_metrics",
-    "reading_order_f1",
-]
+from picarones.evaluation.metrics.reading_order import *  # noqa: F401, F403, E402

picarones/measurements/searchability.py

@@ -1,225 +1,21 @@
-"""Recherchabilité fuzzy — Sprint 84 (A.II.5).
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 84 — A.II.5 du plan d'évolution 2026.
-
-Pourquoi ce module
-------------------
-Le CER mesure les erreurs caractère par caractère.  Mais pour
-un usage *recherche plein-texte* (ce que font Elastic, Solr en
-mode fuzzy, ou la recherche full-text de Gallica), la question
-réelle est :
-
-    *« Combien de mots de ma GT sont retrouvables dans la
-    sortie OCR, à orthographe approchée près ? »*
-
-Un CER de 8 % peut donner 95 % de findability si les erreurs
-sont concentrées sur des caractères non-significatifs ou sur
-quelques mots aberrants ; à l'inverse, 4 % de CER mais
-distribué sur tous les noms propres rend le corpus inutilisable
-pour l'indexation prosopographique.
-
-Méthode
--------
-Pour chaque token GT, on regarde s'il existe au moins un token
-hypothèse à distance de Levenshtein ≤ ``max_distance`` (défaut
-2, valeur Elastic ``fuzziness: AUTO`` standard pour mots ≥ 5
-caractères).  Le **rappel** est la proportion de tokens GT
-ainsi retrouvés.
-
-Multiplicité
-------------
-Si la GT contient *« le »* deux fois et l'hypothèse une fois,
-seul un token GT est compté comme retrouvé (alignement
-multi-set, comme ``rare_token_recall`` Sprint 71).
-
-Sortie
-------
-``compute_searchability(reference, hypothesis)`` retourne
-``{n_gt_tokens, n_searchable, recall, missed_tokens}``.
-
-Limites documentées
--------------------
-- Tokenisation par split sur whitespace (cohérent avec le reste
-  du codebase).  Pas de stemming ni de lemmatisation.
-- Levenshtein non pondéré — substitution = insertion = suppression
-  = 1.  Pour un poids différent (par ex. faute classique
-  diacritique = 0,5), passer une fonction custom.
-- Pas de sémantique : *« roi »* ≠ *« souverain »*.  Pour la
-  similarité sémantique, voir des modules futurs (BERTScore).
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.searchability`` vers
+``picarones.evaluation.metrics.searchability`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-from typing import Optional
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Tokenisation et distance d'édition
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _split_words(text: Optional[str]) -> list[str]:
-    """Tokenisation par whitespace — cohérent avec
-    ``lexical_modernization.py``, ``rare_tokens.py``, etc."""
-    if not text:
-        return []
-    return text.split()
-
+import warnings
 
-def levenshtein_distance(a: str, b: str) -> int:
-    """Distance de Levenshtein (substitution=insertion=suppression=1).
-
-    Implémentation DP O(|a|·|b|) en mémoire O(min(|a|,|b|)).
-    """
-    if a == b:
-        return 0
-    if len(a) < len(b):
-        a, b = b, a
-    # |a| ≥ |b|
-    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]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul principal
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_searchability(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    *,
-    max_distance: int = 2,
-    case_sensitive: bool = False,
-) -> dict:
-    """Recherchabilité fuzzy de ``reference`` dans ``hypothesis``.
-
-    Parameters
-    ----------
-    reference, hypothesis:
-        Transcriptions GT et OCR.
-    max_distance:
-        Seuil de distance de Levenshtein (≤ pour considérer un
-        token comme retrouvé).  Défaut 2 — convention
-        ``fuzziness: AUTO`` d'Elastic pour mots ≥ 5 caractères.
-    case_sensitive:
-        Si False (défaut), casse insensible côté match — la
-        sortie ``missed_tokens`` reste avec la casse GT
-        originale.
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_gt_tokens": int,
-            "n_searchable": int,
-            "recall": float | None,    # None si n_gt_tokens == 0
-            "missed_tokens": list[str],
-            "max_distance": int,
-        }``
-    """
-    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 {
-            "n_gt_tokens": 0,
-            "n_searchable": 0,
-            "recall": None,
-            "missed_tokens": [],
-            "max_distance": max_distance,
-        }
-    # Multi-set : un token hypothèse ne peut servir qu'une fois.
-    # Tri par longueur croissante pour matcher d'abord les
-    # tokens GT les plus courts (où ε-fautes sont plus rares).
-    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_searchable = 0
-    missed: list[str] = []
-    for gi, gt_match in enumerate(gt_for_match):
-        # Court-circuit si match exact disponible
-        best_idx = -1
-        best_dist = max_distance + 1
-        for hi, used in enumerate(hyp_used):
-            if used:
-                continue
-            hyp_match = hyp_for_match[hi]
-            # Court-circuit longueur (Levenshtein ≥ |Δlen|)
-            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  # match exact, inutile de chercher mieux
-        if best_idx >= 0 and best_dist <= max_distance:
-            hyp_used[best_idx] = True
-            n_searchable += 1
-        else:
-            missed.append(gt_tokens[gi])
-    recall = n_searchable / n_gt
-    return {
-        "n_gt_tokens": n_gt,
-        "n_searchable": n_searchable,
-        "recall": recall,
-        "missed_tokens": missed,
-        "max_distance": max_distance,
-    }
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="searchability_recall",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Recherchabilité fuzzy : proportion de tokens GT retrouvés "
-        "dans l'OCR à distance de Levenshtein ≤ 2. Proxy direct de "
-        "la qualité pour la recherche plein-texte (Elastic, Solr)."
-    ),
+warnings.warn(
+    "picarones.measurements.searchability est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.searchability à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-def searchability_recall_metric(reference: str, hypothesis: str) -> float:
-    """Variante scalaire pour le registre typé : retourne le
-    rappel en [0, 1], ou ``0.0`` si la GT est vide (convention
-    cohérente avec rare_token_recall Sprint 71).
-    """
-    result = compute_searchability(reference, hypothesis)
-    recall = result.get("recall")
-    return 0.0 if recall is None else recall
-
 
-__all__ = [
-    "levenshtein_distance",
-    "compute_searchability",
-    "searchability_recall_metric",
-]
+from picarones.evaluation.metrics.searchability import *  # noqa: F401, F403, E402

picarones/measurements/searchability_hooks.py

@@ -1,81 +1,21 @@
-"""Câblage runner de la recherchabilité (Sprint 86).
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 86 — A.II.5a (vue HTML + câblage runner).
-
-Le module ``picarones/core/searchability.py`` (Sprint 84) a livré
-la couche de calcul.  Ce helper prépare la donnée pour le runner
-historique et l'agrégation par moteur.
-
-Adaptive masking
-----------------
-Comme pour les modules philologiques (Sprint 61), on ne calcule
-le rappel que si la GT contient au moins un token —  pas de
-calcul vide qui produirait du bruit dans le rapport.
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.searchability_hooks`` vers
+``picarones.evaluation.metrics.searchability_hooks`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-from typing import Iterable, Optional
+import warnings
 
-from picarones.measurements.searchability import (
-    _split_words,
-    compute_searchability,
+warnings.warn(
+    "picarones.measurements.searchability_hooks est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.searchability_hooks à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-logger = logging.getLogger(__name__)
-
-
-def compute_searchability_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    *,
-    max_distance: int = 2,
-) -> Optional[dict]:
-    """Recherchabilité d'un document (adaptive).
-
-    Retourne ``None`` si la GT est vide ou ne contient aucun
-    token — ce qui déclenche l'adaptive masking côté HTML.
-    """
-    if not reference or not _split_words(reference):
-        return None
-    return compute_searchability(
-        reference, hypothesis or "", max_distance=max_distance,
-    )
-
-
-def aggregate_searchability_metrics(
-    per_doc: Iterable[Optional[dict]],
-) -> Optional[dict]:
-    """Agrège les métriques par-doc en un score corpus-wide.
-
-    Convention : on somme les ``n_gt_tokens`` et ``n_searchable``
-    et on recalcule un rappel **micro** (cohérent avec ECE/MCE
-    Sprint 39 et NER Sprint 38).
-    """
-    docs = [d for d in per_doc if d]
-    if not docs:
-        return None
-    n_gt = sum(int(d.get("n_gt_tokens") or 0) for d in docs)
-    n_search = sum(int(d.get("n_searchable") or 0) for d in docs)
-    if n_gt == 0:
-        return None
-    # On garde l'union des missed_tokens (capped pour ne pas
-    # exploser le JSON sur de gros corpus)
-    missed: list[str] = []
-    for d in docs:
-        missed.extend(d.get("missed_tokens") or [])
-    return {
-        "n_docs": len(docs),
-        "n_gt_tokens": n_gt,
-        "n_searchable": n_search,
-        "recall": n_search / n_gt,
-        "missed_tokens_sample": missed[:50],
-        "max_distance": docs[0].get("max_distance", 2),
-    }
-
-
-__all__ = [
-    "compute_searchability_metrics",
-    "aggregate_searchability_metrics",
-]
+from picarones.evaluation.metrics.searchability_hooks import *  # noqa: F401, F403, E402

picarones/measurements/unicode_blocks.py

@@ -1,233 +1,21 @@
-"""Précision par bloc Unicode — Sprint 55.
+"""Shim de compatibilité — métrique relocalisée.
 
-Sprint 55 — A.II.3.1 du plan d'évolution 2026 (métriques philologiques).
-
-Pourquoi ce module
-------------------
-Pour un éditeur d'imprimés anciens ou un médiéviste, la question
-n'est pas seulement *« quel CER global ? »* mais *« quels caractères
-historiques ce moteur restitue-t-il fidèlement ? »*.  Une phrase de
-synthèse actionnable en un coup d'œil :
-
-> *« GPT-4o restitue 95 % du Latin de Base mais seulement 12 % des
-> formes de présentation latine (fi, fl, ſ…). »*
-
-Ce module agrège la précision par **bloc Unicode standard** (Latin de
-Base, Latin Étendu A/B, Diacritiques combinants, Présentation latine,
-etc.).  Le résultat permet directement de choisir un moteur selon le
-type de glyphes attendus dans le corpus.
-
-Stratégie de découpage
-----------------------
-Cohérente avec NER (Sprint 38), Flesch (Sprint 52), Reading order F1
-(Sprint 53), Layout F1 (Sprint 54) : couche de calcul pure d'abord.
-Le câblage runner et la vue HTML suivent dans des sprints dédiés.
-
-Convention d'alignement
------------------------
-Alignement caractère par caractère via ``difflib.SequenceMatcher`` :
-
-- chaque caractère de la GT est classé dans son bloc Unicode,
-- pour chaque position GT couverte par un opcode ``equal`` →
-  +1 dans ``correct[bloc]``,
-- pour chaque position GT non couverte (replace, delete) → +0,
-- les insertions côté hypothèse (caractères absents de la GT) ne
-  contribuent à aucun bloc — elles sont visibles uniquement via le
-  CER global.
-
-Précision par bloc = ``correct[bloc] / total[bloc]``.
-
-Liste des blocs reconnus
-------------------------
-Centrée sur les glyphes courants des corpus patrimoniaux européens.
-Tout caractère hors de cette table est classé dans ``"Other"``
-(garantit une couverture exhaustive : ``sum(total[bloc]) ==
-len(GT)``).
+Sprint E.2 du plan v2.0 (mai 2026) — module migré depuis
+``picarones.measurements.unicode_blocks`` vers
+``picarones.evaluation.metrics.unicode_blocks`` (couche canonique).
+Ce shim re-exporte l'API publique avec un ``DeprecationWarning``
+et sera supprimé en 2.0.
 """
 
 from __future__ import annotations
 
-import logging
-from difflib import SequenceMatcher
-from typing import Optional
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
+import warnings
 
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Table des blocs Unicode reconnus
-# ──────────────────────────────────────────────────────────────────────────
-
-# Triplets (nom, code_point_min, code_point_max) — bornes inclusives.
-# Centré sur les blocs pertinents pour les corpus patrimoniaux
-# européens (manuscrits médiévaux, imprimés anciens, archives).
-# Source : https://www.unicode.org/charts/
-_UNICODE_BLOCKS: tuple[tuple[str, int, int], ...] = (
-    ("Basic Latin",                              0x0000, 0x007F),
-    ("Latin-1 Supplement",                       0x0080, 0x00FF),
-    ("Latin Extended-A",                         0x0100, 0x017F),
-    ("Latin Extended-B",                         0x0180, 0x024F),
-    ("IPA Extensions",                           0x0250, 0x02AF),
-    ("Spacing Modifier Letters",                 0x02B0, 0x02FF),
-    ("Combining Diacritical Marks",              0x0300, 0x036F),
-    ("Greek and Coptic",                         0x0370, 0x03FF),
-    ("Cyrillic",                                 0x0400, 0x04FF),
-    ("Hebrew",                                   0x0590, 0x05FF),
-    ("Arabic",                                   0x0600, 0x06FF),
-    ("General Punctuation",                      0x2000, 0x206F),
-    ("Superscripts and Subscripts",              0x2070, 0x209F),
-    ("Currency Symbols",                         0x20A0, 0x20CF),
-    ("Combining Diacritical Marks Supplement",   0x1DC0, 0x1DFF),
-    ("Latin Extended Additional",                0x1E00, 0x1EFF),
-    ("Latin Extended-C",                         0x2C60, 0x2C7F),
-    ("Latin Extended-D",                         0xA720, 0xA7FF),  # médiéval
-    ("Latin Extended-E",                         0xAB30, 0xAB6F),
-    ("Alphabetic Presentation Forms",            0xFB00, 0xFB4F),  # fi, fl, ff…
-    ("Mathematical Alphanumeric Symbols",        0x1D400, 0x1D7FF),
-    ("Medieval Unicode Font Initiative (MUFI)",  0xE000, 0xF8FF),  # PUA
+warnings.warn(
+    "picarones.measurements.unicode_blocks est obsolète et sera supprimé en 2.0.  "
+    "Utiliser picarones.evaluation.metrics.unicode_blocks à la place.",
+    DeprecationWarning,
+    stacklevel=2,
 )
 
-
-def get_block(char: str) -> str:
-    """Retourne le nom du bloc Unicode contenant ``char``.
-
-    Pour un caractère hors des blocs listés (ex. CJK, emoji, etc.),
-    retourne ``"Other"``.  Pour une chaîne multi-caractères, on
-    considère uniquement le premier code-point.
-    """
-    if not char:
-        return "Other"
-    cp = ord(char[0])
-    for name, lo, hi in _UNICODE_BLOCKS:
-        if lo <= cp <= hi:
-            return name
-    return "Other"
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul d'accuracy par bloc
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_unicode_block_accuracy(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> dict:
-    """Calcule la précision (recall caractère) par bloc Unicode.
-
-    Parameters
-    ----------
-    reference:
-        Texte GT.  Chaque caractère est classé dans son bloc Unicode.
-    hypothesis:
-        Texte produit par le moteur OCR.
-
-    Returns
-    -------
-    dict
-        ``{
-            "per_block": {
-                bloc_name: {
-                    "correct": int,    # caractères GT correctement restitués
-                    "total":   int,    # caractères GT du bloc
-                    "accuracy": float, # correct / total ∈ [0, 1]
-                },
-                ...
-            },
-            "global_accuracy": float,    # somme(correct) / somme(total)
-            "n_chars_reference": int,
-        }``
-
-    Cas dégénérés
-    -------------
-    - GT vide → ``per_block`` vide, ``global_accuracy = 0.0``,
-      ``n_chars_reference = 0``.
-    - hypothèse vide + GT non-vide → tous les blocs à
-      ``accuracy = 0``.
-    - GT et hyp identiques → tous les blocs à ``accuracy = 1``.
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-    n_ref = len(ref)
-
-    if n_ref == 0:
-        return {
-            "per_block": {},
-            "global_accuracy": 0.0,
-            "n_chars_reference": 0,
-        }
-
-    # 1. Compter le total par bloc
-    total: dict[str, int] = {}
-    for ch in ref:
-        b = get_block(ch)
-        total[b] = total.get(b, 0) + 1
-
-    # 2. Aligner par opcodes de SequenceMatcher
-    #    Pour chaque opcode ``equal``, les positions ``i1..i2-1`` du GT
-    #    sont correctement restituées → +1 par caractère dans son bloc.
-    correct: dict[str, int] = {b: 0 for b in total}
-    matcher = SequenceMatcher(a=ref, b=hyp, autojunk=False)
-    for op, i1, i2, _j1, _j2 in matcher.get_opcodes():
-        if op != "equal":
-            continue
-        for i in range(i1, i2):
-            b = get_block(ref[i])
-            correct[b] = correct.get(b, 0) + 1
-
-    per_block: dict[str, dict] = {}
-    for b in sorted(total):
-        n = total[b]
-        c = correct.get(b, 0)
-        per_block[b] = {
-            "correct": c,
-            "total": n,
-            "accuracy": c / n if n > 0 else 0.0,
-        }
-
-    n_correct_total = sum(d["correct"] for d in per_block.values())
-    return {
-        "per_block": per_block,
-        "global_accuracy": n_correct_total / n_ref,
-        "n_chars_reference": n_ref,
-    }
-
-
-def unicode_block_global_accuracy(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> float:
-    """Raccourci : retourne ``global_accuracy`` (fraction de
-    caractères GT correctement restitués)."""
-    return compute_unicode_block_accuracy(reference, hypothesis)["global_accuracy"]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="unicode_block_global_accuracy",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Fraction de caractères GT correctement restitués par "
-        "l'OCR (alignement caractère par caractère via difflib). "
-        "Pour le détail par bloc Unicode (Latin de Base, Présentation "
-        "latine, etc.), utiliser compute_unicode_block_accuracy."
-    ),
-    higher_is_better=True,
-    tags={"text", "unicode", "philology"},
-)
-def _registered_global_accuracy(reference: str, hypothesis: str) -> float:
-    return unicode_block_global_accuracy(reference, hypothesis)
-
-
-__all__ = [
-    "get_block",
-    "compute_unicode_block_accuracy",
-    "unicode_block_global_accuracy",
-]
+from picarones.evaluation.metrics.unicode_blocks import *  # noqa: F401, F403, E402

tests/architecture/test_legacy_canonical_parity.py

@@ -72,7 +72,7 @@ LEGACY_PACKAGES: tuple[str, ...] = (
 #: :data:`LEGACY_PARITY` sans faire échouer le test.  À diminuer
 #: à chaque session de migration : on cible 0 quand le retrait
 #: est complet.
-BOOTSTRAP_BASELINE = 73
+BOOTSTRAP_BASELINE = 30
 
 
 # ──────────────────────────────────────────────────────────────────

tests/architecture/test_module_coverage.py

@@ -76,6 +76,11 @@ TEST_ONLY_BASELINE: frozenset[str] = frozenset({
     # production.  Suppression / migration prévue en Sprint E
     # (migration des hooks vers ``evaluation/metric_hooks/``).
     "builtin_hooks",
+    # Sprint E.2 du plan v2.0 — module ``measurements.searchability``
+    # est devenu un shim après son déplacement vers
+    # ``evaluation/metrics/searchability``.  Le shim garde son entrée
+    # ici pour que le scanner ne crie pas tant qu'il existe.
+    "searchability",
 })
 
 

tests/measurements/test_sprint38_ner_metrics.py

@@ -33,7 +33,7 @@ import pytest
 
 from picarones.evaluation.metric_registry import compute_at_junction, select_metrics
 from picarones.domain.artifacts import ArtifactType
-from picarones.measurements.ner import Entity, compute_ner_metrics, ner_f1
+from picarones.evaluation.metrics.ner import Entity, compute_ner_metrics, ner_f1
 
 
 # ──────────────────────────────────────────────────────────────────────────

tests/measurements/test_sprint52_readability.py

@@ -30,7 +30,7 @@ import pytest
 
 from picarones.evaluation.metric_registry import select_metrics
 from picarones.domain.artifacts import ArtifactType
-from picarones.measurements.readability import (
+from picarones.evaluation.metrics.readability import (
     count_sentences,
     count_syllables,
     count_syllables_word,

tests/measurements/test_sprint53_reading_order.py

@@ -28,7 +28,7 @@ import pytest
 
 from picarones.evaluation.metric_registry import compute_at_junction, select_metrics
 from picarones.domain.artifacts import ArtifactType
-from picarones.measurements.reading_order import (
+from picarones.evaluation.metrics.reading_order import (
     compute_reading_order_metrics,
     reading_order_f1,
 )

tests/measurements/test_sprint55_unicode_blocks.py

@@ -25,7 +25,7 @@ import pytest
 
 from picarones.evaluation.metric_registry import compute_at_junction, select_metrics
 from picarones.domain.artifacts import ArtifactType
-from picarones.measurements.unicode_blocks import (
+from picarones.evaluation.metrics.unicode_blocks import (
     compute_unicode_block_accuracy,
     get_block,
     unicode_block_global_accuracy,

tests/measurements/test_sprint78_equivalence_profile.py

@@ -23,7 +23,7 @@ Couvre :
 
 from __future__ import annotations
 
-from picarones.measurements.equivalence_profile import (
+from picarones.evaluation.metrics.equivalence_profile import (
     BUILTIN_EQUIVALENCES,
     EquivalenceRule,
     apply_selected_equivalences,

tests/measurements/test_sprint84_searchability.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 
 import pytest
 
-from picarones.measurements.searchability import (
+from picarones.evaluation.metrics.searchability import (
     compute_searchability,
     levenshtein_distance,
     searchability_recall_metric,

tests/report/test_sprint86_aii5_html.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
-from picarones.measurements.numerical_sequences_hooks import (
+from picarones.evaluation.metrics.numerical_sequences_hooks import (
     aggregate_numerical_sequence_metrics,
     compute_numerical_sequence_metrics_adaptive,
 )
@@ -32,7 +32,7 @@ def _stub_metrics() -> MetricsResult:
         wer=0.0, wer_normalized=0.0, mer=0.0, wil=0.0,
         reference_length=0, hypothesis_length=0,
     )
-from picarones.measurements.searchability_hooks import (
+from picarones.evaluation.metrics.searchability_hooks import (
     aggregate_searchability_metrics,
     compute_searchability_metrics,
 )

tests/report/test_sprint87_readability_html.py

@@ -17,7 +17,7 @@ import json
 from pathlib import Path
 
 from picarones.evaluation.metric_result import MetricsResult
-from picarones.measurements.readability_hooks import (
+from picarones.evaluation.metrics.readability_hooks import (
     aggregate_readability_metrics,
     compute_readability_metrics,
 )