@mostajs/prononciation 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 Format : Keep a Changelog ; versions : SemVer.
 
+## [0.2.1] — 2026-10-26
+
+### Corrigé
+- `service/installer.sh` accepte **`PRONONCIATION_VENV`**. L'environnement Python peut vivre hors de `node_modules/`, que `npm ci` efface à chaque déploiement.
+- `lexiqueCmudict` ignore le **commentaire de fin de ligne**. Le CMUdict de référence (cmusphinx/cmudict, `cmudict.dict`) en porte sur 22 lignes (« aalborg AO1 L B AO0 R G # place, danish »). Les mots du commentaire devenaient des sons. Essai T-PRO-24.
+
+## [0.2.0] — 2026-10-25
+
+### Ajouté
+- **Le service de reconnaissance** (`service/`, Python ≥ 3.10), livré avec le module :
+  - `POST /reconnaitre` sert le contrat de `reconnaisseurHttp` ; `GET /sante` le décrit ;
+  - wav2vec2 phonémique à révision figée, et dépendances figées (`requirements.txt`) ;
+  - alignement forcé CTC et 8 traits par son attendu, repris d'`extraire_gop.py`.
+- **Refus nommés** : ATTENDUS, AUDIO_ABSENT, LONGUEUR, TROP_GROS, TROP_LONG, FORMAT, CHEMIN, METHODE, INTERNE.
+- **Fonctionnement** : écoute locale par défaut, une inférence à la fois. L'audio n'est jamais écrit, et le journal ne contient que des comptes et des durées.
+- **`service/installer.sh`** : rejouable, il vérifie que le modèle se charge sans réseau.
+- **Essais** :
+  - T-SRV-1 à 9 (unittest). Parité avec l'apprentissage sur cinq phrases : écart de traits **nul**.
+  - T-PRO-23 : le service réel derrière `reconnaisseurHttp` rend la note de Python.
+
+### Corrigé
+- Quand l'audio a moins de trames que de sons attendus, le partage égal débordait de l'audio, et un trait se calculait sur un segment vide. Les segments sont désormais ramenés sur la dernière trame. Les cas du corpus ne changent pas : la parité le vérifie.
+
+### Points ouverts
+- Le WebM/Opus enregistré par les navigateurs n'est pas lu. Il faut l'enregistreur WAV de `@mostajs/media` (B-03).
+- Le débit reste à mesurer sur le serveur de production (amia).
+
 ## [0.1.0] — 2026-10-25
 
 ### Ajouté

package/README.md

@@ -11,8 +11,11 @@ Ce module dit si une voix a prononcé un texte connu, et où elle s'en écarte,
 
 ```bash
 npm install @mostajs/prononciation
+bash node_modules/@mostajs/prononciation/service/installer.sh   # le service de reconnaissance (0.2.0), voir service/README.md
 ```
 
+Le service de reconnaissance (Python, wav2vec2) est livré avec le module, dans `service/`. Il écoute en local, et `reconnaisseurHttp` en est le client.
+
 ## Exemple minimal
 
 ```js
@@ -23,7 +26,7 @@ import { readFileSync } from 'node:fs';
 const p = createPrononciation({
   lexique: combinerLexiques(creerLexique({ BOUMERDES: 'b u m ɛ ɹ d ɛ s' }),
                             lexiqueCmudict(readFileSync('cmudict.dict', 'utf8'))),
-  reconnaisseur: reconnaisseurHttp({ url: 'http://127.0.0.1:8765/reconnaitre' }),
+  reconnaisseur: reconnaisseurHttp({ url: 'http://127.0.0.1:8762/reconnaitre', type: 'audio/wav' }),
   note: NOTE_APPRISE_1,
 });
 
@@ -57,7 +60,7 @@ Les poids sont appris sur des voix d'apprenants chinois. Il faut les remesurer s
 ## Vérifier
 
 ```bash
-npm test                    # 22 essais (mjs-unit), parité JS ↔ Python comprise
+npm test                    # 23 essais (mjs-unit) + 9 essais du service (Python), parités comprises
 node examples/verifier.mjs  # trois vraies phrases, par le vrai adaptateur HTTP
 ```
 

package/llms.txt

@@ -42,6 +42,17 @@ Port reconnaisseur { reconnaitre({ audio, attendus }) → Promise<{ entendus: st
 Contrat HTTP : POST <url>, corps = octets de l'audio ; en-tête x-attendus = encodeURIComponent(JSON des sons attendus) ;
   réponse 200 JSON { entendus, traits?, duree? }.
 
+SERVICE DE RECONNAISSANCE (0.2.0, service/, Python ≥ 3.10)
+Installer : bash service/installer.sh (venv, dépendances FIGÉES, wav2vec2 à la révision ae45363b ; PRONONCIATION_HF_HOME)
+Lancer    : HF_HOME=… service/.venv/bin/python service/serveur.py --local-seulement  → écoute http://127.0.0.1:8762
+  options --hote 127.0.0.1, --port 8762 (0 = libre), --fils 2, --octets 2000000, --secondes 15
+POST /reconnaitre → { entendus, traits, duree, regle: 'stricte-2', modele } ; GET /sante → { ok, modele, revision, regle, classes }
+Refus { erreur, message } : ATTENDUS 400, AUDIO_ABSENT 400 (vide ou < 0,25 s), LONGUEUR 411, TROP_GROS 413,
+  TROP_LONG 413, FORMAT 415 (WAV/FLAC/OGG ; pas WebM), CHEMIN 404, METHODE 405, INTERNE 500 → côté JS : RECONNAISSEUR 502
+Une inférence à la fois ; audio jamais écrit ; journal = comptes et durées seulement.
+Parité : traits identiques à l'apprentissage (T-SRV-9, écart 0) ; note de Python de bout en bout (T-PRO-23).
+Piège : la révision du modèle et les versions sont figées — en changer, c'est changer la note.
+
 NOTES ET SEUILS
 - Simple (aucune note configurée) : son = 2 si retrouvé, sinon 0 ; phrase = 10 × part retrouvée. Seuils : phrase 6, mot 1, son 1.
 - Apprise (note: NOTE_APPRISE_1) :

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mostajs/prononciation",
-  "version": "0.1.0",
-  "description": "Compare une voix à un texte connu : sons attendus par un lexique injecté, sons entendus par un reconnaisseur injecté, alignement, note par son, mot et phrase (note apprise ou simple), verdict, et les sons qui résistent.",
+  "version": "0.2.1",
+  "description": "Compare une voix à un texte connu : sons attendus par un lexique injecté, sons entendus par un reconnaisseur injecté, alignement, note par son, mot et phrase (note apprise ou simple), verdict, et les sons qui résistent. Avec son service de reconnaissance (Python, wav2vec2), local.",
   "license": "AGPL-3.0-or-later",
   "author": "Dr Hamid MADANI <drmdh@msn.com>",
   "type": "module",
@@ -12,6 +12,9 @@
   },
   "files": [
     "src",
+    "service",
+    "!service/.venv",
+    "!service/**/__pycache__",
     "llms.txt",
     "README.md",
     "CHANGELOG.md",
@@ -33,7 +36,9 @@
     "phoneme",
     "speech",
     "english",
-    "cmudict"
+    "cmudict",
+    "wav2vec2",
+    "speech-recognition"
   ],
   "dependencies": {},
   "devDependencies": {
@@ -59,7 +64,8 @@
     "interop": [
       "IPA (Alphabet phonétique international)",
       "ARPAbet / CMUdict",
-      "speechocean762 (échelles de notes 0-2 par son, 0-10 par phrase)"
+      "speechocean762 (échelles de notes 0-2 par son, 0-10 par phrase)",
+      "HTTP : POST /reconnaitre (x-attendus), GET /sante — service/README.md"
     ],
     "ne_fait_pas": {
       "faire entendre une phrase": "@mostajs/voix",

package/service/README.md

@@ -0,0 +1,81 @@
+# Service de reconnaissance de `@mostajs/prononciation`
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later · Python ≥ 3.10
+
+Il reçoit l'audio d'un élève et les sons attendus. Il rend les sons entendus, 8 traits par son attendu et la durée, exactement comme pour l'apprentissage de `note-apprise-1`. `reconnaisseurHttp` en est le client.
+
+## Installer
+
+```bash
+bash node_modules/@mostajs/prononciation/service/installer.sh
+# ou, pour ranger le modèle (≈ 1,2 Go) ailleurs que dans ~/.cache/huggingface :
+PRONONCIATION_HF_HOME=/srv/modeles bash node_modules/@mostajs/prononciation/service/installer.sh
+```
+
+Installé depuis npm, le service vit dans `node_modules/`, que `npm ci` efface à chaque déploiement : posez `PRONONCIATION_VENV` (et `PRONONCIATION_HF_HOME`) **hors du projet**, pour n'installer qu'une fois :
+
+```bash
+PRONONCIATION_VENV=/srv/prononciation-venv PRONONCIATION_HF_HOME=/srv/modeles bash node_modules/@mostajs/prononciation/service/installer.sh
+```
+
+L'installeur fait trois choses :
+- il crée `service/.venv` et y installe les dépendances **figées** (`requirements.txt` : torch 2.4.1 CPU, transformers 4.44.2…) ;
+- il télécharge `facebook/wav2vec2-lv-60-espeak-cv-ft` à sa **révision figée** (`ae45363b`) ;
+- il vérifie que le modèle se charge sans réseau.
+
+Une autre version des dépendances ou du modèle donne d'autres traits, et la note apprise ne vaut plus ses 0,72.
+
+## Lancer
+
+```bash
+HF_HOME=/srv/modeles service/.venv/bin/python service/serveur.py --local-seulement
+# écoute http://127.0.0.1:8762
+```
+
+| option | défaut | rôle |
+|---|---|---|
+| `--hote` | `127.0.0.1` (`PRONONCIATION_HOTE`) | écoute locale : seule l'application le joint |
+| `--port` | `8762` (`PRONONCIATION_PORT`) | `0` : un port libre, annoncé sur la sortie |
+| `--fils` | `2` (`PRONONCIATION_FILS`) | fils de calcul du modèle |
+| `--octets` | `2000000` | taille maximale du corps |
+| `--secondes` | `15` | durée maximale de l'audio |
+| `--local-seulement` | non | ne rien télécharger ; sortie 3 si le modèle manque |
+
+Côté application :
+
+```js
+reconnaisseurHttp({ url: 'http://127.0.0.1:8762/reconnaitre', type: 'audio/wav' })
+```
+
+## Le contrat
+
+- `POST /reconnaitre` : le corps est l'audio (WAV, FLAC ou OGG, de 0,25 à 15 s) ; l'en-tête `x-attendus` porte les sons attendus, en JSON encodé. Réponse 200 : `{ entendus, traits, duree, regle, modele }`.
+- `GET /sante` : `{ ok, modele, revision, regle, classes }`.
+- Refus `{ erreur, message }` :
+
+| code | statut | quand |
+|---|---|---|
+| `ATTENDUS` | 400 | `x-attendus` absent, illisible, vide, plus de 400 sons, ou un son de plus de 4 signes |
+| `AUDIO_ABSENT` | 400 | corps vide, ou moins de 0,25 s |
+| `LONGUEUR` | 411 | pas de `content-length` |
+| `TROP_GROS` | 413 | corps au-delà de `--octets` (refusé sans être lu) |
+| `TROP_LONG` | 413 | audio au-delà de `--secondes` |
+| `FORMAT` | 415 | audio illisible (le WebM/Opus des navigateurs ne l'est pas : enregistrer en WAV) |
+| `CHEMIN`, `METHODE` | 404, 405 | autre adresse, autre méthode |
+| `INTERNE` | 500 | toute autre faute |
+
+## Ce qu'il ne garde pas
+
+L'audio est lu en mémoire et n'est jamais écrit. Le journal, sur la sortie d'erreur, ne porte que des comptes et des durées : jamais l'audio, jamais les sons attendus (essai T-SRV-8).
+
+## Débit
+
+Une inférence à la fois ; les requêtes suivantes attendent. Mesure du 25/10/2026, poste de développement, 2 fils : **1,5 à 2 s de calcul pour 3 s d'audio**. Le débit sur le serveur de production reste à mesurer.
+
+## Essais
+
+```bash
+PRONONCIATION_PYTHON=service/.venv/bin/python npm test   # 23 essais JS + 9 essais du service
+```
+
+T-SRV-9 compare les traits du vrai modèle à ceux de l'apprentissage, sur cinq phrases de speechocean762 : l'écart est **nul**. T-PRO-23 lance le service et note trois phrases de bout en bout, par `reconnaisseurHttp` : on retrouve la note de Python.

package/service/audio.py

@@ -0,0 +1,38 @@
+"""
+@mostajs/prononciation — service de reconnaissance : octets → onde mono à 16 kHz, en mémoire.
+
+@author Dr Hamid MADANI <drmdh@msn.com>
+@license AGPL-3.0-or-later
+
+libsndfile lit WAV, FLAC, OGG. Rien n'est écrit sur le disque : la voix d'un élève ne quitte pas la mémoire du
+processus, et le journal n'en garde que la durée.
+"""
+import io
+
+import soundfile as sf
+import torch
+import torchaudio.functional as AF
+
+from erreurs import ErreurService
+
+TAUX = 16000
+SECONDES_MIN = 0.25          # en deçà, le modèle n'a pas assez de trames pour un mot
+
+
+def lire_audio(octets, secondes_max=15.0):
+    try:
+        with sf.SoundFile(io.BytesIO(octets)) as f:
+            if f.frames / f.samplerate > secondes_max:
+                raise ErreurService('TROP_LONG', f'audio de {f.frames / f.samplerate:.1f} s ; au plus {secondes_max:g} s')
+            if f.frames / f.samplerate < SECONDES_MIN:
+                raise ErreurService('AUDIO_ABSENT', f'audio de {f.frames / f.samplerate:.2f} s ; au moins {SECONDES_MIN:g} s')
+            onde, sr = f.read(dtype='float32'), f.samplerate
+    except ErreurService:
+        raise
+    except Exception:
+        raise ErreurService('FORMAT', 'audio illisible (WAV, FLAC ou OGG attendu)') from None
+    if onde.ndim > 1:
+        onde = onde.mean(axis=1)
+    if sr != TAUX:
+        onde = AF.resample(torch.from_numpy(onde), sr, TAUX).numpy()
+    return onde

package/service/erreurs.py

@@ -0,0 +1,19 @@
+"""
+@mostajs/prononciation — service de reconnaissance : les refus nommés (plan §8.3).
+
+@author Dr Hamid MADANI <drmdh@msn.com>
+@license AGPL-3.0-or-later
+"""
+
+STATUTS = {
+    'ATTENDUS': 400, 'AUDIO_ABSENT': 400, 'LONGUEUR': 411, 'TROP_GROS': 413, 'TROP_LONG': 413,
+    'FORMAT': 415, 'CHEMIN': 404, 'METHODE': 405, 'INTERNE': 500,
+}
+
+
+class ErreurService(Exception):
+    """Un refus du service : un code nommé, son statut HTTP, un message en français."""
+
+    def __init__(self, code, message):
+        super().__init__(message)
+        self.code, self.statut, self.message = code, STATUTS[code], message

package/service/installer.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+#
+# @mostajs/prononciation — installe le service de reconnaissance (rejouable, plan §8.2).
+# Auteur : Dr Hamid MADANI <drmdh@msn.com>
+#
+#   bash service/installer.sh
+#   PRONONCIATION_HF_HOME=/srv/modeles bash service/installer.sh    # où ranger le modèle (≈ 1,2 Go)
+#   PRONONCIATION_VENV=/srv/prononciation-venv bash service/installer.sh   # l'environnement Python HORS de node_modules
+#
+# 0.2.1 — installé depuis npm, le service vit dans node_modules/, que `npm ci` efface à chaque déploiement : poser
+# PRONONCIATION_VENV (et PRONONCIATION_HF_HOME) hors du projet, pour n'installer qu'une fois.
+#
+# Crée service/.venv (Python ≥ 3.10), y installe les dépendances figées, télécharge le modèle à sa révision figée,
+# puis vérifie qu'il se charge sans réseau. Rien d'autre n'est écrit.
+set -euo pipefail
+ICI="$(cd "$(dirname "$0")" && pwd)"
+PY="${PYTHON:-python3}"
+"$PY" -c 'import sys; sys.exit(0 if sys.version_info >= (3, 10) else 1)' || { echo "✗ Python ≥ 3.10 requis ($PY)"; exit 1; }
+VENV="${PRONONCIATION_VENV:-$ICI/.venv}"
+[ -x "$VENV/bin/python" ] || "$PY" -m venv "$VENV"
+"$VENV/bin/pip" install -q --upgrade pip
+"$VENV/bin/pip" install -q -r "$ICI/requirements.txt"
+[ -n "${PRONONCIATION_HF_HOME:-}" ] && export HF_HOME="$PRONONCIATION_HF_HOME"
+cd "$ICI"
+"$VENV/bin/python" - <<'PY'
+from huggingface_hub import hf_hub_download
+import moteur
+for f in moteur.FICHIERS:
+    hf_hub_download(moteur.MODELE, f, revision=moteur.REVISION)
+assert moteur.modele_installe(), 'modèle absent après téléchargement'
+m = moteur.Moteur(local_seulement=True)
+print(f'✓ modèle {moteur.MODELE}@{moteur.REVISION[:8]} chargé : {m.classes} classes de sons, règle {m.regle}')
+PY
+echo "✓ installé. Lancer : ${PRONONCIATION_HF_HOME:+HF_HOME=$PRONONCIATION_HF_HOME }$VENV/bin/python $ICI/serveur.py --local-seulement"

package/service/moteur.py

@@ -0,0 +1,74 @@
+"""
+@mostajs/prononciation — service de reconnaissance : le modèle acoustique, chargé une fois.
+
+@author Dr Hamid MADANI <drmdh@msn.com>
+@license AGPL-3.0-or-later
+
+wav2vec2 phonémique (Apache-2.0), à la révision qui a servi à apprendre note-apprise-1. Une inférence à la fois :
+deux en parallèle sur les mêmes cœurs se ralentissent l'une l'autre (dossier produit, 11 §3).
+"""
+import json
+import threading
+import time
+
+import torch
+from huggingface_hub import hf_hub_download
+from transformers import Wav2Vec2FeatureExtractor, Wav2Vec2ForCTC
+from transformers.utils import logging as journal_transformers
+
+# transformers 4.44 annonce à tort des poids « réinitialisés » (weight_g/weight_v → parametrizations) : ils sont bien
+# chargés — T-SRV-9 retrouve les traits d'apprentissage à l'identique. L'avertissement égarerait l'exploitant.
+journal_transformers.set_verbosity_error()
+
+import sons
+import traits
+
+MODELE = 'facebook/wav2vec2-lv-60-espeak-cv-ft'
+REVISION = 'ae45363bf3413b374fecd9dc8bc1df0e24c3b7f4'
+FICHIERS = ('config.json', 'preprocessor_config.json', 'vocab.json', 'pytorch_model.bin')
+
+
+def modele_installe():
+    """Vrai si la révision figée du modèle est dans le cache local (HF_HOME), sans réseau."""
+    try:
+        for f in FICHIERS:
+            hf_hub_download(MODELE, f, revision=REVISION, local_files_only=True)
+        return True
+    except Exception:
+        return False
+
+
+class Moteur:
+    modele, revision, regle = MODELE, REVISION, sons.REGLE
+
+    def __init__(self, fils=2, local_seulement=False):
+        torch.set_num_threads(fils)
+        o = {'revision': REVISION, 'local_files_only': local_seulement}
+        vocab = json.load(open(hf_hub_download(MODELE, 'vocab.json', **o), encoding='utf-8'))
+        self.noms, self.membre, self.matrice, self.blanc = sons.classes_du_vocabulaire(vocab)
+        self.classes = len(self.noms)
+        self.id2tok = {i: t for t, i in vocab.items()}
+        self.proc = Wav2Vec2FeatureExtractor.from_pretrained(MODELE, **o)
+        self.model = Wav2Vec2ForCTC.from_pretrained(MODELE, **o).eval()
+        self.verrou = threading.Lock()
+
+    def reconnaitre(self, onde, attendus):
+        """onde : float32 mono 16 kHz ; attendus : sons → { entendus, traits, duree, calcul }."""
+        with self.verrou:
+            t0 = time.perf_counter()
+            with torch.inference_mode():
+                logits = self.model(self.proc(onde, sampling_rate=16000, return_tensors='pt').input_values).logits[0]
+            lp = torch.log_softmax(logits, dim=-1)
+            lp_cls = torch.log(lp.exp() @ self.matrice + 1e-12)
+            lp_blanc = lp[:, self.blanc]
+            bruts, prec = [], None
+            for i in torch.argmax(logits, dim=-1).tolist():     # décodage glouton
+                if i != prec and i != self.blanc:
+                    tk = self.id2tok.get(i, '')
+                    if tk.strip() and tk not in sons.SPECIAUX:
+                        bruts.append(tk)
+                prec = i
+            r = {'entendus': sons.entendre(bruts), 'traits': traits.caracteristiques(lp_cls, lp_blanc, attendus, self.membre),
+                 'duree': len(onde) / 16000}
+            r['calcul'] = time.perf_counter() - t0
+            return r

package/service/requirements.txt

@@ -0,0 +1,10 @@
+# @mostajs/prononciation — service de reconnaissance : dépendances FIGÉES (plan §8.2).
+# Ce sont celles qui ont produit les traits d'apprentissage de note-apprise-1 : une autre version est une autre mesure.
+# Auteur : Dr Hamid MADANI <drmdh@msn.com>
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.4.1+cpu
+torchaudio==2.4.1+cpu
+transformers==4.44.2
+huggingface_hub==0.24.6
+numpy==1.26.4
+soundfile==0.12.1

package/service/serveur.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+@mostajs/prononciation — service de reconnaissance : le serveur HTTP (plan §8.3).
+
+@author Dr Hamid MADANI <drmdh@msn.com>
+@license AGPL-3.0-or-later
+
+  POST /reconnaitre   corps = l'audio ; x-attendus = JSON des sons attendus (encodeURIComponent)
+                      → 200 { entendus, traits, duree, regle, modele }
+  GET  /sante         → 200 { ok, modele, revision, regle, classes }
+Tout refus : { erreur, message } avec son statut. Écoute locale par défaut : seule l'application le joint.
+Le journal ne porte que des comptes et des durées — jamais l'audio, jamais les sons attendus.
+
+Lancer : python serveur.py [--hote 127.0.0.1] [--port 8762] [--fils 2] [--octets 2000000] [--secondes 15]
+"""
+import argparse
+import json
+import os
+import signal
+import sys
+import time
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from audio import lire_audio
+from erreurs import ErreurService
+
+SONS_MAX, SON_LONGUEUR_MAX = 400, 4
+
+
+def lire_attendus(entete):
+    if not entete:
+        raise ErreurService('ATTENDUS', 'en-tête x-attendus absent')
+    try:
+        a = json.loads(urllib.parse.unquote(entete))
+    except Exception:
+        raise ErreurService('ATTENDUS', 'x-attendus : JSON illisible') from None
+    if not isinstance(a, list) or not 1 <= len(a) <= SONS_MAX:
+        raise ErreurService('ATTENDUS', f'x-attendus : une liste de 1 à {SONS_MAX} sons')
+    if not all(isinstance(s, str) and 1 <= len(s) <= SON_LONGUEUR_MAX and not any(c.isspace() for c in s) for s in a):
+        raise ErreurService('ATTENDUS', f'x-attendus : chaque son est une chaîne de 1 à {SON_LONGUEUR_MAX} signes')
+    return a
+
+
+def creer_serveur(moteur, hote='127.0.0.1', port=8762, octets_max=2_000_000, secondes_max=15.0, journal=None):
+    ecrire = journal or (lambda m: print(time.strftime('%Y-%m-%dT%H:%M:%S'), m, file=sys.stderr, flush=True))
+
+    class Gestion(BaseHTTPRequestHandler):
+        server_version = 'prononciation-reconnaissance'
+        sys_version = ''
+
+        def log_message(self, *args):       # pas de journal d'accès : il porterait les en-têtes
+            pass
+
+        def repondre(self, statut, corps):
+            b = json.dumps(corps, ensure_ascii=False).encode('utf-8')
+            self.send_response(statut)
+            self.send_header('content-type', 'application/json; charset=utf-8')
+            self.send_header('content-length', str(len(b)))
+            self.send_header('connection', 'close')
+            self.end_headers()
+            self.wfile.write(b)
+            self.close_connection = True
+
+        def refuser(self, e):
+            ecrire(f'refus {e.code} ({e.statut})')
+            self.repondre(e.statut, {'erreur': e.code, 'message': e.message})
+
+        def do_GET(self):
+            if self.path == '/sante':
+                return self.repondre(200, {'ok': True, 'modele': moteur.modele, 'revision': moteur.revision,
+                                           'regle': moteur.regle, 'classes': moteur.classes})
+            self.refuser(ErreurService('METHODE', 'POST attendu') if self.path == '/reconnaitre'
+                         else ErreurService('CHEMIN', f'adresse inconnue ; /reconnaitre ou /sante'))
+
+        def autre(self):
+            self.refuser(ErreurService('METHODE', 'POST /reconnaitre ou GET /sante'))
+
+        do_PUT = do_DELETE = do_PATCH = autre
+
+        def do_POST(self):
+            try:
+                if self.path != '/reconnaitre':
+                    raise ErreurService('CHEMIN', 'adresse inconnue ; /reconnaitre ou /sante')
+                attendus = lire_attendus(self.headers.get('x-attendus'))
+                longueur = self.headers.get('content-length')
+                if longueur is None or not longueur.isdigit():
+                    raise ErreurService('LONGUEUR', 'content-length attendu')
+                n = int(longueur)
+                if n == 0:
+                    raise ErreurService('AUDIO_ABSENT', 'corps vide : l’audio est attendu')
+                if n > octets_max:                     # refusé SANS lire : la borne n'est jamais dépassée en mémoire
+                    raise ErreurService('TROP_GROS', f'{n} octets ; au plus {octets_max}')
+                onde = lire_audio(self.rfile.read(n), secondes_max)
+                r = moteur.reconnaitre(onde, attendus)
+                ecrire(f'reconnu : {len(attendus)} sons attendus, {len(r["entendus"])} entendus, '
+                       f'{r["duree"]:.2f} s d’audio, {r.get("calcul", 0.0):.2f} s de calcul')
+                self.repondre(200, {'entendus': r['entendus'], 'traits': r['traits'], 'duree': r['duree'],
+                                    'regle': moteur.regle, 'modele': moteur.modele})
+            except ErreurService as e:
+                self.refuser(e)
+            except Exception:
+                self.refuser(ErreurService('INTERNE', 'faute interne du service'))
+
+    srv = ThreadingHTTPServer((hote, port), Gestion)
+    srv.daemon_threads = True
+    return srv
+
+
+def main():
+    ap = argparse.ArgumentParser(description='Service de reconnaissance de @mostajs/prononciation')
+    ap.add_argument('--hote', default=os.environ.get('PRONONCIATION_HOTE', '127.0.0.1'))
+    ap.add_argument('--port', type=int, default=int(os.environ.get('PRONONCIATION_PORT', '8762')))
+    ap.add_argument('--fils', type=int, default=int(os.environ.get('PRONONCIATION_FILS', '2')))
+    ap.add_argument('--octets', type=int, default=2_000_000)
+    ap.add_argument('--secondes', type=float, default=15.0)
+    ap.add_argument('--local-seulement', action='store_true', help='ne rien télécharger : le modèle doit être installé')
+    a = ap.parse_args()
+    import moteur as m
+    if a.local_seulement and not m.modele_installe():
+        print(f'modèle {m.MODELE}@{m.REVISION[:8]} non installé : service/installer.sh', file=sys.stderr)
+        sys.exit(3)
+    srv = creer_serveur(m.Moteur(fils=a.fils, local_seulement=a.local_seulement), a.hote, a.port, a.octets, a.secondes)
+    signal.signal(signal.SIGTERM, lambda *_: (srv.server_close(), sys.exit(0)))
+    print(f'écoute http://{srv.server_address[0]}:{srv.server_address[1]}', flush=True)
+    srv.serve_forever()
+
+
+if __name__ == '__main__':
+    main()

package/service/sons.py

@@ -0,0 +1,64 @@
+"""
+@mostajs/prononciation — service de reconnaissance : jetons du modèle → classes de sons (règle stricte-2).
+
+@author Dr Hamid MADANI <drmdh@msn.com>
+@license AGPL-3.0-or-later
+
+Repris de mesure_moteur_speechocean762.py (dossier produit), la règle qui a servi à apprendre note-apprise-1.
+Le cœur JS (src/lib/notation.js, normaliserJetons) applique la même : l'essai T-SRV-1 les compare jeton par jeton
+sur tout le vocabulaire du modèle. Corrections de notation seulement : longueur, accent, aspiration, tons chinois,
+symboles composés (ɑːɹ = ɑ + ɹ).
+"""
+import re
+
+import torch
+
+REGLE = 'stricte-2'
+
+CLASSES = {'ə': 'ʌ', 'ɐ': 'ʌ', 'ɚ': 'ɜ', 'ɝ': 'ɜ', 'əʊ': 'oʊ', 'e': 'ɛ', 'ɒ': 'ɑ', 'g': 'ɡ',
+           'r': 'ɹ', 'ɾ': 't', 'ɫ': 'l', 'ᵻ': 'ɪ', 'ɪ̈': 'ɪ', 'o': 'oʊ', 'tS': 'tʃ', 'dZ': 'dʒ',
+           'th': 't', 'kh': 'k', 'ph': 'p', 'e̞': 'ɛ', 'o̞': 'oʊ', 'a': 'æ', 'ä': 'ɑ', 'l̩': 'l', 'n̩': 'n'}
+COMPOSES = {'ɑɹ': ['ɑ', 'ɹ'], 'ɔɹ': ['ɔ', 'ɹ'], 'oɹ': ['ɔ', 'ɹ'], 'ɪɹ': ['ɪ', 'ɹ'], 'ɛɹ': ['ɛ', 'ɹ'],
+            'ʊɹ': ['ʊ', 'ɹ'], 'əl': ['ʌ', 'l'], 'aɪə': ['aɪ', 'ʌ'], 'aɪɚ': ['aɪ', 'ɜ'], 'ju': ['j', 'u'],
+            'ja': ['j', 'ɑ'], 'iə': ['i', 'ʌ'], 'eə': ['ɛ', 'ʌ'], 'ʊə': ['ʊ', 'ʌ']}
+VOYELLES = set('aeiouæɑɒɔəɛɜɪʊʌy')
+SPECIAUX = {'<s>', '</s>', '<unk>', '|', ' ', '<pad>'}
+
+
+def nettoyer(p):
+    p = re.sub(r'[ːˈˌ:."^\[ʰʲ]', '', p)
+    p = re.sub(r'[1-5]+$', '', p)                       # tons chinois notés par chiffre
+    if len(p) > 1 and p.endswith('ɜ') and p[0] in VOYELLES:
+        p = p[:-1]                                      # ton 3 noté ɜ (iɜ, uɜ, əɜ…)
+    return p
+
+
+def entendre(jetons):
+    """Jetons bruts du modèle → classes de sons comparables (liste)."""
+    out = []
+    for j in jetons:
+        p = nettoyer(j)
+        if not p:
+            continue
+        for q in COMPOSES.get(p, [p]):
+            out.append(CLASSES.get(q, q))
+    return out
+
+
+def classes_du_vocabulaire(vocab):
+    """vocab {jeton: indice} → (noms des classes, {classe: colonne}, matrice [jetons × classes], indice du blanc).
+    Un symbole composé (ɑːɹ) compte pour CHACUN de ses sons."""
+    noms, membre = [], {}
+    for tok in vocab:
+        if tok in SPECIAUX:
+            continue
+        for c in entendre([tok]):
+            if c not in membre:
+                membre[c] = len(noms)
+                noms.append(c)
+    matrice = torch.zeros(len(vocab), len(noms))
+    for tok, i in vocab.items():
+        if tok not in SPECIAUX:
+            for c in entendre([tok]):
+                matrice[i, membre[c]] = 1.0
+    return noms, membre, matrice, vocab['<pad>']

package/service/traits.py

@@ -0,0 +1,62 @@
+"""
+@mostajs/prononciation — service de reconnaissance : les 8 traits par son attendu (GOP).
+
+@author Dr Hamid MADANI <drmdh@msn.com>
+@license AGPL-3.0-or-later
+
+Repris tel quel d'extraire_gop.py (dossier produit), qui a produit les traits d'apprentissage de note-apprise-1 :
+l'alignement forcé CTC place chaque son attendu sur ses trames, puis, par son :
+  gop_moy, gop_max      log-probabilité moyenne et maximale de la classe attendue sur ses trames ;
+  fenetre_max           maximum sur une fenêtre élargie (fin du son précédent → début du suivant : le CTC est « pointu ») ;
+  lpr_moy, lpr_max      écart au meilleur concurrent ;
+  duree, fenetre        en trames de 20 ms ;
+  blanc_moy             probabilité moyenne du « rien ».
+Un son que le modèle ne connaît pas reçoit le plancher.
+"""
+import numpy as np
+import torch
+import torchaudio.functional as AF
+
+PLANCHER = float(np.log(1e-8))
+
+
+def caracteristiques(lp_cls, lp_blanc, attendus, membre):
+    """lp_cls [T, C] log-proba par classe ; lp_blanc [T] ; attendus : sons (suffixe 0 possible) → [[8 traits]]."""
+    T = lp_cls.shape[0]
+    bases = [a[:-1] if a.endswith('0') else a for a in attendus]
+    cibles = [membre.get(b, -1) for b in bases]
+    # émission réduite : colonne 0 = blanc, puis une colonne par position attendue
+    em = torch.full((T, len(cibles) + 1), PLANCHER)
+    em[:, 0] = lp_blanc
+    for j, c in enumerate(cibles):
+        if c >= 0:
+            em[:, j + 1] = lp_cls[:, c]
+    em = em - torch.logsumexp(em, dim=1, keepdim=True)
+    try:
+        ali, _ = AF.forced_align(em[None], torch.arange(1, len(cibles) + 1, dtype=torch.int32)[None], blank=0)
+        spans = AF.merge_tokens(ali[0], torch.zeros(T))
+        bornes = [(s.start, s.end) for s in spans]
+        if len(bornes) != len(cibles):
+            raise RuntimeError('alignement incomplet')
+    except Exception:
+        pas = T / max(1, len(cibles))         # trop court pour l'alignement : partage égal
+        bornes = [(int(j * pas), max(int(j * pas) + 1, int((j + 1) * pas))) for j in range(len(cibles))]
+    # Plus de sons que de trames : le partage déborde de l'audio. On ramène chaque segment sur la dernière trame
+    # (0.2.0 ; extraire_gop.py n'a jamais rencontré le cas sur le corpus). Un segment dans l'audio n'est pas touché.
+    bornes = [(d, f) if d < T else (T - 1, T) for d, f in bornes]
+    meilleur = lp_cls.max(dim=1).values
+    out = []
+    for j, (c, (d, f)) in enumerate(zip(cibles, bornes)):
+        wd = bornes[j - 1][1] if j else 0
+        wf = bornes[j + 1][0] if j + 1 < len(bornes) else T
+        wf = max(wf, f)
+        wd = min(wd, d)
+        if c >= 0:
+            seg, win = lp_cls[d:f, c], lp_cls[wd:wf, c]
+            gop_moy, gop_max, win_max = float(seg.mean()), float(seg.max()), float(win.max())
+            lpr = seg - meilleur[d:f]
+            lpr_moy, lpr_max = float(lpr.mean()), float(lpr.max())
+        else:
+            gop_moy = gop_max = win_max = lpr_moy = lpr_max = PLANCHER
+        out.append([gop_moy, gop_max, win_max, lpr_moy, lpr_max, f - d, wf - wd, float(lp_blanc[d:f].mean())])
+    return out

package/src/lib/lexique.js

@@ -23,12 +23,14 @@ export function creerLexique(table = {}) {
 export function lexiqueCmudict(texte) {
   if (typeof texte !== 'string') refus('CONFIGURATION', 'lexiqueCmudict : le texte du fichier est attendu');
   const table = {};
-  for (const ligne of texte.split(/\r?\n/)) {
-    if (!ligne.trim() || ligne.startsWith(';;;')) continue;
+  for (const brute of texte.split(/\r?\n/)) {
+    if (brute.startsWith(';;;')) continue;
+    const ligne = brute.split('#')[0];                             // 0.2.1 : « … R G # place, danish » → commentaire
+    if (!ligne.trim()) continue;
     const [mot, ...sons] = ligne.trim().split(/\s+/);
     if (!sons.length || /\(\d+\)$/.test(mot)) continue;          // variante : TOMATO(2)
     const cle = mot.toUpperCase();
-    if (!(cle in table)) table[cle] = sons.map((s) => s.toUpperCase()).filter((s) => !s.startsWith('#'));
+    if (!(cle in table)) table[cle] = sons.map((s) => s.toUpperCase());
   }
   return creerLexique(table);
 }