discovery-media-player 0.1.1 → 0.1.3

package/CONTRAT.md

@@ -271,6 +271,47 @@ d'environnement), et ce qui reste est du branchement. Un câblage qu'on ne pourr
 un câblage qui contient quelque chose qui n'a rien à y faire. *(Ce n'est pas un avis juridique :
 c'est la posture retenue, et elle est sûre dans les deux cas.)*
 
+### Les deux routes que le player appelle chez l'hôte
+
+⚠️ **Ces formats sont le contrat, pas une suggestion.** Ils manquaient à ce document : un hôte a
+écrit ses deux routes sur la *description* de `canManageShares`, ce qui donnait une intention juste
+et une forme fausse. Et le pire : **deux des trois écarts étaient silencieux** — une réponse d'une
+autre forme est lue comme un refus. Personne n'aurait pu diffuser un document, sans erreur nulle
+part, indiscernable d'un droit correctement refusé. On aurait cherché dans les rôles.
+
+Les deux routes sont appelées en **POST JSON, serveur à serveur**, avec le secret partagé dans
+l'en-tête `x-player-fetch-secret` (jamais en query). Délai : **4 secondes** — une décision qui tarde
+est une décision absente.
+
+**`PLAYER_HOST_AUTHZ_URL` — qui a le droit de diffuser**
+
+```
+→  { "email": "…", "role": "…", "action": "create|list|list.all|revoke|setauth|overview|sessions|test" }
+←  { "allowed": true }            // booléen STRICT ; tout le reste vaut refus
+```
+
+- **`email` est l'identité qui fait foi.** `role` est celui lu dans le jeton de session
+  (`app_metadata.role`) : un hôte dont les rôles vivent en base l'ignore et interroge la sienne à
+  partir de l'email. C'est un cas prévu, pas une entorse.
+- **Le jeton est déjà vérifié** par le player avant l'appel. La route n'a pas à le revalider — elle
+  ne le reçoit d'ailleurs pas.
+- **Seul `allowed` est lu**, et il doit être un booléen. `{ "canManageShares": true }` ou
+  `{ "allowed": "yes" }` valent refus. Le player le signale désormais dans son journal.
+
+**`PLAYER_HOST_BRAND_URL` — la marque d'un client**
+
+```
+→  { "key": "…" }                                  // la référence portée par le lien
+←  { "logo": "https://…", "name": "…", "dark": false }   ou   {} / null si inconnue
+```
+
+Une clé inconnue n'est pas une erreur : le lien retombe sur la marque de l'instance.
+
+**Une panne n'est plus muette.** Hôte injoignable, délai dépassé, réponse non-JSON, `allowed`
+d'un autre type : le player reste **fail-closed** (personne ne diffuse) mais l'écrit dans son
+journal, avec la cause. Sans ça, « ma route répond mal » et « le droit est refusé » se
+ressemblaient exactement.
+
 ### Le câblage d'une instance — à qui il appartient
 
 Une instance autonome, c'est **un petit dépôt qui appartient à l'hôte**, pas un dépôt généré par le
@@ -467,6 +508,10 @@ Toute évolution de la frontière se note ici, datée, avec sa nature.
 | 2026-08-13 | additif | **« L'hôte sert le fichier »** : la garde de streaming accepte une route de l'hôte comme origine, appelée serveur à serveur via `PLAYER_HOST_FETCH_SECRET`. Rendu nécessaire par ADV, dont les documents vivent sur un serveur de fichiers tiers derrière une clé d'API. Le studio n'est pas concerné (Storage direct) — **additif, aucune rupture**. |
 | 2026-08-13 | additif | **`embed-denied`** ajouté au pont : un refus d'afficher se dit, au lieu de se confondre avec une panne. Les pages de refus deviennent encadrables en mode intégré (sinon le message ne partirait pas). **Additif** — un hôte qui l'ignore garde le comportement d'avant. |
 | 2026-08-13 | correctif | **Taille annoncée** : les trois routes de streaming passent par `relayerFichier()`, qui envoie la taille des octets servis et jamais celle reçue de l'amont, demande `Accept-Encoding: identity` et refuse un `206` compressé. Corrige un PDF tronqué silencieux. |
+| 2026-08-13 | précision | **Le format d'appel des deux routes de l'hôte** (`PLAYER_HOST_AUTHZ_URL`, `PLAYER_HOST_BRAND_URL`) est enfin écrit. Il manquait : un hôte a écrit ses routes sur la description de `canManageShares` — intention juste, forme fausse, et **deux écarts sur trois étaient silencieux** (réponse lue comme un refus). |
+| 2026-08-13 | additif | **Une panne de route d'hôte se distingue d'un refus** : injoignable, délai dépassé, réponse non-JSON ou `allowed` d'un autre type sont journalisés avec leur cause. Le player reste fail-closed. |
+| 2026-08-13 | correctif | **Objet littéral utilisé comme table de correspondance** : `ATT_KINDS["constructor"]` rendait une fonction, donc une valeur vraie — la liste blanche des types de pièce jointe était contournable depuis une action publique. Même forme cinq fois dans le greffon de langue. Tout passe par `Object.hasOwn`, un test statique interdit le retour en arrière. Trouvé chez nous après signalement d'un hôte qui l'avait chez lui. |
+| 2026-08-13 | correctif | **Le chat passe en diffusion** : ses messages arrivaient par lecture de table en temps réel, ce qui exposait les conversations de TOUTES les présentations à qui détient la clé publiable. Dernier usage qui l'exigeait — `v12420` devient applicable. Les mutations renvoient la ligne écrite, **projetée sur une liste blanche** : `author_hash` (le jeton qui autorise à éditer et supprimer) ne sort jamais. |
 | 2026-08-13 | correctif | **Tous les chemins de refus** émettent `embed-denied`, pas seulement celui du lien tracé : l'aperçu interne (`url-not-allowed`) et la page d'audience (`ended`) se taisaient — or l'aperçu intégré est le premier mode qu'un nouvel hôte exerce. Deux motifs ajoutés, une garde de test empêche le prochain refus muet. |
 | 2026-08-13 | précision | **`branding.forKey` renvoie `{ logo, name, dark }`** — la forme de retour manquait au contrat, et `name` (le repli quand le logo ne charge pas) a été omis par le premier hôte qui l'a lu. Le registre `brand.*`, retiré, disparaît aussi de la section Marque. |
 | 2026-08-13 | précision | **« On ne replie pas » vaut pour ce qu'un hôte PROPOSE**, pas seulement pour ce qu'il fait tout seul : un bouton « Ouvrir ↗ » laissé après un refus revient à replier une seconde plus tard. Généralisation proposée par ADV. |
@@ -494,7 +539,7 @@ Un hôte qui a besoin d'une évolution de la frontière l'écrit ici. Il ne la c
 | 2026-08-13 | ADV | **Gestion des liens tracés accessible hors studio** : `docshare.create/list/revoke` vit dans la route de synchro derrière le modèle de droits du studio (`clients_registry`) — inappelable par un autre hôte. **Point d'intégration le plus sous-estimé.** | à faire |
 | 2026-08-13 | ADV | **Marque de l'hôte** : retirer les mentions « 3D Discovery » en dur | ✅ **livré** — `PLAYER_BRAND_NAME` / `PLAYER_BRAND_POWERED_BY`, neutre par défaut |
 | 2026-08-13 | ADV | **Mur d'accès Microsoft** en plus d'email+code et Google One-Tap (ADV est en SSO M365) | à faire |
-| 2026-08-13 | ADV | **Confidentialité Realtime** : la lecture anon large interdit d'y mettre des documents sensibles | 🟡 **code prêt, migration en attente de vérification en production** (`v12420`) |
+| 2026-08-13 | ADV | **Confidentialité Realtime** : la lecture anon large interdit d'y mettre des documents sensibles | 🟡 **code complet** — l'état ET le chat passent en diffusion ; migration `v12420` en attente d'une vérification en production |
 | 2026-08-13 | ADV | **Streaming via une route de l'hôte** (Range relayé + secret serveur à serveur) — cf. section dédiée | ✅ **livré côté player** — reste à ADV d'exposer sa route |
 | 2026-08-13 | ADV | **Le piège de la compression** : `fetch()` décompresse et garde les en-têtes → un `Content-Length` relayé sert un PDF tronqué, sans erreur | ✅ **livré** — 3e exigence de la section, et corrigé dans le player lui-même (le piège nous concernait) |
 | 2026-08-13 | ADV | **Distinguer « player absent » de « player refuse »** : le silence pousse l'hôte à replier sur son lecteur, ce qui ouvrirait un document refusé | ✅ **livré** — `embed-denied {reason}` + pages de refus encadrables |
@@ -513,3 +558,5 @@ Un hôte qui a besoin d'une évolution de la frontière l'écrit ici. Il ne la c
 | 2026-08-13 | ADV | **Comment on installe** : npm public, npm privé ou git ? | ✅ **tranché** — dépôt public + npm public, rien à configurer chez l'hôte |
 | 2026-08-13 | ADV | **Cible de `PLAYER_SOURCE_URL`** avant le premier lecteur | ✅ **tranché** — le dépôt public lui-même |
 | 2026-08-13 | ADV | **`?contract=1` n'existait pas** alors que la règle 4 repose dessus | ✅ **livré** — forme documentée, 3 tests |
+| 2026-08-13 | ADV | **Format des routes de l'hôte absent du contrat** — route d'autorisation réécrite après lecture du paquet publié | ✅ **livré** — les deux formats sont au contrat et dans `docs/CONFIGURATION.md` |
+| 2026-08-13 | ADV | **Un objet littéral comme table de correspondance répond à `constructor`** (trois occurrences chez eux) | ✅ **vérifié chez nous : deux sites, dont un atteignable depuis une action publique** — corrigés, plus un test statique |

package/context/standalone.js

@@ -63,8 +63,14 @@ function creerDb(env) {
  * Appel d'une route de l'HÔTE (autorisation, marque). Authentifié par le même secret partagé que
  * la route de fichiers, et **jamais en query** : les journaux gardent les URL.
  */
-async function appelHote(url, secret, corps) {
+async function appelHote(url, secret, corps, errors) {
   if (!url) return null;
+  // ⚠️ UN REFUS ET UNE PANNE NE DOIVENT PAS SE RESSEMBLER. Le player reste fail-closed — hôte
+  // injoignable ⇒ personne ne diffuse — mais sans trace, « ma route répond mal » est
+  // indiscernable de « le droit est refusé », et on cherche pendant une demi-journée du côté des
+  // rôles. Un hôte qui a écrit sa route sur la description du contrat plutôt que sur le code a
+  // perdu exactement ce temps-là.
+  const signaler = (quoi) => { try { errors && errors.capture(new Error(`route hôte : ${quoi}`), { url }); } catch { /* jamais bloquant */ } };
   try {
     const r = await fetch(url, {
       method: "POST",
@@ -75,8 +81,12 @@ async function appelHote(url, secret, corps) {
       body: JSON.stringify(corps),
       signal: AbortSignal.timeout(4000), // une décision qui tarde est une décision absente
     });
-    return r.ok ? await r.json() : null;
-  } catch {
+    if (!r.ok) { signaler(`réponse ${r.status}`); return null; }
+    const d = await r.json().catch(() => null);
+    if (!d || typeof d !== "object") { signaler("réponse illisible (JSON attendu)"); return null; }
+    return d;
+  } catch (e) {
+    signaler(e && e.name === "TimeoutError" ? "délai dépassé" : "injoignable");
     return null;
   }
 }
@@ -107,6 +117,11 @@ function creerLimites() {
 /** Construit le contexte d'une instance autonome à partir de l'environnement. */
 function createStandaloneContext(env = process.env) {
   const db = creerDb(env);
+  const journal = {
+    async capture(error, meta) {
+      console.error("[player]", (meta && meta.route) || "", (error && error.message) || error, meta && meta.url ? `→ ${meta.url}` : "");
+    },
+  };
   const secret = String(env.PLAYER_HOST_FETCH_SECRET || "");
   const origins = () => storage.storageOrigins(env);
   const hostBase = () => storage.hostFetchBase(env);
@@ -163,8 +178,14 @@ function createStandaloneContext(env = process.env) {
         if (!user || !user.email) return false;
         const reponse = await appelHote(env.PLAYER_HOST_AUTHZ_URL, secret, {
           email: user.email, role: ((user.app_metadata || {}).role) || "", action: String(action || ""),
-        });
-        return !!(reponse && reponse.allowed);
+        }, journal);
+        // ⚠️ `allowed` doit être présent ET booléen. Une réponse d'une autre forme — même
+        // parfaitement intentionnée — vaut refus, et le dit. C'est le cas le plus courant au
+        // branchement d'un nouvel hôte.
+        if (reponse && typeof reponse.allowed !== "boolean") {
+          try { journal.capture(new Error("route d'autorisation : champ `allowed` booléen attendu"), { recu: Object.keys(reponse).join(",") }); } catch { /* ignore */ }
+        }
+        return reponse ? reponse.allowed === true : false;
       },
     },
 
@@ -185,7 +206,7 @@ function createStandaloneContext(env = process.env) {
        */
       async forKey(key) {
         if (!key) return null;
-        const b = await appelHote(env.PLAYER_HOST_BRAND_URL, secret, { key: String(key) });
+        const b = await appelHote(env.PLAYER_HOST_BRAND_URL, secret, { key: String(key) }, journal);
         return b && b.logo ? { logo: String(b.logo), name: String(b.name || ""), dark: !!b.dark } : null;
       },
 
@@ -196,11 +217,7 @@ function createStandaloneContext(env = process.env) {
       },
     },
 
-    errors: {
-      async capture(error, meta) {
-        console.error("[player]", (meta && meta.route) || "", (error && error.stack) || error);
-      },
-    },
+    errors: journal,
 
     legal: {
       get sourceUrl() { return String(env.PLAYER_SOURCE_URL || "https://github.com/Juli1artha/discovery-media-player").trim(); },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",

package/server/__tests__/audienceEtat.test.js

@@ -0,0 +1,90 @@
+// @vitest-environment jsdom
+//
+// L'AUDIENCE DOIT VRAIMENT ÊTRE BRANCHÉE SUR L'ÉTAT DU PRÉSENTATEUR.
+//
+// ⚠️ Ce test existe à cause d'une panne en production. `appliquerEtat` était défini dans un bloc
+// de script, et l'abonnement à la diffusion écrit dans le SUIVANT — autre portée. La référence
+// n'existait pas, la ReferenceError partait dans un try/catch muet, et l'audience n'avait aucun
+// écouteur d'état. Invisible pendant tout le temps où une seconde voie (lecture de table) portait
+// la page ; « les pages ne tournent plus » le jour où on l'a retirée pour fermer une fuite.
+//
+// La leçon : deux voies qui font la même chose ne se valident pas l'une l'autre. Tant que la
+// seconde existait, aucun test ne pouvait dire laquelle marchait. On exécute donc la page.
+
+// ⚠️ AVANT de requérir le gestionnaire : il déstructure ses dépendances au chargement, donc une
+// substitution plus tardive n'aurait aucun effet — il partirait chercher la vraie base.
+const PRESENTATION_ID = require.resolve("../presentations.js");
+const vraiesPresentations = require("../presentations.js");
+const PRESENTATION = {
+  slug: "Ab3-_xYz9012", doc_title: "Démo", file_name: "demo.pdf",
+  file_url: "https://exemple.supabase.co/storage/v1/object/public/resources/demo.pdf",
+  current_page: 1, active: true, updated_at: "2026-08-13T00:00:00.000Z",
+};
+require.cache[PRESENTATION_ID] = {
+  id: PRESENTATION_ID, filename: PRESENTATION_ID, loaded: true,
+  exports: { ...vraiesPresentations, getPresentation: async () => ({ ...PRESENTATION }), listMessages: async () => [] },
+};
+
+const player = require("../handler.js");
+
+function contexteMinimal() {
+  return {
+    plugins: {}, has: () => false,
+    storage: { isAllowedUrl: () => true, async fetchFile() { return null; }, async put() {} },
+    db: { async request() { return []; }, async selectAll() { return []; } },
+    mail: { async send() {} },
+    identity: { async verifyToken() { return null; }, roleOf: () => "", isAdmin: () => false, async canManageShares() { return false; } },
+    limits: { async allow() { return true; } },
+    branding: { async logo() { return ""; }, name: "", poweredBy: "", loaderName: "", async forKey() { return null; }, title: (b) => b },
+    errors: { async capture() {} },
+    legal: { sourceUrl: "", legalUrl: "", privacyUrl: "", trackingNotice: "" },
+    config: { supabaseUrl: "https://exemple.supabase.co", supabasePublishableKey: "cle", mapsKey: "", extraFrameAncestors: [] },
+  };
+}
+
+async function pageAudience() {
+  player.init(contexteMinimal());
+  const res = {
+    statusCode: 0, headers: {}, body: "",
+    setHeader(k, v) { this.headers[k.toLowerCase()] = v; },
+    end(b) { this.body = String(b == null ? "" : b); },
+  };
+  await player.handler({ method: "GET", headers: {}, socket: {}, query: { present: PRESENTATION.slug } }, res);
+  return res.body;
+}
+
+describe("page audience", () => {
+  it("expose vraiment le gestionnaire que la couche live doit brancher", async () => {
+    const html = await pageAudience();
+
+    // ⚠️ On EXÉCUTE la page. Le test statique ne pouvait pas voir le défaut : le code fautif
+    // contenait bien l'appel à onState — il référençait simplement un nom absent de cette
+    // portée-là. Seule l'exécution distingue « écrit » de « branché ».
+    window.supabase = { createClient: () => ({ channel: () => { const c = { on: () => c, subscribe: () => c }; return c; } }) };
+    for (const m of html.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)) {
+      // `window.eval` et pas `new Function` : les scripts déclarent des `var` au niveau global,
+      // qu'une portée de fonction rendrait invisibles au bloc suivant — c'est exactement le
+      // genre de nuance de portée qui a produit le bug.
+      try { window.eval(m[1]); } catch { /* les scripts qui dépendent de pdf.js ne nous intéressent pas */ }
+    }
+
+    expect(typeof window.__presAppliquerEtat,
+      "le gestionnaire d'état n'est pas exposé : la couche live, définie dans un autre bloc, ne peut pas le brancher")
+      .toBe("function");
+  });
+
+  it("branche ce gestionnaire-là, et pas un nom hors de portée", async () => {
+    const html = await pageAudience();
+    expect(html).toContain("Live.onState(window.__presAppliquerEtat)");
+  });
+
+  // Il ne doit plus rester une seule voie qui exige une table lisible publiquement.
+  it("n'ouvre aucun abonnement à une table", async () => {
+    expect(await pageAudience()).not.toContain("postgres_changes");
+  });
+
+  // Un câblage raté doit se dire. C'est le silence, pas le bug, qui a coûté la journée.
+  it("crie si la couche live manque, au lieu d'avaler l'erreur", async () => {
+    expect(await pageAudience()).toContain("console.error('[present]");
+  });
+});

package/server/handler.js

@@ -230,6 +230,17 @@ var Live=(function(){
   // État de la présentation diffusé par le présentateur — même canal que la carte. Sert à se
   // passer de la lecture anonyme des tables : l'audience n'a plus besoin de lire la ligne.
   function sendState(p){try{if(ch)ch.send({type:'broadcast',event:'state',payload:p});}catch(e){}}
+  // CHAT EN DIFFUSION. Les messages arrivaient jusqu'ici par la lecture de TABLE en temps réel,
+  // qui exige que cette table soit lisible publiquement — donc, avec la clé publiable, les
+  // conversations de TOUTES les présentations, pas seulement la sienne. C'était le dernier
+  // obstacle avant de pouvoir fermer cette lecture.
+  // L'émetteur diffuse la ligne que le serveur vient d'écrire ; les autres l'ajoutent chez eux.
+  // ⚠️ La diffusion ne revient pas à son émetteur : il ajoute donc SA copie lui-même.
+  function sendMsg(m){if(!m)return;try{if(ch)ch.send({type:'broadcast',event:'msg',payload:m});}catch(e){}}
+  function sendMsgUpd(m){if(!m)return;try{if(ch)ch.send({type:'broadcast',event:'msg-upd',payload:m});}catch(e){}}
+  // Édition, suppression, réaction : le serveur renvoie la ligne à jour, on l'applique chez soi
+  // puis on la diffuse. Même chemin pour les trois — une seule façon de se tromper.
+  function majDiffusee(r){return r.json().then(function(d){if(d&&d.ok&&d.message){updateMsg(d.message);sendMsgUpd(d.message);}}).catch(function(){});}
   function onState(fn){_onState=fn;}
   // Badge « non lus » sur le bouton chat/FAB (panneau fermé) + pulse du FAB. Aperçu (ticker) au nouveau message.
   function chatHidden(){var pn=document.getElementById('chatPanel');return !pn||pn.classList.contains('hidden');}
@@ -276,17 +287,23 @@ var Live=(function(){
   function cmClass(m){return Player.chat.messageClassName(m,ME,isMentioned(m));}
   function hydratePdf(d,m){if(m&&m.attachment&&m.attachment.kind==='pdf'&&!m.deleted){var ph=d.querySelector('.cm-att-ph');if(ph)pdfThumb(m.attachment.url,ph);}}
   function pdfThumb(url,ph){if(!ph)return;if(pdfCache[url]){ph.innerHTML='<img src="'+pdfCache[url]+'" alt="">';return;}if(!window.pdfjsLib)return;try{pdfjsLib.getDocument(url).promise.then(function(pdf){return pdf.getPage(1);}).then(function(pg){var v0=pg.getViewport({scale:1}),sc=Math.min(1.6,208/v0.width),vp=pg.getViewport({scale:sc}),cv=document.createElement('canvas');cv.width=Math.ceil(vp.width);cv.height=Math.ceil(vp.height);return pg.render({canvasContext:cv.getContext('2d'),viewport:vp}).promise.then(function(){var u=cv.toDataURL('image/jpeg',0.8);pdfCache[url]=u;ph.innerHTML='<img src="'+u+'" alt="">';});}).catch(function(){});}catch(e){}}
-  function addMsg(m){if(m.id&&seen[m.id])return;if(m.id)seen[m.id]=1;var box=document.getElementById('chatMsgs');if(!box)return;var em=box.querySelector('.chat-empty');if(em)em.remove();
+  // Renvoie true seulement si le message a réellement été AJOUTÉ. Pendant la transition, il
+  // arrive par deux voies (diffusion et lecture de table) : sans cette réponse, l'affichage était
+  // bien dédoublonné mais le compteur de non-lus comptait deux fois — une pastille à 2 pour un
+  // seul message. Le dédoublonnage doit valoir pour tout ce qui suit l'arrivée, pas seulement
+  // pour le rendu.
+  function addMsg(m){if(m.id&&seen[m.id])return false;if(m.id)seen[m.id]=1;var box=document.getElementById('chatMsgs');if(!box)return;var em=box.querySelector('.chat-empty');if(em)em.remove();
     if(m.id)msgData[m.id]=m;
     var d=document.createElement('div');d.className=cmClass(m);if(m.id)d.setAttribute('data-id',m.id);
     d.innerHTML=renderMsgInner(m);
-    if(m.id)msgEls[m.id]=d;box.appendChild(d);box.scrollTop=box.scrollHeight;hydratePdf(d,m);}
+    if(m.id)msgEls[m.id]=d;box.appendChild(d);box.scrollTop=box.scrollHeight;hydratePdf(d,m);
+    return true;}
   function updateMsg(m){if(!m.id)return;msgData[m.id]=m;var d=msgEls[m.id];if(!d)return;d.className=cmClass(m);d.innerHTML=renderMsgInner(m);hydratePdf(d,m);}
   function startEdit(id){var d=msgEls[id],m=msgData[id];if(!d||!m||m.deleted)return;var txt=d.querySelector('.txt');if(!txt)return;var inp=document.createElement('input');inp.className='cm-edit-in';inp.value=m.body||'';txt.replaceWith(inp);inp.focus();
-    function fin(save){var v=(inp.value||'').trim();if(save&&v&&v!==m.body){fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-msg-edit',slug:SLUG,msgId:+id,authorToken:authToken(),body:v})}).catch(function(){});}d.innerHTML=renderMsgInner(m);}
+    function fin(save){var v=(inp.value||'').trim();if(save&&v&&v!==m.body){fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-msg-edit',slug:SLUG,msgId:+id,authorToken:authToken(),body:v})}).then(majDiffusee).catch(function(){});}d.innerHTML=renderMsgInner(m);}
     inp.addEventListener('keydown',function(e){if(e.key==='Enter'){e.preventDefault();fin(true);}else if(e.key==='Escape'){fin(false);}});
     inp.addEventListener('blur',function(){fin(false);});}
-  function delMsg(id){fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-msg-delete',slug:SLUG,msgId:+id,authorToken:authToken(),control:CONTROL})}).catch(function(){});}
+  function delMsg(id){fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-msg-delete',slug:SLUG,msgId:+id,authorToken:authToken(),control:CONTROL})}).then(majDiffusee).catch(function(){});}
   // Modale de confirmation maison (l'iframe de présentation ne peut pas utiliser le useConfirm React). Repli window.confirm si absente.
   function confirmDialog(opts,onOk){opts=opts||{};var m=document.getElementById('lModal');if(!m){if(!onOk)return;if(window.confirm(opts.title||'Confirmer ?'))onOk();return;}
     var t=document.getElementById('lModalT'),d=document.getElementById('lModalD'),y=document.getElementById('lModalYes'),n=document.getElementById('lModalNo');
@@ -297,14 +314,17 @@ 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:reactorId()})}).catch(function(){});}
+  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:reactorId()})}).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,isPresenter:ME.role==='presenter',isMember:!!ME.member,body:t,authorToken:authToken()};
     if(CONTROL)o.control=CONTROL;
     if(replyCtx){o.replyTo=replyCtx.id;o.replyName=replyCtx.name;o.replyText=replyCtx.text;clearReply();}
-    fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(o)}).catch(function(){});}
+    fetch('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(o)})
+      .then(function(r){return r.json();})
+      .then(function(d){if(d&&d.ok&&d.message){addMsg(d.message);sendMsg(d.message);}})
+      .catch(function(){});}
   function uploadFile(file){if(!file||!ME||!sb)return;if(LOCKED&&!canMod())return;
     if(file.size>10*1024*1024){alert('Fichier trop volumineux (max 10 Mo).');return;}
     var s=document.getElementById('chatSend');if(s){s.disabled=true;s.textContent='…';}
@@ -377,8 +397,10 @@ var Live=(function(){
     try{sb=window.supabase.createClient(LIVECFG.supaUrl,LIVECFG.supaKey,{realtime:{params:{eventsPerSecond:10}}});
       ch=sb.channel('plive-'+slug,{config:{presence:{key:(me.email||me.name||'x')+':'+MYID}}});
       ch.on('presence',{event:'sync'},function(){renderPres(ch.presenceState());});
-      ch.on('postgres_changes',{event:'INSERT',schema:'public',table:'doc_presentation_messages',filter:'slug=eq.'+slug},function(p){if(p&&p.new){addMsg(p.new);notifyMsg(p.new);}});
-      ch.on('postgres_changes',{event:'UPDATE',schema:'public',table:'doc_presentation_messages',filter:'slug=eq.'+slug},function(p){if(p&&p.new)updateMsg(p.new);});
+      // Plus d'abonnement à la table des messages : elle n'est plus publiée ni lisible
+      // publiquement. Tout passe par la diffusion, et l'historique par la route de chat.
+      ch.on('broadcast',{event:'msg'},function(p){if(p&&p.payload&&addMsg(p.payload))notifyMsg(p.payload);});
+      ch.on('broadcast',{event:'msg-upd'},function(p){if(p&&p.payload)updateMsg(p.payload);});
       ch.on('broadcast',{event:'typing'},function(p){onTyping(p&&p.payload);});
       ch.on('broadcast',{event:'lock'},function(p){if(p&&p.payload)applyLock(p.payload.locked);});
       ch.on('broadcast',{event:'map'},function(p){if(_onMap&&p&&p.payload)_onMap(p.payload);});
@@ -1994,6 +2016,12 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
     // diffusion temps réel. La règle d'ordre (terminée > carte > changement de doc > page) et la
     // re-validation du contenu vivent dans le module, pas ici.
     var _etatVu='';
+    // ⚠️ EXPOSÉ HORS DE CETTE FERMETURE, ET C'EST INDISPENSABLE. La couche Live est définie dans
+    // le bloc de script SUIVANT : y appeler onState avec ce nom-ci référence une fonction qui
+    // n'existe pas dans cette portée-là. L'exception partait dans un try/catch muet, donc
+    // l'audience n'avait aucun écouteur de diffusion — invisible tant que la lecture de table
+    // portait encore la page, puis « les pages ne tournent plus » le jour où on l'a retirée.
+    window.__presAppliquerEtat = appliquerEtat;
     function appliquerEtat(row){
       if(!row) return;
       // La table et la diffusion portent la même vérité : sans cette garde, chaque changement de
@@ -2020,16 +2048,13 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
     document.addEventListener('visibilitychange',function(){ if(document.visibilityState==='visible') relireEtat(); });
     window.addEventListener('online', relireEtat);
 
-    // Realtime : suivre la page courante + la fin de session (UPDATE de notre ligne).
-    try{
-      if(window.supabase && CFG.supaUrl && CFG.supaKey){
-        var sb=window.supabase.createClient(CFG.supaUrl, CFG.supaKey, {realtime:{params:{eventsPerSecond:5}}});
-        sb.channel('present-'+CFG.slug)
-          .on('postgres_changes',{event:'UPDATE',schema:'public',table:'doc_presentations',filter:'slug=eq.'+CFG.slug},function(payload){
-            appliquerEtat(payload && payload.new);
-          }).subscribe();
-      }
-    }catch(e){}
+    // ⚠️ PLUS D'ABONNEMENT À LA TABLE ICI. Il exigeait une lecture publique de
+    // de la table des présentations — donc, avec la clé publiable, TOUTES les présentations de
+    // l'instance. L'état arrive par diffusion du présentateur, et la relecture d'état ci-dessus
+    // rattrape les arrivées tardives et les retours d'onglet en interrogeant le serveur.
+    //
+    // Le laisser en place n'était pas neutre : il ouvrait un abonnement qui ne recevra jamais
+    // rien, ce qui donne l'impression que le suivi est branché alors qu'il ne l'est pas.
     // Si on rejoint alors que le présentateur est DÉJÀ sur une carte / Street View → l'afficher dès que Map3DD est prêt.
     if(CFG.content && (CFG.content.kind==='map'||CFG.content.kind==='streetview')){ var _mi=setInterval(function(){ if(window.Map3DD){ clearInterval(_mi); if(CFG.content.kind==='streetview')Map3DD.enterSV(CFG.content,false); else Map3DD.enter(CFG.content,false); } },100); setTimeout(function(){ clearInterval(_mi); },8000); }
   })();
@@ -2045,7 +2070,16 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
     // L'état arrive maintenant par DEUX voies : la table (historique) et la diffusion du
     // présentateur (nouvelle). Les deux passent par le même filtre, qui ignore un état déjà
     // appliqué — recevoir deux fois la même chose ne doit pas re-rendre la page.
-    try{ if(window.Live) Live.onState(appliquerEtat); }catch(e){}
+    // Par la référence exposée plus haut : le nom local n'existe pas dans cette portée-ci.
+    try{
+      if(!window.Live || !window.__presAppliquerEtat) throw new Error('couche live absente');
+      Live.onState(window.__presAppliquerEtat);
+    }catch(e){
+      // PLUS DE SILENCE ICI. Ce try/catch a avalé une ReferenceError : l'audience n'avait aucun
+      // ecouteur d'etat, ce qui ne se voyait pas tant qu'une seconde voie portait la page. Un
+      // cablage rate doit se dire, meme si la page continue de vivre.
+      console.error('[present] suivi de l etat non branche :', e && e.message);
+    }
     // « Reprendre la main » : si le membre connecté (même origine) devient propriétaire de CETTE présentation
     // (après un transfert), on affiche un bouton pour ouvrir la visionneuse en pilotage — sinon on ne peut pas
     // piloter depuis la page audience.
@@ -2243,7 +2277,11 @@ async function handler(req, res) {
             return jp(200, { ok: true });
           }
           if (body.action === "bot-history") return jp(200, { ok: true, messages: await docbot.listMessages(String(body.sessionId || "")) });
-          const blang = docbot.I18N_LANGS[String(body.lang || "").toLowerCase()] ? String(body.lang).toLowerCase() : null; // fr/inconnu → null (langue source)
+          // ⚠️ Même piège : un objet littéral répond à `constructor`. Sans `Object.hasOwn`, une
+          // langue « constructor » passait la garde et finissait interpolée dans le prompt du
+          // modèle sous la forme « function Object() { [native code] } ».
+          const langueDemandee = String(body.lang || "").toLowerCase();
+          const blang = Object.hasOwn(docbot.I18N_LANGS, langueDemandee) ? langueDemandee : null; // fr/inconnu → null (langue source)
           if (body.action === "bot-start") return jp(200, { ok: true, ...(await docbot.botStart(share, pages, mobile, String(body.intent || ""), blang)) });
           // Bascule de langue EN COURS de présentation : renvoie le script (traduit ou FR) — le client
           // remplace sa liste d'étapes et rejoue le message courant dans la nouvelle langue.

package/server/presentations.js

@@ -131,7 +131,13 @@ async function endPresentation(slug, control) {
 const ATT_KINDS = { "image/png": "image", "image/jpeg": "image", "image/webp": "image", "image/gif": "image", "application/pdf": "pdf" };
 async function createUploadUrl(slug, name, type) {
   const base = (process.env.SUPABASE_URL || "").replace(/\/+$/, ""); const KEY = process.env.SUPABASE_SERVICE_ROLE_KEY || "";
-  const kind = ATT_KINDS[String(type || "").toLowerCase()];
+  // ⚠️ `Object.hasOwn` et pas une simple lecture : un objet littéral hérite de `constructor`,
+  // `toString`, `valueOf`, `__proto__`… `ATT_KINDS["constructor"]` rend une FONCTION, donc une
+  // valeur vraie — la garde juste en dessous laissait alors passer un type qui n'a jamais été
+  // autorisé, et signait une URL d'envoi pour lui. Le type est fourni par l'appelant, sur une
+  // action publique. Signalé par un hôte tiers qui venait de trouver la même forme chez lui.
+  const demande = String(type || "").toLowerCase();
+  const kind = Object.hasOwn(ATT_KINDS, demande) ? ATT_KINDS[demande] : null;
   if (!kind || !slug || !base || !KEY) return { ok: false, status: 400 };
   const safe = (String(name || "fichier").replace(/[^a-zA-Z0-9._-]/g, "_").slice(-60)) || "fichier";
   const path = `${String(slug).replace(/[^a-zA-Z0-9._-]/g, "")}/${Date.now()}-${crypto.randomBytes(4).toString("hex")}-${safe}`;
@@ -142,6 +148,33 @@ async function createUploadUrl(slug, name, type) {
   return { ok: true, path, token, kind, publicUrl: `${base}/storage/v1/object/public/present-attachments/${path}` };
 }
 
+/**
+ * Les champs d'un message qui ont le droit de sortir du serveur.
+ *
+ * ⚠️ LISTE BLANCHE, jamais une liste noire. `author_hash` est l'empreinte du jeton qui autorise
+ * à éditer et supprimer ce message : le diffuser à toute l'audience donnerait à chacun le droit
+ * de réécrire les messages des autres. Une ligne de table renvoyée telle quelle emporterait ce
+ * champ sans que personne ne le remarque — d'où la projection explicite, ici et nulle part
+ * ailleurs. C'est le même jeu de champs que celui servi à l'historique.
+ */
+const CHAMPS_PUBLICS = [
+  "id", "author_name", "author_email", "author_avatar", "is_presenter", "is_member",
+  "body", "attachment", "reactions", "reply_to", "reply_name", "reply_text",
+  "deleted", "edited", "created_at",
+];
+function messagePublic(row) {
+  if (!row || typeof row !== "object") return null;
+  const out = {};
+  for (const c of CHAMPS_PUBLICS) if (c in row) out[c] = row[c];
+  return out;
+}
+
+/** Renvoie la ligne telle qu'elle est après écriture — sans jamais renvoyer plus que le public. */
+function premierPublic(reponse) {
+  const row = Array.isArray(reponse) ? reponse[0] : reponse;
+  return messagePublic(row);
+}
+
 async function addMessage(slug, { name, email, avatar, isPresenter, isMember, body, replyTo, replyName, replyText, authorToken, attachment }) {
   const b = String(body || "").trim().slice(0, 2000);
   const base = (process.env.SUPABASE_URL || "").replace(/\/+$/, "");
@@ -159,8 +192,10 @@ 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,
   };
-  await PLAYER.db.request("doc_presentation_messages", { method: "POST", headers: { Prefer: "return=minimal" }, body: [row] });
-  return { ok: true };
+  // `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) };
 }
 
 async function listMessages(slug) {
@@ -175,8 +210,8 @@ async function editMessage(slug, msgId, authorToken, body) {
   const rows = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&select=author_hash,deleted&limit=1`);
   const m = Array.isArray(rows) && rows[0]; if (!m || m.deleted) return { ok: false, status: 404 };
   if (!m.author_hash || m.author_hash !== sha(authorToken)) return { ok: false, status: 403 };
-  await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { body: b, edited: true } });
-  return { ok: true };
+  const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { body: b, edited: true } });
+  return { ok: true, message: premierPublic(maj) };
 }
 
 // Supprimer (soft) : l'auteur (jeton) OU le présentateur (control_token de la présentation).
@@ -189,8 +224,8 @@ async function deleteMessage(slug, msgId, { authorToken, control }) {
   let byPresenter = false;
   if (!byAuthor && control) { const pres = await getPresentation(slug); byPresenter = !!(pres && tokenMatches(control, pres.control_hash)); }
   if (!byAuthor && !byPresenter) return { ok: false, status: 403 };
-  await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { deleted: true, body: "", reactions: {}, attachment: null } });
-  return { ok: true };
+  const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { deleted: true, body: "", reactions: {}, attachment: null } });
+  return { ok: true, message: premierPublic(maj) };
 }
 
 // Verrouiller / déverrouiller le chat (présentateur uniquement).
@@ -212,8 +247,8 @@ async function toggleReaction(slug, msgId, emoji, reactor) {
   const i = arr.indexOf(who);
   if (i >= 0) arr.splice(i, 1); else arr.push(who);
   if (arr.length) cur[e] = arr; else delete cur[e];
-  await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { reactions: cur } });
-  return { ok: true };
+  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) };
 }
 
 // ── Statistiques de présentation (assistance) ────────────────────────────────────────────────────────────
@@ -316,4 +351,5 @@ async function listPresentationsForDoc(docId) {
   return list.map((p) => ({ slug: p.slug, presenterName: p.presenter_name, ownerName: p.owner_name, currentPage: p.current_page || 1, active: !!p.active, createdAt: p.created_at, endedAt: p.active ? null : p.updated_at, attendees: counts[p.slug] || 0 }));
 }
 
-module.exports = { init, createPresentation, getPresentation, setPage, endPresentation, addMessage, listMessages, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent };
+module.exports = {
+  messagePublic, CHAMPS_PUBLICS, init, createPresentation, getPresentation, setPage, endPresentation, addMessage, listMessages, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent };

package/supabase/init.sql

@@ -223,10 +223,22 @@ alter table public.doc_presentation_attendees        enable row level security;
 alter table public.doc_bot_sessions                  enable row level security;
 
 -- ── Temps réel ─────────────────────────────────────────────────────────────────────────────────
--- Le chat en direct reste en `postgres_changes` : ses messages sont écrits POUR être vus de
--- l'audience. L'état de la présentation, lui, voyage en broadcast — d'où l'absence de
--- `doc_presentations` ici, et l'absence de politique de lecture au-dessus.
--- ⚠️ Ne mettez jamais de donnée confidentielle dans un message de chat ni dans un nom d'auteur.
+-- L'état de la présentation (page courante, carte, verrou) voyage en BROADCAST : l'audience suit
+-- le présentateur sans qu'aucune table ne soit lisible publiquement. C'est ce qui permet de ne
+-- créer aucune politique de lecture au-dessus.
+--
+-- ⚠️ LE CHAT N'EST PAS ENCORE SUR CE CHEMIN. Ses messages sont livrés par `postgres_changes`, qui
+-- exige un SELECT au niveau de la TABLE — donc ouvert à quiconque détient la clé publiable, et
+-- pour TOUTES les présentations, pas seulement la sienne. Ce fichier refuse ce compromis : la
+-- table est publiée, mais AUCUNE politique de lecture n'est créée.
+--
+-- Conséquence assumée sur une installation neuve : un participant voit l'historique du chat en
+-- arrivant, et les messages suivants à l'actualisation — pas en direct. Le chat n'est pas cassé,
+-- il est différé. Le portage du chat en broadcast lèvera cette limite ; d'ici là, mieux vaut une
+-- fonctionnalité partiellement en retard qu'une base où chacun lit les conversations des autres.
+--
+-- ⚠️ Ne mettez de toute façon jamais de donnée confidentielle dans un message de chat ni dans un
+-- nom d'auteur.
 do $$
 begin
   if exists (select 1 from pg_publication where pubname = 'supabase_realtime') then