sprint34: Phase 0.3 — registre typé de métriques (clôture Phase 0)

Troisième et dernier sprint de la Phase 0 du plan d'évolution 2026.
Permet à un runner de pipeline composée de calculer automatiquement la
métrique adéquate à chaque jonction de son DAG selon les types
d'artefacts.

Nouveaux modules :
- picarones/core/metric_registry.py : MetricSpec (dataclass figée),
décorateur @register_metric(name, input_types, ...), select_metrics
par signature exacte, compute_at_junction qui orchestre toutes les
métriques applicables et tolère les erreurs unitaires (logger.warning).
- picarones/core/builtin_metrics.py : enregistre cer/wer/mer/wil sur
(TEXT, TEXT) plus le stub text_preservation_after_reconstruction sur
(TEXT, ALTO) comme preuve de concept de jonction hétérogène.

Approche strictement additive : ni metrics.py ni compute_metrics ne
sont modifiés. Le rapport HTML reste identique octet par octet (critère
de la Phase 0.3).

Tests : +21 dans test_sprint34_metric_registry.py couvrant
l'enregistrement, la sélection par signature, la résilience aux
erreurs (skip_on_error), les garde-fous (double enregistrement, arité),
le stub TEXT→ALTO et — point critique — la parité numérique
CER/WER/MER/WIL avec compute_metrics legacy à 1e-9 près sur 4 paires
de textes.
Suite complète : 1518 → 1539 passed, 2 skipped, 0 failed.

Phase 0 du plan d'évolution 2026 close. Les 3 sprints (32 GT
multi-niveaux, 33 BaseModule générique, 34 registre de métriques)
constituent la fondation commune des axes A et B. Prochaine étape :
Étape 2 du plan — premier livrable de l'axe A (NER, calibration,
divergence taxonomique, médiane par défaut, stratification script_type).

CHANGELOG.md

@@ -16,6 +16,33 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 34 — Phase 0.3 : registre typé de métriques (clôture Phase 0).**
+  Nouveaux modules `picarones/core/metric_registry.py` et
+  `picarones/core/builtin_metrics.py` :
+  - `MetricSpec` (dataclass figée) déclare `name`, `func`,
+    `input_types: tuple[ArtifactType, ArtifactType]`, `description`,
+    `higher_is_better`, `tags`
+  - Décorateur `@register_metric(name=..., input_types=..., ...)`
+    enregistre une métrique dans un registre global ; double
+    enregistrement avec le même nom interdit, signature non-paire rejetée
+  - `select_metrics(input_types)` retourne les métriques applicables à
+    une jonction
+  - `compute_at_junction(reference, hypothesis, input_types)` calcule
+    toutes les métriques sélectionnées et tolère les erreurs unitaires
+    (`logger.warning`, jamais `except: pass`)
+  - `builtin_metrics.py` enregistre `cer`, `wer`, `mer`, `wil` sur
+    `(TEXT, TEXT)` plus le stub `text_preservation_after_reconstruction`
+    sur `(TEXT, ALTO)` comme preuve de concept de jonction hétérogène
+  - **Approche additive stricte** : ni `metrics.py` ni `compute_metrics`
+    ne sont modifiés ; le rapport HTML existant reste strictement
+    identique octet par octet
+  - +21 tests dans `tests/test_sprint34_metric_registry.py` couvrant
+    l'enregistrement, la sélection par signature exacte, la résilience
+    aux erreurs (`skip_on_error`), la **parité numérique** avec
+    `compute_metrics` legacy sur 4 paires de textes (CER/WER/MER/WIL
+    identiques à 1e-9 près), les garde-fous (double enregistrement,
+    arité), et le stub TEXT→ALTO
+
 - **Sprint 33 — Phase 0.2 : interface module générique.** Création de
   `picarones/core/modules.py` :
   - Enum `ArtifactType` (IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER) —
@@ -56,7 +83,8 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Tests
 
-- 1478 → 1518 tests (+17 Sprint 32, +23 Sprint 33). Aucune régression.
+- 1478 → 1539 tests (+17 Sprint 32, +23 Sprint 33, +21 Sprint 34). Aucune
+  régression sur la suite existante. **Phase 0 du plan d'évolution close.**
 
 ---
 

CLAUDE.md

@@ -205,6 +205,7 @@ AZURE_DOC_INTEL_KEY=...
 | 23-31 | Sprints intermédiaires : anti-hallucination, sécurité institutionnelle, refactor frontend Jinja2, persistance SQLite des jobs, snapshots reproductibilité, save/load config + comparaison de runs, registre déclaratif des détecteurs, polish/a11y/DX, couverture des modules sous-testés. Voir `CHANGELOG.md` [1.1.x] pour le détail. |
 | 32 | **Sprint 1 du plan d'évolution 2026 — Phase 0.1 : GT multi-niveaux**. Refonte de `picarones/core/corpus.py` pour porter une vérité terrain à plusieurs niveaux (`GTLevel.{TEXT,ALTO,PAGE,ENTITIES,READING_ORDER}`), payloads typés (`TextGT`, `AltoGT`, `PageGT`, `EntitiesGT`, `ReadingOrderGT`) avec `source_path` traçable. Le champ `Document.ground_truth: str` reste la source de vérité historique et est synchronisé automatiquement avec `Document.ground_truths[GTLevel.TEXT]` — rétrocompatibilité stricte (1478 tests existants passent sans modification). Le loader détecte automatiquement `.gt.alto.xml`, `.gt.page.xml`, `.gt.entities.json`, `.gt.reading_order.json` à côté de l'image. `Corpus.gt_level_coverage()` et `Corpus.available_gt_levels` exposent la couverture. Erreurs de parse dégradées en `logger.warning` (jamais `except: pass`). +17 tests dans `test_sprint32_multi_level_gt.py`. **Verrou levé** : ce sprint débloque l'évaluation des modules qui produisent ou consomment ALTO/PAGE/entités (axe B du plan, à venir Sprint 35+) et plusieurs métriques de l'axe A (Layout F1, reading order F1, NER). |
 | 33 | **Sprint 2 du plan d'évolution 2026 — Phase 0.2 : interface module générique**. Nouveau module `picarones/core/modules.py` avec l'enum `ArtifactType` (IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER) et la classe abstraite `BaseModule` qui déclare `input_types`/`output_types`, `execution_mode` (`"io"`/`"cpu"`), une méthode `process(dict[ArtifactType, Any]) → dict[ArtifactType, Any]`, et des helpers `validate_inputs`/`validate_outputs`. `BaseOCREngine` (`picarones/engines/base.py`) hérite désormais de `BaseModule` avec `input_types=(IMAGE,)` et `output_types=(TEXT,)` ; sa nouvelle méthode `process` wrappe l'API historique `run()`. Aucun adaptateur OCR existant n'est touché — `test_engines.py` passe à 20/20 sans modification. +23 tests dans `test_sprint33_module_interface.py` (contrat, validation, MockModule TEXT→ALTO démonstratif comme demandé par le plan, délégation `BaseOCREngine.process → run`, cohérence ArtifactType/GTLevel). **Verrou levé** : un même runner peut maintenant exécuter un OCR (image→texte), un mappeur VLM→ALTO, un rewriter ALTO→ALTO, un module NER (texte→entités), etc. — fondation directe pour l'axe B du plan. |
+| 34 | **Sprint 3 du plan d'évolution 2026 — Phase 0.3 : registre typé de métriques (clôture Phase 0)**. Nouveaux modules `picarones/core/metric_registry.py` (`MetricSpec`, `@register_metric`, `select_metrics`, `compute_at_junction`) et `picarones/core/builtin_metrics.py` qui enregistre `cer`, `wer`, `mer`, `wil` sur `(TEXT, TEXT)` plus un stub `text_preservation_after_reconstruction` sur `(TEXT, ALTO)` comme preuve de concept de jonction hétérogène. **Approche strictement additive** : ni `metrics.py` ni `compute_metrics` ne sont modifiés, le rapport HTML reste identique octet par octet. La sélection par signature de types est exacte (pas de coercion). +21 tests dans `test_sprint34_metric_registry.py`, dont une parité numérique CER/WER/MER/WIL avec `compute_metrics` legacy à 1e-9 près sur 4 paires de textes. **Verrou levé** : le runner d'une pipeline composée peut maintenant calculer automatiquement la métrique adéquate à chaque jonction de son DAG selon les types d'artefacts produits/attendus — fondation directe pour la métrique d'absorption d'erreur (acte B.3) et toutes les métriques structurelles à venir (Layout F1, reading order F1, NER). |
 
 ---
 
@@ -251,7 +252,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 1518 passed, 2 skipped (Sprints 32-33 — Phase 0.1 + 0.2 du plan d'évolution 2026)
+- **Tests** : 1539 passed, 2 skipped (Sprints 32-34 — Phase 0 du plan d'évolution 2026 close)
 - **Plan d'évolution actif** : [`docs/roadmap/evolution-2026.md`](docs/roadmap/evolution-2026.md)
 - **Branche active** : `claude/analyze-project-evolution-KOA56`
 - **Transcript de la conversation de développement** :

picarones/core/builtin_metrics.py

@@ -0,0 +1,163 @@
+"""Métriques natives enregistrées dans le registre typé (Sprint 34).
+
+Ce module est un démonstrateur d'enregistrement : il expose les
+métriques scalaires existantes (CER, WER, MER, WIL) sous une forme
+unitaire dans le registre, plus un stub typé hétérogène pour les
+jonctions ``(TEXT, ALTO)``.
+
+L'import du module suffit à peupler le registre — le décorateur
+``@register_metric`` s'exécute à l'import.  Les sprints suivants (axe A
+du plan d'évolution) ajouteront ici les métriques structurelles
+(``reading_order_f1``, ``layout_f1``), philologiques (``unicode_block_*``,
+``mufi_coverage``), et de fiabilité (``ece``, ``mce``).
+
+Important — pas de double calcul
+-------------------------------
+Ces wrappers ne **remplacent pas** ``compute_metrics`` du module
+``metrics.py``.  Ils existent pour les nouveaux chemins (pipelines
+composées qui calculent par jonction).  Le rapport HTML existant
+continue à passer par ``compute_metrics`` et reste donc strictement
+identique octet par octet (critère de la Phase 0.3).
+"""
+
+from __future__ import annotations
+
+import logging
+
+from picarones.core.metric_registry import register_metric
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+try:
+    import jiwer
+    _JIWER_AVAILABLE = True
+except ImportError:
+    _JIWER_AVAILABLE = False
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Métriques scalaires (TEXT, TEXT) — wrappers fins autour de jiwer
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _safe_jiwer_call(fn, reference: str, hypothesis: str) -> float:
+    """Wrapper qui gère les cas dégénérés (références ou hypothèses vides)."""
+    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)
+
+
+@register_metric(
+    name="cer",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description="Character Error Rate (distance d'édition normalisée par la longueur de la GT).",
+    higher_is_better=False,
+    tags={"text", "edit_distance", "error_rate"},
+)
+def cer(reference: str, hypothesis: str) -> float:
+    """CER brut sur les caractères, via jiwer."""
+    return _safe_jiwer_call(jiwer.cer, reference, hypothesis)
+
+
+@register_metric(
+    name="wer",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description="Word Error Rate.",
+    higher_is_better=False,
+    tags={"text", "edit_distance", "error_rate"},
+)
+def wer(reference: str, hypothesis: str) -> float:
+    """WER brut, via jiwer."""
+    return _safe_jiwer_call(jiwer.wer, reference, hypothesis)
+
+
+@register_metric(
+    name="mer",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description="Match Error Rate (jiwer).",
+    higher_is_better=False,
+    tags={"text", "error_rate"},
+)
+def mer(reference: str, hypothesis: str) -> float:
+    return _safe_jiwer_call(jiwer.mer, reference, hypothesis)
+
+
+@register_metric(
+    name="wil",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description="Word Information Lost (jiwer).",
+    higher_is_better=False,
+    tags={"text", "error_rate"},
+)
+def wil(reference: str, hypothesis: str) -> float:
+    return _safe_jiwer_call(jiwer.wil, reference, hypothesis)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Métrique typée hétérogène (TEXT, ALTO) — stub démonstrateur
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="text_preservation_after_reconstruction",
+    input_types=(ArtifactType.TEXT, ArtifactType.ALTO),
+    description=(
+        "Taux de tokens de la GT texte présents dans le texte extrait de "
+        "l'ALTO produit (preuve de concept ; remplaçable par une mesure "
+        "alignée par les sprints futurs)."
+    ),
+    higher_is_better=True,
+    tags={"structure", "preservation", "stub"},
+)
+def text_preservation_after_reconstruction(
+    reference_text: str,
+    hypothesis_alto: str,
+) -> float:
+    """Stub démonstrateur d'une jonction texte → ALTO.
+
+    Sprints à venir (axe A du plan d'évolution) remplaceront cette
+    implémentation par une vraie mesure de préservation : extraction
+    structurée du texte ALTO via le parser dédié, alignement, calcul
+    déterministe.  Pour l'instant la mesure est volontairement simple
+    pour démontrer le mécanisme.
+
+    Parameters
+    ----------
+    reference_text:
+        Texte GT (niveau ``GTLevel.TEXT``).
+    hypothesis_alto:
+        ALTO XML brut produit par un module de reconstruction (niveau
+        ``ArtifactType.ALTO``).
+
+    Returns
+    -------
+    float
+        Taux de tokens uniques de ``reference_text`` apparaissant dans
+        ``hypothesis_alto`` (case-insensitive).  ``1.0`` = tous les
+        tokens préservés.
+    """
+    if not reference_text:
+        return 1.0
+    ref_tokens = {tok.lower() for tok in reference_text.split() if tok}
+    if not ref_tokens:
+        return 1.0
+    alto_text = hypothesis_alto.lower()
+    preserved = sum(1 for tok in ref_tokens if tok in alto_text)
+    return preserved / len(ref_tokens)
+
+
+__all__ = [
+    "cer",
+    "wer",
+    "mer",
+    "wil",
+    "text_preservation_after_reconstruction",
+]

picarones/core/metric_registry.py

@@ -0,0 +1,263 @@
+"""Registre typé de métriques (Sprint 34 — Phase 0.3 du plan d'évolution).
+
+Pourquoi ce module
+------------------
+Aujourd'hui ``compute_metrics`` (`picarones/core/metrics.py`) calcule un
+ensemble fixe de métriques (CER, WER, MER, WIL) sur la paire ``(GT_text,
+hypothesis_text)``.  Cette signature implicite empêche d'évaluer les
+sorties d'une pipeline composée à autre chose qu'à du texte : un
+reconstructeur ALTO, un module NER, un mappeur VLM ne peuvent pas être
+mesurés.
+
+Le registre ci-dessous résout ce problème par typage : chaque métrique
+déclare les types d'artefacts qu'elle consomme via ``@register_metric``,
+et le runner d'une pipeline composée sélectionne automatiquement les
+métriques applicables à chaque jonction de son DAG.
+
+Approche additive
+-----------------
+Ce sprint **n'altère pas** le chemin de calcul existant.  Le code legacy
+(``compute_metrics`` → ``MetricsResult``) continue à fonctionner sans
+modification, ce qui garantit le déterminisme bit-à-bit du rapport HTML.
+Le registre est une couche supplémentaire utilisable par les nouveaux
+chemins (pipelines composées, métriques typées contribuées par les
+modules tiers).
+
+Exemple d'usage
+---------------
+>>> from picarones.core.modules import ArtifactType
+>>> from picarones.core.metric_registry import (
+...     register_metric, select_metrics, compute_at_junction,
+... )
+>>>
+>>> @register_metric(
+...     name="my_word_count_ratio",
+...     input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+...     description="Rapport du nombre de mots OCR / GT",
+... )
+... def word_count_ratio(reference: str, hypothesis: str) -> float:
+...     ref = max(1, len(reference.split()))
+...     return len(hypothesis.split()) / ref
+>>>
+>>> applicable = select_metrics((ArtifactType.TEXT, ArtifactType.TEXT))
+>>> any(spec.name == "my_word_count_ratio" for spec in applicable)
+True
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Spécification d'une métrique typée
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class MetricSpec:
+    """Description déclarative d'une métrique enregistrée.
+
+    Attributs
+    ---------
+    name:
+        Identifiant unique du registre (ex. ``"cer"``,
+        ``"reading_order_f1"``).  Deux enregistrements avec le même
+        ``name`` lèvent ``ValueError`` à l'enregistrement.
+    func:
+        Fonction de calcul ``f(reference, hypothesis) -> Any``.  Le type
+        des deux arguments doit correspondre à ``input_types``.
+    input_types:
+        Couple ``(reference_type, hypothesis_type)`` indiquant ce que la
+        métrique attend.  Le runner sélectionne par cette signature.
+    description:
+        Phrase courte affichée dans le rapport / le glossaire.
+    higher_is_better:
+        ``True`` si une valeur plus élevée signale une meilleure qualité
+        (ex : F1, recall) ; ``False`` pour les métriques d'erreur (CER,
+        WER).  Utilisé par le moteur narratif pour orienter ses
+        comparaisons.
+    tags:
+        Étiquettes libres pour grouper les métriques (ex. ``{"text",
+        "edit_distance"}`` ou ``{"structure", "icdar"}``).
+    """
+
+    name: str
+    func: Callable[..., Any]
+    input_types: tuple[ArtifactType, ArtifactType]
+    description: str = ""
+    higher_is_better: bool = False
+    tags: frozenset[str] = field(default_factory=frozenset)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Registre global
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_METRIC_REGISTRY: dict[str, MetricSpec] = {}
+
+
+def register_metric(
+    *,
+    name: str,
+    input_types: tuple[ArtifactType, ArtifactType],
+    description: str = "",
+    higher_is_better: bool = False,
+    tags: frozenset[str] | set[str] | None = None,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Décorateur d'enregistrement d'une métrique typée.
+
+    Parameters
+    ----------
+    name:
+        Identifiant unique.
+    input_types:
+        Couple ``(reference_artifact_type, hypothesis_artifact_type)``.
+    description:
+        Aide courte (≤ une phrase).
+    higher_is_better:
+        ``True`` pour les métriques de qualité, ``False`` pour les
+        métriques d'erreur.
+    tags:
+        Étiquettes pour grouper.
+
+    Raises
+    ------
+    ValueError
+        Si ``name`` est déjà enregistré ou si ``input_types`` n'a pas
+        exactement deux éléments.
+    """
+    if len(input_types) != 2:
+        raise ValueError(
+            f"input_types doit être un couple (ref, hyp) — reçu {input_types!r}"
+        )
+
+    frozen_tags = frozenset(tags) if tags is not None else frozenset()
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        if name in _METRIC_REGISTRY:
+            existing = _METRIC_REGISTRY[name]
+            if existing.func is func:
+                # Ré-import du module : on tolère silencieusement.
+                return func
+            raise ValueError(
+                f"Métrique '{name}' déjà enregistrée par "
+                f"{existing.func.__module__}.{existing.func.__qualname__}"
+            )
+        spec = MetricSpec(
+            name=name,
+            func=func,
+            input_types=input_types,
+            description=description,
+            higher_is_better=higher_is_better,
+            tags=frozen_tags,
+        )
+        _METRIC_REGISTRY[name] = spec
+        return func
+
+    return decorator
+
+
+def get_metric(name: str) -> MetricSpec:
+    """Retourne la spec enregistrée pour ``name``.
+
+    Raises
+    ------
+    KeyError
+        Si la métrique n'est pas enregistrée.
+    """
+    if name not in _METRIC_REGISTRY:
+        raise KeyError(f"Métrique '{name}' non enregistrée")
+    return _METRIC_REGISTRY[name]
+
+
+def all_metrics() -> list[MetricSpec]:
+    """Liste toutes les métriques enregistrées (ordre d'enregistrement)."""
+    return list(_METRIC_REGISTRY.values())
+
+
+def select_metrics(
+    input_types: tuple[ArtifactType, ArtifactType],
+) -> list[MetricSpec]:
+    """Retourne les métriques applicables à une jonction donnée.
+
+    Parameters
+    ----------
+    input_types:
+        Couple ``(reference_type, hypothesis_type)`` à la jonction.
+
+    Returns
+    -------
+    list[MetricSpec]
+        Liste (potentiellement vide) des métriques dont la signature
+        correspond exactement.
+    """
+    return [spec for spec in _METRIC_REGISTRY.values() if spec.input_types == input_types]
+
+
+def compute_at_junction(
+    reference: Any,
+    hypothesis: Any,
+    input_types: tuple[ArtifactType, ArtifactType],
+    *,
+    skip_on_error: bool = True,
+) -> dict[str, Any]:
+    """Calcule toutes les métriques applicables à une jonction.
+
+    Parameters
+    ----------
+    reference:
+        Artefact de référence (typiquement la GT au niveau attendu).
+    hypothesis:
+        Artefact à évaluer (sortie d'un module).
+    input_types:
+        Signature de la jonction.  Détermine quelles métriques sont
+        sélectionnées.
+    skip_on_error:
+        Si ``True`` (défaut), une exception levée par une métrique est
+        loggée en warning et la métrique est absente du résultat.  Si
+        ``False``, l'exception est propagée — utile pour les tests.
+
+    Returns
+    -------
+    dict[str, Any]
+        Dictionnaire ``{metric_name: value}`` pour chaque métrique
+        applicable qui s'est calculée sans erreur.
+    """
+    selected = select_metrics(input_types)
+    results: dict[str, Any] = {}
+    for spec in selected:
+        try:
+            results[spec.name] = spec.func(reference, hypothesis)
+        except Exception as exc:  # noqa: BLE001
+            if skip_on_error:
+                logger.warning(
+                    "[metric_registry] '%s' a échoué : %s — métrique ignorée",
+                    spec.name, exc,
+                )
+            else:
+                raise
+    return results
+
+
+def _reset_registry_for_tests() -> None:
+    """Vide le registre global.  **Réservé aux tests** — ne pas appeler
+    en production sous peine de désactiver toutes les métriques."""
+    _METRIC_REGISTRY.clear()
+
+
+__all__ = [
+    "MetricSpec",
+    "register_metric",
+    "get_metric",
+    "all_metrics",
+    "select_metrics",
+    "compute_at_junction",
+]

tests/test_sprint34_metric_registry.py

@@ -0,0 +1,288 @@
+"""Tests Sprint 34 — registre typé de métriques (Phase 0.3).
+
+Vérifie :
+
+1. ``register_metric`` accepte les métriques typées et les expose via
+   ``all_metrics`` / ``get_metric`` / ``select_metrics``.
+2. La sélection par signature de types est exacte (pas de coercion).
+3. ``compute_at_junction`` calcule toutes les métriques applicables et
+   tolère les erreurs d'une métrique sans casser les autres.
+4. Les métriques natives (``builtin_metrics``) produisent les mêmes
+   valeurs que ``jiwer`` directement (parité numérique avec
+   ``compute_metrics`` legacy).
+5. Le double enregistrement avec le même nom est interdit.
+6. Une signature à 1 ou 3 éléments est rejetée.
+7. Le stub typé hétérogène ``(TEXT, ALTO)`` se calcule sans erreur.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.core.metric_registry import (
+    MetricSpec,
+    all_metrics,
+    compute_at_junction,
+    get_metric,
+    register_metric,
+    select_metrics,
+)
+from picarones.core.modules import ArtifactType
+
+
+# Force l'import du module qui enregistre les métriques natives. Les
+# tests s'exécutent avec ce registre peuplé ; on n'utilise pas
+# ``_reset_registry_for_tests`` parce qu'on veut justement tester l'état
+# par défaut visible par le runner en production.
+import picarones.core.builtin_metrics  # noqa: F401
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1 & 2. Enregistrement et sélection par signature
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRegistryBasics:
+    def test_builtin_metrics_loaded(self) -> None:
+        names = {spec.name for spec in all_metrics()}
+        assert {"cer", "wer", "mer", "wil"} <= names
+
+    def test_get_metric_returns_spec(self) -> None:
+        spec = get_metric("cer")
+        assert isinstance(spec, MetricSpec)
+        assert spec.input_types == (ArtifactType.TEXT, ArtifactType.TEXT)
+        assert spec.higher_is_better is False
+
+    def test_get_metric_unknown_raises(self) -> None:
+        with pytest.raises(KeyError):
+            get_metric("definitely_not_registered_42")
+
+    def test_select_text_text_includes_cer_wer(self) -> None:
+        selected = select_metrics((ArtifactType.TEXT, ArtifactType.TEXT))
+        names = {spec.name for spec in selected}
+        assert "cer" in names
+        assert "wer" in names
+
+    def test_select_alto_alto_excludes_text_metrics(self) -> None:
+        selected = select_metrics((ArtifactType.ALTO, ArtifactType.ALTO))
+        names = {spec.name for spec in selected}
+        assert "cer" not in names
+        assert "wer" not in names
+
+    def test_select_text_alto_returns_heterogeneous_metric(self) -> None:
+        selected = select_metrics((ArtifactType.TEXT, ArtifactType.ALTO))
+        names = {spec.name for spec in selected}
+        assert "text_preservation_after_reconstruction" in names
+
+    def test_select_returns_empty_when_no_match(self) -> None:
+        # ENTITIES → READING_ORDER : aucune métrique enregistrée à ce jour
+        assert select_metrics((ArtifactType.ENTITIES, ArtifactType.READING_ORDER)) == []
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. compute_at_junction — calcul orchestré et résilience
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestComputeAtJunction:
+    def test_returns_all_applicable_metrics(self) -> None:
+        out = compute_at_junction(
+            "hello world",
+            "hello wrld",
+            (ArtifactType.TEXT, ArtifactType.TEXT),
+        )
+        # Au moins les 4 métriques natives doivent être présentes
+        for name in ("cer", "wer", "mer", "wil"):
+            assert name in out
+            assert isinstance(out[name], float)
+            assert 0.0 <= out[name] <= 1.0
+
+    def test_empty_dict_when_no_metric_applies(self) -> None:
+        # Un type d'artefact sans métrique enregistrée
+        out = compute_at_junction(
+            [], [],
+            (ArtifactType.ENTITIES, ArtifactType.READING_ORDER),
+        )
+        assert out == {}
+
+    def test_skip_on_error_default_true(self) -> None:
+        """Une métrique qui lève est ignorée, les autres tournent."""
+
+        @register_metric(
+            name="_test_always_raises",
+            input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+            description="Test only",
+        )
+        def _broken(ref: str, hyp: str) -> float:
+            raise RuntimeError("intentional failure")
+
+        try:
+            out = compute_at_junction(
+                "abc", "abd",
+                (ArtifactType.TEXT, ArtifactType.TEXT),
+            )
+            assert "_test_always_raises" not in out
+            # Les natives sont toujours là
+            assert "cer" in out
+        finally:
+            # Nettoyage manuel — pas d'API publique, on écrit dans le dict.
+            from picarones.core.metric_registry import _METRIC_REGISTRY
+
+            _METRIC_REGISTRY.pop("_test_always_raises", None)
+
+    def test_skip_on_error_false_propagates(self) -> None:
+        @register_metric(
+            name="_test_propagates",
+            input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+        )
+        def _broken(ref: str, hyp: str) -> float:
+            raise RuntimeError("propagate me")
+
+        try:
+            with pytest.raises(RuntimeError, match="propagate me"):
+                compute_at_junction(
+                    "x", "y",
+                    (ArtifactType.TEXT, ArtifactType.TEXT),
+                    skip_on_error=False,
+                )
+        finally:
+            from picarones.core.metric_registry import _METRIC_REGISTRY
+
+            _METRIC_REGISTRY.pop("_test_propagates", None)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Parité numérique avec compute_metrics legacy
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestParityWithLegacy:
+    """Le critère « rapport identique octet par octet » du Sprint 34
+    se traduit en : les métriques enregistrées produisent les mêmes
+    chiffres que ``compute_metrics`` historique sur les mêmes paires."""
+
+    @pytest.mark.parametrize(
+        "ref,hyp",
+        [
+            ("hello world", "hello wrld"),
+            ("Le manuscrit médiéval", "Le manuscript medieval"),
+            ("abcdef", "abcdef"),  # cas parfait
+            ("a", "b"),
+        ],
+    )
+    def test_cer_matches_compute_metrics(self, ref: str, hyp: str) -> None:
+        from picarones.core.metrics import compute_metrics
+
+        legacy = compute_metrics(ref, hyp)
+        registered = compute_at_junction(
+            ref, hyp,
+            (ArtifactType.TEXT, ArtifactType.TEXT),
+        )
+        # On compare au CER brut, pas aux variantes (NFC, caseless,
+        # diplomatic) qui sont des métriques distinctes non encore
+        # enregistrées.
+        assert registered["cer"] == pytest.approx(legacy.cer, abs=1e-9)
+        assert registered["wer"] == pytest.approx(legacy.wer, abs=1e-9)
+        assert registered["mer"] == pytest.approx(legacy.mer, abs=1e-9)
+        assert registered["wil"] == pytest.approx(legacy.wil, abs=1e-9)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5 & 6. Garde-fous d'enregistrement
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRegistrationGuards:
+    def test_double_register_same_name_raises(self) -> None:
+        @register_metric(
+            name="_test_duplicate",
+            input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+        )
+        def _first(ref: str, hyp: str) -> float:
+            return 0.0
+
+        try:
+            with pytest.raises(ValueError, match="déjà enregistrée"):
+
+                @register_metric(
+                    name="_test_duplicate",
+                    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+                )
+                def _second(ref: str, hyp: str) -> float:
+                    return 1.0
+        finally:
+            from picarones.core.metric_registry import _METRIC_REGISTRY
+
+            _METRIC_REGISTRY.pop("_test_duplicate", None)
+
+    def test_re_register_same_function_tolerated(self) -> None:
+        """Ré-importer le module ne doit pas lever (cas réel : pytest
+        recharge un module entre fichiers de tests)."""
+
+        def _func(ref: str, hyp: str) -> float:
+            return 0.0
+
+        register_metric(
+            name="_test_idempotent",
+            input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+        )(_func)
+        # Second appel avec la même fonction → tolérance
+        register_metric(
+            name="_test_idempotent",
+            input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+        )(_func)
+
+        from picarones.core.metric_registry import _METRIC_REGISTRY
+
+        _METRIC_REGISTRY.pop("_test_idempotent", None)
+
+    def test_input_types_must_be_pair(self) -> None:
+        with pytest.raises(ValueError, match="couple"):
+
+            @register_metric(
+                name="_bad_arity_3",
+                input_types=(  # type: ignore[arg-type]
+                    ArtifactType.TEXT,
+                    ArtifactType.TEXT,
+                    ArtifactType.TEXT,
+                ),
+            )
+            def _f(a, b, c):
+                return 0.0
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 7. Stub TEXT → ALTO opérationnel
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestHeterogeneousJunction:
+    def test_text_preservation_runs(self) -> None:
+        ref = "le manuscrit médiéval"
+        alto = (
+            '<?xml version="1.0"?><alto>'
+            '<String CONTENT="le"/><String CONTENT="manuscrit"/>'
+            '<String CONTENT="médiéval"/></alto>'
+        )
+
+        out = compute_at_junction(
+            ref, alto,
+            (ArtifactType.TEXT, ArtifactType.ALTO),
+        )
+        assert "text_preservation_after_reconstruction" in out
+        assert out["text_preservation_after_reconstruction"] == pytest.approx(1.0)
+
+    def test_text_preservation_partial(self) -> None:
+        ref = "alpha beta gamma"
+        alto = '<?xml version="1.0"?><alto><String CONTENT="alpha"/></alto>'
+
+        score = compute_at_junction(
+            ref, alto,
+            (ArtifactType.TEXT, ArtifactType.ALTO),
+        )["text_preservation_after_reconstruction"]
+        # 1 token sur 3 préservé
+        assert score == pytest.approx(1 / 3, abs=1e-9)
+
+    def test_text_preservation_metric_marked_higher_is_better(self) -> None:
+        spec = get_metric("text_preservation_after_reconstruction")
+        assert spec.higher_is_better is True