@mostajs/prononciation 0.0.0-stage → 0.2.0

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/adapters/fixe.js

@@ -0,0 +1,12 @@
+// @mostajs/prononciation — reconnaisseur FIXE : rend une réponse donnée, ou calculée des sons attendus. Pour les essais.
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+
+/** @param {object | ((demande: { audio, attendus: string[] }) => object)} reponse */
+export function reconnaisseurFixe(reponse) {
+  return Object.freeze({
+    nom: 'fixe',
+    async reconnaitre({ audio, attendus }) {
+      return typeof reponse === 'function' ? reponse({ audio, attendus: [...attendus] }) : { ...reponse };
+    },
+  });
+}

package/src/adapters/http.js

@@ -0,0 +1,37 @@
+// @mostajs/prononciation — reconnaisseur HTTP : client du service de reconnaissance (wav2vec2, joint en local).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+// Contrat (docs/03-PLAN-DEV-PRONONCIATION.md §3.2) : POST <url>, corps = octets de l'audio, en-tête x-attendus = JSON
+// des sons attendus (encodeURIComponent) ; réponse 200 { entendus, traits?, duree? }. L'adaptateur ne fait que traduire (R-L).
+import { ErreurPrononciation, refus } from '../lib/erreurs.js';
+
+export function reconnaisseurHttp({ url, fetch: f = globalThis.fetch, delaiMs = 15_000, type = 'application/octet-stream' } = {}) {
+  if (typeof url !== 'string' || !/^https?:\/\//.test(url)) refus('CONFIGURATION', 'reconnaisseurHttp : url http(s) attendue');
+  if (typeof f !== 'function') refus('CONFIGURATION', 'reconnaisseurHttp : fetch indisponible');
+  const echec = (m) => new ErreurPrononciation('RECONNAISSEUR', `reconnaissance : ${m}`);
+  return Object.freeze({
+    nom: 'http',
+    async reconnaitre({ audio, attendus }) {
+      const ctl = new AbortController();
+      let minuterie;
+      const delai = new Promise((_, rej) => { minuterie = setTimeout(() => { ctl.abort(); rej(echec(`délai de ${delaiMs} ms dépassé`)); }, delaiMs); });
+      try {
+        const rep = await Promise.race([f(url, {
+          method: 'POST', body: audio, signal: ctl.signal,
+          headers: { 'content-type': audio?.type || type, 'x-attendus': encodeURIComponent(JSON.stringify(attendus)) },
+        }), delai]);
+        if (!rep?.ok) throw echec(`statut ${rep?.status}`);
+        let corps;
+        try { corps = await rep.json(); } catch { throw echec('réponse qui n’est pas du JSON'); }
+        if (!Array.isArray(corps?.entendus) || !corps.entendus.every((s) => typeof s === 'string')) throw echec('entendus absent ou mal formé');
+        const r = { entendus: corps.entendus };
+        if (corps.traits !== undefined) r.traits = corps.traits;
+        if (corps.duree !== undefined) r.duree = corps.duree;
+        return r;
+      } catch (e) {
+        throw e instanceof ErreurPrononciation ? e : echec(e?.message ?? String(e));
+      } finally {
+        clearTimeout(minuterie);
+      }
+    },
+  });
+}

package/src/index.js

@@ -0,0 +1,13 @@
+// @mostajs/prononciation — point d'entrée. Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+export { createPrononciation } from './prononciation.js';
+export { ErreurPrononciation, CODES, LIBELLES } from './lib/erreurs.js';
+export { arpaVersIpa, normaliserJetons, egal, ARPA, PHONEMES, REGLES } from './lib/notation.js';
+export { motsDe } from './lib/texte.js';
+export { creerLexique, lexiqueCmudict, combinerLexiques } from './lib/lexique.js';
+export { aligner } from './lib/alignement.js';
+export { appliquerNote, noteSimple, validerNote } from './lib/note.js';
+export { resistances } from './lib/resistances.js';
+export { reconnaisseurFixe } from './adapters/fixe.js';
+export { reconnaisseurHttp } from './adapters/http.js';
+/** Les poids appris sur speechocean762 (CC BY 4.0) : phrase 0,72, son 0,56 d'accord avec les juges sur la partie test. */
+export { default as NOTE_APPRISE_1 } from './poids/note-apprise-1.js';

package/src/lib/alignement.js

@@ -0,0 +1,36 @@
+// @mostajs/prononciation — alignement des sons attendus et entendus (Levenshtein).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+// Même calcul et même ordre de retour arrière que aligner() de mesure_moteur_speechocean762.py.
+import { egal } from './notation.js';
+
+/**
+ * @param {string[]} attendus  sons attendus (suffixe 0 possible)
+ * @param {string[]} entendus  sons entendus, normalisés
+ * @returns {{ etats: ('juste'|'faux'|'omis')[], entendus: (string|null)[], insertions: { apres: number, entendu: string }[] }}
+ *   `entendus[i]` : le son entendu en face du i-ème attendu ; `apres` : l'indice de l'attendu qui précède l'insertion (-1 en tête)
+ */
+export function aligner(attendus, entendus, { regle = 'stricte-2' } = {}) {
+  const n = attendus.length, m = entendus.length;
+  const d = Array.from({ length: n + 1 }, (_, i) => { const r = new Int32Array(m + 1); r[0] = i; return r; });
+  for (let j = 0; j <= m; j++) d[0][j] = j;
+  const cout = (i, j) => (egal(attendus[i - 1], entendus[j - 1], regle) ? 0 : 1);
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cout(i, j));
+  }
+  const etats = new Array(n).fill(null), vis = new Array(n).fill(null), insertions = [];
+  let i = n, j = m;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && d[i][j] === d[i - 1][j - 1] + cout(i, j)) {
+      etats[i - 1] = cout(i, j) === 0 ? 'juste' : 'faux';
+      vis[i - 1] = entendus[j - 1];
+      i--; j--;
+    } else if (i > 0 && d[i][j] === d[i - 1][j] + 1) {
+      etats[i - 1] = 'omis';
+      i--;
+    } else {
+      insertions.unshift({ apres: i - 1, entendu: entendus[j - 1] });
+      j--;
+    }
+  }
+  return { etats, entendus: vis, insertions };
+}

package/src/lib/erreurs.js

@@ -0,0 +1,38 @@
+// @mostajs/prononciation — vocabulaire d'erreur unique (R-I). Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+
+/** Chaque code et son statut HTTP : l'application le mappe une fois, à un seul endroit. */
+export const CODES = Object.freeze({
+  CONFIGURATION: 400,
+  TEXTE_VIDE: 400,
+  TEXTE_TROP_LONG: 413,
+  MOT_INCONNU: 422,
+  AUDIO_ABSENT: 400,
+  AUDIO_TROP_LONG: 413,
+  RECONNAISSEUR: 502,
+  TRAITS: 502,
+});
+
+/** Le libellé français de référence de chaque code ; l'application le traduit. */
+export const LIBELLES = Object.freeze({
+  CONFIGURATION: 'Configuration du moteur de prononciation invalide.',
+  TEXTE_VIDE: 'Le texte ne contient aucun mot.',
+  TEXTE_TROP_LONG: 'Le texte contient trop de mots.',
+  MOT_INCONNU: 'Un ou plusieurs mots sont absents du lexique.',
+  AUDIO_ABSENT: 'Aucun enregistrement reçu.',
+  AUDIO_TROP_LONG: "L'enregistrement est trop long.",
+  RECONNAISSEUR: "Le service de reconnaissance n'a pas répondu correctement.",
+  TRAITS: 'Le service de reconnaissance ne rend pas les traits que demande la note apprise.',
+});
+
+export class ErreurPrononciation extends Error {
+  /** @param {keyof CODES} code ; @param {string} message ; @param {object} [details] copiés sur l'erreur (ex. { mots }) */
+  constructor(code, message = LIBELLES[code], details = {}) {
+    super(message);
+    this.name = 'ErreurPrononciation';
+    this.code = code;
+    this.statut = CODES[code] ?? 500;
+    Object.assign(this, details);
+  }
+}
+
+export const refus = (code, message, details) => { throw new ErreurPrononciation(code, message, details); };

package/src/lib/lexique.js

@@ -0,0 +1,45 @@
+// @mostajs/prononciation — lexiques (port `lexique` : { phonemes(mot) → string[] | null }).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { arpaVersIpa } from './notation.js';
+import { refus } from './erreurs.js';
+
+const ARPABET = /^[A-Z]{1,2}[0-2]?$/;
+/** Une suite de sons (chaîne séparée par des espaces, ou tableau), en IPA ou en ARPAbet. */
+function lireSons(valeur, mot) {
+  const sons = Array.isArray(valeur) ? valeur.map(String) : String(valeur ?? '').trim().split(/\s+/).filter(Boolean);
+  if (!sons.length) refus('CONFIGURATION', `lexique : le mot ${mot} n'a aucun son`);
+  return sons.every((s) => ARPABET.test(s)) ? sons.map(arpaVersIpa) : sons;
+}
+
+/** Un lexique depuis une table { MOT: 'k ʌ p' | 'K AH1 P' | ['k','ʌ','p'] }. */
+export function creerLexique(table = {}) {
+  if (table === null || typeof table !== 'object') refus('CONFIGURATION', 'creerLexique : une table est attendue');
+  const m = new Map();
+  for (const [mot, sons] of Object.entries(table)) m.set(mot.toUpperCase(), Object.freeze(lireSons(sons, mot)));
+  return Object.freeze({ phonemes: (mot) => (m.has(String(mot).toUpperCase()) ? [...m.get(String(mot).toUpperCase())] : null), taille: m.size });
+}
+
+/** Un lexique depuis le texte d'un fichier CMUdict (BSD-2), fourni par l'application. Première variante gardée. */
+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;
+    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('#'));
+  }
+  return creerLexique(table);
+}
+
+/** Plusieurs lexiques consultés dans l'ordre : le premier qui connaît le mot l'emporte (les mots de l'enseignant d'abord). */
+export function combinerLexiques(...lexiques) {
+  if (!lexiques.length || lexiques.some((l) => typeof l?.phonemes !== 'function')) refus('CONFIGURATION', 'combinerLexiques : des lexiques sont attendus');
+  return Object.freeze({
+    phonemes(mot) {
+      for (const l of lexiques) { const s = l.phonemes(mot); if (s) return s; }
+      return null;
+    },
+  });
+}

package/src/lib/notation.js

@@ -0,0 +1,71 @@
+// @mostajs/prononciation — notation des sons : ARPAbet → IPA, classes, égalité selon la règle, jetons d'espeak.
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+// Porté de mesure_moteur_speechocean762.py (dossier Entreprise/saas-making/produits/prononciation, règle stricte-2),
+// mesuré sur les 2 500 phrases de test de speechocean762.
+
+/** ARPAbet (CMUdict, speechocean762) → IPA à la manière d'espeak. */
+export const ARPA = Object.freeze({
+  AA: 'ɑ', AE: 'æ', AH: 'ʌ', AO: 'ɔ', AW: 'aʊ', AY: 'aɪ', B: 'b', CH: 'tʃ', D: 'd', DH: 'ð', EH: 'ɛ', ER: 'ɜ',
+  EY: 'eɪ', F: 'f', G: 'ɡ', HH: 'h', IH: 'ɪ', IY: 'i', JH: 'dʒ', K: 'k', L: 'l', M: 'm', N: 'n', NG: 'ŋ',
+  OW: 'oʊ', OY: 'ɔɪ', P: 'p', R: 'ɹ', S: 's', SH: 'ʃ', T: 't', TH: 'θ', UH: 'ʊ', UW: 'u', V: 'v', W: 'w',
+  Y: 'j', Z: 'z', ZH: 'ʒ',
+});
+
+/** Les 39 classes de sons de l'anglais que compare le module. */
+export const PHONEMES = Object.freeze([...new Set(Object.values(ARPA))]);
+
+/** Variantes de notation ramenées à leur classe (le modèle acoustique est multilingue, 392 symboles). */
+export const CLASSES = Object.freeze({
+  'ə': 'ʌ', 'ɐ': 'ʌ', 'ɚ': 'ɜ', 'ɝ': 'ɜ', 'əʊ': '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',
+});
+
+/** Symboles composés d'espeak découpés en leurs sons. */
+export const COMPOSES = Object.freeze({
+  'ɑɹ': ['ɑ', 'ɹ'], 'ɔɹ': ['ɔ', 'ɹ'], 'oɹ': ['ɔ', 'ɹ'], 'ɪɹ': ['ɪ', 'ɹ'], 'ɛɹ': ['ɛ', 'ɹ'], 'ʊɹ': ['ʊ', 'ɹ'],
+  'əl': ['ʌ', 'l'], 'aɪə': ['aɪ', 'ʌ'], 'aɪɚ': ['aɪ', 'ɜ'], 'ju': ['j', 'u'], 'ja': ['j', 'ɑ'], 'iə': ['i', 'ʌ'],
+  'eə': ['ɛ', 'ʌ'], 'ʊə': ['ʊ', 'ʌ'],
+});
+
+export const REGLES = Object.freeze(['stricte-2', 'tolerante-2']);
+const VOYELLES = new Set('aeiouæɑɒɔəɛɜɪʊʌy');
+
+/** Un son ARPAbet (AA1, AH0…) → classe IPA ; AH0 et IY0 gardent le suffixe 0 (non accentué). */
+export function arpaVersIpa(ph) {
+  const base = String(ph).toUpperCase().replace(/\d/g, '');
+  const brut = ARPA[base] ?? base.toLowerCase();
+  const ipa = CLASSES[brut] ?? brut;
+  return (base === 'AH' || base === 'IY') && /0$/.test(ph) ? `${ipa}0` : ipa;
+}
+
+/** La classe d'un son attendu, sans la marque 0. */
+export const base = (p) => (p.endsWith('0') ? p.slice(0, -1) : p);
+
+function nettoyer(p) {
+  let q = p.replace(/[ːˈˌ:."^[ʰʲ]/g, '').replace(/[1-5]+$/, '');
+  if (q.length > 1 && q.endsWith('ɜ') && VOYELLES.has(q[0])) q = q.slice(0, -1);    // ton 3 noté ɜ
+  return q;
+}
+
+/** Jetons bruts d'espeak (sortie du modèle) → sons comparables. */
+export function normaliserJetons(jetons) {
+  const out = [];
+  for (const j of jetons) {
+    const p = nettoyer(String(j).trim());
+    if (!p) continue;
+    for (const q of COMPOSES[p] ?? [p]) out.push(CLASSES[q] ?? q);
+  }
+  return out;
+}
+
+/** Le son attendu `a` (suffixe 0 possible) est-il le son entendu `b`, selon la règle ? */
+export function egal(a, b, regle = 'stricte-2') {
+  const x = base(a);
+  if (x === b) return true;
+  if (regle === 'tolerante-2') {
+    if ((x === 'ɑ' && b === 'ɔ') || (x === 'ɔ' && b === 'ɑ')) return true;
+    if ((a === 'ʌ0' || a === 'i0') && b === 'ɪ') return true;
+  }
+  return false;
+}

package/src/lib/note.js

@@ -0,0 +1,98 @@
+// @mostajs/prononciation — les notes : simple (part des sons retrouvés) et apprise (traits GOP → réseau → ridge).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+// La passe avant reproduit apprendre_note.py (dossier Entreprise/saas-making/produits/prononciation, doc 13) ;
+// l'essai T-PRO-11 compare ses sorties à celles de Python sur des phrases de contrôle.
+import { refus } from './erreurs.js';
+
+export const ETATS = Object.freeze(['juste', 'faux', 'omis']);
+export const NB_TRAITS = 8;
+const NB_AGREGATS = 9;
+
+/** Note simple : un son retrouvé vaut 2, sinon 0 ; la phrase vaut 10 × part retrouvée. */
+export function noteSimple(etats) {
+  const notes = etats.map((e) => (e === 'juste' ? 2 : 0));
+  return { notes, note: etats.length ? (10 * notes.filter((x) => x === 2).length) / etats.length : 0 };
+}
+
+const nombres = (x, n) => Array.isArray(x) && x.length === n && x.every(Number.isFinite);
+const matrice = (w, lignes, colonnes) => Array.isArray(w) && w.length === lignes && w.every((r) => nombres(r, colonnes));
+
+/** Vérifie la forme d'un objet de poids ; rend sa dimension d'entrée par son. */
+export function validerNote(note) {
+  const mal = (m) => refus('CONFIGURATION', `note apprise mal formée : ${m}`);
+  if (note === null || typeof note !== 'object') mal('un objet est attendu');
+  if (typeof note.nom !== 'string' || !note.nom) mal('nom');
+  if (!Array.isArray(note.phonemes) || !note.phonemes.length) mal('phonemes');
+  const d = NB_TRAITS + ETATS.length + 1 + note.phonemes.length;
+  const ph = note.phoneme ?? {};
+  if (!nombres(ph.moy, d) || !nombres(ph.ect, d)) mal(`phoneme.moy et phoneme.ect : ${d} valeurs attendues`);
+  if (ph.modele === 'reseau') {
+    const c = ph.couches;
+    if (!Array.isArray(c) || !c.length) mal('phoneme.couches');
+    let entree = d;
+    c.forEach(([w, b], k) => {
+      if (!Array.isArray(b) || !b.length || !matrice(w, b.length, entree) || !nombres(b, b.length)) mal(`couche ${k}`);
+      entree = b.length;
+    });
+    if (entree !== 1) mal('la dernière couche doit rendre une note');
+  } else if (ph.modele === 'ridge') {
+    if (!nombres(ph.ridge, d + 1)) mal('phoneme.ridge');
+  } else mal('phoneme.modele : reseau ou ridge');
+  const phr = note.phrase ?? {};
+  if (!nombres(phr.moy, NB_AGREGATS) || !nombres(phr.ect, NB_AGREGATS) || !nombres(phr.ridge, NB_AGREGATS + 1)) mal('phrase');
+  const s = note.seuils ?? {};
+  if (!Number.isFinite(s.phrase) || !Number.isFinite(s.phoneme)) mal('seuils');
+  return d;
+}
+
+const lineaire = (w, b, x) => b.map((bi, i) => { let s = bi; const r = w[i]; for (let k = 0; k < x.length; k++) s += r[k] * x[k]; return s; });
+const ridge = (w, x) => { let s = w[w.length - 1]; for (let k = 0; k < x.length; k++) s += w[k] * x[k]; return s; };
+
+function vecteur(note, index, p, etat, traits) {
+  const t = traits.slice();
+  t[5] = Math.log1p(t[5]);
+  t[6] = Math.log1p(t[6]);
+  const un = new Array(note.phonemes.length).fill(0);
+  const b = p.endsWith('0') ? p.slice(0, -1) : p;
+  if (index.has(b)) un[index.get(b)] = 1;
+  const x = [...t, ...ETATS.map((s) => (etat === s ? 1 : 0)), p.endsWith('0') ? 1 : 0, ...un];
+  return x.map((v, k) => (v - note.phoneme.moy[k]) / note.phoneme.ect[k]);
+}
+
+function centile(tries, q) {
+  const pos = (tries.length - 1) * q, bas = Math.floor(pos), haut = Math.ceil(pos);
+  return tries[bas] + (tries[haut] - tries[bas]) * (pos - bas);
+}
+
+function agregats(notes, etats, nEntendus, duree) {
+  const n = notes.map((v) => Math.min(2, Math.max(0, v)));
+  const moy = n.reduce((a, b) => a + b, 0) / n.length;
+  const ecart = Math.sqrt(n.reduce((a, b) => a + (b - moy) ** 2, 0) / n.length);
+  const part = (f) => n.filter(f).length / n.length;
+  const total = Math.max(1, etats.length);
+  return [moy, Math.min(...n), ecart, centile([...n].sort((a, b) => a - b), 0.1), part((v) => v < 1), part((v) => v < 1.5),
+    etats.filter((e) => e === 'juste').length / etats.length, nEntendus / total, duree / total];
+}
+
+const indexDe = new WeakMap();
+/**
+ * Applique la note apprise. Notes brutes, non bornées (la parité avec Python se juge sur elles) ; le service les borne.
+ * @param {object} note  poids (NOTE_APPRISE_1)
+ * @param {{ phonemes: string[], etats: string[], traits: number[][], nEntendus: number, duree: number }} e
+ * @returns {{ notes: number[], note: number }}
+ */
+export function appliquerNote(note, { phonemes, etats, traits, nEntendus, duree }) {
+  if (!indexDe.has(note)) { validerNote(note); indexDe.set(note, new Map(note.phonemes.map((p, i) => [p, i]))); }
+  const index = indexDe.get(note);
+  const notes = phonemes.map((p, i) => {
+    let x = vecteur(note, index, p, etats[i], traits[i]);
+    if (note.phoneme.modele === 'ridge') return ridge(note.phoneme.ridge, x);
+    note.phoneme.couches.forEach(([w, b], k) => {
+      x = lineaire(w, b, x);
+      if (k < note.phoneme.couches.length - 1) x = x.map((v) => (v > 0 ? v : 0));
+    });
+    return x[0];
+  });
+  const a = agregats(notes, etats, nEntendus, duree).map((v, k) => (v - note.phrase.moy[k]) / note.phrase.ect[k]);
+  return { notes, note: ridge(note.phrase.ridge, a) };
+}

package/src/lib/resistances.js

@@ -0,0 +1,25 @@
+// @mostajs/prononciation — les sons qui résistent, sur un ensemble de résultats (la vue de classe).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+
+/**
+ * @param {object[]} resultats  des résultats de evaluer()
+ * @param {{ minEssais?: number }} [o]  un son vu moins de minEssais fois est écarté
+ * @returns {{ phoneme: string, essais: number, echecs: number, taux: number }[]}  du plus résistant au moins résistant
+ */
+export function resistances(resultats, { minEssais = 1 } = {}) {
+  const t = new Map();
+  for (const r of resultats ?? []) {
+    for (const m of r?.mots ?? []) {
+      for (const ph of m.phonemes ?? []) {
+        const c = t.get(ph.attendu) ?? { phoneme: ph.attendu, essais: 0, echecs: 0 };
+        c.essais += 1;
+        if (ph.aReprendre) c.echecs += 1;
+        t.set(ph.attendu, c);
+      }
+    }
+  }
+  return [...t.values()]
+    .filter((c) => c.essais >= minEssais)
+    .map((c) => ({ ...c, taux: c.echecs / c.essais }))
+    .sort((a, b) => b.taux - a.taux || b.essais - a.essais || a.phoneme.localeCompare(b.phoneme));
+}

package/src/lib/texte.js

@@ -0,0 +1,11 @@
+// @mostajs/prononciation — découpe d'un texte en mots. Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+
+/** Texte → mots en majuscules : ponctuation ôtée, apostrophes internes gardées (I'D, DON'T), traits d'union coupés. */
+export function motsDe(texte) {
+  return String(texte ?? '')
+    .replace(/[’‘ʼ`]/g, "'")
+    .split(/[^\p{L}\p{N}']+/u)
+    .map((m) => m.replace(/^'+|'+$/g, ''))
+    .filter(Boolean)
+    .map((m) => m.toUpperCase());
+}