phaseB: extras/historical/ — 8 modules philologiques + 2 renderers en Cercle 3

Deuxième phase de la refonte en 3 cercles. Cible : extraire les
métriques philologiques (cas d'usage patrimoniaux par période) du
cœur ``core/`` vers le sous-package ``extras/historical/``.

Modules déplacés (8 modules, ~3000 lignes)
------------------------------------------
``picarones/extras/historical/`` :
- ``unicode_blocks.py`` précision par bloc Unicode (toutes périodes)
- ``abbreviations.py`` score d'expansion (Capelli, médiéval)
- ``mufi.py`` couverture MUFI v4.0 (médiéval, PUA)
- ``early_modern_typography.py`` fl fi ſ ã & ı (XVIᵉ-XVIIIᵉ)
- ``modern_archives.py`` Mme/Mlle/°/†/₶ (XIXᵉ-XXᵉ)
- ``roman_numerals.py`` numéraux romains (toutes périodes)
- ``lexical_modernization.py`` top tokens GT modernisés
- ``philological_runner.py`` orchestration adaptive des 6 modules

Renderers (2 fichiers, ~700 lignes)
-----------------------------------
``picarones/extras/render/`` :
- ``philological_render.py`` profil philologique 6 sections
- ``lexical_modernization_render.py`` table top tokens

Rétrocompatibilité absolue (10 shims de 16 lignes)
---------------------------------------------------
Imports historiques préservés :
from picarones.core.unicode_blocks import compute_unicode_block_accuracy
from picarones.core.philological_runner import compute_philological_metrics
from picarones.report.philological_render import build_philological_profile_html

L'identité est préservée — ``shim.X is extras.X`` (test ``is``
vérifié), pas de duplication de logique.

Dépendance Cercle 2 → Cercle 3 (note architecturale)
-----------------------------------------------------
``picarones/core/numerical_sequences.py`` (Cercle 2 — measurements/)
importe ``roman_numerals`` (Cercle 3 — extras/historical/) pour
détecter les numéraux romains dans les séquences numériques. Cette
dépendance traverse le shim et fonctionne. Acceptée car :

- ``numerical_sequences`` est lui-même semi-historique (détecte
dates anciennes, foliotation archivistique).
- Le shim assure la rétrocompat sans coût d'exécution.
- Si on extrait ``picarones-historical`` en package PyPI séparé un
jour, on devra rendre cette dépendance optionnelle (try/except).

pyproject.toml — extra [historical] documenté
---------------------------------------------
Nouvel extra ``picarones[historical]`` déclaré (vide pour l'instant
— les modules sont dans le package principal). Documente l'intention
de séparation future en package PyPI distinct. Inclus dans l'extra
``[all]``.

Validation 8/8 en sandbox
-------------------------
- 10 imports rétrocompat OK (8 core + 2 render).
- Identité shim ↔ nouveau chemin préservée (3 paires testées).
- ``philological_runner`` détecte 5 modules de signal sur texte
médiéval test (⁊ par leſ XIV. fontoyers) : unicode_blocks,
abbreviations, mufi, early_modern, roman_numerals.
- Dépendance Cercle 2→3 (``numerical_sequences`` → ``roman_numerals``
via shim) : score strict 1.00 sur "Le roi Louis XIV régna jusqu'en 1715".
- Hook ``philological`` toujours présent dans les 12 hooks doc
enregistrés par ``builtin_hooks``.
- pyproject.toml : extra ``[historical]`` documenté.
- 10 shims minces (16 lignes chacun, pas de logique métier).
- Vue ``advanced_taxonomy`` du chantier 3 fonctionne avec
``lexical_modernization`` opt-in (5359 chars produits).

Tests
-----
+250 lignes dans tests/test_phaseB_migration.py organisés en 8 classes :
TestPhilologicalRetrocompat, TestNewHistoricalImports,
TestIdentityThroughShim, TestPhilologicalRunnerIntegration,
TestCercle2DependsOnCercle3ViaShim, TestPyprojectExtra,
TestBuiltinHooksStillRegisterPhilological, TestOriginalsAreShims.

Bilan cumulé phases A + B
-------------------------
- Cercle 3 contient maintenant 18 modules + 6 renderers.
- ``core/`` allégé de 12 modules (4 phase A + 8 phase B).
- ``report/`` allégé de 6 renderers (4 phase A + 2 phase B).
- Aucune ligne de fonctionnalité supprimée.

Phases suivantes
----------------
- Phase C : extras/importers/ (3-5 jours).
- Phase E : core/ → core/ (Cercle 1) + measurements/ (Cercle 2).
- Phase D : docs/api-stable.md + test_public_api.py + version 2.0.

picarones/core/abbreviations.py

@@ -1,350 +1,17 @@
-"""Score d'expansion d'abréviations médiévales — Sprint 56.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.abbreviations`.
 
-Sprint 56 — A.II.3.2 du plan d'évolution 2026 (axe philologique).
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.core.abbreviations
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-Sur les manuscrits médiévaux (chartes, registres, copies de droit
-canonique), les scribes utilisent intensivement des **signes
-d'abréviation** : ``ꝑ`` (per/par), ``ꝓ`` (pro), ``ꝗ`` (qui),
-``ꝙ`` (quia), ``ꝯ`` (con/-us), ``⁊`` (et), tilde combinant pour
-``-en/-an``, etc.
-
-Un OCR/HTR a deux comportements possibles face à ces signes :
-
-1. **Préservation** : la forme abrégée est gardée telle quelle
-   (``ꝑ`` → ``ꝑ``).  C'est le comportement attendu d'une
-   transcription **diplomatique** (édition critique).
-2. **Développement** : le signe est remplacé par sa forme
-   développée (``ꝑ`` → ``per``).  C'est le comportement attendu
-   d'une édition **modernisée**.
-
-Une troisième possibilité — et c'est l'erreur qu'on cherche à
-détecter : le signe est **mal restitué** (remplacé par un
-caractère ASCII proche, supprimé, ou mal développé).
-
-Ce module produit deux scores complémentaires :
-
-- ``abbreviation_strict_score`` : taux d'abréviations GT dont la
-  **forme abrégée Unicode est préservée** dans l'OCR.
-- ``abbreviation_expansion_score`` : taux d'abréviations GT dont
-  **soit** la forme abrégée, **soit** la forme développée
-  attendue, est présente dans l'OCR.
-
-Le **ratio** des deux dit beaucoup sur la convention adoptée :
-
-- ``strict ≈ expansion`` proche de 1 → le moteur est diplomatique
-  (préserve l'abrégé) ;
-- ``strict << expansion`` → le moteur est modernisant (développe
-  systématiquement) ;
-- les deux faibles → le moteur perd les abréviations (signal
-  d'erreur OCR).
-
-Stratégie de découpage
-----------------------
-Cohérente avec NER (Sprint 38), Flesch (52), Reading order F1 (53),
-Layout F1 (54), Bloc Unicode (55) : couche de calcul pure d'abord.
-Le câblage runner et la vue HTML suivent dans des sprints dédiés.
-
-Limites documentées
--------------------
-- L'alignement est **bag-of-occurrences** (proxy positionnel
-  simple) : on compte les occurrences GT et on vérifie leur
-  présence dans l'hyp.  Pas d'alignement séquentiel rigoureux.
-- La table d'abréviations couvre les signes les plus courants en
-  scriptura latine européenne (Capelli).  Elle est extensible via
-  ``ABBREVIATION_EXPANSIONS``.
-- Pour les abréviations marquées par un **tilde combinant**
-  (``p̃``, ``q̃``), on détecte la séquence ``lettre + U+0303``.
-  Pas de gestion fine des polices Capelli/MUFI complètes.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-import logging
-import re
-import unicodedata
-from typing import Optional
-
-from picarones.core.metric_registry import register_metric
-from picarones.core.modules import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Table d'expansions
-# ──────────────────────────────────────────────────────────────────────────
-
-# Signes d'abréviation latins médiévaux les plus courants.
-# Source : Capelli, "Lexicon Abbreviaturarum" (1929) + MUFI.
-#
-# La clé est une chaîne (1 ou 2 code-points pour le cas tilde
-# combinant) ; la valeur est la liste des expansions courantes
-# acceptées (les détails varient selon la convention éditoriale,
-# on accepte plusieurs formes).
-ABBREVIATION_EXPANSIONS: dict[str, tuple[str, ...]] = {
-    "ꝑ": ("per", "par"),                       # U+A751
-    "ꝓ": ("pro",),                              # U+A753
-    "ꝗ": ("qui",),                              # U+A757
-    "ꝙ": ("quia",),                             # U+A759
-    "ꝯ": ("us", "con"),                         # U+A76F
-    "⁊": ("et",),                               # U+204A "et" tironien
-    "ꝝ": ("rum",),                              # U+A75D
-    "ꝫ": ("et",),                               # U+A76B
-    "ꝭ": ("is",),                               # U+A76D
-    # Tilde combinant après lettre (U+0303 = ̃) : pẽ, qũ, etc.
-    "p̃": ("par", "per"),
-    "q̃": ("que", "qui"),
-    "ñ": ("an", "en"),                          # U+00F1 (Latin-1 Sup)
-    # Note : ñ existe aussi comme caractère latin moderne (espagnol),
-    # donc l'attribuer aux abréviations introduit du bruit ; on
-    # laisse au benchmark le soin d'évaluer.  Pour les éditeurs
-    # médiévistes qui veulent restreindre, ils peuvent passer par
-    # une table custom (à venir).
-}
-
-
-# Set des "premiers code-points" reconnus comme début d'une
-# abréviation (pour balayage rapide).
-_ABBR_FIRST_CHARS: frozenset[str] = frozenset(
-    abbr[0] for abbr in ABBREVIATION_EXPANSIONS
-)
-
-
-# Combining tilde (U+0303) — utilisé pour la détection p̃, q̃, etc.
-_COMBINING_TILDE = "̃"
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Détection d'abréviations dans un texte
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def detect_abbreviations(text: Optional[str]) -> list[str]:
-    """Liste des abréviations médiévales détectées dans ``text``,
-    dans l'ordre d'apparition.
-
-    Reconnaît :
-
-    - Les caractères Unicode dédiés présents dans
-      ``ABBREVIATION_EXPANSIONS`` (``ꝑ``, ``ꝓ``, ``⁊``…).
-    - Les séquences ``lettre + U+0303`` (tilde combinant) si la
-      paire est dans la table (``p̃``, ``q̃``).
-
-    Doublons conservés : si le texte contient deux ``ꝑ``, la liste
-    en a deux.  Cohérent avec le calcul bag-of-occurrences en aval.
-    """
-    if not text:
-        return []
-    found: list[str] = []
-    # Forme NFD pour reconnaître les ã, p̃, q̃ même quand l'utilisateur
-    # passe la forme NFC (« ñ » = U+00F1 sera traité par le mapping
-    # direct ; les séquences manuelles ``p`` + tilde combinant restent
-    # détectables).
-    text_nfd = unicodedata.normalize("NFD", text)
-    i = 0
-    while i < len(text_nfd):
-        ch = text_nfd[i]
-        # Cas 1 : lettre + tilde combinant
-        if i + 1 < len(text_nfd) and text_nfd[i + 1] == _COMBINING_TILDE:
-            seq = ch + _COMBINING_TILDE
-            if seq in ABBREVIATION_EXPANSIONS:
-                found.append(seq)
-                i += 2
-                continue
-        # Cas 2 : caractère unicode dédié
-        if ch in ABBREVIATION_EXPANSIONS:
-            found.append(ch)
-        i += 1
-    return found
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Scores
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _hyp_contains_abbr(hypothesis: str, abbr: str) -> bool:
-    """Vrai si la forme abrégée ``abbr`` apparaît telle quelle dans
-    ``hypothesis``.  Sensible aux deux formes NFC / NFD pour les
-    séquences à tilde combinant."""
-    if abbr in hypothesis:
-        return True
-    # Pour les séquences ``lettre + tilde combinant``, l'hyp peut
-    # avoir une forme NFC (ex. ``ñ`` au lieu de ``n + U+0303``).
-    nfd = unicodedata.normalize("NFD", hypothesis)
-    return abbr in nfd
-
-
-def _hyp_contains_expansion(
-    hypothesis: str, expansions: tuple[str, ...],
-) -> bool:
-    """Vrai si l'une des formes développées apparaît dans ``hypothesis``
-    (recherche insensible à la casse, sur les frontières de mots
-    pour limiter les faux positifs sur les sous-chaînes courtes
-    type ``us`` ou ``et``)."""
-    if not expansions:
-        return False
-    hyp_lower = hypothesis.lower()
-    for exp in expansions:
-        if not exp:
-            continue
-        # Recherche frontière de mot pour les expansions courtes.
-        # Pour ``per`` ou ``pro`` : on accepte le développement à
-        # n'importe quelle position d'un mot (tolère ``per`` dans
-        # ``permettre``, c'est imprécis mais pragmatique).  Pour
-        # les expansions très courtes (≤ 2 lettres), on impose un
-        # mot complet pour limiter le bruit.
-        if len(exp) <= 2:
-            if re.search(rf"\b{re.escape(exp)}\b", hyp_lower):
-                return True
-        else:
-            if exp.lower() in hyp_lower:
-                return True
-    return False
-
-
-def compute_abbreviation_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> dict:
-    """Calcule les scores d'abréviation strict et d'expansion.
-
-    Parameters
-    ----------
-    reference:
-        Texte GT (avec abréviations médiévales originales).
-    hypothesis:
-        Texte produit par l'OCR.
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_abbreviations_in_reference": int,
-            "n_strict_preserved":   int,    # forme abrégée préservée
-            "n_expansion_preserved": int,    # abrégée OU développée
-            "strict_score":   float,         # ∈ [0, 1]
-            "expansion_score": float,        # ∈ [0, 1]
-            "per_abbreviation": [
-                {"abbr", "strict_preserved", "expansion_preserved",
-                 "expansions"},
-                ...
-            ],
-        }``
-
-    Cas dégénérés
-    -------------
-    - GT vide ou sans abréviation détectée → tous les compteurs à 0
-      et les scores à ``0.0`` (convention : on ne récompense pas
-      l'absence d'abréviations).
-    - GT non vide avec abréviations + hyp vide → tous les scores
-      à ``0.0``.
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-
-    abbreviations = detect_abbreviations(ref)
-    n = len(abbreviations)
-    if n == 0:
-        return {
-            "n_abbreviations_in_reference": 0,
-            "n_strict_preserved": 0,
-            "n_expansion_preserved": 0,
-            "strict_score": 0.0,
-            "expansion_score": 0.0,
-            "per_abbreviation": [],
-        }
-
-    n_strict = 0
-    n_expansion = 0
-    per_abbr: list[dict] = []
-    for abbr in abbreviations:
-        expansions = ABBREVIATION_EXPANSIONS.get(abbr, ())
-        strict_ok = _hyp_contains_abbr(hyp, abbr)
-        # Expansion : on accepte la forme abrégée OU le développement.
-        # Convention : si l'OCR a préservé la forme abrégée, c'est
-        # aussi compté comme valide pour le score d'expansion (le
-        # moteur n'a pas perdu l'information ; il a juste choisi
-        # une convention diplomatique).
-        expansion_ok = strict_ok or _hyp_contains_expansion(hyp, expansions)
-        if strict_ok:
-            n_strict += 1
-        if expansion_ok:
-            n_expansion += 1
-        per_abbr.append({
-            "abbr": abbr,
-            "strict_preserved": strict_ok,
-            "expansion_preserved": expansion_ok,
-            "expansions": list(expansions),
-        })
-
-    return {
-        "n_abbreviations_in_reference": n,
-        "n_strict_preserved": n_strict,
-        "n_expansion_preserved": n_expansion,
-        "strict_score": n_strict / n,
-        "expansion_score": n_expansion / n,
-        "per_abbreviation": per_abbr,
-    }
-
-
-def abbreviation_strict_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux de préservation **stricte** des abréviations
-    Unicode (forme abrégée gardée telle quelle)."""
-    return compute_abbreviation_metrics(reference, hypothesis)["strict_score"]
-
-
-def abbreviation_expansion_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux de préservation par expansion (forme abrégée
-    OU forme développée présente dans l'hyp)."""
-    return compute_abbreviation_metrics(reference, hypothesis)["expansion_score"]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="abbreviation_strict_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux d'abréviations médiévales (Unicode dédié + lettre + "
-        "tilde combinant) dont la forme abrégée est préservée telle "
-        "quelle dans l'OCR. Idéal pour les éditions diplomatiques."
-    ),
-    higher_is_better=True,
-    tags={"text", "abbreviation", "philology", "medieval"},
-)
-def _registered_strict(reference: str, hypothesis: str) -> float:
-    return abbreviation_strict_score(reference, hypothesis)
-
-
-@register_metric(
-    name="abbreviation_expansion_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux d'abréviations dont SOIT la forme abrégée Unicode SOIT "
-        "la forme développée attendue (per, pro, et…) est présente "
-        "dans l'OCR. Score plus large que strict_score."
-    ),
-    higher_is_better=True,
-    tags={"text", "abbreviation", "philology", "medieval"},
-)
-def _registered_expansion(reference: str, hypothesis: str) -> float:
-    return abbreviation_expansion_score(reference, hypothesis)
-
+from picarones.extras.historical.abbreviations import *  # noqa: F401, F403
 
-__all__ = [
-    "ABBREVIATION_EXPANSIONS",
-    "detect_abbreviations",
-    "compute_abbreviation_metrics",
-    "abbreviation_strict_score",
-    "abbreviation_expansion_score",
-]
+import picarones.extras.historical.abbreviations as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/early_modern_typography.py

@@ -1,342 +1,17 @@
-"""Marqueurs typographiques de l'imprimé ancien (XVIᵉ-XVIIIᵉ).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.early_modern_typography`.
 
-Sprint 58 — Étape 3 / extension philologique du plan d'évolution
-2026.
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.core.early_modern_typography
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-Les Sprints 56 (abréviations Capelli) et 57 (couverture MUFI) sont
-orientés **médiéval scribal**.  Mais Picarones doit aussi servir
-les éditeurs d'**imprimés anciens** (XVIᵉ-XVIIIᵉ siècles), pour
-qui les marqueurs caractéristiques ne sont pas scribaux mais
-**typographiques** : ligatures composées (fi, fl, ff, ffi, ffl, ſt),
-s long (ſ), i sans point (ı), esperluette (&), tildes nasaux
-indiquant une abréviation (ã = an/am, õ = on/om).
-
-Distinction avec MUFI/abbreviations
-------------------------------------
-- ``mufi.py`` (Sprint 57) : caractères médiévaux scribaux
-  (Capelli + lettres þ ð ƿ + PUA MUFI).
-- ``abbreviations.py`` (Sprint 56) : signes d'abréviation latins
-  scribaux médiévaux (ꝑ ꝓ ⁊ + tildes scribaux).
-- ``early_modern_typography.py`` (ce module) : marqueurs
-  **typographiques** de la composition imprimée ancienne.
-
-Les ligatures fi et fl sont communes aux deux univers (médiéval et
-imprimé ancien) ; le choix du module à utiliser dépend du **corpus**
-et de l'angle d'analyse éditoriale, pas du caractère pris isolément.
-
-Catégorisation
---------------
-Les marqueurs sont classés en cinq catégories pour permettre un
-breakdown éditorial :
-
-1. ``ligatures`` : fi fl ff ffi ffl ſt
-2. ``long_s`` : ſ
-3. ``dotless_i`` : ı
-4. ``ampersand`` : & (esperluette typographique)
-5. ``nasal_tildes`` : ã õ ũ ñ ē ī (abréviation par tilde nasal)
-
-``compute_early_modern_metrics`` retourne le taux de préservation
-par catégorie + global.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-import logging
-from difflib import SequenceMatcher
-from typing import Optional
-
-from picarones.core.metric_registry import register_metric
-from picarones.core.modules import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Marqueurs typographiques imprimé ancien
-# ──────────────────────────────────────────────────────────────────────────
-
-# Ligatures typographiques héritées de l'incunable (XVᵉ) et toujours
-# courantes jusqu'au XVIIIᵉ avant la normalisation typographique.
-LIGATURES: frozenset[str] = frozenset({
-    "ff",  # U+FB00 ff
-    "fi",  # U+FB01 fi
-    "fl",  # U+FB02 fl
-    "ffi",  # U+FB03 ffi
-    "ffl",  # U+FB04 ffl
-    "ſt",  # U+FB05 long s + t
-    "st",  # U+FB06 st
-})
-
-# S long : Latin Extended-A.  Caractéristique de la typographie
-# antérieure à 1800.
-LONG_S: frozenset[str] = frozenset({"ſ"})  # U+017F
-
-# i sans point : utilisé en typographie ancienne, parfois confondu
-# avec un l ou un 1 par les OCR modernes.
-DOTLESS_I: frozenset[str] = frozenset({"ı"})  # U+0131
-
-# Esperluette typographique : "&" remplace fréquemment "et" dans
-# les imprimés ; sa préservation discrimine un OCR diplomatique
-# d'un OCR modernisant.
-AMPERSAND: frozenset[str] = frozenset({"&"})
-
-# Tildes nasaux : pré-composés (ñ ã ẽ ĩ õ ũ) ou séquences
-# lettre + U+0303 combinant.  En imprimé ancien, ã = an/am abrégé,
-# õ = on/om, etc.  Distinction avec les tildes scribaux médiévaux
-# (Sprint 56) : ici on cible les **pré-composés** ou séquences sur
-# des voyelles (le scribal médiéval cible plutôt p̃ q̃).
-NASAL_TILDE_PRECOMPOSED: frozenset[str] = frozenset({
-    "ã", "Ã",  # U+00E3 / U+00C3
-    "ñ", "Ñ",  # U+00F1 / U+00D1
-    "õ", "Õ",  # U+00F5 / U+00D5
-    "ũ", "Ũ",  # U+0169 / U+0168
-    "ẽ", "Ẽ",  # U+1EBD / U+1EBC
-    "ĩ", "Ĩ",  # U+0129 / U+0128
-})
-
-# Voyelles susceptibles de porter un tilde combinant pour former
-# un tilde nasal (couvre les écritures NFD non pré-composées).
-_NASAL_TILDE_VOWELS: frozenset[str] = frozenset(
-    "aeiouAEIOU"
-)
-_COMBINING_TILDE = "̃"
-
-
-# Catégorisation : nom → set de caractères pré-composés ou séquences.
-_CATEGORIES: dict[str, frozenset[str]] = {
-    "ligatures": LIGATURES,
-    "long_s": LONG_S,
-    "dotless_i": DOTLESS_I,
-    "ampersand": AMPERSAND,
-    "nasal_tildes": NASAL_TILDE_PRECOMPOSED,
-}
-
-
-# ─────────────���────────────────────────────────────────────────────────────
-# Détection des marqueurs dans la GT
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _detect_markers(text: str) -> list[tuple[int, str, str]]:
-    """Retourne les positions des marqueurs typographiques dans
-    ``text``.
-
-    Forme de sortie : ``[(index, marker, category), ...]`` dans
-    l'ordre d'apparition.  Pour les tildes nasaux non
-    pré-composés, on détecte les séquences ``voyelle + U+0303`` et
-    on retourne l'index de la voyelle.
-    """
-    if not text:
-        return []
-    found: list[tuple[int, str, str]] = []
-    i = 0
-    while i < len(text):
-        ch = text[i]
-        # Cas 1 : marqueur pré-composé dans une catégorie
-        category = _category_of_char(ch)
-        if category is not None:
-            found.append((i, ch, category))
-            i += 1
-            continue
-        # Cas 2 : voyelle + tilde combinant → nasal_tildes
-        if (
-            ch in _NASAL_TILDE_VOWELS
-            and i + 1 < len(text)
-            and text[i + 1] == _COMBINING_TILDE
-        ):
-            seq = ch + _COMBINING_TILDE
-            found.append((i, seq, "nasal_tildes"))
-            i += 2
-            continue
-        i += 1
-    return found
-
-
-def _category_of_char(ch: str) -> Optional[str]:
-    """Retourne la catégorie d'un caractère typographique ou
-    ``None`` s'il n'est pas reconnu."""
-    for cat, chars in _CATEGORIES.items():
-        if ch in chars:
-            return cat
-    return None
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul de la préservation par catégorie
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_early_modern_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> dict:
-    """Mesure la préservation des marqueurs typographiques de
-    l'imprimé ancien dans l'OCR.
-
-    Stratégie d'alignement
-    ----------------------
-    Pour chaque marqueur identifié dans la GT à la position ``i``,
-    on vérifie si l'OCR l'a préservé en utilisant l'alignement
-    caractère par caractère via ``difflib.SequenceMatcher`` (même
-    méthode que les Sprints 55/57) :
-
-    - Marqueur **mono-caractère** (fi, ſ, ı, &, ã…) : la position
-      ``i`` est-elle dans un opcode ``equal`` ?
-    - Marqueur **bi-caractère** (voyelle + U+0303) : les positions
-      ``i`` et ``i+1`` sont-elles toutes deux dans un opcode
-      ``equal`` ?
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_markers_reference":  int,
-            "n_markers_preserved":  int,
-            "global_preservation":  float,    # ∈ [0, 1]
-            "per_category": {
-                category: {"total", "preserved", "preservation"}
-            },
-            "missed_markers": [{"index", "marker", "category"}, ...],
-        }``
-
-    Cas dégénérés : GT vide ou sans marqueur → tous compteurs à 0,
-    ``global_preservation = 0``.
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-
-    # Forme NFD pour reconnaître les tildes nasaux décomposés (ã =
-    # 'a' + U+0303) côté GT — on conserve toutefois la forme passée
-    # pour les indices rapportés dans missed_markers.
-    markers = _detect_markers(ref)
-    n_total = len(markers)
-
-    if n_total == 0:
-        return {
-            "n_markers_reference": 0,
-            "n_markers_preserved": 0,
-            "global_preservation": 0.0,
-            "per_category": {},
-            "missed_markers": [],
-        }
-
-    # Aligner GT/hyp et récupérer le set des positions GT couvertes
-    # par un opcode "equal".
-    matcher = SequenceMatcher(a=ref, b=hyp, autojunk=False)
-    correct_positions: set[int] = set()
-    for op, i1, i2, _j1, _j2 in matcher.get_opcodes():
-        if op == "equal":
-            correct_positions.update(range(i1, i2))
-
-    per_cat_total: dict[str, int] = {}
-    per_cat_preserved: dict[str, int] = {}
-    n_preserved = 0
-    missed: list[dict] = []
-
-    for index, marker, category in markers:
-        per_cat_total[category] = per_cat_total.get(category, 0) + 1
-        # Marqueur préservé si toutes ses positions GT sont dans
-        # un opcode "equal".
-        marker_len = len(marker)
-        positions_ok = all(
-            (index + k) in correct_positions for k in range(marker_len)
-        )
-        if positions_ok:
-            per_cat_preserved[category] = (
-                per_cat_preserved.get(category, 0) + 1
-            )
-            n_preserved += 1
-        else:
-            missed.append({
-                "index": index,
-                "marker": marker,
-                "category": category,
-            })
-
-    per_category = {
-        cat: {
-            "total": per_cat_total[cat],
-            "preserved": per_cat_preserved.get(cat, 0),
-            "preservation": (
-                per_cat_preserved.get(cat, 0) / per_cat_total[cat]
-                if per_cat_total[cat] > 0
-                else 0.0
-            ),
-        }
-        for cat in sorted(per_cat_total)
-    }
-
-    return {
-        "n_markers_reference": n_total,
-        "n_markers_preserved": n_preserved,
-        "global_preservation": n_preserved / n_total,
-        "per_category": per_category,
-        "missed_markers": missed,
-    }
-
-
-def early_modern_preservation(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux global de préservation des marqueurs
-    typographiques de l'imprimé ancien."""
-    return compute_early_modern_metrics(
-        reference, hypothesis,
-    )["global_preservation"]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Helpers exposés
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def detect_markers(text: Optional[str]) -> list[tuple[int, str, str]]:
-    """Wrapper public sur ``_detect_markers`` (acceptant ``None``)."""
-    return _detect_markers(text or "")
-
-
-def get_category(char: str) -> Optional[str]:
-    """Retourne la catégorie typographique d'un caractère
-    (``ligatures``, ``long_s``, ``dotless_i``, ``ampersand``,
-    ``nasal_tildes``) ou ``None``.
-
-    Pour un tilde combinant suivi d'une voyelle, l'utilisateur doit
-    utiliser ``detect_markers`` qui gère les séquences.
-    """
-    return _category_of_char(char[0]) if char else None
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="early_modern_preservation",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de préservation des marqueurs typographiques de "
-        "l'imprimé ancien (XVIᵉ-XVIIIᵉ) : ligatures fi fl ff, s long ſ, "
-        "i sans point ı, esperluette &, tildes nasaux ã õ. Critère "
-        "éditorial pour les éditions diplomatiques d'imprimés anciens."
-    ),
-    higher_is_better=True,
-    tags={"text", "typography", "early_modern", "philology"},
-)
-def _registered_early_modern(reference: str, hypothesis: str) -> float:
-    return early_modern_preservation(reference, hypothesis)
-
+from picarones.extras.historical.early_modern_typography import *  # noqa: F401, F403
 
-__all__ = [
-    "LIGATURES",
-    "LONG_S",
-    "DOTLESS_I",
-    "AMPERSAND",
-    "NASAL_TILDE_PRECOMPOSED",
-    "detect_markers",
-    "get_category",
-    "compute_early_modern_metrics",
-    "early_modern_preservation",
-]
+import picarones.extras.historical.early_modern_typography as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/lexical_modernization.py

@@ -1,263 +1,17 @@
-"""Détection de la sur-normalisation lexicale par les LLM/VLM —
-Sprint 80 (A.I.7).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.lexical_modernization`.
 
-Sprint 80 — A.I.7 du plan d'évolution 2026.
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.core.lexical_modernization
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-Le détecteur ``llm_hallucination_flag`` (Sprint 19) signale qu'un
-moteur sur-normalise (« 0,05 % »).  Mais ce score agrégé ne dit
-rien sur **quoi** corriger dans le prompt.  Ce module produit
-une **table de fréquences détaillée** :
-
-+----------------------+--------------------+------+----------+
-| Forme historique GT  | Forme modernisée   | n GT | % modern |
-+======================+====================+======+==========+
-| maistre              | maître             |   47 |     85 % |
-| nostre               | nostre             |   92 |      8 % |
-| veoir                | voir               |   23 |    100 % |
-+----------------------+--------------------+------+----------+
-
-Lecture immédiate : *« le LLM modernise systématiquement
-maistre → maître ; pour préserver l'orthographe historique, ajouter
-au prompt "ne pas moderniser maistre, nostre, veoir" »*.
-
-Méthode
--------
-Alignement mot-à-mot via ``difflib.SequenceMatcher``.  Chaque
-``replace`` ou ``equal`` produit une paire ``(gt_token,
-hyp_token)``.  On accumule pour chaque ``gt_token`` :
-
-- ``n_total`` : nombre d'occurrences du token dans la GT
-- ``n_modernized`` : nombre d'occurrences où ``hyp_token != gt_token``
-- ``variants`` : dict des hyp_tokens observés avec leur count
-
-Stop-list
----------
-L'utilisateur peut passer ``stop_list`` (ensemble de tokens GT à
-ignorer).  Par défaut, vide — le module ne tente pas de deviner ce
-qui est « moderne » ou « historique », c'est au chercheur de
-fournir le filtre adapté à son corpus.
-
-Sortie
-------
-``compute_lexical_modernization`` retourne une structure adaptée
-au rendu HTML.  ``aggregate_lexical_modernization`` agrège
-plusieurs documents.
-
-Limites documentées
--------------------
-- Tokenisation au niveau mot (split sur espace) — cohérent avec
-  ``taxonomy.py`` et autres modules.  Pas de stemming ni de
-  lemmatisation.
-- La métrique mesure la **réécriture lexicale** ; elle n'attrape
-  pas les modernisations infra-mot (perte du s long ſ qui se
-  fond dans la même forme).  Pour ça, voir ``early_modern_typography``
-  (Sprint 58) et ``equivalence_profile`` (Sprint 78).
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-import difflib
-import logging
-from typing import Iterable, Optional
-
-logger = logging.getLogger(__name__)
-
-
-def _split_words(text: Optional[str]) -> list[str]:
-    """Tokenisation simple par split sur whitespace."""
-    if not text:
-        return []
-    return text.split()
-
-
-def compute_lexical_modernization(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    *,
-    stop_list: Optional[Iterable[str]] = None,
-    case_sensitive: bool = False,
-) -> dict:
-    """Calcule le tableau de modernisation lexicale pour un document.
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_gt_tokens": int,
-            "tokens": {
-                gt_token: {
-                    "n_total": int,
-                    "n_modernized": int,
-                    "rate_modernized": float,  # ∈ [0, 1]
-                    "variants": {hyp_token: count, ...},
-                },
-                ...
-            },
-        }``
-        Si ``reference`` est vide → ``tokens == {}``.
-    """
-    ref_tokens = _split_words(reference)
-    hyp_tokens = _split_words(hypothesis)
-    if not ref_tokens:
-        return {"n_gt_tokens": 0, "tokens": {}}
-
-    if not case_sensitive:
-        ref_for_match = [t.lower() for t in ref_tokens]
-        hyp_for_match = [t.lower() for t in hyp_tokens]
-    else:
-        ref_for_match = ref_tokens
-        hyp_for_match = hyp_tokens
-
-    stop = frozenset(
-        (t.lower() if not case_sensitive else t)
-        for t in (stop_list or [])
-    )
-
-    # On accumule par gt_token (forme display = forme originale,
-    # match key = forme casée selon ``case_sensitive``).
-    tokens_data: dict[str, dict] = {}
-
-    matcher = difflib.SequenceMatcher(
-        None, ref_for_match, hyp_for_match, autojunk=False,
-    )
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-        if tag == "equal":
-            for k in range(i2 - i1):
-                gt_orig = ref_tokens[i1 + k]
-                gt_match = ref_for_match[i1 + k]
-                if gt_match in stop:
-                    continue
-                slot = tokens_data.setdefault(
-                    gt_orig,
-                    {"n_total": 0, "n_modernized": 0, "variants": {}},
-                )
-                slot["n_total"] += 1
-        elif tag == "replace":
-            # Apparier 1-à-1 quand possible
-            paired = min(i2 - i1, j2 - j1)
-            for k in range(paired):
-                gt_orig = ref_tokens[i1 + k]
-                gt_match = ref_for_match[i1 + k]
-                if gt_match in stop:
-                    continue
-                hyp_orig = hyp_tokens[j1 + k]
-                slot = tokens_data.setdefault(
-                    gt_orig,
-                    {"n_total": 0, "n_modernized": 0, "variants": {}},
-                )
-                slot["n_total"] += 1
-                slot["n_modernized"] += 1
-                slot["variants"][hyp_orig] = slot["variants"].get(hyp_orig, 0) + 1
-            # Si plus de gt que de hyp, le reste des gt_tokens est
-            # « perdu » — on les compte comme totaux mais pas comme
-            # modernisés (on ne sait pas en quoi).
-            for k in range(paired, i2 - i1):
-                gt_orig = ref_tokens[i1 + k]
-                gt_match = ref_for_match[i1 + k]
-                if gt_match in stop:
-                    continue
-                slot = tokens_data.setdefault(
-                    gt_orig,
-                    {"n_total": 0, "n_modernized": 0, "variants": {}},
-                )
-                slot["n_total"] += 1
-                slot["n_modernized"] += 1
-                slot["variants"]["∅"] = slot["variants"].get("∅", 0) + 1
-        elif tag == "delete":
-            # gt présent, pas en hyp → modernisation par
-            # suppression (ou perte pure)
-            for k in range(i2 - i1):
-                gt_orig = ref_tokens[i1 + k]
-                gt_match = ref_for_match[i1 + k]
-                if gt_match in stop:
-                    continue
-                slot = tokens_data.setdefault(
-                    gt_orig,
-                    {"n_total": 0, "n_modernized": 0, "variants": {}},
-                )
-                slot["n_total"] += 1
-                slot["n_modernized"] += 1
-                slot["variants"]["∅"] = slot["variants"].get("∅", 0) + 1
-
-    # Calcul du taux par token
-    for slot in tokens_data.values():
-        total = slot["n_total"]
-        slot["rate_modernized"] = (
-            slot["n_modernized"] / total if total > 0 else 0.0
-        )
-
-    return {
-        "n_gt_tokens": len(ref_tokens),
-        "tokens": tokens_data,
-    }
-
-
-def aggregate_lexical_modernization(
-    per_doc_results: Iterable[dict],
-) -> dict:
-    """Agrège des ``compute_lexical_modernization`` per-doc.
-
-    Renvoie la structure agrégée corpus-wide avec la même forme
-    que ``compute_lexical_modernization``.
-    """
-    agg_tokens: dict[str, dict] = {}
-    n_gt_total = 0
-    for doc_result in per_doc_results:
-        if not doc_result:
-            continue
-        n_gt_total += doc_result.get("n_gt_tokens", 0)
-        for gt, data in (doc_result.get("tokens") or {}).items():
-            slot = agg_tokens.setdefault(
-                gt, {"n_total": 0, "n_modernized": 0, "variants": {}},
-            )
-            slot["n_total"] += data.get("n_total", 0)
-            slot["n_modernized"] += data.get("n_modernized", 0)
-            for hyp_t, count in (data.get("variants") or {}).items():
-                slot["variants"][hyp_t] = slot["variants"].get(hyp_t, 0) + count
-
-    for slot in agg_tokens.values():
-        total = slot["n_total"]
-        slot["rate_modernized"] = (
-            slot["n_modernized"] / total if total > 0 else 0.0
-        )
-    return {
-        "n_gt_tokens": n_gt_total,
-        "tokens": agg_tokens,
-    }
-
-
-def top_modernized_tokens(
-    data: dict,
-    *,
-    n: int = 20,
-    min_total: int = 1,
-) -> list[tuple[str, dict]]:
-    """Top-N tokens GT par taux de modernisation.
-
-    Filtre les tokens dont ``n_total < min_total`` (anecdotiques).
-    Tri par ``rate_modernized`` décroissant, tie-break par
-    ``n_total`` décroissant.
-    """
-    tokens = data.get("tokens") or {}
-    candidates = [
-        (gt, slot) for gt, slot in tokens.items()
-        if slot.get("n_total", 0) >= min_total
-        and slot.get("n_modernized", 0) > 0
-    ]
-    candidates.sort(
-        key=lambda pair: (
-            -pair[1].get("rate_modernized", 0.0),
-            -pair[1].get("n_total", 0),
-            pair[0],
-        ),
-    )
-    return candidates[:n]
-
+from picarones.extras.historical.lexical_modernization import *  # noqa: F401, F403
 
-__all__ = [
-    "compute_lexical_modernization",
-    "aggregate_lexical_modernization",
-    "top_modernized_tokens",
-]
+import picarones.extras.historical.lexical_modernization as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/modern_archives.py

@@ -1,600 +1,17 @@
-"""Marqueurs typographiques et abréviations des archives modernes
-(XIXᵉ-XXᵉ siècles) — Sprint 59.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.modern_archives`.
 
-Sprint 59 — Étape 3 / extension philologique du plan d'évolution
-2026.
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.core.modern_archives
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-Les Sprints 56-57 sont orientés **médiéval scribal** (Capelli, MUFI),
-le Sprint 58 cible l'**imprimé ancien** XVIᵉ-XVIIIᵉ.  Ce sprint étend
-la couverture aux **archives modernes** (XIXᵉ-XXᵉ), période où la
-typographie historique a disparu mais où subsistent des conventions
-d'abréviation propres aux corpus institutionnels (état civil,
-recensements, presse, monographies, archives militaires).
-
-Distinction avec les modules précédents
----------------------------------------
-- ``mufi.py`` (Sprint 57) : caractères médiévaux scribaux.
-- ``abbreviations.py`` (Sprint 56) : signes scribaux médiévaux.
-- ``early_modern_typography.py`` (Sprint 58) : marqueurs
-  typographiques imprimé ancien (fi ſ ı &…).
-- ``modern_archives.py`` (ce module) : abréviations et conventions
-  de l'archive moderne XIXᵉ-XXᵉ.
-
-Catégories
-----------
-1. ``civility_titles`` : Mme, M., Mlle, Mgr, Dr, Pr, Me, R.P., S.M.,
-   S.A.R., S.E., S.S.
-2. ``ordinals`` : 1ᵉʳ, 1ʳᵉ, 2ᵉ, 2ᵈ, Vᵉ (avec exposants Unicode)
-3. ``currency`` : ₶ (livre tournois), ₣ ƒ (franc), £, l. s. d.
-   (livre/sol/denier d'Ancien Régime)
-4. ``administrative`` : arr., dép., cant., com., reg., prov.
-5. ``civil_status`` : °, †, ✶, ⚭, ép., vve
-6. ``typographic_punctuation`` : « », –, —, …, ’
-7. ``latin_abbr_modern`` : e.g., i.e., etc., cf., ibid., op. cit.,
-   ad lib.
-8. ``bibliographic`` : vol., t., p., pp., n°, fasc., éd., ms.,
-   r°, v°
-9. ``address`` : bd, av., r., pl., imp., fbg
-
-Sortie
-------
-``compute_modern_archives_metrics(ref, hyp)`` retourne deux scores
-par catégorie (pattern Sprint 56) :
-
-- ``strict_score`` : forme abrégée préservée telle quelle ;
-- ``expansion_score`` : forme abrégée OU forme développée présente.
-
-Le **ratio strict/expansion** par catégorie permet au chercheur de
-juger lui-même la convention adoptée par chaque moteur, sans
-classification automatique imposée par le module.
-
-Stratégie de découpage
-----------------------
-Cohérente avec NER (38), Flesch (52), Reading order F1 (53),
-Layout F1 (54), Bloc Unicode (55), Abréviations (56), MUFI (57),
-Imprimé ancien (58) : couche de calcul pure d'abord ; câblage
-runner et HTML dans des sprints dédiés.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-import logging
-import re
-from typing import Optional
-
-from picarones.core.metric_registry import register_metric
-from picarones.core.modules import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Tables d'abréviations par catégorie
-# ──────────────────────────────────────────────────────────────────────────
-#
-# Format : tuple ``(marker, expansions, regex_strict_pattern_or_None)``
-# où :
-#   - ``marker``                 : forme abrégée canonique (str)
-#   - ``expansions``             : tuple de formes développées
-#                                   acceptées (insensible à la casse)
-#   - ``regex_strict_pattern``   : pattern Python regex pour la
-#                                   détection dans la GT.  ``None``
-#                                   = on dérive automatiquement
-#                                   ``\b<marker_escaped>\b`` (avec
-#                                   garde-fou sur les abréviations
-#                                   contenant un point).
-#
-# Détection : pour les abréviations contenant un ``.`` (« M. »),
-# on n'utilise pas ``\b`` standard car « M.\b » match dans
-# « M.A. » (le ``.`` étant non-mot, ``\b`` est satisfait).  On
-# exige donc explicitement une frontière espace/début/fin/
-# ponctuation après le point.
-
-CIVILITY_TITLES: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("Mme",      ("Madame",)),
-    ("Mlle",     ("Mademoiselle",)),
-    ("Mgr",      ("Monseigneur",)),
-    ("Dr",       ("Docteur",)),
-    ("Pr",       ("Professeur",)),
-    ("Me",       ("Maître",)),
-    ("M.",       ("Monsieur",)),
-    ("R.P.",     ("Révérend Père",)),
-    ("S.M.",     ("Sa Majesté",)),
-    ("S.A.R.",   ("Son Altesse Royale",)),
-    ("S.E.",     ("Son Excellence",)),
-    ("S.S.",     ("Sa Sainteté",)),
-)
-
-# Ordinaux : la forme **strict** porte l'exposant Unicode
-# (1ᵉʳ U+1D49 U+02B3, 1ʳᵉ, 2ᵈ, 2ᵉ, 3ᵉ…) ; la forme **expansion**
-# accepte la version plate (« 1er », « 1re », « 2nd ») ou la forme
-# textuelle (« premier », « première »).
-#
-# On définit chaque ordinal explicitement (1-12 + Vᵉ pour les
-# numéraux romains de siècle).  Au-delà, l'exposant ᵉ seul couvre
-# les usages courants (3ᵉ, 4ᵉ, 5ᵉ, 6ᵉ, 7ᵉ, 8ᵉ, 9ᵉ, 10ᵉ).
-
-ORDINALS: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("1ᵉʳ",      ("1er", "premier")),
-    ("1ʳᵉ",      ("1re", "première", "premiere")),
-    ("2ᵈ",       ("2d", "second")),
-    ("2ᵈᵉ",      ("2de", "seconde")),
-    ("2ᵉ",       ("2e", "deuxième", "deuxieme")),
-    ("3ᵉ",       ("3e", "troisième", "troisieme")),
-    ("Iᵉʳ",      ("Ier", "premier")),
-    ("Vᵉ",       ("Ve", "cinquième", "cinquieme")),
-    ("XIᵉ",      ("XIe", "onzième", "onzieme")),
-    ("XIIᵉ",     ("XIIe", "douzième", "douzieme")),
-    ("XVIᵉ",     ("XVIe", "seizième", "seizieme")),
-    ("XVIIᵉ",    ("XVIIe", "dix-septième", "dix-septieme")),
-    ("XVIIIᵉ",   ("XVIIIe", "dix-huitième", "dix-huitieme")),
-    ("XIXᵉ",     ("XIXe", "dix-neuvième", "dix-neuvieme")),
-    ("XXᵉ",      ("XXe", "vingtième", "vingtieme")),
-)
-
-CURRENCY: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("₶",        ("livre tournois", "livres tournois")),
-    ("₣",        ("franc", "francs")),
-    ("ƒ",        ("florin", "florins")),
-    ("£",        ("livre", "livres", "pound", "pounds")),
-    ("l.",       ("livre", "livres")),
-    ("s.",       ("sol", "sols", "sou", "sous")),
-    ("d.",       ("denier", "deniers")),
-)
-
-ADMINISTRATIVE: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("arr.",     ("arrondissement",)),
-    ("dép.",     ("département", "departement")),
-    ("cant.",    ("canton",)),
-    ("com.",     ("commune",)),
-    ("reg.",     ("régiment", "regiment")),
-    ("prov.",    ("province",)),
-)
-
-# État civil : signes typographiques (° = né, † = mort, ⚭ = marié)
-# et abréviations textuelles (ép. = épouse/époux, vve = veuve).
-CIVIL_STATUS: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("°",        ("né", "née")),
-    ("†",        ("mort", "morte", "décédé", "décédée")),
-    ("✶",        ("naissance",)),
-    ("⚭",        ("marié", "mariée", "épousa", "epousa")),
-    ("ép.",      ("épouse", "époux", "epouse", "epoux")),
-    ("vve",      ("veuve",)),
-)
-
-# Ponctuation typographique : ces marqueurs sont préservés en
-# diplomatique et remplacés par leur équivalent ASCII en
-# modernisant.  L'expansion n'est pas une « expansion » au sens
-# linguistique mais un substitut typographique.
-TYPOGRAPHIC_PUNCTUATION: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("«",        ('"',)),
-    ("»",        ('"',)),
-    ("—",        ("-", "--")),
-    ("–",        ("-",)),
-    ("…",        ("...",)),
-    ("’",        ("'",)),
-    ("‘",        ("'",)),
-)
-
-LATIN_ABBR_MODERN: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("e.g.",     ("for example", "par exemple", "exempli gratia")),
-    ("i.e.",     ("c'est-à-dire", "id est", "that is")),
-    ("etc.",     ("et cetera", "et caetera")),
-    ("cf.",      ("confer", "voir")),
-    ("ibid.",    ("ibidem",)),
-    ("op. cit.", ("opere citato", "opus citatum")),
-    ("ad lib.",  ("ad libitum",)),
-    ("N.B.",     ("nota bene",)),
-)
-
-BIBLIOGRAPHIC: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("vol.",     ("volume",)),
-    ("t.",       ("tome",)),
-    ("p.",       ("page",)),
-    ("pp.",      ("pages",)),
-    ("n°",       ("numéro", "numero", "no")),
-    ("fasc.",    ("fascicule",)),
-    ("éd.",      ("édition", "edition")),
-    ("ms.",      ("manuscrit",)),
-    ("f.",       ("folio",)),
-    ("r°",       ("recto",)),
-    ("v°",       ("verso",)),
-)
-
-ADDRESS: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("bd",       ("boulevard",)),
-    ("av.",      ("avenue",)),
-    ("r.",       ("rue",)),
-    ("pl.",      ("place",)),
-    ("imp.",     ("impasse",)),
-    ("fbg",      ("faubourg",)),
-)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Indexation par catégorie
-# ──────────────────────────────────────────────────────────────────────────
-
-_CATEGORIES: dict[str, tuple[tuple[str, tuple[str, ...]], ...]] = {
-    "civility_titles":          CIVILITY_TITLES,
-    "ordinals":                 ORDINALS,
-    "currency":                 CURRENCY,
-    "administrative":           ADMINISTRATIVE,
-    "civil_status":             CIVIL_STATUS,
-    "typographic_punctuation":  TYPOGRAPHIC_PUNCTUATION,
-    "latin_abbr_modern":        LATIN_ABBR_MODERN,
-    "bibliographic":            BIBLIOGRAPHIC,
-    "address":                  ADDRESS,
-}
-
-# Liste plate de tous les marqueurs avec leur catégorie.  Triée par
-# longueur décroissante pour que la détection préfère le marqueur
-# le plus long quand plusieurs préfixes matchent (ex. « S.A.R. »
-# avant « S.A. ").
-_ALL_MARKERS: list[tuple[str, tuple[str, ...], str]] = sorted(
-    [
-        (marker, expansions, category)
-        for category, entries in _CATEGORIES.items()
-        for marker, expansions in entries
-    ],
-    key=lambda triple: -len(triple[0]),
-)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Compilation des patterns regex
-# ──────────────────────────────────────────────────────────────────────────
-#
-# Pour chaque marqueur, on compile un pattern qui exige une
-# frontière de mot adaptée :
-#
-# - Marqueur alphabétique seul (« Mme », « bd ») → ``\b<marker>\b``
-#   (le ``\b`` Python gère correctement les bords).
-# - Marqueur contenant un point (« M. », « S.A.R. », « arr. »,
-#   « r° », « n° ») → frontière espace/début/fin/ponctuation
-#   explicite (le ``.`` final étant non-mot, ``\b`` standard
-#   matcherait dans « arr.acher »).
-# - Marqueur contenant un caractère non ASCII (exposant, monnaie,
-#   guillemet, croix d'état civil) → match littéral, pas de
-#   frontière de mot car ``\b`` ne fonctionne pas sur les
-#   caractères non-mot Unicode.
-#
-# La frontière de droite après un point exige soit la fin de
-# chaîne, soit un blanc, soit une ponctuation usuelle (« , ; : ! ? )
-# … » »).
-
-_TRAILING_BOUNDARY = r"(?=$|[\s,;:!?\)\]\»\"\'\n\r\t…])"
-_LEADING_BOUNDARY = r"(?:^|(?<=[\s,;:!?\(\[\«\"\'\n\r\t]))"
-
-
-def _is_alphanumeric_only(text: str) -> bool:
-    """Vrai si tous les caractères sont alphanumériques ASCII."""
-    return all(c.isascii() and c.isalnum() for c in text)
-
-
-def _compile_pattern(marker: str) -> re.Pattern[str]:
-    """Compile le pattern regex pour la détection d'un marqueur
-    dans la GT et l'hypothèse.
-
-    La logique de frontière de mot dépend de la composition du
-    marqueur (cf. commentaire principal).
-    """
-    escaped = re.escape(marker)
-    if "." in marker:
-        # Frontière explicite après le point final.
-        return re.compile(_LEADING_BOUNDARY + escaped + _TRAILING_BOUNDARY)
-    if _is_alphanumeric_only(marker):
-        return re.compile(r"\b" + escaped + r"\b")
-    # Marqueurs Unicode (exposants, monnaies, guillemets, ponctuation
-    # typographique, croix) : match littéral, pas de \b.
-    return re.compile(escaped)
-
-
-# Cache des patterns compilés : (marker, category) → pattern.
-_PATTERNS: dict[tuple[str, str], re.Pattern[str]] = {
-    (marker, category): _compile_pattern(marker)
-    for marker, _expansions, category in _ALL_MARKERS
-}
-
-# Patterns d'expansion (insensibles à la casse, frontière de mot
-# si la forme développée est purement alphabétique).
-_EXPANSION_PATTERNS: dict[str, list[re.Pattern[str]]] = {}
-for marker, expansions, _category in _ALL_MARKERS:
-    compiled: list[re.Pattern[str]] = []
-    for exp in expansions:
-        escaped = re.escape(exp)
-        if exp and _is_alphanumeric_only(exp):
-            compiled.append(re.compile(r"\b" + escaped + r"\b", re.IGNORECASE))
-        else:
-            compiled.append(re.compile(escaped, re.IGNORECASE))
-    _EXPANSION_PATTERNS[marker] = compiled
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# API publique : catégorisation + détection
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def get_category(marker: str) -> Optional[str]:
-    """Retourne la catégorie d'un marqueur ou ``None`` si inconnu.
-
-    La comparaison est exacte (sensible à la casse, aux exposants
-    Unicode et aux points).
-    """
-    if not marker:
-        return None
-    for category, entries in _CATEGORIES.items():
-        for known, _expansions in entries:
-            if known == marker:
-                return category
-    return None
-
-
-def get_expansions(marker: str) -> tuple[str, ...]:
-    """Retourne les formes développées connues pour un marqueur,
-    ou un tuple vide si inconnu."""
-    if not marker:
-        return ()
-    for _category, entries in _CATEGORIES.items():
-        for known, expansions in entries:
-            if known == marker:
-                return expansions
-    return ()
-
-
-def detect_modern_markers(
-    text: Optional[str],
-) -> list[tuple[int, str, str]]:
-    """Retourne les marqueurs trouvés dans ``text``.
-
-    Forme de sortie : ``[(index, marker, category), ...]`` triée
-    par index croissant.  Si plusieurs marqueurs se chevauchent, le
-    plus long gagne (ex. « S.A.R. » plutôt que « S. " puis « A.R. »).
-
-    Tolérance casse
-    ---------------
-    Les marqueurs alphabétiques courts (« Mme », « Dr », « bd »)
-    sont matchés tels quels (sensibilité à la casse) — on n'élargit
-    pas car « me » en minuscule n'est pas une abréviation de
-    « Maître ».
-    """
-    if not text:
-        return []
-    # Collecte tous les matches de tous les marqueurs.
-    candidates: list[tuple[int, int, str, str]] = []  # start, end, marker, cat
-    for marker, _expansions, category in _ALL_MARKERS:
-        pattern = _PATTERNS[(marker, category)]
-        for match in pattern.finditer(text):
-            candidates.append((match.start(), match.end(), marker, category))
-    # Tri par (start, -length) pour appliquer une stratégie greedy
-    # « plus long gagne » à chaque position.
-    candidates.sort(key=lambda c: (c[0], -(c[1] - c[0])))
-    chosen: list[tuple[int, str, str]] = []
-    last_end = -1
-    for start, end, marker, category in candidates:
-        if start < last_end:
-            continue
-        chosen.append((start, marker, category))
-        last_end = end
-    return chosen
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul des scores strict / expansion
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _hyp_contains_marker(
-    hypothesis: str, marker: str, category: str,
-) -> bool:
-    """Vrai si le marqueur est présent (au moins une occurrence) dans
-    l'hypothèse, avec la même règle de frontière qu'en GT."""
-    pattern = _PATTERNS[(marker, category)]
-    return pattern.search(hypothesis) is not None
-
-
-def _hyp_contains_expansion(hypothesis: str, marker: str) -> bool:
-    """Vrai si une forme développée connue du marqueur est présente
-    dans l'hypothèse (insensible à la casse)."""
-    for pattern in _EXPANSION_PATTERNS.get(marker, ()):
-        if pattern.search(hypothesis) is not None:
-            return True
-    return False
-
-
-def compute_modern_archives_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> dict:
-    """Calcule la préservation des marqueurs d'archives modernes.
-
-    Pour chaque catégorie : retourne le ``strict_score`` (forme
-    abrégée préservée) et l'``expansion_score`` (abrégée OU
-    développée présente).  Le ratio des deux donne au chercheur la
-    convention adoptée (diplomatique / modernisante / mixte) sans
-    qu'aucune classification ne soit imposée.
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_markers_reference": int,
-            "n_strict_preserved": int,
-            "n_expansion_preserved": int,
-            "global_strict_score": float,
-            "global_expansion_score": float,
-            "per_category": {
-                category: {
-                    "n_total": int,
-                    "n_strict_preserved": int,
-                    "n_expansion_preserved": int,
-                    "strict_score": float,
-                    "expansion_score": float,
-                }
-            },
-            "missed_markers": [
-                {"index": int, "marker": str, "category": str,
-                 "expansion_preserved": bool}
-            ],
-        }``
-
-    Cas dégénérés
-    -------------
-    - GT vide ou sans marqueur → tous les compteurs à 0, scores à
-      ``0.0``, ``per_category == {}``.
-    - GT non vide avec marqueurs + hyp vide → tous les scores à
-      ``0.0``, tous les marqueurs dans ``missed_markers``.
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-
-    detected = detect_modern_markers(ref)
-    n_total = len(detected)
-    if n_total == 0:
-        return {
-            "n_markers_reference": 0,
-            "n_strict_preserved": 0,
-            "n_expansion_preserved": 0,
-            "global_strict_score": 0.0,
-            "global_expansion_score": 0.0,
-            "per_category": {},
-            "missed_markers": [],
-        }
-
-    per_cat_total: dict[str, int] = {}
-    per_cat_strict: dict[str, int] = {}
-    per_cat_expansion: dict[str, int] = {}
-    n_strict = 0
-    n_expansion = 0
-    missed: list[dict] = []
-
-    for index, marker, category in detected:
-        per_cat_total[category] = per_cat_total.get(category, 0) + 1
-        strict_ok = _hyp_contains_marker(hyp, marker, category)
-        # Convention identique à Sprint 56 : si l'abrégé est
-        # préservé, c'est aussi un succès pour expansion (l'OCR n'a
-        # pas perdu l'information).
-        expansion_ok = strict_ok or _hyp_contains_expansion(hyp, marker)
-        if strict_ok:
-            per_cat_strict[category] = per_cat_strict.get(category, 0) + 1
-            n_strict += 1
-        if expansion_ok:
-            per_cat_expansion[category] = per_cat_expansion.get(category, 0) + 1
-            n_expansion += 1
-        if not strict_ok:
-            missed.append({
-                "index": index,
-                "marker": marker,
-                "category": category,
-                "expansion_preserved": expansion_ok,
-            })
-
-    per_category = {
-        cat: {
-            "n_total": per_cat_total[cat],
-            "n_strict_preserved": per_cat_strict.get(cat, 0),
-            "n_expansion_preserved": per_cat_expansion.get(cat, 0),
-            "strict_score": (
-                per_cat_strict.get(cat, 0) / per_cat_total[cat]
-                if per_cat_total[cat] > 0 else 0.0
-            ),
-            "expansion_score": (
-                per_cat_expansion.get(cat, 0) / per_cat_total[cat]
-                if per_cat_total[cat] > 0 else 0.0
-            ),
-        }
-        for cat in sorted(per_cat_total)
-    }
-
-    return {
-        "n_markers_reference": n_total,
-        "n_strict_preserved": n_strict,
-        "n_expansion_preserved": n_expansion,
-        "global_strict_score": n_strict / n_total,
-        "global_expansion_score": n_expansion / n_total,
-        "per_category": per_category,
-        "missed_markers": missed,
-    }
-
-
-def modern_archives_strict_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux global de préservation **stricte** des
-    marqueurs d'archives modernes ∈ [0, 1]."""
-    return compute_modern_archives_metrics(
-        reference, hypothesis,
-    )["global_strict_score"]
-
-
-def modern_archives_expansion_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux global de préservation **étendue** (abrégée
-    OU développée) des marqueurs d'archives modernes ∈ [0, 1]."""
-    return compute_modern_archives_metrics(
-        reference, hypothesis,
-    )["global_expansion_score"]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="modern_archives_strict_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de préservation stricte des abréviations et marqueurs "
-        "typographiques caractéristiques des archives modernes "
-        "(XIXᵉ-XXᵉ) : titres de civilité, ordinaux, monnaies, "
-        "abréviations administratives, état civil, ponctuation "
-        "typographique, abréviations latines, abréviations "
-        "bibliographiques, abréviations d'adresse. Forme abrégée "
-        "préservée telle quelle (signal d'édition diplomatique)."
-    ),
-    higher_is_better=True,
-    tags={"text", "modern_archives", "philology", "abbreviations"},
-)
-def _registered_strict(reference: str, hypothesis: str) -> float:
-    return modern_archives_strict_score(reference, hypothesis)
-
-
-@register_metric(
-    name="modern_archives_expansion_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de préservation étendue (forme abrégée OU forme "
-        "développée présente) des marqueurs d'archives modernes "
-        "XIXᵉ-XXᵉ. Le ratio strict/expansion par catégorie "
-        "permet au chercheur de juger lui-même la convention "
-        "éditoriale adoptée."
-    ),
-    higher_is_better=True,
-    tags={"text", "modern_archives", "philology", "abbreviations"},
-)
-def _registered_expansion(reference: str, hypothesis: str) -> float:
-    return modern_archives_expansion_score(reference, hypothesis)
-
-
-__all__ = [
-    "CIVILITY_TITLES",
-    "ORDINALS",
-    "CURRENCY",
-    "ADMINISTRATIVE",
-    "CIVIL_STATUS",
-    "TYPOGRAPHIC_PUNCTUATION",
-    "LATIN_ABBR_MODERN",
-    "BIBLIOGRAPHIC",
-    "ADDRESS",
-    "compute_modern_archives_metrics",
-    "detect_modern_markers",
-    "get_category",
-    "get_expansions",
-    "modern_archives_strict_score",
-    "modern_archives_expansion_score",
-]
+from picarones.extras.historical.modern_archives import *  # noqa: F401, F403
 
+import picarones.extras.historical.modern_archives as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/mufi.py

@@ -1,264 +1,17 @@
-"""Couverture MUFI — Sprint 57.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.mufi`.
 
-Sprint 57 — A.II.3.3 du plan d'évolution 2026 (clôture axe A.II.3
-philologique).
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.core.mufi
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-La **Medieval Unicode Font Initiative** (MUFI v4.0) standardise les
-caractères médiévaux que les éditeurs critiques attendent dans une
-transcription fidèle : signes d'abréviation, ligatures, lettres
-spéciales (ƿ wynn, þ thorn), ponctuation médiévale, marques
-diacritiques rares, etc.  Pour les médiévistes, la **couverture
-MUFI** d'un moteur OCR/HTR est un critère éditorial central.
-
-Ce module mesure le taux de **caractères MUFI de la GT
-correctement restitués** dans l'OCR, après alignement caractère par
-caractère (même approche que la précision par bloc Unicode du
-Sprint 55).
-
-Détection des caractères MUFI
------------------------------
-La spécification MUFI v4.0 référence ~1300 caractères dans plusieurs
-plages Unicode.  Plutôt que d'embarquer la liste exhaustive (qui
-évolue), on utilise un **set de plages caractéristiques** suffisant
-pour les corpus patrimoniaux européens courants :
-
-- PUA principal (U+E000–U+F8FF) : zone usuelle des glyphes MUFI
-  qui n'ont pas (encore) de point de code Unicode standard.
-- Latin Extended-D (U+A720–U+A7FF) : abréviations latines
-  médiévales (ꝑ, ꝓ, ꝗ, etc.).
-- Combining Diacritical Marks Supplement (U+1DC0–U+1DFF) :
-  diacritiques médiévaux rares (macron suscript, etc.).
-- Alphabetic Presentation Forms (U+FB00–U+FB4F) : ligatures
-  (fi, fl, ff).
-- Une **liste explicite** de caractères médiévaux dans les blocs
-  Latin Extended-A/B/Additional (þ, ð, ƿ, ſ, æ, œ, etc.)
-
-L'utilisateur peut personnaliser via le paramètre ``custom_chars``
-de ``compute_mufi_coverage`` pour étendre ou restreindre.
-
-Stratégie de découpage
-----------------------
-Cohérente avec NER (Sprint 38), Flesch (52), Reading order F1 (53),
-Layout F1 (54), Bloc Unicode (55), Abréviations (56) : couche de
-calcul pure d'abord.  Le câblage runner et la vue HTML suivent dans
-des sprints dédiés.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-import logging
-from difflib import SequenceMatcher
-from typing import Iterable, Optional
-
-from picarones.core.metric_registry import register_metric
-from picarones.core.modules import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Plages Unicode considérées comme MUFI
-# ──────────────────────────────────────────────────────────────────────────
-
-# Triplets (nom, lo, hi) inclusifs.  Source : MUFI v4.0 spec
-# (https://mufi.info/) + revue manuelle des caractères patrimoniaux
-# courants.
-_MUFI_RANGES: tuple[tuple[str, int, int], ...] = (
-    ("Private Use Area",                          0xE000, 0xF8FF),
-    ("Latin Extended-D",                          0xA720, 0xA7FF),
-    ("Combining Diacritical Marks Supplement",    0x1DC0, 0x1DFF),
-    ("Alphabetic Presentation Forms",             0xFB00, 0xFB4F),
-)
-
-# Caractères MUFI explicites hors plages couvertes par les ranges.
-# Surtout des glyphes médiévaux standardisés en Unicode mais qui ne
-# sont pas dans le PUA ni dans Latin Extended-D : þ, ð, ƿ, ſ, æ, œ,
-# ø, ƀ, ƕ, etc.  Liste raisonnée pour les corpus européens médiévaux.
-_MUFI_EXPLICIT_CHARS: frozenset[str] = frozenset(
-    [
-        # Lettres médiévales standard
-        "þ", "Þ",  # thorn — vieil anglais, islandais
-        "ð", "Ð",  # eth — vieil anglais, islandais
-        "ƿ", "Ƿ",  # wynn — vieil anglais
-        "ſ",       # s long médiéval (déjà U+017F)
-        "æ", "Æ",  # ash
-        "œ", "Œ",  # ethel
-        "ø", "Ø",  # o barré
-        # Lettres rares avec barré (pour préfixes abréviés)
-        "ƀ",       # b barré
-        "ŧ",       # t barré
-        "đ",       # d barré
-        "ħ",       # h barré
-        # Yogh
-        "ȝ", "Ȝ",
-        # Autres signes médiévaux courants
-        "ꜿ",       # con
-        # Note : la liste est volontairement courte ; pour étendre,
-        # l'utilisateur peut passer ``custom_chars`` à
-        # ``compute_mufi_coverage``.
-    ]
-)
-
-
-def is_mufi_char(char: str, custom_chars: Optional[frozenset[str]] = None) -> bool:
-    """Retourne ``True`` si ``char`` est considéré comme MUFI.
-
-    Reconnaît :
-
-    - les caractères dans les plages Unicode MUFI (``_MUFI_RANGES``),
-    - les caractères de la liste explicite (``_MUFI_EXPLICIT_CHARS``),
-    - tout caractère supplémentaire fourni via ``custom_chars``.
-
-    Pour une chaîne multi-caractères, seul le premier code-point
-    est considéré.
-    """
-    if not char:
-        return False
-    cp = ord(char[0])
-    for _name, lo, hi in _MUFI_RANGES:
-        if lo <= cp <= hi:
-            return True
-    if char[0] in _MUFI_EXPLICIT_CHARS:
-        return True
-    if custom_chars and char[0] in custom_chars:
-        return True
-    return False
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul de couverture MUFI
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_mufi_coverage(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    custom_chars: Optional[Iterable[str]] = None,
-) -> dict:
-    """Calcule la couverture MUFI : taux de caractères MUFI de la GT
-    correctement restitués dans l'hypothèse.
-
-    Parameters
-    ----------
-    reference:
-        Texte GT.
-    hypothesis:
-        Texte produit par l'OCR.
-    custom_chars:
-        Itérable optionnel de caractères supplémentaires à considérer
-        comme MUFI (utile pour les éditeurs ayant une convention
-        propre).  Chaque entrée doit être un caractère unique.
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_mufi_chars_reference": int,    # caractères MUFI dans la GT
-            "n_mufi_chars_preserved": int,    # MUFI restitués correctement
-            "coverage": float,                 # ∈ [0, 1] ou 0 si N=0
-            "per_char": {char: {"total", "preserved", "coverage"}},
-            "missed_chars": list[str],         # caractères MUFI ratés
-        }``
-
-    Cas dégénérés
-    -------------
-    - GT vide ou sans caractère MUFI → ``coverage = 0`` (convention :
-      pas de récompense gratuite).
-    - Hyp vide + MUFI dans GT → ``coverage = 0``.
-    - GT et hyp identiques avec MUFI → ``coverage = 1``.
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-    extra: Optional[frozenset[str]] = (
-        frozenset(c for c in custom_chars if c) if custom_chars else None
-    )
-
-    # 1. Identifier les positions MUFI dans la GT
-    mufi_positions = [i for i, ch in enumerate(ref) if is_mufi_char(ch, extra)]
-    n_total = len(mufi_positions)
-
-    if n_total == 0:
-        return {
-            "n_mufi_chars_reference": 0,
-            "n_mufi_chars_preserved": 0,
-            "coverage": 0.0,
-            "per_char": {},
-            "missed_chars": [],
-        }
-
-    # 2. Aligner via SequenceMatcher (même méthode que Sprint 55)
-    matcher = SequenceMatcher(a=ref, b=hyp, autojunk=False)
-    correct_positions: set[int] = set()
-    for op, i1, i2, _j1, _j2 in matcher.get_opcodes():
-        if op == "equal":
-            correct_positions.update(range(i1, i2))
-
-    # 3. Compter par caractère
-    per_char_total: dict[str, int] = {}
-    per_char_preserved: dict[str, int] = {}
-    missed: list[str] = []
-    for i in mufi_positions:
-        ch = ref[i]
-        per_char_total[ch] = per_char_total.get(ch, 0) + 1
-        if i in correct_positions:
-            per_char_preserved[ch] = per_char_preserved.get(ch, 0) + 1
-        else:
-            missed.append(ch)
-
-    n_preserved = sum(per_char_preserved.values())
-    per_char = {
-        ch: {
-            "total": per_char_total[ch],
-            "preserved": per_char_preserved.get(ch, 0),
-            "coverage": (
-                per_char_preserved.get(ch, 0) / per_char_total[ch]
-                if per_char_total[ch] > 0
-                else 0.0
-            ),
-        }
-        for ch in sorted(per_char_total)
-    }
-
-    return {
-        "n_mufi_chars_reference": n_total,
-        "n_mufi_chars_preserved": n_preserved,
-        "coverage": n_preserved / n_total,
-        "per_char": per_char,
-        "missed_chars": missed,
-    }
-
-
-def mufi_coverage(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : retourne la couverture MUFI globale ∈ [0, 1]."""
-    return compute_mufi_coverage(reference, hypothesis)["coverage"]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────��───────────────────────────────
-
-
-@register_metric(
-    name="mufi_coverage",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de caractères MUFI (Medieval Unicode Font Initiative) "
-        "de la GT correctement restitués dans l'OCR. Critère "
-        "éditorial central pour les médiévistes."
-    ),
-    higher_is_better=True,
-    tags={"text", "mufi", "philology", "medieval"},
-)
-def _registered_mufi_coverage(reference: str, hypothesis: str) -> float:
-    return mufi_coverage(reference, hypothesis)
-
+from picarones.extras.historical.mufi import *  # noqa: F401, F403
 
-__all__ = [
-    "is_mufi_char",
-    "compute_mufi_coverage",
-    "mufi_coverage",
-]
+import picarones.extras.historical.mufi as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/philological_runner.py

@@ -1,363 +1,17 @@
-"""Helpers de câblage des métriques philologiques (Sprints 55-60) au runner.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.philological_runner`.
 
-Sprint 61 — câblage backend des 6 modules philologiques :
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.core.philological_runner
+import ...``) de continuer à fonctionner sans modification.
 
-- ``unicode_blocks``    (Sprint 55)
-- ``abbreviations``     (Sprint 56)
-- ``mufi``              (Sprint 57)
-- ``early_modern``      (Sprint 58)
-- ``modern_archives``   (Sprint 59)
-- ``roman_numerals``    (Sprint 60)
-
-Principe « adaptive »
-----------------------
-Un module n'est inclus dans le résultat que si la **GT contient du
-signal exploitable** pour ce module.  Cette logique évite de polluer
-les rapports sur les corpus sans marqueurs philologiques (typique
-sur des données XXIᵉ ou des transcriptions modernes propres).
-
-Coût
-----
-Les 6 calculs sont O(N) sur la longueur du texte ; le surcoût total
-par document est négligeable face à un appel OCR.  L'activation est
-donc **automatique** (pas d'opt-in), contrairement aux backends NER
-ou calibration qui exigent une dépendance externe ou des données
-spécifiques.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-from picarones.core.abbreviations import compute_abbreviation_metrics
-from picarones.core.early_modern_typography import compute_early_modern_metrics
-from picarones.core.modern_archives import compute_modern_archives_metrics
-from picarones.core.mufi import compute_mufi_coverage
-from picarones.core.roman_numerals import compute_roman_numeral_metrics
-from picarones.core.unicode_blocks import compute_unicode_block_accuracy
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Critères « le module a-t-il du signal sur ce document ? »
-# ──────────────────────────────────────────────────────────────────────────
-#
-# Pour chaque module, on définit un prédicat sur le résultat : si vrai,
-# le module est inclus ; sinon, il est omis pour ne pas alourdir le
-# rapport.
-
-def _has_unicode_signal(result: dict) -> bool:
-    # Le module retourne toujours du signal dès que GT non-vide ; on
-    # n'inclut que si la GT a au moins un caractère **hors Basic
-    # Latin** (sinon le breakdown se réduit à 100 % Basic Latin et
-    # n'apporte rien au lecteur).
-    per_block = result.get("per_block", {})
-    for block, stats in per_block.items():
-        if block == "Basic Latin":
-            continue
-        if stats.get("total", 0) > 0:
-            return True
-    return False
-
-
-def _has_abbreviation_signal(result: dict) -> bool:
-    return result.get("n_abbreviations_in_reference", 0) > 0
-
-
-def _has_mufi_signal(result: dict) -> bool:
-    return result.get("n_mufi_chars_reference", 0) > 0
-
-
-def _has_early_modern_signal(result: dict) -> bool:
-    return result.get("n_markers_reference", 0) > 0
-
-
-def _has_modern_archives_signal(result: dict) -> bool:
-    return result.get("n_markers_reference", 0) > 0
-
-
-def _has_roman_numeral_signal(result: dict) -> bool:
-    return result.get("n_numerals_reference", 0) > 0
-
-
-# Ordre fixé pour la reproductibilité des sorties.
-_PHILOLOGICAL_MODULES: tuple[
-    tuple[str, callable, callable], ...
-] = (
-    ("unicode_blocks",  compute_unicode_block_accuracy, _has_unicode_signal),
-    ("abbreviations",   compute_abbreviation_metrics,   _has_abbreviation_signal),
-    ("mufi",            compute_mufi_coverage,          _has_mufi_signal),
-    ("early_modern",    compute_early_modern_metrics,   _has_early_modern_signal),
-    ("modern_archives", compute_modern_archives_metrics, _has_modern_archives_signal),
-    ("roman_numerals",  compute_roman_numeral_metrics,  _has_roman_numeral_signal),
-)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul par document
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_philological_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> Optional[dict]:
-    """Calcule les 6 métriques philologiques pour un document.
-
-    Retourne un dict avec une clé par module ayant du signal, ou
-    ``None`` si aucun module n'en a (corpus sans marqueur
-    philologique pertinent).
-
-    En cas d'erreur dans un module individuel, le module est
-    silencieusement omis et un warning est émis (les autres modules
-    restent calculés).
-    """
-    ref = reference or ""
-    if not ref:
-        return None
-    out: dict = {}
-    for name, compute_fn, has_signal_fn in _PHILOLOGICAL_MODULES:
-        try:
-            result = compute_fn(ref, hypothesis or "")
-        except Exception as exc:  # pragma: no cover — défense en profondeur
-            logger.warning(
-                "[philological_runner] module %s a échoué : %s", name, exc,
-            )
-            continue
-        if has_signal_fn(result):
-            out[name] = result
-    return out if out else None
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Agrégation corpus-wide par moteur
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _aggregate_unicode(per_doc: list[dict]) -> dict:
-    total_correct = 0
-    total_chars = 0
-    per_block: dict[str, dict[str, int]] = {}
-    for d in per_doc:
-        for block, stats in d.get("per_block", {}).items():
-            slot = per_block.setdefault(block, {"correct": 0, "total": 0})
-            slot["correct"] += stats.get("correct", 0)
-            slot["total"] += stats.get("total", 0)
-            total_correct += stats.get("correct", 0)
-            total_chars += stats.get("total", 0)
-    out_per_block = {
-        block: {
-            "correct": slot["correct"],
-            "total": slot["total"],
-            "accuracy": (
-                slot["correct"] / slot["total"] if slot["total"] > 0 else 0.0
-            ),
-        }
-        for block, slot in sorted(per_block.items())
-    }
-    return {
-        "global_accuracy": total_correct / total_chars if total_chars > 0 else 0.0,
-        "n_chars_total": total_chars,
-        "n_chars_correct": total_correct,
-        "per_block": out_per_block,
-        "doc_count": len(per_doc),
-    }
-
-
-def _aggregate_abbreviations(per_doc: list[dict]) -> dict:
-    n_total = 0
-    n_strict = 0
-    n_expansion = 0
-    per_abbr: dict[str, dict[str, int]] = {}
-    for d in per_doc:
-        n_total += d.get("n_abbreviations_in_reference", 0)
-        n_strict += d.get("n_strict_preserved", 0)
-        n_expansion += d.get("n_expansion_preserved", 0)
-        for entry in d.get("per_abbreviation", []):
-            slot = per_abbr.setdefault(
-                entry["abbr"],
-                {"total": 0, "strict": 0, "expansion": 0},
-            )
-            slot["total"] += 1
-            if entry.get("strict_preserved"):
-                slot["strict"] += 1
-            if entry.get("expansion_preserved"):
-                slot["expansion"] += 1
-    return {
-        "n_abbreviations_in_reference": n_total,
-        "n_strict_preserved": n_strict,
-        "n_expansion_preserved": n_expansion,
-        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
-        "global_expansion_score": n_expansion / n_total if n_total > 0 else 0.0,
-        "per_abbreviation": {
-            abbr: {
-                "n_total": slot["total"],
-                "n_strict": slot["strict"],
-                "n_expansion": slot["expansion"],
-                "strict_score": slot["strict"] / slot["total"],
-                "expansion_score": slot["expansion"] / slot["total"],
-            }
-            for abbr, slot in sorted(per_abbr.items())
-        },
-        "doc_count": len(per_doc),
-    }
-
-
-def _aggregate_mufi(per_doc: list[dict]) -> dict:
-    n_total = 0
-    n_preserved = 0
-    per_char: dict[str, dict[str, int]] = {}
-    for d in per_doc:
-        n_total += d.get("n_mufi_chars_reference", 0)
-        n_preserved += d.get("n_mufi_chars_preserved", 0)
-        for ch, stats in d.get("per_char", {}).items():
-            slot = per_char.setdefault(ch, {"total": 0, "preserved": 0})
-            slot["total"] += stats.get("total", 0)
-            slot["preserved"] += stats.get("preserved", 0)
-    return {
-        "n_mufi_chars_reference": n_total,
-        "n_mufi_chars_preserved": n_preserved,
-        "coverage": n_preserved / n_total if n_total > 0 else 0.0,
-        "per_char": {
-            ch: {
-                "total": slot["total"],
-                "preserved": slot["preserved"],
-                "coverage": slot["preserved"] / slot["total"],
-            }
-            for ch, slot in sorted(per_char.items())
-        },
-        "doc_count": len(per_doc),
-    }
-
-
-def _aggregate_early_modern(per_doc: list[dict]) -> dict:
-    n_total = 0
-    n_preserved = 0
-    per_cat: dict[str, dict[str, int]] = {}
-    for d in per_doc:
-        n_total += d.get("n_markers_reference", 0)
-        n_preserved += d.get("n_markers_preserved", 0)
-        for cat, stats in d.get("per_category", {}).items():
-            slot = per_cat.setdefault(cat, {"total": 0, "preserved": 0})
-            slot["total"] += stats.get("total", 0)
-            slot["preserved"] += stats.get("preserved", 0)
-    return {
-        "n_markers_reference": n_total,
-        "n_markers_preserved": n_preserved,
-        "global_preservation": n_preserved / n_total if n_total > 0 else 0.0,
-        "per_category": {
-            cat: {
-                "total": slot["total"],
-                "preserved": slot["preserved"],
-                "preservation": slot["preserved"] / slot["total"],
-            }
-            for cat, slot in sorted(per_cat.items())
-        },
-        "doc_count": len(per_doc),
-    }
-
-
-def _aggregate_modern_archives(per_doc: list[dict]) -> dict:
-    n_total = 0
-    n_strict = 0
-    n_expansion = 0
-    per_cat: dict[str, dict[str, int]] = {}
-    for d in per_doc:
-        n_total += d.get("n_markers_reference", 0)
-        n_strict += d.get("n_strict_preserved", 0)
-        n_expansion += d.get("n_expansion_preserved", 0)
-        for cat, stats in d.get("per_category", {}).items():
-            slot = per_cat.setdefault(
-                cat, {"total": 0, "strict": 0, "expansion": 0},
-            )
-            slot["total"] += stats.get("n_total", 0)
-            slot["strict"] += stats.get("n_strict_preserved", 0)
-            slot["expansion"] += stats.get("n_expansion_preserved", 0)
-    return {
-        "n_markers_reference": n_total,
-        "n_strict_preserved": n_strict,
-        "n_expansion_preserved": n_expansion,
-        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
-        "global_expansion_score": n_expansion / n_total if n_total > 0 else 0.0,
-        "per_category": {
-            cat: {
-                "n_total": slot["total"],
-                "n_strict_preserved": slot["strict"],
-                "n_expansion_preserved": slot["expansion"],
-                "strict_score": slot["strict"] / slot["total"],
-                "expansion_score": slot["expansion"] / slot["total"],
-            }
-            for cat, slot in sorted(per_cat.items())
-        },
-        "doc_count": len(per_doc),
-    }
-
-
-def _aggregate_roman_numerals(per_doc: list[dict]) -> dict:
-    from picarones.core.roman_numerals import ALL_STATUSES, VALUE_PRESERVING_STATUSES
-
-    n_total = 0
-    per_status: dict[str, int] = {s: 0 for s in ALL_STATUSES}
-    for d in per_doc:
-        n_total += d.get("n_numerals_reference", 0)
-        for status, count in d.get("per_status", {}).items():
-            per_status[status] = per_status.get(status, 0) + count
-    n_strict = per_status.get("strict_preserved", 0)
-    n_value = sum(per_status.get(s, 0) for s in VALUE_PRESERVING_STATUSES)
-    return {
-        "n_numerals_reference": n_total,
-        "n_strict_preserved": n_strict,
-        "n_value_preserved": n_value,
-        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
-        "global_value_score": n_value / n_total if n_total > 0 else 0.0,
-        "per_status": per_status,
-        "doc_count": len(per_doc),
-    }
-
-
-_AGGREGATORS = {
-    "unicode_blocks":   _aggregate_unicode,
-    "abbreviations":    _aggregate_abbreviations,
-    "mufi":             _aggregate_mufi,
-    "early_modern":     _aggregate_early_modern,
-    "modern_archives":  _aggregate_modern_archives,
-    "roman_numerals":   _aggregate_roman_numerals,
-}
-
-
-def aggregate_philological_metrics(
-    doc_metrics: list[Optional[dict]],
-) -> Optional[dict]:
-    """Agrège les ``philological_metrics`` per-document en un dict
-    corpus-wide par module.
-
-    Pour chaque module, on agrège uniquement les documents qui ont
-    eu du signal pour ce module.  Si aucun module n'a été calculé
-    sur aucun document, retourne ``None``.
-    """
-    by_module: dict[str, list[dict]] = {}
-    for doc in doc_metrics:
-        if not doc:
-            continue
-        for module, payload in doc.items():
-            by_module.setdefault(module, []).append(payload)
-    if not by_module:
-        return None
-    out: dict = {}
-    for module, payloads in by_module.items():
-        aggregator = _AGGREGATORS.get(module)
-        if aggregator is None:  # pragma: no cover
-            logger.warning(
-                "[philological_runner] aucun agrégateur pour %s", module,
-            )
-            continue
-        out[module] = aggregator(payloads)
-    return out if out else None
-
+from picarones.extras.historical.philological_runner import *  # noqa: F401, F403
 
-__all__ = [
-    "compute_philological_metrics",
-    "aggregate_philological_metrics",
-]
+import picarones.extras.historical.philological_runner as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/roman_numerals.py

@@ -1,478 +1,17 @@
-"""Numéraux romains — Sprint 60.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.roman_numerals`.
 
-Sprint 60 — Étape 3 / extension philologique transversale du plan
-d'évolution 2026.
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.core.roman_numerals
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-Les numéraux romains traversent **toutes les périodes patrimoniales**
-servies par Picarones :
-
-- **Médiéval** : minuscules avec ``j`` final pour le dernier ``i``
-  (``ij`` = 2, ``iij`` = 3, ``viij`` = 8, ``mcclxxxij`` = 1282).
-  Convention scribale standard dans les chartes et registres.
-- **Imprimé ancien** : majuscules (``Tome IV``, ``Chap. VII``).
-- **Moderne** : majuscules pour les souverains (``Louis XIV``) et
-  les siècles (``XIXᵉ siècle`` — la partie exposant ᵉ est gérée
-  par le Sprint 59 ``ordinals``, ce module ne traite que la partie
-  numérale ``XIX``).
-
-Quatre traitements possibles d'un numéral par l'OCR
-----------------------------------------------------
-Pour chaque numéral romain présent dans la GT, l'OCR peut :
-
-1. **Préserver strictement** : forme exacte gardée
-   (``mcclxxxij`` → ``mcclxxxij``).  Édition diplomatique idéale.
-2. **Préserver en changeant la casse** : la valeur est intacte mais
-   la convention typographique est modifiée
-   (``xiv`` → ``XIV``).  Modernisation typographique courante.
-3. **Préserver en supprimant le ``j`` final** :
-   (``mcclxxxij`` → ``mcclxxxii``).  Modernisation orthographique
-   médiévale → standard académique moderne.
-4. **Convertir en chiffres arabes** : la valeur est préservée mais
-   le système de numération est modernisé
-   (``XIV`` → ``14``).  Modernisation profonde, perte de
-   l'information typographique.
-5. **Perdre** : aucune trace de la valeur dans l'hypothèse.
-
-Ce module retourne un breakdown par statut pour que le chercheur
-juge lui-même la convention adoptée par chaque moteur, **sans
-classification automatique imposée**.
-
-Stratégie de découpage
-----------------------
-Cohérente avec NER (38), Flesch (52), Reading order F1 (53),
-Layout F1 (54), Bloc Unicode (55), Abréviations (56), MUFI (57),
-Imprimé ancien (58), Archives modernes (59) : couche de calcul
-pure d'abord ; câblage runner et HTML dans des sprints dédiés.
-
-Limites documentées
--------------------
-- Détection greedy par regex ``\\b[IVXLCDMivxlcdmj]+\\b`` puis
-  validation par parsing.  Les faux positifs restent possibles sur
-  des mots courts (``I`` pronom anglais, ``MM`` initiales, ``LL``).
-  Le paramètre ``min_length`` permet de filtrer les single-letter.
-- Pas de gestion des notations rares avec barre suscript pour
-  multiplier par 1000 (V̄ = 5000, X̄ = 10000) — usage très rare en
-  corpus patrimonial européen courant.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-import logging
-import re
-from typing import Optional
-
-from picarones.core.metric_registry import register_metric
-from picarones.core.modules import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Table de conversion + parsing
-# ──────────────────────────────────────────────────────────────────────────
-
-ROMAN_VALUES: dict[str, int] = {
-    "I": 1,    "V": 5,    "X": 10,
-    "L": 50,   "C": 100,  "D": 500,  "M": 1000,
-}
-
-# Caractères acceptés en entrée (incluant minuscules + j médiéval).
-_ROMAN_CHARS = "IVXLCDMivxlcdmj"
-_ROMAN_RE = re.compile(rf"\b[{_ROMAN_CHARS}]+\b")
-
-
-def _normalize_roman(s: str) -> str:
-    """Normalise un numéral romain : majuscule + ``j`` final → ``i``.
-
-    Les manuscrits médiévaux notent traditionnellement le dernier
-    ``i`` d'une suite par ``j`` (« ij », « iij », « viij »…).  On
-    convertit pour pouvoir parser comme un numéral standard.
-    """
-    if not s:
-        return ""
-    upper = s.upper()
-    if upper.endswith("J"):
-        upper = upper[:-1] + "I"
-    return upper
-
-
-def _parse_normalized_roman(s: str) -> Optional[int]:
-    """Parse un numéral romain **après normalisation** (majuscule,
-    sans ``j`` médiéval).  Retourne ``None`` si la chaîne n'est pas
-    un numéral romain valide.
-
-    Validation : on parse en additionnant/soustrayant selon la règle
-    classique, puis on **regénère la forme standard** et on compare
-    pour rejeter les formes non canoniques (« IIII » au lieu de
-    « IV », « VV » au lieu de « X »).  Cette stricte validation
-    garantit qu'on ne compte pas des séquences absurdes comme
-    « XXXX » comme un numéral.
-
-    Note : les manuscrits médiévaux utilisent fréquemment « IIII »
-    pour 4 (notation soustractive plus tardive).  On accepte donc
-    aussi cette forme via une règle relâchée : tant que les valeurs
-    sont décroissantes ou suivent la règle soustractive standard,
-    on accepte.
-    """
-    if not s or not all(c in "IVXLCDM" for c in s):
-        return None
-    # Calcul par soustraction.
-    total = 0
-    prev_value = 0
-    for ch in reversed(s):
-        v = ROMAN_VALUES[ch]
-        if v < prev_value:
-            total -= v
-        else:
-            total += v
-        prev_value = v
-    if total <= 0:
-        return None
-    # Validation relâchée : on accepte les formes médiévales (IIII,
-    # VIIII) mais on rejette les vraiment absurdes (IIIII, VVVV).
-    if not _is_plausible_roman(s):
-        return None
-    return total
-
-
-def _is_plausible_roman(s: str) -> bool:
-    """Validation relâchée d'un numéral romain (majuscule).
-
-    On rejette :
-
-    - 5 caractères identiques d'affilée ou plus (« IIIII », « XXXXX »).
-    - Les répétitions de V, L, D (jamais répétés en notation
-      classique : « VV », « LL », « DD »).
-    - Les paires soustractives non standard.  En romain canonique,
-      seules sont valides : IV, IX, XL, XC, CD, CM.  Toute autre
-      combinaison « petit avant grand » est rejetée.  Cela élimine
-      les faux positifs sur des mots français comme « ici » (qui
-      formerait sinon « I + C » = 99) ou « IL » qui formerait 49.
-    """
-    if not s:
-        return False
-    # Pas de répétitions invalides
-    for forbidden in ("VV", "LL", "DD", "IIIII", "XXXXX", "CCCCC", "MMMMMM"):
-        if forbidden in s:
-            return False
-    # Paires soustractives autorisées (toutes les autres sont rejetées)
-    legal_subtractive = {"IV", "IX", "XL", "XC", "CD", "CM"}
-    for i in range(len(s) - 1):
-        a, b = s[i], s[i + 1]
-        if ROMAN_VALUES[a] < ROMAN_VALUES[b]:
-            if (a + b) not in legal_subtractive:
-                return False
-    return True
-
-
-def roman_to_int(s: Optional[str]) -> Optional[int]:
-    """Convertit une chaîne en numéral romain entier.  Tolère casse
-    et ``j`` médiéval final.  Retourne ``None`` si invalide.
-    """
-    if not s:
-        return None
-    return _parse_normalized_roman(_normalize_roman(s))
-
-
-def int_to_roman(n: int) -> str:
-    """Convertit un entier en numéral romain majuscule standard.
-
-    Utilise la notation classique (IV, IX, XL, XC, CD, CM) — pas la
-    forme médiévale relâchée.
-    """
-    if n <= 0:
-        raise ValueError("n must be positive")
-    pairs = [
-        (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
-        (100, "C"),  (90, "XC"),  (50, "L"),  (40, "XL"),
-        (10, "X"),   (9, "IX"),   (5, "V"),   (4, "IV"),
-        (1, "I"),
-    ]
-    out: list[str] = []
-    for value, symbol in pairs:
-        while n >= value:
-            out.append(symbol)
-            n -= value
-    return "".join(out)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Détection dans le texte
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def detect_roman_numerals(
-    text: Optional[str],
-    *,
-    min_length: int = 1,
-) -> list[tuple[int, str, int]]:
-    """Retourne les numéraux romains valides dans ``text``.
-
-    Forme : ``[(start_index, numeral_string, integer_value), ...]``
-    triée par index croissant.
-
-    Parameters
-    ----------
-    text:
-        Texte à analyser.
-    min_length:
-        Longueur minimale d'un numéral retenu.  Par défaut ``1``.
-        Mettre à ``2`` pour filtrer les single-letter ambigus (``I``
-        pronom, ``M`` initiale).
-
-    Faux positifs connus
-    --------------------
-    - ``I`` (pronom anglais), ``M`` ou ``D`` en initiale d'une
-      personne ne peuvent pas être distingués sans NER.  Le chercheur
-      qui s'inquiète de ces faux positifs peut passer
-      ``min_length=2``.
-    """
-    if not text:
-        return []
-    found: list[tuple[int, str, int]] = []
-    for match in _ROMAN_RE.finditer(text):
-        s = match.group(0)
-        if len(s) < min_length:
-            continue
-        value = roman_to_int(s)
-        if value is None:
-            continue
-        found.append((match.start(), s, value))
-    return found
-
-
-# ──────────────────────────────────────────────────────────────���───────────
-# Classification de la restitution dans l'hypothèse
-# ──────────────────────────────────────────────────────────────────────────
-
-# Statuts possibles, dans l'ordre de priorité (un numéral est
-# classé selon le premier statut qui s'applique).
-
-STATUS_STRICT_PRESERVED   = "strict_preserved"
-STATUS_CASE_CHANGED       = "case_changed"
-STATUS_J_DROPPED          = "j_dropped"
-STATUS_CONVERTED_TO_ARABIC = "converted_to_arabic"
-STATUS_LOST               = "lost"
-
-ALL_STATUSES = (
-    STATUS_STRICT_PRESERVED,
-    STATUS_CASE_CHANGED,
-    STATUS_J_DROPPED,
-    STATUS_CONVERTED_TO_ARABIC,
-    STATUS_LOST,
-)
-
-# Statuts qui indiquent une préservation de la valeur (par opposition
-# à la perte).
-VALUE_PRESERVING_STATUSES = frozenset({
-    STATUS_STRICT_PRESERVED,
-    STATUS_CASE_CHANGED,
-    STATUS_J_DROPPED,
-    STATUS_CONVERTED_TO_ARABIC,
-})
-
-
-def _classify_restitution(numeral: str, value: int, hyp: str) -> str:
-    """Classifie comment ``numeral`` (de valeur ``value``) est
-    restitué dans ``hyp`` selon les 5 statuts définis."""
-    # 1. Forme stricte présente
-    if re.search(r"(?<![A-Za-z])" + re.escape(numeral) + r"(?![A-Za-z])", hyp):
-        return STATUS_STRICT_PRESERVED
-    # 2. Variante de casse seule
-    swapped = numeral.swapcase()
-    if swapped != numeral and re.search(
-        r"(?<![A-Za-z])" + re.escape(swapped) + r"(?![A-Za-z])", hyp,
-    ):
-        return STATUS_CASE_CHANGED
-    # 3. ``j`` final remplacé par ``i`` (ou inverse)
-    if numeral.lower().endswith("j"):
-        no_j = numeral[:-1] + ("I" if numeral[-1] == "J" else "i")
-    elif numeral.lower().endswith("i"):
-        no_j = numeral[:-1] + ("J" if numeral[-1] == "I" else "j")
-    else:
-        no_j = numeral
-    if no_j != numeral and re.search(
-        r"(?<![A-Za-z])" + re.escape(no_j) + r"(?![A-Za-z])", hyp,
-    ):
-        return STATUS_J_DROPPED
-    # Variante de casse + j-flip combinés
-    no_j_swapped = no_j.swapcase()
-    if no_j_swapped != numeral and re.search(
-        r"(?<![A-Za-z])" + re.escape(no_j_swapped) + r"(?![A-Za-z])", hyp,
-    ):
-        return STATUS_J_DROPPED
-    # 4. Conversion en chiffres arabes
-    if re.search(r"(?<!\d)" + str(value) + r"(?!\d)", hyp):
-        return STATUS_CONVERTED_TO_ARABIC
-    # 5. Perdu
-    return STATUS_LOST
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul de la métrique
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_roman_numeral_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    *,
-    min_length: int = 1,
-) -> dict:
-    """Calcule la préservation des numéraux romains.
-
-    Pour chaque numéral romain dans la GT, on classifie sa
-    restitution dans l'hypothèse selon l'un des 5 statuts (forme
-    stricte / casse modifiée / j supprimé / conversion arabe / perdu).
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_numerals_reference": int,
-            "n_strict_preserved": int,
-            "n_value_preserved": int,    # tous statuts sauf LOST
-            "global_strict_score": float,
-            "global_value_score": float,
-            "per_status": {status: count for status in ALL_STATUSES},
-            "per_numeral": [
-                {"index", "numeral", "value", "status"}
-            ],
-            "lost_numerals": [
-                {"index", "numeral", "value"}
-            ],
-        }``
-
-    Cas dégénérés
-    -------------
-    - GT vide ou sans numéral → tous compteurs à 0, scores à 0.0,
-      ``per_status`` initialisé à 0 sur tous les statuts.
-    - GT avec numéraux + hyp vide → tous classés ``lost``,
-      strict_score = value_score = 0.0.
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-
-    detected = detect_roman_numerals(ref, min_length=min_length)
-    n_total = len(detected)
-    per_status_init = {status: 0 for status in ALL_STATUSES}
-
-    if n_total == 0:
-        return {
-            "n_numerals_reference": 0,
-            "n_strict_preserved": 0,
-            "n_value_preserved": 0,
-            "global_strict_score": 0.0,
-            "global_value_score": 0.0,
-            "per_status": per_status_init,
-            "per_numeral": [],
-            "lost_numerals": [],
-        }
-
-    per_status: dict[str, int] = dict(per_status_init)
-    per_numeral: list[dict] = []
-    lost: list[dict] = []
-    for index, numeral, value in detected:
-        status = _classify_restitution(numeral, value, hyp)
-        per_status[status] = per_status.get(status, 0) + 1
-        per_numeral.append({
-            "index": index,
-            "numeral": numeral,
-            "value": value,
-            "status": status,
-        })
-        if status == STATUS_LOST:
-            lost.append({"index": index, "numeral": numeral, "value": value})
-
-    n_strict = per_status[STATUS_STRICT_PRESERVED]
-    n_value = sum(per_status[s] for s in VALUE_PRESERVING_STATUSES)
-
-    return {
-        "n_numerals_reference": n_total,
-        "n_strict_preserved": n_strict,
-        "n_value_preserved": n_value,
-        "global_strict_score": n_strict / n_total,
-        "global_value_score": n_value / n_total,
-        "per_status": per_status,
-        "per_numeral": per_numeral,
-        "lost_numerals": lost,
-    }
-
-
-def roman_numeral_strict_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux global de préservation **stricte** des
-    numéraux romains ∈ [0, 1]."""
-    return compute_roman_numeral_metrics(
-        reference, hypothesis,
-    )["global_strict_score"]
-
-
-def roman_numeral_value_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux global de préservation de la **valeur** des
-    numéraux romains (toute forme confondue : strict, case_changed,
-    j_dropped, arabe) ∈ [0, 1]."""
-    return compute_roman_numeral_metrics(
-        reference, hypothesis,
-    )["global_value_score"]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="roman_numeral_strict_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de préservation stricte des numéraux romains "
-        "(forme exacte gardée : casse, j médiéval final). "
-        "Métrique transversale aux périodes médiévale, imprimé "
-        "ancien et moderne."
-    ),
-    higher_is_better=True,
-    tags={"text", "roman_numerals", "philology"},
-)
-def _registered_strict(reference: str, hypothesis: str) -> float:
-    return roman_numeral_strict_score(reference, hypothesis)
-
-
-@register_metric(
-    name="roman_numeral_value_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de préservation de la valeur numérique des numéraux "
-        "romains, indépendamment de la forme (strict, casse "
-        "changée, j supprimé, conversion en chiffres arabes). "
-        "Le breakdown per_status permet au chercheur de juger la "
-        "convention adoptée."
-    ),
-    higher_is_better=True,
-    tags={"text", "roman_numerals", "philology"},
-)
-def _registered_value(reference: str, hypothesis: str) -> float:
-    return roman_numeral_value_score(reference, hypothesis)
-
+from picarones.extras.historical.roman_numerals import *  # noqa: F401, F403
 
-__all__ = [
-    "ROMAN_VALUES",
-    "ALL_STATUSES",
-    "STATUS_STRICT_PRESERVED",
-    "STATUS_CASE_CHANGED",
-    "STATUS_J_DROPPED",
-    "STATUS_CONVERTED_TO_ARABIC",
-    "STATUS_LOST",
-    "VALUE_PRESERVING_STATUSES",
-    "compute_roman_numeral_metrics",
-    "detect_roman_numerals",
-    "int_to_roman",
-    "roman_numeral_strict_score",
-    "roman_numeral_value_score",
-    "roman_to_int",
-]
+import picarones.extras.historical.roman_numerals as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/unicode_blocks.py

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

picarones/extras/historical/__init__.py

@@ -0,0 +1,30 @@
+"""Métriques philologiques pour documents historiques (Cercle 3).
+
+Modules orientés cas d'usage patrimoniaux par période :
+
+- :mod:`unicode_blocks`         — précision par bloc Unicode (toutes périodes)
+- :mod:`abbreviations`          — score d'expansion d'abréviations (médiéval)
+- :mod:`mufi`                   — couverture MUFI v4.0 (médiéval, PUA)
+- :mod:`early_modern_typography` — fl, fi, ſ, ã, &, ı (XVIᵉ-XVIIIᵉ siècles)
+- :mod:`modern_archives`        — Mme/Mlle/°/†/₶ (XIXᵉ-XXᵉ siècles)
+- :mod:`roman_numerals`         — numéraux romains (toutes périodes)
+- :mod:`lexical_modernization`  — top tokens GT modernisés par le moteur
+- :mod:`philological_runner`    — orchestration adaptive des 6 modules
+
+Utilité
+-------
+Ces métriques répondent à la question éditoriale *« quels caractères
+historiques ce moteur restitue-t-il fidèlement ? »*. Elles ne
+participent pas à la décision « peut-on déployer ce moteur en prod ? »
+quand le corpus est moderne (les modules retournent ``None`` via
+adaptive masking sur un texte sans signal philologique).
+
+Plugin séparable
+----------------
+Distribué via l'extra pip ``picarones[historical]``. Les imports
+historiques ``from picarones.core.unicode_blocks import ...`` restent
+fonctionnels via des fichiers-shims dans :mod:`picarones.core`.
+
+Phase B du chantier de refonte en 3 cercles — voir
+:doc:`docs/architecture-cercles.md`.
+"""

picarones/extras/historical/abbreviations.py

@@ -0,0 +1,350 @@
+"""Score d'expansion d'abréviations médiévales — Sprint 56.
+
+Sprint 56 — A.II.3.2 du plan d'évolution 2026 (axe philologique).
+
+Pourquoi ce module
+------------------
+Sur les manuscrits médiévaux (chartes, registres, copies de droit
+canonique), les scribes utilisent intensivement des **signes
+d'abréviation** : ``ꝑ`` (per/par), ``ꝓ`` (pro), ``ꝗ`` (qui),
+``ꝙ`` (quia), ``ꝯ`` (con/-us), ``⁊`` (et), tilde combinant pour
+``-en/-an``, etc.
+
+Un OCR/HTR a deux comportements possibles face à ces signes :
+
+1. **Préservation** : la forme abrégée est gardée telle quelle
+   (``ꝑ`` → ``ꝑ``).  C'est le comportement attendu d'une
+   transcription **diplomatique** (édition critique).
+2. **Développement** : le signe est remplacé par sa forme
+   développée (``ꝑ`` → ``per``).  C'est le comportement attendu
+   d'une édition **modernisée**.
+
+Une troisième possibilité — et c'est l'erreur qu'on cherche à
+détecter : le signe est **mal restitué** (remplacé par un
+caractère ASCII proche, supprimé, ou mal développé).
+
+Ce module produit deux scores complémentaires :
+
+- ``abbreviation_strict_score`` : taux d'abréviations GT dont la
+  **forme abrégée Unicode est préservée** dans l'OCR.
+- ``abbreviation_expansion_score`` : taux d'abréviations GT dont
+  **soit** la forme abrégée, **soit** la forme développée
+  attendue, est présente dans l'OCR.
+
+Le **ratio** des deux dit beaucoup sur la convention adoptée :
+
+- ``strict ≈ expansion`` proche de 1 → le moteur est diplomatique
+  (préserve l'abrégé) ;
+- ``strict << expansion`` → le moteur est modernisant (développe
+  systématiquement) ;
+- les deux faibles → le moteur perd les abréviations (signal
+  d'erreur OCR).
+
+Stratégie de découpage
+----------------------
+Cohérente avec NER (Sprint 38), Flesch (52), Reading order F1 (53),
+Layout F1 (54), Bloc Unicode (55) : couche de calcul pure d'abord.
+Le câblage runner et la vue HTML suivent dans des sprints dédiés.
+
+Limites documentées
+-------------------
+- L'alignement est **bag-of-occurrences** (proxy positionnel
+  simple) : on compte les occurrences GT et on vérifie leur
+  présence dans l'hyp.  Pas d'alignement séquentiel rigoureux.
+- La table d'abréviations couvre les signes les plus courants en
+  scriptura latine européenne (Capelli).  Elle est extensible via
+  ``ABBREVIATION_EXPANSIONS``.
+- Pour les abréviations marquées par un **tilde combinant**
+  (``p̃``, ``q̃``), on détecte la séquence ``lettre + U+0303``.
+  Pas de gestion fine des polices Capelli/MUFI complètes.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import unicodedata
+from typing import Optional
+
+from picarones.core.metric_registry import register_metric
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Table d'expansions
+# ──────────────────────────────────────────────────────────────────────────
+
+# Signes d'abréviation latins médiévaux les plus courants.
+# Source : Capelli, "Lexicon Abbreviaturarum" (1929) + MUFI.
+#
+# La clé est une chaîne (1 ou 2 code-points pour le cas tilde
+# combinant) ; la valeur est la liste des expansions courantes
+# acceptées (les détails varient selon la convention éditoriale,
+# on accepte plusieurs formes).
+ABBREVIATION_EXPANSIONS: dict[str, tuple[str, ...]] = {
+    "ꝑ": ("per", "par"),                       # U+A751
+    "ꝓ": ("pro",),                              # U+A753
+    "ꝗ": ("qui",),                              # U+A757
+    "ꝙ": ("quia",),                             # U+A759
+    "ꝯ": ("us", "con"),                         # U+A76F
+    "⁊": ("et",),                               # U+204A "et" tironien
+    "ꝝ": ("rum",),                              # U+A75D
+    "ꝫ": ("et",),                               # U+A76B
+    "ꝭ": ("is",),                               # U+A76D
+    # Tilde combinant après lettre (U+0303 = ̃) : pẽ, qũ, etc.
+    "p̃": ("par", "per"),
+    "q̃": ("que", "qui"),
+    "ñ": ("an", "en"),                          # U+00F1 (Latin-1 Sup)
+    # Note : ñ existe aussi comme caractère latin moderne (espagnol),
+    # donc l'attribuer aux abréviations introduit du bruit ; on
+    # laisse au benchmark le soin d'évaluer.  Pour les éditeurs
+    # médiévistes qui veulent restreindre, ils peuvent passer par
+    # une table custom (à venir).
+}
+
+
+# Set des "premiers code-points" reconnus comme début d'une
+# abréviation (pour balayage rapide).
+_ABBR_FIRST_CHARS: frozenset[str] = frozenset(
+    abbr[0] for abbr in ABBREVIATION_EXPANSIONS
+)
+
+
+# Combining tilde (U+0303) — utilisé pour la détection p̃, q̃, etc.
+_COMBINING_TILDE = "̃"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Détection d'abréviations dans un texte
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def detect_abbreviations(text: Optional[str]) -> list[str]:
+    """Liste des abréviations médiévales détectées dans ``text``,
+    dans l'ordre d'apparition.
+
+    Reconnaît :
+
+    - Les caractères Unicode dédiés présents dans
+      ``ABBREVIATION_EXPANSIONS`` (``ꝑ``, ``ꝓ``, ``⁊``…).
+    - Les séquences ``lettre + U+0303`` (tilde combinant) si la
+      paire est dans la table (``p̃``, ``q̃``).
+
+    Doublons conservés : si le texte contient deux ``ꝑ``, la liste
+    en a deux.  Cohérent avec le calcul bag-of-occurrences en aval.
+    """
+    if not text:
+        return []
+    found: list[str] = []
+    # Forme NFD pour reconnaître les ã, p̃, q̃ même quand l'utilisateur
+    # passe la forme NFC (« ñ » = U+00F1 sera traité par le mapping
+    # direct ; les séquences manuelles ``p`` + tilde combinant restent
+    # détectables).
+    text_nfd = unicodedata.normalize("NFD", text)
+    i = 0
+    while i < len(text_nfd):
+        ch = text_nfd[i]
+        # Cas 1 : lettre + tilde combinant
+        if i + 1 < len(text_nfd) and text_nfd[i + 1] == _COMBINING_TILDE:
+            seq = ch + _COMBINING_TILDE
+            if seq in ABBREVIATION_EXPANSIONS:
+                found.append(seq)
+                i += 2
+                continue
+        # Cas 2 : caractère unicode dédié
+        if ch in ABBREVIATION_EXPANSIONS:
+            found.append(ch)
+        i += 1
+    return found
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Scores
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _hyp_contains_abbr(hypothesis: str, abbr: str) -> bool:
+    """Vrai si la forme abrégée ``abbr`` apparaît telle quelle dans
+    ``hypothesis``.  Sensible aux deux formes NFC / NFD pour les
+    séquences à tilde combinant."""
+    if abbr in hypothesis:
+        return True
+    # Pour les séquences ``lettre + tilde combinant``, l'hyp peut
+    # avoir une forme NFC (ex. ``ñ`` au lieu de ``n + U+0303``).
+    nfd = unicodedata.normalize("NFD", hypothesis)
+    return abbr in nfd
+
+
+def _hyp_contains_expansion(
+    hypothesis: str, expansions: tuple[str, ...],
+) -> bool:
+    """Vrai si l'une des formes développées apparaît dans ``hypothesis``
+    (recherche insensible à la casse, sur les frontières de mots
+    pour limiter les faux positifs sur les sous-chaînes courtes
+    type ``us`` ou ``et``)."""
+    if not expansions:
+        return False
+    hyp_lower = hypothesis.lower()
+    for exp in expansions:
+        if not exp:
+            continue
+        # Recherche frontière de mot pour les expansions courtes.
+        # Pour ``per`` ou ``pro`` : on accepte le développement à
+        # n'importe quelle position d'un mot (tolère ``per`` dans
+        # ``permettre``, c'est imprécis mais pragmatique).  Pour
+        # les expansions très courtes (≤ 2 lettres), on impose un
+        # mot complet pour limiter le bruit.
+        if len(exp) <= 2:
+            if re.search(rf"\b{re.escape(exp)}\b", hyp_lower):
+                return True
+        else:
+            if exp.lower() in hyp_lower:
+                return True
+    return False
+
+
+def compute_abbreviation_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> dict:
+    """Calcule les scores d'abréviation strict et d'expansion.
+
+    Parameters
+    ----------
+    reference:
+        Texte GT (avec abréviations médiévales originales).
+    hypothesis:
+        Texte produit par l'OCR.
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_abbreviations_in_reference": int,
+            "n_strict_preserved":   int,    # forme abrégée préservée
+            "n_expansion_preserved": int,    # abrégée OU développée
+            "strict_score":   float,         # ∈ [0, 1]
+            "expansion_score": float,        # ∈ [0, 1]
+            "per_abbreviation": [
+                {"abbr", "strict_preserved", "expansion_preserved",
+                 "expansions"},
+                ...
+            ],
+        }``
+
+    Cas dégénérés
+    -------------
+    - GT vide ou sans abréviation détectée → tous les compteurs à 0
+      et les scores à ``0.0`` (convention : on ne récompense pas
+      l'absence d'abréviations).
+    - GT non vide avec abréviations + hyp vide → tous les scores
+      à ``0.0``.
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+
+    abbreviations = detect_abbreviations(ref)
+    n = len(abbreviations)
+    if n == 0:
+        return {
+            "n_abbreviations_in_reference": 0,
+            "n_strict_preserved": 0,
+            "n_expansion_preserved": 0,
+            "strict_score": 0.0,
+            "expansion_score": 0.0,
+            "per_abbreviation": [],
+        }
+
+    n_strict = 0
+    n_expansion = 0
+    per_abbr: list[dict] = []
+    for abbr in abbreviations:
+        expansions = ABBREVIATION_EXPANSIONS.get(abbr, ())
+        strict_ok = _hyp_contains_abbr(hyp, abbr)
+        # Expansion : on accepte la forme abrégée OU le développement.
+        # Convention : si l'OCR a préservé la forme abrégée, c'est
+        # aussi compté comme valide pour le score d'expansion (le
+        # moteur n'a pas perdu l'information ; il a juste choisi
+        # une convention diplomatique).
+        expansion_ok = strict_ok or _hyp_contains_expansion(hyp, expansions)
+        if strict_ok:
+            n_strict += 1
+        if expansion_ok:
+            n_expansion += 1
+        per_abbr.append({
+            "abbr": abbr,
+            "strict_preserved": strict_ok,
+            "expansion_preserved": expansion_ok,
+            "expansions": list(expansions),
+        })
+
+    return {
+        "n_abbreviations_in_reference": n,
+        "n_strict_preserved": n_strict,
+        "n_expansion_preserved": n_expansion,
+        "strict_score": n_strict / n,
+        "expansion_score": n_expansion / n,
+        "per_abbreviation": per_abbr,
+    }
+
+
+def abbreviation_strict_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux de préservation **stricte** des abréviations
+    Unicode (forme abrégée gardée telle quelle)."""
+    return compute_abbreviation_metrics(reference, hypothesis)["strict_score"]
+
+
+def abbreviation_expansion_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux de préservation par expansion (forme abrégée
+    OU forme développée présente dans l'hyp)."""
+    return compute_abbreviation_metrics(reference, hypothesis)["expansion_score"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="abbreviation_strict_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux d'abréviations médiévales (Unicode dédié + lettre + "
+        "tilde combinant) dont la forme abrégée est préservée telle "
+        "quelle dans l'OCR. Idéal pour les éditions diplomatiques."
+    ),
+    higher_is_better=True,
+    tags={"text", "abbreviation", "philology", "medieval"},
+)
+def _registered_strict(reference: str, hypothesis: str) -> float:
+    return abbreviation_strict_score(reference, hypothesis)
+
+
+@register_metric(
+    name="abbreviation_expansion_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux d'abréviations dont SOIT la forme abrégée Unicode SOIT "
+        "la forme développée attendue (per, pro, et…) est présente "
+        "dans l'OCR. Score plus large que strict_score."
+    ),
+    higher_is_better=True,
+    tags={"text", "abbreviation", "philology", "medieval"},
+)
+def _registered_expansion(reference: str, hypothesis: str) -> float:
+    return abbreviation_expansion_score(reference, hypothesis)
+
+
+__all__ = [
+    "ABBREVIATION_EXPANSIONS",
+    "detect_abbreviations",
+    "compute_abbreviation_metrics",
+    "abbreviation_strict_score",
+    "abbreviation_expansion_score",
+]

picarones/extras/historical/early_modern_typography.py

@@ -0,0 +1,342 @@
+"""Marqueurs typographiques de l'imprimé ancien (XVIᵉ-XVIIIᵉ).
+
+Sprint 58 — Étape 3 / extension philologique du plan d'évolution
+2026.
+
+Pourquoi ce module
+------------------
+Les Sprints 56 (abréviations Capelli) et 57 (couverture MUFI) sont
+orientés **médiéval scribal**.  Mais Picarones doit aussi servir
+les éditeurs d'**imprimés anciens** (XVIᵉ-XVIIIᵉ siècles), pour
+qui les marqueurs caractéristiques ne sont pas scribaux mais
+**typographiques** : ligatures composées (fi, fl, ff, ffi, ffl, ſt),
+s long (ſ), i sans point (ı), esperluette (&), tildes nasaux
+indiquant une abréviation (ã = an/am, õ = on/om).
+
+Distinction avec MUFI/abbreviations
+------------------------------------
+- ``mufi.py`` (Sprint 57) : caractères médiévaux scribaux
+  (Capelli + lettres þ ð ƿ + PUA MUFI).
+- ``abbreviations.py`` (Sprint 56) : signes d'abréviation latins
+  scribaux médiévaux (ꝑ ꝓ ⁊ + tildes scribaux).
+- ``early_modern_typography.py`` (ce module) : marqueurs
+  **typographiques** de la composition imprimée ancienne.
+
+Les ligatures fi et fl sont communes aux deux univers (médiéval et
+imprimé ancien) ; le choix du module à utiliser dépend du **corpus**
+et de l'angle d'analyse éditoriale, pas du caractère pris isolément.
+
+Catégorisation
+--------------
+Les marqueurs sont classés en cinq catégories pour permettre un
+breakdown éditorial :
+
+1. ``ligatures`` : fi fl ff ffi ffl ſt
+2. ``long_s`` : ſ
+3. ``dotless_i`` : ı
+4. ``ampersand`` : & (esperluette typographique)
+5. ``nasal_tildes`` : ã õ ũ ñ ē ī (abréviation par tilde nasal)
+
+``compute_early_modern_metrics`` retourne le taux de préservation
+par catégorie + global.
+"""
+
+from __future__ import annotations
+
+import logging
+from difflib import SequenceMatcher
+from typing import Optional
+
+from picarones.core.metric_registry import register_metric
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Marqueurs typographiques imprimé ancien
+# ──────────────────────────────────────────────────────────────────────────
+
+# Ligatures typographiques héritées de l'incunable (XVᵉ) et toujours
+# courantes jusqu'au XVIIIᵉ avant la normalisation typographique.
+LIGATURES: frozenset[str] = frozenset({
+    "ff",  # U+FB00 ff
+    "fi",  # U+FB01 fi
+    "fl",  # U+FB02 fl
+    "ffi",  # U+FB03 ffi
+    "ffl",  # U+FB04 ffl
+    "ſt",  # U+FB05 long s + t
+    "st",  # U+FB06 st
+})
+
+# S long : Latin Extended-A.  Caractéristique de la typographie
+# antérieure à 1800.
+LONG_S: frozenset[str] = frozenset({"ſ"})  # U+017F
+
+# i sans point : utilisé en typographie ancienne, parfois confondu
+# avec un l ou un 1 par les OCR modernes.
+DOTLESS_I: frozenset[str] = frozenset({"ı"})  # U+0131
+
+# Esperluette typographique : "&" remplace fréquemment "et" dans
+# les imprimés ; sa préservation discrimine un OCR diplomatique
+# d'un OCR modernisant.
+AMPERSAND: frozenset[str] = frozenset({"&"})
+
+# Tildes nasaux : pré-composés (ñ ã ẽ ĩ õ ũ) ou séquences
+# lettre + U+0303 combinant.  En imprimé ancien, ã = an/am abrégé,
+# õ = on/om, etc.  Distinction avec les tildes scribaux médiévaux
+# (Sprint 56) : ici on cible les **pré-composés** ou séquences sur
+# des voyelles (le scribal médiéval cible plutôt p̃ q̃).
+NASAL_TILDE_PRECOMPOSED: frozenset[str] = frozenset({
+    "ã", "Ã",  # U+00E3 / U+00C3
+    "ñ", "Ñ",  # U+00F1 / U+00D1
+    "õ", "Õ",  # U+00F5 / U+00D5
+    "ũ", "Ũ",  # U+0169 / U+0168
+    "ẽ", "Ẽ",  # U+1EBD / U+1EBC
+    "ĩ", "Ĩ",  # U+0129 / U+0128
+})
+
+# Voyelles susceptibles de porter un tilde combinant pour former
+# un tilde nasal (couvre les écritures NFD non pré-composées).
+_NASAL_TILDE_VOWELS: frozenset[str] = frozenset(
+    "aeiouAEIOU"
+)
+_COMBINING_TILDE = "̃"
+
+
+# Catégorisation : nom → set de caractères pré-composés ou séquences.
+_CATEGORIES: dict[str, frozenset[str]] = {
+    "ligatures": LIGATURES,
+    "long_s": LONG_S,
+    "dotless_i": DOTLESS_I,
+    "ampersand": AMPERSAND,
+    "nasal_tildes": NASAL_TILDE_PRECOMPOSED,
+}
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Détection des marqueurs dans la GT
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _detect_markers(text: str) -> list[tuple[int, str, str]]:
+    """Retourne les positions des marqueurs typographiques dans
+    ``text``.
+
+    Forme de sortie : ``[(index, marker, category), ...]`` dans
+    l'ordre d'apparition.  Pour les tildes nasaux non
+    pré-composés, on détecte les séquences ``voyelle + U+0303`` et
+    on retourne l'index de la voyelle.
+    """
+    if not text:
+        return []
+    found: list[tuple[int, str, str]] = []
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        # Cas 1 : marqueur pré-composé dans une catégorie
+        category = _category_of_char(ch)
+        if category is not None:
+            found.append((i, ch, category))
+            i += 1
+            continue
+        # Cas 2 : voyelle + tilde combinant → nasal_tildes
+        if (
+            ch in _NASAL_TILDE_VOWELS
+            and i + 1 < len(text)
+            and text[i + 1] == _COMBINING_TILDE
+        ):
+            seq = ch + _COMBINING_TILDE
+            found.append((i, seq, "nasal_tildes"))
+            i += 2
+            continue
+        i += 1
+    return found
+
+
+def _category_of_char(ch: str) -> Optional[str]:
+    """Retourne la catégorie d'un caractère typographique ou
+    ``None`` s'il n'est pas reconnu."""
+    for cat, chars in _CATEGORIES.items():
+        if ch in chars:
+            return cat
+    return None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul de la préservation par catégorie
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_early_modern_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> dict:
+    """Mesure la préservation des marqueurs typographiques de
+    l'imprimé ancien dans l'OCR.
+
+    Stratégie d'alignement
+    ----------------------
+    Pour chaque marqueur identifié dans la GT à la position ``i``,
+    on vérifie si l'OCR l'a préservé en utilisant l'alignement
+    caractère par caractère via ``difflib.SequenceMatcher`` (même
+    méthode que les Sprints 55/57) :
+
+    - Marqueur **mono-caractère** (fi, ſ, ı, &, ã…) : la position
+      ``i`` est-elle dans un opcode ``equal`` ?
+    - Marqueur **bi-caractère** (voyelle + U+0303) : les positions
+      ``i`` et ``i+1`` sont-elles toutes deux dans un opcode
+      ``equal`` ?
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_markers_reference":  int,
+            "n_markers_preserved":  int,
+            "global_preservation":  float,    # ∈ [0, 1]
+            "per_category": {
+                category: {"total", "preserved", "preservation"}
+            },
+            "missed_markers": [{"index", "marker", "category"}, ...],
+        }``
+
+    Cas dégénérés : GT vide ou sans marqueur → tous compteurs à 0,
+    ``global_preservation = 0``.
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+
+    # Forme NFD pour reconnaître les tildes nasaux décomposés (ã =
+    # 'a' + U+0303) côté GT — on conserve toutefois la forme passée
+    # pour les indices rapportés dans missed_markers.
+    markers = _detect_markers(ref)
+    n_total = len(markers)
+
+    if n_total == 0:
+        return {
+            "n_markers_reference": 0,
+            "n_markers_preserved": 0,
+            "global_preservation": 0.0,
+            "per_category": {},
+            "missed_markers": [],
+        }
+
+    # Aligner GT/hyp et récupérer le set des positions GT couvertes
+    # par un opcode "equal".
+    matcher = SequenceMatcher(a=ref, b=hyp, autojunk=False)
+    correct_positions: set[int] = set()
+    for op, i1, i2, _j1, _j2 in matcher.get_opcodes():
+        if op == "equal":
+            correct_positions.update(range(i1, i2))
+
+    per_cat_total: dict[str, int] = {}
+    per_cat_preserved: dict[str, int] = {}
+    n_preserved = 0
+    missed: list[dict] = []
+
+    for index, marker, category in markers:
+        per_cat_total[category] = per_cat_total.get(category, 0) + 1
+        # Marqueur préservé si toutes ses positions GT sont dans
+        # un opcode "equal".
+        marker_len = len(marker)
+        positions_ok = all(
+            (index + k) in correct_positions for k in range(marker_len)
+        )
+        if positions_ok:
+            per_cat_preserved[category] = (
+                per_cat_preserved.get(category, 0) + 1
+            )
+            n_preserved += 1
+        else:
+            missed.append({
+                "index": index,
+                "marker": marker,
+                "category": category,
+            })
+
+    per_category = {
+        cat: {
+            "total": per_cat_total[cat],
+            "preserved": per_cat_preserved.get(cat, 0),
+            "preservation": (
+                per_cat_preserved.get(cat, 0) / per_cat_total[cat]
+                if per_cat_total[cat] > 0
+                else 0.0
+            ),
+        }
+        for cat in sorted(per_cat_total)
+    }
+
+    return {
+        "n_markers_reference": n_total,
+        "n_markers_preserved": n_preserved,
+        "global_preservation": n_preserved / n_total,
+        "per_category": per_category,
+        "missed_markers": missed,
+    }
+
+
+def early_modern_preservation(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux global de préservation des marqueurs
+    typographiques de l'imprimé ancien."""
+    return compute_early_modern_metrics(
+        reference, hypothesis,
+    )["global_preservation"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers exposés
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def detect_markers(text: Optional[str]) -> list[tuple[int, str, str]]:
+    """Wrapper public sur ``_detect_markers`` (acceptant ``None``)."""
+    return _detect_markers(text or "")
+
+
+def get_category(char: str) -> Optional[str]:
+    """Retourne la catégorie typographique d'un caractère
+    (``ligatures``, ``long_s``, ``dotless_i``, ``ampersand``,
+    ``nasal_tildes``) ou ``None``.
+
+    Pour un tilde combinant suivi d'une voyelle, l'utilisateur doit
+    utiliser ``detect_markers`` qui gère les séquences.
+    """
+    return _category_of_char(char[0]) if char else None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="early_modern_preservation",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de préservation des marqueurs typographiques de "
+        "l'imprimé ancien (XVIᵉ-XVIIIᵉ) : ligatures fi fl ff, s long ſ, "
+        "i sans point ı, esperluette &, tildes nasaux ã õ. Critère "
+        "éditorial pour les éditions diplomatiques d'imprimés anciens."
+    ),
+    higher_is_better=True,
+    tags={"text", "typography", "early_modern", "philology"},
+)
+def _registered_early_modern(reference: str, hypothesis: str) -> float:
+    return early_modern_preservation(reference, hypothesis)
+
+
+__all__ = [
+    "LIGATURES",
+    "LONG_S",
+    "DOTLESS_I",
+    "AMPERSAND",
+    "NASAL_TILDE_PRECOMPOSED",
+    "detect_markers",
+    "get_category",
+    "compute_early_modern_metrics",
+    "early_modern_preservation",
+]

picarones/extras/historical/lexical_modernization.py

@@ -0,0 +1,263 @@
+"""Détection de la sur-normalisation lexicale par les LLM/VLM —
+Sprint 80 (A.I.7).
+
+Sprint 80 — A.I.7 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Le détecteur ``llm_hallucination_flag`` (Sprint 19) signale qu'un
+moteur sur-normalise (« 0,05 % »).  Mais ce score agrégé ne dit
+rien sur **quoi** corriger dans le prompt.  Ce module produit
+une **table de fréquences détaillée** :
+
++----------------------+--------------------+------+----------+
+| Forme historique GT  | Forme modernisée   | n GT | % modern |
++======================+====================+======+==========+
+| maistre              | maître             |   47 |     85 % |
+| nostre               | nostre             |   92 |      8 % |
+| veoir                | voir               |   23 |    100 % |
++----------------------+--------------------+------+----------+
+
+Lecture immédiate : *« le LLM modernise systématiquement
+maistre → maître ; pour préserver l'orthographe historique, ajouter
+au prompt "ne pas moderniser maistre, nostre, veoir" »*.
+
+Méthode
+-------
+Alignement mot-à-mot via ``difflib.SequenceMatcher``.  Chaque
+``replace`` ou ``equal`` produit une paire ``(gt_token,
+hyp_token)``.  On accumule pour chaque ``gt_token`` :
+
+- ``n_total`` : nombre d'occurrences du token dans la GT
+- ``n_modernized`` : nombre d'occurrences où ``hyp_token != gt_token``
+- ``variants`` : dict des hyp_tokens observés avec leur count
+
+Stop-list
+---------
+L'utilisateur peut passer ``stop_list`` (ensemble de tokens GT à
+ignorer).  Par défaut, vide — le module ne tente pas de deviner ce
+qui est « moderne » ou « historique », c'est au chercheur de
+fournir le filtre adapté à son corpus.
+
+Sortie
+------
+``compute_lexical_modernization`` retourne une structure adaptée
+au rendu HTML.  ``aggregate_lexical_modernization`` agrège
+plusieurs documents.
+
+Limites documentées
+-------------------
+- Tokenisation au niveau mot (split sur espace) — cohérent avec
+  ``taxonomy.py`` et autres modules.  Pas de stemming ni de
+  lemmatisation.
+- La métrique mesure la **réécriture lexicale** ; elle n'attrape
+  pas les modernisations infra-mot (perte du s long ſ qui se
+  fond dans la même forme).  Pour ça, voir ``early_modern_typography``
+  (Sprint 58) et ``equivalence_profile`` (Sprint 78).
+"""
+
+from __future__ import annotations
+
+import difflib
+import logging
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _split_words(text: Optional[str]) -> list[str]:
+    """Tokenisation simple par split sur whitespace."""
+    if not text:
+        return []
+    return text.split()
+
+
+def compute_lexical_modernization(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    stop_list: Optional[Iterable[str]] = None,
+    case_sensitive: bool = False,
+) -> dict:
+    """Calcule le tableau de modernisation lexicale pour un document.
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_gt_tokens": int,
+            "tokens": {
+                gt_token: {
+                    "n_total": int,
+                    "n_modernized": int,
+                    "rate_modernized": float,  # ∈ [0, 1]
+                    "variants": {hyp_token: count, ...},
+                },
+                ...
+            },
+        }``
+        Si ``reference`` est vide → ``tokens == {}``.
+    """
+    ref_tokens = _split_words(reference)
+    hyp_tokens = _split_words(hypothesis)
+    if not ref_tokens:
+        return {"n_gt_tokens": 0, "tokens": {}}
+
+    if not case_sensitive:
+        ref_for_match = [t.lower() for t in ref_tokens]
+        hyp_for_match = [t.lower() for t in hyp_tokens]
+    else:
+        ref_for_match = ref_tokens
+        hyp_for_match = hyp_tokens
+
+    stop = frozenset(
+        (t.lower() if not case_sensitive else t)
+        for t in (stop_list or [])
+    )
+
+    # On accumule par gt_token (forme display = forme originale,
+    # match key = forme casée selon ``case_sensitive``).
+    tokens_data: dict[str, dict] = {}
+
+    matcher = difflib.SequenceMatcher(
+        None, ref_for_match, hyp_for_match, autojunk=False,
+    )
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            for k in range(i2 - i1):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+        elif tag == "replace":
+            # Apparier 1-à-1 quand possible
+            paired = min(i2 - i1, j2 - j1)
+            for k in range(paired):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                hyp_orig = hyp_tokens[j1 + k]
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+                slot["n_modernized"] += 1
+                slot["variants"][hyp_orig] = slot["variants"].get(hyp_orig, 0) + 1
+            # Si plus de gt que de hyp, le reste des gt_tokens est
+            # « perdu » — on les compte comme totaux mais pas comme
+            # modernisés (on ne sait pas en quoi).
+            for k in range(paired, i2 - i1):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+                slot["n_modernized"] += 1
+                slot["variants"]["∅"] = slot["variants"].get("∅", 0) + 1
+        elif tag == "delete":
+            # gt présent, pas en hyp → modernisation par
+            # suppression (ou perte pure)
+            for k in range(i2 - i1):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+                slot["n_modernized"] += 1
+                slot["variants"]["∅"] = slot["variants"].get("∅", 0) + 1
+
+    # Calcul du taux par token
+    for slot in tokens_data.values():
+        total = slot["n_total"]
+        slot["rate_modernized"] = (
+            slot["n_modernized"] / total if total > 0 else 0.0
+        )
+
+    return {
+        "n_gt_tokens": len(ref_tokens),
+        "tokens": tokens_data,
+    }
+
+
+def aggregate_lexical_modernization(
+    per_doc_results: Iterable[dict],
+) -> dict:
+    """Agrège des ``compute_lexical_modernization`` per-doc.
+
+    Renvoie la structure agrégée corpus-wide avec la même forme
+    que ``compute_lexical_modernization``.
+    """
+    agg_tokens: dict[str, dict] = {}
+    n_gt_total = 0
+    for doc_result in per_doc_results:
+        if not doc_result:
+            continue
+        n_gt_total += doc_result.get("n_gt_tokens", 0)
+        for gt, data in (doc_result.get("tokens") or {}).items():
+            slot = agg_tokens.setdefault(
+                gt, {"n_total": 0, "n_modernized": 0, "variants": {}},
+            )
+            slot["n_total"] += data.get("n_total", 0)
+            slot["n_modernized"] += data.get("n_modernized", 0)
+            for hyp_t, count in (data.get("variants") or {}).items():
+                slot["variants"][hyp_t] = slot["variants"].get(hyp_t, 0) + count
+
+    for slot in agg_tokens.values():
+        total = slot["n_total"]
+        slot["rate_modernized"] = (
+            slot["n_modernized"] / total if total > 0 else 0.0
+        )
+    return {
+        "n_gt_tokens": n_gt_total,
+        "tokens": agg_tokens,
+    }
+
+
+def top_modernized_tokens(
+    data: dict,
+    *,
+    n: int = 20,
+    min_total: int = 1,
+) -> list[tuple[str, dict]]:
+    """Top-N tokens GT par taux de modernisation.
+
+    Filtre les tokens dont ``n_total < min_total`` (anecdotiques).
+    Tri par ``rate_modernized`` décroissant, tie-break par
+    ``n_total`` décroissant.
+    """
+    tokens = data.get("tokens") or {}
+    candidates = [
+        (gt, slot) for gt, slot in tokens.items()
+        if slot.get("n_total", 0) >= min_total
+        and slot.get("n_modernized", 0) > 0
+    ]
+    candidates.sort(
+        key=lambda pair: (
+            -pair[1].get("rate_modernized", 0.0),
+            -pair[1].get("n_total", 0),
+            pair[0],
+        ),
+    )
+    return candidates[:n]
+
+
+__all__ = [
+    "compute_lexical_modernization",
+    "aggregate_lexical_modernization",
+    "top_modernized_tokens",
+]

picarones/extras/historical/modern_archives.py

@@ -0,0 +1,600 @@
+"""Marqueurs typographiques et abréviations des archives modernes
+(XIXᵉ-XXᵉ siècles) — Sprint 59.
+
+Sprint 59 — Étape 3 / extension philologique du plan d'évolution
+2026.
+
+Pourquoi ce module
+------------------
+Les Sprints 56-57 sont orientés **médiéval scribal** (Capelli, MUFI),
+le Sprint 58 cible l'**imprimé ancien** XVIᵉ-XVIIIᵉ.  Ce sprint étend
+la couverture aux **archives modernes** (XIXᵉ-XXᵉ), période où la
+typographie historique a disparu mais où subsistent des conventions
+d'abréviation propres aux corpus institutionnels (état civil,
+recensements, presse, monographies, archives militaires).
+
+Distinction avec les modules précédents
+---------------------------------------
+- ``mufi.py`` (Sprint 57) : caractères médiévaux scribaux.
+- ``abbreviations.py`` (Sprint 56) : signes scribaux médiévaux.
+- ``early_modern_typography.py`` (Sprint 58) : marqueurs
+  typographiques imprimé ancien (fi ſ ı &…).
+- ``modern_archives.py`` (ce module) : abréviations et conventions
+  de l'archive moderne XIXᵉ-XXᵉ.
+
+Catégories
+----------
+1. ``civility_titles`` : Mme, M., Mlle, Mgr, Dr, Pr, Me, R.P., S.M.,
+   S.A.R., S.E., S.S.
+2. ``ordinals`` : 1ᵉʳ, 1ʳᵉ, 2ᵉ, 2ᵈ, Vᵉ (avec exposants Unicode)
+3. ``currency`` : ₶ (livre tournois), ₣ ƒ (franc), £, l. s. d.
+   (livre/sol/denier d'Ancien Régime)
+4. ``administrative`` : arr., dép., cant., com., reg., prov.
+5. ``civil_status`` : °, †, ✶, ⚭, ép., vve
+6. ``typographic_punctuation`` : « », –, —, …, ’
+7. ``latin_abbr_modern`` : e.g., i.e., etc., cf., ibid., op. cit.,
+   ad lib.
+8. ``bibliographic`` : vol., t., p., pp., n°, fasc., éd., ms.,
+   r°, v°
+9. ``address`` : bd, av., r., pl., imp., fbg
+
+Sortie
+------
+``compute_modern_archives_metrics(ref, hyp)`` retourne deux scores
+par catégorie (pattern Sprint 56) :
+
+- ``strict_score`` : forme abrégée préservée telle quelle ;
+- ``expansion_score`` : forme abrégée OU forme développée présente.
+
+Le **ratio strict/expansion** par catégorie permet au chercheur de
+juger lui-même la convention adoptée par chaque moteur, sans
+classification automatique imposée par le module.
+
+Stratégie de découpage
+----------------------
+Cohérente avec NER (38), Flesch (52), Reading order F1 (53),
+Layout F1 (54), Bloc Unicode (55), Abréviations (56), MUFI (57),
+Imprimé ancien (58) : couche de calcul pure d'abord ; câblage
+runner et HTML dans des sprints dédiés.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Optional
+
+from picarones.core.metric_registry import register_metric
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Tables d'abréviations par catégorie
+# ──────────────────────────────────────────────────────────────────────────
+#
+# Format : tuple ``(marker, expansions, regex_strict_pattern_or_None)``
+# où :
+#   - ``marker``                 : forme abrégée canonique (str)
+#   - ``expansions``             : tuple de formes développées
+#                                   acceptées (insensible à la casse)
+#   - ``regex_strict_pattern``   : pattern Python regex pour la
+#                                   détection dans la GT.  ``None``
+#                                   = on dérive automatiquement
+#                                   ``\b<marker_escaped>\b`` (avec
+#                                   garde-fou sur les abréviations
+#                                   contenant un point).
+#
+# Détection : pour les abréviations contenant un ``.`` (« M. »),
+# on n'utilise pas ``\b`` standard car « M.\b » match dans
+# « M.A. » (le ``.`` étant non-mot, ``\b`` est satisfait).  On
+# exige donc explicitement une frontière espace/début/fin/
+# ponctuation après le point.
+
+CIVILITY_TITLES: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("Mme",      ("Madame",)),
+    ("Mlle",     ("Mademoiselle",)),
+    ("Mgr",      ("Monseigneur",)),
+    ("Dr",       ("Docteur",)),
+    ("Pr",       ("Professeur",)),
+    ("Me",       ("Maître",)),
+    ("M.",       ("Monsieur",)),
+    ("R.P.",     ("Révérend Père",)),
+    ("S.M.",     ("Sa Majesté",)),
+    ("S.A.R.",   ("Son Altesse Royale",)),
+    ("S.E.",     ("Son Excellence",)),
+    ("S.S.",     ("Sa Sainteté",)),
+)
+
+# Ordinaux : la forme **strict** porte l'exposant Unicode
+# (1ᵉʳ U+1D49 U+02B3, 1ʳᵉ, 2ᵈ, 2ᵉ, 3ᵉ…) ; la forme **expansion**
+# accepte la version plate (« 1er », « 1re », « 2nd ») ou la forme
+# textuelle (« premier », « première »).
+#
+# On définit chaque ordinal explicitement (1-12 + Vᵉ pour les
+# numéraux romains de siècle).  Au-delà, l'exposant ᵉ seul couvre
+# les usages courants (3ᵉ, 4ᵉ, 5ᵉ, 6ᵉ, 7ᵉ, 8ᵉ, 9ᵉ, 10ᵉ).
+
+ORDINALS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("1ᵉʳ",      ("1er", "premier")),
+    ("1ʳᵉ",      ("1re", "première", "premiere")),
+    ("2ᵈ",       ("2d", "second")),
+    ("2ᵈᵉ",      ("2de", "seconde")),
+    ("2ᵉ",       ("2e", "deuxième", "deuxieme")),
+    ("3ᵉ",       ("3e", "troisième", "troisieme")),
+    ("Iᵉʳ",      ("Ier", "premier")),
+    ("Vᵉ",       ("Ve", "cinquième", "cinquieme")),
+    ("XIᵉ",      ("XIe", "onzième", "onzieme")),
+    ("XIIᵉ",     ("XIIe", "douzième", "douzieme")),
+    ("XVIᵉ",     ("XVIe", "seizième", "seizieme")),
+    ("XVIIᵉ",    ("XVIIe", "dix-septième", "dix-septieme")),
+    ("XVIIIᵉ",   ("XVIIIe", "dix-huitième", "dix-huitieme")),
+    ("XIXᵉ",     ("XIXe", "dix-neuvième", "dix-neuvieme")),
+    ("XXᵉ",      ("XXe", "vingtième", "vingtieme")),
+)
+
+CURRENCY: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("₶",        ("livre tournois", "livres tournois")),
+    ("₣",        ("franc", "francs")),
+    ("ƒ",        ("florin", "florins")),
+    ("£",        ("livre", "livres", "pound", "pounds")),
+    ("l.",       ("livre", "livres")),
+    ("s.",       ("sol", "sols", "sou", "sous")),
+    ("d.",       ("denier", "deniers")),
+)
+
+ADMINISTRATIVE: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("arr.",     ("arrondissement",)),
+    ("dép.",     ("département", "departement")),
+    ("cant.",    ("canton",)),
+    ("com.",     ("commune",)),
+    ("reg.",     ("régiment", "regiment")),
+    ("prov.",    ("province",)),
+)
+
+# État civil : signes typographiques (° = né, † = mort, ⚭ = marié)
+# et abréviations textuelles (ép. = épouse/époux, vve = veuve).
+CIVIL_STATUS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("°",        ("né", "née")),
+    ("†",        ("mort", "morte", "décédé", "décédée")),
+    ("✶",        ("naissance",)),
+    ("⚭",        ("marié", "mariée", "épousa", "epousa")),
+    ("ép.",      ("épouse", "époux", "epouse", "epoux")),
+    ("vve",      ("veuve",)),
+)
+
+# Ponctuation typographique : ces marqueurs sont préservés en
+# diplomatique et remplacés par leur équivalent ASCII en
+# modernisant.  L'expansion n'est pas une « expansion » au sens
+# linguistique mais un substitut typographique.
+TYPOGRAPHIC_PUNCTUATION: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("«",        ('"',)),
+    ("»",        ('"',)),
+    ("—",        ("-", "--")),
+    ("–",        ("-",)),
+    ("…",        ("...",)),
+    ("’",        ("'",)),
+    ("‘",        ("'",)),
+)
+
+LATIN_ABBR_MODERN: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("e.g.",     ("for example", "par exemple", "exempli gratia")),
+    ("i.e.",     ("c'est-à-dire", "id est", "that is")),
+    ("etc.",     ("et cetera", "et caetera")),
+    ("cf.",      ("confer", "voir")),
+    ("ibid.",    ("ibidem",)),
+    ("op. cit.", ("opere citato", "opus citatum")),
+    ("ad lib.",  ("ad libitum",)),
+    ("N.B.",     ("nota bene",)),
+)
+
+BIBLIOGRAPHIC: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("vol.",     ("volume",)),
+    ("t.",       ("tome",)),
+    ("p.",       ("page",)),
+    ("pp.",      ("pages",)),
+    ("n°",       ("numéro", "numero", "no")),
+    ("fasc.",    ("fascicule",)),
+    ("éd.",      ("édition", "edition")),
+    ("ms.",      ("manuscrit",)),
+    ("f.",       ("folio",)),
+    ("r°",       ("recto",)),
+    ("v°",       ("verso",)),
+)
+
+ADDRESS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("bd",       ("boulevard",)),
+    ("av.",      ("avenue",)),
+    ("r.",       ("rue",)),
+    ("pl.",      ("place",)),
+    ("imp.",     ("impasse",)),
+    ("fbg",      ("faubourg",)),
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Indexation par catégorie
+# ──────────────────────────────────────────────────────────────────────────
+
+_CATEGORIES: dict[str, tuple[tuple[str, tuple[str, ...]], ...]] = {
+    "civility_titles":          CIVILITY_TITLES,
+    "ordinals":                 ORDINALS,
+    "currency":                 CURRENCY,
+    "administrative":           ADMINISTRATIVE,
+    "civil_status":             CIVIL_STATUS,
+    "typographic_punctuation":  TYPOGRAPHIC_PUNCTUATION,
+    "latin_abbr_modern":        LATIN_ABBR_MODERN,
+    "bibliographic":            BIBLIOGRAPHIC,
+    "address":                  ADDRESS,
+}
+
+# Liste plate de tous les marqueurs avec leur catégorie.  Triée par
+# longueur décroissante pour que la détection préfère le marqueur
+# le plus long quand plusieurs préfixes matchent (ex. « S.A.R. »
+# avant « S.A. ").
+_ALL_MARKERS: list[tuple[str, tuple[str, ...], str]] = sorted(
+    [
+        (marker, expansions, category)
+        for category, entries in _CATEGORIES.items()
+        for marker, expansions in entries
+    ],
+    key=lambda triple: -len(triple[0]),
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Compilation des patterns regex
+# ──────────────────────────────────────────────────────────────────────────
+#
+# Pour chaque marqueur, on compile un pattern qui exige une
+# frontière de mot adaptée :
+#
+# - Marqueur alphabétique seul (« Mme », « bd ») → ``\b<marker>\b``
+#   (le ``\b`` Python gère correctement les bords).
+# - Marqueur contenant un point (« M. », « S.A.R. », « arr. »,
+#   « r° », « n° ») → frontière espace/début/fin/ponctuation
+#   explicite (le ``.`` final étant non-mot, ``\b`` standard
+#   matcherait dans « arr.acher »).
+# - Marqueur contenant un caractère non ASCII (exposant, monnaie,
+#   guillemet, croix d'état civil) → match littéral, pas de
+#   frontière de mot car ``\b`` ne fonctionne pas sur les
+#   caractères non-mot Unicode.
+#
+# La frontière de droite après un point exige soit la fin de
+# chaîne, soit un blanc, soit une ponctuation usuelle (« , ; : ! ? )
+# … » »).
+
+_TRAILING_BOUNDARY = r"(?=$|[\s,;:!?\)\]\»\"\'\n\r\t…])"
+_LEADING_BOUNDARY = r"(?:^|(?<=[\s,;:!?\(\[\«\"\'\n\r\t]))"
+
+
+def _is_alphanumeric_only(text: str) -> bool:
+    """Vrai si tous les caractères sont alphanumériques ASCII."""
+    return all(c.isascii() and c.isalnum() for c in text)
+
+
+def _compile_pattern(marker: str) -> re.Pattern[str]:
+    """Compile le pattern regex pour la détection d'un marqueur
+    dans la GT et l'hypothèse.
+
+    La logique de frontière de mot dépend de la composition du
+    marqueur (cf. commentaire principal).
+    """
+    escaped = re.escape(marker)
+    if "." in marker:
+        # Frontière explicite après le point final.
+        return re.compile(_LEADING_BOUNDARY + escaped + _TRAILING_BOUNDARY)
+    if _is_alphanumeric_only(marker):
+        return re.compile(r"\b" + escaped + r"\b")
+    # Marqueurs Unicode (exposants, monnaies, guillemets, ponctuation
+    # typographique, croix) : match littéral, pas de \b.
+    return re.compile(escaped)
+
+
+# Cache des patterns compilés : (marker, category) → pattern.
+_PATTERNS: dict[tuple[str, str], re.Pattern[str]] = {
+    (marker, category): _compile_pattern(marker)
+    for marker, _expansions, category in _ALL_MARKERS
+}
+
+# Patterns d'expansion (insensibles à la casse, frontière de mot
+# si la forme développée est purement alphabétique).
+_EXPANSION_PATTERNS: dict[str, list[re.Pattern[str]]] = {}
+for marker, expansions, _category in _ALL_MARKERS:
+    compiled: list[re.Pattern[str]] = []
+    for exp in expansions:
+        escaped = re.escape(exp)
+        if exp and _is_alphanumeric_only(exp):
+            compiled.append(re.compile(r"\b" + escaped + r"\b", re.IGNORECASE))
+        else:
+            compiled.append(re.compile(escaped, re.IGNORECASE))
+    _EXPANSION_PATTERNS[marker] = compiled
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# API publique : catégorisation + détection
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def get_category(marker: str) -> Optional[str]:
+    """Retourne la catégorie d'un marqueur ou ``None`` si inconnu.
+
+    La comparaison est exacte (sensible à la casse, aux exposants
+    Unicode et aux points).
+    """
+    if not marker:
+        return None
+    for category, entries in _CATEGORIES.items():
+        for known, _expansions in entries:
+            if known == marker:
+                return category
+    return None
+
+
+def get_expansions(marker: str) -> tuple[str, ...]:
+    """Retourne les formes développées connues pour un marqueur,
+    ou un tuple vide si inconnu."""
+    if not marker:
+        return ()
+    for _category, entries in _CATEGORIES.items():
+        for known, expansions in entries:
+            if known == marker:
+                return expansions
+    return ()
+
+
+def detect_modern_markers(
+    text: Optional[str],
+) -> list[tuple[int, str, str]]:
+    """Retourne les marqueurs trouvés dans ``text``.
+
+    Forme de sortie : ``[(index, marker, category), ...]`` triée
+    par index croissant.  Si plusieurs marqueurs se chevauchent, le
+    plus long gagne (ex. « S.A.R. » plutôt que « S. " puis « A.R. »).
+
+    Tolérance casse
+    ---------------
+    Les marqueurs alphabétiques courts (« Mme », « Dr », « bd »)
+    sont matchés tels quels (sensibilité à la casse) — on n'élargit
+    pas car « me » en minuscule n'est pas une abréviation de
+    « Maître ».
+    """
+    if not text:
+        return []
+    # Collecte tous les matches de tous les marqueurs.
+    candidates: list[tuple[int, int, str, str]] = []  # start, end, marker, cat
+    for marker, _expansions, category in _ALL_MARKERS:
+        pattern = _PATTERNS[(marker, category)]
+        for match in pattern.finditer(text):
+            candidates.append((match.start(), match.end(), marker, category))
+    # Tri par (start, -length) pour appliquer une stratégie greedy
+    # « plus long gagne » à chaque position.
+    candidates.sort(key=lambda c: (c[0], -(c[1] - c[0])))
+    chosen: list[tuple[int, str, str]] = []
+    last_end = -1
+    for start, end, marker, category in candidates:
+        if start < last_end:
+            continue
+        chosen.append((start, marker, category))
+        last_end = end
+    return chosen
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul des scores strict / expansion
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _hyp_contains_marker(
+    hypothesis: str, marker: str, category: str,
+) -> bool:
+    """Vrai si le marqueur est présent (au moins une occurrence) dans
+    l'hypothèse, avec la même règle de frontière qu'en GT."""
+    pattern = _PATTERNS[(marker, category)]
+    return pattern.search(hypothesis) is not None
+
+
+def _hyp_contains_expansion(hypothesis: str, marker: str) -> bool:
+    """Vrai si une forme développée connue du marqueur est présente
+    dans l'hypothèse (insensible à la casse)."""
+    for pattern in _EXPANSION_PATTERNS.get(marker, ()):
+        if pattern.search(hypothesis) is not None:
+            return True
+    return False
+
+
+def compute_modern_archives_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> dict:
+    """Calcule la préservation des marqueurs d'archives modernes.
+
+    Pour chaque catégorie : retourne le ``strict_score`` (forme
+    abrégée préservée) et l'``expansion_score`` (abrégée OU
+    développée présente).  Le ratio des deux donne au chercheur la
+    convention adoptée (diplomatique / modernisante / mixte) sans
+    qu'aucune classification ne soit imposée.
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_markers_reference": int,
+            "n_strict_preserved": int,
+            "n_expansion_preserved": int,
+            "global_strict_score": float,
+            "global_expansion_score": float,
+            "per_category": {
+                category: {
+                    "n_total": int,
+                    "n_strict_preserved": int,
+                    "n_expansion_preserved": int,
+                    "strict_score": float,
+                    "expansion_score": float,
+                }
+            },
+            "missed_markers": [
+                {"index": int, "marker": str, "category": str,
+                 "expansion_preserved": bool}
+            ],
+        }``
+
+    Cas dégénérés
+    -------------
+    - GT vide ou sans marqueur → tous les compteurs à 0, scores à
+      ``0.0``, ``per_category == {}``.
+    - GT non vide avec marqueurs + hyp vide → tous les scores à
+      ``0.0``, tous les marqueurs dans ``missed_markers``.
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+
+    detected = detect_modern_markers(ref)
+    n_total = len(detected)
+    if n_total == 0:
+        return {
+            "n_markers_reference": 0,
+            "n_strict_preserved": 0,
+            "n_expansion_preserved": 0,
+            "global_strict_score": 0.0,
+            "global_expansion_score": 0.0,
+            "per_category": {},
+            "missed_markers": [],
+        }
+
+    per_cat_total: dict[str, int] = {}
+    per_cat_strict: dict[str, int] = {}
+    per_cat_expansion: dict[str, int] = {}
+    n_strict = 0
+    n_expansion = 0
+    missed: list[dict] = []
+
+    for index, marker, category in detected:
+        per_cat_total[category] = per_cat_total.get(category, 0) + 1
+        strict_ok = _hyp_contains_marker(hyp, marker, category)
+        # Convention identique à Sprint 56 : si l'abrégé est
+        # préservé, c'est aussi un succès pour expansion (l'OCR n'a
+        # pas perdu l'information).
+        expansion_ok = strict_ok or _hyp_contains_expansion(hyp, marker)
+        if strict_ok:
+            per_cat_strict[category] = per_cat_strict.get(category, 0) + 1
+            n_strict += 1
+        if expansion_ok:
+            per_cat_expansion[category] = per_cat_expansion.get(category, 0) + 1
+            n_expansion += 1
+        if not strict_ok:
+            missed.append({
+                "index": index,
+                "marker": marker,
+                "category": category,
+                "expansion_preserved": expansion_ok,
+            })
+
+    per_category = {
+        cat: {
+            "n_total": per_cat_total[cat],
+            "n_strict_preserved": per_cat_strict.get(cat, 0),
+            "n_expansion_preserved": per_cat_expansion.get(cat, 0),
+            "strict_score": (
+                per_cat_strict.get(cat, 0) / per_cat_total[cat]
+                if per_cat_total[cat] > 0 else 0.0
+            ),
+            "expansion_score": (
+                per_cat_expansion.get(cat, 0) / per_cat_total[cat]
+                if per_cat_total[cat] > 0 else 0.0
+            ),
+        }
+        for cat in sorted(per_cat_total)
+    }
+
+    return {
+        "n_markers_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_expansion_preserved": n_expansion,
+        "global_strict_score": n_strict / n_total,
+        "global_expansion_score": n_expansion / n_total,
+        "per_category": per_category,
+        "missed_markers": missed,
+    }
+
+
+def modern_archives_strict_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux global de préservation **stricte** des
+    marqueurs d'archives modernes ∈ [0, 1]."""
+    return compute_modern_archives_metrics(
+        reference, hypothesis,
+    )["global_strict_score"]
+
+
+def modern_archives_expansion_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux global de préservation **étendue** (abrégée
+    OU développée) des marqueurs d'archives modernes ∈ [0, 1]."""
+    return compute_modern_archives_metrics(
+        reference, hypothesis,
+    )["global_expansion_score"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="modern_archives_strict_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de préservation stricte des abréviations et marqueurs "
+        "typographiques caractéristiques des archives modernes "
+        "(XIXᵉ-XXᵉ) : titres de civilité, ordinaux, monnaies, "
+        "abréviations administratives, état civil, ponctuation "
+        "typographique, abréviations latines, abréviations "
+        "bibliographiques, abréviations d'adresse. Forme abrégée "
+        "préservée telle quelle (signal d'édition diplomatique)."
+    ),
+    higher_is_better=True,
+    tags={"text", "modern_archives", "philology", "abbreviations"},
+)
+def _registered_strict(reference: str, hypothesis: str) -> float:
+    return modern_archives_strict_score(reference, hypothesis)
+
+
+@register_metric(
+    name="modern_archives_expansion_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de préservation étendue (forme abrégée OU forme "
+        "développée présente) des marqueurs d'archives modernes "
+        "XIXᵉ-XXᵉ. Le ratio strict/expansion par catégorie "
+        "permet au chercheur de juger lui-même la convention "
+        "éditoriale adoptée."
+    ),
+    higher_is_better=True,
+    tags={"text", "modern_archives", "philology", "abbreviations"},
+)
+def _registered_expansion(reference: str, hypothesis: str) -> float:
+    return modern_archives_expansion_score(reference, hypothesis)
+
+
+__all__ = [
+    "CIVILITY_TITLES",
+    "ORDINALS",
+    "CURRENCY",
+    "ADMINISTRATIVE",
+    "CIVIL_STATUS",
+    "TYPOGRAPHIC_PUNCTUATION",
+    "LATIN_ABBR_MODERN",
+    "BIBLIOGRAPHIC",
+    "ADDRESS",
+    "compute_modern_archives_metrics",
+    "detect_modern_markers",
+    "get_category",
+    "get_expansions",
+    "modern_archives_strict_score",
+    "modern_archives_expansion_score",
+]
+

picarones/extras/historical/mufi.py

@@ -0,0 +1,264 @@
+"""Couverture MUFI — Sprint 57.
+
+Sprint 57 — A.II.3.3 du plan d'évolution 2026 (clôture axe A.II.3
+philologique).
+
+Pourquoi ce module
+------------------
+La **Medieval Unicode Font Initiative** (MUFI v4.0) standardise les
+caractères médiévaux que les éditeurs critiques attendent dans une
+transcription fidèle : signes d'abréviation, ligatures, lettres
+spéciales (ƿ wynn, þ thorn), ponctuation médiévale, marques
+diacritiques rares, etc.  Pour les médiévistes, la **couverture
+MUFI** d'un moteur OCR/HTR est un critère éditorial central.
+
+Ce module mesure le taux de **caractères MUFI de la GT
+correctement restitués** dans l'OCR, après alignement caractère par
+caractère (même approche que la précision par bloc Unicode du
+Sprint 55).
+
+Détection des caractères MUFI
+-----------------------------
+La spécification MUFI v4.0 référence ~1300 caractères dans plusieurs
+plages Unicode.  Plutôt que d'embarquer la liste exhaustive (qui
+évolue), on utilise un **set de plages caractéristiques** suffisant
+pour les corpus patrimoniaux européens courants :
+
+- PUA principal (U+E000–U+F8FF) : zone usuelle des glyphes MUFI
+  qui n'ont pas (encore) de point de code Unicode standard.
+- Latin Extended-D (U+A720–U+A7FF) : abréviations latines
+  médiévales (ꝑ, ꝓ, ꝗ, etc.).
+- Combining Diacritical Marks Supplement (U+1DC0–U+1DFF) :
+  diacritiques médiévaux rares (macron suscript, etc.).
+- Alphabetic Presentation Forms (U+FB00–U+FB4F) : ligatures
+  (fi, fl, ff).
+- Une **liste explicite** de caractères médiévaux dans les blocs
+  Latin Extended-A/B/Additional (þ, ð, ƿ, ſ, æ, œ, etc.)
+
+L'utilisateur peut personnaliser via le paramètre ``custom_chars``
+de ``compute_mufi_coverage`` pour étendre ou restreindre.
+
+Stratégie de découpage
+----------------------
+Cohérente avec NER (Sprint 38), Flesch (52), Reading order F1 (53),
+Layout F1 (54), Bloc Unicode (55), Abréviations (56) : couche de
+calcul pure d'abord.  Le câblage runner et la vue HTML suivent dans
+des sprints dédiés.
+"""
+
+from __future__ import annotations
+
+import logging
+from difflib import SequenceMatcher
+from typing import Iterable, Optional
+
+from picarones.core.metric_registry import register_metric
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Plages Unicode considérées comme MUFI
+# ──────────────────────────────────────────────────────────────────────────
+
+# Triplets (nom, lo, hi) inclusifs.  Source : MUFI v4.0 spec
+# (https://mufi.info/) + revue manuelle des caractères patrimoniaux
+# courants.
+_MUFI_RANGES: tuple[tuple[str, int, int], ...] = (
+    ("Private Use Area",                          0xE000, 0xF8FF),
+    ("Latin Extended-D",                          0xA720, 0xA7FF),
+    ("Combining Diacritical Marks Supplement",    0x1DC0, 0x1DFF),
+    ("Alphabetic Presentation Forms",             0xFB00, 0xFB4F),
+)
+
+# Caractères MUFI explicites hors plages couvertes par les ranges.
+# Surtout des glyphes médiévaux standardisés en Unicode mais qui ne
+# sont pas dans le PUA ni dans Latin Extended-D : þ, ð, ƿ, ſ, æ, œ,
+# ø, ƀ, ƕ, etc.  Liste raisonnée pour les corpus européens médiévaux.
+_MUFI_EXPLICIT_CHARS: frozenset[str] = frozenset(
+    [
+        # Lettres médiévales standard
+        "þ", "Þ",  # thorn — vieil anglais, islandais
+        "ð", "Ð",  # eth — vieil anglais, islandais
+        "ƿ", "Ƿ",  # wynn — vieil anglais
+        "ſ",       # s long médiéval (déjà U+017F)
+        "æ", "Æ",  # ash
+        "œ", "Œ",  # ethel
+        "ø", "Ø",  # o barré
+        # Lettres rares avec barré (pour préfixes abréviés)
+        "ƀ",       # b barré
+        "ŧ",       # t barré
+        "đ",       # d barré
+        "ħ",       # h barré
+        # Yogh
+        "ȝ", "Ȝ",
+        # Autres signes médiévaux courants
+        "ꜿ",       # con
+        # Note : la liste est volontairement courte ; pour étendre,
+        # l'utilisateur peut passer ``custom_chars`` à
+        # ``compute_mufi_coverage``.
+    ]
+)
+
+
+def is_mufi_char(char: str, custom_chars: Optional[frozenset[str]] = None) -> bool:
+    """Retourne ``True`` si ``char`` est considéré comme MUFI.
+
+    Reconnaît :
+
+    - les caractères dans les plages Unicode MUFI (``_MUFI_RANGES``),
+    - les caractères de la liste explicite (``_MUFI_EXPLICIT_CHARS``),
+    - tout caractère supplémentaire fourni via ``custom_chars``.
+
+    Pour une chaîne multi-caractères, seul le premier code-point
+    est considéré.
+    """
+    if not char:
+        return False
+    cp = ord(char[0])
+    for _name, lo, hi in _MUFI_RANGES:
+        if lo <= cp <= hi:
+            return True
+    if char[0] in _MUFI_EXPLICIT_CHARS:
+        return True
+    if custom_chars and char[0] in custom_chars:
+        return True
+    return False
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul de couverture MUFI
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_mufi_coverage(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    custom_chars: Optional[Iterable[str]] = None,
+) -> dict:
+    """Calcule la couverture MUFI : taux de caractères MUFI de la GT
+    correctement restitués dans l'hypothèse.
+
+    Parameters
+    ----------
+    reference:
+        Texte GT.
+    hypothesis:
+        Texte produit par l'OCR.
+    custom_chars:
+        Itérable optionnel de caractères supplémentaires à considérer
+        comme MUFI (utile pour les éditeurs ayant une convention
+        propre).  Chaque entrée doit être un caractère unique.
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_mufi_chars_reference": int,    # caractères MUFI dans la GT
+            "n_mufi_chars_preserved": int,    # MUFI restitués correctement
+            "coverage": float,                 # ∈ [0, 1] ou 0 si N=0
+            "per_char": {char: {"total", "preserved", "coverage"}},
+            "missed_chars": list[str],         # caractères MUFI ratés
+        }``
+
+    Cas dégénérés
+    -------------
+    - GT vide ou sans caractère MUFI → ``coverage = 0`` (convention :
+      pas de récompense gratuite).
+    - Hyp vide + MUFI dans GT → ``coverage = 0``.
+    - GT et hyp identiques avec MUFI → ``coverage = 1``.
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+    extra: Optional[frozenset[str]] = (
+        frozenset(c for c in custom_chars if c) if custom_chars else None
+    )
+
+    # 1. Identifier les positions MUFI dans la GT
+    mufi_positions = [i for i, ch in enumerate(ref) if is_mufi_char(ch, extra)]
+    n_total = len(mufi_positions)
+
+    if n_total == 0:
+        return {
+            "n_mufi_chars_reference": 0,
+            "n_mufi_chars_preserved": 0,
+            "coverage": 0.0,
+            "per_char": {},
+            "missed_chars": [],
+        }
+
+    # 2. Aligner via SequenceMatcher (même méthode que Sprint 55)
+    matcher = SequenceMatcher(a=ref, b=hyp, autojunk=False)
+    correct_positions: set[int] = set()
+    for op, i1, i2, _j1, _j2 in matcher.get_opcodes():
+        if op == "equal":
+            correct_positions.update(range(i1, i2))
+
+    # 3. Compter par caractère
+    per_char_total: dict[str, int] = {}
+    per_char_preserved: dict[str, int] = {}
+    missed: list[str] = []
+    for i in mufi_positions:
+        ch = ref[i]
+        per_char_total[ch] = per_char_total.get(ch, 0) + 1
+        if i in correct_positions:
+            per_char_preserved[ch] = per_char_preserved.get(ch, 0) + 1
+        else:
+            missed.append(ch)
+
+    n_preserved = sum(per_char_preserved.values())
+    per_char = {
+        ch: {
+            "total": per_char_total[ch],
+            "preserved": per_char_preserved.get(ch, 0),
+            "coverage": (
+                per_char_preserved.get(ch, 0) / per_char_total[ch]
+                if per_char_total[ch] > 0
+                else 0.0
+            ),
+        }
+        for ch in sorted(per_char_total)
+    }
+
+    return {
+        "n_mufi_chars_reference": n_total,
+        "n_mufi_chars_preserved": n_preserved,
+        "coverage": n_preserved / n_total,
+        "per_char": per_char,
+        "missed_chars": missed,
+    }
+
+
+def mufi_coverage(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : retourne la couverture MUFI globale ∈ [0, 1]."""
+    return compute_mufi_coverage(reference, hypothesis)["coverage"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="mufi_coverage",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de caractères MUFI (Medieval Unicode Font Initiative) "
+        "de la GT correctement restitués dans l'OCR. Critère "
+        "éditorial central pour les médiévistes."
+    ),
+    higher_is_better=True,
+    tags={"text", "mufi", "philology", "medieval"},
+)
+def _registered_mufi_coverage(reference: str, hypothesis: str) -> float:
+    return mufi_coverage(reference, hypothesis)
+
+
+__all__ = [
+    "is_mufi_char",
+    "compute_mufi_coverage",
+    "mufi_coverage",
+]

picarones/extras/historical/philological_runner.py

@@ -0,0 +1,363 @@
+"""Helpers de câblage des métriques philologiques (Sprints 55-60) au runner.
+
+Sprint 61 — câblage backend des 6 modules philologiques :
+
+- ``unicode_blocks``    (Sprint 55)
+- ``abbreviations``     (Sprint 56)
+- ``mufi``              (Sprint 57)
+- ``early_modern``      (Sprint 58)
+- ``modern_archives``   (Sprint 59)
+- ``roman_numerals``    (Sprint 60)
+
+Principe « adaptive »
+----------------------
+Un module n'est inclus dans le résultat que si la **GT contient du
+signal exploitable** pour ce module.  Cette logique évite de polluer
+les rapports sur les corpus sans marqueurs philologiques (typique
+sur des données XXIᵉ ou des transcriptions modernes propres).
+
+Coût
+----
+Les 6 calculs sont O(N) sur la longueur du texte ; le surcoût total
+par document est négligeable face à un appel OCR.  L'activation est
+donc **automatique** (pas d'opt-in), contrairement aux backends NER
+ou calibration qui exigent une dépendance externe ou des données
+spécifiques.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from picarones.core.abbreviations import compute_abbreviation_metrics
+from picarones.core.early_modern_typography import compute_early_modern_metrics
+from picarones.core.modern_archives import compute_modern_archives_metrics
+from picarones.core.mufi import compute_mufi_coverage
+from picarones.core.roman_numerals import compute_roman_numeral_metrics
+from picarones.core.unicode_blocks import compute_unicode_block_accuracy
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Critères « le module a-t-il du signal sur ce document ? »
+# ──────────────────────────────────────────────────────────────────────────
+#
+# Pour chaque module, on définit un prédicat sur le résultat : si vrai,
+# le module est inclus ; sinon, il est omis pour ne pas alourdir le
+# rapport.
+
+def _has_unicode_signal(result: dict) -> bool:
+    # Le module retourne toujours du signal dès que GT non-vide ; on
+    # n'inclut que si la GT a au moins un caractère **hors Basic
+    # Latin** (sinon le breakdown se réduit à 100 % Basic Latin et
+    # n'apporte rien au lecteur).
+    per_block = result.get("per_block", {})
+    for block, stats in per_block.items():
+        if block == "Basic Latin":
+            continue
+        if stats.get("total", 0) > 0:
+            return True
+    return False
+
+
+def _has_abbreviation_signal(result: dict) -> bool:
+    return result.get("n_abbreviations_in_reference", 0) > 0
+
+
+def _has_mufi_signal(result: dict) -> bool:
+    return result.get("n_mufi_chars_reference", 0) > 0
+
+
+def _has_early_modern_signal(result: dict) -> bool:
+    return result.get("n_markers_reference", 0) > 0
+
+
+def _has_modern_archives_signal(result: dict) -> bool:
+    return result.get("n_markers_reference", 0) > 0
+
+
+def _has_roman_numeral_signal(result: dict) -> bool:
+    return result.get("n_numerals_reference", 0) > 0
+
+
+# Ordre fixé pour la reproductibilité des sorties.
+_PHILOLOGICAL_MODULES: tuple[
+    tuple[str, callable, callable], ...
+] = (
+    ("unicode_blocks",  compute_unicode_block_accuracy, _has_unicode_signal),
+    ("abbreviations",   compute_abbreviation_metrics,   _has_abbreviation_signal),
+    ("mufi",            compute_mufi_coverage,          _has_mufi_signal),
+    ("early_modern",    compute_early_modern_metrics,   _has_early_modern_signal),
+    ("modern_archives", compute_modern_archives_metrics, _has_modern_archives_signal),
+    ("roman_numerals",  compute_roman_numeral_metrics,  _has_roman_numeral_signal),
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul par document
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_philological_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> Optional[dict]:
+    """Calcule les 6 métriques philologiques pour un document.
+
+    Retourne un dict avec une clé par module ayant du signal, ou
+    ``None`` si aucun module n'en a (corpus sans marqueur
+    philologique pertinent).
+
+    En cas d'erreur dans un module individuel, le module est
+    silencieusement omis et un warning est émis (les autres modules
+    restent calculés).
+    """
+    ref = reference or ""
+    if not ref:
+        return None
+    out: dict = {}
+    for name, compute_fn, has_signal_fn in _PHILOLOGICAL_MODULES:
+        try:
+            result = compute_fn(ref, hypothesis or "")
+        except Exception as exc:  # pragma: no cover — défense en profondeur
+            logger.warning(
+                "[philological_runner] module %s a échoué : %s", name, exc,
+            )
+            continue
+        if has_signal_fn(result):
+            out[name] = result
+    return out if out else None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Agrégation corpus-wide par moteur
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _aggregate_unicode(per_doc: list[dict]) -> dict:
+    total_correct = 0
+    total_chars = 0
+    per_block: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        for block, stats in d.get("per_block", {}).items():
+            slot = per_block.setdefault(block, {"correct": 0, "total": 0})
+            slot["correct"] += stats.get("correct", 0)
+            slot["total"] += stats.get("total", 0)
+            total_correct += stats.get("correct", 0)
+            total_chars += stats.get("total", 0)
+    out_per_block = {
+        block: {
+            "correct": slot["correct"],
+            "total": slot["total"],
+            "accuracy": (
+                slot["correct"] / slot["total"] if slot["total"] > 0 else 0.0
+            ),
+        }
+        for block, slot in sorted(per_block.items())
+    }
+    return {
+        "global_accuracy": total_correct / total_chars if total_chars > 0 else 0.0,
+        "n_chars_total": total_chars,
+        "n_chars_correct": total_correct,
+        "per_block": out_per_block,
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_abbreviations(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_strict = 0
+    n_expansion = 0
+    per_abbr: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_abbreviations_in_reference", 0)
+        n_strict += d.get("n_strict_preserved", 0)
+        n_expansion += d.get("n_expansion_preserved", 0)
+        for entry in d.get("per_abbreviation", []):
+            slot = per_abbr.setdefault(
+                entry["abbr"],
+                {"total": 0, "strict": 0, "expansion": 0},
+            )
+            slot["total"] += 1
+            if entry.get("strict_preserved"):
+                slot["strict"] += 1
+            if entry.get("expansion_preserved"):
+                slot["expansion"] += 1
+    return {
+        "n_abbreviations_in_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_expansion_preserved": n_expansion,
+        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
+        "global_expansion_score": n_expansion / n_total if n_total > 0 else 0.0,
+        "per_abbreviation": {
+            abbr: {
+                "n_total": slot["total"],
+                "n_strict": slot["strict"],
+                "n_expansion": slot["expansion"],
+                "strict_score": slot["strict"] / slot["total"],
+                "expansion_score": slot["expansion"] / slot["total"],
+            }
+            for abbr, slot in sorted(per_abbr.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_mufi(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_preserved = 0
+    per_char: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_mufi_chars_reference", 0)
+        n_preserved += d.get("n_mufi_chars_preserved", 0)
+        for ch, stats in d.get("per_char", {}).items():
+            slot = per_char.setdefault(ch, {"total": 0, "preserved": 0})
+            slot["total"] += stats.get("total", 0)
+            slot["preserved"] += stats.get("preserved", 0)
+    return {
+        "n_mufi_chars_reference": n_total,
+        "n_mufi_chars_preserved": n_preserved,
+        "coverage": n_preserved / n_total if n_total > 0 else 0.0,
+        "per_char": {
+            ch: {
+                "total": slot["total"],
+                "preserved": slot["preserved"],
+                "coverage": slot["preserved"] / slot["total"],
+            }
+            for ch, slot in sorted(per_char.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_early_modern(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_preserved = 0
+    per_cat: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_markers_reference", 0)
+        n_preserved += d.get("n_markers_preserved", 0)
+        for cat, stats in d.get("per_category", {}).items():
+            slot = per_cat.setdefault(cat, {"total": 0, "preserved": 0})
+            slot["total"] += stats.get("total", 0)
+            slot["preserved"] += stats.get("preserved", 0)
+    return {
+        "n_markers_reference": n_total,
+        "n_markers_preserved": n_preserved,
+        "global_preservation": n_preserved / n_total if n_total > 0 else 0.0,
+        "per_category": {
+            cat: {
+                "total": slot["total"],
+                "preserved": slot["preserved"],
+                "preservation": slot["preserved"] / slot["total"],
+            }
+            for cat, slot in sorted(per_cat.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_modern_archives(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_strict = 0
+    n_expansion = 0
+    per_cat: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_markers_reference", 0)
+        n_strict += d.get("n_strict_preserved", 0)
+        n_expansion += d.get("n_expansion_preserved", 0)
+        for cat, stats in d.get("per_category", {}).items():
+            slot = per_cat.setdefault(
+                cat, {"total": 0, "strict": 0, "expansion": 0},
+            )
+            slot["total"] += stats.get("n_total", 0)
+            slot["strict"] += stats.get("n_strict_preserved", 0)
+            slot["expansion"] += stats.get("n_expansion_preserved", 0)
+    return {
+        "n_markers_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_expansion_preserved": n_expansion,
+        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
+        "global_expansion_score": n_expansion / n_total if n_total > 0 else 0.0,
+        "per_category": {
+            cat: {
+                "n_total": slot["total"],
+                "n_strict_preserved": slot["strict"],
+                "n_expansion_preserved": slot["expansion"],
+                "strict_score": slot["strict"] / slot["total"],
+                "expansion_score": slot["expansion"] / slot["total"],
+            }
+            for cat, slot in sorted(per_cat.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_roman_numerals(per_doc: list[dict]) -> dict:
+    from picarones.core.roman_numerals import ALL_STATUSES, VALUE_PRESERVING_STATUSES
+
+    n_total = 0
+    per_status: dict[str, int] = {s: 0 for s in ALL_STATUSES}
+    for d in per_doc:
+        n_total += d.get("n_numerals_reference", 0)
+        for status, count in d.get("per_status", {}).items():
+            per_status[status] = per_status.get(status, 0) + count
+    n_strict = per_status.get("strict_preserved", 0)
+    n_value = sum(per_status.get(s, 0) for s in VALUE_PRESERVING_STATUSES)
+    return {
+        "n_numerals_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_value_preserved": n_value,
+        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
+        "global_value_score": n_value / n_total if n_total > 0 else 0.0,
+        "per_status": per_status,
+        "doc_count": len(per_doc),
+    }
+
+
+_AGGREGATORS = {
+    "unicode_blocks":   _aggregate_unicode,
+    "abbreviations":    _aggregate_abbreviations,
+    "mufi":             _aggregate_mufi,
+    "early_modern":     _aggregate_early_modern,
+    "modern_archives":  _aggregate_modern_archives,
+    "roman_numerals":   _aggregate_roman_numerals,
+}
+
+
+def aggregate_philological_metrics(
+    doc_metrics: list[Optional[dict]],
+) -> Optional[dict]:
+    """Agrège les ``philological_metrics`` per-document en un dict
+    corpus-wide par module.
+
+    Pour chaque module, on agrège uniquement les documents qui ont
+    eu du signal pour ce module.  Si aucun module n'a été calculé
+    sur aucun document, retourne ``None``.
+    """
+    by_module: dict[str, list[dict]] = {}
+    for doc in doc_metrics:
+        if not doc:
+            continue
+        for module, payload in doc.items():
+            by_module.setdefault(module, []).append(payload)
+    if not by_module:
+        return None
+    out: dict = {}
+    for module, payloads in by_module.items():
+        aggregator = _AGGREGATORS.get(module)
+        if aggregator is None:  # pragma: no cover
+            logger.warning(
+                "[philological_runner] aucun agrégateur pour %s", module,
+            )
+            continue
+        out[module] = aggregator(payloads)
+    return out if out else None
+
+
+__all__ = [
+    "compute_philological_metrics",
+    "aggregate_philological_metrics",
+]

picarones/extras/historical/roman_numerals.py

@@ -0,0 +1,478 @@
+"""Numéraux romains — Sprint 60.
+
+Sprint 60 — Étape 3 / extension philologique transversale du plan
+d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Les numéraux romains traversent **toutes les périodes patrimoniales**
+servies par Picarones :
+
+- **Médiéval** : minuscules avec ``j`` final pour le dernier ``i``
+  (``ij`` = 2, ``iij`` = 3, ``viij`` = 8, ``mcclxxxij`` = 1282).
+  Convention scribale standard dans les chartes et registres.
+- **Imprimé ancien** : majuscules (``Tome IV``, ``Chap. VII``).
+- **Moderne** : majuscules pour les souverains (``Louis XIV``) et
+  les siècles (``XIXᵉ siècle`` — la partie exposant ᵉ est gérée
+  par le Sprint 59 ``ordinals``, ce module ne traite que la partie
+  numérale ``XIX``).
+
+Quatre traitements possibles d'un numéral par l'OCR
+----------------------------------------------------
+Pour chaque numéral romain présent dans la GT, l'OCR peut :
+
+1. **Préserver strictement** : forme exacte gardée
+   (``mcclxxxij`` → ``mcclxxxij``).  Édition diplomatique idéale.
+2. **Préserver en changeant la casse** : la valeur est intacte mais
+   la convention typographique est modifiée
+   (``xiv`` → ``XIV``).  Modernisation typographique courante.
+3. **Préserver en supprimant le ``j`` final** :
+   (``mcclxxxij`` → ``mcclxxxii``).  Modernisation orthographique
+   médiévale → standard académique moderne.
+4. **Convertir en chiffres arabes** : la valeur est préservée mais
+   le système de numération est modernisé
+   (``XIV`` → ``14``).  Modernisation profonde, perte de
+   l'information typographique.
+5. **Perdre** : aucune trace de la valeur dans l'hypothèse.
+
+Ce module retourne un breakdown par statut pour que le chercheur
+juge lui-même la convention adoptée par chaque moteur, **sans
+classification automatique imposée**.
+
+Stratégie de découpage
+----------------------
+Cohérente avec NER (38), Flesch (52), Reading order F1 (53),
+Layout F1 (54), Bloc Unicode (55), Abréviations (56), MUFI (57),
+Imprimé ancien (58), Archives modernes (59) : couche de calcul
+pure d'abord ; câblage runner et HTML dans des sprints dédiés.
+
+Limites documentées
+-------------------
+- Détection greedy par regex ``\\b[IVXLCDMivxlcdmj]+\\b`` puis
+  validation par parsing.  Les faux positifs restent possibles sur
+  des mots courts (``I`` pronom anglais, ``MM`` initiales, ``LL``).
+  Le paramètre ``min_length`` permet de filtrer les single-letter.
+- Pas de gestion des notations rares avec barre suscript pour
+  multiplier par 1000 (V̄ = 5000, X̄ = 10000) — usage très rare en
+  corpus patrimonial européen courant.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Optional
+
+from picarones.core.metric_registry import register_metric
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Table de conversion + parsing
+# ──────────────────────────────────────────────────────────────────────────
+
+ROMAN_VALUES: dict[str, int] = {
+    "I": 1,    "V": 5,    "X": 10,
+    "L": 50,   "C": 100,  "D": 500,  "M": 1000,
+}
+
+# Caractères acceptés en entrée (incluant minuscules + j médiéval).
+_ROMAN_CHARS = "IVXLCDMivxlcdmj"
+_ROMAN_RE = re.compile(rf"\b[{_ROMAN_CHARS}]+\b")
+
+
+def _normalize_roman(s: str) -> str:
+    """Normalise un numéral romain : majuscule + ``j`` final → ``i``.
+
+    Les manuscrits médiévaux notent traditionnellement le dernier
+    ``i`` d'une suite par ``j`` (« ij », « iij », « viij »…).  On
+    convertit pour pouvoir parser comme un numéral standard.
+    """
+    if not s:
+        return ""
+    upper = s.upper()
+    if upper.endswith("J"):
+        upper = upper[:-1] + "I"
+    return upper
+
+
+def _parse_normalized_roman(s: str) -> Optional[int]:
+    """Parse un numéral romain **après normalisation** (majuscule,
+    sans ``j`` médiéval).  Retourne ``None`` si la chaîne n'est pas
+    un numéral romain valide.
+
+    Validation : on parse en additionnant/soustrayant selon la règle
+    classique, puis on **regénère la forme standard** et on compare
+    pour rejeter les formes non canoniques (« IIII » au lieu de
+    « IV », « VV » au lieu de « X »).  Cette stricte validation
+    garantit qu'on ne compte pas des séquences absurdes comme
+    « XXXX » comme un numéral.
+
+    Note : les manuscrits médiévaux utilisent fréquemment « IIII »
+    pour 4 (notation soustractive plus tardive).  On accepte donc
+    aussi cette forme via une règle relâchée : tant que les valeurs
+    sont décroissantes ou suivent la règle soustractive standard,
+    on accepte.
+    """
+    if not s or not all(c in "IVXLCDM" for c in s):
+        return None
+    # Calcul par soustraction.
+    total = 0
+    prev_value = 0
+    for ch in reversed(s):
+        v = ROMAN_VALUES[ch]
+        if v < prev_value:
+            total -= v
+        else:
+            total += v
+        prev_value = v
+    if total <= 0:
+        return None
+    # Validation relâchée : on accepte les formes médiévales (IIII,
+    # VIIII) mais on rejette les vraiment absurdes (IIIII, VVVV).
+    if not _is_plausible_roman(s):
+        return None
+    return total
+
+
+def _is_plausible_roman(s: str) -> bool:
+    """Validation relâchée d'un numéral romain (majuscule).
+
+    On rejette :
+
+    - 5 caractères identiques d'affilée ou plus (« IIIII », « XXXXX »).
+    - Les répétitions de V, L, D (jamais répétés en notation
+      classique : « VV », « LL », « DD »).
+    - Les paires soustractives non standard.  En romain canonique,
+      seules sont valides : IV, IX, XL, XC, CD, CM.  Toute autre
+      combinaison « petit avant grand » est rejetée.  Cela élimine
+      les faux positifs sur des mots français comme « ici » (qui
+      formerait sinon « I + C » = 99) ou « IL » qui formerait 49.
+    """
+    if not s:
+        return False
+    # Pas de répétitions invalides
+    for forbidden in ("VV", "LL", "DD", "IIIII", "XXXXX", "CCCCC", "MMMMMM"):
+        if forbidden in s:
+            return False
+    # Paires soustractives autorisées (toutes les autres sont rejetées)
+    legal_subtractive = {"IV", "IX", "XL", "XC", "CD", "CM"}
+    for i in range(len(s) - 1):
+        a, b = s[i], s[i + 1]
+        if ROMAN_VALUES[a] < ROMAN_VALUES[b]:
+            if (a + b) not in legal_subtractive:
+                return False
+    return True
+
+
+def roman_to_int(s: Optional[str]) -> Optional[int]:
+    """Convertit une chaîne en numéral romain entier.  Tolère casse
+    et ``j`` médiéval final.  Retourne ``None`` si invalide.
+    """
+    if not s:
+        return None
+    return _parse_normalized_roman(_normalize_roman(s))
+
+
+def int_to_roman(n: int) -> str:
+    """Convertit un entier en numéral romain majuscule standard.
+
+    Utilise la notation classique (IV, IX, XL, XC, CD, CM) — pas la
+    forme médiévale relâchée.
+    """
+    if n <= 0:
+        raise ValueError("n must be positive")
+    pairs = [
+        (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
+        (100, "C"),  (90, "XC"),  (50, "L"),  (40, "XL"),
+        (10, "X"),   (9, "IX"),   (5, "V"),   (4, "IV"),
+        (1, "I"),
+    ]
+    out: list[str] = []
+    for value, symbol in pairs:
+        while n >= value:
+            out.append(symbol)
+            n -= value
+    return "".join(out)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Détection dans le texte
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def detect_roman_numerals(
+    text: Optional[str],
+    *,
+    min_length: int = 1,
+) -> list[tuple[int, str, int]]:
+    """Retourne les numéraux romains valides dans ``text``.
+
+    Forme : ``[(start_index, numeral_string, integer_value), ...]``
+    triée par index croissant.
+
+    Parameters
+    ----------
+    text:
+        Texte à analyser.
+    min_length:
+        Longueur minimale d'un numéral retenu.  Par défaut ``1``.
+        Mettre à ``2`` pour filtrer les single-letter ambigus (``I``
+        pronom, ``M`` initiale).
+
+    Faux positifs connus
+    --------------------
+    - ``I`` (pronom anglais), ``M`` ou ``D`` en initiale d'une
+      personne ne peuvent pas être distingués sans NER.  Le chercheur
+      qui s'inquiète de ces faux positifs peut passer
+      ``min_length=2``.
+    """
+    if not text:
+        return []
+    found: list[tuple[int, str, int]] = []
+    for match in _ROMAN_RE.finditer(text):
+        s = match.group(0)
+        if len(s) < min_length:
+            continue
+        value = roman_to_int(s)
+        if value is None:
+            continue
+        found.append((match.start(), s, value))
+    return found
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Classification de la restitution dans l'hypothèse
+# ──────────────────────────────────────────────────────────────────────────
+
+# Statuts possibles, dans l'ordre de priorité (un numéral est
+# classé selon le premier statut qui s'applique).
+
+STATUS_STRICT_PRESERVED   = "strict_preserved"
+STATUS_CASE_CHANGED       = "case_changed"
+STATUS_J_DROPPED          = "j_dropped"
+STATUS_CONVERTED_TO_ARABIC = "converted_to_arabic"
+STATUS_LOST               = "lost"
+
+ALL_STATUSES = (
+    STATUS_STRICT_PRESERVED,
+    STATUS_CASE_CHANGED,
+    STATUS_J_DROPPED,
+    STATUS_CONVERTED_TO_ARABIC,
+    STATUS_LOST,
+)
+
+# Statuts qui indiquent une préservation de la valeur (par opposition
+# à la perte).
+VALUE_PRESERVING_STATUSES = frozenset({
+    STATUS_STRICT_PRESERVED,
+    STATUS_CASE_CHANGED,
+    STATUS_J_DROPPED,
+    STATUS_CONVERTED_TO_ARABIC,
+})
+
+
+def _classify_restitution(numeral: str, value: int, hyp: str) -> str:
+    """Classifie comment ``numeral`` (de valeur ``value``) est
+    restitué dans ``hyp`` selon les 5 statuts définis."""
+    # 1. Forme stricte présente
+    if re.search(r"(?<![A-Za-z])" + re.escape(numeral) + r"(?![A-Za-z])", hyp):
+        return STATUS_STRICT_PRESERVED
+    # 2. Variante de casse seule
+    swapped = numeral.swapcase()
+    if swapped != numeral and re.search(
+        r"(?<![A-Za-z])" + re.escape(swapped) + r"(?![A-Za-z])", hyp,
+    ):
+        return STATUS_CASE_CHANGED
+    # 3. ``j`` final remplacé par ``i`` (ou inverse)
+    if numeral.lower().endswith("j"):
+        no_j = numeral[:-1] + ("I" if numeral[-1] == "J" else "i")
+    elif numeral.lower().endswith("i"):
+        no_j = numeral[:-1] + ("J" if numeral[-1] == "I" else "j")
+    else:
+        no_j = numeral
+    if no_j != numeral and re.search(
+        r"(?<![A-Za-z])" + re.escape(no_j) + r"(?![A-Za-z])", hyp,
+    ):
+        return STATUS_J_DROPPED
+    # Variante de casse + j-flip combinés
+    no_j_swapped = no_j.swapcase()
+    if no_j_swapped != numeral and re.search(
+        r"(?<![A-Za-z])" + re.escape(no_j_swapped) + r"(?![A-Za-z])", hyp,
+    ):
+        return STATUS_J_DROPPED
+    # 4. Conversion en chiffres arabes
+    if re.search(r"(?<!\d)" + str(value) + r"(?!\d)", hyp):
+        return STATUS_CONVERTED_TO_ARABIC
+    # 5. Perdu
+    return STATUS_LOST
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul de la métrique
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_roman_numeral_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    min_length: int = 1,
+) -> dict:
+    """Calcule la préservation des numéraux romains.
+
+    Pour chaque numéral romain dans la GT, on classifie sa
+    restitution dans l'hypothèse selon l'un des 5 statuts (forme
+    stricte / casse modifiée / j supprimé / conversion arabe / perdu).
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_numerals_reference": int,
+            "n_strict_preserved": int,
+            "n_value_preserved": int,    # tous statuts sauf LOST
+            "global_strict_score": float,
+            "global_value_score": float,
+            "per_status": {status: count for status in ALL_STATUSES},
+            "per_numeral": [
+                {"index", "numeral", "value", "status"}
+            ],
+            "lost_numerals": [
+                {"index", "numeral", "value"}
+            ],
+        }``
+
+    Cas dégénérés
+    -------------
+    - GT vide ou sans numéral → tous compteurs à 0, scores à 0.0,
+      ``per_status`` initialisé à 0 sur tous les statuts.
+    - GT avec numéraux + hyp vide → tous classés ``lost``,
+      strict_score = value_score = 0.0.
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+
+    detected = detect_roman_numerals(ref, min_length=min_length)
+    n_total = len(detected)
+    per_status_init = {status: 0 for status in ALL_STATUSES}
+
+    if n_total == 0:
+        return {
+            "n_numerals_reference": 0,
+            "n_strict_preserved": 0,
+            "n_value_preserved": 0,
+            "global_strict_score": 0.0,
+            "global_value_score": 0.0,
+            "per_status": per_status_init,
+            "per_numeral": [],
+            "lost_numerals": [],
+        }
+
+    per_status: dict[str, int] = dict(per_status_init)
+    per_numeral: list[dict] = []
+    lost: list[dict] = []
+    for index, numeral, value in detected:
+        status = _classify_restitution(numeral, value, hyp)
+        per_status[status] = per_status.get(status, 0) + 1
+        per_numeral.append({
+            "index": index,
+            "numeral": numeral,
+            "value": value,
+            "status": status,
+        })
+        if status == STATUS_LOST:
+            lost.append({"index": index, "numeral": numeral, "value": value})
+
+    n_strict = per_status[STATUS_STRICT_PRESERVED]
+    n_value = sum(per_status[s] for s in VALUE_PRESERVING_STATUSES)
+
+    return {
+        "n_numerals_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_value_preserved": n_value,
+        "global_strict_score": n_strict / n_total,
+        "global_value_score": n_value / n_total,
+        "per_status": per_status,
+        "per_numeral": per_numeral,
+        "lost_numerals": lost,
+    }
+
+
+def roman_numeral_strict_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux global de préservation **stricte** des
+    numéraux romains ∈ [0, 1]."""
+    return compute_roman_numeral_metrics(
+        reference, hypothesis,
+    )["global_strict_score"]
+
+
+def roman_numeral_value_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux global de préservation de la **valeur** des
+    numéraux romains (toute forme confondue : strict, case_changed,
+    j_dropped, arabe) ∈ [0, 1]."""
+    return compute_roman_numeral_metrics(
+        reference, hypothesis,
+    )["global_value_score"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="roman_numeral_strict_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de préservation stricte des numéraux romains "
+        "(forme exacte gardée : casse, j médiéval final). "
+        "Métrique transversale aux périodes médiévale, imprimé "
+        "ancien et moderne."
+    ),
+    higher_is_better=True,
+    tags={"text", "roman_numerals", "philology"},
+)
+def _registered_strict(reference: str, hypothesis: str) -> float:
+    return roman_numeral_strict_score(reference, hypothesis)
+
+
+@register_metric(
+    name="roman_numeral_value_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de préservation de la valeur numérique des numéraux "
+        "romains, indépendamment de la forme (strict, casse "
+        "changée, j supprimé, conversion en chiffres arabes). "
+        "Le breakdown per_status permet au chercheur de juger la "
+        "convention adoptée."
+    ),
+    higher_is_better=True,
+    tags={"text", "roman_numerals", "philology"},
+)
+def _registered_value(reference: str, hypothesis: str) -> float:
+    return roman_numeral_value_score(reference, hypothesis)
+
+
+__all__ = [
+    "ROMAN_VALUES",
+    "ALL_STATUSES",
+    "STATUS_STRICT_PRESERVED",
+    "STATUS_CASE_CHANGED",
+    "STATUS_J_DROPPED",
+    "STATUS_CONVERTED_TO_ARABIC",
+    "STATUS_LOST",
+    "VALUE_PRESERVING_STATUSES",
+    "compute_roman_numeral_metrics",
+    "detect_roman_numerals",
+    "int_to_roman",
+    "roman_numeral_strict_score",
+    "roman_numeral_value_score",
+    "roman_to_int",
+]

picarones/extras/historical/unicode_blocks.py

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

picarones/extras/render/lexical_modernization_render.py

@@ -0,0 +1,119 @@
+"""Rendu HTML de la vue « Modernisation lexicale » — Sprint 80.
+
+A.I.7 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/lexical_modernization.py``.
+Pattern identique aux autres rendus (Sprints 41/43/62/67/72/74/75/76/77) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Vue
+---
+Tableau trié par taux de modernisation décroissant : forme
+historique GT → forme(s) modernisée(s), occurrences GT, %.
+Couleur de cellule pour le %.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.core.lexical_modernization import top_modernized_tokens
+
+
+def _color_for_rate(rate: float) -> str:
+    """Gradient blanc → orange profond pour rate ∈ [0, 1]."""
+    f = max(0.0, min(1.0, rate))
+    r = int(255 + (194 - 255) * f)
+    g = int(255 + (65 - 255) * f)
+    b = int(255 + (12 - 255) * f)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _format_variants(variants: dict, max_show: int = 3) -> str:
+    """Liste compacte des variants modernisés."""
+    items = sorted(variants.items(), key=lambda kv: -kv[1])
+    shown = items[:max_show]
+    rest = len(items) - max_show
+    parts = [
+        f"{_e(form)} ({count})"
+        for form, count in shown
+    ]
+    if rest > 0:
+        parts.append(f"+{rest}")
+    return ", ".join(parts)
+
+
+def build_lexical_modernization_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+    *,
+    top_n: int = 20,
+    min_total: int = 1,
+) -> str:
+    """Construit la table HTML de modernisation lexicale.
+
+    Retourne ``""`` si ``data is None`` ou si aucun token modernisé.
+    """
+    if not data:
+        return ""
+    rows = top_modernized_tokens(data, n=top_n, min_total=min_total)
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "lexmod_title", "Modernisation lexicale (top tokens)",
+    )
+    note = labels.get(
+        "lexmod_note",
+        "Tokens GT que le moteur réécrit le plus souvent. "
+        "Lecture : « maistre → maître modernisé dans 85 % des cas » "
+        "indique de quoi corriger dans le prompt pour préserver "
+        "l'orthographe historique.",
+    )
+    gt_label = labels.get("lexmod_gt_label", "Forme historique GT")
+    hyp_label = labels.get("lexmod_hyp_label", "Variantes OCR")
+    n_label = labels.get("lexmod_n_label", "n GT")
+    rate_label = labels.get("lexmod_rate_label", "% modernisé")
+
+    parts = [
+        '<div class="lexmod" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">',
+        '<thead><tr>',
+    ]
+    for col in (gt_label, hyp_label, n_label, rate_label):
+        parts.append(
+            f'<th style="padding:.3rem .5rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+    for gt_token, slot in rows:
+        rate = slot.get("rate_modernized", 0.0)
+        n_total = slot.get("n_total", 0)
+        variants_str = _format_variants(slot.get("variants") or {})
+        rate_color = _color_for_rate(rate)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.3rem .5rem;font-family:monospace">'
+            f'{_e(gt_token)}</td>'
+            f'<td style="padding:.3rem .5rem;font-size:.85rem">'
+            f'{variants_str}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-family:monospace">{n_total}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'background:{rate_color};font-family:monospace">'
+            f'{rate * 100:.0f}%</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_lexical_modernization_html",
+]

picarones/extras/render/philological_render.py

@@ -0,0 +1,615 @@
+"""Rendu HTML server-side du profil philologique (Sprint 62).
+
+Suite directe Sprint 61 (câblage backend) — produit les blocs HTML
+qui exposent les six modules philologiques (Sprints 55-60) dans le
+rapport :
+
+- ``unicode_blocks``    (Sprint 55) — précision par bloc Unicode
+- ``abbreviations``     (Sprint 56) — score strict + expansion par
+                                       abréviation médiévale Capelli
+- ``mufi``              (Sprint 57) — couverture MUFI globale + par
+                                       caractère
+- ``early_modern``      (Sprint 58) — préservation des marqueurs
+                                       typographiques imprimé ancien
+- ``modern_archives``   (Sprint 59) — strict + expansion par
+                                       catégorie d'archive moderne
+- ``roman_numerals``    (Sprint 60) — breakdown 5 statuts de
+                                       restitution
+
+Principe identique aux Sprints 41 (NER) et 43 (calibration) :
+
+- Rendu **server-side**, pas de JavaScript, déterministe.
+- Section adaptive : si aucun moteur n'a de signal pour un module
+  donné, la sous-section est silencieusement omise.
+- Si **aucun module** n'a de signal sur l'ensemble des moteurs,
+  ``build_philological_profile_html`` retourne une chaîne vide et
+  le bloc complet n'apparaît pas dans la vue analyses.
+- **Aucune classification automatique** : on affiche les chiffres
+  bruts par catégorie/bloc/statut, le chercheur juge lui-même la
+  convention adoptée.
+- Anti-injection : tous les noms de moteurs, catégories, statuts,
+  caractères passent par ``html.escape`` avant insertion.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers de coloration
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _color_for_score(score: float) -> str:
+    """Gradient rouge → jaune → vert proportionnel à ``score`` ∈ [0, 1].
+
+    Identique à ``ner_render._color_for_f1``.  Les scores
+    philologiques (preservation, coverage, accuracy) suivent la même
+    sémantique « plus c'est haut, mieux c'est » donc le gradient
+    est valide.
+    """
+    f = max(0.0, min(1.0, score))
+    if f <= 0.5:
+        ratio = f / 0.5
+        r = int(220 + (240 - 220) * ratio)
+        g = int(100 + (220 - 100) * ratio)
+        b = int(100 + (130 - 100) * ratio)
+    else:
+        ratio = (f - 0.5) / 0.5
+        r = int(240 + (130 - 240) * ratio)
+        g = int(220 + (200 - 220) * ratio)
+        b = int(130 + (130 - 130) * ratio)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _engines_with_module(
+    engines_summary: list[dict], module: str,
+) -> list[dict]:
+    """Filtre les moteurs ayant des données pour le module donné."""
+    out: list[dict] = []
+    for eng in engines_summary:
+        agg = eng.get("aggregated_philological") or {}
+        if module in agg and agg[module]:
+            out.append(eng)
+    return out
+
+
+def _score_cell(score: Optional[float], extra: str = "") -> str:
+    """Rend une cellule colorée.  ``None`` → cellule grise « — »."""
+    if score is None:
+        return (
+            '<td style="padding:.3rem .5rem;text-align:center;'
+            'background:#f0f0f0;color:#999">—</td>'
+        )
+    color = _color_for_score(score)
+    text = f"{score * 100:.1f}%"
+    if extra:
+        text += f" <span style=\"opacity:.6;font-size:.85em\">({_e(extra)})</span>"
+    return (
+        f'<td style="padding:.3rem .5rem;text-align:center;'
+        f'background:{color}">{text}</td>'
+    )
+
+
+def _table_header(
+    columns: list[str], engine_label: str,
+) -> str:
+    """Construit l'entête d'un tableau moteur × colonnes."""
+    parts = [
+        '<thead><tr>',
+        f'<th style="padding:.3rem .5rem;text-align:left;'
+        f'border-bottom:1px solid var(--border);font-weight:600">'
+        f'{_e(engine_label)}</th>',
+    ]
+    for col in columns:
+        parts.append(
+            f'<th style="padding:.3rem .5rem;text-align:center;'
+            f'border-bottom:1px solid var(--border);font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append('</tr></thead>')
+    return "".join(parts)
+
+
+def _engine_label_cell(name: str) -> str:
+    return (
+        f'<td style="padding:.3rem .5rem;font-weight:500;'
+        f'border-bottom:1px solid var(--border-light)">{_e(name)}</td>'
+    )
+
+
+def _section_open(title: str, note: str = "") -> str:
+    parts = [
+        '<div class="philological-section" '
+        'style="margin:1rem 0;padding:.75rem;'
+        'background:var(--bg-secondary);border-radius:6px">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+    ]
+    if note:
+        parts.append(
+            f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
+            f'{_e(note)}</div>'
+        )
+    return "".join(parts)
+
+
+def _section_close() -> str:
+    return "</div>"
+
+
+def _table_open() -> str:
+    return (
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">'
+    )
+
+
+def _table_close() -> str:
+    return "</table>"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 55 — Précision par bloc Unicode
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_unicode_blocks_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "unicode_blocks")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_unicode_blocks_title", "Précision par bloc Unicode",
+    )
+    note = labels.get(
+        "philo_unicode_blocks_note",
+        "Pourcentage de caractères correctement restitués par bloc "
+        "Unicode rencontré dans la GT (hors Basic Latin).",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    global_label = labels.get("philo_global_label", "Global")
+
+    # Collecte tous les blocs présents (hors Basic Latin déjà filtré
+    # par adaptive masking, mais on défilte ici si Basic Latin
+    # apparaît malgré tout chez certains moteurs).
+    all_blocks: set[str] = set()
+    for eng in relevant:
+        per_block = eng["aggregated_philological"]["unicode_blocks"].get(
+            "per_block", {},
+        )
+        for block in per_block:
+            if block != "Basic Latin":
+                all_blocks.add(block)
+    blocks = sorted(all_blocks)
+    if not blocks:
+        return ""
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header([global_label] + blocks, engine_label))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["unicode_blocks"]
+        global_acc = agg.get("global_accuracy", 0.0)
+        n_chars = agg.get("n_chars_total", 0)
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(global_acc, extra=f"n={n_chars}"))
+        per_block = agg.get("per_block", {})
+        for block in blocks:
+            stats = per_block.get(block)
+            if stats and stats.get("total", 0) > 0:
+                parts.append(_score_cell(
+                    stats["accuracy"], extra=f"n={stats['total']}",
+                ))
+            else:
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# (sections suivantes définies plus loin)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 56 — Abréviations Capelli médiévales
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_abbreviations_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "abbreviations")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_abbreviations_title",
+        "Abréviations médiévales (Capelli)",
+    )
+    note = labels.get(
+        "philo_abbreviations_note",
+        "Strict = forme abrégée (ꝑ, ꝓ, ⁊…) préservée telle quelle ; "
+        "Expansion = abrégée OU forme développée (per, pro, et…) "
+        "présente. Le ratio strict/expansion par moteur indique la "
+        "convention adoptée (diplomatique / modernisante).",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    strict_label = labels.get("philo_strict_label", "Strict")
+    expansion_label = labels.get("philo_expansion_label", "Expansion")
+    n_label = labels.get("philo_n_total_label", "n total")
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header(
+        [strict_label, expansion_label, n_label], engine_label,
+    ))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["abbreviations"]
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
+        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:center">'
+            f'{agg.get("n_abbreviations_in_reference", 0)}</td>'
+        )
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 57 — Couverture MUFI
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_mufi_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "mufi")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_mufi_title",
+        "Couverture MUFI (Medieval Unicode Font Initiative)",
+    )
+    note = labels.get(
+        "philo_mufi_note",
+        "Taux de caractères MUFI de la GT (þ, ð, ƿ, ſ, æ, lettres "
+        "PUA…) correctement restitués dans l'OCR. Critère éditorial "
+        "central pour les médiévistes.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    coverage_label = labels.get("philo_mufi_coverage_label", "Couverture")
+    n_label = labels.get("philo_n_total_label", "n total")
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header(
+        [coverage_label, n_label], engine_label,
+    ))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["mufi"]
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(agg.get("coverage", 0.0)))
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:center">'
+            f'{agg.get("n_mufi_chars_reference", 0)}</td>'
+        )
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 58 — Marqueurs typographiques imprimé ancien (heatmap)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_early_modern_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "early_modern")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_early_modern_title",
+        "Marqueurs typographiques imprimé ancien (XVIᵉ-XVIIIᵉ)",
+    )
+    note = labels.get(
+        "philo_early_modern_note",
+        "Préservation des ligatures (fi fl ff), s long (ſ), i sans "
+        "point (ı), esperluette (&) et tildes nasaux (ã õ ñ). "
+        "Une ligne par moteur, une colonne par catégorie.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    global_label = labels.get("philo_global_label", "Global")
+
+    all_cats: set[str] = set()
+    for eng in relevant:
+        all_cats.update(
+            eng["aggregated_philological"]["early_modern"]
+            .get("per_category", {}).keys(),
+        )
+    cats = sorted(all_cats)
+    if not cats:
+        return ""
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header([global_label] + cats, engine_label))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["early_modern"]
+        n_total = agg.get("n_markers_reference", 0)
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(
+            agg.get("global_preservation", 0.0), extra=f"n={n_total}",
+        ))
+        per_cat = agg.get("per_category", {})
+        for cat in cats:
+            stats = per_cat.get(cat)
+            if stats and stats.get("total", 0) > 0:
+                parts.append(_score_cell(
+                    stats["preservation"], extra=f"n={stats['total']}",
+                ))
+            else:
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 59 — Archives modernes : strict + expansion par catégorie
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_modern_archives_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "modern_archives")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_modern_archives_title",
+        "Abréviations des archives modernes (XIXᵉ-XXᵉ)",
+    )
+    note = labels.get(
+        "philo_modern_archives_note",
+        "Strict = abrégé préservé (Mme, S.A.R., bd, vol., …) ; "
+        "Expansion = abrégé OU forme développée. Affiché par "
+        "catégorie : civilité, ordinaux, monnaie, administratif, "
+        "état civil, ponctuation typo, latin, biblio, adresse.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    global_label = labels.get("philo_global_label", "Global")
+    strict_label = labels.get("philo_strict_label", "Strict")
+    expansion_label = labels.get("philo_expansion_label", "Expansion")
+
+    all_cats: set[str] = set()
+    for eng in relevant:
+        all_cats.update(
+            eng["aggregated_philological"]["modern_archives"]
+            .get("per_category", {}).keys(),
+        )
+    cats = sorted(all_cats)
+
+    parts = [_section_open(title, note)]
+    parts.append(
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">'
+    )
+    parts.append("<thead><tr>")
+    parts.append(
+        f'<th rowspan="2" style="padding:.3rem .5rem;text-align:left;'
+        f'border-bottom:1px solid var(--border);font-weight:600">'
+        f'{_e(engine_label)}</th>'
+    )
+    parts.append(
+        f'<th colspan="2" style="padding:.3rem .5rem;text-align:center;'
+        f'border-bottom:1px solid var(--border);font-weight:600">'
+        f'{_e(global_label)}</th>'
+    )
+    for cat in cats:
+        parts.append(
+            f'<th colspan="2" style="padding:.3rem .5rem;text-align:center;'
+            f'border-bottom:1px solid var(--border);font-weight:600">'
+            f'{_e(cat)}</th>'
+        )
+    parts.append("</tr><tr>")
+    for _ in range(1 + len(cats)):
+        parts.append(
+            f'<th style="padding:.2rem .4rem;text-align:center;'
+            f'font-size:.75rem;font-weight:500;opacity:.7">'
+            f'{_e(strict_label)}</th>'
+        )
+        parts.append(
+            f'<th style="padding:.2rem .4rem;text-align:center;'
+            f'font-size:.75rem;font-weight:500;opacity:.7">'
+            f'{_e(expansion_label)}</th>'
+        )
+    parts.append("</tr></thead>")
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["modern_archives"]
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
+        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
+        per_cat = agg.get("per_category", {})
+        for cat in cats:
+            stats = per_cat.get(cat)
+            if stats and stats.get("n_total", 0) > 0:
+                parts.append(_score_cell(
+                    stats["strict_score"],
+                    extra=f"n={stats['n_total']}",
+                ))
+                parts.append(_score_cell(stats["expansion_score"]))
+            else:
+                parts.append(_score_cell(None))
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 60 — Numéraux romains : breakdown 5 statuts
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_roman_numerals_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "roman_numerals")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_roman_numerals_title",
+        "Numéraux romains : restitution par statut",
+    )
+    note = labels.get(
+        "philo_roman_numerals_note",
+        "Pour chaque numéral romain de la GT, statut de restitution : "
+        "strict (forme exacte), case_changed (casse modifiée), "
+        "j_dropped (j médiéval normalisé), converted_to_arabic, lost. "
+        "Le breakdown indique la convention : majoritaire strict → "
+        "diplomatique ; majoritaire arabic → modernisation profonde.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    n_label = labels.get("philo_n_total_label", "n total")
+
+    statuses = (
+        "strict_preserved", "case_changed", "j_dropped",
+        "converted_to_arabic", "lost",
+    )
+    status_labels = {
+        s: labels.get(f"philo_roman_status_{s}", s) for s in statuses
+    }
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header(
+        [n_label] + [status_labels[s] for s in statuses],
+        engine_label,
+    ))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["roman_numerals"]
+        n_total = agg.get("n_numerals_reference", 0)
+        per_status = agg.get("per_status", {})
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:center">'
+            f'{n_total}</td>'
+        )
+        for status in statuses:
+            count = per_status.get(status, 0)
+            if n_total > 0:
+                ratio = count / n_total
+                # Pour « lost » on inverse la couleur (un haut taux
+                # de perte est mauvais).  Pour les autres on garde
+                # la sémantique « plus c'est haut, plus l'OCR a
+                # adopté ce statut ».
+                color = (
+                    _color_for_score(1.0 - ratio) if status == "lost"
+                    else _color_for_score(ratio)
+                )
+                parts.append(
+                    f'<td style="padding:.3rem .5rem;text-align:center;'
+                    f'background:{color}">{count} '
+                    f'<span style="opacity:.6;font-size:.85em">'
+                    f'({ratio * 100:.0f}%)</span></td>'
+                )
+            else:
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Agrégateur principal
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_philological_profile_html(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Assemble les six sections en un bloc unique.
+
+    Retourne ``""`` si aucune section n'a de contenu (c.-à-d.
+    aucun moteur n'a de signal philologique sur le corpus).
+    """
+    sections = [
+        build_unicode_blocks_section(engines_summary, labels),
+        build_abbreviations_section(engines_summary, labels),
+        build_mufi_section(engines_summary, labels),
+        build_early_modern_section(engines_summary, labels),
+        build_modern_archives_section(engines_summary, labels),
+        build_roman_numerals_section(engines_summary, labels),
+    ]
+    non_empty = [s for s in sections if s]
+    if not non_empty:
+        return ""
+    labels = labels or {}
+    main_title = labels.get(
+        "philo_profile_title", "Profil philologique",
+    )
+    main_note = labels.get(
+        "philo_profile_note",
+        "Données brutes par catégorie de marqueur philologique. "
+        "L'outil ne classifie pas la convention adoptée par chaque "
+        "moteur — c'est au chercheur de lire les chiffres et de "
+        "conclure selon ses critères éditoriaux.",
+    )
+    parts = [
+        '<div class="philological-profile">',
+        f'<h3 style="margin-top:0">{_e(main_title)}</h3>',
+        f'<p style="font-size:.85rem;opacity:.8;margin-bottom:.5rem">'
+        f'{_e(main_note)}</p>',
+    ]
+    parts.extend(non_empty)
+    parts.append("</div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_philological_profile_html",
+    "build_unicode_blocks_section",
+    "build_abbreviations_section",
+    "build_mufi_section",
+    "build_early_modern_section",
+    "build_modern_archives_section",
+    "build_roman_numerals_section",
+]

picarones/report/lexical_modernization_render.py

@@ -1,119 +1,17 @@
-"""Rendu HTML de la vue « Modernisation lexicale » — Sprint 80.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.lexical_modernization_render`.
 
-A.I.7 du plan d'évolution 2026.
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.report.lexical_modernization_render
+import ...``) de continuer à fonctionner sans modification.
 
-Suite directe ``picarones/core/lexical_modernization.py``.
-Pattern identique aux autres rendus (Sprints 41/43/62/67/72/74/75/76/77) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Vue
----
-Tableau trié par taux de modernisation décroissant : forme
-historique GT → forme(s) modernisée(s), occurrences GT, %.
-Couleur de cellule pour le %.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-from picarones.core.lexical_modernization import top_modernized_tokens
-
-
-def _color_for_rate(rate: float) -> str:
-    """Gradient blanc → orange profond pour rate ∈ [0, 1]."""
-    f = max(0.0, min(1.0, rate))
-    r = int(255 + (194 - 255) * f)
-    g = int(255 + (65 - 255) * f)
-    b = int(255 + (12 - 255) * f)
-    return f"#{r:02x}{g:02x}{b:02x}"
-
-
-def _format_variants(variants: dict, max_show: int = 3) -> str:
-    """Liste compacte des variants modernisés."""
-    items = sorted(variants.items(), key=lambda kv: -kv[1])
-    shown = items[:max_show]
-    rest = len(items) - max_show
-    parts = [
-        f"{_e(form)} ({count})"
-        for form, count in shown
-    ]
-    if rest > 0:
-        parts.append(f"+{rest}")
-    return ", ".join(parts)
-
-
-def build_lexical_modernization_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-    *,
-    top_n: int = 20,
-    min_total: int = 1,
-) -> str:
-    """Construit la table HTML de modernisation lexicale.
-
-    Retourne ``""`` si ``data is None`` ou si aucun token modernisé.
-    """
-    if not data:
-        return ""
-    rows = top_modernized_tokens(data, n=top_n, min_total=min_total)
-    if not rows:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "lexmod_title", "Modernisation lexicale (top tokens)",
-    )
-    note = labels.get(
-        "lexmod_note",
-        "Tokens GT que le moteur réécrit le plus souvent. "
-        "Lecture : « maistre → maître modernisé dans 85 % des cas » "
-        "indique de quoi corriger dans le prompt pour préserver "
-        "l'orthographe historique.",
-    )
-    gt_label = labels.get("lexmod_gt_label", "Forme historique GT")
-    hyp_label = labels.get("lexmod_hyp_label", "Variantes OCR")
-    n_label = labels.get("lexmod_n_label", "n GT")
-    rate_label = labels.get("lexmod_rate_label", "% modernisé")
-
-    parts = [
-        '<div class="lexmod" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
-        f'{_e(note)}</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.85rem">',
-        '<thead><tr>',
-    ]
-    for col in (gt_label, hyp_label, n_label, rate_label):
-        parts.append(
-            f'<th style="padding:.3rem .5rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-    for gt_token, slot in rows:
-        rate = slot.get("rate_modernized", 0.0)
-        n_total = slot.get("n_total", 0)
-        variants_str = _format_variants(slot.get("variants") or {})
-        rate_color = _color_for_rate(rate)
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.3rem .5rem;font-family:monospace">'
-            f'{_e(gt_token)}</td>'
-            f'<td style="padding:.3rem .5rem;font-size:.85rem">'
-            f'{variants_str}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'font-family:monospace">{n_total}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'background:{rate_color};font-family:monospace">'
-            f'{rate * 100:.0f}%</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></div>")
-    return "".join(parts)
-
+from picarones.extras.render.lexical_modernization_render import *  # noqa: F401, F403
 
-__all__ = [
-    "build_lexical_modernization_html",
-]
+import picarones.extras.render.lexical_modernization_render as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/report/philological_render.py

@@ -1,615 +1,17 @@
-"""Rendu HTML server-side du profil philologique (Sprint 62).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.philological_render`.
 
-Suite directe Sprint 61 (câblage backend) — produit les blocs HTML
-qui exposent les six modules philologiques (Sprints 55-60) dans le
-rapport :
+Phase B du chantier de refonte en 3 cercles (architecture-cercles.md).
+Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias
+ici permet aux imports historiques (``from picarones.report.philological_render
+import ...``) de continuer à fonctionner sans modification.
 
-- ``unicode_blocks``    (Sprint 55) — précision par bloc Unicode
-- ``abbreviations``     (Sprint 56) — score strict + expansion par
-                                       abréviation médiévale Capelli
-- ``mufi``              (Sprint 57) — couverture MUFI globale + par
-                                       caractère
-- ``early_modern``      (Sprint 58) — préservation des marqueurs
-                                       typographiques imprimé ancien
-- ``modern_archives``   (Sprint 59) — strict + expansion par
-                                       catégorie d'archive moderne
-- ``roman_numerals``    (Sprint 60) — breakdown 5 statuts de
-                                       restitution
-
-Principe identique aux Sprints 41 (NER) et 43 (calibration) :
-
-- Rendu **server-side**, pas de JavaScript, déterministe.
-- Section adaptive : si aucun moteur n'a de signal pour un module
-  donné, la sous-section est silencieusement omise.
-- Si **aucun module** n'a de signal sur l'ensemble des moteurs,
-  ``build_philological_profile_html`` retourne une chaîne vide et
-  le bloc complet n'apparaît pas dans la vue analyses.
-- **Aucune classification automatique** : on affiche les chiffres
-  bruts par catégorie/bloc/statut, le chercheur juge lui-même la
-  convention adoptée.
-- Anti-injection : tous les noms de moteurs, catégories, statuts,
-  caractères passent par ``html.escape`` avant insertion.
+Voir :doc:`docs/architecture-cercles.md` et l'extra
+``picarones[historical]`` du ``pyproject.toml``.
 """
 
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Helpers de coloration
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _color_for_score(score: float) -> str:
-    """Gradient rouge → jaune → vert proportionnel à ``score`` ∈ [0, 1].
-
-    Identique à ``ner_render._color_for_f1``.  Les scores
-    philologiques (preservation, coverage, accuracy) suivent la même
-    sémantique « plus c'est haut, mieux c'est » donc le gradient
-    est valide.
-    """
-    f = max(0.0, min(1.0, score))
-    if f <= 0.5:
-        ratio = f / 0.5
-        r = int(220 + (240 - 220) * ratio)
-        g = int(100 + (220 - 100) * ratio)
-        b = int(100 + (130 - 100) * ratio)
-    else:
-        ratio = (f - 0.5) / 0.5
-        r = int(240 + (130 - 240) * ratio)
-        g = int(220 + (200 - 220) * ratio)
-        b = int(130 + (130 - 130) * ratio)
-    return f"#{r:02x}{g:02x}{b:02x}"
-
-
-def _engines_with_module(
-    engines_summary: list[dict], module: str,
-) -> list[dict]:
-    """Filtre les moteurs ayant des données pour le module donné."""
-    out: list[dict] = []
-    for eng in engines_summary:
-        agg = eng.get("aggregated_philological") or {}
-        if module in agg and agg[module]:
-            out.append(eng)
-    return out
-
-
-def _score_cell(score: Optional[float], extra: str = "") -> str:
-    """Rend une cellule colorée.  ``None`` → cellule grise « — »."""
-    if score is None:
-        return (
-            '<td style="padding:.3rem .5rem;text-align:center;'
-            'background:#f0f0f0;color:#999">—</td>'
-        )
-    color = _color_for_score(score)
-    text = f"{score * 100:.1f}%"
-    if extra:
-        text += f" <span style=\"opacity:.6;font-size:.85em\">({_e(extra)})</span>"
-    return (
-        f'<td style="padding:.3rem .5rem;text-align:center;'
-        f'background:{color}">{text}</td>'
-    )
-
-
-def _table_header(
-    columns: list[str], engine_label: str,
-) -> str:
-    """Construit l'entête d'un tableau moteur × colonnes."""
-    parts = [
-        '<thead><tr>',
-        f'<th style="padding:.3rem .5rem;text-align:left;'
-        f'border-bottom:1px solid var(--border);font-weight:600">'
-        f'{_e(engine_label)}</th>',
-    ]
-    for col in columns:
-        parts.append(
-            f'<th style="padding:.3rem .5rem;text-align:center;'
-            f'border-bottom:1px solid var(--border);font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append('</tr></thead>')
-    return "".join(parts)
-
-
-def _engine_label_cell(name: str) -> str:
-    return (
-        f'<td style="padding:.3rem .5rem;font-weight:500;'
-        f'border-bottom:1px solid var(--border-light)">{_e(name)}</td>'
-    )
-
-
-def _section_open(title: str, note: str = "") -> str:
-    parts = [
-        '<div class="philological-section" '
-        'style="margin:1rem 0;padding:.75rem;'
-        'background:var(--bg-secondary);border-radius:6px">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-    ]
-    if note:
-        parts.append(
-            f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
-            f'{_e(note)}</div>'
-        )
-    return "".join(parts)
-
-
-def _section_close() -> str:
-    return "</div>"
-
-
-def _table_open() -> str:
-    return (
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.85rem">'
-    )
-
-
-def _table_close() -> str:
-    return "</table>"
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 55 — Précision par bloc Unicode
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_unicode_blocks_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "unicode_blocks")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_unicode_blocks_title", "Précision par bloc Unicode",
-    )
-    note = labels.get(
-        "philo_unicode_blocks_note",
-        "Pourcentage de caractères correctement restitués par bloc "
-        "Unicode rencontré dans la GT (hors Basic Latin).",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    global_label = labels.get("philo_global_label", "Global")
-
-    # Collecte tous les blocs présents (hors Basic Latin déjà filtré
-    # par adaptive masking, mais on défilte ici si Basic Latin
-    # apparaît malgré tout chez certains moteurs).
-    all_blocks: set[str] = set()
-    for eng in relevant:
-        per_block = eng["aggregated_philological"]["unicode_blocks"].get(
-            "per_block", {},
-        )
-        for block in per_block:
-            if block != "Basic Latin":
-                all_blocks.add(block)
-    blocks = sorted(all_blocks)
-    if not blocks:
-        return ""
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header([global_label] + blocks, engine_label))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["unicode_blocks"]
-        global_acc = agg.get("global_accuracy", 0.0)
-        n_chars = agg.get("n_chars_total", 0)
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(global_acc, extra=f"n={n_chars}"))
-        per_block = agg.get("per_block", {})
-        for block in blocks:
-            stats = per_block.get(block)
-            if stats and stats.get("total", 0) > 0:
-                parts.append(_score_cell(
-                    stats["accuracy"], extra=f"n={stats['total']}",
-                ))
-            else:
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# (sections suivantes définies plus loin)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 56 — Abréviations Capelli médiévales
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_abbreviations_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "abbreviations")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_abbreviations_title",
-        "Abréviations médiévales (Capelli)",
-    )
-    note = labels.get(
-        "philo_abbreviations_note",
-        "Strict = forme abrégée (ꝑ, ꝓ, ⁊…) préservée telle quelle ; "
-        "Expansion = abrégée OU forme développée (per, pro, et…) "
-        "présente. Le ratio strict/expansion par moteur indique la "
-        "convention adoptée (diplomatique / modernisante).",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    strict_label = labels.get("philo_strict_label", "Strict")
-    expansion_label = labels.get("philo_expansion_label", "Expansion")
-    n_label = labels.get("philo_n_total_label", "n total")
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header(
-        [strict_label, expansion_label, n_label], engine_label,
-    ))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["abbreviations"]
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
-        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:center">'
-            f'{agg.get("n_abbreviations_in_reference", 0)}</td>'
-        )
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 57 — Couverture MUFI
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_mufi_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "mufi")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_mufi_title",
-        "Couverture MUFI (Medieval Unicode Font Initiative)",
-    )
-    note = labels.get(
-        "philo_mufi_note",
-        "Taux de caractères MUFI de la GT (þ, ð, ƿ, ſ, æ, lettres "
-        "PUA…) correctement restitués dans l'OCR. Critère éditorial "
-        "central pour les médiévistes.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    coverage_label = labels.get("philo_mufi_coverage_label", "Couverture")
-    n_label = labels.get("philo_n_total_label", "n total")
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header(
-        [coverage_label, n_label], engine_label,
-    ))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["mufi"]
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(agg.get("coverage", 0.0)))
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:center">'
-            f'{agg.get("n_mufi_chars_reference", 0)}</td>'
-        )
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 58 — Marqueurs typographiques imprimé ancien (heatmap)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_early_modern_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "early_modern")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_early_modern_title",
-        "Marqueurs typographiques imprimé ancien (XVIᵉ-XVIIIᵉ)",
-    )
-    note = labels.get(
-        "philo_early_modern_note",
-        "Préservation des ligatures (fi fl ff), s long (ſ), i sans "
-        "point (ı), esperluette (&) et tildes nasaux (ã õ ñ). "
-        "Une ligne par moteur, une colonne par catégorie.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    global_label = labels.get("philo_global_label", "Global")
-
-    all_cats: set[str] = set()
-    for eng in relevant:
-        all_cats.update(
-            eng["aggregated_philological"]["early_modern"]
-            .get("per_category", {}).keys(),
-        )
-    cats = sorted(all_cats)
-    if not cats:
-        return ""
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header([global_label] + cats, engine_label))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["early_modern"]
-        n_total = agg.get("n_markers_reference", 0)
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(
-            agg.get("global_preservation", 0.0), extra=f"n={n_total}",
-        ))
-        per_cat = agg.get("per_category", {})
-        for cat in cats:
-            stats = per_cat.get(cat)
-            if stats and stats.get("total", 0) > 0:
-                parts.append(_score_cell(
-                    stats["preservation"], extra=f"n={stats['total']}",
-                ))
-            else:
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 59 — Archives modernes : strict + expansion par catégorie
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_modern_archives_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "modern_archives")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_modern_archives_title",
-        "Abréviations des archives modernes (XIXᵉ-XXᵉ)",
-    )
-    note = labels.get(
-        "philo_modern_archives_note",
-        "Strict = abrégé préservé (Mme, S.A.R., bd, vol., …) ; "
-        "Expansion = abrégé OU forme développée. Affiché par "
-        "catégorie : civilité, ordinaux, monnaie, administratif, "
-        "état civil, ponctuation typo, latin, biblio, adresse.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    global_label = labels.get("philo_global_label", "Global")
-    strict_label = labels.get("philo_strict_label", "Strict")
-    expansion_label = labels.get("philo_expansion_label", "Expansion")
-
-    all_cats: set[str] = set()
-    for eng in relevant:
-        all_cats.update(
-            eng["aggregated_philological"]["modern_archives"]
-            .get("per_category", {}).keys(),
-        )
-    cats = sorted(all_cats)
-
-    parts = [_section_open(title, note)]
-    parts.append(
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.85rem">'
-    )
-    parts.append("<thead><tr>")
-    parts.append(
-        f'<th rowspan="2" style="padding:.3rem .5rem;text-align:left;'
-        f'border-bottom:1px solid var(--border);font-weight:600">'
-        f'{_e(engine_label)}</th>'
-    )
-    parts.append(
-        f'<th colspan="2" style="padding:.3rem .5rem;text-align:center;'
-        f'border-bottom:1px solid var(--border);font-weight:600">'
-        f'{_e(global_label)}</th>'
-    )
-    for cat in cats:
-        parts.append(
-            f'<th colspan="2" style="padding:.3rem .5rem;text-align:center;'
-            f'border-bottom:1px solid var(--border);font-weight:600">'
-            f'{_e(cat)}</th>'
-        )
-    parts.append("</tr><tr>")
-    for _ in range(1 + len(cats)):
-        parts.append(
-            f'<th style="padding:.2rem .4rem;text-align:center;'
-            f'font-size:.75rem;font-weight:500;opacity:.7">'
-            f'{_e(strict_label)}</th>'
-        )
-        parts.append(
-            f'<th style="padding:.2rem .4rem;text-align:center;'
-            f'font-size:.75rem;font-weight:500;opacity:.7">'
-            f'{_e(expansion_label)}</th>'
-        )
-    parts.append("</tr></thead>")
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["modern_archives"]
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
-        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
-        per_cat = agg.get("per_category", {})
-        for cat in cats:
-            stats = per_cat.get(cat)
-            if stats and stats.get("n_total", 0) > 0:
-                parts.append(_score_cell(
-                    stats["strict_score"],
-                    extra=f"n={stats['n_total']}",
-                ))
-                parts.append(_score_cell(stats["expansion_score"]))
-            else:
-                parts.append(_score_cell(None))
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 60 — Numéraux romains : breakdown 5 statuts
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_roman_numerals_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "roman_numerals")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_roman_numerals_title",
-        "Numéraux romains : restitution par statut",
-    )
-    note = labels.get(
-        "philo_roman_numerals_note",
-        "Pour chaque numéral romain de la GT, statut de restitution : "
-        "strict (forme exacte), case_changed (casse modifiée), "
-        "j_dropped (j médiéval normalisé), converted_to_arabic, lost. "
-        "Le breakdown indique la convention : majoritaire strict → "
-        "diplomatique ; majoritaire arabic → modernisation profonde.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    n_label = labels.get("philo_n_total_label", "n total")
-
-    statuses = (
-        "strict_preserved", "case_changed", "j_dropped",
-        "converted_to_arabic", "lost",
-    )
-    status_labels = {
-        s: labels.get(f"philo_roman_status_{s}", s) for s in statuses
-    }
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header(
-        [n_label] + [status_labels[s] for s in statuses],
-        engine_label,
-    ))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["roman_numerals"]
-        n_total = agg.get("n_numerals_reference", 0)
-        per_status = agg.get("per_status", {})
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:center">'
-            f'{n_total}</td>'
-        )
-        for status in statuses:
-            count = per_status.get(status, 0)
-            if n_total > 0:
-                ratio = count / n_total
-                # Pour « lost » on inverse la couleur (un haut taux
-                # de perte est mauvais).  Pour les autres on garde
-                # la sémantique « plus c'est haut, plus l'OCR a
-                # adopté ce statut ».
-                color = (
-                    _color_for_score(1.0 - ratio) if status == "lost"
-                    else _color_for_score(ratio)
-                )
-                parts.append(
-                    f'<td style="padding:.3rem .5rem;text-align:center;'
-                    f'background:{color}">{count} '
-                    f'<span style="opacity:.6;font-size:.85em">'
-                    f'({ratio * 100:.0f}%)</span></td>'
-                )
-            else:
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Agrégateur principal
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_philological_profile_html(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Assemble les six sections en un bloc unique.
-
-    Retourne ``""`` si aucune section n'a de contenu (c.-à-d.
-    aucun moteur n'a de signal philologique sur le corpus).
-    """
-    sections = [
-        build_unicode_blocks_section(engines_summary, labels),
-        build_abbreviations_section(engines_summary, labels),
-        build_mufi_section(engines_summary, labels),
-        build_early_modern_section(engines_summary, labels),
-        build_modern_archives_section(engines_summary, labels),
-        build_roman_numerals_section(engines_summary, labels),
-    ]
-    non_empty = [s for s in sections if s]
-    if not non_empty:
-        return ""
-    labels = labels or {}
-    main_title = labels.get(
-        "philo_profile_title", "Profil philologique",
-    )
-    main_note = labels.get(
-        "philo_profile_note",
-        "Données brutes par catégorie de marqueur philologique. "
-        "L'outil ne classifie pas la convention adoptée par chaque "
-        "moteur — c'est au chercheur de lire les chiffres et de "
-        "conclure selon ses critères éditoriaux.",
-    )
-    parts = [
-        '<div class="philological-profile">',
-        f'<h3 style="margin-top:0">{_e(main_title)}</h3>',
-        f'<p style="font-size:.85rem;opacity:.8;margin-bottom:.5rem">'
-        f'{_e(main_note)}</p>',
-    ]
-    parts.extend(non_empty)
-    parts.append("</div>")
-    return "".join(parts)
-
+from picarones.extras.render.philological_render import *  # noqa: F401, F403
 
-__all__ = [
-    "build_philological_profile_html",
-    "build_unicode_blocks_section",
-    "build_abbreviations_section",
-    "build_mufi_section",
-    "build_early_modern_section",
-    "build_modern_archives_section",
-    "build_roman_numerals_section",
-]
+import picarones.extras.render.philological_render as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

pyproject.toml

@@ -69,9 +69,19 @@ ocr-cloud = [
     "boto3>=1.34.0",
     "azure-ai-formrecognizer>=3.3.0",
 ]
+# Métriques philologiques pour documents historiques (Cercle 3, phase B
+# du chantier de refonte post-Sprint 97). Aujourd'hui les modules
+# philologiques (`picarones.extras.historical.*`) sont livrés dans le
+# package principal sans dépendance externe — l'extra ``[historical]``
+# n'ajoute donc aucun paquet à installer. Il est déclaré ici pour
+# **documenter l'intention** : un usage purement moderne (sans cas
+# d'usage patrimonial) peut ignorer le sous-package extras/historical/
+# entièrement, et un futur split en package PyPI séparé
+# ``picarones-historical`` réutilisera ce nom d'extra.
+historical = []
 # Installation complète (tous les extras sauf les OCR cloud)
 all = [
-    "picarones[web,hf,llm,dev]",
+    "picarones[web,hf,llm,dev,historical]",
 ]
 
 [project.scripts]

tests/test_phaseB_migration.py

@@ -0,0 +1,249 @@
+"""Tests de la phase B — extras/historical/ (philologique vers Cercle 3).
+
+Couvre :
+
+- 8 modules philologiques (Cercle 3) déplacés vers `extras/historical/`.
+- 2 renderers correspondants déplacés vers `extras/render/`.
+- Identité préservée à travers les shims (test ``is``).
+- Intégration : `philological_runner` orchestre toujours les 6 modules
+  même après déplacement.
+- Dépendance Cercle 2 → Cercle 3 (`numerical_sequences` →
+  `roman_numerals`) continue de fonctionner via shim.
+- pyproject.toml déclare `[historical]` comme extra documentaire.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. Modules historiques accessibles via shims (rétrocompat)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestPhilologicalRetrocompat:
+    @pytest.mark.parametrize("module_path, attribute", [
+        ("picarones.core.unicode_blocks", "compute_unicode_block_accuracy"),
+        ("picarones.core.abbreviations", "compute_abbreviation_metrics"),
+        ("picarones.core.mufi", "compute_mufi_coverage"),
+        ("picarones.core.early_modern_typography", "compute_early_modern_metrics"),
+        ("picarones.core.modern_archives", "compute_modern_archives_metrics"),
+        ("picarones.core.roman_numerals", "compute_roman_numeral_metrics"),
+        ("picarones.core.lexical_modernization", "compute_lexical_modernization"),
+        ("picarones.core.philological_runner", "compute_philological_metrics"),
+        ("picarones.core.philological_runner", "aggregate_philological_metrics"),
+    ])
+    def test_core_alias_still_works(self, module_path: str, attribute: str):
+        import importlib
+        mod = importlib.import_module(module_path)
+        assert hasattr(mod, attribute), (
+            f"{module_path}.{attribute} a disparu après la phase B"
+        )
+
+    @pytest.mark.parametrize("module_path, attribute", [
+        ("picarones.report.philological_render", "build_philological_profile_html"),
+        ("picarones.report.lexical_modernization_render",
+         "build_lexical_modernization_html"),
+    ])
+    def test_render_alias_still_works(self, module_path: str, attribute: str):
+        import importlib
+        mod = importlib.import_module(module_path)
+        assert hasattr(mod, attribute)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Modules accessibles via leur nouveau chemin extras/historical/
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestNewHistoricalImports:
+    @pytest.mark.parametrize("new_path, attribute", [
+        ("picarones.extras.historical.unicode_blocks",
+         "compute_unicode_block_accuracy"),
+        ("picarones.extras.historical.abbreviations",
+         "compute_abbreviation_metrics"),
+        ("picarones.extras.historical.mufi", "compute_mufi_coverage"),
+        ("picarones.extras.historical.early_modern_typography",
+         "compute_early_modern_metrics"),
+        ("picarones.extras.historical.modern_archives",
+         "compute_modern_archives_metrics"),
+        ("picarones.extras.historical.roman_numerals",
+         "compute_roman_numeral_metrics"),
+        ("picarones.extras.historical.lexical_modernization",
+         "compute_lexical_modernization"),
+        ("picarones.extras.historical.philological_runner",
+         "compute_philological_metrics"),
+        ("picarones.extras.render.philological_render",
+         "build_philological_profile_html"),
+        ("picarones.extras.render.lexical_modernization_render",
+         "build_lexical_modernization_html"),
+    ])
+    def test_extras_path_works(self, new_path: str, attribute: str):
+        import importlib
+        mod = importlib.import_module(new_path)
+        assert hasattr(mod, attribute)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Identité préservée (shim et nouveau chemin = même fonction)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestIdentityThroughShim:
+    def test_unicode_blocks_identity(self):
+        from picarones.core.unicode_blocks import (
+            compute_unicode_block_accuracy as via_old,
+        )
+        from picarones.extras.historical.unicode_blocks import (
+            compute_unicode_block_accuracy as via_new,
+        )
+        assert via_old is via_new
+
+    def test_philological_runner_identity(self):
+        from picarones.core.philological_runner import (
+            compute_philological_metrics as via_old,
+        )
+        from picarones.extras.historical.philological_runner import (
+            compute_philological_metrics as via_new,
+        )
+        assert via_old is via_new
+
+    def test_renderer_identity(self):
+        from picarones.report.philological_render import (
+            build_philological_profile_html as via_old,
+        )
+        from picarones.extras.render.philological_render import (
+            build_philological_profile_html as via_new,
+        )
+        assert via_old is via_new
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Intégration : philological_runner orchestre toujours les 6 modules
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestPhilologicalRunnerIntegration:
+    """Le runner philologique appelle les 6 modules
+    philologiques. Vérifie que cette chaîne fonctionne après le
+    déplacement (les imports internes traversent les shims)."""
+
+    def test_runner_returns_dict_or_none(self):
+        from picarones.core.philological_runner import (
+            compute_philological_metrics,
+        )
+        # Texte sans signal philologique → None par adaptive masking
+        result = compute_philological_metrics(
+            "Bonjour le monde", "Bonjour le monde",
+        )
+        # None acceptable (texte ASCII pur sans aucun marqueur)
+        # OU dict vide (signal nul partout)
+        assert result is None or isinstance(result, dict)
+
+    def test_runner_with_medieval_text(self):
+        """Texte médiéval avec abréviations + numéraux romains : on
+        s'attend à au moins un module qui détecte du signal."""
+        from picarones.core.philological_runner import (
+            compute_philological_metrics,
+        )
+        # ⁊ = symbole d'abréviation Capelli ; XIV = numéral romain ; ſ = long s
+        ref = "⁊ par leſ XIV. fontoyers"
+        hyp = "et par les XIV. fontoyers"
+        result = compute_philological_metrics(ref, hyp)
+        # Au moins un module doit avoir détecté du signal
+        # (abbreviations OU early_modern OU roman_numerals)
+        assert result is not None
+        assert isinstance(result, dict)
+        assert len(result) >= 1
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Dépendance Cercle 2 → Cercle 3 fonctionne via shim
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestCercle2DependsOnCercle3ViaShim:
+    """``picarones.core.numerical_sequences`` (Cercle 2,
+    measurements/) importe ``roman_numerals`` (Cercle 3, extras/).
+    Cette dépendance traverse le shim — elle continue à fonctionner."""
+
+    def test_numerical_sequences_uses_roman_numerals(self):
+        from picarones.core.numerical_sequences import (
+            compute_numerical_sequence_metrics,
+        )
+        # Texte avec numéral romain
+        result = compute_numerical_sequence_metrics(
+            "Le roi Louis XIV régna jusqu'en 1715",
+            "Le roi Louis XIV régna jusqu'en 1715",
+        )
+        # Le score strict global doit refléter au moins la détection
+        # du romain et de la date
+        assert isinstance(result, dict)
+        assert result.get("global_strict_score") is not None
+        assert result.get("global_strict_score") >= 0.5
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. pyproject.toml déclare l'extra [historical]
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestPyprojectExtra:
+    def test_historical_extra_declared(self):
+        path = Path(__file__).parent.parent / "pyproject.toml"
+        content = path.read_text(encoding="utf-8")
+        # L'extra [historical] doit être déclaré, même vide
+        assert "historical = []" in content or 'historical = [' in content
+        # Documentation de l'intention présente
+        assert "extras/historical" in content
+        assert "Cercle 3" in content
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 7. Hooks builtin enregistrés conditionnels (philological + lexical)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestBuiltinHooksStillRegisterPhilological:
+    """Les hooks ``philological`` et ``lexical_modernization``
+    s'enregistrent au chargement de :mod:`picarones.core.builtin_hooks`
+    via les imports qui traversent les shims (``from
+    picarones.core.philological_runner import ...``)."""
+
+    def test_philological_hook_registered(self):
+        # L'import déclenche l'enregistrement
+        import picarones.core.builtin_hooks  # noqa: F401
+        from picarones.core.metric_hooks import _all_document_hook_names
+
+        assert "philological" in _all_document_hook_names()
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 8. Modules originaux sont des shims minces
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestOriginalsAreShims:
+    @pytest.mark.parametrize("path", [
+        "picarones/core/unicode_blocks.py",
+        "picarones/core/abbreviations.py",
+        "picarones/core/mufi.py",
+        "picarones/core/early_modern_typography.py",
+        "picarones/core/modern_archives.py",
+        "picarones/core/roman_numerals.py",
+        "picarones/core/lexical_modernization.py",
+        "picarones/core/philological_runner.py",
+        "picarones/report/philological_render.py",
+        "picarones/report/lexical_modernization_render.py",
+    ])
+    def test_is_thin_shim(self, path):
+        repo_root = Path(__file__).parent.parent
+        content = (repo_root / path).read_text(encoding="utf-8")
+        n_lines = len([line for line in content.splitlines() if line.strip()])
+        assert n_lines < 30, (
+            f"{path} fait {n_lines} lignes — devrait être un shim mince"
+        )
+        assert "déplacé" in content or "extras" in content