discovery-media-player 0.1.56 → 0.1.58

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/docs/HOST-CONTRACT.md

@@ -31,7 +31,8 @@ need.
   "separateIssuer": true,
   "hostShare": true,
   "hostMail": true,
-  "plugins": { "bot": false, "visitors": false, "brandIntro": false, "botBrowser": false, "providerQuotas": false }
+  "plugins": { "bot": false, "visitors": false, "brandIntro": false, "botBrowser": false, "providerQuotas": false },
+  "schema": { "attendues": 3, "sondees": 1, "manquant": [] }
 }
 ```
 
@@ -39,6 +40,18 @@ need.
 never by order. `plugins` lets you refuse to start when you depend on an optional module this
 instance does not have.
 
+⚠️ **`schema` tells you which migrations this instance is still waiting for.** The player never
+applies migrations — it cannot, it only speaks PostgREST — so it *detects* instead, and a missing
+column makes the feature that needs it **degrade silently**, by design, so as not to break a host
+mid-migration. That silence is the point: an operator whose write ordering and message idempotency
+are both switched off sees an instance that looks perfectly healthy. Each entry names the file to
+apply and the feature that is asleep.
+
+⚠️ **`sondees` is not decoration.** The card **reports** what this process has already asked; it
+never probes, because a diagnostic must answer when the database does not. A freshly started
+process therefore knows nothing, and `manquant: []` on `sondees: 0` means *no question asked yet*,
+not *nothing missing*. Compare `sondees` with `attendues` before you conclude.
+
 ⚠️ **`frameAncestors` matters more than it looks.** A host that is not listed will never see the
 viewer: the browser blocks the iframe **before any script runs**, so no message can be emitted and
 the host sees a silence indistinguishable from an unreachable instance. Check that your domain is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "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");
@@ -436,7 +438,12 @@ var Live=(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;
@@ -1558,24 +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; }
 
-  // ⚠️ UN PLAFOND, ET IL REFUSE AVANT D'ALLOUER. Ce relais chargeait le fichier ENTIER en mémoire
-  // sans borne : un PDF de 80 Mo, trois requêtes Range simultanées, et une fonction serverless
-  // tombe — pas pour un document en particulier, pour la somme. Le défaut n'est pas la taille d'un
-  // fichier, c'est l'absence de toute limite haute.
+  // ⚠️ DEUX BORNES, ET LA SECONDE EST LA SEULE QUI TIENNE DEVANT UN AMONT QUI MENT.
   //
-  // ⚠️ ON REGARDE `Content-Length` AVANT DE LIRE LE CORPS : refuser après l'allocation ne protège
-  // de rien, c'est l'allocation qui coûte. Un amont qui n'annonce pas sa taille passe quand même —
-  // on ne peut pas refuser ce qu'on ne sait pas mesurer, et fermer par défaut couperait des
-  // stockages parfaitement légitimes. La borne est donc une garde contre le GROS, pas contre
-  // l'inconnu ; c'est ce que le streaming, lui, fermera vraiment.
-  const annoncee = Number(r.headers.get("content-length") || 0);
+  // 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;
   }
-  const buf = Buffer.from(await r.arrayBuffer());
+
   res.statusCode = r.status;
   const typeAmont = r.headers.get("content-type") || "application/pdf";
   const executable = TYPES_EXECUTABLES.test(typeAmont);
@@ -1591,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.
@@ -3309,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 }); }
       }
@@ -3422,10 +3476,7 @@ async function handler(req, res) {
             // capable d'expédier en son nom : le repli silencieux ouvrirait exactement la porte que
             // la séparation ferme. On nomme le fichier à appliquer et on s'arrête.
             if (atteste) {
-              const pret = await require("./schema").aLaColonne(
-                "commercial_doc_shares", "attested_recipient_email",
-                "supabase/migrations/0001-destinataire-atteste.sql",
-              );
+              const pret = await require("./schema").attendue("destinataireAtteste");
               if (!pret) {
                 return jd(409, { ok: false, error: "migration", message: "Destinataire attesté indisponible : appliquez supabase/migrations/0001-destinataire-atteste.sql." });
               }
@@ -3770,6 +3821,14 @@ async function handler(req, res) {
         // l'hôte connaît déjà son émetteur — il veut seulement savoir si l'instance le regarde.
         // Dire lequel n'aiderait personne et renseignerait qui sonde.
         separateIssuer: !!(PLAYER.config && PLAYER.config.separateIssuer),
+        // ⚠️ L'ÉTAT DU SCHÉMA, LÀ OÙ ON REGARDE. Une colonne absente était signalée par un
+        // `console.warn`, une fois par processus : sur une fonction serverless, une ligne perdue
+        // dans une sortie que personne n'ouvre tant que tout a l'air de marcher — et « tout a
+        // l'air de marcher » est exactement l'état d'un hôte dont trois protections dorment. Cette
+        // carte est ce qu'un hôte interroge déjà pour épingler sa version ; c'est donc ici.
+        // Elle RAPPORTE ce qui est connu, elle ne sonde pas : un diagnostic ne doit pas tomber en
+        // même temps que ce qu'il diagnostique.
+        schema: require("./schema").etatDuSchema(),
         // « L'hôte peut-il créer un lien en son nom propre ? » — configuré, pas seulement
         // possible. Un hôte qui oublie le secret reçoit un 401 qui ressemble à un droit
         // manquant ; ce booléen le lui dit sans qu'il ait à essayer.

package/server/presentations.js

@@ -54,9 +54,7 @@ async function reclaimPresentation(slug, email) {
   // ⚠️ Et j'ai écrit ce champ sans condition en premier jet, ce qui est exactement le piège que
   // docs/MIGRATIONS.md décrit : PostgREST rejette le PATCH ENTIER si la colonne manque. La reprise
   // aurait cessé de fonctionner chez tout hôte non migré — pas la nouvelle garantie, la reprise.
-  const rangDispo = await require("./schema").aLaColonne(
-    "doc_presentations", "write_seq", "supabase/migrations/0002-ordre-des-ecritures.sql",
-  );
+  const rangDispo = await require("./schema").attendue("rangEcriture");
   await PLAYER.db.request(`doc_presentations?slug=eq.${enc(slug)}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { control_hash: sha(control), active: true, ...(rangDispo ? { write_seq: 0 } : {}), last_seen: new Date().toISOString(), updated_at: new Date().toISOString() } });
   return { ok: true, slug, control, page: row.current_page || 1, fileUrl: row.file_url, fileName: row.file_name, docTitle: row.doc_title, docId: row.doc_id };
 }
@@ -200,9 +198,7 @@ async function getPresentation(slug) {
 async function rangAccepte(row, seq) {
   const rang = Number(seq);
   if (!Number.isFinite(rang) || rang <= 0) return { controle: false };   // client plus ancien : pas de rang
-  const dispo = await require("./schema").aLaColonne(
-    "doc_presentations", "write_seq", "supabase/migrations/0002-ordre-des-ecritures.sql",
-  );
+  const dispo = await require("./schema").attendue("rangEcriture");
   if (!dispo) return { controle: false };
   if (rang <= Number(row.write_seq || 0)) return { controle: true, perime: true };
   // ⚠️ ON REND LE RANG, PAS UN OBJET TOUT FAIT. La première version rendait « { write_seq: rang } »,
@@ -403,7 +399,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
@@ -424,10 +420,40 @@ 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").attendue("envoiUnique")) {
+    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 };
+  }
 }
 
 /**

package/server/schema.js

@@ -16,6 +16,34 @@
 // chantiers ont été repoussés pour cette seule raison. Avec cette sonde, l'ordre de déploiement
 // cesse d'être un piège.
 
+/**
+ * CE QUE CE CODE ATTEND DE LA BASE — DÉCLARÉ UNE FOIS, ET C'EST LA SOURCE.
+ *
+ * ⚠️ UN INVENTAIRE QUI N'EST PAS LA SOURCE DÉRIVE. Ces couples vivaient recopiés sur quatre
+ * appels ; en tirer une simple liste « pour l'affichage » aurait refait, en plus petit, le défaut
+ * qui a vidé supabase/init.sql de ses cinq migrations : deux exemplaires du même fait, personne
+ * pour les confronter. Les appelants passent donc par `attendue(nom)` et ne nomment plus de
+ * colonne — il n'existe plus qu'un endroit où se tromper. Une étape de la forge vérifie en outre
+ * que chaque fichier nommé ici existe, et qu'aucun appel ne contourne cette table.
+ */
+const ATTENDUES = {
+  destinataireAtteste: {
+    table: "commercial_doc_shares", colonne: "attested_recipient_email",
+    migration: "supabase/migrations/0001-destinataire-atteste.sql",
+    fonction: "attribuer une lecture au destinataire attesté par l'hôte",
+  },
+  rangEcriture: {
+    table: "doc_presentations", colonne: "write_seq",
+    migration: "supabase/migrations/0002-ordre-des-ecritures.sql",
+    fonction: "refuser une écriture de pilotage doublée en vol",
+  },
+  envoiUnique: {
+    table: "doc_presentation_messages", colonne: "client_key",
+    migration: "supabase/migrations/0005-envoi-unique.sql",
+    fonction: "empêcher qu'un renvoi crée un second message",
+  },
+};
+
 let PLAYER = null;
 /**
  * Une question posée une fois, retenue pour le processus.
@@ -28,9 +56,59 @@ let PLAYER = null;
  */
 const connues = new Map();
 
+/**
+ * Les réponses DÉJÀ OBTENUES, pour qui veut les lire — la carte d'identité, essentiellement.
+ *
+ * ⚠️ CE N'EST PAS UN DOUBLON DE `connues`. Celle-ci porte des promesses, dont on ne peut rien dire
+ * sans les attendre ; celle-là porte des réponses. La distinction compte parce que la carte
+ * d'identité ne doit RIEN demander à la base — elle doit répondre quand la base ne répond plus.
+ */
+const reponses = new Map();
+
 function init(ctx) {
   PLAYER = ctx;
   connues.clear();
+  reponses.clear();
+}
+
+/** La sonde d'une attente déclarée. C'est la seule forme d'appel que les appelants utilisent. */
+function attendue(nom) {
+  const a = ATTENDUES[nom];
+  // Un nom inconnu est une faute de frappe, pas une dégradation : la taire ferait passer la
+  // fonction pour « en attente de migration » alors qu'elle est simplement mal câblée.
+  if (!a) throw new Error(`attente de schéma inconnue : ${nom}`);
+  return aLaColonne(a.table, a.colonne, a.migration);
+}
+
+/**
+ * ⚠️ CE QUE LE JOURNAL NE DIRA JAMAIS À PERSONNE.
+ *
+ * La sonde signale une colonne absente par un `console.warn`, une fois par processus. Sur une
+ * fonction serverless, c'est une ligne perdue dans une sortie que personne n'ouvre quand tout a
+ * l'air de marcher — et « tout a l'air de marcher » est précisément l'état d'un hôte dont trois
+ * protections dorment. Remarque du second hôte, et elle est juste : la trace existait à l'endroit
+ * exact où on ne regarde pas.
+ *
+ * ⚠️ ON NE SONDE PAS ICI, ON RAPPORTE. La carte d'identité doit répondre quand la base ne répond
+ * plus ; sonder depuis elle en ferait un diagnostic qui tombe en même temps que ce qu'il diagnostique.
+ *
+ * ⚠️ D'OÙ TROIS ÉTATS, ET PAS DEUX. Un processus qui n'a encore rien demandé ne sait rien — et
+ * « rien de manquant » se lirait « tout va bien ». Une absence de résultat ressemble à un
+ * résultat ; `sondees` est là pour qu'on ne puisse pas les confondre.
+ */
+function etatDuSchema() {
+  const manquant = [];
+  for (const [, r] of reponses) if (!r.present) manquant.push({ migration: r.migration, fonction: r.fonction });
+  return {
+    attendues: Object.keys(ATTENDUES).length,
+    sondees: reponses.size,
+    // ⚠️ ON NOMME LE FICHIER, alors que cette route est publique. Même raison que `frameAncestors`
+    // juste au-dessus d'elle : l'exploitant n'a AUCUN autre moyen d'apprendre laquelle manque, et
+    // un compte nu le laisserait deviner. Ce qu'on révèle en échange — qu'une fonction de
+    // fiabilité est en attente, dans un dépôt dont les migrations sont publiques — n'ouvre aucun
+    // accès : il faut déjà détenir un jeton de pilotage pour tirer parti d'un rang absent.
+    manquant,
+  };
 }
 
 /**
@@ -67,6 +145,7 @@ async function sonder(table, colonne, migration, cle) {
     // portage a un fichier à réécrire, pas une habitude à retrouver partout.
     const champ = encodeURIComponent(colonne);
     await PLAYER.db.request(`${table}?select=${champ}&limit=0`);
+    noter(cle, true, migration);
     return true;
   } catch {
     // ⚠️ ON NE DISTINGUE PAS « COLONNE ABSENTE » DE « BASE INJOIGNABLE », ET C'EST VOULU. Les deux
@@ -74,11 +153,18 @@ async function sonder(table, colonne, migration, cle) {
     // message d'erreur, c'est-à-dire de dépendre du texte d'un service tiers. Ce qui change entre
     // les deux, c'est la durée : une base injoignable le redevient, et le processus suivant reposera
     // la question.
+    noter(cle, false, migration);
     signaler(cle, migration);
     return false;
   }
 }
 
+/** La réponse, retenue pour qui la demandera — sans repasser par la base. */
+function noter(cle, present, migration) {
+  const a = Object.values(ATTENDUES).find((x) => `${x.table}.${x.colonne}` === cle);
+  reponses.set(cle, { present, migration, fonction: a ? a.fonction : "" });
+}
+
 /**
  * ⚠️ ON NOMME LE FICHIER, PAS L'ERREUR. « column does not exist » envoie l'exploitant lire du
  * PostgREST ; « appliquez supabase/migrations/0001-…sql » lui dit quoi faire. La différence entre
@@ -92,6 +178,6 @@ function signaler(cle, migration) {
 }
 
 /** Pour les tests et l'exploitation : reposer la question. */
-function oublier() { connues.clear(); }
+function oublier() { connues.clear(); reponses.clear(); }
 
-module.exports = { init, aLaColonne, oublier };
+module.exports = { init, aLaColonne, attendue, etatDuSchema, oublier, ATTENDUES };

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;