discovery-media-player 0.1.117 → 0.1.119

package/docs/HOST-CONTRACT.md

@@ -35,6 +35,9 @@ need.
   "frameAncestors": ["'self'", "https://*.vercel.app", "https://app.example.com"],
   "separateIssuer": true,
   "internalStrict": true,
+  "presenceStrict": true,
+  "presenceJetons": true,
+  "presenceDurcissement": "inconnu",
   "retentionSweep": false,
   "hostShare": true,
   "hostMail": true,
@@ -63,6 +66,14 @@ different question when you want a real answer:
 GET /api/doc?contract=1&schema=1
 ```
 
+The three `presence*` fields report what the host has **observed**, not what it is configured to do:
+
+| field | meaning |
+|---|---|
+| `presenceJetons` | measured — the host actually signed a throwaway token, so `PLAYER_PRESENCE_SECRET` works |
+| `presenceStrict` | **effective** — `PLAYER_PRESENCE_STRICT` is set *and* tokens can be issued. A closed door announced over an open one would be the worse failure |
+| `presenceDurcissement` | `actif` (a hardened call came back), `degrade` (migration 0018 is missing), `inconnu` (nothing attempted in this process — **not** a green light, and process-local: another instance may have seen otherwise) |
+
 That parameter **is** the one part of this card that needs the database, and only when you ask for
 it. `verdict` is then one of:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.117",
+  "version": "0.1.119",
   "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/page-audience.js

@@ -94,6 +94,17 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
   (function(){
     var CFG=${cfg};
     var PDF=null, total=0, cur=CFG.page||1, ready=false;
+    // ⚠️ DEUX GÉNÉRATIONS, PARCE QU'IL Y A DEUX COURSES DISTINCTES (P1 audit externe).
+    //
+    // docGen : le présentateur change de document pendant qu'un chargement est en cours. Le
+    // callback de l'ANCIEN document arrivait après le nouveau et posait ses pages par-dessus.
+    // renderGen : deux getPage() en vol (changement de page rapide, redimensionnement) peuvent
+    // se résoudre DANS LE DÉSORDRE — pdf.js ne garantit aucun ordre entre deux pages. Le plus lent
+    // gagnait, et l'audience restait sur une page que personne n'avait demandée.
+    //
+    // Une génération par course : les confondre ferait qu'un simple changement de page invaliderait
+    // le document, ou l'inverse.
+    var docGen=0, renderGen=0, tacheRendu=null, chargement=null;
     var stage=document.getElementById('stage'), pageEl=document.getElementById('page');
     function hideLoader(){ var l=document.getElementById('load'); if(l){ l.classList.add('hide'); setTimeout(function(){ if(l.parentNode)l.parentNode.removeChild(l); },450);} }
     function ended(){ document.getElementById('ended').style.display='flex';
@@ -115,7 +126,14 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
         pgi.innerHTML=''; pgi.appendChild(el);
         return;
       }
+      // ⚠️ ON ANNULE LE RENDU PRÉCÉDENT AVANT D'EN LANCER UN AUTRE. Le RenderTask était jeté :
+      // deux rendus peignaient alors en parallèle, et le plus lent finissait par l'emporter.
+      if(tacheRendu){ try{ tacheRendu.cancel(); }catch(e){} tacheRendu=null; }
+      var monDoc=docGen, monRendu=++renderGen;
       PDF.getPage(n).then(function(page){
+        // Le document a changé, ou une page plus récente a été demandée pendant que celle-ci
+        // arrivait : ce résultat n'est plus celui qu'on attend. On ne le pose pas.
+        if(monDoc!==docGen || monRendu!==renderGen) return;
         var availW=Math.max(120, stage.clientWidth-40), availH=Math.max(120, stage.clientHeight-40);
         var v1=page.getViewport({scale:1});
         var scale=Math.min(availW/v1.width, availH/v1.height); // fit entier → une page à l'écran
@@ -123,9 +141,18 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
         var cv=document.createElement('canvas'); cv.width=Math.floor(vp.width*dpr); cv.height=Math.floor(vp.height*dpr);
         cv.setAttribute('role','img'); cv.setAttribute('aria-label','Page '+n+(total>1?' sur '+total:''));
         cv.style.width=vp.width+'px'; cv.style.height=vp.height+'px';
-        page.render({canvasContext:cv.getContext('2d'),viewport:vp,transform:dpr!==1?[dpr,0,0,dpr,0,0]:null});
-        pageEl.innerHTML=''; pageEl.appendChild(cv);
-      });
+        var t=page.render({canvasContext:cv.getContext('2d'),viewport:vp,transform:dpr!==1?[dpr,0,0,dpr,0,0]:null});
+        tacheRendu=t;
+        // ⚠️ ON NE PUBLIE QU'APRÈS LE RENDU. L'ancien code posait le canvas AVANT que pdf.js n'ait
+        // peint : la page apparaissait blanche puis se remplissait, et un rendu périmé pouvait
+        // encore écraser le bon. On revérifie la génération APRÈS l'attente — c'est là qu'elle a pu
+        // changer, pas avant.
+        return t.promise.then(function(){
+          if(monDoc!==docGen || monRendu!==renderGen) return;
+          if(tacheRendu===t) tacheRendu=null;
+          pageEl.innerHTML=''; pageEl.appendChild(cv);
+        });
+      }).catch(function(){ /* rendu annulé ou page illisible : le rendu courant fait foi */ });
     }
     function boot(){
       import(CFG.pdfjs).then(function(m){
@@ -170,35 +197,67 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
     // réponse n est jamais « celui que le banc sait voir » : on garde le champ qui fait foi, puis on
     // rend le banc capable de le distinguer — un cas où l URL ment et où seul le nom dit vrai.
     function estImage(){ return Player.viewer.isImageDocument(CFG.fileName, CFG.docUrl); }
-    function chargerImage(){
+    function chargerImage(monDoc){
       var im=new Image();
       im.alt='Document présenté';
       im.onload=function(){
+        // Le présentateur a pu rebasculer pendant le téléchargement : cette image n'est plus celle
+        // du document courant.
+        if(monDoc!==docGen) return;
         total=1; ready=true; PDF={image:im};
         var tot=document.getElementById('tot'); if(tot)tot.textContent=1;
         show(1); hideLoader();
         if(!CFG.active) ended();
       };
-      im.onerror=function(){ var l=document.getElementById('load'); if(l)l.querySelector('.lsub').textContent="Document indisponible."; };
+      im.onerror=function(){ if(monDoc!==docGen) return; var l=document.getElementById('load'); if(l)l.querySelector('.lsub').textContent="Document indisponible."; };
       im.src=CFG.fileUrl;
     }
+    // ⚠️ ON LIBÈRE L'ANCIEN DOCUMENT. Un PDFDocumentProxy retient ses pages, ses canvas et son
+    // worker : enchaîner les bascules sans détruire faisait croître la mémoire sans borne, et c'est
+    // le mode de panne d'une présentation longue — celle qui dure, pas celle qu'on teste.
+    function libererDocument(){
+      if(tacheRendu){ try{ tacheRendu.cancel(); }catch(e){} tacheRendu=null; }
+      if(chargement){ try{ chargement.destroy(); }catch(e){} chargement=null; }
+      if(PDF && !PDF.image && typeof PDF.destroy==='function'){ try{ PDF.destroy(); }catch(e){} }
+      PDF=null;
+    }
     function load(){
-      if(estImage()){ chargerImage(); return; }
-      pdfjsLib.getDocument({url:CFG.fileUrl,isEvalSupported:false}).promise.then(function(pdf){
+      var monDoc=docGen;
+      if(estImage()){ chargerImage(monDoc); return; }
+      var t=pdfjsLib.getDocument({url:CFG.fileUrl,isEvalSupported:false});
+      chargement=t;
+      t.promise.then(function(pdf){
+        // Une bascule est survenue pendant le chargement : ce document n'est plus attendu, et le
+        // garder fuirait. On le détruit plutôt que de simplement l'ignorer.
+        if(monDoc!==docGen){ try{ pdf.destroy(); }catch(e){} return; }
         PDF=pdf; total=pdf.numPages; ready=true;
         var tot=document.getElementById('tot'); if(tot)tot.textContent=total;
         show(cur); hideLoader();
         if(!CFG.active) ended();
-      }).catch(function(){ var l=document.getElementById('load'); if(l)l.querySelector('.lsub').textContent="Document indisponible."; });
+      }).catch(function(){ if(monDoc!==docGen) return; var l=document.getElementById('load'); if(l)l.querySelector('.lsub').textContent="Document indisponible."; });
     }
     // Le présentateur a changé de document (même session) → recharger le PDF servi par le proxy (URL identique →
     // cache-buster obligatoire), remettre à la page 1, mettre à jour le titre.
+    // ⚠️ TOUT CE QUI DÉCRIT LE DOCUMENT CHANGE ENSEMBLE, fileName COMPRIS — c'était le P1.
+    //
+    // fileName n'était PAS mis à jour, alors que c'est lui qui fait foi pour décider image ou PDF
+    // (estImage, et le commentaire plus bas dit pourquoi). Après une bascule, le nom restait celui
+    // du document précédent : un PDF→PNG envoyait donc le nouveau PNG à pdf.js, et un PNG→PDF
+    // chargeait le nouveau PDF avec new Image(). Dans les deux cas : « Document indisponible ».
+    //
+    // Une mise à jour partielle d'un état qui se lit comme un TOUT est la forme du défaut : il n'y a
+    // pas de moment où CFG doit décrire un document par son URL et un autre par son nom.
     function switchDoc(row){
+      docGen++;                 // invalide tout callback du document précédent
+      libererDocument();
       var t=document.getElementById('ptitle'); if(t) t.textContent=row.doc_title||row.file_name||'Document';
       var pg=document.getElementById('page'); if(pg) pg.innerHTML='';
       cur=1; total=0; ready=false;
       var tot=document.getElementById('tot'); if(tot)tot.textContent='—';
       var cu=document.getElementById('cur'); if(cu)cu.textContent='1';
+      if(row.file_url) CFG.docUrl=row.file_url;
+      CFG.fileName=row.file_name||'';
+      CFG.title=row.doc_title||row.file_name||'Document';
       CFG.fileUrl='/api/doc?present='+encodeURIComponent(CFG.slug)+'&file=1&v='+encodeURIComponent(row.updated_at||String(row.current_page||1));
       load();
     }
@@ -229,7 +288,9 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
         if(a.kind==='ended'){ ended(); return; }
         if(a.kind==='show-map'){ if(window.Map3DD){ if(a.content.kind==='streetview') Map3DD.enterSV(a.content,false); else Map3DD.enter(a.content,false); } return; }
         if(a.kind==='leave-map'){ if(window.Map3DD) Map3DD.exit(); }
-        if(a.kind==='switch-doc'){ CFG.docUrl=a.url; switchDoc(row); return; }
+        // switchDoc pose LUI-MÊME docUrl/fileName/titre : les poser ici, en partie, était
+        // exactement ce qui laissait fileName en arrière.
+        if(a.kind==='switch-doc'){ switchDoc(row); return; }
         if(a.kind==='show-page'){ show(a.page); }
       }
     }

package/server/presentations.js

@@ -6,7 +6,7 @@ const crypto = require("crypto");
 // ⚠️ Le contexte est REÇU, pas construit. Ce module ne doit pas savoir d'où il vient : c'est ce
 // qui lui permettra de partir dans le dépôt du player sans emporter le studio avec lui.
 let PLAYER = null;
-function init(ctx) { PLAYER = ctx; _bumpSansDurcissementJusqua = 0; _avertRpcPresence = false; _dernierSuccesDurcissement = 0; _dernierEchecDurcissement = 0; }
+function init(ctx) { PLAYER = ctx; _bumpSansDurcissementJusqua = 0; _avertRpcPresence = false; _etatDurcissement = "inconnu"; }
 
 /**
  * L'état OBSERVÉ du durcissement des bootstraps — pas sa configuration.
@@ -23,14 +23,17 @@ function init(ctx) { PLAYER = ctx; _bumpSansDurcissementJusqua = 0; _avertRpcPre
  */
 function etatDurcissementBootstrap() {
   if (Date.now() < _bumpSansDurcissementJusqua) return "degrade";
-  // ⚠️ « actif » EXIGE UN SUCCÈS PLUS RÉCENT QUE LE DERNIER ÉCHEC — pas un simple drapeau. Deux
-  // défauts tenaient dans la version précédente (relevés par le second hôte) : (1) le drapeau était
-  // posé AVANT l'appel, donc il enregistrait une TENTATIVE et non un succès ; (2) l'expiration du
-  // mémo ne rétrogradait pas l'état, elle le PROMOUVAIT — un hôte sans 0018 rendait « degrade »
-  // 60 s, puis « actif », sur la foi d'une tentative dont la seule chose prouvée était l'échec.
-  // Comparer les deux instants traite les deux d'un coup : le repli d'une preuve périmée est
-  // l'IGNORANCE, jamais la confiance.
-  return _dernierSuccesDurcissement > _dernierEchecDurcissement ? "actif" : "inconnu";
+  // ⚠️ UN ÉTAT EXPLICITE, PAS UNE COMPARAISON D'INSTANTS. La version précédente comparait le dernier
+  // succès au dernier échec — correct sur le fond, mais deux réponses concurrentes qui se terminent
+  // dans la MÊME milliseconde rendaient les deux instants égaux, et l'égalité tombait du côté
+  // « inconnu » : jamais un faux « actif », mais un faux négatif possible. Le dernier mot observé
+  // s'écrit ; il n'a pas à se déduire d'une horloge dont la résolution n'est pas garantie.
+  // (Simplification proposée par l'audit externe.)
+  //
+  // ⚠️ ET L'EXPIRATION NE PROMEUT TOUJOURS PAS. Une preuve NÉGATIVE périmée retombe sur l'ignorance,
+  // jamais sur la confiance : c'était le défaut de 0.1.115, et le remède ne doit pas le réintroduire
+  // en chemin. Un « oui » n'expire pas — une fonction ne disparaît pas toute seule.
+  return _etatDurcissement === "degrade" ? "inconnu" : _etatDurcissement;
 }
 
 
@@ -836,12 +839,11 @@ function signatureAbsente(erreur) {
 // silence. Un « oui » (la signature existe) n'a pas besoin d'expirer : une fonction ne disparaît pas.
 let _bumpSansDurcissementJusqua = 0;
 const MEMO_SANS_DURCISSEMENT_MS = 60 * 1000;
-// ⚠️ DEUX INSTANTS, PAS UN DRAPEAU — parce que l'ORDRE est ce qui distingue « réparé » de « cassé ».
-// Un booléen « on a essayé » ne peut pas dire si le dernier mot fut un succès ou un échec, et c'est
-// exactement le mot qui décide. Un succès plus récent que le dernier échec ⇒ la signature existe
-// (une fonction ne disparaît pas toute seule) ; un échec plus récent, mémo expiré ⇒ on ne sait plus.
-let _dernierSuccesDurcissement = 0;
-let _dernierEchecDurcissement = 0;
+// ⚠️ LE DERNIER MOT OBSERVÉ, ÉCRIT — pas déduit. Un booléen « on a essayé » ne pouvait pas dire si
+// ce mot fut un succès ou un échec, et c'est lui qui décide. Comparer deux instants le disait, au
+// prix d'une égalité possible à la milliseconde. On écrit donc l'état : « actif » (un appel durci
+// est revenu), « degrade » (la signature manquait), « inconnu » (rien constaté dans ce processus).
+let _etatDurcissement = "inconnu";
 // ⚠️ A-T-ON SEULEMENT ESSAYÉ ? « Pas dégradé » n'est pas « vérifié » : un processus qui vient de
 // démarrer n'a rien tenté, et rendre « actif » reviendrait à annoncer une garde active sur la foi
 // d'une absence d'observation. Trois états, donc — la même règle que le verdict du schéma, où « rien
@@ -857,7 +859,7 @@ async function appelerBump(corps, durcissementVoulu) {
     // ⚠️ ON NE MARQUE LE SUCCÈS QU'ICI — l'appel est REVENU, donc la signature à 12 arguments existe.
     // Un rendu `{ok:false, usurpe:true}` compte : seule 0018 sait répondre ça. Ce qui se mesure est
     // le RETOUR, jamais l'intention de partir.
-    if (durcissementVoulu) _dernierSuccesDurcissement = Date.now();
+    if (durcissementVoulu) _etatDurcissement = "actif";
     return r;
   } catch (erreur) {
     if (!durcissementVoulu) throw erreur;   // rien à retirer : l'échec est réel
@@ -866,8 +868,8 @@ async function appelerBump(corps, durcissementVoulu) {
     if (!signatureAbsente(erreur)) throw erreur;
     // La signature à 12 arguments n'existe pas (0018 non appliquée) : on retire l'argument et on
     // réessaie. Le durcissement n'est alors PAS appliqué — et ça se dit, une fois, plus bas.
-    _dernierEchecDurcissement = Date.now();
-    _bumpSansDurcissementJusqua = _dernierEchecDurcissement + MEMO_SANS_DURCISSEMENT_MS;
+    _etatDurcissement = "degrade";
+    _bumpSansDurcissementJusqua = Date.now() + MEMO_SANS_DURCISSEMENT_MS;
     // ⚠️ CE QUI DISPARAÎT SE DIT. Le durcissement demandé n'est pas appliqué : sous
     // PLAYER_PRESENCE_STRICT, la porte se fermerait sur les battements legacy tout en laissant un
     // bootstrap auto-déclaré s'emparer d'une présence réclamée — c'est-à-dire une fermeture qui
@@ -879,6 +881,25 @@ async function appelerBump(corps, durcissementVoulu) {
         + "de jeton — n'armez pas PLAYER_PRESENCE_STRICT avant de l'avoir appliquée.",
       ), { route: "present-attend" });
     } catch { /* jamais bloquant */ }
+    // ⚠️ SOUS PORTE FERMÉE, ON NE SE REPLIE PAS — ON REFUSE. Le repli retire le contrôle
+    // anti-usurpation et écrit quand même : acceptable pendant la TRANSITION (mieux vaut une
+    // présence enregistrée sans contrôle qu'une présentation cassée), inacceptable une fois
+    // PLAYER_PRESENCE_STRICT posé. À ce moment-là l'exploitant a déclaré que seule une identité
+    // prouvée entre ; laisser un bootstrap auto-déclaré s'emparer d'une ligne réclamée serait une
+    // fermeture qui rassure sans protéger — précisément ce que la porte prétend empêcher.
+    //
+    // On lève, et l'appelant rend 503 : « je n'ai pas pu vérifier », pas « c'est refusé » ni « c'est
+    // écrit ». ⚠️ Seuls les BOOTSTRAPS sont concernés (durcissementVoulu) : un battement prouvé n'a
+    // jamais emprunté ce chemin, donc une présentation en cours ne s'arrête pas. (Audit externe.)
+    if (PLAYER && PLAYER.config && PLAYER.config.presenceStrict) {
+      const refus = new Error(
+        "bootstrap de présence NON durci alors que PLAYER_PRESENCE_STRICT est posé : appliquez "
+        + "supabase/migrations/0018-bootstrap-non-usurpable.sql, ou retirez le mode strict le temps "
+        + "de la migration. Aucune écriture non protégée n'a été faite.",
+      );
+      refus.code = "durcissement-absent";
+      throw refus;
+    }
     const { p_only_if_unclaimed: _retire, ...sansDurcissement } = corps;
     return appel(sansDurcissement);
   }