@piecemaker-legal/piecemaker 1.0.6

package/server/piecemaker/vendor/websocket-server/scripts/mineru_improved_1.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+MinerU PDF Parser - Direct PDF Processing
+Supports both pipeline (direct PDF) and VLM/hybrid (image-based) modes
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+def parse_with_pipeline(pdf_path, output_dir, lang=None):
+    """
+    Parse PDF using pipeline backend (direct PDF processing, no image conversion needed)
+    
+    Args:
+        pdf_path: Path to PDF file
+        output_dir: Output directory
+        lang: OCR language (None for default, 'ch' for Chinese, 'en' for English, etc.)
+    """
+    print(f"📄 Parsing with PIPELINE backend (direct PDF processing)")
+    print(f"   Input: {pdf_path}")
+    if lang:
+        print(f"   Language: {lang}")
+    print(f"\n{'='*60}")
+    print("Processing... (this may take several minutes for scanned PDFs)")
+    print(f"{'='*60}\n")
+    
+    # Build mineru command
+    cmd = [
+        'mineru',
+        '-p', str(pdf_path),
+        '-o', str(output_dir),
+        '-b', 'pipeline'
+    ]
+    
+    # Add language parameter if specified
+    if lang:
+        cmd.extend(['--lang', lang])
+    
+    # Execute mineru command with real-time output
+    try:
+        # Don't capture output - let it stream to console so user sees progress
+        result = subprocess.run(cmd, check=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"\n❌ Error running mineru: {e}")
+        return False
+    except KeyboardInterrupt:
+        print(f"\n\n⚠️  Interrupted by user (Ctrl+C)")
+        print("Processing was stopped before completion.")
+        return False
+
+
+def parse_with_vlm(pdf_path, output_dir, backend='hybrid-auto-engine'):
+    """
+    Parse PDF using VLM/hybrid backend (MinerU2.5 model, higher accuracy)
+    
+    Args:
+        pdf_path: Path to PDF file
+        output_dir: Output directory  
+        backend: 'vlm-auto-engine' or 'hybrid-auto-engine' (hybrid combines pipeline + vlm for best results)
+    """
+    backend_display = backend.replace('-auto-engine', '').upper()
+    print(f"🤖 Parsing with {backend_display} backend (MinerU2.5 model)")
+    print(f"   Input: {pdf_path}")
+    print(f"   Backend: {backend}")
+    print(f"\n{'='*60}")
+    print("Processing... (this may take several minutes)")
+    print(f"{'='*60}\n")
+    
+    # Build mineru command
+    cmd = [
+        'mineru',
+        '-p', str(pdf_path),
+        '-o', str(output_dir),
+        '-b', backend
+    ]
+    
+    # Execute mineru command with real-time output
+    try:
+        # Don't capture output - let it stream to console so user sees progress
+        result = subprocess.run(cmd, check=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"\n❌ Error running mineru: {e}")
+        return False
+    except KeyboardInterrupt:
+        print(f"\n\n⚠️  Interrupted by user (Ctrl+C)")
+        print("Processing was stopped before completion.")
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Parse PDF with MinerU (pipeline, vlm, or hybrid mode)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Default: Pipeline mode (fast, direct PDF processing, auto-detects language)
+  python mineru_improved.py document.pdf
+  
+  # Pipeline mode with specific language
+  python mineru_improved.py document.pdf --lang en
+  python mineru_improved.py document.pdf --lang ch
+  
+  # VLM mode with MinerU2.5 model (higher accuracy)
+  python mineru_improved.py document.pdf --mode vlm
+  
+  # Hybrid mode (best of both: pipeline + vlm) - RECOMMENDED
+  python mineru_improved.py document.pdf --mode hybrid
+  
+  # Hybrid with specific language for OCR
+  python mineru_improved.py document.pdf --mode hybrid --lang ch
+  
+  # Custom output directory
+  python mineru_improved.py document.pdf -o ./my_output
+
+Valid Languages:
+  ch          - Chinese (default for most documents)
+  ch_server   - Chinese with better handwriting support (PPOCRv5)
+  ch_lite     - Chinese lightweight model
+  en          - English
+  korean      - Korean
+  japan       - Japanese
+  chinese_cht - Traditional Chinese
+  ta          - Tamil
+  te          - Telugu
+  ka          - Kannada
+  th          - Thai
+  el          - Greek
+  latin       - Latin-based languages (Portuguese, Spanish, French, etc.)
+  arabic      - Arabic
+  east_slavic - East Slavic languages
+  cyrillic    - Cyrillic script languages
+  devanagari  - Devanagari script languages
+        """
+    )
+    
+    parser.add_argument('pdf_file', help='PDF file to process')
+    
+    parser.add_argument(
+        '-o', '--output',
+        default='./mineru_output',
+        help='Output directory (default: ./mineru_output)'
+    )
+    
+    parser.add_argument(
+        '--mode',
+        choices=['pipeline', 'vlm', 'hybrid'],
+        default='pipeline',
+        help='Parsing mode: pipeline (fast), vlm (high accuracy), or hybrid (best, default for VLM)'
+    )
+    
+    parser.add_argument(
+        '--lang',
+        choices=['ch', 'ch_server', 'ch_lite', 'en', 'korean', 'japan', 'chinese_cht', 
+                 'ta', 'te', 'ka', 'th', 'el', 'latin', 'arabic', 'east_slavic', 
+                 'cyrillic', 'devanagari'],
+        default=None,
+        help='OCR language (optional, default: auto-detect). Only for pipeline/hybrid modes.'
+    )
+    
+    args = parser.parse_args()
+    
+    pdf_path = Path(args.pdf_file)
+    if not pdf_path.exists():
+        print(f"❌ Error: File not found: {pdf_path}")
+        return 1
+    
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    print(f"\n{'='*60}")
+    print(f"MinerU PDF Parser")
+    print(f"{'='*60}\n")
+    
+    # Map user-friendly mode names to actual backend names
+    backend_map = {
+        'pipeline': 'pipeline',
+        'vlm': 'vlm-auto-engine',
+        'hybrid': 'hybrid-auto-engine'
+    }
+    
+    success = False
+    if args.mode == 'pipeline':
+        success = parse_with_pipeline(pdf_path, output_dir, args.lang)
+    else:
+        if args.lang:
+            print(f"⚠️  Note: --lang parameter only applies to pipeline mode (hybrid uses it automatically)")
+        backend = backend_map[args.mode]
+        success = parse_with_vlm(pdf_path, output_dir, backend=backend)
+    
+    print(f"\n{'='*60}")
+    if success:
+        print("✅ Processing complete!")
+        print(f"Output saved to: {output_dir}")
+    else:
+        print("❌ Processing failed!")
+        return 1
+    print(f"{'='*60}\n")
+    
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/AUDIT_PERF_QUALITE.md

@@ -0,0 +1,246 @@
+# PieceMaker — plan v3 (archive historique)
+
+> **Statut — archive, non-feuille de route active.** Ce plan est conservé comme trace de l'analyse
+> publiée dans le commit `fb4bca1` du **6 août 2026**. Il fige les mesures, hypothèses et travaux
+> « à faire » tels qu'ils étaient alors envisagés ; il ne décrit pas l'état courant du code et ne
+> constitue pas un compte rendu d'exécution ultérieure. Ne pas interpréter ses chiffres ou ses
+> étapes comme des résultats actuels sans consulter les documents de vérification ci-dessous.
+>
+> État et résultats disponibles depuis ce plan :
+> - [`eval/CRITERES_QUALITE.md`](eval/CRITERES_QUALITE.md) vérifie les étapes 1 à 3 et documente
+>   la correction de la fuite liée aux tirets Unicode ;
+> - [`eval/BACKENDS_MESURES.md`](eval/BACKENDS_MESURES.md) rassemble les mesures comparatives des
+>   backends ;
+> - les scripts [`eval/verify_substitution.cjs`](eval/verify_substitution.cjs),
+>   [`eval/verify_whitespace.py`](eval/verify_whitespace.py), [`eval/evaluate.py`](eval/evaluate.py)
+>   et [`eval/bench_backend.py`](eval/bench_backend.py) indiquent les vérifications
+>   effectivement rejouables. Leurs JSON de sortie sont régénérables localement et ne sont
+>   volontairement pas conservés dans le dépôt.
+>
+> Les sections historiques ci-dessous sont volontairement laissées inchangées : leurs mentions
+> « à faire », estimations et résultats partiels ne donnent pas le statut courant et ne prouvent
+> pas des travaux réalisés aujourd'hui.
+
+> Remplace la v2. Contient **deux corrections de mes propres conclusions** et un renversement de
+> l'objectif qualité, provoqué par la lecture du code de substitution que je n'avais pas encore lu.
+
+---
+
+## 0. État du run et chiffres, tous mesurés
+
+Le run end-to-end a été **interrompu à 592/972 chunks (61 %)**, encore en phase d'extraction — il n'a
+jamais atteint la phase de classification. Ce qu'il a donné avant de s'arrêter :
+
+| | valeur | base de mesure |
+|---|---|---|
+| Démarrage (modèle + 2 analyseurs spaCy) | **64 s** | mesuré |
+| Extraction | **1,22 s/chunk** | **n = 592 chunks**, 61 % du document |
+| → extraction document complet | **19,7 min** | 1,22 × 972 |
+| RSS du worker | 869 Mo | mesuré |
+| `classify_text` sur contextes réels | **2 890 ms/appel** | n = 25, tirés au sort dans les **1 689 occurrences réelles** |
+| → phase classification | **81,3 min** | 2,89 × 1 689 |
+| spaCy (pipeline complet, jeté) | ~1,5 min | mesuré |
+| **Total attendu** | **≈ 102 min** | |
+
+Ce n'est toujours pas un chrono end-to-end complet. Les deux phases sont maintenant mesurées sur des
+échantillons larges et réels, mais la somme reste une somme. **Dis-moi si tu veux que je relance le
+run complet** — il sature ton M1 pendant ~1 h 40, je ne le relance pas sans ton feu vert.
+
+---
+
+## 1. ⚠️ Correction n° 1 — j'avais tort sur `classify_text`
+
+En v2 j'ai écrit : « 12 runs, 0 type `ORGANIZATION_*` produit → l'étape ne produit rien ».
+Le fait était exact, **l'inférence était fausse**. Mesuré sur 25 contextes réels avec le schéma à
+221 labels verbatim de `scanner_worker.py` : `classify_text` renvoie une forme ≠ `other`
+**25 fois sur 25**. L'absence de `ORGANIZATION_*` dans les 12 sorties vient donc de ces runs-là
+(fichier à 30 labels / version antérieure), pas d'un échec de la fonction.
+
+**Mais ce que la mesure montre est pire.** Voici ce que la fonction produit sur un URD biotech
+franco-américain :
+
+```
+SA 11/25  ·  AG 2  ·  AS 2  ·  No Liability 1  ·  Osakeyhtiö 1  ·  Ltd 1
+EIRELI 1  ·  Srl 1  ·  Aktiengesellschaft 1  ·  GP 1  ·  ANS 1  ·  Inc 1  ·  CC 1
+```
+
+`Osakeyhtiö` (finlandais), `EIRELI` (brésilien), `No Liability` (australien), `ANS` (norvégien),
+`CC` (Close Corporation sud-africaine) — pour des sociétés comme AlphaBio, Novartis, Investis.
+44 % de « SA » par défaut. Ce ne sont pas des abstentions, ce sont des **réponses fausses et
+confiantes, à 2,9 s pièce**.
+
+L'argument de suppression est donc plus fort qu'en v2, mais pour une autre raison : l'étape ne coûte
+pas 81 min pour rien, elle coûte 81 min pour **injecter des codes faux** (`SOCIETE_OSAKEYHTIÖ_04`)
+dans le document anonymisé.
+
+---
+
+## 2. 🔴 Correction n° 2 — j'avais tort sur l'objectif qualité
+
+En v2 j'ai proposé « maximiser le rappel sous plancher de précision, car un faux positif n'est qu'un
+mot caviardé pour rien ». **C'est faux**, et je l'ai écrit avant d'avoir lu le code de substitution.
+
+`websocket-server/lib/anonymization-server.cjs:394` :
+
+```js
+const regex = new RegExp(escapeRegex(original), 'gi');
+result = result.replace(regex, code);
+```
+
+Substitution **globale**, **insensible à la casse**, et **sans limite de mot**. Trois conséquences,
+toutes vérifiées sur le document réel :
+
+### 2.1 Ta seconde intuition est juste — et déjà implémentée
+
+Détecter une entité **une seule fois suffit** : le `replace` global remplace ensuite toutes ses
+occurrences. J'ai mesuré que 74,6 % des occurrences d'entités déjà connues ne sont jamais re-détectées
+par GLiNER — j'ai failli te l'annoncer comme une fuite. **Ce n'en est pas une**, précisément à cause
+de ce `replace` global. Vérifié avant de te l'écrire.
+
+### 2.2 En revanche chaque faux positif est amplifié à l'échelle du document
+
+Blast radius mesuré, entité par entité, sur le ALPHABIO :
+
+| entité détectée | substitutions déclenchées | dont **à l'intérieur d'un autre mot** |
+|---|---|---|
+| `CA` | **4 725** | 4 724 — `capital`, `case`, `cash`, `indicators`, `carbon` |
+| `us` / `US` | 2 099 ×2 | 1 918 — `business`, `used`, `adjustments` |
+| `AU` | 1 030 | 1 028 — `Faubourg`, `authority`, `Audit`, `auditors` |
+| `EU` | 726 | 644 — `European` |
+| `RU` | 702 | 701 — `rue`, `structure`, `rules`, `instruments` |
+| `ZA` | 477 | 476 — `organization`, `commercialization`, `authorization` |
+| `IND` | 454 | 432 — `indicators`, `indirect`, `kind` |
+| `RP` | 441 | 343 — `Corporation`, `purpose`, `corporate` |
+| `Company` | 895 | — (vrai mot, mais générique) |
+
+**Total : 600 entités → 28 956 substitutions sur un document de 194 391 mots.**
+Soit environ **un mot sur sept réécrit**. Le document anonymisé n'est pas « sur-caviardé », il est
+**détruit** — et de façon irréversible, puisque `reverse_mapping` ne peut pas reconstituer `capital`
+à partir de `ADRESSE_07pital`.
+
+### 2.3 Donc l'objectif s'inverse
+
+Ce n'est pas « rappel maximal sous plancher de précision ». Avec cette substitution, **la précision
+est le terme dominant** : une entité fausse coûte toutes ses occurrences, et une entité fausse et
+courte corrompt le texte. Le rappel *par occurrence*, lui, est presque gratuit grâce au `replace`
+global — il suffit d'un seul repérage.
+
+**Objectif corrigé** : *maximiser le rappel sur les entités **distinctes**, sous contrainte de
+précision élevée, avec une pénalité spécifique aux entités courtes et fréquentes.*
+Et surtout : **corriger la substitution avant de toucher au modèle** — c'est là que se joue le ratio.
+
+---
+
+## 3. Tes deux propositions
+
+### ✅ « Les `\n` doivent être supprimés des .md (ou ne pas être produits) » — oui, et c'est plus grave que je ne l'avais dit
+
+Je peux maintenant le prouver par le code. La substitution utilise `escapeRegex(original)` : une
+entité contenant `\n`, un double espace ou un NBSP produit une regex qui n'accepte **que cette
+séquence exacte de blancs**. Ces entités-là ne sont donc **jamais substituées nulle part** :
+
+```
+ORGANIZATION : 217 entités contiennent un \n   ·  18 un NBSP
+PERSON       :  41                              ·  21
+LOCATION     :  19                              ·   6
+```
+
+**277 entités = fuite de PII réelle**, pas théorique. C'est le seul vrai cas de fuite que j'aie trouvé.
+
+Sur le **où** corriger : à la conversion, comme tu le dis — c'est le seul endroit où les offsets du
+`sensitive_map` restent cohérents avec le fichier que tout le monde lit ensuite. Mais pas un
+`replace(/\n/g,' ')` brutal : il faut **préserver les sauts de paragraphe (`\n\n`), les listes et les
+tableaux**, et ne réduire que les retours à la ligne *intra-paragraphe* (retours de justification PDF),
+les espaces multiples et les NBSP. Règle à appliquer dans `smart_converter.py` en post-traitement de
+markitdown, avant écriture du `.md`.
+
+### ⚠️ « Quand une entité est repérée, supprimer les occurrences suivantes pour éviter à GLiNER de recommencer » — juste sur la bonne phase, sans effet sur l'autre
+
+- **Phase d'extraction : aucun gain.** Le coût est **par chunk**, pas par entité — 1,22 s que le chunk
+  contienne 0 ou 20 entités. GLiNER fait une passe d'encodeur sur le chunk entier quoi qu'il arrive ;
+  on ne peut pas lui dire « ignore Dupont ». Et supprimer le texte décalerait tous les offsets, en plus
+  d'exiger de savoir que c'est de la PII *avant* de l'avoir cherchée.
+- **Phase de classification : exactement ça, et c'est le gros morceau.** Celle-là est bien
+  *par occurrence* : **1 689 appels pour 576 noms distincts**. Mémoïser par nom normalisé, c'est
+  **−66 %** sur les 81 min. Ton intuition tombe juste sur la seule phase où elle s'applique.
+- **Et un troisième usage, meilleur** : une fois l'ensemble des noms distincts connu, une passe
+  « gazetteer » (recherche de chaîne de chaque nom connu sur tout le document) rattrape gratuitement
+  ce que GLiNER a manqué. C'est précisément ce que fait déjà le `replace` global — d'où le §2.1.
+
+---
+
+## 4. Plan révisé, par ordre de priorité
+
+### Étape 1 — Réparer la substitution 🔴 *avant tout le reste*
+`anonymization-server.cjs:377-404`. Rien ne sert de régler le modèle tant qu'une détection correcte
+produit un document détruit.
+1. **Limites de mot** : `new RegExp("(?<!\\w)"+escapeRegex(original)+"(?!\\w)", "g")`.
+   → supprime à elle seule ~11 000 des 28 956 substitutions, toutes fausses.
+2. **Supprimer le flag `i`** (ou ne le garder que pour la première lettre). `us` ≠ `US`.
+3. **Longueur minimale** : refuser toute entité < 4 caractères hors liste blanche explicite.
+   → neutralise `CA`, `us`, `AU`, `EU`, `RU`, `ZA`, `HK`, `MX`, `JP`, `KR`, `CN`.
+4. **Ordonner les substitutions par longueur décroissante** et remplacer par jeton non re-substituable,
+   pour que `French` ne mange pas `French Monetary and Financial Code`.
+- **Critère d'acceptation** : sur le ALPHABIO, 0 substitution à l'intérieur d'un mot. Vérifiable exactement.
+
+### Étape 2 — Normalisation des blancs à la conversion 🔴
+Règle décrite en §3. Cible : **0 entité contenant `\n` ou double espace** dans le `sensitive_map`,
+et les 1 273 « distincts » qui retombent à 971 (−24 % de faux distincts, cf. v2).
+
+### Étape 3 — Arbitrage de spans 🔴
+Supprimer tout span chevauchant ou inclus **quel que soit le type** (presidio ne le fait qu'à type
+égal). → corrige les 81 double-typages et 179 chevauchements. Départage : longueur, puis score,
+puis priorité PERSON > ORG > LOC — à valider sur corpus.
+
+### Étape 4 — Corpus de référence annoté ⭐
+Inchangé depuis la v2, et toujours le prérequis de toute décision « qualité » :
+3 documents du Dossier AVION + un extrait ALPHABIO, outil d'annotation HTML local, ~1 h de ton temps.
+Métrique révisée par le §2.3 : **rappel sur entités distinctes / précision, avec pénalité sur les
+entités courtes et fréquentes**.
+
+### Étape 5 — Faux positifs des pattern recognizers
+`IpRecognizer` : 31/31 FP (numéros de section `3.7.2.2`). `UrlRecognizer` : `2023.Th`, `occur.Th`.
+Vérifiable exactement, sans annotation.
+
+### Étape 6 — Calibration du seuil, par type
+Rappel : le seuil actuel de **0.3 ne filtre rien** (score minimum observé 0.401). Balayage
+0.30→0.90 sur le corpus. Tester aussi `0.1` : s'il apparaît des entités sous 0.4, il y a du rappel
+gratuit ; sinon c'est un plancher interne du modèle. Mesure, pas hypothèse.
+
+### Étape 7 — Supprimer `classify_text`
+Regex de forme juridique sur le nom normalisé ; absence de forme → `ORGANIZATION`.
+Gain : **81 min**, et surtout suppression des `Osakeyhtiö`/`EIRELI` du §1.
+Couverture mesurée **sur ce document** : 11 % des noms portent une forme littérale (63/576).
+**À re-mesurer sur le Dossier AVION** (Kbis « URGOT SA », « CAITLYN SA ») où elle sera bien plus haute.
+
+### Étape 8 — Choix du checkpoint (A/B sur corpus)
+`gliner2-privacy-filter-PII-multi` — même backbone, donc **même vitesse**, spécialisé PII.
+Décision sur les chiffres du corpus uniquement.
+
+### Étape 9 — Vitesse, chaque levier conditionné à un score corpus inchangé ou meilleur
+| levier | gain mesuré | risque qualité |
+|---|---|---|
+| spaCy en tokenizer seul | −1,5 min, −1 Go RSS | nul (le NER spaCy est déjà jeté) |
+| `torch.set_num_threads(6)` | −18 % sur l'extraction | nul |
+| mémoïsation classification par nom distinct | −66 % *(sans objet si étape 7 faite)* | nul |
+| recouvrement 50 → ~15 mots | −15 à −20 % de chunks | à mesurer sur corpus |
+| taille de chunk | — | ⚠️ ne pas augmenter : p90 = 485 tokens / 512, 1 % des chunks débordent déjà |
+| MPS · int8 | ⛔ écartés, mesurés | MPS 29,6 vs 23,0 min ; int8 indisponible (`NoQEngine`) |
+
+### Étape 10 — Fuite PII dans les logs
+`scanner_worker.py:495` — chaque entité en clair sur stderr, capturé par Electron.
+Flag `PIECEMAKER_DEBUG_ENTITIES`, off par défaut.
+
+---
+
+## 5. Bilan
+
+**Qualité** — l'essentiel du ratio ne se joue pas dans GLiNER : il se joue dans la substitution
+(28 956 remplacements dont ~11 000 à l'intérieur de mots), la normalisation des blancs (277 entités
+jamais substituées = la seule vraie fuite trouvée), et l'arbitrage de spans. Ces trois corrections
+coûtent **zéro milliseconde d'inférence**.
+
+**Vitesse** — ~102 min → ~20 min, dont 81 min gagnées en supprimant une étape qui produit des
+réponses fausses.
+
+**Ce qui reste inconnu** — précision et rappel réels. Étape 4.

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/MODELE_COREML.md

@@ -0,0 +1,62 @@
+# Encodeur CoreML — génération et déploiement
+
+`coreml_runtime.py` fait tourner l'encodeur mdeberta sur le GPU du Mac : **2,1× sur le document
+complet, sortie identique** (mesures et méthode dans `eval/BACKENDS_MESURES.md`). Si le modèle
+compilé est absent, le worker retombe sur torch sans erreur — cette étape est donc **optionnelle**,
+elle n'achète que la vitesse.
+
+## Générer le modèle (~4 min, une fois)
+
+```bash
+cd eval
+PIECEMAKER_COREML_SEQ=832 python3 coreml_encoder.py convert     # ~2 min -> .mlpackage
+python3 - <<'PY'
+import shutil, coremltools as ct
+m = ct.models.MLModel('artifacts/encoder_b1_832.mlpackage',
+                      compute_units=ct.ComputeUnit.CPU_AND_GPU)   # ~2 min de compilation
+shutil.copytree(m.get_compiled_model_path(), 'artifacts/encoder_b1_832.mlmodelc')
+PY
+mkdir -p ../models && cp -R artifacts/encoder_b1_832.mlmodelc ../models/
+```
+
+Prérequis : `pip install coremltools` (n'a rétrogradé aucune dépendance sur cette machine).
+
+## Pourquoi un `.mlmodelc` et pas le `.mlpackage`
+
+Charger le `.mlpackage` **recompile à chaque démarrage** : 97 s, mesuré deux fois de suite, parce
+que chaque chargement compile dans un répertoire temporaire que le cache système ne reconnaît pas.
+Un `.mlmodelc` persisté touche ce cache : **97 s au tout premier chargement, puis ~6 s**. C'est la
+différence entre inutilisable et livrable.
+
+## Pourquoi 832 tokens
+
+Le padding se fait sur la séquence la plus longue du lot. Longueurs réelles mesurées :
+
+| document | longueurs des lots |
+|---|---|
+| `Assignation_URGOT_vs_CAITLYN` | 741 · 781 · 811 |
+| `Conclusions_Assignation_URGOT` | 770 · 811 |
+
+À 772 (première tentative), 2 lots sur 3 de l'Assignation retombaient sur torch et le gain tombait
+à 1,13×. À 832 : **0 repli en français**, 11 lots sur 122 sur le ALPHABIO anglais.
+
+## Pourquoi le GPU et pas le Neural Engine
+
+`CPU_AND_NE` a été mesuré **3,3× plus lent que le CPU** sur ce modèle (3,60 s contre 1,10 s).
+L'attention désenchevêtrée de deberta-v3 est le motif que l'ANE traite le plus mal. `CPU_AND_GPU`
+est un choix mesuré.
+
+## Désactiver
+
+```bash
+PIECEMAKER_COREML=0            # repli torch explicite
+PIECEMAKER_COREML_MODEL=/chemin/vers/encoder_b1_<seq>.mlmodelc
+```
+
+La longueur de séquence est lue dans le nom du fichier (`encoder_b1_832.mlmodelc` → 832).
+
+## Déploiement
+
+Le `.mlmodelc` fait 620 Mo et n'est **pas** versionné (`.gitignore`). Deux options :
+soit l'empaqueter avec l'app, soit le générer à la première exécution. Tant qu'il est absent, le
+worker tourne en torch — correct, seulement plus lent.

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/build_coreml.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Génère une fois l'encodeur CoreML, pour que les scans GLiNER tournent sur le GPU.
+
+Le runtime (`coreml_runtime.py`) accélère l'encodeur mdeberta sur le GPU du Mac
+et libère surtout les cœurs CPU pour que la machine reste utilisable pendant un
+scan. Les mesures historiques sont documentées dans `eval/BACKENDS_MESURES.md` ;
+GLiNER2.5 reçoit son propre artefact compilé à partir de ses poids exacts.
+
+Ce script est **best-effort et idempotent** :
+  - il ne refait rien si le `.mlmodelc` est déjà là ;
+  - il sort 0 quoi qu'il arrive (dépendance manquante, conversion refusée…), car
+    le runtime retombe seul sur torch — un scan ne doit jamais échouer à cause
+    d'une optimisation.
+
+Il réutilise `Wrap` et `_patch_deberta_scale` de `eval/coreml_encoder.py` pour ne
+pas dupliquer les correctifs de traçage deberta, mais synthétise ses propres
+entrées (la conversion ne dépend que de leur forme, pas de leurs valeurs).
+
+    python3 build_coreml.py            # génère l'encodeur GLiNER2.5 dans models/
+    PIECEMAKER_COREML_SEQ=832          # longueur de séquence (défaut 832)
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SEQ = int(os.environ.get("PIECEMAKER_COREML_SEQ", "832"))
+MODELS_DIR = os.path.join(HERE, "models")
+
+from model_config import PREFERRED_GLINER_MODEL  # noqa: E402
+from coreml_runtime import default_model_path  # noqa: E402
+
+GLINER_MODEL = PREFERRED_GLINER_MODEL
+TARGET = default_model_path(GLINER_MODEL, SEQ)
+
+
+def _log(msg):
+    print(msg, flush=True)
+
+
+def main():
+    if os.path.exists(TARGET):
+        _log(f"Encodeur CoreML déjà présent : {TARGET}")
+        return 0
+
+    try:
+        import numpy as np
+        import torch
+        import coremltools as ct
+        from gliner2 import AutoExtractor
+    except Exception as exc:  # noqa: BLE001
+        _log(f"CoreML non généré (dépendance manquante : {type(exc).__name__}: {exc}) — les scans resteront sur CPU torch")
+        return 0
+
+    # Correctifs de traçage deberta partagés avec l'outil d'évaluation.
+    sys.path.insert(0, os.path.join(HERE, "eval"))
+    try:
+        from coreml_encoder import Wrap, _patch_deberta_scale
+    except Exception as exc:  # noqa: BLE001
+        _log(f"CoreML non généré (helpers de conversion introuvables : {exc}) — CPU torch")
+        return 0
+
+    try:
+        torch.set_grad_enabled(False)
+        _patch_deberta_scale()
+
+        # Entrées factices de la bonne forme : seule la forme (1 x SEQ) est gravée
+        # dans le modèle converti, pas les valeurs.
+        ids = torch.zeros((1, SEQ), dtype=torch.long)
+        mask = torch.ones((1, SEQ), dtype=torch.long)
+
+        _log(f"Chargement de {GLINER_MODEL}...")
+        model = AutoExtractor.from_pretrained(
+            GLINER_MODEL,
+            local_files_only=True,
+        ).eval()
+        wrap = Wrap(model.encoder).eval()
+        del model
+
+        _log("Traçage du modèle...")
+        traced = torch.jit.trace(wrap, (ids, mask), strict=False)
+
+        _log("Conversion en MLProgram (fp16)...")
+        mlmodel = ct.convert(
+            traced,
+            inputs=[ct.TensorType(name="input_ids", shape=ids.shape, dtype=np.int32),
+                    ct.TensorType(name="attention_mask", shape=mask.shape, dtype=np.int32)],
+            outputs=[ct.TensorType(name="last_hidden_state")],
+            convert_to="mlprogram",
+            compute_precision=ct.precision.FLOAT16,
+            minimum_deployment_target=ct.target.macOS14,
+        )
+
+        with tempfile.TemporaryDirectory() as tmp:
+            pkg = os.path.join(tmp, f"encoder_b1_{SEQ}.mlpackage")
+            mlmodel.save(pkg)
+
+            # Le .mlmodelc persisté touche le cache système : ~6 s au chargement
+            # ensuite, contre ~97 s si l'on rechargeait le .mlpackage à chaque fois
+            # (cf. MODELE_COREML.md). On garde une référence vivante le temps de la
+            # copie, sinon le répertoire compilé temporaire peut disparaître.
+            _log("Compilation en .mlmodelc (peut prendre ~2 min)...")
+            compiled_model = ct.models.MLModel(pkg, compute_units=ct.ComputeUnit.CPU_AND_GPU)
+            os.makedirs(MODELS_DIR, exist_ok=True)
+            if os.path.exists(TARGET):
+                shutil.rmtree(TARGET, ignore_errors=True)
+            shutil.copytree(compiled_model.get_compiled_model_path(), TARGET)
+
+        _log(f"Encodeur GPU CoreML prêt : {TARGET}")
+        return 0
+    except Exception as exc:  # noqa: BLE001
+        _log(f"Génération CoreML échouée ({type(exc).__name__}: {exc}) — les scans resteront sur CPU torch, sans conséquence sur la qualité")
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())