discovery-media-player 0.1.82 → 0.1.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "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/gabarit-live.js

@@ -568,7 +568,11 @@ var Live=(function(){
       ch.on('broadcast',{event:'map'},function(){if(_onMap)_onMap();});
       ch.subscribe(function(st){if(st==='SUBSCRIBED'){REFPRETE.then(function(){ME.ref=MOIREF;ch.track({name:me.name,ref:MOIREF,avatar:me.avatar,role:me.role,member:!!me.member,uid:presId()});sendAttend();});}});
       _tyIv=setInterval(renderTyping,1500);
-      _atIv=setInterval(sendAttend,25000);
+      // ⚠️ Battement JITTERÉ (±15 %), pas un setInterval fixe (P1 performance) : 250 onglets
+      // ouverts à la même seconde produiraient une rafale synchronisée toutes les 25 s. Un
+      // setTimeout qui se replanifie avec un délai varié étale la charge. clearInterval(_atIv)
+      // efface aussi un id de setTimeout (même espace de timers dans le navigateur).
+      (function planAttend(){ _atIv=setTimeout(function(){ try{sendAttend();}catch(e){} planAttend(); }, 25000*(0.85+Math.random()*0.30)); })();
       // Filet de sécurité : au déchargement de la page/iframe (fermeture, reload, switch), on retire la présence
       // → évite les fantômes (« je me vois deux fois » au retour). Une seule fois.
       if(!_phWired){_phWired=true;window.addEventListener('pagehide',function(){try{clearInterval(_filet);_ordEtat.arreter();_ordChat.arreter();}catch(e){}try{if(ch){ch.untrack();ch.unsubscribe();ch=null;}}catch(e){}});}

package/server/presentations.js

@@ -582,8 +582,12 @@ async function addMessage(slug, { name, email, avatar, isPresenter, isMember, bo
  * garde qui dépend de ce qu'on n'a pas demandé cède au premier champ qu'on demande.
  */
 async function listMessages(slug) {
-  const rows = await PLAYER.db.request(`doc_presentation_messages?slug=eq.${enc(String(slug || ""))}&select=id,author_name,author_avatar,author_hash,is_presenter,is_member,body,attachment,reactions,reply_to,reply_name,reply_text,deleted,edited,created_at&order=created_at.asc&limit=300`);
-  return Array.isArray(rows) ? rows.map(messagePublic) : [];
+  // ⚠️ LES 300 PLUS RÉCENTS, PAS LES 300 PLUS ANCIENS (P1 performance). Avec `asc&limit=300`, au
+  // 301e message les nouveaux ne revenaient JAMAIS à ceux qui relisaient — seul l'auteur le voyait,
+  // par la réponse du POST. On trie `desc` (id départage created_at à la milliseconde) puis on
+  // REND en ordre chronologique, comme l'affichage l'attend.
+  const rows = await PLAYER.db.request(`doc_presentation_messages?slug=eq.${enc(String(slug || ""))}&select=id,author_name,author_avatar,author_hash,is_presenter,is_member,body,attachment,reactions,reply_to,reply_name,reply_text,deleted,edited,created_at&order=created_at.desc,id.desc&limit=300`);
+  return Array.isArray(rows) ? rows.slice().reverse().map(messagePublic) : [];
 }
 
 // Éditer son message (jeton d'auteur requis). Ne touche pas aux messages supprimés.
@@ -727,9 +731,12 @@ async function toggleReaction(slug, msgId, emoji, reactor, etat) {
 // Heartbeat d'un participant : upsert de sa ligne d'assistance. On accumule le temps de présence (intervalles
 // < 60 s → un aller-retour ne gonfle pas total_ms) et l'ensemble des pages vues (page courante de la présentation).
 const ATTEND_MAX_GAP_MS = 60 * 1000;
-async function recordAttendance(slug, { key, name, email, avatar, isMember, isPresenter }) {
+async function recordAttendance(slug, presDejaCharge, { key, name, email, avatar, isMember, isPresenter }) {
   if (!slug || !key) return { ok: false, status: 400 };
-  const pres = await getPresentation(slug);
+  // ⚠️ La route vient DÉJÀ de charger la présentation (contrôle présentateur) : on la reçoit plutôt
+  // que d'en refaire une lecture par battement (P1 performance — un battement = un aller-retour DB
+  // de moins). Repli sur une lecture si l'appelant ne la fournit pas.
+  const pres = presDejaCharge || await getPresentation(slug);
   if (!pres) return { ok: false, status: 404 };
   // ⚠️ La lecture est DÉJÀ faite ici : on s'en sert plutôt que d'en refaire une. Un battement de
   // présence sur une session close n'a rien à mettre à jour — et il en arrive à chaque onglet

package/server/retention.js

@@ -211,14 +211,20 @@ async function purgerRetention(now, optsBrutes = {}) {
   // Présentations mortes : bornées à PLAFOND_PRESENTATIONS par exécution ; la ligne, ses messages,
   // ses présences — et les fichiers du bucket si storage.remove est fourni (OPTIONNELLE).
   const bPres = borne(now, f.presentationsMois);
-  const mortes = await PLAYER.db.request(`doc_presentations?active=eq.false&updated_at=lt.${enc(bPres)}&select=slug&order=slug.asc&limit=${PLAFOND_PRESENTATIONS}`);
+  // ⚠️ On interroge PLAFOND+1 pour départager « pile PLAFOND présentations, rien après » (non
+  // tronqué) de « il y en a plus » — `>= PLAFOND` seul rendait un faux positif à exactement 500
+  // (P3 douzième audit : annoncé en 0.1.82, mais l'édition avait été perdue, sans essai pour la
+  // garder — c'est cet essai-ci qui manquait).
+  const mortesLot = await PLAYER.db.request(`doc_presentations?active=eq.false&updated_at=lt.${enc(bPres)}&select=slug&order=slug.asc&limit=${PLAFOND_PRESENTATIONS + 1}`);
+  const troncPres = Array.isArray(mortesLot) && mortesLot.length > PLAFOND_PRESENTATIONS;
+  const mortes = Array.isArray(mortesLot) ? mortesLot.slice(0, PLAFOND_PRESENTATIONS) : [];
   // ⚠️ BUDGET GLOBAL AUX PRÉSENTATIONS (P2 dixième audit). Le plafond n'était appliqué qu'À CHAQUE
   // présentation : 500 présentations × 5 000 = 2,5 M de messages en une exécution, timeout et
   // contention avec le chat. Deux budgets partagés — messages et présences — décrémentés au fil
   // des présentations ; la boucle s'arrête quand ils sont épuisés (tronque), sans supprimer les
   // parents restants. En dry-run, on parcourt quand même pour REMONTER ce que la vraie purge
   // ferait (examinés), sans jamais détruire.
-  const presRapport = { examinees: 0, supprimees: 0, messages: 0, presences: 0, messagesExaminees: 0, presencesExaminees: 0, fichiers: 0, fichiersErreur: 0, fichiersCandidats: 0, tronque: Array.isArray(mortes) && mortes.length >= PLAFOND_PRESENTATIONS };
+  const presRapport = { examinees: 0, supprimees: 0, messages: 0, presences: 0, messagesExaminees: 0, presencesExaminees: 0, fichiers: 0, fichiersErreur: 0, fichiersCandidats: 0, tronque: troncPres };
   let budgetMessages = opts.plafond, budgetPresences = opts.plafond;
   for (const p of (Array.isArray(mortes) ? mortes : [])) {
     const slug = p && p.slug; if (!slug) continue;

package/server/routes-direct.js

@@ -4,6 +4,10 @@
 const { adresseAppelant, lcMembre, cleAnonyme, profilDuJeton } = require("./appelant");
 
 const { createPresentation, getPresentation, setPage, endPresentation, addMessage, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent } = require("./presentations");
+// Cadence de présence et cible de mutualisation par IP (P1 performance). L'intervalle DOIT
+// refléter celui du navigateur (gabarit-live.js) ; la cible est un vrai événement en salle.
+const ATTENDANCE_INTERVAL_MS = 25_000;
+const ATTENDEES_PER_EGRESS = 250;
 let PLAYER = null;
 const init = (ctx) => { PLAYER = ctx; };
 // Même délégation que dans handler : la règle vit chez l'hôte.
@@ -55,7 +59,14 @@ async function traiter(req, res, body, _slug) {
         const jp = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
         try {
           const ip = adresseAppelant(req) || "anon";
-          const allowed = await PLAYER.limits.allow(`patt:${ip}`, 1000, 3600);
+          // ⚠️ QUOTA DÉRIVÉ DE LA CADENCE, PAS 1000 EN DUR (P1 performance). Un participant émet un
+          // battement toutes les ATTENDANCE_INTERVAL_MS ; le quota vise ATTENDEES_PER_EGRESS
+          // participants derrière une même IP (bureau, Wi-Fi d'événement partagent une sortie).
+          // 1000/h ne couvrait que ~6 participants — le 7e prenait des 429. Marge ×1,3 pour les
+          // battements immédiats (arrivée, changement de page, pagehide).
+          const battementsParH = Math.ceil(3_600_000 / ATTENDANCE_INTERVAL_MS);
+          const quotaPresence = Math.ceil(battementsParH * ATTENDEES_PER_EGRESS * 1.3);
+          const allowed = await PLAYER.limits.allow(`patt:${ip}`, quotaPresence, 3600);
           if (!allowed) return jp(429, { ok: false, error: "rate" });
           // ⚠️ CES DEUX BOOLÉENS ÉTAIENT CEUX DE L'APPELANT. `isMember` sépare la population interne
           // de celle des prospects — c'est la promesse même du produit — et `isPresenter` accorde le
@@ -83,7 +94,7 @@ async function traiter(req, res, body, _slug) {
           // On dérive donc la clé de ce qui est prouvé, et jamais de ce qui est affirmé. Un anonyme,
           // lui, ne peut rien prouver : sa clé reste la sienne, mais enfermée dans un espace de noms
           // dont elle ne peut pas sortir — elle ne pourra jamais ressembler à l'e-mail d'un membre.
-          const r = await recordAttendance(String(body.slug || ""), {
+          const r = await recordAttendance(String(body.slug || ""), pres, {
             // ⚠️ MINUSCULÉE, ET CE DÉTAIL EST UNE LIGNE DE PRÉSENCE. La clé cliente que 0.1.42 a
             // remplacée l'était (`me.email.toLowerCase()`) ; la clé dérivée ne l'était pas, et la
             // ligne se retrouve par `attendee_key=eq.` — une correspondance EXACTE. Un hôte dont

package/server/routes-liens.js

@@ -443,7 +443,16 @@ async function traiter(req, res, body, slug) {
         return;
       }
       const share = await getShareBySlug(body.slug || slug);
-      if (share && !share.is_test) { // répétition générale : la lecture de test ne compte pas dans les stats
+      // ⚠️ PLAFOND ANTI-INONDATION PAR IP (P1 performance). Le chemin analytique externe écrivait
+      // SANS quota : un slug public permettait des écritures illimitées (base gonflée, stats
+      // faussées). Même quota dérivé de la cadence que l'interne (SESSION_QUOTA_PER_HOUR par IP).
+      // Dépassé : on n'écrit pas — mais on répond 200, car une mesure ne doit pas casser une lecture.
+      const ipTrack = ip0 || "anon";
+      const sousQuota = await PLAYER.limits.allow(`sess:${ipTrack}`, SESSION_QUOTA_PER_HOUR, 3600);
+      if (share && !share.is_test && !sousQuota) {
+        try { if (await PLAYER.limits.allow("sess:quota-avert", 1, 3600)) PLAYER.errors.capture(new Error(`télémétrie externe refusée : quota horaire atteint (${SESSION_QUOTA_PER_HOUR}/h par adresse)`), { route: "track" }); } catch { /* jamais bloquant */ }
+      }
+      if (share && !share.is_test && sousQuota) { // répétition générale : la lecture de test ne compte pas dans les stats
         try {
           // 'session' = résumé riche (temps par page, appareil) → upsert ; open/page/heartbeat → journal léger (funnel/overview).
           if (body.event === "session") await upsertSession(share, { sessionId: body.sessionId, numPages: body.numPages, maxPage: body.maxPage, totalSeconds: body.totalSeconds, pagesTime: body.pagesTime }, { ip: ip0, ua: ua0 });

package/server/shares.js

@@ -277,14 +277,14 @@ function parseUa(ua) {
 // Upsert d'une session de consultation (résumé envoyé périodiquement par la visionneuse). Stocke le temps
 // PAR page (cumulatif côté client → on remplace), totaux, appareil. Conserve started_at (insert) via merge.
 async function upsertSession(share, p, { ip, ua }) {
-  const num = (v) => (Number.isFinite(+v) ? Math.trunc(+v) : null);
   const sessionId = String(p.sessionId || "").slice(0, 64);
   if (!sessionId) return;
-  const pagesTime = (p.pagesTime && typeof p.pagesTime === "object") ? p.pagesTime : {};
   const { device, os, browser } = parseUa(ua);
   const row = {
     session_id: sessionId, slug: share.slug, doc_id: share.doc_id, recipient_email: share.recipient_email,
-    num_pages: num(p.numPages), max_page: num(p.maxPage), total_seconds: num(p.totalSeconds) || 0, pages_time: pagesTime,
+    // Bornées comme la session INTERNE : plafond d'entrées, clés/valeurs numériques, totaux capés.
+    num_pages: bornerNombre(p.numPages, BORNES.pages), max_page: bornerNombre(p.maxPage, BORNES.pages),
+    total_seconds: bornerNombre(p.totalSeconds, BORNES.secondes) || 0, pages_time: bornerPagesTime(p.pagesTime),
     ua: String(ua || "").slice(0, 300), ip: String(ip || "").slice(0, 60), device, os, browser, last_at: new Date().toISOString(),
   };
   // started_at non touché par l'upsert (default à l'insert ; merge ne l'écrase pas car absent du body).
@@ -370,6 +370,21 @@ async function setShareAuth(slug, requireAuth) {
 // que l'hôte se porte garant de l'identité (jeton signé) : c'est le second volet, et il est
 // signalé au point d'entrée plutôt qu'ici.
 const BORNES = { pages: 10_000, secondes: 24 * 3600, entreesPagesTime: 2_000 };
+// ⚠️ BORNER CE QUI VIENT DU DEHORS — les DEUX chemins de session (interne ET externe). Un objet
+// libre sans plafond laisse un seul appel écrire un JSON de la taille qu'il veut (P1 performance).
+const bornerNombre = (v, max) => { const n = Number.isFinite(+v) ? Math.trunc(+v) : null; return n == null ? null : Math.max(0, Math.min(n, max)); };
+function bornerPagesTime(brut) {
+  const src = (brut && typeof brut === "object" && !Array.isArray(brut)) ? brut : {};
+  const out = {};
+  let n = 0;
+  for (const k in src) {
+    if (++n > BORNES.entreesPagesTime) break;
+    const page = Number.isFinite(+k) ? Math.trunc(+k) : null;
+    if (page == null || page < 0 || page > BORNES.pages) continue;
+    out[String(page)] = bornerNombre(src[k], BORNES.secondes) || 0;
+  }
+  return out;
+}
 
 // ⚠️ `ip` N'EST PLUS LU, ET LA SIGNATURE LE DIT. L'appelant continue de le passer — il ne sait pas
 // ce que chaque table conserve, et ce n'est pas à lui de le savoir. Mais le garder en paramètre