refactor(report): regrouper renderers depuis extras/render/

Les 6 renderers HTML qui vivaient dans ``picarones/extras/render/``
sont déplacés dans ``picarones/report/`` (où vivent déjà les ~16
autres renderers). Le rendu HTML est l'identité visible de Picarones —
pas un plugin tiers — et n'a aucune raison d'être éparpillé entre
deux dossiers.

Renderers déplacés :
- image_predictive_render
- lexical_modernization_render
- module_audit_render
- philological_render
- taxonomy_cooccurrence_render
- taxonomy_intra_doc_render

Le sous-package ``extras/render/`` est supprimé. Les fichiers
historiquement présents dans ``report/`` (qui étaient des shims
pointant vers ``extras/render/``) sont écrasés par les vraies
sources.

https://claude.ai/code/session_01Hsd7kL8yeCbXn1mA7GQK9L

picarones/extras/render/__init__.py

@@ -1,13 +0,0 @@
-"""Renderers atomiques pour les modules ``extras/``.
-
-Importés conditionnellement par les vues thématiques du chantier 3
-(``picarones.report.views.advanced_taxonomy``, etc.) qui restent
-dans le Cercle 2. Si les modules ``extras/academic/`` ou
-``extras/governance/`` sont absents, ces renderers ne sont pas
-sollicités et la vue masque la sous-section.
-
-Rétrocompat
------------
-Imports historiques ``from picarones.report.taxonomy_intra_doc_render
-import ...`` continuent à fonctionner via des fichiers-shims.
-"""

picarones/extras/render/image_predictive_render.py

@@ -1,221 +0,0 @@
-"""Rendu HTML « Profil d'image du corpus » — Sprint 93 (A.II.7).
-
-Suite directe ``picarones/core/image_predictive.py``.  Pattern
-identique aux autres rendus : server-side, pas de JS, anti-
-injection systématique.
-
-Vue
----
-Deux blocs dans une section unique :
-
-1. **Complexité paléographique** : moyenne, médiane, min, max,
-   écart-type sur l'ensemble du corpus.
-2. **Homogénéité du corpus** : score combiné + détail par
-   feature (mean, stdev, contribution normalisée).
-
-Adaptive : ``""`` si pas de données.
-
-Note d'intégration
-------------------
-Module pur — l'utilisateur compose :
-
-.. code-block:: python
-
-    from picarones.core.image_predictive import aggregate_corpus_predictive
-    from picarones.report.image_predictive_render import (
-        build_image_predictive_html,
-    )
-
-    qualities = [doc.image_quality.as_dict() for doc in benchmark.docs]
-    agg = aggregate_corpus_predictive(qualities)
-    html = build_image_predictive_html(agg, labels)
-"""
-
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _color_for_score(score: float) -> str:
-    """Vert (faible) → orange → rouge (élevé)."""
-    f = max(0.0, min(1.0, score))
-    if f < 0.5:
-        t = f / 0.5
-        r = int(167 + (235 - 167) * t)
-        g = int(240 + (180 - 240) * t)
-        b = int(167 + (60 - 167) * t)
-    else:
-        t = (f - 0.5) / 0.5
-        r = int(235 + (220 - 235) * t)
-        g = int(180 + (50 - 180) * t)
-        b = int(60 + (50 - 60) * t)
-    return f"#{r:02x}{g:02x}{b:02x}"
-
-
-_FEATURE_LABEL_KEYS = {
-    "noise_level": "imgpred_feat_noise",
-    "sharpness_score": "imgpred_feat_sharpness",
-    "contrast_score": "imgpred_feat_contrast",
-    "rotation_degrees": "imgpred_feat_rotation",
-}
-
-
-def _render_complexity_block(
-    aggregated: dict, labels: dict[str, str],
-) -> str:
-    h_complex = labels.get(
-        "imgpred_complexity", "Complexité paléographique",
-    )
-    h_mean = labels.get("imgpred_mean", "Moyenne")
-    h_median = labels.get("imgpred_median", "Médiane")
-    h_min = labels.get("imgpred_min", "Min")
-    h_max = labels.get("imgpred_max", "Max")
-    h_stdev = labels.get("imgpred_stdev", "Écart-type")
-    h_docs = labels.get("imgpred_docs", "Docs")
-    mean = float(aggregated.get("complexity_mean") or 0.0)
-    median = float(aggregated.get("complexity_median") or 0.0)
-    mn = float(aggregated.get("complexity_min") or 0.0)
-    mx = float(aggregated.get("complexity_max") or 0.0)
-    sd = float(aggregated.get("complexity_stdev") or 0.0)
-    n_docs = int(aggregated.get("n_docs") or 0)
-    color_mean = _color_for_score(mean)
-    return (
-        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
-        f'{_e(h_complex)}</div>'
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem;margin-bottom:.8rem">'
-        f'<thead><tr>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_mean)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_median)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_min)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_max)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_stdev)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_docs)}</th>'
-        f'</tr></thead>'
-        f'<tbody><tr>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'background:{color_mean};font-family:monospace;font-weight:600">'
-        f'{mean:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{median:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{mn:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{mx:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{sd:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{n_docs}</td>'
-        f'</tr></tbody></table>'
-    )
-
-
-def _render_homogeneity_block(
-    homogeneity: dict, labels: dict[str, str],
-) -> str:
-    h_homo = labels.get(
-        "imgpred_homogeneity", "Homogénéité du corpus",
-    )
-    h_feat = labels.get("imgpred_feature", "Feature")
-    h_mean = labels.get("imgpred_feat_mean", "Moyenne")
-    h_stdev = labels.get("imgpred_feat_stdev", "Écart-type")
-    h_norm = labels.get(
-        "imgpred_feat_norm", "Contribution normalisée",
-    )
-    score = float(homogeneity.get("score") or 0.0)
-    color = _color_for_score(score)
-    parts = [
-        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
-        f'{_e(h_homo)} : '
-        f'<span style="background:{color};padding:.1rem .4rem;'
-        f'border-radius:.3rem;font-family:monospace">{score:.3f}</span>'
-        f'</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem">',
-        '<thead><tr>',
-    ]
-    for col in (h_feat, h_mean, h_stdev, h_norm):
-        parts.append(
-            f'<th style="padding:.4rem .6rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-    per_feat = homogeneity.get("per_feature") or {}
-    for key, label_key in _FEATURE_LABEL_KEYS.items():
-        if key not in per_feat:
-            continue
-        slot = per_feat[key]
-        feat_label = labels.get(label_key, key)
-        feat_mean = float(slot.get("mean") or 0.0)
-        feat_stdev = float(slot.get("stdev") or 0.0)
-        feat_norm = float(slot.get("normalised") or 0.0)
-        norm_color = _color_for_score(feat_norm)
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem">{_e(feat_label)}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{feat_mean:.3f}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{feat_stdev:.3f}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'background:{norm_color};font-family:monospace">'
-            f'{feat_norm:.3f}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table>")
-    return "".join(parts)
-
-
-def build_image_predictive_html(
-    aggregated: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la vue HTML « Profil d'image du corpus ».
-
-    Parameters
-    ----------
-    aggregated:
-        Sortie de ``aggregate_corpus_predictive``.  Si ``None``
-        ou ``n_docs == 0``, retourne ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``imgpred_*``.
-    """
-    if not aggregated:
-        return ""
-    if not aggregated.get("n_docs"):
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "imgpred_title", "Profil d'image du corpus",
-    )
-    note = labels.get(
-        "imgpred_note",
-        "Score de complexité paléographique combinant bruit, "
-        "flou, faible contraste et rotation. Le score "
-        "d'homogénéité signale si la moyenne globale est fiable "
-        "(corpus uniforme) ou trompeuse (corpus hétérogène — "
-        "voir alors la vue stratifiée).",
-    )
-    parts = [
-        '<section class="imgpred-section" style="margin:1rem 0">',
-        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
-        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.6rem">'
-        f'{_e(note)}</div>',
-    ]
-    parts.append(_render_complexity_block(aggregated, labels))
-    homo = aggregated.get("homogeneity")
-    if isinstance(homo, dict):
-        parts.append(_render_homogeneity_block(homo, labels))
-    parts.append("</section>")
-    return "".join(parts)
-
-
-__all__ = ["build_image_predictive_html"]

picarones/extras/render/lexical_modernization_render.py

@@ -1,119 +0,0 @@
-"""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/module_audit_render.py

@@ -1,173 +0,0 @@
-"""Rendu HTML « Modules audités » — Sprint 97 (B.6).
-
-Suite directe ``picarones/core/module_policy.py``.  Pattern
-identique aux autres rendus : server-side, pas de JS, anti-
-injection systématique.
-
-Vue
----
-Tableau récapitulatif des modules utilisés dans une pipeline
-composée, chacun avec :
-
-- Statut d'audit (✓ vert si tous les checks passent, ✗ rouge
-  sinon, avec compte des échecs) ;
-- Métadonnées : version, auteur, licence ;
-- Citation académique si fournie ;
-- Lien vers la homepage si fourni.
-
-Adaptive : ``""`` si la liste est vide.
-
-Note d'intégration
-------------------
-Module pur — l'utilisateur compose la liste depuis sa
-``PipelineSpec`` augmentée des ``ModuleManifest`` :
-
-.. code-block:: python
-
-    from picarones.core.module_policy import audit_module
-    from picarones.report.module_audit_render import build_module_audit_html
-
-    audits = []
-    for step in pipeline.steps:
-        manifest = step.module.manifest  # convention applicative
-        result = audit_module(step.module, manifest)
-        audits.append({
-            "manifest": manifest.as_dict(),
-            "audit": result.as_dict(),
-        })
-    html = build_module_audit_html(audits, labels)
-"""
-
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _passed_badge(passed: bool, n_failed: int, label_pass: str,
-                  label_fail: str) -> str:
-    if passed:
-        return (
-            f'<span style="color:#16a34a;font-weight:700">'
-            f'✓ {_e(label_pass)}</span>'
-        )
-    return (
-        f'<span style="color:#dc2626;font-weight:700">'
-        f'✗ {_e(label_fail)} ({n_failed})</span>'
-    )
-
-
-def build_module_audit_html(
-    audits: Optional[list],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la vue HTML « Modules audités ».
-
-    Parameters
-    ----------
-    audits:
-        Liste de dicts ``{"manifest": ManifestDict, "audit":
-        AuditResultDict}``.  Si vide ou ``None``, retourne ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``audit_*``.
-    """
-    if not audits:
-        return ""
-    rows = [
-        a for a in audits
-        if isinstance(a, dict)
-        and isinstance(a.get("manifest"), dict)
-        and isinstance(a.get("audit"), dict)
-    ]
-    if not rows:
-        return ""
-    labels = labels or {}
-    title = labels.get("audit_title", "Modules audités")
-    note = labels.get(
-        "audit_note",
-        "Récapitulatif des modules utilisés dans la pipeline "
-        "composée. Un module qui ne passe pas l'audit n'est "
-        "pas exécutable. Métadonnées issues du manifest fourni "
-        "par le contributeur (auteur, licence, citation).",
-    )
-    label_pass = labels.get("audit_pass", "audit OK")
-    label_fail = labels.get("audit_fail", "checks échoués")
-    h_module = labels.get("audit_module", "Module")
-    h_status = labels.get("audit_status", "Audit")
-    h_version = labels.get("audit_version", "Version")
-    h_author = labels.get("audit_author", "Auteur")
-    h_license = labels.get("audit_license", "Licence")
-    h_io = labels.get("audit_io", "Entrée → sortie")
-    h_citation = labels.get("audit_citation", "Citation")
-    h_homepage = labels.get("audit_homepage", "Page projet")
-
-    parts = [
-        '<section class="audit-section" style="margin:1rem 0">',
-        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
-        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
-        f'{_e(note)}</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem">',
-        '<thead><tr>',
-    ]
-    for col in (h_module, h_status, h_version, h_author,
-                h_license, h_io, h_citation, h_homepage):
-        parts.append(
-            f'<th style="padding:.4rem .6rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-
-    for entry in rows:
-        manifest = entry["manifest"]
-        audit = entry["audit"]
-        name = str(manifest.get("name") or "?")
-        version = str(manifest.get("version") or "—")
-        author = str(manifest.get("author") or "—")
-        license_ = str(manifest.get("license") or "—")
-        in_types = ", ".join(manifest.get("input_types") or []) or "—"
-        out_types = ", ".join(manifest.get("output_types") or []) or "—"
-        citation = manifest.get("citation") or ""
-        homepage = manifest.get("homepage") or ""
-        passed = bool(audit.get("passed"))
-        n_failed = int(audit.get("n_failed") or 0)
-        status_cell = _passed_badge(
-            passed, n_failed, label_pass, label_fail,
-        )
-        # Citation : tronqué si trop long
-        citation_str = str(citation)[:120]
-        if len(str(citation)) > 120:
-            citation_str += "…"
-        citation_cell = (
-            _e(citation_str) if citation_str.strip() else "—"
-        )
-        # Homepage : on n'auto-link **pas** (anti-injection +
-        # honnêteté : l'URL peut pointer ailleurs).  On affiche
-        # le texte échappé tel quel.
-        homepage_cell = (
-            _e(str(homepage))[:80] + ("…" if len(str(homepage)) > 80 else "")
-        ) if str(homepage).strip() else "—"
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace">'
-            f'{_e(name)}</td>'
-            f'<td style="padding:.4rem .6rem">{status_cell}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace">'
-            f'{_e(version)}</td>'
-            f'<td style="padding:.4rem .6rem">{_e(author)}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace">'
-            f'{_e(license_)}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace;'
-            f'font-size:.8rem">{_e(in_types)} → {_e(out_types)}</td>'
-            f'<td style="padding:.4rem .6rem;font-size:.8rem;'
-            f'opacity:.85">{citation_cell}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace;'
-            f'font-size:.8rem">{homepage_cell}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></section>")
-    return "".join(parts)
-
-
-__all__ = ["build_module_audit_html"]

picarones/extras/render/philological_render.py

@@ -1,615 +0,0 @@
-"""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/extras/render/taxonomy_cooccurrence_render.py

@@ -1,199 +0,0 @@
-"""Rendu HTML de la heatmap de co-occurrence taxonomique — Sprint 75.
-
-A.I.4 chantier 1 du plan d'évolution 2026.
-
-Suite directe ``picarones/core/taxonomy_cooccurrence.py``.  Pattern
-identique aux autres rendus (Sprints 41/43/62/67/72/74) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Sortie typique
---------------
-- ``build_taxonomy_cooccurrence_html(data, labels)`` produit un
-  bloc complet : titre + note d'usage + heatmap SVG + table des
-  paires les plus co-occurrentes.
-- ``""`` retourné si ``data is None`` ou si la matrice est vide
-  (rapport adaptatif).
-"""
-
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _color_for_jaccard(j: float) -> str:
-    """Gradient blanc → bleu profond pour Jaccard ∈ [0, 1].
-
-    Interpolation entre #ffffff (j=0) et #1e3a8a (j=1).
-    """
-    f = max(0.0, min(1.0, j))
-    r = int(255 + (30 - 255) * f)
-    g = int(255 + (58 - 255) * f)
-    b = int(255 + (138 - 255) * f)
-    return f"#{r:02x}{g:02x}{b:02x}"
-
-
-def _text_color_for_bg(j: float) -> str:
-    """Texte blanc si fond foncé, noir sinon (lisibilité)."""
-    return "#fff" if j > 0.55 else "#222"
-
-
-def _build_heatmap_svg(
-    classes: list[str],
-    matrix: dict[str, dict[str, float]],
-    *,
-    cell_size: int = 36,
-    label_left: int = 130,
-    label_top: int = 80,
-) -> str:
-    """Construit la heatmap SVG.
-
-    Cellule = carré coloré ``_color_for_jaccard``, valeur Jaccard
-    affichée en chiffres si > 0,05.  Étiquettes des classes en
-    colonne (haut) et en ligne (gauche).
-    """
-    n = len(classes)
-    if n == 0:
-        return ""
-    width = label_left + n * cell_size + 10
-    height = label_top + n * cell_size + 10
-
-    parts = [
-        f'<svg xmlns="http://www.w3.org/2000/svg" '
-        f'width="{width}" height="{height}" '
-        f'viewBox="0 0 {width} {height}" '
-        f'role="img" aria-label="Heatmap Jaccard co-occurrence taxonomique">',
-    ]
-    # Étiquettes de colonnes (rotées -45°)
-    for j, cls in enumerate(classes):
-        cx = label_left + j * cell_size + cell_size // 2
-        cy = label_top - 6
-        parts.append(
-            f'<text x="{cx}" y="{cy}" '
-            f'transform="rotate(-45 {cx} {cy})" '
-            f'font-size="11" fill="#333" text-anchor="start">'
-            f'{_e(cls)}</text>'
-        )
-    # Étiquettes de lignes
-    for i, cls in enumerate(classes):
-        rx = label_left - 6
-        ry = label_top + i * cell_size + cell_size // 2 + 4
-        parts.append(
-            f'<text x="{rx}" y="{ry}" '
-            f'font-size="11" fill="#333" text-anchor="end">'
-            f'{_e(cls)}</text>'
-        )
-    # Cellules
-    for i, ca in enumerate(classes):
-        for j, cb in enumerate(classes):
-            value = matrix.get(ca, {}).get(cb, 0.0)
-            x = label_left + j * cell_size
-            y = label_top + i * cell_size
-            color = _color_for_jaccard(value)
-            text_color = _text_color_for_bg(value)
-            parts.append(
-                f'<rect x="{x}" y="{y}" '
-                f'width="{cell_size}" height="{cell_size}" '
-                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
-            )
-            if value > 0.05:
-                parts.append(
-                    f'<text x="{x + cell_size // 2}" '
-                    f'y="{y + cell_size // 2 + 4}" '
-                    f'font-size="10" fill="{text_color}" '
-                    f'text-anchor="middle">'
-                    f'{value:.2f}</text>'
-                )
-    parts.append("</svg>")
-    return "".join(parts)
-
-
-def _build_top_pairs_table(
-    top_pairs: list,
-    labels: dict,
-) -> str:
-    """Construit la table HTML des paires les plus co-occurrentes."""
-    if not top_pairs:
-        return ""
-    pair_label = labels.get("taxocooc_pair_label", "Paire")
-    jaccard_label = labels.get("taxocooc_jaccard_label", "Jaccard")
-
-    parts = [
-        '<table style="border-collapse:collapse;font-size:.85rem;'
-        'margin-top:.5rem">',
-        '<thead><tr>',
-        f'<th style="padding:.3rem .5rem;text-align:left;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(pair_label)}</th>',
-        f'<th style="padding:.3rem .5rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(jaccard_label)}</th>',
-        '</tr></thead><tbody>',
-    ]
-    for ca, cb, j in top_pairs:
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.2rem .5rem">'
-            f'<code>{_e(ca)}</code> ↔ <code>{_e(cb)}</code></td>'
-            f'<td style="padding:.2rem .5rem;text-align:right;'
-            f'font-family:monospace;background:{_color_for_jaccard(j)};'
-            f'color:{_text_color_for_bg(j)}">{j:.2f}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table>")
-    return "".join(parts)
-
-
-def build_taxonomy_cooccurrence_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le bloc HTML complet de co-occurrence taxonomique.
-
-    Retourne ``""`` si ``data is None`` ou matrice vide.
-    """
-    if not data:
-        return ""
-    classes = data.get("classes") or []
-    matrix = data.get("cooccurrence_matrix") or {}
-    if not classes or not matrix:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "taxocooc_title",
-        "Co-occurrence des classes d'erreur",
-    )
-    note = labels.get(
-        "taxocooc_note",
-        "Indice de Jaccard au niveau document : 1,00 = ces deux classes "
-        "apparaissent toujours ensemble ; 0,00 = jamais. Lecture par paires "
-        "co-occurrentes ci-dessous.",
-    )
-    n_docs = data.get("n_documents", 0)
-    n_docs_label_template = labels.get(
-        "taxocooc_n_docs", "Calculé sur {n_docs} documents.",
-    )
-    n_docs_phrase = n_docs_label_template.format(n_docs=n_docs)
-
-    svg = _build_heatmap_svg(classes, matrix)
-    top_table = _build_top_pairs_table(
-        data.get("top_pairs") or [], labels,
-    )
-
-    parts = [
-        '<div class="taxocooc" 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>',
-        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
-        f'{_e(n_docs_phrase)}</div>',
-        svg,
-        top_table,
-        "</div>",
-    ]
-    return "".join(parts)
-
-
-__all__ = [
-    "build_taxonomy_cooccurrence_html",
-]

picarones/extras/render/taxonomy_intra_doc_render.py

@@ -1,182 +0,0 @@
-"""Rendu HTML de la heatmap class × position — Sprint 76.
-
-A.I.4 chantier 2 du plan d'évolution 2026.
-
-Suite directe ``picarones/core/taxonomy_intra_doc.py``.  Pattern
-identique aux autres rendus (Sprints 41/43/62/67/72/74/75) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Sortie typique
---------------
-Une grille N_classes × N_bins où chaque cellule indique la densité
-d'erreurs de cette classe à cette position dans le document.
-Lecture immédiate : « ligature_error concentré dans la première
-tranche → erreur de marge ; visual_confusion uniformément réparti
-→ erreur de scribe ».
-
-Adaptive : si ``data is None`` ou si toutes les classes ont 0
-erreur, retourne ``""``.
-"""
-
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _color_for_density(density: float) -> str:
-    """Gradient blanc → orange profond pour densité ∈ [0, 1].
-
-    Interpolation entre #ffffff (0) et #c2410c (1).
-    """
-    f = max(0.0, min(1.0, density))
-    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 _text_color_for_bg(density: float) -> str:
-    return "#fff" if density > 0.55 else "#222"
-
-
-def _build_heatmap_svg(
-    classes_with_errors: list[str],
-    per_class: dict[str, list[int]],
-    n_bins: int,
-    *,
-    cell_w: int = 36,
-    cell_h: int = 26,
-    label_left: int = 150,
-    label_top: int = 30,
-) -> str:
-    """Construit la heatmap SVG class × position."""
-    n_rows = len(classes_with_errors)
-    if n_rows == 0:
-        return ""
-    width = label_left + n_bins * cell_w + 10
-    height = label_top + n_rows * cell_h + 30  # +30 pour étiquette X
-
-    # Normalisation : pour chaque classe, densité relative au max
-    # de cette classe (mise en évidence des positions concentrées).
-    parts = [
-        f'<svg xmlns="http://www.w3.org/2000/svg" '
-        f'width="{width}" height="{height}" '
-        f'viewBox="0 0 {width} {height}" '
-        f'role="img" aria-label="Heatmap class taxonomique × position">',
-    ]
-    # Étiquettes des colonnes (positions)
-    for j in range(n_bins):
-        cx = label_left + j * cell_w + cell_w // 2
-        cy = label_top - 6
-        parts.append(
-            f'<text x="{cx}" y="{cy}" '
-            f'font-size="10" fill="#666" text-anchor="middle">'
-            f'{j + 1}</text>'
-        )
-    # Cellules
-    for i, cls in enumerate(classes_with_errors):
-        # Étiquette de ligne (classe)
-        rx = label_left - 6
-        ry = label_top + i * cell_h + cell_h // 2 + 4
-        parts.append(
-            f'<text x="{rx}" y="{ry}" '
-            f'font-size="11" fill="#333" text-anchor="end">'
-            f'{_e(cls)}</text>'
-        )
-        counts = per_class.get(cls, [0] * n_bins)
-        max_count = max(counts) if counts else 0
-        for j in range(n_bins):
-            x = label_left + j * cell_w
-            y = label_top + i * cell_h
-            count = counts[j] if j < len(counts) else 0
-            density = (count / max_count) if max_count > 0 else 0.0
-            color = _color_for_density(density)
-            text_color = _text_color_for_bg(density)
-            parts.append(
-                f'<rect x="{x}" y="{y}" '
-                f'width="{cell_w}" height="{cell_h}" '
-                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
-            )
-            if count > 0:
-                parts.append(
-                    f'<text x="{x + cell_w // 2}" '
-                    f'y="{y + cell_h // 2 + 4}" '
-                    f'font-size="10" fill="{text_color}" '
-                    f'text-anchor="middle">{count}</text>'
-                )
-    # Étiquette axe X en bas
-    cx_axis = label_left + (n_bins * cell_w) // 2
-    cy_axis = height - 6
-    parts.append(
-        f'<text x="{cx_axis}" y="{cy_axis}" '
-        f'font-size="11" fill="#666" text-anchor="middle" '
-        f'font-style="italic">'
-        f'Position dans le document (1 = début)</text>'
-    )
-    parts.append("</svg>")
-    return "".join(parts)
-
-
-def build_taxonomy_intra_doc_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le bloc HTML complet de la heatmap intra-document.
-
-    Retourne ``""`` si ``data is None`` ou aucune erreur.
-    """
-    if not data:
-        return ""
-    n_bins = data.get("n_bins", 0)
-    per_class = data.get("per_class") or {}
-    total_errors = data.get("total_errors", 0)
-    if total_errors == 0 or n_bins <= 0:
-        return ""
-    # Filtre : uniquement les classes ayant au moins une erreur
-    classes_with_errors = [
-        cls for cls, counts in per_class.items()
-        if isinstance(counts, list) and sum(counts) > 0
-    ]
-    if not classes_with_errors:
-        return ""
-
-    labels = labels or {}
-    title = labels.get(
-        "intradoc_title",
-        "Évolution intra-document des classes d'erreur",
-    )
-    note = labels.get(
-        "intradoc_note",
-        "Heatmap class × position : densité relative par classe "
-        "(plus foncé = concentré). Une classe concentrée dans la "
-        "première colonne suggère une erreur de marge ; "
-        "une distribution uniforme suggère une erreur de scribe.",
-    )
-    n_words_gt = data.get("n_words_gt", 0)
-    n_words_template = labels.get(
-        "intradoc_n_words",
-        "Calculé sur {n_words_gt} mots GT, répartis en {n_bins} tranches.",
-    )
-    n_words_phrase = n_words_template.format(
-        n_words_gt=n_words_gt, n_bins=n_bins,
-    )
-
-    svg = _build_heatmap_svg(classes_with_errors, per_class, n_bins)
-
-    parts = [
-        '<div class="intradoc" 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>',
-        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
-        f'{_e(n_words_phrase)}</div>',
-        svg,
-        "</div>",
-    ]
-    return "".join(parts)
-
-
-__all__ = [
-    "build_taxonomy_intra_doc_html",
-]

picarones/report/image_predictive_render.py

@@ -1,26 +1,221 @@
-"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.image_predictive_render`.
+"""Rendu HTML « Profil d'image du corpus » — Sprint 93 (A.II.7).
 
-Le contenu vit désormais dans son cercle d'origine. Cet alias permet
-aux imports historiques (y compris les noms privés ``_*``) de
-continuer à fonctionner sans modification.
+Suite directe ``picarones/core/image_predictive.py``.  Pattern
+identique aux autres rendus : server-side, pas de JS, anti-
+injection systématique.
 
-Voir :doc:`docs/architecture-cercles.md` pour la cartographie.
+Vue
+---
+Deux blocs dans une section unique :
+
+1. **Complexité paléographique** : moyenne, médiane, min, max,
+   écart-type sur l'ensemble du corpus.
+2. **Homogénéité du corpus** : score combiné + détail par
+   feature (mean, stdev, contribution normalisée).
+
+Adaptive : ``""`` si pas de données.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose :
+
+.. code-block:: python
+
+    from picarones.measurements.image_predictive import aggregate_corpus_predictive
+    from picarones.report.image_predictive_render import (
+        build_image_predictive_html,
+    )
+
+    qualities = [doc.image_quality.as_dict() for doc in benchmark.docs]
+    agg = aggregate_corpus_predictive(qualities)
+    html = build_image_predictive_html(agg, labels)
 """
 
-from picarones.extras.render.image_predictive_render import *  # noqa: F401, F403
-
-# Réexport explicite de TOUS les noms (privés inclus) pour la
-# rétrocompatibilité des tests Sprints qui importent ``_helper``,
-# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *``
-# ne propage que les noms publics et casse les imports historiques.
-import picarones.extras.render.image_predictive_render as _shim_module
-for _shim_name in dir(_shim_module):
-    if _shim_name == "__builtins__":
-        continue
-    if _shim_name not in globals():
-        globals()[_shim_name] = getattr(_shim_module, _shim_name)
-del _shim_module, _shim_name
-
-__all__ = [
-    _n for _n in dir() if not _n.startswith("__")
-]
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_score(score: float) -> str:
+    """Vert (faible) → orange → rouge (élevé)."""
+    f = max(0.0, min(1.0, score))
+    if f < 0.5:
+        t = f / 0.5
+        r = int(167 + (235 - 167) * t)
+        g = int(240 + (180 - 240) * t)
+        b = int(167 + (60 - 167) * t)
+    else:
+        t = (f - 0.5) / 0.5
+        r = int(235 + (220 - 235) * t)
+        g = int(180 + (50 - 180) * t)
+        b = int(60 + (50 - 60) * t)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+_FEATURE_LABEL_KEYS = {
+    "noise_level": "imgpred_feat_noise",
+    "sharpness_score": "imgpred_feat_sharpness",
+    "contrast_score": "imgpred_feat_contrast",
+    "rotation_degrees": "imgpred_feat_rotation",
+}
+
+
+def _render_complexity_block(
+    aggregated: dict, labels: dict[str, str],
+) -> str:
+    h_complex = labels.get(
+        "imgpred_complexity", "Complexité paléographique",
+    )
+    h_mean = labels.get("imgpred_mean", "Moyenne")
+    h_median = labels.get("imgpred_median", "Médiane")
+    h_min = labels.get("imgpred_min", "Min")
+    h_max = labels.get("imgpred_max", "Max")
+    h_stdev = labels.get("imgpred_stdev", "Écart-type")
+    h_docs = labels.get("imgpred_docs", "Docs")
+    mean = float(aggregated.get("complexity_mean") or 0.0)
+    median = float(aggregated.get("complexity_median") or 0.0)
+    mn = float(aggregated.get("complexity_min") or 0.0)
+    mx = float(aggregated.get("complexity_max") or 0.0)
+    sd = float(aggregated.get("complexity_stdev") or 0.0)
+    n_docs = int(aggregated.get("n_docs") or 0)
+    color_mean = _color_for_score(mean)
+    return (
+        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
+        f'{_e(h_complex)}</div>'
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem;margin-bottom:.8rem">'
+        f'<thead><tr>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_mean)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_median)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_min)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_max)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_stdev)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_docs)}</th>'
+        f'</tr></thead>'
+        f'<tbody><tr>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'background:{color_mean};font-family:monospace;font-weight:600">'
+        f'{mean:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{median:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{mn:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{mx:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{sd:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{n_docs}</td>'
+        f'</tr></tbody></table>'
+    )
+
+
+def _render_homogeneity_block(
+    homogeneity: dict, labels: dict[str, str],
+) -> str:
+    h_homo = labels.get(
+        "imgpred_homogeneity", "Homogénéité du corpus",
+    )
+    h_feat = labels.get("imgpred_feature", "Feature")
+    h_mean = labels.get("imgpred_feat_mean", "Moyenne")
+    h_stdev = labels.get("imgpred_feat_stdev", "Écart-type")
+    h_norm = labels.get(
+        "imgpred_feat_norm", "Contribution normalisée",
+    )
+    score = float(homogeneity.get("score") or 0.0)
+    color = _color_for_score(score)
+    parts = [
+        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
+        f'{_e(h_homo)} : '
+        f'<span style="background:{color};padding:.1rem .4rem;'
+        f'border-radius:.3rem;font-family:monospace">{score:.3f}</span>'
+        f'</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_feat, h_mean, h_stdev, h_norm):
+        parts.append(
+            f'<th style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+    per_feat = homogeneity.get("per_feature") or {}
+    for key, label_key in _FEATURE_LABEL_KEYS.items():
+        if key not in per_feat:
+            continue
+        slot = per_feat[key]
+        feat_label = labels.get(label_key, key)
+        feat_mean = float(slot.get("mean") or 0.0)
+        feat_stdev = float(slot.get("stdev") or 0.0)
+        feat_norm = float(slot.get("normalised") or 0.0)
+        norm_color = _color_for_score(feat_norm)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(feat_label)}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{feat_mean:.3f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{feat_stdev:.3f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{norm_color};font-family:monospace">'
+            f'{feat_norm:.3f}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def build_image_predictive_html(
+    aggregated: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML « Profil d'image du corpus ».
+
+    Parameters
+    ----------
+    aggregated:
+        Sortie de ``aggregate_corpus_predictive``.  Si ``None``
+        ou ``n_docs == 0``, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``imgpred_*``.
+    """
+    if not aggregated:
+        return ""
+    if not aggregated.get("n_docs"):
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "imgpred_title", "Profil d'image du corpus",
+    )
+    note = labels.get(
+        "imgpred_note",
+        "Score de complexité paléographique combinant bruit, "
+        "flou, faible contraste et rotation. Le score "
+        "d'homogénéité signale si la moyenne globale est fiable "
+        "(corpus uniforme) ou trompeuse (corpus hétérogène — "
+        "voir alors la vue stratifiée).",
+    )
+    parts = [
+        '<section class="imgpred-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.6rem">'
+        f'{_e(note)}</div>',
+    ]
+    parts.append(_render_complexity_block(aggregated, labels))
+    homo = aggregated.get("homogeneity")
+    if isinstance(homo, dict):
+        parts.append(_render_homogeneity_block(homo, labels))
+    parts.append("</section>")
+    return "".join(parts)
+
+
+__all__ = ["build_image_predictive_html"]

picarones/report/lexical_modernization_render.py

@@ -1,26 +1,119 @@
-"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.lexical_modernization_render`.
+"""Rendu HTML de la vue « Modernisation lexicale » — Sprint 80.
 
-Le contenu vit désormais dans son cercle d'origine. Cet alias permet
-aux imports historiques (y compris les noms privés ``_*``) de
-continuer à fonctionner sans modification.
+A.I.7 du plan d'évolution 2026.
 
-Voir :doc:`docs/architecture-cercles.md` pour la cartographie.
+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 picarones.extras.render.lexical_modernization_render import *  # noqa: F401, F403
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.measurements.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)
 
-# Réexport explicite de TOUS les noms (privés inclus) pour la
-# rétrocompatibilité des tests Sprints qui importent ``_helper``,
-# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *``
-# ne propage que les noms publics et casse les imports historiques.
-import picarones.extras.render.lexical_modernization_render as _shim_module
-for _shim_name in dir(_shim_module):
-    if _shim_name == "__builtins__":
-        continue
-    if _shim_name not in globals():
-        globals()[_shim_name] = getattr(_shim_module, _shim_name)
-del _shim_module, _shim_name
 
 __all__ = [
-    _n for _n in dir() if not _n.startswith("__")
+    "build_lexical_modernization_html",
 ]

picarones/report/module_audit_render.py

@@ -1,26 +1,173 @@
-"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.module_audit_render`.
+"""Rendu HTML « Modules audités » — Sprint 97 (B.6).
 
-Le contenu vit désormais dans son cercle d'origine. Cet alias permet
-aux imports historiques (y compris les noms privés ``_*``) de
-continuer à fonctionner sans modification.
+Suite directe ``picarones/core/module_policy.py``.  Pattern
+identique aux autres rendus : server-side, pas de JS, anti-
+injection systématique.
 
-Voir :doc:`docs/architecture-cercles.md` pour la cartographie.
+Vue
+---
+Tableau récapitulatif des modules utilisés dans une pipeline
+composée, chacun avec :
+
+- Statut d'audit (✓ vert si tous les checks passent, ✗ rouge
+  sinon, avec compte des échecs) ;
+- Métadonnées : version, auteur, licence ;
+- Citation académique si fournie ;
+- Lien vers la homepage si fourni.
+
+Adaptive : ``""`` si la liste est vide.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose la liste depuis sa
+``PipelineSpec`` augmentée des ``ModuleManifest`` :
+
+.. code-block:: python
+
+    from picarones.measurements.module_policy import audit_module
+    from picarones.report.module_audit_render import build_module_audit_html
+
+    audits = []
+    for step in pipeline.steps:
+        manifest = step.module.manifest  # convention applicative
+        result = audit_module(step.module, manifest)
+        audits.append({
+            "manifest": manifest.as_dict(),
+            "audit": result.as_dict(),
+        })
+    html = build_module_audit_html(audits, labels)
 """
 
-from picarones.extras.render.module_audit_render import *  # noqa: F401, F403
-
-# Réexport explicite de TOUS les noms (privés inclus) pour la
-# rétrocompatibilité des tests Sprints qui importent ``_helper``,
-# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *``
-# ne propage que les noms publics et casse les imports historiques.
-import picarones.extras.render.module_audit_render as _shim_module
-for _shim_name in dir(_shim_module):
-    if _shim_name == "__builtins__":
-        continue
-    if _shim_name not in globals():
-        globals()[_shim_name] = getattr(_shim_module, _shim_name)
-del _shim_module, _shim_name
-
-__all__ = [
-    _n for _n in dir() if not _n.startswith("__")
-]
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _passed_badge(passed: bool, n_failed: int, label_pass: str,
+                  label_fail: str) -> str:
+    if passed:
+        return (
+            f'<span style="color:#16a34a;font-weight:700">'
+            f'✓ {_e(label_pass)}</span>'
+        )
+    return (
+        f'<span style="color:#dc2626;font-weight:700">'
+        f'✗ {_e(label_fail)} ({n_failed})</span>'
+    )
+
+
+def build_module_audit_html(
+    audits: Optional[list],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML « Modules audités ».
+
+    Parameters
+    ----------
+    audits:
+        Liste de dicts ``{"manifest": ManifestDict, "audit":
+        AuditResultDict}``.  Si vide ou ``None``, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``audit_*``.
+    """
+    if not audits:
+        return ""
+    rows = [
+        a for a in audits
+        if isinstance(a, dict)
+        and isinstance(a.get("manifest"), dict)
+        and isinstance(a.get("audit"), dict)
+    ]
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get("audit_title", "Modules audités")
+    note = labels.get(
+        "audit_note",
+        "Récapitulatif des modules utilisés dans la pipeline "
+        "composée. Un module qui ne passe pas l'audit n'est "
+        "pas exécutable. Métadonnées issues du manifest fourni "
+        "par le contributeur (auteur, licence, citation).",
+    )
+    label_pass = labels.get("audit_pass", "audit OK")
+    label_fail = labels.get("audit_fail", "checks échoués")
+    h_module = labels.get("audit_module", "Module")
+    h_status = labels.get("audit_status", "Audit")
+    h_version = labels.get("audit_version", "Version")
+    h_author = labels.get("audit_author", "Auteur")
+    h_license = labels.get("audit_license", "Licence")
+    h_io = labels.get("audit_io", "Entrée → sortie")
+    h_citation = labels.get("audit_citation", "Citation")
+    h_homepage = labels.get("audit_homepage", "Page projet")
+
+    parts = [
+        '<section class="audit-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_module, h_status, h_version, h_author,
+                h_license, h_io, h_citation, h_homepage):
+        parts.append(
+            f'<th style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+
+    for entry in rows:
+        manifest = entry["manifest"]
+        audit = entry["audit"]
+        name = str(manifest.get("name") or "?")
+        version = str(manifest.get("version") or "—")
+        author = str(manifest.get("author") or "—")
+        license_ = str(manifest.get("license") or "—")
+        in_types = ", ".join(manifest.get("input_types") or []) or "—"
+        out_types = ", ".join(manifest.get("output_types") or []) or "—"
+        citation = manifest.get("citation") or ""
+        homepage = manifest.get("homepage") or ""
+        passed = bool(audit.get("passed"))
+        n_failed = int(audit.get("n_failed") or 0)
+        status_cell = _passed_badge(
+            passed, n_failed, label_pass, label_fail,
+        )
+        # Citation : tronqué si trop long
+        citation_str = str(citation)[:120]
+        if len(str(citation)) > 120:
+            citation_str += "…"
+        citation_cell = (
+            _e(citation_str) if citation_str.strip() else "—"
+        )
+        # Homepage : on n'auto-link **pas** (anti-injection +
+        # honnêteté : l'URL peut pointer ailleurs).  On affiche
+        # le texte échappé tel quel.
+        homepage_cell = (
+            _e(str(homepage))[:80] + ("…" if len(str(homepage)) > 80 else "")
+        ) if str(homepage).strip() else "—"
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace">'
+            f'{_e(name)}</td>'
+            f'<td style="padding:.4rem .6rem">{status_cell}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace">'
+            f'{_e(version)}</td>'
+            f'<td style="padding:.4rem .6rem">{_e(author)}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace">'
+            f'{_e(license_)}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace;'
+            f'font-size:.8rem">{_e(in_types)} → {_e(out_types)}</td>'
+            f'<td style="padding:.4rem .6rem;font-size:.8rem;'
+            f'opacity:.85">{citation_cell}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace;'
+            f'font-size:.8rem">{homepage_cell}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></section>")
+    return "".join(parts)
+
+
+__all__ = ["build_module_audit_html"]

picarones/report/philological_render.py

@@ -1,26 +1,615 @@
-"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.philological_render`.
+"""Rendu HTML server-side du profil philologique (Sprint 62).
 
-Le contenu vit désormais dans son cercle d'origine. Cet alias permet
-aux imports historiques (y compris les noms privés ``_*``) de
-continuer à fonctionner sans modification.
+Suite directe Sprint 61 (câblage backend) — produit les blocs HTML
+qui exposent les six modules philologiques (Sprints 55-60) dans le
+rapport :
 
-Voir :doc:`docs/architecture-cercles.md` pour la cartographie.
+- ``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 picarones.extras.render.philological_render import *  # noqa: F401, F403
+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)
 
-# Réexport explicite de TOUS les noms (privés inclus) pour la
-# rétrocompatibilité des tests Sprints qui importent ``_helper``,
-# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *``
-# ne propage que les noms publics et casse les imports historiques.
-import picarones.extras.render.philological_render as _shim_module
-for _shim_name in dir(_shim_module):
-    if _shim_name == "__builtins__":
-        continue
-    if _shim_name not in globals():
-        globals()[_shim_name] = getattr(_shim_module, _shim_name)
-del _shim_module, _shim_name
 
 __all__ = [
-    _n for _n in dir() if not _n.startswith("__")
+    "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/taxonomy_cooccurrence_render.py

@@ -1,26 +1,199 @@
-"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.taxonomy_cooccurrence_render`.
+"""Rendu HTML de la heatmap de co-occurrence taxonomique — Sprint 75.
 
-Le contenu vit désormais dans son cercle d'origine. Cet alias permet
-aux imports historiques (y compris les noms privés ``_*``) de
-continuer à fonctionner sans modification.
+A.I.4 chantier 1 du plan d'évolution 2026.
 
-Voir :doc:`docs/architecture-cercles.md` pour la cartographie.
+Suite directe ``picarones/core/taxonomy_cooccurrence.py``.  Pattern
+identique aux autres rendus (Sprints 41/43/62/67/72/74) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Sortie typique
+--------------
+- ``build_taxonomy_cooccurrence_html(data, labels)`` produit un
+  bloc complet : titre + note d'usage + heatmap SVG + table des
+  paires les plus co-occurrentes.
+- ``""`` retourné si ``data is None`` ou si la matrice est vide
+  (rapport adaptatif).
 """
 
-from picarones.extras.render.taxonomy_cooccurrence_render import *  # noqa: F401, F403
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_jaccard(j: float) -> str:
+    """Gradient blanc → bleu profond pour Jaccard ∈ [0, 1].
+
+    Interpolation entre #ffffff (j=0) et #1e3a8a (j=1).
+    """
+    f = max(0.0, min(1.0, j))
+    r = int(255 + (30 - 255) * f)
+    g = int(255 + (58 - 255) * f)
+    b = int(255 + (138 - 255) * f)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _text_color_for_bg(j: float) -> str:
+    """Texte blanc si fond foncé, noir sinon (lisibilité)."""
+    return "#fff" if j > 0.55 else "#222"
+
+
+def _build_heatmap_svg(
+    classes: list[str],
+    matrix: dict[str, dict[str, float]],
+    *,
+    cell_size: int = 36,
+    label_left: int = 130,
+    label_top: int = 80,
+) -> str:
+    """Construit la heatmap SVG.
+
+    Cellule = carré coloré ``_color_for_jaccard``, valeur Jaccard
+    affichée en chiffres si > 0,05.  Étiquettes des classes en
+    colonne (haut) et en ligne (gauche).
+    """
+    n = len(classes)
+    if n == 0:
+        return ""
+    width = label_left + n * cell_size + 10
+    height = label_top + n * cell_size + 10
+
+    parts = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" '
+        f'width="{width}" height="{height}" '
+        f'viewBox="0 0 {width} {height}" '
+        f'role="img" aria-label="Heatmap Jaccard co-occurrence taxonomique">',
+    ]
+    # Étiquettes de colonnes (rotées -45°)
+    for j, cls in enumerate(classes):
+        cx = label_left + j * cell_size + cell_size // 2
+        cy = label_top - 6
+        parts.append(
+            f'<text x="{cx}" y="{cy}" '
+            f'transform="rotate(-45 {cx} {cy})" '
+            f'font-size="11" fill="#333" text-anchor="start">'
+            f'{_e(cls)}</text>'
+        )
+    # Étiquettes de lignes
+    for i, cls in enumerate(classes):
+        rx = label_left - 6
+        ry = label_top + i * cell_size + cell_size // 2 + 4
+        parts.append(
+            f'<text x="{rx}" y="{ry}" '
+            f'font-size="11" fill="#333" text-anchor="end">'
+            f'{_e(cls)}</text>'
+        )
+    # Cellules
+    for i, ca in enumerate(classes):
+        for j, cb in enumerate(classes):
+            value = matrix.get(ca, {}).get(cb, 0.0)
+            x = label_left + j * cell_size
+            y = label_top + i * cell_size
+            color = _color_for_jaccard(value)
+            text_color = _text_color_for_bg(value)
+            parts.append(
+                f'<rect x="{x}" y="{y}" '
+                f'width="{cell_size}" height="{cell_size}" '
+                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
+            )
+            if value > 0.05:
+                parts.append(
+                    f'<text x="{x + cell_size // 2}" '
+                    f'y="{y + cell_size // 2 + 4}" '
+                    f'font-size="10" fill="{text_color}" '
+                    f'text-anchor="middle">'
+                    f'{value:.2f}</text>'
+                )
+    parts.append("</svg>")
+    return "".join(parts)
+
+
+def _build_top_pairs_table(
+    top_pairs: list,
+    labels: dict,
+) -> str:
+    """Construit la table HTML des paires les plus co-occurrentes."""
+    if not top_pairs:
+        return ""
+    pair_label = labels.get("taxocooc_pair_label", "Paire")
+    jaccard_label = labels.get("taxocooc_jaccard_label", "Jaccard")
+
+    parts = [
+        '<table style="border-collapse:collapse;font-size:.85rem;'
+        'margin-top:.5rem">',
+        '<thead><tr>',
+        f'<th style="padding:.3rem .5rem;text-align:left;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(pair_label)}</th>',
+        f'<th style="padding:.3rem .5rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(jaccard_label)}</th>',
+        '</tr></thead><tbody>',
+    ]
+    for ca, cb, j in top_pairs:
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.2rem .5rem">'
+            f'<code>{_e(ca)}</code> ↔ <code>{_e(cb)}</code></td>'
+            f'<td style="padding:.2rem .5rem;text-align:right;'
+            f'font-family:monospace;background:{_color_for_jaccard(j)};'
+            f'color:{_text_color_for_bg(j)}">{j:.2f}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def build_taxonomy_cooccurrence_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le bloc HTML complet de co-occurrence taxonomique.
+
+    Retourne ``""`` si ``data is None`` ou matrice vide.
+    """
+    if not data:
+        return ""
+    classes = data.get("classes") or []
+    matrix = data.get("cooccurrence_matrix") or {}
+    if not classes or not matrix:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "taxocooc_title",
+        "Co-occurrence des classes d'erreur",
+    )
+    note = labels.get(
+        "taxocooc_note",
+        "Indice de Jaccard au niveau document : 1,00 = ces deux classes "
+        "apparaissent toujours ensemble ; 0,00 = jamais. Lecture par paires "
+        "co-occurrentes ci-dessous.",
+    )
+    n_docs = data.get("n_documents", 0)
+    n_docs_label_template = labels.get(
+        "taxocooc_n_docs", "Calculé sur {n_docs} documents.",
+    )
+    n_docs_phrase = n_docs_label_template.format(n_docs=n_docs)
+
+    svg = _build_heatmap_svg(classes, matrix)
+    top_table = _build_top_pairs_table(
+        data.get("top_pairs") or [], labels,
+    )
+
+    parts = [
+        '<div class="taxocooc" 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>',
+        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
+        f'{_e(n_docs_phrase)}</div>',
+        svg,
+        top_table,
+        "</div>",
+    ]
+    return "".join(parts)
 
-# Réexport explicite de TOUS les noms (privés inclus) pour la
-# rétrocompatibilité des tests Sprints qui importent ``_helper``,
-# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *``
-# ne propage que les noms publics et casse les imports historiques.
-import picarones.extras.render.taxonomy_cooccurrence_render as _shim_module
-for _shim_name in dir(_shim_module):
-    if _shim_name == "__builtins__":
-        continue
-    if _shim_name not in globals():
-        globals()[_shim_name] = getattr(_shim_module, _shim_name)
-del _shim_module, _shim_name
 
 __all__ = [
-    _n for _n in dir() if not _n.startswith("__")
+    "build_taxonomy_cooccurrence_html",
 ]

picarones/report/taxonomy_intra_doc_render.py

@@ -1,26 +1,182 @@
-"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.taxonomy_intra_doc_render`.
+"""Rendu HTML de la heatmap class × position — Sprint 76.
 
-Le contenu vit désormais dans son cercle d'origine. Cet alias permet
-aux imports historiques (y compris les noms privés ``_*``) de
-continuer à fonctionner sans modification.
+A.I.4 chantier 2 du plan d'évolution 2026.
 
-Voir :doc:`docs/architecture-cercles.md` pour la cartographie.
+Suite directe ``picarones/core/taxonomy_intra_doc.py``.  Pattern
+identique aux autres rendus (Sprints 41/43/62/67/72/74/75) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Sortie typique
+--------------
+Une grille N_classes × N_bins où chaque cellule indique la densité
+d'erreurs de cette classe à cette position dans le document.
+Lecture immédiate : « ligature_error concentré dans la première
+tranche → erreur de marge ; visual_confusion uniformément réparti
+→ erreur de scribe ».
+
+Adaptive : si ``data is None`` ou si toutes les classes ont 0
+erreur, retourne ``""``.
 """
 
-from picarones.extras.render.taxonomy_intra_doc_render import *  # noqa: F401, F403
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_density(density: float) -> str:
+    """Gradient blanc → orange profond pour densité ∈ [0, 1].
+
+    Interpolation entre #ffffff (0) et #c2410c (1).
+    """
+    f = max(0.0, min(1.0, density))
+    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 _text_color_for_bg(density: float) -> str:
+    return "#fff" if density > 0.55 else "#222"
+
+
+def _build_heatmap_svg(
+    classes_with_errors: list[str],
+    per_class: dict[str, list[int]],
+    n_bins: int,
+    *,
+    cell_w: int = 36,
+    cell_h: int = 26,
+    label_left: int = 150,
+    label_top: int = 30,
+) -> str:
+    """Construit la heatmap SVG class × position."""
+    n_rows = len(classes_with_errors)
+    if n_rows == 0:
+        return ""
+    width = label_left + n_bins * cell_w + 10
+    height = label_top + n_rows * cell_h + 30  # +30 pour étiquette X
+
+    # Normalisation : pour chaque classe, densité relative au max
+    # de cette classe (mise en évidence des positions concentrées).
+    parts = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" '
+        f'width="{width}" height="{height}" '
+        f'viewBox="0 0 {width} {height}" '
+        f'role="img" aria-label="Heatmap class taxonomique × position">',
+    ]
+    # Étiquettes des colonnes (positions)
+    for j in range(n_bins):
+        cx = label_left + j * cell_w + cell_w // 2
+        cy = label_top - 6
+        parts.append(
+            f'<text x="{cx}" y="{cy}" '
+            f'font-size="10" fill="#666" text-anchor="middle">'
+            f'{j + 1}</text>'
+        )
+    # Cellules
+    for i, cls in enumerate(classes_with_errors):
+        # Étiquette de ligne (classe)
+        rx = label_left - 6
+        ry = label_top + i * cell_h + cell_h // 2 + 4
+        parts.append(
+            f'<text x="{rx}" y="{ry}" '
+            f'font-size="11" fill="#333" text-anchor="end">'
+            f'{_e(cls)}</text>'
+        )
+        counts = per_class.get(cls, [0] * n_bins)
+        max_count = max(counts) if counts else 0
+        for j in range(n_bins):
+            x = label_left + j * cell_w
+            y = label_top + i * cell_h
+            count = counts[j] if j < len(counts) else 0
+            density = (count / max_count) if max_count > 0 else 0.0
+            color = _color_for_density(density)
+            text_color = _text_color_for_bg(density)
+            parts.append(
+                f'<rect x="{x}" y="{y}" '
+                f'width="{cell_w}" height="{cell_h}" '
+                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
+            )
+            if count > 0:
+                parts.append(
+                    f'<text x="{x + cell_w // 2}" '
+                    f'y="{y + cell_h // 2 + 4}" '
+                    f'font-size="10" fill="{text_color}" '
+                    f'text-anchor="middle">{count}</text>'
+                )
+    # Étiquette axe X en bas
+    cx_axis = label_left + (n_bins * cell_w) // 2
+    cy_axis = height - 6
+    parts.append(
+        f'<text x="{cx_axis}" y="{cy_axis}" '
+        f'font-size="11" fill="#666" text-anchor="middle" '
+        f'font-style="italic">'
+        f'Position dans le document (1 = début)</text>'
+    )
+    parts.append("</svg>")
+    return "".join(parts)
+
+
+def build_taxonomy_intra_doc_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le bloc HTML complet de la heatmap intra-document.
+
+    Retourne ``""`` si ``data is None`` ou aucune erreur.
+    """
+    if not data:
+        return ""
+    n_bins = data.get("n_bins", 0)
+    per_class = data.get("per_class") or {}
+    total_errors = data.get("total_errors", 0)
+    if total_errors == 0 or n_bins <= 0:
+        return ""
+    # Filtre : uniquement les classes ayant au moins une erreur
+    classes_with_errors = [
+        cls for cls, counts in per_class.items()
+        if isinstance(counts, list) and sum(counts) > 0
+    ]
+    if not classes_with_errors:
+        return ""
+
+    labels = labels or {}
+    title = labels.get(
+        "intradoc_title",
+        "Évolution intra-document des classes d'erreur",
+    )
+    note = labels.get(
+        "intradoc_note",
+        "Heatmap class × position : densité relative par classe "
+        "(plus foncé = concentré). Une classe concentrée dans la "
+        "première colonne suggère une erreur de marge ; "
+        "une distribution uniforme suggère une erreur de scribe.",
+    )
+    n_words_gt = data.get("n_words_gt", 0)
+    n_words_template = labels.get(
+        "intradoc_n_words",
+        "Calculé sur {n_words_gt} mots GT, répartis en {n_bins} tranches.",
+    )
+    n_words_phrase = n_words_template.format(
+        n_words_gt=n_words_gt, n_bins=n_bins,
+    )
+
+    svg = _build_heatmap_svg(classes_with_errors, per_class, n_bins)
+
+    parts = [
+        '<div class="intradoc" 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>',
+        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
+        f'{_e(n_words_phrase)}</div>',
+        svg,
+        "</div>",
+    ]
+    return "".join(parts)
 
-# Réexport explicite de TOUS les noms (privés inclus) pour la
-# rétrocompatibilité des tests Sprints qui importent ``_helper``,
-# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *``
-# ne propage que les noms publics et casse les imports historiques.
-import picarones.extras.render.taxonomy_intra_doc_render as _shim_module
-for _shim_name in dir(_shim_module):
-    if _shim_name == "__builtins__":
-        continue
-    if _shim_name not in globals():
-        globals()[_shim_name] = getattr(_shim_module, _shim_name)
-del _shim_module, _shim_name
 
 __all__ = [
-    _n for _n in dir() if not _n.startswith("__")
+    "build_taxonomy_intra_doc_html",
 ]