discovery-media-player 0.1.55 → 0.1.57

package/context/storage.js

@@ -176,7 +176,9 @@ async function lireDepuis(fh, stat, cible, range) {
   const buf = Buffer.alloc(fin - debut + 1);
   const { bytesRead } = await fh.read(buf, 0, buf.length, debut);
   const corps = bytesRead === buf.length ? buf : buf.subarray(0, bytesRead);
-  const entetes = { "content-type": type };
+  // La taille est connue d'un `stat` sur le descripteur ouvert : l'annoncer permet au relais de
+  // la refuser avant d'allouer, et à la visionneuse d'afficher une progression.
+  const entetes = { "content-type": type, "content-length": String(corps.length) };
   if (statut === 206) entetes["content-range"] = `bytes ${debut}-${fin}/${total}`;
   return reponse(statut, entetes, corps);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "Self-hosted document viewer: per-recipient tracked links, reading analytics, live presentation. The core knows nothing about the application hosting it — everything it borrows arrives through an injected context.",
   "keywords": [
     "pdf-viewer",
@@ -62,7 +62,8 @@
     "lint:fix": "eslint bin context server src build --fix",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build && npm test",
-    "test:e2e": "vitest run --config vitest.e2e.config.mjs"
+    "test:e2e": "vitest run --config vitest.e2e.config.mjs",
+    "test:base": "vitest run --config vitest.base.config.mjs"
   },
   "engines": {
     "node": ">=22"

package/server/handler.js

@@ -4,6 +4,8 @@
 //  - GET  /doc/:slug?file=1     → stream le PDF depuis le Storage (MÊME ORIGINE → pas de souci CORS pour pdf.js)
 //  - POST /api/doc {slug,event…}→ journalise un événement (open / page / heartbeat) — best-effort
 const crypto = require("crypto");
+const { Readable } = require("node:stream");
+const { pipeline } = require("node:stream/promises");
 const { getShareBySlug, logView, upsertSession, createReshare, sendReshareEmail, upsertInternalSession,
   createShare, revokeShare, setShareAuth, overview: docOverview, listSharesForDoc, listSessionsForDoc, internalStatsForDoc } = require("./shares");
 const { SESSION_QUOTA_PER_HOUR, PRESENT_QUOTA_PER_HOUR, PRESENT_CACHE_MS } = require("./shared.generated.js");
@@ -309,6 +311,12 @@ var Live=(function(){
   // participants, d'URL — donc du dehors. typers est le cas vif : il est alimenté par 'typing',
   // le SEUL événement qui croie encore son émetteur (cf. 0.1.30). Un objet nu retire la question
   // entière au lieu de la traiter cas par cas. (audit P1-2)
+  // ⚠️ _ordEtat, _ordChat et _filet VIVAIENT DANS connect() : disconnect(), défini ici, ne pouvait
+  // pas les atteindre. Après connect → disconnect → connect, les relectures de l'ancienne session
+  // continuaient — un spectateur qui rouvre la page doublait le trafic, et le filet de sécurité
+  // battait deux fois. On les déclare au niveau du CYCLE DE VIE : ce qui doit être arrêté doit
+  // être visible depuis l'endroit qui arrête.
+  var _ordEtat=null,_ordChat=null,_filet=null;
   var sb=null,ch=null,ME=null,SLUG=null,CONTROL=null,LOCKED=false,AUTHTOK=null,PRESENT=[],PRESNAME='',seen=Object.create(null),msgEls=Object.create(null),msgData=Object.create(null),replyCtx=null,typers=Object.create(null),pdfCache=Object.create(null),_tyT=0,_tyIv=0,_atIv=0,unread=0,autoOpened=false,_histDone=false,_phWired=false,_onMap=null,_onState=null,_peekT=0,MUTED=false;
   try{ MUTED=localStorage.getItem('3dd-present-mute')==='1'; }catch(e){}
   // Couper/rétablir les notifications du chat (cloche) : coupé = plus de ticker ni de pulse (badge silencieux gardé).
@@ -419,11 +427,23 @@ var Live=(function(){
     if(y)y.onclick=function(){close();if(onOk)onOk();};if(n)n.onclick=close;m.onclick=function(e){if(e.target===m)close();};
     document.addEventListener('keydown',key);m.classList.add('open');if(y)try{y.focus();}catch(e){}}
   function history(){fetch('/api/doc?present='+encodeURIComponent(SLUG)+'&chat=1').then(function(r){return r.json();}).then(function(d){var box=document.getElementById('chatMsgs');if(d&&d.messages&&d.messages.length){d.messages.forEach(function(m){addMsg(m);});}else if(box&&!box.children.length){box.innerHTML='<div class=chat-empty>Aucun message. Lancez la discussion.</div>';}if(d&&typeof d.locked!=='undefined')applyLock(d.locked);_histDone=true;}).catch(function(){_histDone=true;});}
-  function react(id,e){if(!ME||!id||!e)return;fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-react',slug:SLUG,msgId:+id,emoji:e,reactor:MOIREF})}).then(majDiffusee).catch(function(){});}
+  function react(id,e){if(!ME||!id||!e)return;
+    // ⚠️ ON ENVOIE L'ÉTAT VOULU, PAS « INVERSE ». Basculer n'a de sens qu'une fois : un renvoi
+    // réseau, un double-clic, une reprise de requête, et la réaction que le participant vient
+    // d'ajouter disparaît — sans aucune erreur affichée. Il voit son émoji s'allumer puis
+    // s'éteindre, recommence, et rebascule encore. Rejouer la même intention deux fois donne le
+    // même résultat qu'une fois ; c'est ce que le réseau exige.
+    var _m=msgData[id]||{},_rs=(_m.reactions&&_m.reactions[e])||[],veut=_rs.indexOf(MOIREF)<0;
+    fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-react',slug:SLUG,msgId:+id,emoji:e,reactor:MOIREF,etat:veut})}).then(majDiffusee).catch(function(){});}
   function setReply(id){var m=msgData[id];if(!m||m.deleted)return;var nm=m.author_name||'Invité';replyCtx={id:+id,name:nm,text:(m.body||'').slice(0,120)};var el=document.getElementById('chatReply');if(el){el.style.display='flex';el.innerHTML='<span class=cq><b>'+esc(nm)+'</b> '+esc((m.body||'').slice(0,80))+'</span><button id=chatReplyX title=Annuler>×</button>';var x=document.getElementById('chatReplyX');if(x)x.addEventListener('click',clearReply);}var t=document.getElementById('chatText');if(t)t.focus();}
   function clearReply(){replyCtx=null;var el=document.getElementById('chatReply');if(el){el.style.display='none';el.innerHTML='';}}
   function send(){var i=document.getElementById('chatText');var t=(i.value||'').trim();if(!t||!ME)return;if(LOCKED&&!canMod())return;i.value='';toggleSend();
-    var o={action:'present-chat',slug:SLUG,name:ME.name,email:ME.email,avatar:ME.avatar,body:t,authorToken:authToken()};
+    
+    // ⚠️ LA CLÉ EST FABRIQUÉE ICI, UNE FOIS, AVANT LE PREMIER ENVOI. Une clé tirée à chaque
+    // tentative ne servirait à rien : deux envois porteraient deux clés et passeraient tous les
+    // deux. C'est sa RÉUTILISATION au renvoi qui rend l'opération idempotente.
+    var _cle=(function(){ try{ var r=crypto.getRandomValues(new Uint8Array(12)); return Array.from(r,function(x){return x.toString(16).padStart(2,'0');}).join(''); }catch(e){ return ''; } })();
+    var o={action:'present-chat',clientKey:_cle,slug:SLUG,name:ME.name,email:ME.email,avatar:ME.avatar,body:t,authorToken:authToken()};
     if(CONTROL)o.control=CONTROL;
     if(replyCtx){o.replyTo=replyCtx.id;o.replyName=replyCtx.name;o.replyText=replyCtx.text;clearReply();}
     var h1={'Content-Type':'application/json'};var j1=accessToken();if(j1)h1.Authorization='Bearer '+j1;
@@ -605,14 +625,14 @@ var Live=(function(){
           arreter:function(){ ord.arreter(); },
         };
       }
-      var _ordEtat=relireAvec('&state=1',function(d){if(d.state)etatDuServeur(d.state);});
+      _ordEtat=relireAvec('&state=1',function(d){if(d.state)etatDuServeur(d.state);});
       // ⚠️ Exposé hors de cette fermeture : la carte vit dans un AUTRE bloc de script et doit
       // pouvoir déclencher la relecture. Même raison que window.__presAppliquerEtat — un nom
       // référencé depuis la mauvaise portée part dans un catch muet, et l'audience se fige.
       window.__presRelireEtat=function(){_ordEtat.signaler();};
       function relireEtat(){_ordEtat.signaler();}
       function relireChat(){_ordChat.signaler();}
-      var _ordChat=relireAvec('&chat=1',function(d){
+      _ordChat=relireAvec('&chat=1',function(d){
           // ⚠️ NOTIFIER CE QUI VIENT D'ARRIVER, ET SEULEMENT ÇA. 'addMsg' rend faux pour un
           // message déjà connu — la relecture ramène tout l'historique, donc sans cette condition
           // la pastille de non-lus compterait chaque message à chaque relecture. Et sans l'appel,
@@ -627,7 +647,7 @@ var Live=(function(){
       // rattrape ce cas : elle ne coûte presque rien et évite qu'une audience reste figée sur un
       // état périmé en croyant être à jour. C'est l'inverse d'une optimisation : c'est le prix de
       // la borne.
-      var _filet=setInterval(function(){_ordEtat.maintenant();_ordChat.maintenant();},25000);
+      _filet=setInterval(function(){_ordEtat.maintenant();_ordChat.maintenant();},25000);
 
       // ⚠️ LE TITRE VIENT D'ICI, PAS DE LA PRÉSENCE. La liste des participants tirait
       // « présentateur » de la charge de présence, que chacun compose lui-même : un
@@ -662,7 +682,7 @@ var Live=(function(){
       // → évite les fantômes (« je me vois deux fois » au retour). Une seule fois.
       if(!_phWired){_phWired=true;window.addEventListener('pagehide',function(){try{clearInterval(_filet);_ordEtat.arreter();_ordChat.arreter();}catch(e){}try{if(ch){ch.untrack();ch.unsubscribe();ch=null;}}catch(e){}});}
     }catch(e){}}
-  function disconnect(){try{clearInterval(_tyIv);}catch(e){}try{clearInterval(_atIv);}catch(e){}try{sendAttend();}catch(e){}try{if(ch){ch.untrack();ch.unsubscribe();ch=null;}}catch(e){}var pb=document.getElementById('presBtn');if(pb)pb.style.display='none';var cb=document.getElementById('chatBtn');if(cb)cb.style.display='none';var _fb=document.getElementById('chatFab');if(_fb)_fb.classList.remove('on');var pn=document.getElementById('chatPanel');if(pn)pn.classList.add('hidden');}
+  function disconnect(){try{clearInterval(_tyIv);}catch(e){}try{clearInterval(_atIv);}catch(e){}try{clearInterval(_filet);_filet=null;}catch(e){}try{if(_ordEtat)_ordEtat.arreter();_ordEtat=null;}catch(e){}try{if(_ordChat)_ordChat.arreter();_ordChat=null;}catch(e){}try{delete window.__presRelireEtat;}catch(e){window.__presRelireEtat=null;}try{sendAttend();}catch(e){}try{if(ch){ch.untrack();ch.unsubscribe();ch=null;}}catch(e){}var pb=document.getElementById('presBtn');if(pb)pb.style.display='none';var cb=document.getElementById('chatBtn');if(cb)cb.style.display='none';var _fb=document.getElementById('chatFab');if(_fb)_fb.classList.remove('on');var pn=document.getElementById('chatPanel');if(pn)pn.classList.add('hidden');}
   // Membre de l'équipe reconnu via la session app (MÊME ORIGINE, localStorage) → avatar + nom auto.
   // Le jeton d'acces de la session locale, quand il y en a une. C'est la SEULE chose qui prouve au
   // serveur qu'on est un membre ; 'member:true' dans la page ne prouve rien, il ne sert qu'a l'affichage.
@@ -1532,6 +1552,12 @@ async function profilDuJeton(req) {
   } catch { return null; }
 }
 
+/**
+ * Plafond du relais, en octets. Réglable par l'exploitant : un hôte qui sert des plans
+ * d'architecte n'a pas les mêmes documents qu'un hôte qui sert des notices.
+ */
+const PLAFOND_RELAIS = Number(process.env.PLAYER_MAX_RELAY_BYTES || 0) || 60 * 1024 * 1024;
+
 async function relayerFichier(res, r, disposition) {
   if (!r) { res.statusCode = 404; res.end("Fichier indisponible"); return; }
   if (!r.ok && r.status !== 206) { res.statusCode = 502; res.end("Fichier indisponible"); return; }
@@ -1539,7 +1565,28 @@ async function relayerFichier(res, r, disposition) {
   const compresse = !!r.headers.get("content-encoding");
   if (compresse && r.status === 206) { res.statusCode = 502; res.end("Fichier indisponible"); return; }
 
-  const buf = Buffer.from(await r.arrayBuffer());
+  // ⚠️ DEUX BORNES, ET LA SECONDE EST LA SEULE QUI TIENNE DEVANT UN AMONT QUI MENT.
+  //
+  // La première regarde `Content-Length` et renonce AVANT d'ouvrir le corps. C'est la seule qui
+  // puisse encore répondre 413, puisque rien n'est parti — mais elle croit l'amont sur parole : un
+  // stockage qui n'annonce rien, ou qui annonce 1 Ko et en envoie 500, passait sans être inquiété.
+  //
+  // La seconde COMPTE LES OCTETS QUI PASSENT et rompt au dépassement. Elle ne peut plus répondre
+  // 413 : les en-têtes sont partis avec le premier octet, et on ne dédit pas un en-tête déjà
+  // envoyé. Elle coupe. Le client voit un transfert interrompu — désagréable et honnête, là où
+  // l'épuisement de la mémoire emportait la fonction ENTIÈRE, donc aussi les requêtes des autres.
+  const brute = r.headers.get("content-length");
+  const annoncee = Number(brute || 0);
+  if (annoncee > PLAFOND_RELAIS) {
+    try { PLAYER.errors.capture(new Error(`relais refusé : ${annoncee} octets au-dessus du plafond de ${PLAFOND_RELAIS}`), { route: "relais" }); } catch { /* jamais bloquant */ }
+    res.statusCode = 413;
+    res.end("Fichier trop volumineux");
+    // ⚠️ Renoncer ne suffit pas : un corps jamais tiré laisse la connexion amont OUVERTE, et le
+    // pool de sockets s'épuise sur les gros fichiers — exactement la ressource qu'on protège.
+    try { if (r.body) r.body.cancel(); } catch { /* déjà refermé */ }
+    return;
+  }
+
   res.statusCode = r.status;
   const typeAmont = r.headers.get("content-type") || "application/pdf";
   const executable = TYPES_EXECUTABLES.test(typeAmont);
@@ -1555,10 +1602,53 @@ async function relayerFichier(res, r, disposition) {
   // Les bornes d'un `Content-Range` ne valent que si l'amont n'a pas compressé.
   const cr = !compresse && r.headers.get("content-range");
   if (cr) res.setHeader("Content-Range", cr);
-  res.setHeader("Content-Length", String(buf.length)); // ce qu'on envoie, jamais ce qu'on a reçu
+  // ⚠️ `fetch` DÉCOMPRESSE DE LUI-MÊME, et c'est le piège du flux. Sur un amont gzip,
+  // `Content-Length` compte les octets COMPRIMÉS alors que nous relayons les octets déployés :
+  // le recopier ferait attendre au client des octets qui ne viendront jamais, ou lui ferait couper
+  // le document au milieu. La bufferisation nous rendait ce service sans qu'on le demande —
+  // `buf.length` était toujours juste. En flux, il faut savoir se taire ; voir plus bas.
   if (disposition) res.setHeader("Content-Disposition", disposition);
   res.setHeader("Cache-Control", "private, max-age=600");
-  res.end(buf);
+
+  // ⚠️ UN AMONT SANS CORPS LISIBLE N'EST PAS UNE ANOMALIE, C'EST LE CONTRAT. `storage.fetchFile`
+  // est une capacité de l'HÔTE : il rend ce qu'il veut, du moment qu'il sait dire `arrayBuffer()`.
+  // Le chemin fichier local du mode autonome, lui, ne rend rien d'autre. Traiter cette absence
+  // comme « rien à envoyer » servait des fichiers VIDES, sans une erreur pour le dire — un défaut
+  // pire que celui qu'on ferme ici, et que seuls deux essais existants ont vu tomber.
+  //
+  // Ici la borne du flux ne peut rien : `arrayBuffer()` a déjà tout alloué quand on pourrait
+  // compter. Seule la taille annoncée protège — ce qui suffit, parce qu'un hôte qui rend un corps
+  // en un bloc l'a lu depuis quelque chose dont il connaît la taille.
+  if (!r.body) {
+    const buf = Buffer.from(await r.arrayBuffer());
+    res.setHeader("Content-Length", String(buf.length)); // connue, donc annoncée
+    res.end(buf);
+    return;
+  }
+
+  // ⚠️ ON N'ANNONCE UNE LONGUEUR QUE QUAND ON SAIT QU'ELLE DÉCRIT CE QU'ON ENVOIE — et en flux,
+  // la seule qu'on ait est celle de l'amont. Sans encodage elle est exacte : on la garde, elle
+  // vaut une barre de progression. Avec encodage on se tait (cf. plus haut), et la fin du corps
+  // fait foi. Sans annonce amont, on se tait aussi : c'est le prix du flux, payé en connaissance.
+  if (!compresse && brute) res.setHeader("Content-Length", brute);
+
+  const plafond = PLAFOND_RELAIS;
+  try {
+    await pipeline(Readable.fromWeb(r.body), async function* (source) {
+      let vus = 0;
+      for await (const morceau of source) {
+        vus += morceau.length;
+        if (vus > plafond) throw new Error(`relais interrompu : ${vus} octets reçus, plafond ${plafond}`);
+        yield morceau;
+      }
+    }, res);
+  } catch (erreur) {
+    // ⚠️ ROMPRE, PAS RÉPONDRE — et le DIRE. Aucun code de retour n'est plus disponible ; ne
+    // reste que la coupure. Une coupure fréquente ici est un plafond mal réglé ou un amont
+    // défaillant : l'avaler ferait passer un défaut d'exploitation pour un caprice du réseau.
+    try { PLAYER.errors.capture(erreur instanceof Error ? erreur : new Error(String(erreur)), { route: "relais" }); } catch { /* jamais bloquant */ }
+    try { res.destroy(); } catch { /* le socket est peut-être déjà parti */ }
+  }
 }
 
 // ⚠️ UNE MENTION DONT L'OBJET EST D'ÊTRE EXACTE NE DOIT PAS INVENTER UN EXPÉDITEUR.
@@ -3273,7 +3363,7 @@ async function handler(req, res) {
             name: (profil && profil.name) || body.name,
             email: profil ? profil.email : body.email,
             avatar: (profil && profil.avatar) || body.avatar,
-            isPresenter: validControl, isMember: !!profil, body: body.body, replyTo: body.replyTo, replyName: body.replyName, replyText: body.replyText, authorToken: body.authorToken, attachment: body.attachment });
+            isPresenter: validControl, isMember: !!profil, body: body.body, replyTo: body.replyTo, replyName: body.replyName, replyText: body.replyText, authorToken: body.authorToken, attachment: body.attachment , clientKey: body.clientKey });
           return jp(r.ok ? 200 : (r.status || 400), r);
         } catch { return jp(500, { ok: false }); }
       }
@@ -4028,6 +4118,8 @@ async function handler(req, res) {
 // ⚠️ `TIERS` est exporté pour être CONFRONTÉ, pas pour être utilisé. Le banc navigateur et la
 // forge doivent pouvoir demander « quelles dépendances tierces, à quelles empreintes » sans en
 // tenir une seconde liste — c'est la seule façon qu'une empreinte périmée finisse par se voir.
-module.exports = { handler, init, TIERS };
+// ⚠️ Exporté pour être ÉPROUVÉ, pas pour être appelé : le plafond du relais ne se vérifie qu en
+// regardant si le corps a été lu, ce qu aucune route ne peut montrer de l extérieur.
+module.exports = { handler, init, TIERS, __relayerFichier: relayerFichier };
 
 // redeploy: forcer le build production (Vercel a sauté la prod du merge #463 — wording re-partage).

package/server/presentations.js

@@ -381,6 +381,19 @@ function messagePublic(row) {
   if ("reactions" in out) out.reactions = reactionsPubliques(out.reactions);
   // Dérivé, jamais recopié : `author_hash` est lu pour ça et ne sort jamais tel quel.
   if ("author_hash" in row) out.author_ref = refAuteur(row.author_hash);
+  // ⚠️ LA GARDE CATÉGORIELLE N'EST PAS ICI, ET LA RAISON EST STRUCTURELLE.
+  //
+  // La liste blanche s'exécute AVANT : elle a déjà retiré tout champ inconnu. `publier()` n'y
+  // verrait donc qu'un jeu de champs connus, et aucune mutation ne peut la faire tomber à cet
+  // endroit — la redondance n'est pas une ceinture, c'est une garde qu'on ne peut pas éprouver.
+  //
+  // ⚠️ Et le cas qu'on écrirait pour forcer le rouge serait faux : `author_name` est CHOISI par le
+  // participant. Quelqu'un qui se nomme « lea@exemple.fr » verrait le chat tomber — le piège de
+  // `body`, rencontré une seconde fois au même endroit.
+  //
+  // Sa place est aux sorties SANS liste blanche : charge de présence, statistiques, aperçu d'un
+  // partage — là où un champ ajouté demain sort sans que personne ne l'ait décidé. C'est là qu'une
+  // mutation pourra rougir, et donc là qu'elle sera branchée.
   return out;
 }
 
@@ -390,7 +403,7 @@ function premierPublic(reponse) {
   return messagePublic(row);
 }
 
-async function addMessage(slug, { name, email, avatar, isPresenter, isMember, body, replyTo, replyName, replyText, authorToken, attachment }) {
+async function addMessage(slug, { name, email, avatar, isPresenter, isMember, body, replyTo, replyName, replyText, authorToken, attachment, clientKey }) {
   if (await estArchive(slug)) return REFUS_ARCHIVE;
   const b = String(body || "").trim().slice(0, 2000);
   // ⚠️ Pas de normalisation ici : `config.supabaseUrl` arrive SANS barre finale, c'est le
@@ -411,10 +424,41 @@ async function addMessage(slug, { name, email, avatar, isPresenter, isMember, bo
     author_hash: authorToken ? sha(authorToken) : null,
     reply_to: rt, reply_name: rt ? ((replyName || "").slice(0, 80) || null) : null, reply_text: rt ? ((replyText || "").slice(0, 140) || null) : null,
   };
+  // ⚠️ LA CLÉ N'EST ÉCRITE QUE SI LA COLONNE EXISTE. PostgREST rejette le POST ENTIER sur une
+  // colonne inconnue : chez un hôte non migré, ce n'est pas l'idempotence qu'on perdrait, c'est
+  // l'envoi de messages. Même piège que le rang d'écriture, même sonde.
+  const cle = String(clientKey || "").slice(0, 80);
+  if (cle && await require("./schema").aLaColonne(
+    "doc_presentation_messages", "client_key", "supabase/migrations/0005-envoi-unique.sql")) {
+    row.client_key = cle;
+  }
+
   // `return=representation` : c'est la ligne écrite qui part ensuite en diffusion vers l'audience.
   // Sans elle, l'émetteur devrait deviner l'`id` et la date attribués par la base.
-  const cree = await PLAYER.db.request("doc_presentation_messages?select=*", { method: "POST", headers: { Prefer: "return=representation" }, body: [row] });
-  return { ok: true, message: premierPublic(cree) };
+  // ⚠️ UN REFUS D'UNICITÉ N'EST PAS UNE ERREUR, C'EST UNE CONFIRMATION. La contrainte dit « ce
+  // message est déjà là » : le remonter au participant remplacerait « deux messages » par « une
+  // erreur », ce qui n'est pas mieux. On relit donc la ligne déjà écrite et on la rend comme si
+  // l'envoi venait de réussir — ce qu'il a fait, la première fois.
+  try {
+    const cree = await PLAYER.db.request("doc_presentation_messages?select=*", { method: "POST", headers: { Prefer: "return=representation" }, body: [row] });
+    return { ok: true, message: premierPublic(cree) };
+  } catch (erreur) {
+    // ⚠️ LA GARDE DES ÉCRITURES MUETTES A REFUSÉ CE BLOC, et elle avait raison de le faire : un
+    // `try` autour d'une écriture doit dire quelque chose. Ici le silence était volontaire — un 409
+    // attendu n'est pas un incident — mais rien ne distinguait « je sais ce que je rattrape » de
+    // « j'avale tout ». On le dit donc : ce qui n'est pas le conflit attendu remonte, et le conflit
+    // attendu est journalisé une fois, en clair, parce qu'un renvoi fréquent est une information.
+    const conflit = cle && String((erreur && erreur.message) || "").includes("409");
+    if (!conflit) throw erreur;
+    try { PLAYER.errors.capture(new Error("message déjà enregistré (renvoi) : " + String(slug)), { route: "present-chat", benin: true }); } catch { /* jamais bloquant */ }
+    const deja = await PLAYER.db.request(
+      `doc_presentation_messages?slug=eq.${enc(String(slug))}&client_key=eq.${enc(cle)}&select=*&limit=1`);
+    const ligne = Array.isArray(deja) && deja[0];
+    // ⚠️ Si la relecture ne trouve rien, on ne prétend pas : le 409 venait d'autre chose, et le
+    // taire ferait croire à un envoi réussi qui n'a pas eu lieu.
+    if (!ligne) throw erreur;
+    return { ok: true, message: messagePublic(ligne), deja: true };
+  }
 }
 
 /**
@@ -470,7 +514,21 @@ async function setChatLock(slug, control, locked) {
 }
 
 // Réaction emoji (toggle) : le participant (identifié par email ou nom) ajoute/retire un emoji sur un message.
-async function toggleReaction(slug, msgId, emoji, reactor) {
+/**
+ * ⚠️ ON POSE UN ÉTAT, ON NE BASCULE PLUS — et la différence est ce qui rend l'opération IDEMPOTENTE.
+ *
+ * « Basculer » n'a de sens qu'une fois : un renvoi réseau, un double-clic, une reprise de requête,
+ * et la réaction que le participant vient d'ajouter disparaît. Il ne voit aucune erreur — il voit
+ * son émoji s'allumer puis s'éteindre, et il recommence, ce qui rebascule encore.
+ *
+ * L'appelant sait ce qu'il VEUT (`etat`), pas ce qu'il faut inverser. Rejouer la même intention
+ * deux fois donne le même résultat qu'une fois, ce qui est exactement la propriété qu'un réseau
+ * peu fiable exige. Constat P10 de l'audit.
+ *
+ * ⚠️ Compatibilité : `etat` absent = ancien client, on bascule comme avant. Un client à jour ne
+ * repasse jamais par là ; un ancien garde son comportement plutôt que de perdre la fonction.
+ */
+async function toggleReaction(slug, msgId, emoji, reactor, etat) {
   if (await estArchive(slug)) return REFUS_ARCHIVE;
   const id = Math.trunc(+msgId); const e = String(emoji || "").slice(0, 8); const who = String(reactor || "").slice(0, 160).toLowerCase();
   if (!id || !e || !who) return { ok: false, status: 400 };
@@ -498,7 +556,9 @@ async function toggleReaction(slug, msgId, emoji, reactor) {
   const cur = Object.assign(Object.create(null), brut);
   const arr = Array.isArray(cur[e]) ? cur[e] : [];
   const i = arr.indexOf(who);
-  if (i >= 0) arr.splice(i, 1); else arr.push(who);
+  const veut = etat === undefined || etat === null ? (i < 0) : !!etat;
+  if (veut && i < 0) arr.push(who);
+  if (!veut && i >= 0) arr.splice(i, 1);
   if (arr.length) cur[e] = arr; else delete cur[e];
   const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { reactions: cur } });
   return { ok: true, message: premierPublic(maj) };

package/server/publier.js

@@ -0,0 +1,72 @@
+// AUCUNE ADRESSE NE SORT — LA CATÉGORIE, PAS LES QUATRE CHEMINS CONNUS.
+//
+// Nous avions corrigé quatre chemins qui portaient l'adresse d'un membre : les champs publics du
+// chat, la carte des réactions, la charge de présence, la clé du canal. Le second hôte a dit ce
+// qui manquait, et il avait raison : « mon fermé vaut pour les chemins que j'ai su nommer, pas
+// pour la catégorie ». Rien ne garantissait qu'il n'y en avait pas un cinquième.
+//
+// ⚠️ CE N'EST PAS UNE SONDE QUI PRODUIT UNE LISTE. Une garde qui signale « ces vingt endroits
+// ressemblent à des adresses » transfère le travail : quelqu'un doit juger vingt cas, et le
+// jugement est précisément ce qui ne passe pas à l'échelle. Celle-ci REFUSE — le champ ne sort
+// pas, et il faut écrire une décision pour qu'il sorte.
+//
+// ⚠️ ET ELLE NE NETTOIE PAS EN SILENCE. Effacer l'adresse au passage serait pire que la laisser :
+// on croirait la donnée partie alors qu'elle n'a jamais été prévue. Une valeur inattendue à la
+// sortie est un défaut de conception, pas une impureté à filtrer — donc on lève.
+
+// Reconnaît une adresse par sa FORME, pas par le nom du champ. `author_email` était nommé ; les
+// réactions ne l'étaient pas, et c'est là que l'adresse se cachait.
+const ADRESSE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/;
+
+/**
+ * Rend l'objet tel quel s'il ne porte aucune adresse ; lève sinon, en NOMMANT le chemin.
+ *
+ * Le chemin compte plus que la valeur : « reactions.👍[0] » dit où regarder, « une adresse a été
+ * trouvée » envoie chercher.
+ */
+/**
+ * ⚠️ LES CHAMPS QUE LES GENS RÉDIGENT, ET CEUX QUI DÉSIGNENT QUELQU'UN — la distinction que le
+ * premier branchement n'avait pas.
+ *
+ * Branchée sur tout, la garde levait sur `body` : un participant qui écrit « écris-moi à
+ * lea@exemple.fr » dans le chat voyait son message provoquer une exception. Elle transformait un
+ * usage normal en panne, et je l'ai mesuré plutôt que supposé.
+ *
+ * Une adresse DANS UN MESSAGE est du contenu : son auteur l'a écrite exprès, pour un destinataire
+ * qu'il a choisi. Une adresse dans un champ d'IDENTITÉ n'a été choisie par personne : elle vient
+ * de la base, et elle sort vers toute l'audience. Ce n'est pas la même donnée, et la garde ne doit
+ * pas les traiter pareil.
+ *
+ * ⚠️ LISTE DES CHAMPS DE CONTENU, PAS DES CHAMPS D'IDENTITÉ — et le sens de l'inversion est la
+ * garde elle-même. Énumérer ce qu'on protège laisse passer la colonne ajoutée demain ; énumérer
+ * ce qu'on EXEMPTE oblige à écrire une décision pour chaque exemption. Un champ inconnu est
+ * protégé par défaut.
+ */
+const CONTENU = new Set(["body", "reply_text", "text", "message", "content", "caption"]);
+
+function publier(valeur, ou = "") {
+  if (typeof valeur === "string") {
+    if (ADRESSE.test(valeur)) {
+      throw Object.assign(
+        new Error(`adresse refusée à la sortie publique : ${ou || "(racine)"}`),
+        { statusCode: 500, champ: ou },
+      );
+    }
+    return valeur;
+  }
+  if (Array.isArray(valeur)) { valeur.forEach((v, i) => publier(v, `${ou}[${i}]`)); return valeur; }
+  if (valeur && typeof valeur === "object") {
+    // ⚠️ Les CLÉS aussi : la carte des réactions portait les identités en clé chez d'autres hôtes,
+    // et une garde qui ne regarde que les valeurs laisserait passer exactement ce cas.
+    for (const [k, v] of Object.entries(valeur)) {
+      publier(k, ou ? `${ou}.<clé>` : "<clé>");
+      // Le champ que quelqu'un a rédigé traverse ; tout le reste est inspecté.
+      if (CONTENU.has(k)) continue;
+      publier(v, ou ? `${ou}.${k}` : k);
+    }
+    return valeur;
+  }
+  return valeur;
+}
+
+module.exports = { publier, ADRESSE, CONTENU };

package/supabase/init.sql

@@ -50,7 +50,10 @@ create table if not exists public.commercial_doc_shares (
   brand_logo      text,                      -- logo RECOPIÉ (flux historiques, toujours accepté)
   brand_dark      boolean not null default false,
   require_auth    boolean not null default false,
-  brand_key       text                       -- ⚠️ RÉFÉRENCE résolue à l'affichage (branding.forKey)
+  brand_key       text,                      -- ⚠️ RÉFÉRENCE résolue à l'affichage (branding.forKey)
+  -- Destinataire attesté par l'hôte : sert à ATTRIBUER une lecture, jamais à expédier en son nom.
+  -- `recipient_email`, elle, dit qui peut expédier — vide quand personne ne le peut.
+  attested_recipient_email text
 );
 create index if not exists cds_doc_id_idx on public.commercial_doc_shares (doc_id);
 create index if not exists cds_parent_idx on public.commercial_doc_shares (parent_slug);
@@ -139,7 +142,11 @@ create table if not exists public.doc_presentations (
   owner_avatar   text,
   owner_email    text,
   last_seen      timestamptz not null default now(),
-  content        jsonb                       -- carte / Street View (revalidé à la réception)
+  content        jsonb,                      -- carte / Street View (revalidé à la réception)
+  -- Rang de la dernière écriture de pilotage acceptée. Une écriture de rang inférieur ou égal est
+  -- refusée : elle a été doublée en vol. Remis à zéro par toute émission d'un jeton de contrôle
+  -- (démarrage, reprise), qui ouvre un nouveau domaine d'ordre.
+  write_seq      bigint not null default 0
 );
 create index if not exists doc_presentations_active_idx      on public.doc_presentations (active, updated_at);
 create index if not exists doc_presentations_last_seen_idx   on public.doc_presentations (active, last_seen);
@@ -163,9 +170,17 @@ create table if not exists public.doc_presentation_messages (
   reply_text    text,
   deleted       boolean not null default false,
   edited        boolean not null default false,
-  attachment    jsonb
+  attachment    jsonb,
+  -- Clé d'idempotence fabriquée par le client AVANT le premier envoi et réutilisée au renvoi :
+  -- un renvoi réseau ne crée pas un second message. Nulle si le client ne la fournit pas.
+  client_key    text
 );
 create index if not exists dpm_slug_idx on public.doc_presentation_messages (slug, created_at);
+-- ⚠️ Portée sur (slug, client_key), pas sur la clé seule : deux présentations n'ont aucune raison
+-- de partager un espace de clés. Partiel, pour que les lignes sans clé ne se gênent pas entre elles.
+create unique index if not exists dpm_client_key_uniq
+  on public.doc_presentation_messages (slug, client_key)
+  where client_key is not null;
 
 create table if not exists public.doc_presentation_attendees (
   slug         text not null,
@@ -209,6 +224,74 @@ create table if not exists public.doc_bot_sessions (
 );
 create index if not exists doc_bot_sessions_share_idx on public.doc_bot_sessions (share_slug);
 
+-- ── Limites de débit partagées ─────────────────────────────────────────────────────────────────
+-- ⚠️ EN MÉMOIRE, UNE LIMITE NE LIMITE RIEN. Chaque instance serverless a la sienne : N instances
+-- accordent N fois le quota, et l'hôte croit être protégé. Le compteur vit donc en base.
+create table if not exists public.player_rate_limits (
+  key         text primary key,
+  count       integer not null default 0,
+  expires_at  timestamptz not null
+);
+create index if not exists player_rate_limits_expires_idx
+  on public.player_rate_limits (expires_at);
+alter table public.player_rate_limits enable row level security;
+comment on table public.player_rate_limits is
+  'Compteurs de débit partagés entre instances. Une ligne par clé et par fenêtre ; les lignes '
+  'périmées sont écrasées à la première demande suivante, il n''y a rien à purger.';
+
+-- ⚠️ ET LIRE PUIS ÉCRIRE N'EST PAS ATOMIQUE. Deux appels simultanés lisent le même compte et
+-- écrivent la même valeur : la limite laisse passer le double. L'incrément se fait donc en UNE
+-- instruction, côté serveur.
+create or replace function public.player_rate_limit_bump(
+  p_key text,
+  p_max integer,
+  p_window_seconds integer
+)
+returns table (autorise boolean, compte integer)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  v_count integer;
+begin
+  insert into public.player_rate_limits as l (key, count, expires_at)
+  values (p_key, 1, now() + make_interval(secs => p_window_seconds))
+  on conflict (key) do update
+    set count = case when l.expires_at <= now() then 1 else l.count + 1 end,
+        expires_at = case when l.expires_at <= now()
+                          then now() + make_interval(secs => p_window_seconds)
+                          else l.expires_at end
+  returning l.count into v_count;
+  return query select (v_count <= p_max), v_count;
+end;
+$$;
+-- ⚠️ `anon` ET `authenticated` SONT DES RÔLES SUPABASE, PAS DES RÔLES POSTGRES. Les nommer en dur
+-- faisait ÉCHOUER ce fichier sur un Postgres nu — donc chez tout hôte auto-hébergé, c'est-à-dire le
+-- public que ce dépôt vise en s'ouvrant. Le `grant` ci-dessous était déjà gardé par un `if exists` ;
+-- ce `revoke` ne l'était pas : la prudence s'arrêtait à mi-chemin. Trouvé par la garde de schéma.
+--
+-- `public` n'est pas un rôle mais un mot-clé : celui-là passe partout, et c'est le seul qui compte.
+revoke all on function public.player_rate_limit_bump(text, integer, integer) from public;
+do $$
+declare
+  r text;
+begin
+  foreach r in array array['anon', 'authenticated'] loop
+    if exists (select 1 from pg_roles where rolname = r) then
+      execute format('revoke all on function public.player_rate_limit_bump(text, integer, integer) from %I', r);
+    end if;
+  end loop;
+end
+$$;
+do $$
+begin
+  if exists (select 1 from pg_roles where rolname = 'service_role') then
+    grant execute on function public.player_rate_limit_bump(text, integer, integer) to service_role;
+  end if;
+end
+$$;
+
 -- ── Accès ──────────────────────────────────────────────────────────────────────────────────────
 -- RLS activé SANS politique permissive : seul `service_role` (donc la route du player) passe.
 -- ⚠️ N'ajoutez pas de politique de lecture publique « pour que le direct fonctionne ». C'est
@@ -252,3 +335,23 @@ begin
   end if;
 end $$;
 alter table public.doc_presentation_messages replica identity full;
+
+-- ── Rattrapage : bases installées depuis un init.sql plus ancien ───────────────────────────────
+--
+-- ⚠️ CE FICHIER A ÉTÉ INCOMPLET, ET RIEN NE LE DISAIT. Il annonçait « un seul fichier, sans rien à
+-- lire ailleurs » alors qu'aucune des cinq migrations de `supabase/migrations/` n'y figurait : un
+-- hôte neuf installait une base sans rang d'écriture, sans limites partagées et sans clé
+-- d'idempotence. Les sondes de schéma dégradent en silence — par conception, pour ne pas casser un
+-- hôte en cours de migration — donc cet hôte-là ne l'apprenait JAMAIS. Un état anormal que rien ne
+-- dit devient l'état normal.
+--
+-- Les colonnes sont désormais dans le corps des tables ci-dessus, ce qui règle le cas d'une base
+-- VIERGE. Mais `create table if not exists` ne touche pas une table déjà là : une base créée
+-- depuis l'ancien init.sql resterait incomplète en rejouant celui-ci. D'où ce rattrapage, qui ne
+-- coûte rien sur une base neuve et rend le fichier vrai dans les deux cas.
+alter table public.commercial_doc_shares
+  add column if not exists attested_recipient_email text;
+alter table public.doc_presentations
+  add column if not exists write_seq bigint not null default 0;
+alter table public.doc_presentation_messages
+  add column if not exists client_key text;

package/supabase/migrations/0004-limites-atomiques.sql

@@ -52,7 +52,24 @@ end;
 $$;
 
 -- Le player parle à la base avec la clé de service ; personne d'autre n'a à appeler ceci.
-revoke all on function public.player_rate_limit_bump(text, integer, integer) from public, anon, authenticated;
+-- ⚠️ `anon` ET `authenticated` SONT DES RÔLES SUPABASE, PAS DES RÔLES POSTGRES. Les nommer en dur
+-- faisait ÉCHOUER ce fichier sur un Postgres nu — donc chez tout hôte auto-hébergé, c'est-à-dire le
+-- public que ce dépôt vise en s'ouvrant. Le `grant` ci-dessous était déjà gardé par un `if exists` ;
+-- ce `revoke` ne l'était pas : la prudence s'arrêtait à mi-chemin. Trouvé par la garde de schéma.
+--
+-- `public` n'est pas un rôle mais un mot-clé : celui-là passe partout, et c'est le seul qui compte.
+revoke all on function public.player_rate_limit_bump(text, integer, integer) from public;
+do $$
+declare
+  r text;
+begin
+  foreach r in array array['anon', 'authenticated'] loop
+    if exists (select 1 from pg_roles where rolname = r) then
+      execute format('revoke all on function public.player_rate_limit_bump(text, integer, integer) from %I', r);
+    end if;
+  end loop;
+end
+$$;
 
 -- ⚠️ LE `revoke` CI-DESSUS NE SUFFIT PAS À RENDRE CE FICHIER VRAI TOUT SEUL — signalé par le
 -- second hôte, qui a interrogé `has_function_privilege` au lieu de relire la migration. Chez

package/supabase/migrations/0005-envoi-unique.sql

@@ -0,0 +1,44 @@
+-- DEUX ENVOIS DU MÊME MESSAGE NE DOIVENT PAS FAIRE DEUX MESSAGES.
+--
+-- Un renvoi réseau, un double-clic, une reprise après délai : la requête part deux fois et la base
+-- enregistre deux lignes. Le participant voit son message en double, et rien ne le lui explique —
+-- il n'y a eu aucune erreur, seulement un succès de trop.
+--
+-- ⚠️ LA CLÉ EST FABRIQUÉE PAR LE CLIENT, UNE FOIS, AVANT LE PREMIER ENVOI — et c'est toute la
+-- subtilité. Une clé tirée à chaque tentative ne servirait à rien : les deux envois porteraient des
+-- clés différentes et passeraient tous les deux. C'est la RÉUTILISATION de la clé au renvoi qui
+-- rend l'opération idempotente, pas la clé elle-même.
+--
+-- ⚠️ INDEX PARTIEL, et il faut comprendre pourquoi. Les lignes déjà en base n'ont pas de clé ; un
+-- index unique ordinaire les traiterait comme des doublons entre elles (plusieurs NULL sont
+-- distincts en SQL, donc en réalité ça passerait — mais la condition rend l'intention explicite et
+-- protège d'un futur `not null default ''`, où toutes les anciennes lignes deviendraient soudain
+-- identiques). L'index ne contraint que ce que le nouveau client écrit.
+--
+-- ⚠️ CE QUE LA BASE FAIT, ET CE QUE LE CODE DOIT FAIRE. La contrainte REFUSE le second envoi ;
+-- PostgREST répond alors 409. Ce refus n'est pas une erreur à remonter au participant : c'est la
+-- preuve que son message est déjà là. Le serveur doit donc relire la ligne existante et la rendre,
+-- comme si l'envoi avait réussi — sinon on remplace « deux messages » par « une erreur », ce qui
+-- n'est pas mieux. Cette partie-là est du code, elle n'est pas dans ce fichier.
+--
+-- Sans lui : rien ne change, deux envois du même message créent toujours deux lignes. Le client
+-- peut envoyer la clé, la colonne l'ignore poliment — aucune écriture ne casse, et le player ne
+-- signale rien puisque l'ancien comportement EST le comportement d'aujourd'hui.
+--
+-- Applicable pendant que la version précédente tourne : tant que personne n'écrit la colonne, elle
+-- reste vide et l'index ne contraint rien.
+
+alter table public.doc_presentation_messages
+  add column if not exists client_key text;
+
+comment on column public.doc_presentation_messages.client_key is
+  'Clé d''idempotence fabriquée par le client AVANT le premier envoi et réutilisée au renvoi. '
+  'Unique par présentation (index partiel dpm_client_key_uniq). Nulle sur les lignes antérieures '
+  'à la migration 0005, et sur celles écrites par un client qui ne la fournit pas.';
+
+-- ⚠️ Portée sur (slug, client_key) et pas sur la clé seule : deux présentations différentes n'ont
+-- aucune raison de partager un espace de clés, et un client qui réutiliserait par accident la même
+-- valeur d'une session à l'autre verrait son message refusé sans comprendre.
+create unique index if not exists dpm_client_key_uniq
+  on public.doc_presentation_messages (slug, client_key)
+  where client_key is not null;