discovery-media-player 0.1.47 → 0.1.49

package/context/standalone.js

@@ -121,18 +121,100 @@ async function appelHote(url, secret, corps, errors) {
  * limite réelle est donc N fois celle annoncée. C'est suffisant pour freiner une boucle, pas pour
  * contenir un attaquant déterminé. Un hôte sérieux branche un compteur partagé dans son câblage.
  */
-function creerLimites() {
+/**
+ * Les limites de débit, comptées pour l'INSTANCE et non pour le processus.
+ *
+ * ⚠️ UN COMPTEUR EN MÉMOIRE EST DIVISÉ PAR LE NOMBRE D'INSTANCES, ET RIEN NE LE DIT. En serverless,
+ * plusieurs exécutions servent en parallèle et démarrent à froid : une limite de 120 par heure en
+ * autorise 120 PAR INSTANCE. Elle existe, elle rassure, et elle ne limite qu'une fraction de ce
+ * qu'elle annonce. C'est le second hôte qui l'a relevé chez lui — il tourne sur ce contexte, et ne
+ * s'en était pas aperçu avant qu'on lui pose la question.
+ *
+ * ⚠️ DEUX ÉTAGES, ET LE PREMIER NE PEUT PAS SE TROMPER. Le compteur local ne voit que ce que CE
+ * processus a servi : il sous-compte toujours par rapport au partagé. Donc s'il dépasse déjà le
+ * plafond, le partagé le dépasse aussi — un refus local est toujours juste, et il ne coûte aucun
+ * aller-retour. C'est l'abus qui se refuse gratuitement, pas le trafic légitime.
+ *
+ * ⚠️ LE CHEMIN DE LECTURE RESTE LOCAL, ET C'EST UN ARBITRAGE ASSUMÉ. Les relectures publiques
+ * (`pread:`) sont servies depuis un cache mémoire par slug, précisément pour ne rien coûter à la
+ * base. Y adosser un compteur partagé ferait payer à la garde le prix qu'on venait d'épargner à ce
+ * qu'elle garde. Sur ce chemin, la protection réelle est le cache, pas le compteur.
+ *
+ * ⚠️ LE COMPTE PARTAGÉ N'EST PAS ATOMIQUE. PostgREST ne sait pas exprimer « incrémente » : c'est une
+ * lecture puis une écriture. Deux instances peuvent donc lire la même valeur et n'en écrire qu'une —
+ * le compteur SOUS-estime sous forte concurrence. Pour une limite de débit, sous-estimer signifie
+ * laisser passer un peu plus, jamais refuser à tort. Le dire vaut mieux que laisser croire à une
+ * exactitude qu'on n'a pas.
+ */
+function creerLimites(db, journal) {
   const seaux = new Map();
+  const PREFIXES_LOCAUX = ["pread:"];
+  let partageDisponible = null;   // null = pas encore demandé
+  let signale = false;
+
+  /** Le compteur local : sert de refus rapide, et de repli complet quand la table manque. */
+  function localAutorise(cle, max, fenetreSecondes) {
+    const maintenant = Date.now();
+    const debut = maintenant - fenetreSecondes * 1000;
+    const vus = (seaux.get(cle) || []).filter((t) => t > debut);
+    if (vus.length >= max) { seaux.set(cle, vus); return false; }
+    vus.push(maintenant);
+    seaux.set(cle, vus);
+    if (seaux.size > 5000) for (const [k, v] of seaux) if (!v.some((t) => t > debut)) seaux.delete(k);
+    return true;
+  }
+
+  async function tablePresente() {
+    if (partageDisponible !== null) return partageDisponible;
+    try {
+      await db.request("player_rate_limits?select=key&limit=0");
+      partageDisponible = true;
+    } catch {
+      partageDisponible = false;
+      if (!signale) {
+        signale = true;
+        try {
+          journal.capture(new Error(
+            "compteurs de débit non partagés : appliquez supabase/migrations/0003-limites-partagees.sql. "
+            + "Sans elle, chaque instance compte pour elle seule et les limites sont plus lâches qu'annoncé.",
+          ), { route: "limits" });
+        } catch { /* jamais bloquant */ }
+      }
+    }
+    return partageDisponible;
+  }
+
   return {
     async allow(cle, max, fenetreSecondes) {
-      const maintenant = Date.now();
-      const debut = maintenant - fenetreSecondes * 1000;
-      const vus = (seaux.get(cle) || []).filter((t) => t > debut);
-      if (vus.length >= max) { seaux.set(cle, vus); return false; }
-      vus.push(maintenant);
-      seaux.set(cle, vus);
-      if (seaux.size > 5000) for (const [k, v] of seaux) if (!v.some((t) => t > debut)) seaux.delete(k);
-      return true;
+      // Étage 1 : le refus local est toujours juste, et gratuit.
+      if (!localAutorise(cle, max, fenetreSecondes)) return false;
+      if (PREFIXES_LOCAUX.some((p) => String(cle).startsWith(p))) return true;
+      if (!(await tablePresente())) return true;
+
+      // Étage 2 : le compte partagé. ⚠️ Échec ouvert — une limite injoignable ne doit pas empêcher
+      // de lire un document. Un 429 raté coûte moins cher qu'une visionneuse morte.
+      try {
+        const fin = new Date(Date.now() + fenetreSecondes * 1000).toISOString();
+        const lignes = await db.request(`player_rate_limits?key=eq.${encodeURIComponent(cle)}&select=count,expires_at&limit=1`);
+        const ligne = Array.isArray(lignes) && lignes[0];
+        const vivante = ligne && new Date(ligne.expires_at).getTime() > Date.now();
+        if (!vivante) {
+          await db.request("player_rate_limits", {
+            method: "POST",
+            headers: { Prefer: "resolution=merge-duplicates,return=minimal" },
+            body: [{ key: String(cle), count: 1, expires_at: fin }],
+          });
+          return true;
+        }
+        if (Number(ligne.count || 0) >= max) return false;
+        await db.request(`player_rate_limits?key=eq.${encodeURIComponent(cle)}`, {
+          method: "PATCH", headers: { Prefer: "return=minimal" },
+          body: { count: Number(ligne.count || 0) + 1 },
+        });
+        return true;
+      } catch {
+        return true;
+      }
     },
   };
 }
@@ -401,7 +483,7 @@ function createStandaloneContext(env = process.env) {
       },
     },
 
-    limits: creerLimites(),
+    limits: creerLimites(db, journal),
 
     branding: {
       async logo() { return String(env.PLAYER_BRAND_LOGO || "").trim(); },

package/docs/HOST-CONTRACT.md

@@ -44,6 +44,56 @@ viewer: the browser blocks the iframe **before any script runs**, so no message
 the host sees a silence indistinguishable from an unreachable instance. Check that your domain is
 there before you open a document.
 
+## Counting the reads of a visitor you vouch for
+
+A host that identifies its own visitors — one-time code, project area — can have their reads counted,
+attributed and revocable, without either an anonymous link or a member's token. Pass
+`recipientEmail` on the server-to-server `docshare.create`: **the host vouches, the player stops
+believing the caller.**
+
+⚠️ **The address must never come from a browser request.** Read it server-side, from the visitor's
+session, at the same place that already decides whether they may see the document. A path that
+cannot phrase the request will never phrase it by accident.
+
+⚠️ **An attested link is named, not closed.** It remains forwardable: the reader is attributed, not
+verified. A host whose documents are confidential must not rely on it — that closes with an attested
+*reader*, which does not exist yet.
+
+The address is stored apart from `recipient_email`, and that separation is the whole point:
+`recipient_email` says *who may send in the link's name* when a recipient forwards it, and a vouched
+visitor never gained that right. Leaving it empty is what makes the send guard and the re-share
+inheritance both refuse — without either of them knowing why.
+
+Requires `supabase/migrations/0001-destinataire-atteste.sql`. Until it is applied the player refuses
+the attested creation and names the file; it never falls back to the other column.
+
+## ⚠️ What `limits.allow` promises changed
+
+It used to promise *best effort, per process*. The standalone context now counts in a **shared
+table**, so a limit means what it says for the **instance** rather than for one execution.
+
+This matters because nothing announced the difference: on serverless, several executions serve in
+parallel and start cold, so a limit of 120/hour allowed 120 **per instance**. It existed, it
+reassured, and it bounded a fraction of what it claimed.
+
+Requires `supabase/migrations/0003-limites-partagees.sql`. **Until it is applied, nothing breaks**:
+counting falls back to memory — the previous behaviour — and the host is told once, by name.
+
+Two deliberate exceptions, both written next to the code:
+
+- **The local counter stays in front, as a fast refusal.** It only ever sees what one process served,
+  so it under-counts: if *it* is already over the ceiling, the shared one is too. A local refusal is
+  therefore always right, and costs no round trip. Abuse is refused for free; legitimate traffic pays.
+- **The public read path (`pread:`) is counted locally only.** Those responses already come from a
+  per-slug memory cache, put there precisely so they cost the database nothing. Backing their guard
+  with a shared counter would make the guard pay the price we had just spared the thing it guards.
+  On that path the real protection is the cache, not the counter.
+
+⚠️ **The shared count is not atomic.** PostgREST cannot express "increment": it is a read then a
+write. Two instances can read the same value and write one. The counter therefore **under**-estimates
+under heavy concurrency — it lets a little more through, never refuses wrongly. Said plainly rather
+than implying a precision we do not have.
+
 ## The three things a host implements
 
 Everything the player borrows arrives through one injected object. Two of its entries carry

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "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/handler.js

@@ -29,6 +29,9 @@ function init(ctx) {
   require("./shares").init(ctx);
   require("./presentations").init(ctx);
   require("./brands").init(ctx);
+  // ⚠️ Réinitialisé avec le contexte : les réponses de la sonde valent pour UNE base. Un hôte qui
+  // rebranche son contexte sur un autre projet doit reposer la question, pas hériter des réponses.
+  require("./schema").init(ctx);
   docbot = ctx.plugins.bot;
   brandIntroRuntime = ctx.plugins.brandIntro && ctx.plugins.brandIntro.brandIntroRuntime;
   botBrowser = ctx.plugins.botBrowser;
@@ -2103,6 +2106,15 @@ ${LEGAL_CSS}
     //
     // Le rythme minimum remplace les deux ordonnanceurs qu'elle absorbe — un déplacement de carte à
     // la souris produirait sinon une écriture par image.
+    // ⚠️ LE RANG D'ÉCRITURE, ET POURQUOI IL VIT ICI. La file garantit une seule écriture en vol,
+    // donc l'ordre des DÉPARTS. Elle ne peut rien sur une requête abandonnée par le délai maximal :
+    // le navigateur cesse de l'attendre, il ne l'annule pas chez le serveur, et elle peut atterrir
+    // après celle qui l'a remplacée. Le rang ferme ce dernier cas.
+    //
+    // Remis à zéro à chaque prise de pilotage — démarrage ou reprise — parce qu'un jeton de contrôle
+    // neuf ouvre un nouveau domaine d'ordre côté serveur.
+    var _seq=0;
+    function prochainRang(){ return ++_seq; }
     var _file=null;
     function fileEcritures(){
       if(!_file&&window.Player&&Player.live&&Player.live.createFileEcritures){
@@ -2118,7 +2130,7 @@ ${LEGAL_CSS}
       if(!f) return envoyerPage(page);
       return f.poser('page',function(){ return envoyerPage(cur||page); }); }
     function envoyerPage(page){ if(!PRES)return Promise.resolve();
-      return Player.live.fetchBorne('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-page',slug:PRES.slug,control:PRES.control,page:page})})
+      return Player.live.fetchBorne('/api/doc',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'present-page',slug:PRES.slug,control:PRES.control,page:page,seq:prochainRang()})})
         .then(function(r){ if(r&&r.ok)diffuserEtat(); })
         .catch(function(){}); }
     // ⚠️ TROIS GESTES, ET L'ORDRE ÉTAIT LE PIRE DES SIX. On signalait la fin, puis on COUPAIT LE
@@ -2186,7 +2198,7 @@ ${LEGAL_CSS}
         .then(function(r){return r.json();}).then(function(d){
           if(btn){ btn.disabled=false; btn.textContent='Présenter'; }
           if(!d||!d.ok||!d.slug) return;
-          PRES={slug:d.slug,control:d.control}; saveCtl(d.slug,d.control);
+          PRES={slug:d.slug,control:d.control}; saveCtl(d.slug,d.control); _seq=0;
           showBar(d.slug); liveConnect(d.slug,d.control); startHb(); pushPage();
         }).catch(function(){ if(btn){ btn.disabled=false; btn.textContent='Présenter'; } });
     }
@@ -2198,7 +2210,7 @@ ${LEGAL_CSS}
       fetch('/api/doc',{method:'POST',headers:h,body:JSON.stringify({action:'present-reclaim',slug:slug})})
         .then(function(r){return r.json();}).then(function(d){
           if(!d||!d.ok||!d.control){ if(d&&d.status===403){ Player.bridge.sendToHost({type:'present-denied'}); } return; }
-          PRES={slug:slug,control:d.control}; saveCtl(slug,d.control);
+          PRES={slug:slug,control:d.control}; saveCtl(slug,d.control); _seq=0;
           showBar(slug); liveConnect(slug,d.control); startHb();
           var target=Math.max(1,d.page||1);
           var tries=0; (function jump(){ var el=(document.getElementById('pages')||document).querySelector('.page[data-p="'+target+'"]'); if(el){ el.scrollIntoView({block:'start'}); } else if(tries++<40){ setTimeout(jump,150); } })();
@@ -2409,6 +2421,53 @@ ${botOn && botBrowser ? botBrowser.botViewerJs(ICONS) : ""}
 
 // CSP de la page audience (Présenter) : autorise pdf.js (cdnjs), supabase-js (jsdelivr) et la connexion
 // Realtime (https + wss vers le projet Supabase). Plus permissive que la visionneuse, limitée à cette page.
+/**
+ * Les origines d'images qu'une page a le droit de charger.
+ *
+ * ⚠️ FOURNIR UNE URL SANS AUTORISER SON ORIGINE REVIENT À NE PAS LA FOURNIR — avec l'apparence du
+ * contraire. Le HTML est parfait, le fichier répond 200, et le navigateur refuse quand même. C'est
+ * arrivé en 0.1.47 : la marque du client était résolue, écrite dans la page, et bloquée. Le chemin
+ * du lien tracé ajoutait bien son origine ; celui de l'aperçu, non. Deux politiques sur la même
+ * instance, à la même minute.
+ *
+ * ⚠️ ET AUCUNE SONDE SERVEUR NE PEUT LE VOIR. Le HTML rendu est correct, le script se compile, le
+ * paquet est conforme. Ni notre étape de fumée, ni la garde d'artefact, ni un test qui exécute la
+ * page ne mordent : seul un navigateur le montre. C'est le second hôte qui l'a vu, à l'œil, chez son
+ * client.
+ *
+ * D'où cette fonction : une seule liste, pour toutes les routes qui rendent la visionneuse. La
+ * remplir est une décision ; l'oublier n'est plus possible, parce qu'il n'y a plus qu'un endroit.
+ *
+ * ⚠️ CE QU'ELLE NE COUVRE PAS, ET QUI EST UN AUTRE PROBLÈME. La page d'AUDIENCE affiche les avatars
+ * des participants, qui arrivent par la présence — donc à l'exécution, et depuis autant d'origines
+ * qu'il y a de membres chez l'hôte. Aucune liste posée au rendu ne peut les prévoir. Les
+ * pré-autoriser demanderait d'élargir la politique à une origine d'hôte entière, ce qui est une
+ * décision à prendre séparément, pas un oubli à corriger ici.
+ *
+ * ⚠️ ON NE DÉRIVE PAS CETTE LISTE DU HTML RENDU, et c'est délibéré. Ce serait plus général et ça
+ * viderait la politique de son sens : autoriser tout ce que la page référence, c'est autoriser aussi
+ * ce qu'une valeur mal filtrée y aurait glissé. La liste porte des CHAMPS connus, pas des URL
+ * trouvées.
+ */
+function originesImages(logoInstance, share) {
+  const s = share || {};
+  return [
+    originOf(logoInstance),
+    originOf(s.brand_logo),
+    originOf(s.bot_avatar),
+    // ⚠️ Celui-ci ne cassait pas, et c'est pire qu'un défaut visible : il marchait PAR ACCIDENT,
+    // parce que la photo du présentateur et l'avatar de l'assistant sortent en général du même
+    // stockage, donc de la même origine. Le jour où un hôte range l'une ailleurs, elle disparaît
+    // sans que rien n'ait changé chez lui.
+    originOf(s.bot_vphoto),
+    // ⚠️ Trouvé par la garde à son premier passage, et il ne se voyait pas : cette adresse ne part
+    // pas dans le HTML mais dans la configuration, et c'est la couche live qui en fait une image à
+    // l'exécution — dans la liste des participants. Un défaut de politique sur une image construite
+    // par du script se lit encore moins qu'un autre : la page est déjà chargée quand il se produit.
+    originOf(s.presenter_avatar),
+  ].filter(Boolean).join(" ");
+}
+
 function sendPresentHtml(res, html, nonce, supaUrl, imgExtra, frameAncestors) {
   const wss = String(supaUrl || "").replace(/^https:/, "wss:");
   res.statusCode = 200;
@@ -2769,7 +2828,7 @@ async function handler(req, res) {
             return jp(200, { ok: true, slug: out.slug, control: out.control });
           }
           const r = body.action === "present-page"
-            ? await setPage(String(body.slug || ""), String(body.control || ""), body.page)
+            ? await setPage(String(body.slug || ""), String(body.control || ""), body.page, body.seq)
             : body.action === "present-touch"
             ? await touchPresentation(String(body.slug || ""), String(body.control || ""))
             : await endPresentation(String(body.slug || ""), String(body.control || ""));
@@ -3112,21 +3171,62 @@ async function handler(req, res) {
             if (body.action !== "docshare.create") {
               return jd(403, { ok: false, error: "L'appel serveur à serveur ne crée que des liens sans destinataire." });
             }
-            if (body.recipientEmail) {
-              return jd(400, { ok: false, error: "Un lien avec destinataire appartient à un membre : il exige son jeton." });
-            }
+            // ⚠️ LE DESTINATAIRE ATTESTÉ : L'HÔTE SE PORTE GARANT, IL N'AFFIRME PAS.
+            //
+            // Cette route refusait tout destinataire, au motif qu'un lien nommé appartient à un
+            // membre. Le second hôte a montré la limite : il IDENTIFIE lui-même son visiteur — code
+            // à usage unique, espace projet — et veut ses lectures comptées, attribuées, révocables.
+            // Le lien anonyme est exclu (il serait transmissible à qui n'y a pas droit) et le lien
+            // nominatif exige un jeton de membre que ce visiteur n'aura jamais.
+            //
+            // Ce qui change tout est QUI FOURNIT L'ADRESSE. Dans le cas refusé, elle venait d'un
+            // formulaire rempli par un inconnu. Ici elle vient de la base de l'hôte, après
+            // vérification, et le visiteur ne la saisit jamais. C'est la forme du jeton interne :
+            // l'hôte atteste, le player n'a plus à croire l'appelant.
+            //
+            // ⚠️ ET ELLE NE VA PAS DANS `recipient_email`, PARCE QUE CE CHAMP PORTE DEUX FAITS.
+            // « À qui ce lien est destiné » et « qui a le droit d'expédier en son nom au repartage »
+            // y vivaient ensemble. Un visiteur attesté doit avoir le premier sans le second — il n'a
+            // jamais engagé sa responsabilité chez nous, et `sendReshareEmail` fait du destinataire
+            // du parent l'EXPÉDITEUR (`from`, `replyTo`) d'un message vers une adresse choisie par
+            // qui détient le lien. Lui donner ce champ ferait de nos serveurs un relais de courrier
+            // signé d'un visiteur.
+            //
+            // En le rangeant ailleurs, `recipient_email` reste vide sur toute la chaîne : la garde
+            // d'envoi refuse, et l'héritage du repartage (`created_by: parent.recipient_email || …`)
+            // ne transmet rien. Les deux refusent SANS SAVOIR POURQUOI on les protège — la règle est
+            // devenue une conséquence de la donnée, pas une consigne à retenir en deux endroits.
+            const atteste = String(body.recipientEmail || "").trim().toLowerCase();
             const docId = String(body.docId || "").trim();
             if (!docId || !body.fileUrl) return jd(400, { ok: false, error: "docId/fileUrl requis" });
 
             const ipH = adresseAppelant(req) || "hote";
             if (!(await PLAYER.limits.allow(`hshare:${ipH}`, 120, 3600))) return jd(429, { ok: false, error: "rate" });
 
-            // ⚠️ La clé d'idempotence n'a PAS demandé de colonne : « le lien de l'hôte pour ce
-            // document » est exactement la ligne sans créateur ET sans destinataire. Seul ce
-            // chemin en produit, donc elle est sans ambiguïté — et une instance déjà en service
-            // n'a aucune migration à passer.
+            // ⚠️ SANS LA COLONNE, ON REFUSE — ON N'ÉCRIT PAS AILLEURS. Un hôte qui n'a pas appliqué
+            // la migration verrait sinon son visiteur rangé dans `recipient_email` par défaut, donc
+            // 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",
+              );
+              if (!pret) {
+                return jd(409, { ok: false, error: "migration", message: "Destinataire attesté indisponible : appliquez supabase/migrations/0001-destinataire-atteste.sql." });
+              }
+            }
+
+            // ⚠️ LA CLÉ D'IDEMPOTENCE COMPTE MAINTENANT LE DESTINATAIRE ATTESTÉ. « Le lien de l'hôte
+            // pour ce document » ne suffit plus : un lien anonyme et un lien attesté ont tous deux
+            // ni créateur ni destinataire au sens de `recipient_email`. Sans cette distinction, le
+            // premier visiteur attesté récupérerait le lien anonyme du document — et tous les
+            // suivants le même, donc des lectures attribuées à la mauvaise personne.
+            const filtreAtteste = atteste
+              ? `&attested_recipient_email=eq.${encodeURIComponent(atteste)}`
+              : "&attested_recipient_email=is.null";
             const dejaLa = await PLAYER.db.request(
-              `commercial_doc_shares?doc_id=eq.${encodeURIComponent(docId)}&created_by=is.null&recipient_email=is.null&select=slug&limit=1`,
+              `commercial_doc_shares?doc_id=eq.${encodeURIComponent(docId)}&created_by=is.null&recipient_email=is.null${filtreAtteste}&select=slug&limit=1`,
             );
             if (Array.isArray(dejaLa) && dejaLa[0]) {
               await PLAYER.db.request(`commercial_doc_shares?slug=eq.${encodeURIComponent(dejaLa[0].slug)}`, {
@@ -3140,7 +3240,8 @@ async function handler(req, res) {
             // de personne, et reste visible en administration (`list.all`, qui ne filtre pas).
             const neuf = await createShare({
               brandKey: body.brandKey, docId, docTitle: body.docTitle, fileUrl: body.fileUrl,
-              fileName: body.fileName, createdBy: null, bot: body.bot, botScript: body.botScript,
+              fileName: body.fileName, createdBy: null, attestedRecipientEmail: atteste || null,
+              bot: body.bot, botScript: body.botScript,
               guided: body.guided, profileId: body.profileId, allowDownload: body.allowDownload,
               videoLayout: body.videoLayout, logo: body.logo, logoDark: body.logoDark,
             });
@@ -3640,7 +3741,7 @@ async function handler(req, res) {
       // Conséquence absurde relevée par cet hôte : la page de REFUS, corrigée la veille, était
       // encadrable chez lui — pas la page de SUCCÈS. Le chemin d'erreur était plus portable que
       // le chemin nominal.
-      return sendPresentHtml(res, viewerHtml(pseudo, pnonce, plogo), pnonce, supaUrl, originOf(plogo),
+      return sendPresentHtml(res, viewerHtml(pseudo, pnonce, plogo), pnonce, supaUrl, originesImages(plogo, pseudo),
         embed ? embedFrameAncestors() : "'self'");
     }
 
@@ -3739,7 +3840,7 @@ async function handler(req, res) {
     const frameAncestors = share.embed
       ? embedFrameAncestors()
       : "'self'";
-    return sendHtml(res, 200, viewerHtml(share, nonce, logoUrl, pitch), `'nonce-${nonce}'`, [originOf(logoUrl), originOf(share.bot_avatar), originOf(share.brand_logo)].filter(Boolean).join(" "), frameAncestors);
+    return sendHtml(res, 200, viewerHtml(share, nonce, logoUrl, pitch), `'nonce-${nonce}'`, originesImages(logoUrl, share), frameAncestors);
   } catch (error) {
     try { await PLAYER.errors.capture(error, { route: "doc", method: req.method }); } catch { /* ignore */ }
     res.statusCode = 500; res.end("Erreur");

package/server/presentations.js

@@ -47,7 +47,17 @@ async function reclaimPresentation(slug, email) {
   if (!row) return { ok: false, status: 404 };
   if (!row.owner_email || row.owner_email !== lc(email)) return { ok: false, status: 403 };
   const control = newToken(18);
-  await PLAYER.db.request(`doc_presentations?slug=eq.${enc(slug)}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { control_hash: sha(control), active: true, last_seen: new Date().toISOString(), updated_at: new Date().toISOString() } });
+  // ⚠️ REMETTRE LE RANG À ZÉRO — MAIS SEULEMENT SI LA COLONNE EXISTE. Un jeton de contrôle neuf ouvre
+  // un nouveau domaine d'ordre : le compteur du navigateur repart de 1, et sans remise à zéro toutes
+  // ses écritures seraient réputées périmées.
+  //
+  // ⚠️ 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",
+  );
+  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 };
 }
 
@@ -134,12 +144,56 @@ async function getPresentation(slug) {
 }
 
 // Pilotage : change la page courante (présentateur uniquement, via control_token).
-async function setPage(slug, control, page) {
+/**
+ * Le rang d'écriture : ce qui fait qu'une écriture périmée n'écrase pas une plus récente.
+ *
+ * ⚠️ LA FILE DU NAVIGATEUR NE SUFFIT PAS, ET ON L'A ÉCRIT EN LA LIVRANT. Elle garantit UNE seule
+ * écriture en vol : elle supprime le désordre qu'on CAUSE. Mais une requête abandonnée par le délai
+ * maximal peut très bien être arrivée au serveur — le navigateur cesse de l'attendre, il ne
+ * l'annule pas chez nous — et y atterrir APRÈS celle qui l'a remplacée. Ce désordre-là, on le SUBIT.
+ *
+ * Le rang le ferme : chaque écriture porte le sien, et le serveur refuse un rang qu'il a déjà
+ * dépassé. L'ordre ne dépend plus de l'ordre d'arrivée.
+ *
+ * ⚠️ UN RANG, PAS UN HORODATAGE. Une heure vient d'une horloge, et deux onglets n'ont pas la même.
+ * Un rang vient d'un compteur : il ne dit pas QUAND, il dit APRÈS QUOI — la question réellement
+ * posée.
+ *
+ * ⚠️ CE QU'IL COÛTE, ET QUI EST ASSUMÉ. Deux onglets du même présentateur partagent le jeton de
+ * contrôle (il est persisté) mais pas le compteur : celui qui a le rang le plus haut gagne, l'autre
+ * est refusé en silence. Deux onglets pilotant la même présentation sont déjà incohérents — ils se
+ * disputeraient la page de toute façon — mais le refus est désormais net plutôt qu'aléatoire.
+ *
+ * ⚠️ SANS LA COLONNE, ON NE CONTRÔLE PLUS RIEN — ET C'EST LE BON REPLI. Refuser toutes les écritures
+ * ferait d'une migration non appliquée une panne totale de pilotage. On revient au comportement
+ * d'avant (dernier arrivé gagne), en le signalant une fois.
+ */
+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",
+  );
+  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 } »,
+  // répandu plus loin par « ...(rang.champ || {}) » : c'était sûr, et illisible — le lecteur du PATCH
+  // ne voyait pas que ce champ est conditionnel. La garde des colonnes migrées l'a signalé, et elle
+  // avait raison sur le fond même si le code était correct : une condition qui ne se voit pas au
+  // point d'écriture finit par être recopiée sans elle.
+  return { controle: true, perime: false, rang };
+}
+
+async function setPage(slug, control, page, seq) {
   const row = await getPresentation(slug);
   if (!row) return { ok: false, status: 404 };
   if (!tokenMatches(control, row.control_hash)) return { ok: false, status: 403 };
+  const rang = await rangAccepte(row, seq);
+  // ⚠️ « Périmé » n'est pas une erreur : c'est le système qui fonctionne. On répond ok pour que le
+  // navigateur n'affiche rien — la page qu'il voulait écrire est déjà dépassée par une plus récente.
+  if (rang.perime) return { ok: true, perime: true };
   const p = Math.max(1, Math.trunc(Number(page) || 1));
-  await PLAYER.db.request(`doc_presentations?slug=eq.${enc(slug)}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { current_page: p, active: true, last_seen: new Date().toISOString(), updated_at: new Date().toISOString() } });
+  await PLAYER.db.request(`doc_presentations?slug=eq.${enc(slug)}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { current_page: p, active: true, last_seen: new Date().toISOString(), updated_at: new Date().toISOString(), ...(rang.controle ? { write_seq: rang.rang } : {}) } });
   return { ok: true };
 }
 

package/server/schema.js

@@ -0,0 +1,97 @@
+// CE QUE LA BASE PORTE VRAIMENT, ET NON CE QU'ON CROIT LUI AVOIR APPLIQUÉ.
+//
+// ⚠️ LE PLAYER N'APPLIQUE PAS LES MIGRATIONS, ET NE LE POURRA JAMAIS. Il parle à la base uniquement
+// par PostgREST, qui n'exécute pas de DDL. Lui donner ce pouvoir supposerait d'exposer une fonction
+// capable d'exécuter du SQL arbitraire — dans un service qui sert des liens publics. C'est l'hôte qui
+// applique ; le player doit seulement SAVOIR.
+//
+// ⚠️ ET IL DEMANDE PLUTÔT QU'IL NE RETIENT. Une table de suivi des migrations aurait dû être créée
+// par une migration : le premier pas serait retombé sur le problème qu'elle résout. Et un registre
+// dit ce qu'on CROIT avoir appliqué ; une sonde dit ce qui EST. Les deux divergent le jour où
+// quelqu'un applique à la main — c'est-à-dire le jour où ça compte.
+//
+// ⚠️ POURQUOI CE FICHIER EXISTE. PostgREST rejette un `PATCH` portant une colonne inconnue. Un hôte
+// qui déploie le code avant la migration voit donc TOUTES ses écritures échouer sur ce chemin, pas
+// seulement la fonction nouvelle — et le message parle d'une colonne, pas d'une version. Deux
+// chantiers ont été repoussés pour cette seule raison. Avec cette sonde, l'ordre de déploiement
+// cesse d'être un piège.
+
+let PLAYER = null;
+/**
+ * Une question posée une fois, retenue pour le processus.
+ *
+ * ⚠️ C'EST AUSSI CE QUI DÉDOUBLONNE LE JOURNAL, et il n'y a donc rien d'autre à écrire pour ça. La
+ * première version portait un second ensemble « déjà signalé » : vidé exactement quand celui-ci
+ * l'est, donc inatteignable. Une mutation qui le retirait ne faisait échouer aucun test — la bonne
+ * réponse n'était pas d'ajouter un test pour le justifier, c'était de constater qu'il ne servait à
+ * rien. Une garde qu'on ne peut pas voir refuser n'est pas une garde.
+ */
+const connues = new Map();
+
+function init(ctx) {
+  PLAYER = ctx;
+  connues.clear();
+}
+
+/**
+ * La base porte-t-elle cette colonne ?
+ *
+ * ⚠️ EN CAS DE DOUTE, ABSENTE. Supposer présente ferait échouer l'écriture ENTIÈRE — la nouvelle
+ * fonction et tout ce qui l'accompagne. Supposer absente fait attendre la fonction seule. Une
+ * fonction qui attend vaut mieux qu'une écriture perdue, et c'est la seule direction où l'erreur se
+ * répare toute seule quand la migration arrive.
+ *
+ * @param {string} table
+ * @param {string} colonne
+ * @param {string} migration le fichier à appliquer — c'est LUI qu'on nomme dans le journal
+ */
+function aLaColonne(table, colonne, migration) {
+  const cle = `${table}.${colonne}`;
+  if (!connues.has(cle)) connues.set(cle, sonder(table, colonne, migration, cle));
+  return connues.get(cle);
+}
+
+async function sonder(table, colonne, migration, cle) {
+  try {
+    // `limit=0` : on ne veut aucune ligne, seulement savoir si la colonne se sélectionne. PostgREST
+    // répond 400 « column … does not exist » quand elle manque — donc l'échec EST la réponse.
+    //
+    // ⚠️ LA PART ENCODÉE EST CALCULÉE À PART, ET PAS POUR LA LISIBILITÉ. La garde de portabilité de
+    // la CI traque la syntaxe propre à PostgREST — les ressources imbriquées « select=a(b) », les
+    // arbres booléens — en cherchant une parenthèse après « select= ». Écrite dans le gabarit,
+    // l'appel à encodeURIComponent en produisait une : la garde accusait une requête parfaitement
+    // portable. On lève l'ambiguïté du côté du code, pas du côté de la garde.
+    //
+    // ⚠️ ET CETTE SONDE EST LE SEUL ENDROIT QUI DÉPEND DU COMPORTEMENT D'ERREUR DE PostgREST. Sur
+    // une autre base, « la colonne manque » se demanderait autrement. C'est isolé ici exprès : un
+    // portage a un fichier à réécrire, pas une habitude à retrouver partout.
+    const champ = encodeURIComponent(colonne);
+    await PLAYER.db.request(`${table}?select=${champ}&limit=0`);
+    return true;
+  } catch {
+    // ⚠️ ON NE DISTINGUE PAS « COLONNE ABSENTE » DE « BASE INJOIGNABLE », ET C'EST VOULU. Les deux
+    // mènent à la même décision — ne pas écrire ce champ — et distinguer supposerait de lire un
+    // 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.
+    signaler(cle, migration);
+    return false;
+  }
+}
+
+/**
+ * ⚠️ 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
+ * les deux se compte en heures.
+ */
+function signaler(cle, migration) {
+  const quoi = migration ? `Appliquez ${migration}.` : "Une migration est en attente.";
+  try {
+    console.warn(`[player] la colonne « ${cle} » manque : la fonction qui en dépend reste inactive. ${quoi}`);
+  } catch { /* sans console */ }
+}
+
+/** Pour les tests et l'exploitation : reposer la question. */
+function oublier() { connues.clear(); }
+
+module.exports = { init, aLaColonne, oublier };

package/server/shares.js

@@ -15,12 +15,21 @@ function newSlug() { return crypto.randomBytes(9).toString("base64url"); } // ~1
 
 // Crée un lien de partage (un par destinataire). Dénormalise titre/URL/nom pour résilience (le doc vit dans
 // un snapshot). Renvoie le slug.
-async function createShare({ docId, docTitle, fileUrl, fileName, recipientEmail, recipientName, createdBy, bot, botScript, guided, profileId, allowDownload, isTest, videoLayout, logo, logoDark, brandKey}) {
+async function createShare({ docId, docTitle, fileUrl, fileName, recipientEmail, recipientName, attestedRecipientEmail, createdBy, bot, botScript, guided, profileId, allowDownload, isTest, videoLayout, logo, logoDark, brandKey}) {
   if (!docId || !fileUrl) throw Object.assign(new Error("doc invalide"), { statusCode: 400 });
   const slug = newSlug();
   const row = {
     slug, doc_id: String(docId), doc_title: docTitle || null, file_url: String(fileUrl), file_name: fileName || null,
     recipient_email: low(recipientEmail) || null, recipient_name: (recipientName || "").trim() || null, created_by: low(createdBy) || null,
+    // ⚠️ DEUX CHAMPS, DEUX FAITS. `recipient_email` dit qui a le droit d'EXPÉDIER en son nom au
+    // repartage — vide quand personne ne l'a. Celui-ci dit seulement à qui le lien est destiné,
+    // pour attribuer une lecture et pouvoir la révoquer.
+    //
+    // Les confondre revenait à donner à un visiteur attesté par un hôte le pouvoir de faire partir
+    // un courrier de nos serveurs, signé de son adresse, vers une adresse choisie par quiconque
+    // détient le lien. La garde d'envoi et l'héritage du repartage lisent tous deux
+    // `recipient_email` : en le laissant vide, ils refusent sans avoir à connaître cette histoire.
+    ...(attestedRecipientEmail ? { attested_recipient_email: low(attestedRecipientEmail) } : {}),
     bot_enabled: !!bot, bot_script: (botScript || "").trim() ? String(botScript).slice(0, 2000) : null, bot_guided: guided !== false,
     bot_profile_id: (profileId || "").trim() ? String(profileId).slice(0, 40) : null,
     allow_download: allowDownload !== false, // défaut : autorisé (rétro-compatible)

package/supabase/migrations/0001-destinataire-atteste.sql

@@ -0,0 +1,30 @@
+-- 0001 — le destinataire ATTESTÉ par l'hôte, séparé de qui peut expédier en son nom
+--
+-- Pour : un hôte qui identifie lui-même son visiteur (code à usage unique, espace projet) et veut
+--        que ses lectures soient comptées, attribuées et révocables — sans lui donner de lien
+--        anonyme, et sans exiger le jeton d'un membre qu'il n'a pas.
+--
+-- Sans lui : rien ne change. Les liens attestés ne peuvent pas être créés, et le player refuse la
+--            demande en le disant. Aucune fonction existante n'est affectée.
+--
+-- Sûre pendant que la version précédente tourne : oui — additive, et personne ne lit ni n'écrit
+-- cette colonne tant que le code qui la connaît n'est pas déployé.
+--
+-- ⚠️ POURQUOI UNE COLONNE PLUTÔT QU'UN DRAPEAU. `recipient_email` porte aujourd'hui DEUX faits :
+-- « à qui ce lien est destiné » et « qui a le droit d'expédier en son nom au repartage ». Un lien
+-- attesté par l'hôte doit avoir le premier sans le second — son visiteur n'a jamais engagé sa
+-- responsabilité chez nous.
+--
+-- Un drapeau `atteste_par_hote` dirait « ne fais pas la chose » : il décrirait le correctif au lieu
+-- du fait, et quelqu'un l'ignorerait dans six mois pour un cas qui semblerait différent. Avec deux
+-- colonnes, la garde d'envoi (qui exige `recipient_email`) et l'héritage du repartage refusent tous
+-- deux SANS SAVOIR POURQUOI on les protège. La règle devient une conséquence de la donnée.
+--
+-- Formulé par le second hôte, dont la demande a produit la séparation.
+
+alter table public.commercial_doc_shares
+  add column if not exists attested_recipient_email text;
+
+comment on column public.commercial_doc_shares.attested_recipient_email is
+  'Destinataire attesté par l''hôte : sert à ATTRIBUER une lecture, jamais à expédier en son nom. '
+  'La colonne recipient_email, elle, dit qui peut expédier — vide quand personne ne le peut.';

package/supabase/migrations/0002-ordre-des-ecritures.sql

@@ -0,0 +1,25 @@
+-- 0002 — le rang d'écriture, pour que l'ordre survive à un abandon
+--
+-- Pour : garantir qu'une écriture PÉRIMÉE n'écrase pas une plus récente. La file unique du
+--        navigateur supprime le désordre qu'on CAUSE (une seule écriture en vol) ; elle ne peut
+--        rien contre celui qu'on SUBIT — une requête abandonnée par le délai maximal peut être
+--        arrivée au serveur et y atterrir après celle qui l'a remplacée.
+--
+-- Sans lui : rien ne change. Le player détecte l'absence de la colonne, cesse de contrôler l'ordre,
+--            et le signale une fois en nommant ce fichier. On revient exactement au comportement
+--            d'avant : dernier arrivé gagne.
+--
+-- Sûre pendant que la version précédente tourne : oui — additive, avec une valeur par défaut, donc
+-- aucune ligne existante n'est réécrite et aucun code plus ancien ne la lit.
+--
+-- ⚠️ POURQUOI UN RANG PLUTÔT QU'UN HORODATAGE. Une heure vient d'une horloge, et deux onglets d'un
+-- même présentateur n'ont pas la même. Un rang vient d'un compteur : il ne dit pas QUAND, il dit
+-- APRÈS QUOI — ce qui est exactement la question posée.
+
+alter table public.doc_presentations
+  add column if not exists write_seq bigint not null default 0;
+
+comment on column public.doc_presentations.write_seq is
+  '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.';

package/supabase/migrations/0003-limites-partagees.sql

@@ -0,0 +1,30 @@
+-- 0003 — un compteur de débit partagé entre les instances
+--
+-- Pour : que les limites du player comptent pour l'INSTANCE et non pour le processus. En
+--        serverless, plusieurs exécutions servent en parallèle et démarrent à froid : un compteur
+--        en mémoire est divisé par le nombre d'instances, sans que rien ne le dise.
+--
+-- Sans lui : le player retombe sur le compteur en mémoire — le comportement d'avant — et le signale
+--            une fois en nommant ce fichier. Aucune limite ne disparaît ; elles comptent seulement
+--            par processus, ce qui les rend plus lâches qu'annoncé.
+--
+-- Sûre pendant que la version précédente tourne : oui — nouvelle table, que personne ne lit encore.
+--
+-- ⚠️ ACCÈS RÉSERVÉ AU SERVICE. Un compteur de débit lisible par le public dirait à un attaquant
+-- exactement où il en est ; modifiable, il ne limiterait rien. Aucune politique n'est ouverte : seule
+-- la clé de service y accède, comme pour toutes les tables que le navigateur ne touche jamais.
+
+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.';