feat(evaluation): Sprint A14-S27 — découpage ProjectionEngine + EvaluationEngine

Le S13 fusionnait dans DefaultEvaluationViewExecutor deux responsabilités
distinctes : transformer un artefact d'un type vers un autre (« projeter »)
**et** calculer les métriques sur les payloads (« évaluer »). La cible
architecturale les sépare en deux moteurs spécialisés à responsabilité unique.

Nouveaux moteurs
----------------
- ProjectionEngine (picarones/evaluation/projection_engine.py)
· Délègue au ProjectorRegistry, gère identité (spec=None ou
source==target) et erreurs (introuvable, lève → ProjectionError).
· Retourne ProjectionResult(artifact, payload, report) frozen.

- EvaluationEngine (picarones/evaluation/evaluation_engine.py)
· Délègue au MetricRegistry, dispatch erreurs métrique dans
failed_metrics, métrique inconnue → message explicite.
· Retourne EvaluationResult(metric_values, failed_metrics) frozen
avec helpers n_succeeded/n_failed/all_succeeded/with_global_failure.
· Sucre evaluate_one() pour les callers à métrique unique
(ex : pipeline executor sur jonction unique S28+).

Refactor de l'executor
----------------------
- DefaultEvaluationViewExecutor.__init__ canonique attend désormais
(projection_engine, evaluation_engine, payload_loader). La séquence
d'orchestration (type-check → project → load → normalize → evaluate
→ ViewResult) reste identique mais déléguée.
- Classmethod from_registries(metric_registry, projector_registry,
payload_loader) reste exposée comme sucre ergonomique pour callers
qui n'ont pas envie de fabriquer eux-mêmes les deux engines.

Migration des 14 callsites
--------------------------
- run_orchestrator.py : .from_registries(...)
- 13 fichiers de test : .from_registries(...)
- 3 tests TestConstructor renommés vers le nouveau contrat (engines)
+ 3 nouveaux tests TestConstructor pour from_registries.

Tests S27 dédiés (21 nouveaux)
------------------------------
- ProjectionEngine : constructeur, identité (None / source==target),
nominal triplet, projecteur introuvable, lève → ProjectionError
wrappé, ProjectionError native non re-wrappé.
- EvaluationEngine : constructeur, all_succeed, métrique non-zéro,
sucre evaluate_one, ordre préservé, métrique inconnue, métrique
qui lève, liste vide.
- Dataclasses frozen + with_global_failure + has_projection.

Tests legacy S13 + intégration : 100 % préservés (couverture
indirecte de la délégation).

Pourquoi cette séparation
-------------------------
- Réutilisation : le PipelineExecutor (S28+) appellera
ProjectionEngine.project directement quand il transforme un
artefact entre étapes du DAG, sans dépendre de l'executor de vue.
- Testabilité : on teste la projection sans construire de view ;
on teste la collecte d'erreurs métriques sans projecteur ni view.
- Découplage : l'executor n'a plus de logique métier — uniquement
la séquence + l'agrégation finale dans ViewResult.

Tests : 4527 passed, 11 skipped, 0 failed (vs 4504 avant : +21 S27
+ 2 nouveaux TestConstructor — 0 régression).
Lint : ruff check picarones/ tests/ → All checks passed.

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

README.md

@@ -396,7 +396,7 @@ ruff check picarones/ tests/
 python -m mypy picarones/core/
 ```
 
-**Test suite**: ~4520 tests, ~3 min on a modern laptop. Coverage
+**Test suite**: ~4540 tests, ~3 min on a modern laptop. Coverage
 floor at 85% (currently ~87%). The `network` marker excludes tests
 requiring live HTTP. A handful of tests depend on optional engines
 (`pero-ocr`, `pytesseract`) and are skipped/fail gracefully when

picarones/app/services/run_orchestrator.py

@@ -346,7 +346,7 @@ class RunOrchestrator:
             timeout_seconds_per_doc=300.0,
             poll_interval_seconds=0.05,
         )
-        view_executor = DefaultEvaluationViewExecutor(
+        view_executor = DefaultEvaluationViewExecutor.from_registries(
             registries.metrics,
             registries.projectors,
             _filesystem_payload_loader,

picarones/evaluation/__init__.py

@@ -31,4 +31,18 @@ rewrite ciblé (Sprints S13-S18).
 
 from __future__ import annotations
 
-__all__: list[str] = []
+from picarones.evaluation.evaluation_engine import (
+    EvaluationEngine,
+    EvaluationResult,
+)
+from picarones.evaluation.projection_engine import (
+    ProjectionEngine,
+    ProjectionResult,
+)
+
+__all__ = [
+    "EvaluationEngine",
+    "EvaluationResult",
+    "ProjectionEngine",
+    "ProjectionResult",
+]

picarones/evaluation/evaluation_engine.py

@@ -0,0 +1,177 @@
+"""``EvaluationEngine`` — Sprint A14-S27.
+
+Pendant de ``ProjectionEngine`` (cf. ``projection_engine.py``).
+Le S13 fusionnait dans ``DefaultEvaluationViewExecutor`` projection
+**et** évaluation ; la cible architecturale les sépare en deux
+moteurs spécialisés à responsabilité unique.
+
+``EvaluationEngine`` calcule un ensemble nommé de métriques sur
+une paire ``(reference, hypothesis)`` de payloads.  Une métrique
+qui lève en interne va dans ``failed_metrics`` au lieu de planter
+l'évaluation complète — l'erreur est capturée et associée au nom
+de la métrique.
+
+Pourquoi cette séparation
+-------------------------
+- **Réutilisation** : le ``PipelineExecutor`` (S28+) peut appeler
+  ``EvaluationEngine.evaluate`` pour des métriques de jonction
+  intra-pipeline (ex : « score de stabilité entre deux étapes ») sans
+  passer par un ``EvaluationView``.
+- **Testabilité** : on teste la collecte d'erreurs (métrique cassée,
+  métrique inconnue) sans instancier de vue ni de projecteur.
+- **Découplage** : ``EvaluationEngine`` ne sait rien des artefacts,
+  des projections, des vues — il prend des payloads bruts.
+
+Anti-sur-ingénierie
+-------------------
+Pas de batch (évaluer N paires en une passe), pas de cache de
+payload normalisé, pas de pré-tri des métriques.  Le moteur est
+volontairement minimal — la complexité vit dans les métriques
+elles-mêmes (cf. ``picarones/evaluation/metrics/``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from picarones.evaluation.registry import (
+    MetricNotFoundError,
+    MetricRegistry,
+)
+
+
+@dataclass(frozen=True)
+class EvaluationResult:
+    """Résultat d'un appel à ``EvaluationEngine.evaluate``.
+
+    Attributes
+    ----------
+    metric_values:
+        Métriques calculées avec succès, ``{name: value}``.
+    failed_metrics:
+        Métriques qui ont échoué, ``{name: error_message}``.  Les
+        deux dicts sont disjoints : une métrique apparaît dans l'un
+        ou l'autre, jamais les deux.
+
+    Notes
+    -----
+    Frozen dataclass : container immuable ; les dicts internes le
+    sont aussi grâce à ``field(default_factory=dict)`` qu'on ne
+    mute pas après construction.  Le caller doit considérer les
+    dicts comme lecture seule.
+    """
+
+    metric_values: dict[str, Any] = field(default_factory=dict)
+    failed_metrics: dict[str, str] = field(default_factory=dict)
+
+    @property
+    def n_succeeded(self) -> int:
+        return len(self.metric_values)
+
+    @property
+    def n_failed(self) -> int:
+        return len(self.failed_metrics)
+
+    @property
+    def all_succeeded(self) -> bool:
+        return self.n_failed == 0
+
+    def with_global_failure(self, error: str) -> "EvaluationResult":
+        """Retourne un nouveau ``EvaluationResult`` où **toutes** les
+        métriques portent le même message d'erreur global.  Utile à
+        un caller qui constate qu'un payload n'a pas pu être chargé
+        et veut marquer l'évaluation entière en échec."""
+        return EvaluationResult(
+            metric_values={},
+            failed_metrics={
+                name: error
+                for name in (
+                    list(self.metric_values) + list(self.failed_metrics)
+                )
+            },
+        )
+
+
+class EvaluationEngine:
+    """Moteur de calcul de métriques sur une paire de payloads.
+
+    Responsabilité unique : prendre un ``MetricRegistry``, une liste
+    de noms de métriques, et une paire ``(reference, hypothesis)``,
+    retourner un ``EvaluationResult``.  Pas de connaissance des
+    artefacts, des projections, des vues.
+
+    Parameters
+    ----------
+    metric_registry:
+        Registre des métriques, instancié explicitement au démarrage
+        (pas de singleton global, pas de side-effect d'import).
+    """
+
+    def __init__(self, metric_registry: MetricRegistry) -> None:
+        if not isinstance(metric_registry, MetricRegistry):
+            raise TypeError(
+                "metric_registry doit être un MetricRegistry."
+            )
+        self._metrics = metric_registry
+
+    @property
+    def metrics(self) -> MetricRegistry:
+        """Accès en lecture au registre sous-jacent (utile aux tests)."""
+        return self._metrics
+
+    def evaluate(
+        self,
+        metric_names: tuple[str, ...] | list[str],
+        reference: Any,
+        hypothesis: Any,
+    ) -> EvaluationResult:
+        """Calcule chaque métrique nommée sur la paire (référence, hypothèse).
+
+        Comportement :
+
+        - Une métrique enregistrée et qui retourne une valeur → entrée
+          dans ``metric_values``.
+        - Une métrique enregistrée qui lève une exception → entrée
+          dans ``failed_metrics`` avec le message ``f"{type}: {message}"``.
+        - Un nom de métrique non enregistré → entrée dans
+          ``failed_metrics`` avec un message explicite.
+
+        L'ordre d'évaluation suit l'ordre de ``metric_names`` ; les
+        deux dicts résultats préservent cet ordre (Python 3.7+
+        garantit l'ordre d'insertion sur les ``dict``).
+        """
+        metric_values: dict[str, Any] = {}
+        failed_metrics: dict[str, str] = {}
+
+        for name in metric_names:
+            try:
+                value = self._metrics.compute(name, reference, hypothesis)
+                metric_values[name] = value
+            except MetricNotFoundError as exc:
+                failed_metrics[name] = (
+                    f"métrique non enregistrée dans le MetricRegistry : "
+                    f"{exc}"
+                )
+            except Exception as exc:  # noqa: BLE001
+                failed_metrics[name] = f"{type(exc).__name__}: {exc}"
+
+        return EvaluationResult(
+            metric_values=metric_values,
+            failed_metrics=failed_metrics,
+        )
+
+    def evaluate_one(
+        self,
+        metric_name: str,
+        reference: Any,
+        hypothesis: Any,
+    ) -> EvaluationResult:
+        """Cas particulier : une seule métrique.  Sucre syntaxique sur
+        ``evaluate``.  Utile aux callers qui pilotent une jonction
+        unique (typiquement le pipeline executor sur une métrique de
+        jonction)."""
+        return self.evaluate((metric_name,), reference, hypothesis)
+
+
+__all__ = ["EvaluationEngine", "EvaluationResult"]

picarones/evaluation/projection_engine.py

@@ -0,0 +1,174 @@
+"""``ProjectionEngine`` — Sprint A14-S27.
+
+Le S13 fusionnait dans ``DefaultEvaluationViewExecutor`` deux
+responsabilités distinctes : transformer un artefact d'un type vers
+un autre (« projeter ») **et** calculer les métriques sur les
+payloads (« évaluer »).  La cible architecturale les sépare en
+deux moteurs spécialisés à responsabilité unique :
+
+- ``ProjectionEngine`` (ce module) : transforme un ``Artifact``
+  candidat selon une ``ProjectionSpec`` et retourne le nouvel
+  artefact, son ``payload`` calculé, et un ``ProjectionReport``
+  documentant les pertes.
+- ``EvaluationEngine`` (cf. ``evaluation_engine.py``) : calcule les
+  métriques sur des payloads.
+
+L'executor de vue (``DefaultEvaluationViewExecutor``) orchestre les
+deux : projection d'abord, puis chargement, normalisation, et
+évaluation.  Il ne contient plus de logique de projection ni de
+calcul de métrique — uniquement la séquence et la collecte d'erreurs.
+
+Pourquoi cette séparation
+-------------------------
+- **Réutilisation** : le ``PipelineExecutor`` (S28+) appelle
+  ``ProjectionEngine.project`` directement quand il transforme un
+  artefact entre deux étapes du DAG, sans dépendre de l'executor de
+  vue.
+- **Testabilité** : on peut tester la projection sur des artefacts
+  arbitraires sans construire un ``EvaluationView`` ni un
+  ``MetricRegistry``.
+- **Lisibilité** : chaque moteur expose une API minimale et
+  vérifiable au type.
+
+Anti-sur-ingénierie
+-------------------
+Pas de cache de payload entre projections, pas de batch, pas de
+pré-validation des params (le projecteur lui-même validera ce qu'il
+attend).  Le moteur est volontairement minimal — la complexité vit
+dans les projecteurs (cf. ``picarones/evaluation/projectors/``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from picarones.domain.artifacts import Artifact
+from picarones.domain.errors import ProjectionError
+from picarones.domain.projection_spec import ProjectionSpec
+from picarones.evaluation.projectors.base import ProjectionReport
+from picarones.evaluation.projectors.registry import (
+    ProjectorNotFoundError,
+    ProjectorRegistry,
+)
+
+
+@dataclass(frozen=True)
+class ProjectionResult:
+    """Résultat d'un appel à ``ProjectionEngine.project``.
+
+    Attributes
+    ----------
+    artifact:
+        Artefact effectif après projection.  Si la spec était
+        ``None`` ou identité, c'est l'artefact d'entrée tel quel.
+    payload:
+        Payload calculé par le projecteur, ou ``None`` si aucune
+        projection n'a été effectuée (le caller chargera depuis
+        son ``payload_loader``).
+    report:
+        Rapport de projection si une projection a eu lieu, ou
+        ``None`` pour une vue sans projection (identité).
+
+    Notes
+    -----
+    Frozen dataclass : aucune mutation post-construction.  La
+    sérialisation passe par ``ProjectionReport`` (pydantic) qui sait
+    déjà se sérialiser ; ``ProjectionResult`` reste un container
+    interne entre engine et executor.
+    """
+
+    artifact: Artifact
+    payload: Any | None
+    report: ProjectionReport | None
+
+    @property
+    def has_projection(self) -> bool:
+        """Vrai si une projection effective a eu lieu (report présent)."""
+        return self.report is not None
+
+
+class ProjectionEngine:
+    """Moteur de projection d'artefacts selon une ``ProjectionSpec``.
+
+    Responsabilité unique : prendre un ``Artifact`` et une éventuelle
+    ``ProjectionSpec``, retourner un ``ProjectionResult``.  Pas de
+    chargement de payload depuis un loader externe (le projecteur
+    fournit le payload calculé directement, depuis Sprint S25).  Pas
+    de connaissance des métriques ni des vues.
+
+    Parameters
+    ----------
+    projector_registry:
+        Registre des projecteurs disponibles, instancié explicitement
+        au démarrage de l'application.  Pas de singleton global, pas
+        de side-effect d'import.
+    """
+
+    def __init__(self, projector_registry: ProjectorRegistry) -> None:
+        if not isinstance(projector_registry, ProjectorRegistry):
+            raise TypeError(
+                "projector_registry doit être un ProjectorRegistry."
+            )
+        self._projectors = projector_registry
+
+    @property
+    def projectors(self) -> ProjectorRegistry:
+        """Accès en lecture au registre sous-jacent (utile aux tests)."""
+        return self._projectors
+
+    def project(
+        self,
+        artifact: Artifact,
+        spec: ProjectionSpec | None,
+    ) -> ProjectionResult:
+        """Applique la projection si pertinente.
+
+        Comportement :
+
+        - ``spec is None`` ou ``spec.is_identity`` →
+          ``ProjectionResult`` avec l'artefact d'entrée tel quel,
+          ``payload=None``, ``report=None``.  Le caller utilisera
+          son payload_loader pour charger l'artefact original.
+        - Sinon : résout le projecteur dans le registre, exécute
+          ``project()``, et retourne le ``ProjectionResult`` complet
+          avec payload calculé.
+
+        Raises
+        ------
+        ProjectionError
+            Si le projecteur référencé n'est pas enregistré, ou si
+            le projecteur lève une exception interne (wrappée dans
+            une ``ProjectionError`` qui préserve la chaîne ``__cause__``).
+        """
+        if spec is None or spec.is_identity:
+            return ProjectionResult(
+                artifact=artifact, payload=None, report=None,
+            )
+
+        try:
+            projector = self._projectors.get(spec.projector_name)
+        except ProjectorNotFoundError as exc:
+            raise ProjectionError(
+                f"Projecteur {spec.projector_name!r} introuvable "
+                "dans le ProjectorRegistry."
+            ) from exc
+
+        try:
+            target, payload, report = projector.project(
+                artifact, dict(spec.params),
+            )
+        except ProjectionError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            raise ProjectionError(
+                f"Projecteur {spec.projector_name!r} a levé sur "
+                f"l'artefact {artifact.id!r} : {exc}"
+            ) from exc
+
+        return ProjectionResult(
+            artifact=target, payload=payload, report=report,
+        )
+
+
+__all__ = ["ProjectionEngine", "ProjectionResult"]

picarones/evaluation/views/executor.py

@@ -1,36 +1,47 @@
-"""``DefaultEvaluationViewExecutor`` — Sprint A14-S13.
+"""``DefaultEvaluationViewExecutor`` — Sprint A14-S13, refactoré au S27.
 
 Implémentation concrète du protocole ``EvaluationViewExecutor`` (S5).
-Orchestration d'une vue d'évaluation sur une paire (candidat, GT) :
+Orchestre une vue d'évaluation sur une paire (candidat, GT) en
+**déléguant** la projection et l'évaluation à deux moteurs spécialisés
+introduits au S27 :
 
+- ``ProjectionEngine`` (cf. ``picarones/evaluation/projection_engine.py``)
+  transforme l'artefact candidat selon la ``ProjectionSpec``.
+- ``EvaluationEngine`` (cf. ``picarones/evaluation/evaluation_engine.py``)
+  calcule les métriques sur les payloads.
+
+Séquence d'orchestration
+------------------------
 1. Vérifie que ``candidate.type`` est dans ``view.candidate_types``.
-2. Si ``view.projection`` est défini, récupère le projecteur depuis
-   ``ProjectorRegistry`` et applique la projection.  Capture le
-   ``ProjectionReport``.
+2. ``ProjectionEngine.project(candidate, view.projection_for(candidate.type))``
+   → retourne un ``ProjectionResult`` qui peut contenir un payload
+   pré-calculé.
 3. Charge les payloads (texte, ALTO parsé, etc.) via le
-   ``payload_loader`` injecté au constructeur.
+   ``payload_loader`` injecté.  Si la projection a produit un payload,
+   l'utilise directement sans repasser par le loader.
 4. Applique optionnellement un profil de normalisation texte
-   (``view.normalization_profile``) sur les payloads texte.
-5. Calcule chaque métrique listée dans ``view.metric_names`` via
-   ``MetricRegistry``.  Une métrique qui lève est enregistrée dans
-   ``failed_metrics`` au lieu de planter le ViewResult complet.
-6. Retourne un ``ViewResult`` agrégeant tout (metric_values,
-   failed_metrics, projection_report, warnings,
-   ignored_dimensions).
-
-Le ``payload_loader`` est injecté pour découpler l'executor de la
-manière dont les artefacts sont stockés (filesystem, in-memory,
-remote).  Le service applicatif (S19) injectera un loader qui sait
-gérer les workspaces sandboxés.
+   (``view.normalization_profile``).
+5. ``EvaluationEngine.evaluate(view.metric_names, gt_payload, cand_payload)``
+   → retourne un ``EvaluationResult`` avec metric_values + failed_metrics.
+6. Construit le ``ViewResult`` agrégeant tout (projection_report,
+   metric_values, failed_metrics, warnings, ignored_dimensions).
+
+Construction
+------------
+- ``__init__`` canonique prend ``(projection_engine, evaluation_engine,
+  payload_loader)``.
+- ``from_registries(metric_registry, projector_registry, payload_loader)``
+  reste exposé comme classmethod ergonomique pour les callers qui
+  n'ont pas envie de fabriquer eux-mêmes les deux moteurs (tests,
+  scripts ad-hoc).  Aucune logique nouvelle — uniquement un appel
+  composé ; l'API canonique reste l'injection des deux engines.
 
 Anti-sur-ingénierie
 -------------------
-Pas de cache de payload chargé entre métriques (chaque métrique
-relit l'artefact via le loader).  Si un caller veut éviter le coût
-de re-lecture, il instancie un loader qui memo-ize lui-même.
-
-Pas de gestion de batch (évaluer N paires en une seule passe).  À
-ajouter quand un caller en a concrètement besoin.
+Pas de cache de payload chargé entre métriques (chaque appel à
+``evaluate`` est indépendant).  Pas de batch (évaluer N paires en
+une passe).  Pas de validation cross-métrique.  La complexité vit
+dans les engines, pas dans l'executor.
 """
 
 from __future__ import annotations
@@ -39,67 +50,86 @@ import logging
 from typing import Any, Callable
 
 from picarones.domain.artifacts import Artifact
-from picarones.domain.errors import ProjectionError
 from picarones.domain.evaluation_spec import EvaluationView
-from picarones.evaluation.projectors.registry import (
-    ProjectorNotFoundError,
-    ProjectorRegistry,
-)
-from picarones.evaluation.registry import MetricRegistry, MetricNotFoundError
+from picarones.evaluation.evaluation_engine import EvaluationEngine
+from picarones.evaluation.projection_engine import ProjectionEngine
+from picarones.evaluation.projectors.registry import ProjectorRegistry
+from picarones.evaluation.registry import MetricRegistry
 from picarones.evaluation.views.base import ViewResult
 
 logger = logging.getLogger(__name__)
 
 
-#: Sentinelle interne pour distinguer "pas de projection" de "projection
-#: a retourné None comme payload" (cas pathologique mais théoriquement
-#: possible).  Ne jamais comparer avec ``==`` — toujours ``is``.
-_UNSET = object()
-
-
 #: Type alias : un payload loader prend un Artifact et retourne le
 #: contenu chargé (str pour RAW_TEXT, dict pour ENTITIES, etc.).
 PayloadLoader = Callable[[Artifact], Any]
 
 
 class DefaultEvaluationViewExecutor:
-    """Implémentation par défaut de ``EvaluationViewExecutor``.
+    """Orchestrateur de vue d'évaluation.
 
     Parameters
     ----------
-    metric_registry:
-        ``MetricRegistry`` contenant les métriques référencées par
-        ``view.metric_names``.
-    projector_registry:
-        ``ProjectorRegistry`` contenant les projecteurs référencés
-        par ``view.projection.projector_name``.
+    projection_engine:
+        ``ProjectionEngine`` injecté.  Responsable de la
+        transformation d'artefacts entre types via le registre de
+        projecteurs.
+    evaluation_engine:
+        ``EvaluationEngine`` injecté.  Responsable du calcul des
+        métriques nommées sur des payloads.
     payload_loader:
         Callable ``(Artifact) -> Any`` qui charge le contenu d'un
-        artefact.  Pour les tests, typiquement un dict in-memory.
-        En production (S19), un service applicatif qui sait gérer
-        les workspaces.
+        artefact non encore résolu (typiquement la GT et le candidat
+        s'il n'est pas projeté).  Pour les tests, un dict in-memory
+        ; en production, un service applicatif qui sait gérer les
+        workspaces sandboxés.
     """
 
     def __init__(
         self,
-        metric_registry: MetricRegistry,
-        projector_registry: ProjectorRegistry,
+        projection_engine: ProjectionEngine,
+        evaluation_engine: EvaluationEngine,
         payload_loader: PayloadLoader,
     ) -> None:
-        if not isinstance(metric_registry, MetricRegistry):
+        if not isinstance(projection_engine, ProjectionEngine):
             raise TypeError(
-                "metric_registry doit être un MetricRegistry."
+                "projection_engine doit être un ProjectionEngine."
             )
-        if not isinstance(projector_registry, ProjectorRegistry):
+        if not isinstance(evaluation_engine, EvaluationEngine):
             raise TypeError(
-                "projector_registry doit être un ProjectorRegistry."
+                "evaluation_engine doit être un EvaluationEngine."
             )
         if not callable(payload_loader):
             raise TypeError("payload_loader doit être callable.")
-        self._metrics = metric_registry
-        self._projectors = projector_registry
+        self._projection = projection_engine
+        self._evaluation = evaluation_engine
         self._loader = payload_loader
 
+    # ──────────────────────────────────────────────────────────────────
+    # Constructeur ergonomique
+    # ──────────────────────────────────────────────────────────────────
+
+    @classmethod
+    def from_registries(
+        cls,
+        metric_registry: MetricRegistry,
+        projector_registry: ProjectorRegistry,
+        payload_loader: PayloadLoader,
+    ) -> "DefaultEvaluationViewExecutor":
+        """Construit l'executor à partir des registres bruts.
+
+        Sucre syntaxique sur l'API canonique : un caller qui a déjà
+        un ``MetricRegistry`` + ``ProjectorRegistry`` (cas typique :
+        un test, ou un service qui n'a qu'un seul executor) gagne
+        deux lignes.  Aucune logique nouvelle — instancie
+        ``ProjectionEngine`` et ``EvaluationEngine`` puis délègue.
+        """
+        return cls(
+            projection_engine=ProjectionEngine(projector_registry),
+            evaluation_engine=EvaluationEngine(metric_registry),
+            payload_loader=payload_loader,
+        )
+
     # ──────────────────────────────────────────────────────────────────
     # API publique
     # ──────────────────────────────────────────────────────────────────
@@ -115,21 +145,20 @@ class DefaultEvaluationViewExecutor:
         Returns
         -------
         ViewResult
-            Toujours retourné, jamais d'exception en sortie normale —
-            les erreurs vont dans ``failed_metrics`` ou
-            (pour les erreurs de projection) lèvent ``ProjectionError``
-            qui est cohérente avec le contrat du S5.
+            Toujours retourné en sortie normale — les erreurs de
+            métriques individuelles vont dans ``failed_metrics``,
+            les erreurs de chargement de payload se traduisent en
+            ``failed_metrics`` global.
 
         Raises
         ------
         ProjectionError
-            Si la vue exige une projection que le projecteur ne peut
-            pas réaliser (ex : type d'entrée incompatible avec le
-            projecteur trouvé).
+            Si la vue exige une projection que le projecteur ne
+            peut pas réaliser (cohérent avec le contrat du S5).
         ValueError
             Si ``candidate.type`` n'est pas dans
             ``view.candidate_types``.  Le caller (typiquement le
-            service applicatif) doit filtrer les pipelines qui ne
+            ``BenchmarkService``) doit filtrer les pipelines qui ne
             produisent pas le bon type avant d'appeler ``evaluate``.
         """
         # 1. Vérification du type d'entrée.
@@ -141,64 +170,32 @@ class DefaultEvaluationViewExecutor:
                 f"{sorted(t.value for t in view.candidate_types)}."
             )
 
-        # 2. Projection (optionnelle).  Résolution par
-        #    ``view.projection_for(candidate.type)`` qui supporte
-        #    soit une projection unique (champ ``projection``), soit
-        #    un mapping par type source (``projections_by_source_type``).
-        # Le projecteur retourne ``(Artifact, payload, report)`` —
-        # on conserve le payload pour le passer aux métriques sans
-        # repasser par le loader (l'artefact projeté est intermédiaire
-        # et n'a typiquement pas d'URI).
-        effective_candidate = candidate
-        projection_report = None
-        projected_payload: Any = _UNSET
+        # 2. Projection (déléguée).  Lève ``ProjectionError`` si la
+        #    projection est invalide — on laisse remonter (cohérence
+        #    avec le contrat S5).
         projection_spec = view.projection_for(candidate.type)
-        if projection_spec is not None and not projection_spec.is_identity:
-            try:
-                projector = self._projectors.get(
-                    projection_spec.projector_name,
-                )
-            except ProjectorNotFoundError as exc:
-                raise ProjectionError(
-                    f"View {view.name!r} référence le projecteur "
-                    f"{projection_spec.projector_name!r} introuvable "
-                    "dans le ProjectorRegistry."
-                ) from exc
-            try:
-                (
-                    effective_candidate,
-                    projected_payload,
-                    projection_report,
-                ) = projector.project(
-                    candidate, dict(projection_spec.params),
-                )
-            except ProjectionError:
-                raise
-            except Exception as exc:  # noqa: BLE001
-                raise ProjectionError(
-                    f"Projecteur {projection_spec.projector_name!r} a "
-                    f"levé sur l'artefact {candidate.id!r} : {exc}"
-                ) from exc
+        projection_result = self._projection.project(
+            candidate, projection_spec,
+        )
 
         # 3. Chargement des payloads.
-        # Échec de chargement = ViewResult avec une erreur globale
-        # (pas de failed_metric par métrique — l'erreur est en amont).
-        if projected_payload is not _UNSET:
-            # Payload déjà calculé par le projecteur — on l'utilise
-            # tel quel sans repasser par le loader.
-            cand_payload = projected_payload
+        # Si la projection a fourni un payload, on l'utilise sans
+        # repasser par le loader (typique S25 — l'artefact projeté
+        # n'a pas d'URI).  Sinon, on charge le candidat via le loader.
+        if projection_result.payload is not None:
+            cand_payload = projection_result.payload
         else:
             try:
-                cand_payload = self._loader(effective_candidate)
+                cand_payload = self._loader(projection_result.artifact)
             except Exception as exc:  # noqa: BLE001
                 return self._failed_view_result(
                     view=view,
                     candidate=candidate,
                     ground_truth=ground_truth,
-                    projection_report=projection_report,
+                    projection_report=projection_result.report,
                     global_error=(
                         f"payload_loader a échoué sur le candidat "
-                        f"{effective_candidate.id!r} : {exc}"
+                        f"{projection_result.artifact.id!r} : {exc}"
                     ),
                 )
         try:
@@ -208,7 +205,7 @@ class DefaultEvaluationViewExecutor:
                 view=view,
                 candidate=candidate,
                 ground_truth=ground_truth,
-                projection_report=projection_report,
+                projection_report=projection_result.report,
                 global_error=(
                     f"payload_loader a échoué sur la GT "
                     f"{ground_truth.id!r} : {exc}"
@@ -221,34 +218,19 @@ class DefaultEvaluationViewExecutor:
                 view.normalization_profile, cand_payload, gt_payload,
             )
 
-        # 5. Calcul des métriques.  Une métrique qui lève va dans
-        #    failed_metrics.  Une métrique non enregistrée va dans
-        #    failed_metrics avec un message explicite.
-        metric_values: dict[str, Any] = {}
-        failed_metrics: dict[str, str] = {}
-        for name in view.metric_names:
-            try:
-                value = self._metrics.compute(name, gt_payload, cand_payload)
-                metric_values[name] = value
-            except MetricNotFoundError as exc:
-                failed_metrics[name] = (
-                    f"métrique non enregistrée dans le MetricRegistry : "
-                    f"{exc}"
-                )
-            except Exception as exc:  # noqa: BLE001
-                failed_metrics[name] = (
-                    f"{type(exc).__name__}: {exc}"
-                )
+        # 5. Évaluation déléguée.  Une métrique cassée → failed_metrics.
+        evaluation_result = self._evaluation.evaluate(
+            view.metric_names, gt_payload, cand_payload,
+        )
 
-        # 6. Construction du ViewResult.
+        # 6. Agrégation finale dans le ViewResult.
         warnings = tuple(view.warnings)
         ignored = tuple(view.ignored_dimensions)
-        if projection_report is not None:
-            warnings = warnings + tuple(projection_report.warnings)
-            # Déduplique les ignored_dimensions tout en préservant l'ordre.
+        if projection_result.report is not None:
+            warnings = warnings + tuple(projection_result.report.warnings)
             seen: set[str] = set(ignored)
             extra = tuple(
-                d for d in projection_report.ignored_dimensions
+                d for d in projection_result.report.ignored_dimensions
                 if d not in seen
             )
             ignored = ignored + extra
@@ -257,9 +239,9 @@ class DefaultEvaluationViewExecutor:
             view_name=view.name,
             candidate_artifact_id=candidate.id,
             ground_truth_artifact_id=ground_truth.id,
-            metric_values=metric_values,
-            failed_metrics=failed_metrics,
-            projection_report=projection_report,
+            metric_values=evaluation_result.metric_values,
+            failed_metrics=evaluation_result.failed_metrics,
+            projection_report=projection_result.report,
             warnings=warnings,
             ignored_dimensions=ignored,
         )

tests/cli/test_sprint_a14_s22_app_cli.py

@@ -83,7 +83,7 @@ def _build_minimal_run_dir(out_dir: Path, *, corpus_name: str = "test") -> None:
     from picarones.evaluation.views import DefaultEvaluationViewExecutor
     from picarones.pipeline import CorpusRunner, PipelineExecutor
     loader = lambda art: ""  # noqa: E731
-    view_executor = DefaultEvaluationViewExecutor(
+    view_executor = DefaultEvaluationViewExecutor.from_registries(
         MetricRegistry(), ProjectorRegistry(), loader,
     )
     runner_internal = CorpusRunner(

tests/evaluation/test_sprint_a14_s13_view_executor.py

@@ -105,7 +105,7 @@ def _build_executor(
             raise KeyError(f"payload manquant : {artifact.id}")
         return payloads[artifact.id]
 
-    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+    return DefaultEvaluationViewExecutor.from_registries(metrics, projectors, loader)
 
 
 def _text_view(
@@ -226,7 +226,7 @@ class TestEvaluator:
         metrics = MetricRegistry()
         projectors = ProjectorRegistry()
         projectors.register(_CrashingProjector())
-        executor = DefaultEvaluationViewExecutor(
+        executor = DefaultEvaluationViewExecutor.from_registries(
             metrics, projectors, lambda a: None,
         )
         view = _text_view(
@@ -304,7 +304,9 @@ class TestEvaluator:
         def _bad_loader(artifact):
             raise FileNotFoundError(f"missing file for {artifact.id}")
 
-        executor = DefaultEvaluationViewExecutor(metrics, projectors, _bad_loader)
+        executor = DefaultEvaluationViewExecutor.from_registries(
+            metrics, projectors, _bad_loader,
+        )
         view = _text_view(metric_names=("cer",))
         cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
         gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
@@ -320,21 +322,51 @@ class TestEvaluator:
 
 
 class TestConstructor:
-    def test_rejects_non_metric_registry(self) -> None:
-        with pytest.raises(TypeError, match="metric_registry"):
+    """Le constructeur canonique (S27) attend deux engines + un loader."""
+
+    def test_rejects_non_projection_engine(self) -> None:
+        from picarones.evaluation.evaluation_engine import EvaluationEngine
+        with pytest.raises(TypeError, match="projection_engine"):
             DefaultEvaluationViewExecutor(
-                "not a registry", ProjectorRegistry(), lambda a: None,  # type: ignore[arg-type]
+                "not an engine",  # type: ignore[arg-type]
+                EvaluationEngine(MetricRegistry()),
+                lambda a: None,
             )
 
-    def test_rejects_non_projector_registry(self) -> None:
-        with pytest.raises(TypeError, match="projector_registry"):
+    def test_rejects_non_evaluation_engine(self) -> None:
+        from picarones.evaluation.projection_engine import ProjectionEngine
+        with pytest.raises(TypeError, match="evaluation_engine"):
             DefaultEvaluationViewExecutor(
-                MetricRegistry(), "nope", lambda a: None,  # type: ignore[arg-type]
+                ProjectionEngine(ProjectorRegistry()),
+                "nope",  # type: ignore[arg-type]
+                lambda a: None,
             )
 
     def test_rejects_non_callable_loader(self) -> None:
+        from picarones.evaluation.evaluation_engine import EvaluationEngine
+        from picarones.evaluation.projection_engine import ProjectionEngine
         with pytest.raises(TypeError, match="callable"):
             DefaultEvaluationViewExecutor(
+                ProjectionEngine(ProjectorRegistry()),
+                EvaluationEngine(MetricRegistry()),
+                "not_callable",  # type: ignore[arg-type]
+            )
+
+    def test_from_registries_rejects_non_metric_registry(self) -> None:
+        with pytest.raises(TypeError, match="metric_registry"):
+            DefaultEvaluationViewExecutor.from_registries(
+                "not a registry", ProjectorRegistry(), lambda a: None,  # type: ignore[arg-type]
+            )
+
+    def test_from_registries_rejects_non_projector_registry(self) -> None:
+        with pytest.raises(TypeError, match="projector_registry"):
+            DefaultEvaluationViewExecutor.from_registries(
+                MetricRegistry(), "nope", lambda a: None,  # type: ignore[arg-type]
+            )
+
+    def test_from_registries_rejects_non_callable_loader(self) -> None:
+        with pytest.raises(TypeError, match="callable"):
+            DefaultEvaluationViewExecutor.from_registries(
                 MetricRegistry(), ProjectorRegistry(), "not_callable",  # type: ignore[arg-type]
             )
 

tests/evaluation/test_sprint_a14_s16_views_consistency.py

@@ -127,7 +127,7 @@ def _build_unified_executor(payloads: dict) -> DefaultEvaluationViewExecutor:
             raise KeyError(art.id)
         return payloads[art.id]
 
-    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+    return DefaultEvaluationViewExecutor.from_registries(metrics, projectors, loader)
 
 
 # ──────────────────────────────────────────────────────────────────

tests/evaluation/test_sprint_a14_s25_projector_payload.py

@@ -113,7 +113,7 @@ class TestProjectionWithoutLoaderHack:
 
         # Loader strict qui ASSERTE qu'il n'est pas appelé sur l'artefact
         # projeté.
-        executor = DefaultEvaluationViewExecutor(
+        executor = DefaultEvaluationViewExecutor.from_registries(
             registries.metrics,
             registries.projectors,
             _strict_loader,
@@ -160,7 +160,7 @@ class TestProjectionWithoutLoaderHack:
         gt_path.write_text("Titre Bonjour le monde", encoding="utf-8")
 
         registries = RegistryService.bootstrap_defaults()
-        executor = DefaultEvaluationViewExecutor(
+        executor = DefaultEvaluationViewExecutor.from_registries(
             registries.metrics,
             registries.projectors,
             _strict_loader,
@@ -201,7 +201,7 @@ class TestProjectionWithoutLoaderHack:
         gt_path.write_text(gt_text, encoding="utf-8")
 
         registries = RegistryService.bootstrap_defaults()
-        executor = DefaultEvaluationViewExecutor(
+        executor = DefaultEvaluationViewExecutor.from_registries(
             registries.metrics,
             registries.projectors,
             _strict_loader,
@@ -287,7 +287,7 @@ class TestPayloadFromProjectorIsAuthoritative:
             metric_names=("capture",),
         )
 
-        executor = DefaultEvaluationViewExecutor(
+        executor = DefaultEvaluationViewExecutor.from_registries(
             metrics, projectors, _strict_loader,
         )
         cand = Artifact(

tests/evaluation/test_sprint_a14_s27_engines.py

@@ -0,0 +1,352 @@
+"""Sprint A14-S27 — ``ProjectionEngine`` + ``EvaluationEngine`` séparés.
+
+Tests des deux moteurs introduits par S27 pour découper le S13.
+Couvre :
+
+1. ``ProjectionEngine.project`` :
+   - cas identité (spec None) → artefact tel quel, payload None,
+     report None ;
+   - spec identité (source == target) → idem ;
+   - projection nominale → triplet complet (artefact target, payload,
+     report) ;
+   - projecteur introuvable → ProjectionError ;
+   - projecteur qui lève → wrappé en ProjectionError ;
+   - validation du constructeur (rejette non-registry).
+
+2. ``EvaluationEngine.evaluate`` :
+   - calcule chaque métrique, dispatch erreur dans failed_metrics ;
+   - métrique inconnue → message explicite ;
+   - métrique qui lève → message ``{type}: {msg}`` ;
+   - ordre des résultats préservé ;
+   - validation du constructeur ;
+   - sucre ``evaluate_one`` ;
+   - dataclass ``EvaluationResult`` (n_succeeded, n_failed,
+     all_succeeded, with_global_failure).
+
+3. Intégration : l'executor refondu (S27) délègue aux deux engines —
+   les comportements existants du S13 sont préservés (couverture
+   indirecte par ``test_sprint_a14_s13_view_executor.py``).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.domain.artifacts import Artifact, ArtifactType
+from picarones.domain.errors import ProjectionError
+from picarones.domain.projection_spec import ProjectionSpec
+from picarones.evaluation.evaluation_engine import (
+    EvaluationEngine,
+    EvaluationResult,
+)
+from picarones.evaluation.projection_engine import (
+    ProjectionEngine,
+    ProjectionResult,
+)
+from picarones.evaluation.projectors.base import ProjectionReport
+from picarones.evaluation.projectors.registry import (
+    ProjectorRegistry,
+)
+from picarones.evaluation.registry import MetricRegistry
+from picarones.domain.evaluation_spec import MetricSpec
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Stubs réutilisables
+# ──────────────────────────────────────────────────────────────────────
+
+
+class _StubProjector:
+    name = "stub"
+    source_type = ArtifactType.ALTO_XML
+    target_type = ArtifactType.RAW_TEXT
+
+    def __init__(self, payload: str = "projected") -> None:
+        self._payload = payload
+
+    def project(self, artifact, params):
+        target = Artifact(
+            id=f"{artifact.id}:projected",
+            document_id=artifact.document_id,
+            type=self.target_type,
+        )
+        report = ProjectionReport(
+            source_artifact_id=artifact.id,
+            source_type=self.source_type,
+            target_type=self.target_type,
+            projector_name=self.name,
+            lossy=True,
+            ignored_dimensions=("geometry",),
+            warnings=("dim perdue",),
+        )
+        return target, self._payload, report
+
+
+class _CrashingProjector:
+    name = "crash"
+    source_type = ArtifactType.ALTO_XML
+    target_type = ArtifactType.RAW_TEXT
+
+    def project(self, artifact, params):
+        raise RuntimeError("boom interne")
+
+
+# ──────────────────────────────────────────────────────────────────────
+# ProjectionEngine
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestProjectionEngineConstructor:
+    def test_rejects_non_registry(self) -> None:
+        with pytest.raises(TypeError, match="projector_registry"):
+            ProjectionEngine("nope")  # type: ignore[arg-type]
+
+    def test_accepts_empty_registry(self) -> None:
+        engine = ProjectionEngine(ProjectorRegistry())
+        assert engine.projectors is not None
+
+
+class TestProjectionEngineIdentity:
+    def test_none_spec_returns_unchanged(self) -> None:
+        engine = ProjectionEngine(ProjectorRegistry())
+        artifact = Artifact(id="a", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = engine.project(artifact, None)
+        assert result.artifact is artifact
+        assert result.payload is None
+        assert result.report is None
+        assert result.has_projection is False
+
+    def test_identity_spec_returns_unchanged(self) -> None:
+        engine = ProjectionEngine(ProjectorRegistry())
+        artifact = Artifact(id="a", document_id="d", type=ArtifactType.RAW_TEXT)
+        spec = ProjectionSpec(
+            source_type=ArtifactType.RAW_TEXT,
+            target_type=ArtifactType.RAW_TEXT,
+            projector_name="ignored_when_identity",
+        )
+        result = engine.project(artifact, spec)
+        assert result.artifact is artifact
+        assert result.payload is None
+        assert result.report is None
+
+
+class TestProjectionEngineNominal:
+    def test_nominal_returns_triple(self) -> None:
+        registry = ProjectorRegistry()
+        registry.register(_StubProjector(payload="hello"))
+        engine = ProjectionEngine(registry)
+        artifact = Artifact(
+            id="alto",
+            document_id="d",
+            type=ArtifactType.ALTO_XML,
+        )
+        spec = ProjectionSpec(
+            source_type=ArtifactType.ALTO_XML,
+            target_type=ArtifactType.RAW_TEXT,
+            projector_name="stub",
+        )
+        result = engine.project(artifact, spec)
+        assert result.artifact.type == ArtifactType.RAW_TEXT
+        assert result.artifact.id == "alto:projected"
+        assert result.payload == "hello"
+        assert result.report is not None
+        assert result.report.projector_name == "stub"
+        assert result.has_projection is True
+
+
+class TestProjectionEngineErrors:
+    def test_unknown_projector_raises_projection_error(self) -> None:
+        engine = ProjectionEngine(ProjectorRegistry())
+        artifact = Artifact(id="a", document_id="d", type=ArtifactType.ALTO_XML)
+        spec = ProjectionSpec(
+            source_type=ArtifactType.ALTO_XML,
+            target_type=ArtifactType.RAW_TEXT,
+            projector_name="missing",
+        )
+        with pytest.raises(ProjectionError, match="introuvable"):
+            engine.project(artifact, spec)
+
+    def test_crashing_projector_wraps_in_projection_error(self) -> None:
+        registry = ProjectorRegistry()
+        registry.register(_CrashingProjector())
+        engine = ProjectionEngine(registry)
+        artifact = Artifact(id="a", document_id="d", type=ArtifactType.ALTO_XML)
+        spec = ProjectionSpec(
+            source_type=ArtifactType.ALTO_XML,
+            target_type=ArtifactType.RAW_TEXT,
+            projector_name="crash",
+        )
+        with pytest.raises(ProjectionError, match="boom interne"):
+            engine.project(artifact, spec)
+
+    def test_native_projection_error_propagated_unwrapped(self) -> None:
+        """Si le projecteur lève déjà un ``ProjectionError``, on ne le
+        wrappe pas dans un nouveau (préservation de la sémantique)."""
+        class _NativeProjErrProjector:
+            name = "native_err"
+            source_type = ArtifactType.ALTO_XML
+            target_type = ArtifactType.RAW_TEXT
+
+            def project(self, artifact, params):
+                raise ProjectionError("erreur native")
+
+        registry = ProjectorRegistry()
+        registry.register(_NativeProjErrProjector())
+        engine = ProjectionEngine(registry)
+        artifact = Artifact(id="a", document_id="d", type=ArtifactType.ALTO_XML)
+        spec = ProjectionSpec(
+            source_type=ArtifactType.ALTO_XML,
+            target_type=ArtifactType.RAW_TEXT,
+            projector_name="native_err",
+        )
+        with pytest.raises(ProjectionError, match="erreur native"):
+            engine.project(artifact, spec)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# EvaluationEngine
+# ──────────────────────────────────────────────────────────────────────
+
+
+def _build_metric_registry(extra: dict = None) -> MetricRegistry:
+    reg = MetricRegistry()
+    reg.register(
+        MetricSpec(
+            name="cer",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+        ),
+        lambda r, h: 0.0 if r == h else 1.0,
+    )
+    reg.register(
+        MetricSpec(
+            name="wer",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+        ),
+        lambda r, h: 0.0 if r == h else 0.5,
+    )
+    if extra:
+        for name, fn in extra.items():
+            reg.register(
+                MetricSpec(
+                    name=name,
+                    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+                ),
+                fn,
+            )
+    return reg
+
+
+class TestEvaluationEngineConstructor:
+    def test_rejects_non_registry(self) -> None:
+        with pytest.raises(TypeError, match="metric_registry"):
+            EvaluationEngine("nope")  # type: ignore[arg-type]
+
+    def test_accepts_empty_registry(self) -> None:
+        engine = EvaluationEngine(MetricRegistry())
+        assert engine.metrics is not None
+
+
+class TestEvaluationEngineNominal:
+    def test_all_metrics_succeed(self) -> None:
+        engine = EvaluationEngine(_build_metric_registry())
+        result = engine.evaluate(("cer", "wer"), "x", "x")
+        assert result.metric_values == {"cer": 0.0, "wer": 0.0}
+        assert result.failed_metrics == {}
+        assert result.n_succeeded == 2
+        assert result.n_failed == 0
+        assert result.all_succeeded is True
+
+    def test_metric_returning_nonzero(self) -> None:
+        engine = EvaluationEngine(_build_metric_registry())
+        result = engine.evaluate(("cer", "wer"), "abc", "xyz")
+        assert result.metric_values["cer"] == 1.0
+        assert result.metric_values["wer"] == 0.5
+
+    def test_evaluate_one_sugar(self) -> None:
+        engine = EvaluationEngine(_build_metric_registry())
+        result = engine.evaluate_one("cer", "x", "x")
+        assert result.metric_values == {"cer": 0.0}
+        assert result.failed_metrics == {}
+
+    def test_order_preserved(self) -> None:
+        engine = EvaluationEngine(_build_metric_registry())
+        result = engine.evaluate(("wer", "cer"), "x", "x")
+        # dict préserve l'ordre d'insertion (Python 3.7+).
+        assert list(result.metric_values.keys()) == ["wer", "cer"]
+
+
+class TestEvaluationEngineFailures:
+    def test_unknown_metric_goes_to_failed(self) -> None:
+        engine = EvaluationEngine(_build_metric_registry())
+        result = engine.evaluate(("cer", "missing"), "x", "x")
+        assert "cer" in result.metric_values
+        assert "missing" in result.failed_metrics
+        assert "non enregistrée" in result.failed_metrics["missing"]
+
+    def test_metric_that_raises_goes_to_failed(self) -> None:
+        def _broken(r, h):
+            raise ValueError("metric crashed")
+
+        engine = EvaluationEngine(_build_metric_registry({"broken": _broken}))
+        result = engine.evaluate(("cer", "broken", "wer"), "x", "x")
+        assert "cer" in result.metric_values
+        assert "wer" in result.metric_values
+        assert "broken" in result.failed_metrics
+        assert "ValueError" in result.failed_metrics["broken"]
+        assert "metric crashed" in result.failed_metrics["broken"]
+        assert result.n_succeeded == 2
+        assert result.n_failed == 1
+        assert result.all_succeeded is False
+
+    def test_empty_metric_list_returns_empty_result(self) -> None:
+        engine = EvaluationEngine(_build_metric_registry())
+        result = engine.evaluate((), "x", "x")
+        assert result.metric_values == {}
+        assert result.failed_metrics == {}
+        assert result.all_succeeded is True
+
+
+class TestEvaluationResultDataclass:
+    def test_with_global_failure_marks_all(self) -> None:
+        engine = EvaluationEngine(_build_metric_registry())
+        result = engine.evaluate(("cer", "wer"), "x", "x")
+        failed_all = result.with_global_failure("loader crashed")
+        assert failed_all.metric_values == {}
+        assert failed_all.failed_metrics == {
+            "cer": "loader crashed",
+            "wer": "loader crashed",
+        }
+
+    def test_dataclass_is_frozen(self) -> None:
+        result = EvaluationResult(metric_values={"cer": 0.0})
+        with pytest.raises(Exception):  # FrozenInstanceError
+            result.metric_values = {}  # type: ignore[misc]
+
+
+# ──────────────────────────────────────────────────────────────────────
+# ProjectionResult dataclass
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestProjectionResultDataclass:
+    def test_has_projection_property(self) -> None:
+        artifact = Artifact(id="a", document_id="d", type=ArtifactType.RAW_TEXT)
+        no_proj = ProjectionResult(artifact=artifact, payload=None, report=None)
+        assert no_proj.has_projection is False
+
+        report = ProjectionReport(
+            source_artifact_id="a",
+            source_type=ArtifactType.ALTO_XML,
+            target_type=ArtifactType.RAW_TEXT,
+            projector_name="x",
+        )
+        with_proj = ProjectionResult(
+            artifact=artifact, payload="text", report=report,
+        )
+        assert with_proj.has_projection is True
+
+    def test_dataclass_is_frozen(self) -> None:
+        artifact = Artifact(id="a", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = ProjectionResult(artifact=artifact, payload=None, report=None)
+        with pytest.raises(Exception):  # FrozenInstanceError
+            result.payload = "modified"  # type: ignore[misc]

tests/evaluation/views/test_sprint_a14_s14_text_view.py

@@ -101,7 +101,7 @@ def _build_executor(payloads: dict[str, object]) -> DefaultEvaluationViewExecuto
             raise KeyError(f"payload manquant : {artifact.id}")
         return payloads[artifact.id]
 
-    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+    return DefaultEvaluationViewExecutor.from_registries(metrics, projectors, loader)
 
 
 # ──────────────────────────────────────────────────────────────────────
@@ -285,7 +285,9 @@ class TestBnFCentralUseCase:
         projectors.register(AltoToText())
         projectors.register(PageToText())
         projectors.register(CanonicalToText())
-        executor = DefaultEvaluationViewExecutor(metrics, projectors, loader)
+        executor = DefaultEvaluationViewExecutor.from_registries(
+            metrics, projectors, loader,
+        )
         view = build_text_view()
 
         gt = Artifact(id="gt_text", document_id="bnf_doc",

tests/evaluation/views/test_sprint_a14_s15_alto_view.py

@@ -187,7 +187,7 @@ def _build_alto_executor(payloads: dict[str, AltoDocument]) -> DefaultEvaluation
             raise KeyError(f"missing payload {art.id}")
         return payloads[art.id]
 
-    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+    return DefaultEvaluationViewExecutor.from_registries(metrics, projectors, loader)
 
 
 class TestAltoViewWithExecutor:

tests/evaluation/views/test_sprint_a14_s16_search_view.py

@@ -188,7 +188,7 @@ def _build_search_executor(payloads: dict[str, str]) -> DefaultEvaluationViewExe
             raise KeyError(art.id)
         return payloads[art.id]
 
-    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+    return DefaultEvaluationViewExecutor.from_registries(metrics, projectors, loader)
 
 
 class TestSearchViewWithExecutor:

tests/integration/test_sprint_a14_s17_full_run.py

@@ -275,7 +275,9 @@ def _build_service(tmp_path: Path) -> tuple[BenchmarkService, dict[str, Path]]:
             return parse_alto(Path(art.uri).read_bytes())
         raise KeyError(f"loader ne sait pas charger {art.id} (type {art.type})")
 
-    view_executor = DefaultEvaluationViewExecutor(metrics, projectors, loader)
+    view_executor = DefaultEvaluationViewExecutor.from_registries(
+        metrics, projectors, loader,
+    )
 
     # Pipeline executor + corpus runner.
     registry_adapters = {

tests/integration/test_sprint_a14_s18_bnf_e2e.py

@@ -368,7 +368,9 @@ def _build_service(tmp_path: Path) -> tuple[BenchmarkService, dict[str, Path]]:
             return _CORRECTED_TEXTS[art.document_id]
         raise KeyError(f"loader: type non géré pour {art.id} ({art.type})")
 
-    view_executor = DefaultEvaluationViewExecutor(metrics, projectors, loader)
+    view_executor = DefaultEvaluationViewExecutor.from_registries(
+        metrics, projectors, loader,
+    )
 
     registry_adapters = {
         "simple_ocr": _SimpleOCRStub(),

tests/integration/test_sprint_a14_s21_report_service.py

@@ -266,7 +266,7 @@ class TestPersistenceRoundTrip:
         from picarones.evaluation.views import DefaultEvaluationViewExecutor
         from picarones.pipeline import CorpusRunner, PipelineExecutor
         loader = lambda art: ""  # noqa: E731 — non appelé par persist
-        view_executor = DefaultEvaluationViewExecutor(
+        view_executor = DefaultEvaluationViewExecutor.from_registries(
             MetricRegistry(), ProjectorRegistry(), loader,
         )
         runner = CorpusRunner(
@@ -296,7 +296,7 @@ class TestPersistenceRoundTrip:
         from picarones.evaluation.views import DefaultEvaluationViewExecutor
         from picarones.pipeline import CorpusRunner, PipelineExecutor
         loader = lambda art: ""  # noqa: E731
-        view_executor = DefaultEvaluationViewExecutor(
+        view_executor = DefaultEvaluationViewExecutor.from_registries(
             MetricRegistry(), ProjectorRegistry(), loader,
         )
         runner = CorpusRunner(

tests/integration/test_sprint_a14_s23_registry_service.py

@@ -280,7 +280,7 @@ class TestSmokeIntegration:
         svc = RegistryService.bootstrap_defaults()
 
         loader = lambda art: ""  # noqa: E731 — non appelé ici
-        executor = DefaultEvaluationViewExecutor(
+        executor = DefaultEvaluationViewExecutor.from_registries(
             svc.metrics, svc.projectors, loader,
         )
         assert executor is not None  # si le constructeur passe, c'est OK