detect/regex_layer.py

"""Couche A : detection deterministe regex + checksums (analyse §2.A).

Regle de decision (2026-07-28) :
- Les patterns AVEC checksum (IBAN, NIR, SIREN/SIRET, TVA, CB) decident seuls :
  un match syntaxique dont le checksum est valide est retenu, point.
- Email, IP (octets valides), plaque SIV (AA-123-BC), cadastre ("section X
  n° N" porte son contexte) decident seuls aussi : formats assez distinctifs.
- Les patterns SANS checksum ni format fort (telephone compact 10 chiffres,
  n° RG, ancienne plaque 123 ABC 75) exigent un mot de contexte dans les
  30 caracteres precedents. Un telephone +33 ou avec separateurs decide seul.

Resolution de chevauchements : le span le plus long gagne (un CB 4x4 matche
dans un IBAN groupe par 4 ; le SIREN vit dans le SIRET et la TVA).

Pre-normalisation OCR : les confusions classiques (O/0, l/1, S/5, B/8) sont
corrigees token par token selon la dominante du token (lettres ou chiffres),
puis la detection tourne sur le texte d'origine ET sur la forme normalisee
(meme longueur, memes offsets). Le checksum reste le juge : un token corrige
qui ne valide pas n'est pas retenu. Voir doc/memory/matrice_comparaison.md.

Sortie : liste de spans au format du harness. Ce module servira tel quel de
couche A du produit ; ici il est branche sur le benchmark comme premier
candidat de la matrice de comparaison (§5.3).
"""

import re

from bench.pii import checksums as ck

_CONTEXT_WINDOW = 30

_PATTERNS: list[tuple[str, re.Pattern, str | None]] = []


def _p(etype: str, pattern: str, context: str | None = None, flags: int = 0):
    _PATTERNS.append((etype, re.compile(pattern, flags), context))


# --- checksum : decident seuls -------------------------------------------
_p("IBAN", r"\b[A-Z]{2}\d{2}(?: ?[A-Z0-9]{4}){2,7}(?: ?[A-Z0-9]{1,3})?\b")
_p("NIR", r"\b[12](?: ?\d{2}){2} ?(?:\d{2}|2A|2B)(?: ?\d{3}){2} ?\d{2}\b")
_p("SIRET", r"\b\d{3} ?\d{3} ?\d{3} ?\d{5}\b")
_p("TVA", r"\bFR ?\d{2} ?\d{3} ?\d{3} ?\d{3}\b")
_p("SIREN", r"\b\d{3} ?\d{3} ?\d{3}\b")
_p("CARD", r"\b\d{4}(?: ?\d{4}){3}\b")

_VALIDATORS = {
    "IBAN": ck.iban_valid,
    "NIR": ck.nir_valid,
    "SIRET": lambda s: ck.siret_valid(s.replace(" ", "")),
    "TVA": ck.tva_fr_valid,
    "SIREN": lambda s: ck.siren_valid(s.replace(" ", "")),
    "CARD": lambda s: ck.luhn_valid(s.replace(" ", "")),
}

# --- format fort : decident seuls ----------------------------------------
_p("EMAIL", r"\b[\w.+-]+@[\w-]+\.[\w.]{1,10}\b")
_p("PLATE", r"\b[A-Z]{2}-\d{3}-[A-Z]{2}\b", flags=re.IGNORECASE)
_p("CADASTRE", r"\bsection [A-Z]{1,2} n° ?\d{1,3}\b", flags=re.IGNORECASE)
_p("ADDRESS", r"\b(?:CS|BP|TSA|CEDEX) ?\d{2,6}\b")
_p("IP", r"\b(?:\d{1,3}\.){3}\d{1,3}\b")
_p("PHONE", r"(?:\+33|0033) ?[1-9](?:[ .]?\d{2}){4}\b")
_p("PHONE", r"\b0[1-9](?:[ .]\d{2}){4}\b")
# formats internationaux reels (audit emails 2026-07-29) : "+33(0)1 23...",
# "+ 33 6...", numeros belges/lux/suisses, groupements irreguliers
_p("PHONE", r"\+ ?\d{2,3} ?\(0\) ?\d(?:[ .]?\d{2,3}){3,5}\b")
_p("PHONE", r"\+ ?\d{2,3}(?:[ .]?\d{2,3}){4,6}\b")
_p("PHONE", r"\+ ?\d{2,3} ?\d(?:[ .]?\d{2}){4}\b")
# formats etrangers a groupes irreguliers (+32 471 12 34 56, +41 79 123 45 67)
_p("PHONE", r"\+ ?\d{2,3}(?:[ .]\d{2,4}){3,5}\b")

# URLs : angle mort releve par l'audit emails (3 liens porteurs de jetons
# jamais captures). Type URL, maskable par politique ; les liens avec longs
# segments aleatoires (jetons) sont le vrai danger.
_p("URL", r"\bhttps?://[^\s<>\"')\]]+")
_p("URL", r"\bwww\.[\w.-]+\.[a-z]{2,6}\b", flags=re.IGNORECASE)
# Domaines nus, sans schema ni www : « app.easywage.fr », « console.mistral.ai ».
# Audit du 31/07 : 16 des 21 URL non protegees etaient de cette forme. La
# liste de TLD evite d'avaler « document.pdf » ou « fichier.tar.gz ».
_TLD = (r"fr|com|net|org|io|dev|app|eu|be|ch|lu|ca|ai|co|me|tech|cloud|"
        r"info|biz|shop|store|agency|studio|solutions|consulting")
_p("URL", rf"\b(?<![@\w.])[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*"
          rf"\.(?:{_TLD})\b(?:/[^\s<>\"')\]]*[^\s<>\"')\].,;:!?])?", flags=re.IGNORECASE)

# Telephones internationaux espaces et format nord-americain.
_p("PHONE", r"\(\+ ?\d{1,3}\) ?\d(?:[ .]?\d{2,3}){3,5}\b")
_p("PHONE", r"\b\d{3}-\d{3}-\d{4}\b")
# indicatif puis groupes de longueur libre : « + 32 2 808 66 05 »
_p("PHONE", r"\+ ?\d{2,3}(?: \d{1,4}){3,6}\b")

# Identifiants techniques : un UUID est toujours une reference opaque.
_p("REF", r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b",
   flags=re.IGNORECASE)

# --- formats etendus (pas des identifiants, mais deterministes) ----------
# Le NER (Anonym-IA V2) ignore quasi totalement dates et montants sur notre
# benchmark (~98 % de fuite) : on les prend en regex. Sur-masquage assume :
# masquer une date non personnelle est benin, la rater ne l'est pas.
_MOIS = ("janvier|février|fevrier|mars|avril|mai|juin|juillet|août|aout|"
         "septembre|octobre|novembre|décembre|decembre")
_p("DATE", r"\b\d{1,2}[/.]\d{1,2}[/.]\d{2,4}\b")
# dates sans annee "12/07" (contexte le/du/au) et mois anglais (titres de
# reunions exportees) — audit emails 2026-07-29
_p("DATE", r"\b\d{1,2}/\d{1,2}\b")
_p("DATE", r"\b\d{1,2}\.\d{1,2}\b", context=r"\ble\b|\bdu\b|\bau\b|\bdès\b|avant|depuis|jusqu")
_MOIS_EN = "January|February|March|April|May|June|July|August|September|October|November|December"
_p("DATE", rf"\b\d{{1,2}} (?:{_MOIS_EN}) \d{{4}}\b", flags=re.IGNORECASE)
_p("DATE", rf"\b(?:{_MOIS}) \d{{4}}\b", flags=re.IGNORECASE)
_JOURS = "lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche"
_p("DATE", rf"\b(?:{_JOURS}) \d{{1,2}}(?: (?:{_MOIS}))?\b", flags=re.IGNORECASE)
_p("DATE", rf"\b\d{{1,2}}(?:er)? (?:{_MOIS}) \d{{4}}\b", flags=re.IGNORECASE)
# Dates sans annee et mois seuls. Audit du 31/07 : DATE fuyait a 42,9 % sur
# la correspondance reelle, uniquement sur ces formes-la. « le 17 juin »,
# « courant juillet », « en 2025 » sont des dates aux yeux de l'annotation.
_p("DATE", rf"\b\d{{1,2}}(?:er)? (?:{_MOIS})\b", flags=re.IGNORECASE)
_p("DATE", rf"\b\d{{1,2}} ?[-–—] ?\d{{1,2}} (?:{_MOIS})\b", flags=re.IGNORECASE)
_p("DATE", rf"\b(?:{_MOIS})\b", flags=re.IGNORECASE)
_p("DATE", r"(?<![-/\w])(?:19|20)\d{2}(?![-/\d])")

# Montants. Le motif d'origine exigeait un symbole euro APRES le nombre, d'ou
# 54 % de fuite : il ratait les francs suisses (« CHF 49.- », « CHF 8'450 »),
# les magnitudes (« 30K€ », « 847 M€ ») et les fourchettes (« 20 a 30 k€ »).
_DEVISE = r"€|euros?\b|EUR\b|CHF\b|\$|USD\b|£|GBP\b"
_NOMBRE = r"\d{1,3}(?:[ .' ]\d{3})+|\d+"
_ECHELLE = r"\s?(?:[kKmM]|[Mm]illions?|[Mm]illiards?)"

# devise en tete : « CHF 8'450 », « CHF 49.- », « CHF - 6.00 », « $ 1 200 »
_p("AMOUNT", rf"(?:{_DEVISE})\s?-?\s?(?:{_NOMBRE}|X)(?:[.,]\d{{1,3}}|\.-{{1,2}})?"
             rf"(?:{_ECHELLE})?", flags=re.IGNORECASE)
# devise en queue, avec echelle optionnelle : « 30K€ », « 847 M€ », « 1 200 € »
_p("AMOUNT", rf"\b(?:{_NOMBRE})(?:[.,]\d{{1,3}})?(?:{_ECHELLE})?\s?(?:{_DEVISE})",
   flags=re.IGNORECASE)
# fourchettes : « 20 a 30 k€ », « 200-250 € », « 1 600–1 700 € »
_p("AMOUNT", rf"\b(?:{_NOMBRE})(?:[.,]\d{{1,2}})?(?:{_ECHELLE})?\s?"
             rf"(?:a|à|-|–|—|et)\s?(?:{_NOMBRE})(?:[.,]\d{{1,2}})?"
             rf"(?:{_ECHELLE})?\s?(?:{_DEVISE})", flags=re.IGNORECASE)
# periodicite collee au montant : « CHF 49/mois », « 1 200 € par an »
_p("AMOUNT", rf"(?:{_DEVISE})\s?(?:{_NOMBRE})(?:[.,]\d{{1,3}})?\s?/\s?"
             rf"(?:mois|an|jour|semaine|h|heure|utilisateur|poste)\b", flags=re.IGNORECASE)
# echelle ecrite en toutes lettres sans devise : « 6,4 Millions »
_p("AMOUNT", r"\b\d{1,3}(?:[.,]\d{1,3})? ?(?:[Mm]illions?|[Mm]illiards?)\b")

# nombre a deux decimales dans un contexte comptable : lignes de facture
_p("AMOUNT", r"\b\d{1,3}(?:[ .']\d{3})*[.,]\d{2}\b",
   context=r"montant|prix|total|facture|co[uû]t|tarif|solde|HT\b|TTC\b|"
           r"honoraires|acompte|remise|net\b|TVA\b|\bpar mois\b|\bmensuel")

_p("ADDRESS", r"\b(?:B[âa]timent|B[âa]t\.?|Immeuble|R[ée]sidence|Escalier|Hall|Lot)"
                      r" ?[A-Z0-9][\w-]{0,12}\b", flags=re.IGNORECASE)

# Recensement du 31/07 : 7 adresses non protegees sur 172, en quatre
# familles. Le corpus contient de la correspondance suisse et anglo-saxonne.
_VOIE = (r"rue|avenue|av\.|boulevard|bd\.?|chemin|impasse|all[ée]e|place|"
         r"route|quai|cours|square|villa|passage|sentier|faubourg")
# ordre suisse et belge : le numero SUIT le nom de voie (« Rue Galilee 4 »)
_p("ADDRESS", rf"\b(?:{_VOIE})\s+[A-ZÀ-Þ][\wÀ-ÿ'’-]*(?:[ -](?:de|du|des|la|le)"
              rf"|[ -][A-ZÀ-Þ][\wÀ-ÿ'’-]*)*\s+\d{{1,4}}[a-zA-Z]?\b",
   flags=re.IGNORECASE)
# numero double a la francaise : « 28 / 32 Boulevard », « 12-14 rue »
_p("ADDRESS", rf"\b\d{{1,4}}\s?[/-]\s?\d{{1,4}}(?:,)? (?:{_VOIE})\b[^\n,;]{{0,40}}",
   flags=re.IGNORECASE)
# boites postales, France et Suisse
_p("ADDRESS", r"\b(?:CP|BP|Case postale|Bo[îi]te postale)\s?\d{1,5}\b",
   flags=re.IGNORECASE)
# code postal britannique : deux blocs, le second toujours chiffre-lettre-lettre
_p("ADDRESS", r"\b[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}\b")
# etat americain suivi du ZIP : « FL 33180 ». Le ZIP seul serait indistinguable
# d'un nombre quelconque, on exige donc l'etat.
_p("ADDRESS", r"\b(?:AL|AK|AZ|AR|CA|CO|CT|DE|FL|GA|HI|ID|IL|IN|IA|KS|KY|LA|ME|"
              r"MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|OH|OK|OR|PA|RI|SC|"
              r"SD|TN|TX|UT|VT|VA|WA|WV|WI|WY|DC) \d{5}(?:-\d{4})?\b")
# voie anglo-saxonne : numero, direction optionnelle, ordinal, type de voie
_p("ADDRESS", r"\b\d{1,5} (?:[NSEW]{1,2} )?[\w'-]+(?:st|nd|rd|th)? "
              r"(?:Street|St\.?|Avenue|Ave\.?|Road|Rd\.?|Drive|Dr\.?|Lane|Ln\.?|"
              r"Boulevard|Blvd\.?|Way|Court|Ct\.?|Place|Pl\.?)"
              r"(?:,? (?:Suite|Ste\.?|Apt\.?|Unit|Floor|Fl\.?) ?#? ?[\w-]+)?",
   flags=re.IGNORECASE)

# Adresses FR : "33, rue de Labbé", "7 avenue Luce Marchal", "chemin des Prés".
# Le NER rate 40 % de nos adresses (matrice 2026-07-28) alors que la
# structure "n°, type de voie + nom propre" est tres reguliere en francais.
_VOIES = ("rue|avenue|av\\.|boulevard|bd|chemin|impasse|all[ée]e|place|quai|"
          "route|cours|square|passage|sente|villa|hameau|faubourg|lotissement|"
          "r[ée]sidence")
_UPPER = "A-ZÀ-ÖØ-Þ"
_WORD = rf"[{_UPPER}][\w'’-]*"
_PARTICLE = r"(?:de\s+la\s+|de\s+l[’']\s?|du\s+|des\s+|de\s+|d[’']\s?|la\s+|le\s+|les\s+)"
# casse : type de voie insensible (Rue/RUE), nom propre exige une majuscule
# (sinon "rue de la république est calme" avalerait "est" et la suite)
_p("ADDRESS",
   rf"\b(?:\d{{1,4}}(?:-\d{{1,4}})?\s?(?i:bis|ter)?\s*,?\s+)?(?i:{_VOIES})\s+"
   rf"{_PARTICLE}?{_WORD}(?:\s+{_PARTICLE}?{_WORD}){{0,3}}")

# lieux-dits et hameaux (le mot "lieu-dit" porte son contexte)
_p("ADDRESS", rf"(?i:lieu-dit)\s+{_PARTICLE}?{_WORD}(?:\s+{_PARTICLE}?{_WORD}){{0,3}}")

# "N Grande Rue" : voie sans nom propre derriere
_p("ADDRESS", r"\b\d{1,4},? ?(?i:grande rue)\b")

# adresse sans type de voie ("5 Le Gasset", "4 Grande Rue") : uniquement
# derriere un mot d'adresse ("siège social :", "demeurant", "sis", "habite")
_p("ADDRESS", rf"\b\d{{1,4}}(?: ?bis| ?ter)?(?: {_WORD}| {_PARTICLE.strip()}){{1,4}}",
   context=(r"siège social|si[eè]ge\b|demeurant|domicili|adresse|r[eé]sidant|"
            r"\bsis(?:e)?\b|habite|logement|\bbien\b|\bau\b|livr|exp[eé]di"))

# denomination sociale : "Dénomination : STOLKIN." / "raison sociale : X" —
# groupe 1 = la valeur seule (le mot-cle n'est pas masque)
_p("COMPANY",
   r"(?i:(?:dénomination|denomination|raison sociale)(?:\s+sociale)?\s*:\s*)"
   r"([^\n]{2,60}?)(?=\.(?:\s|$)|,|\n|$)")

# marques et raisons sociales (remontees bench_v2 / BODACC) :
_UPWORD = r"[A-ZÀ-ÖØ-Þ][A-ZÀ-ÖØ-Þ0-9&'-]{1,}"
_FORMES = r"(?:S\.A\.S\.U?|S\.A\.R\.L\.|S\.A\.|SARL|SASU|SAS|SA|SCI|EURL|SNC|SELARL)"
# 1. style domaine : HOARAU.FR, TOSCA.COM
_p("COMPANY", r"\b[A-ZÀ-ÖØ-Þ][A-ZÀ-ÖØ-Þ0-9-]{2,}\.(?:FR|COM)\b")
# 2. nom + forme juridique (la forme sert de contexte porte ; (?!\w) et
# pas \b : apres "S.A.S." le point n'offre pas de frontiere de mot)
_p("COMPANY", rf"\b(?:{_UPWORD} |{_WORD} ){{1,4}}{_FORMES}(?!\w)")
# 3. mot(s) capitalises derriere un declencheur ("l'agence X", "chez X")
_p("COMPANY",
   rf"\b(?!(?:SIREN|SIRET|RCS|TVA|IBAN|NIR|BIC|URSSAF|DREETS|CSE)\b)"
   rf"{_UPWORD}(?: {_UPWORD}){{0,3}}",
   context=r"soci[eé]t[eé]|agence|entreprise|[eé]tablissements?|maison|cabinet|\bchez\b|\bst[eé]\b")
# 4. apposition d'annonce legale : "X, société par actions simplifiée..."
_p("COMPANY",
   rf"\b({_WORD}(?: {_WORD}){{0,3}}|{_UPWORD}(?: {_UPWORD}){{0,3}})"
   rf"(?=, soci[eé]t[eé] (?:par|à|a|anonyme|civile|en))")

# code postal FR suivi d'une ville (signatures multi-sites, audit reel)
_p("ADDRESS", rf"\b(?:0[1-9]|[1-9]\d)\d{{3}}[ ]{_WORD}(?:[- ]{_WORD}){{0,2}}")
# code postal isole en fin de ligne (signature multi-sites)
_p("ADDRESS", r"\b(?:0[1-9]|[1-9]\d)\d{3}(?=\s*(?:$|\n|[|/,-]))",
   context=(r"adresse|si[eè]ge|bureaux?|agence|site|locaux|cedex|\bCS\b|\bBP\b|"
            r"rue|avenue|boulevard|chemin|place|route|\|"))

# --- types techniques (audit ai4privacy 2026-07-29) : presents dans les
# logs, exports et emails techniques francais aussi. Regex-ables, sans
# ambiguite metier.

# mot de passe / secret annonce en clair ("mot de passe : xxx", "pwd=xxx")
_p("SECRET",
   r"(?i:(?:mot de passe|passe|password|pwd|pass|secret|token|api[_ -]?key|"
   r"cl[eé] api|client[_ -]?secret|passphrase)\s*(?:est|:|=)\s*)"
   r"[\"']?([^\s\"'<>,;]{6,80})")

# user-agent (navigateur/robot) : signature tres reconnaissable
_p("USERAGENT", r"Mozilla/\d[^\n]{10,200}")
_p("USERAGENT", r"\b(?:curl|Wget|PostmanRuntime|python-requests|okhttp|axios)/[\d.]+")

# adresses techniques
_p("MAC", r"\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\b")
_p("IPV6", r"\b(?:[0-9A-Fa-f]{1,4}:){2,7}[0-9A-Fa-f]{1,4}\b")

# identifiants opaques : cles et jetons longs (base64/hex) annonces ou nus
_p("SECRET", r"\b(?:sk|pk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b")
_p("SECRET", r"\bgh[pousr]_[A-Za-z0-9]{30,}\b")
_p("SECRET", r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b")
_p("SECRET", r"\b[0-9a-f]{32,64}\b",
   context=r"cl[eé]|key|token|secret|hash|signature|empreinte|md5|sha")

# age en contexte RH/dossier ("45 ans", "age : 45")
_p("AGE", r"\b\d{1,3} ans\b",
   context=r"[aâ]g[eé]|ann[eé]es|naissance|salari|candidat|patient|enfant|\best\b|\ba\b")
_p("AGE", r"(?i:[aâ]ge\s*(?::|est de)\s*)(\d{1,3})\b")

# IBAN etranger sans checksum FR mais format IBAN valide (deja couvert),
# et numero de compte annonce ("compte n° 12345678")
_p("ACCOUNT", r"(?i:(?:compte|account)\s*(?:bancaire\s*)?(?:n°|no|num[eé]ro|#|:)\s*)([0-9]{6,17})")

# --- sans checksum : contexte requis -------------------------------------
_p("PHONE", r"\b0[1-9]\d{8}\b",
   context=r"t[eé]l|portable|mobile|fixe|appel|joign|rappel|contact|num[eé]ro|\bau\b")
# identifiants internes rattaches a une personne (audit 2026-07-29 :
# matricule, n° de police, contrat, reference client = PII RGPD)
_p("REF", r"\b\d{4,8}\b",
   context=(r"matricule|police|contrat|dossier|r[eé]f[eé]rence|r[eé]f\.|"
            r"abonn|adh[eé]rent|client|sinistre|avenant"))

_p("RG", r"\b\d{2}/\d{5}\b",
   context=(r"\bRG\b|r[oô]le|r[eé]pertoire|dossier|tribunal|jugement|"
            r"instance|enr[oô]l|audience|greffe|affaire|contentieux"))
_p("PLATE", r"\b\d{3} [A-Z]{3} \d{2}\b", context=r"immatricul|v[eé]hicule|plaque")


def _ip_valid(s: str) -> bool:
    return all(int(o) <= 255 for o in s.split("."))


_TO_DIGIT = str.maketrans("OolISsBb", "00115588")
_TO_LETTER = str.maketrans("0158", "olsb")
_TOKEN_RE = re.compile(r"[A-Za-z0-9]+")


def ocr_normalize(text: str) -> str:
    """Corrige les confusions OCR token par token, longueur conservee.

    Token a dominante chiffres -> lettres confusables vers chiffres (O->0...).
    Token a dominante lettres -> chiffres confusables vers lettres (0->o...).
    Le checksum/pattern reste le juge en aval : on ne decide rien ici.
    """
    out = list(text)
    for m in _TOKEN_RE.finditer(text):
        tok = m.group(0)
        if len(tok) < 2:
            continue
        digits = sum(c.isdigit() for c in tok)
        fixed = tok.translate(_TO_DIGIT) if digits * 2 >= len(tok) else tok.translate(_TO_LETTER)
        if fixed != tok:
            out[m.start():m.end()] = fixed
    return "".join(out)


def _scan(text: str, original: str) -> list[dict]:
    candidates = []
    for etype, pattern, context in _PATTERNS:
        for m in pattern.finditer(text):
            # si le pattern a un groupe de capture, le span est le groupe 1
            # (permet un mot-cle declencheur hors masque, ex. "Dénomination :")
            grp = 1 if m.groups() else 0
            value = m.group(grp)
            if not value:
                continue
            if etype in _VALIDATORS and not _VALIDATORS[etype](value):
                continue
            if etype == "IP" and not _ip_valid(value):
                continue
            if context is not None:
                before = text[max(0, m.start() - _CONTEXT_WINDOW):m.start()]
                if not re.search(context, before, re.IGNORECASE):
                    continue
            candidates.append(
                {"start": m.start(grp), "end": m.end(grp), "type": etype,
                 "value": original[m.start(grp):m.end(grp)]}
            )
    return candidates


def detect(text: str) -> list[dict]:
    # variantes a longueur constante (offsets communs) : correction OCR, et
    # sauts de ligne aplatis — une valeur coupee par un \n (PDF, courrier)
    # doit etre detectee ("MEYER\nTRANSPORTS", "26\nnovembre 2025")
    variants = [text]
    for base in (text, ocr_normalize(text)):
        for v in (base, base.replace("\n", " ")):
            if v not in variants:
                variants.append(v)

    candidates = _scan(text, text)
    seen = {(c["start"], c["end"], c["type"]) for c in candidates}
    for v in variants[1:]:
        flattened = "\n" in text and "\n" not in v
        for c in _scan(v, text):
            # la passe "sauts de ligne aplatis" ne sert qu'aux valeurs
            # coupees par un \n dans un PDF (identifiants, dates, montants).
            # Sur les types a mots (ADDRESS, COMPANY, CITY) elle recollait
            # deux lignes distinctes ("75011 Paris" + "Tél") — audit reel.
            if flattened and c["type"] in ("ADDRESS", "COMPANY", "CITY", "URL",
                                           "REF", "USERAGENT", "SECRET", "AGE"):
                continue
            if (c["start"], c["end"], c["type"]) not in seen:
                seen.add((c["start"], c["end"], c["type"]))
                candidates.append(c)

    # le span le plus long gagne ; a longueur egale, premier arrive (ordre
    # de declaration = priorite : checksum avant format avant contexte)
    candidates.sort(key=lambda c: (-(c["end"] - c["start"]), c["start"]))
    kept: list[dict] = []
    occupied: set[int] = set()
    for c in candidates:
        span = set(range(c["start"], c["end"]))
        if span & occupied:
            continue
        kept.append(c)
        occupied |= span
    kept.sort(key=lambda c: c["start"])
    return kept