ASPIC/micro_test.js

/**
 * ASPIC — micro_test.js
 *
 * Outil de mise au point interne (3 septembre 2026, demande explicite de
 * Jean-Marc) : PAS un futur module utilisateur. Sert uniquement à
 * constituer une banque de dictées réelles (table ASP_DicteesTest, thème
 * "Gestion des Contacts") pour préparer, plus tard, la conception des
 * règles d'interprétation du pilotage vocal — voir réflexions
 * stratégiques et le commentaire d'en-tête de dictees_test.php.
 *
 * Chargé À LA PLACE de micro.js sur ecran_fond.html, le temps de cette
 * phase de mise au point (voir le commentaire dédié dans ecran_fond.html,
 * autour de #micro-desk) — micro.js (le vrai pilotage : agents nommés,
 * mot déclencheur, mode notation) reste totalement inchangé et continue de
 * tourner normalement sur liste_contacts.html. Pour reconnecter le vrai
 * pilotage sur le micro de l'écran de fond une fois cette phase terminée :
 * remettre <script src="micro.js"> à la place de
 * <script src="micro_test.js"> en bas d'ecran_fond.html, rien d'autre à
 * défaire — ce fichier-ci n'est jamais modifié pour ça.
 *
 * Différences volontaires avec micro.js, toutes actées avec Jean-Marc :
 * - Aucun mot déclencheur : le clic sur le micro fait déjà office de
 *   signal explicite de début (contrairement à l'écoute ambiante continue
 *   de micro.js, qui doit filtrer une conversation de fond d'une vraie
 *   commande — ce problème ne se pose pas ici, on sait que tout ce qui est
 *   dit après le clic est un essai volontaire).
 * - Aucune notion d'agent, de mode notation, de phrase de clôture : chaque
 *   énoncé séparé par un silence est une ligne indépendante, enregistrée
 *   immédiatement dès qu'il est reconnu — la segmentation elle-même n'est
 *   pas gérée à la main ici, c'est le moteur de reconnaissance du
 *   navigateur qui la fait (un événement "result" avec isFinal=true
 *   correspond déjà à "ce qui a été dit avant une pause" ; on ne choisit
 *   pas la durée exacte de cette pause, elle est interne au navigateur —
 *   même mécanisme que celui déjà éprouvé en production dans micro.js).
 *   **Exception : le "mode adresse", voir plus bas.**
 * - Restitution au fur et à mesure dans une fenêtre dédiée (fond noir,
 *   texte blanc, défilement) : la ligne en cours s'affiche pendant la
 *   dictée (interimResults activé, contrairement à micro.js) puis se fige
 *   et se sauvegarde dès que le silence est détecté par le navigateur ;
 *   une nouvelle ligne en cours démarre aussitôt après.
 * - Aucune suppression possible depuis l'écran, y compris pour un essai
 *   raté (décision explicite de Jean-Marc, 3 septembre 2026) : un post-it
 *   raté fera aussi partie de la vraie vie des futurs utilisateurs, la
 *   banque de tests doit refléter ça dès maintenant plutôt que ne garder
 *   que les essais réussis.
 * - Fenêtre ouverte à chaque ouverture du micro, vidée à chaque fermeture
 *   (elle ne conserve donc rien visuellement d'une session à l'autre — la
 *   table ASP_DicteesTest, elle, continue évidemment d'accumuler tous les
 *   essais, la fenêtre n'est qu'un retour visuel immédiat).
 *
 * Reprend, pour la robustesse, le même squelette que micro.js pour le
 * redémarrage silencieux du moteur (qui peut s'arrêter tout seul sans que
 * l'utilisateur l'ait demandé) et la coupure automatique après inactivité
 * prolongée (même prudence de confidentialité que celle qui avait conduit
 * à cet ajout dans micro.js — voir son commentaire d'en-tête) — sans
 * dépendre de micro.js lui-même : ce fichier est volontairement autonome et
 * plus simple, pour ne jamais risquer de contaminer le vrai pilotage avec
 * de la logique de test jetable.
 *
 * ---------------------------------------------------------------------
 * AJOUT DU 3 SEPTEMBRE 2026 (soirée) — "Mode adresse" (email / URL).
 * ---------------------------------------------------------------------
 * Origine : essais réels de Jean-Marc montrant que la dictée d'une adresse
 * mail échoue très souvent (voir réflexions stratégiques). Deux causes
 * distinctes identifiées à partir d'un export réel de ASP_DicteesTest :
 *
 * 1. Le mot "point" (et "tiret", "arobase", "tiret du bas"...) n'est
 *    converti en symbole ("." "-" "@" "_") que de façon incohérente par le
 *    moteur gratuit du navigateur — parfois converti, parfois laissé en
 *    toutes lettres, parfois avalé. "tiret" est en plus régulièrement
 *    confondu avec le verbe "tirer" (homophone). Un problème de
 *    *vocabulaire*, rattrapable par un dictionnaire de conversion.
 * 2. Le moteur découpe une même adresse dictée en plusieurs lignes
 *    indépendantes (plusieurs événements isFinal) sans que la durée du
 *    silence permette de distinguer fiablement "il continue la même
 *    adresse" de "il change de sujet" (des écarts de 3-4 secondes
 *    s'observent dans les deux cas sur le corpus réel). Un problème de
 *    *segmentation*, qu'un dictionnaire seul ne peut pas résoudre.
 *
 * Le "mode adresse" répond aux deux à la fois en réutilisant le principe
 * déjà éprouvé du mode notation de micro.js (ouverture/clôture explicite)
 * mais ici au clic plutôt qu'à la phrase, pour ne pas dépendre d'un mot
 * de clôture qui pourrait lui-même être mal reconnu :
 * - Activé via le bouton "Mode adresse" de la fenêtre de test.
 * - Tant qu'il est actif, chaque fragment reconnu (isFinal) est empilé
 *   dans un buffer au lieu d'être enregistré comme une ligne indépendante
 *   — la segmentation du moteur n'a donc plus d'importance.
 * - Le bouton "Valider" (ou la désactivation du mode) clôt le buffer :
 *   les fragments sont concaténés, passés à normaliserTexteAdresse() qui
 *   applique le dictionnaire de conversion et retire les espaces
 *   restants (une adresse mail/URL n'en contient jamais), puis le résultat
 *   est comparé à une forme attendue (email ou domaine) pour un simple
 *   retour visuel (vert/orange) — indicatif seulement, n'empêche jamais
 *   l'enregistrement (cohérent avec la règle "aucun essai raté supprimé").
 * - Le texte brut (tel que dicté, fragments concaténés) ET le texte
 *   normalisé sont envoyés à dictees_test.php et conservés tous les deux
 *   (DCT_Texte / DCT_TexteNormalise) — rien n'écrase la matière brute déjà
 *   actée comme précieuse pour la suite ; DCT_TexteNormalise est une
 *   colonne en plus, NULL pour toutes les lignes hors "mode adresse".
 *   ⚠️ Nécessite l'ajout manuel de cette colonne en base avant déploiement
 *   (voir le message livré avec ce fichier — Claude n'exécute jamais de
 *   modification de schéma lui-même, cf. réflexions stratégiques).
 * - Un compteur simple (conforme / non conforme) s'affiche dans la fenêtre
 *   pour donner une lecture immédiate du taux d'échec au fil des essais.
 *
 * Portée volontairement limitée à ce problème précis : aucune tentative
 * de deviner where s'arrête une adresse dans un flux libre, aucune
 * interprétation sémantique — juste un buffer explicite et un dictionnaire
 * de conversion, dans le même esprit "pas de sur-ingénierie" que le reste
 * du projet.
 *
 * ---------------------------------------------------------------------
 * CORRECTIF DU 3 SEPTEMBRE 2026 (fin de soirée) — fenêtre effacée à
 * chaque redémarrage automatique du moteur (bug préexistant, pas lié au
 * "mode adresse" ci-dessus).
 * ---------------------------------------------------------------------
 * `ouvrirFenetre()` (qui vide entièrement le contenu affiché) était
 * appelée à chaque événement "start" du moteur de reconnaissance — or ce
 * moteur se coupe et se relance tout seul en silence après une pause
 * (comportement voulu, voir plus haut), ce qui déclenche un nouvel
 * événement "start" à chaque fois. Avec des dictées enchaînées, ça ne se
 * voyait pas ; avec une dictée hésitante (adresse mail, beaucoup de
 * silences de réflexion), les redémarrages deviennent fréquents et la
 * fenêtre se vide sans cesse avant d'avoir pu être lue — signalé par
 * l'indicateur micro de Chrome qui clignote en continu. Corrigé en ne
 * réinitialisant la fenêtre qu'au tout premier "start" suivant un clic
 * utilisateur réel (`ouvertureInitiale`), jamais lors d'une relance
 * automatique. Un bloc de diagnostic temporaire (`DIAGNOSTIC_ACTIF`,
 * fonction logDiag) a été ajouté en parallèle pour visualiser les cycles
 * démarrage/arrêt/erreur en direct dans la fenêtre — à retirer une fois
 * le comportement confirmé stable.
 *
 * Ce diagnostic a révélé un second problème, plus grave : dans certaines
 * conditions le moteur enchaîne des centaines de redémarrages par seconde
 * (des "aborted" apparaissent parmi les erreurs), sans aucun frein côté
 * code d'origine (relance immédiate à chaque "end", aucun délai). Ajout
 * d'un coupe-circuit (`cyclesRapidesConsecutifs` / `MAX_CYCLES_RAPIDES`) :
 * au-delà de 5 redémarrages consécutifs en moins de 800 ms, l'écoute
 * s'arrête proprement avec un message, plutôt que de boucler indéfiniment
 * et de noyer la fenêtre de diagnostic.
 */
(function(){
  "use strict";

  const bouton = document.getElementById("micro-desk");
  if(!bouton) return; // ce script ne concerne que l'écran de fond

  const ReconnaissanceVocale = window.SpeechRecognition || window.webkitSpeechRecognition;

  if(!ReconnaissanceVocale){
    bouton.title = "Reconnaissance vocale non disponible sur ce navigateur";
    return;
  }

  const reconnaissance = new ReconnaissanceVocale();
  reconnaissance.lang = "fr-FR";
  reconnaissance.continuous = true;
  reconnaissance.interimResults = true; // restitution au fur et à mesure, demandée par Jean-Marc
  reconnaissance.maxAlternatives = 1;

  let ecouteVoulue = false;
  let erreurBloquante = false;

  // Coupure automatique après inactivité — même prudence que micro.js
  // (voir son commentaire d'en-tête sur l'incident de confidentialité qui
  // avait motivé cet ajout) : un outil de test resté ouvert par oubli ne
  // doit pas non plus continuer à envoyer l'audio ambiant indéfiniment.
  const DUREE_INACTIVITE_MS = 10 * 60 * 1000; // 10 minutes
  let minuteurInactivite = null;

  function reinitialiserMinuteurInactivite(){
    if(minuteurInactivite) clearTimeout(minuteurInactivite);
    minuteurInactivite = setTimeout(couperPourInactivite, DUREE_INACTIVITE_MS);
  }

  function arreterMinuteurInactivite(){
    if(minuteurInactivite){
      clearTimeout(minuteurInactivite);
      minuteurInactivite = null;
    }
  }

  function couperPourInactivite(){
    minuteurInactivite = null;
    if(!ecouteVoulue) return; // déjà refermé entre-temps
    ecouteVoulue = false;
    reconnaissance.stop();
  }

  // -------- Mode adresse : dictionnaire de conversion --------
  // Volontairement limité aux mots utiles à une adresse mail/URL dictée en
  // français — jamais appliqué en dehors du "mode adresse" (voir plus bas),
  // pour ne jamais risquer de transformer un "point" ou un "tiret" dit dans
  // une phrase normale ailleurs dans l'outil.
  const REMPLACEMENTS_ADRESSE = [
    [/\btiret du bas\b/g, "_"],
    [/\btiret bas\b/g, "_"],
    [/\bunderscore\b/g, "_"],
    [/\barobase\b/g, "@"],
    [/\barobas\b/g, "@"],
    [/\btrait d'union\b/g, "-"],
    // "tirer" (verbe) est une confusion acoustique fréquente avec "tiret"
    // dans ce contexte précis (voir export du 3 septembre) — alias
    // volontairement restreint au mode adresse, jamais appliqué ailleurs.
    [/\btiret\b/g, "-"],
    [/\btirer\b/g, "-"],
    [/\bpoint\b/g, "."]
  ];

  function normaliserTexteAdresse(brut){
    let t = " " + brut.toLowerCase().trim() + " ";
    REMPLACEMENTS_ADRESSE.forEach(function(paire){
      t = t.replace(paire[0], paire[1]);
    });
    // Une adresse mail ou une URL ne contient jamais d'espace : tout espace
    // restant à ce stade vient de la reconnaissance vocale elle-même
    // (silences entre syllabes/mots), pas d'une intention de l'utilisateur.
    t = t.replace(/\s+/g, "");
    return t;
  }

  const FORME_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  const FORME_DOMAINE = /^[a-z0-9-]+(\.[a-z0-9-]+)+$/;

  function evaluerConformite(normalise){
    if(FORME_EMAIL.test(normalise)) return {ok:true, categorie:"email"};
    if(FORME_DOMAINE.test(normalise)) return {ok:true, categorie:"domaine"};
    return {ok:false, categorie:null};
  }

  // -------- Fenêtre de restitution --------
  // Construite ici plutôt que dans ecran_fond.html, pour que ce fichier
  // reste entièrement autonome — le retirer (remettre micro.js) ne laisse
  // aucune trace HTML/CSS à nettoyer côté page hôte.
  let fenetre = null;
  let zoneLignes = null;
  let ligneEnCours = null;
  let boutonModeAdresse = null;
  let boutonValider = null;
  let zoneBuffer = null;
  let compteurEl = null;

  // État du mode adresse
  let modeAdresse = false;
  let bufferFragments = []; // fragments isFinal accumulés depuis l'activation/le dernier "Valider"
  let compteurConforme = 0;
  let compteurNonConforme = 0;

  function construireFenetre(){
    if(fenetre) return;

    const style = document.createElement("style");
    style.textContent =
      "#fenetre-dictees-test{position:fixed;top:8%;left:50%;" +
      "transform:translateX(-50%);width:min(560px,80vw);height:min(460px,72vh);" +
      "background:#000;border:1px solid #333;border-radius:6px;" +
      "box-shadow:0 10px 40px rgba(0,0,0,.6);z-index:950;display:none;" +
      "flex-direction:column;overflow:hidden;" +
      "font-family:'Courier New',Consolas,monospace;}" +
      "#fenetre-dictees-test.visible{display:flex;}" +
      "#fenetre-dictees-test .entete{color:#888;font-size:11px;" +
      "padding:6px 10px;border-bottom:1px solid #222;flex:none;}" +
      "#fenetre-dictees-test .controles{display:flex;align-items:center;" +
      "gap:8px;padding:6px 10px;border-bottom:1px solid #222;flex:none;}" +
      "#fenetre-dictees-test .controles button{font:inherit;font-size:12px;" +
      "background:#1a1a1a;color:#ccc;border:1px solid #444;border-radius:4px;" +
      "padding:4px 10px;cursor:pointer;}" +
      "#fenetre-dictees-test .controles button.actif{background:#2a4d2a;" +
      "color:#bdf7bd;border-color:#3a6d3a;}" +
      "#fenetre-dictees-test .controles button:disabled{opacity:.4;" +
      "cursor:default;}" +
      "#fenetre-dictees-test .controles .compteur{margin-left:auto;" +
      "color:#777;font-size:11px;}" +
      "#fenetre-dictees-test .buffer{padding:6px 10px;color:#ffd76a;" +
      "font-size:13px;border-bottom:1px solid #222;min-height:1.4em;" +
      "flex:none;white-space:pre-wrap;}" +
      "#fenetre-dictees-test .lignes{flex:1;overflow-y:auto;padding:8px 10px;" +
      "color:#fff;font-size:14px;line-height:1.6;white-space:pre-wrap;}" +
      "#fenetre-dictees-test .lignes .en-cours{color:#8a8a8a;font-style:italic;}" +
      "#fenetre-dictees-test .lignes .erreur{color:#e14a5c;}" +
      "#fenetre-dictees-test .lignes .adresse-ok{color:#7be07b;}" +
      "#fenetre-dictees-test .lignes .adresse-ko{color:#e0a95a;}" +
      "#fenetre-dictees-test .lignes .adresse-brut{color:#777;font-size:12px;}" +
      "#fenetre-dictees-test .lignes .diag{color:#6ab8ff;font-size:11px;}";
    document.head.appendChild(style);

    fenetre = document.createElement("div");
    fenetre.id = "fenetre-dictees-test";
    fenetre.innerHTML =
      '<div class="entete">Banque de dictées — Gestion des Contacts ' +
      '(outil de mise au point, non destiné aux utilisateurs finaux)</div>' +
      '<div class="controles">' +
        '<button type="button" class="btn-mode-adresse">Mode adresse : OFF</button>' +
        '<button type="button" class="btn-valider" disabled>Valider</button>' +
        '<span class="compteur"></span>' +
      '</div>' +
      '<div class="buffer"></div>' +
      '<div class="lignes"></div>';
    document.body.appendChild(fenetre);
    zoneLignes = fenetre.querySelector(".lignes");
    zoneBuffer = fenetre.querySelector(".buffer");
    boutonModeAdresse = fenetre.querySelector(".btn-mode-adresse");
    boutonValider = fenetre.querySelector(".btn-valider");
    compteurEl = fenetre.querySelector(".compteur");

    boutonModeAdresse.addEventListener("click", function(){
      if(modeAdresse){
        // Désactivation : on ne perd jamais un buffer en cours, on le
        // valide d'abord (même logique que le bouton "Valider").
        if(bufferFragments.length) validerBufferAdresse();
        modeAdresse = false;
        boutonModeAdresse.textContent = "Mode adresse : OFF";
        boutonModeAdresse.classList.remove("actif");
        boutonValider.disabled = true;
        afficherBuffer();
      } else {
        modeAdresse = true;
        boutonModeAdresse.textContent = "Mode adresse : ON";
        boutonModeAdresse.classList.add("actif");
        boutonValider.disabled = false;
      }
    });

    boutonValider.addEventListener("click", function(){
      validerBufferAdresse();
    });
  }

  function majCompteur(){
    if(!compteurEl) return;
    const total = compteurConforme + compteurNonConforme;
    compteurEl.textContent = total
      ? "adresses : " + compteurConforme + "/" + total + " conformes"
      : "";
  }

  function afficherBuffer(){
    if(!zoneBuffer) return;
    zoneBuffer.textContent = modeAdresse
      ? "[mode adresse] " + bufferFragments.join(" ")
      : "";
  }

  function validerBufferAdresse(){
    const brutConcatene = bufferFragments.join(" ").trim();
    bufferFragments = [];
    afficherBuffer();
    if(!brutConcatene) return;

    const normalise = normaliserTexteAdresse(brutConcatene);
    const conformite = evaluerConformite(normalise);

    if(conformite.ok) compteurConforme++; else compteurNonConforme++;
    majCompteur();

    const ligneBrut = document.createElement("div");
    ligneBrut.className = "adresse-brut";
    ligneBrut.textContent = "brut : " + brutConcatene;
    zoneLignes.appendChild(ligneBrut);

    const ligneNormalisee = document.createElement("div");
    ligneNormalisee.className = conformite.ok ? "adresse-ok" : "adresse-ko";
    ligneNormalisee.textContent = "→ " + normalise +
      (conformite.ok ? " (" + conformite.categorie + " reconnu)" : " (forme non reconnue)");
    zoneLignes.appendChild(ligneNormalisee);
    zoneLignes.scrollTop = zoneLignes.scrollHeight;

    enregistrerDictee(brutConcatene, normalise);
    reinitialiserMinuteurInactivite();
  }

  function ouvrirFenetre(){
    construireFenetre();
    zoneLignes.innerHTML = "";
    ligneEnCours = null;
    bufferFragments = [];
    compteurConforme = 0;
    compteurNonConforme = 0;
    majCompteur();
    afficherBuffer();
    fenetre.classList.add("visible");
  }

  function fermerFenetre(){
    if(fenetre) fenetre.classList.remove("visible");
    if(zoneLignes) zoneLignes.innerHTML = "";
    ligneEnCours = null;
    bufferFragments = [];
  }

  function afficherEnCours(texte){
    if(!zoneLignes) return;
    if(!ligneEnCours){
      ligneEnCours = document.createElement("div");
      ligneEnCours.className = "en-cours";
      zoneLignes.appendChild(ligneEnCours);
    }
    ligneEnCours.textContent = texte;
    zoneLignes.scrollTop = zoneLignes.scrollHeight;
  }

  function figerLigne(texte){
    if(!zoneLignes) return;
    if(!ligneEnCours){
      ligneEnCours = document.createElement("div");
      zoneLignes.appendChild(ligneEnCours);
    }
    ligneEnCours.className = "";
    ligneEnCours.textContent = texte;
    ligneEnCours = null; // la prochaine ligne (en cours ou figée) en recrée une
    zoneLignes.scrollTop = zoneLignes.scrollHeight;
  }

  function afficherErreur(texte){
    if(!zoneLignes) return;
    const div = document.createElement("div");
    div.className = "erreur";
    div.textContent = texte;
    zoneLignes.appendChild(div);
    zoneLignes.scrollTop = zoneLignes.scrollHeight;
  }

  // -------- DIAGNOSTIC TEMPORAIRE (3 septembre 2026, soir) --------
  // Ajouté uniquement pour comprendre pourquoi rien ne s'affiche chez
  // Jean-Marc (indicateur micro de Chrome qui clignote sans arrêt — signe
  // possible d'un cycle démarrage/arrêt en boucle rapide). Affiche TOUT,
  // y compris les événements normalement filtrés (ex. "no-speech"), avec
  // horodatage précis. À RETIRER une fois le problème identifié — ce n'est
  // pas un affichage destiné à rester.
  const DIAGNOSTIC_ACTIF = true;
  let diagCompteurDemarrages = 0;

  function logDiag(texte){
    if(!DIAGNOSTIC_ACTIF || !zoneLignes) return;
    const maintenant = new Date();
    const heure = maintenant.toLocaleTimeString("fr-FR") + "." +
      String(maintenant.getMilliseconds()).padStart(3, "0");
    const div = document.createElement("div");
    div.className = "diag";
    div.textContent = "[diag " + heure + "] " + texte;
    zoneLignes.appendChild(div);
    zoneLignes.scrollTop = zoneLignes.scrollHeight;
  }

  // -------- Enregistrement --------
  // Aucune interprétation, aucun filtrage : tout ce qui est capté part vers
  // dictees_test.php, essai raté compris (décision de Jean-Marc, voir
  // commentaire d'en-tête). En mode adresse, le texte normalisé est envoyé
  // en plus (jamais à la place) du texte brut — voir commentaire d'en-tête
  // du 3 septembre sur DCT_TexteNormalise.
  function enregistrerDictee(texte, texteNormalise){
    const corps = {texte: texte};
    if(texteNormalise) corps.texteNormalise = texteNormalise;
    fetch("dictees_test.php", {
      method: "POST",
      headers: {"Content-Type": "application/json"},
      body: JSON.stringify(corps)
    }).then(function(reponse){
      if(!reponse.ok) throw new Error("HTTP " + reponse.status);
    }).catch(function(){
      afficherErreur("(non enregistré — erreur de connexion à dictees_test.php)");
    });
  }

  // Vrai uniquement pour le tout prochain événement "start" déclenché par un
  // clic utilisateur réel — jamais pour une relance automatique après coupure
  // silencieuse (voir diagnostic du 3 septembre, soir : la fenêtre entière
  // était effacée à CHAQUE redémarrage du moteur, pas seulement à l'ouverture
  // volontaire, ce qui devenait très visible dès que les silences — donc les
  // redémarrages — se multipliaient pendant une dictée hésitante).
  let ouvertureInitiale = false;

  function passerEnEcoute(){
    bouton.classList.add("ecoute");
    bouton.title = "Le micro est ouvert (banque de dictées contacts — outil de mise au point)";
    if(ouvertureInitiale){
      ouvertureInitiale = false;
      ouvrirFenetre(); // construit/affiche et réinitialise réellement, une seule fois
    } else if(fenetre){
      fenetre.classList.add("visible"); // relance automatique : rien n'est effacé
    }
    reinitialiserMinuteurInactivite();
  }

  function revenirAuRepos(){
    ecouteVoulue = false;
    arreterMinuteurInactivite();
    bouton.classList.remove("ecoute");
    bouton.title = "Le micro est inactif";
    fermerFenetre();
  }

  bouton.addEventListener("click", function(){
    if(ecouteVoulue){
      // Fermeture demandée : le retour au repos (et la fermeture de la
      // fenêtre) se fait via l'événement "end" qui va suivre.
      ecouteVoulue = false;
      reconnaissance.stop();
      return;
    }
    ecouteVoulue = true;
    erreurBloquante = false;
    ouvertureInitiale = true;
    try{
      reconnaissance.start();
    }catch(erreur){
      ecouteVoulue = false;
      ouvertureInitiale = false;
      afficherErreur("Impossible de démarrer le micro (" + erreur.name + ").");
    }
  });

  // Coupe-circuit anti-boucle (3 septembre 2026, fin de soirée) : le
  // diagnostic en direct a montré des centaines de redémarrages par
  // seconde dans certaines conditions (service en défaut, ou toute autre
  // cause empêchant le moteur de rester ouvert) — sans aucun frein, le code
  // d'origine relançait immédiatement à chaque "end", ce qui peut boucler
  // indéfiniment et rendre la fenêtre illisible. Si plusieurs redémarrages
  // se suivent anormalement vite, on arrête proprement plutôt que de
  // continuer à boucler en silence.
  let dernierDemarrageHorodatage = 0;
  let cyclesRapidesConsecutifs = 0;
  const SEUIL_CYCLE_RAPIDE_MS = 800;
  const MAX_CYCLES_RAPIDES = 5;

  reconnaissance.addEventListener("start", function(){
    diagCompteurDemarrages++;
    dernierDemarrageHorodatage = Date.now();
    passerEnEcoute();
    logDiag("start #" + diagCompteurDemarrages);
  });

  reconnaissance.addEventListener("end", function(){
    logDiag("end (ecouteVoulue=" + ecouteVoulue + ", erreurBloquante=" + erreurBloquante + ")");
    if(ecouteVoulue && !erreurBloquante){
      const ecoule = Date.now() - dernierDemarrageHorodatage;
      cyclesRapidesConsecutifs = (ecoule < SEUIL_CYCLE_RAPIDE_MS) ? (cyclesRapidesConsecutifs + 1) : 0;

      if(cyclesRapidesConsecutifs >= MAX_CYCLES_RAPIDES){
        erreurBloquante = true;
        revenirAuRepos();
        afficherErreur("Le micro redémarre en boucle anormalement vite (" +
          cyclesRapidesConsecutifs + " fois de suite en moins de " +
          SEUIL_CYCLE_RAPIDE_MS + " ms) — arrêt automatique pour ne pas " +
          "boucler indéfiniment. Attends quelques secondes puis rouvre le micro.");
        return;
      }

      // Le moteur s'est arrêté tout seul (silence prolongé, limite interne
      // du navigateur...) alors que l'écoute reste voulue : relance
      // invisible pour l'utilisateur, même principe que micro.js.
      try{
        reconnaissance.start();
      }catch(erreur){
        revenirAuRepos();
        afficherErreur("Le micro s'est arrêté et n'a pas pu redémarrer automatiquement.");
      }
      return;
    }
    revenirAuRepos();
  });

  reconnaissance.addEventListener("result", function(evenement){
    const dernier = evenement.results[evenement.results.length - 1];
    const texte = dernier[0].transcript.trim();
    if(!texte) return;

    if(dernier.isFinal){
      if(modeAdresse){
        // Accumulation dans le buffer plutôt qu'enregistrement immédiat —
        // voir commentaire d'en-tête du 3 septembre sur le "mode adresse".
        bufferFragments.push(texte);
        afficherBuffer();
      } else {
        // Silence détecté par le moteur : la ligne se fige et s'enregistre
        // immédiatement, essai raté ou non — aucun jugement porté ici sur
        // la qualité du texte reconnu.
        figerLigne(texte);
        enregistrerDictee(texte, null);
      }
      reinitialiserMinuteurInactivite();
    } else {
      // Restitution au fur et à mesure, avant que le silence ne fige la
      // ligne — demande explicite de Jean-Marc.
      if(modeAdresse){
        zoneBuffer.textContent = "[mode adresse] " +
          (bufferFragments.concat([texte])).join(" ");
      } else {
        afficherEnCours(texte);
      }
    }
  });

  reconnaissance.addEventListener("error", function(evenement){
    logDiag("error : " + evenement.error);
    const messagesBloquants = {
      "not-allowed": "Micro refusé — vérifie l'autorisation dans le navigateur.",
      "service-not-allowed": "Micro refusé — vérifie l'autorisation dans le navigateur.",
      "audio-capture": "Aucun micro détecté."
    };
    if(messagesBloquants[evenement.error]){
      erreurBloquante = true;
      afficherErreur(messagesBloquants[evenement.error]);
      return;
    }
    // "no-speech" est un bruit normal entre deux essais (silence pendant
    // qu'on réfléchit à la phrase suivante) : pas affiché, pour ne pas
    // polluer la fenêtre de tests — l'événement "end" qui suit relance de
    // toute façon l'écoute tant qu'elle reste voulue.
    if(evenement.error === "network"){
      afficherErreur("(problème réseau, nouvelle tentative...)");
    }
  });
})();