discovery-media-player 0.1.110 → 0.1.112

package/context/standalone.js

@@ -69,7 +69,16 @@ function creerDb(env) {
       // début. Tronqué : c'est un message d'erreur, pas un relais de données.
       let detail = "";
       try { detail = (await r.text()).slice(0, 300); } catch { /* le statut restera seul */ }
-      throw new Error(`Supabase ${methode} ${chemin} → ${r.status}${detail ? ` — ${detail}` : ""}`);
+      // ⚠️ LE MESSAGE NE CHANGE PAS — du code appelant y cherche « 409 ». On AJOUTE seulement de quoi
+      // décider sans lire une phrase : le statut, et le corps PostgREST analysé quand il l'est. Sans
+      // ça, distinguer « cette fonction n'existe pas » (PGRST202) d'un hoquet réseau obligeait à
+      // deviner sur du texte — et l'appelant concluait « migration absente » par défaut, ce qui lui
+      // faisait retirer une protection sur une simple panne. L'autre contexte (studio) expose déjà
+      // `statusCode`/`details` : les deux formes convergent enfin.
+      const erreur = new Error(`Supabase ${methode} ${chemin} → ${r.status}${detail ? ` — ${detail}` : ""}`);
+      erreur.statusCode = r.status;
+      try { erreur.details = JSON.parse(detail); } catch { /* corps non JSON : le message suffit */ }
+      throw erreur;
     }
     const texte = await r.text();
     return texte ? JSON.parse(texte) : null;

package/package.json

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

@@ -37,10 +37,38 @@
  */
 function creerCache(options) {
   const ttl = Math.max(0, Number(options && options.ttlMs) || 0);
-  const max = Math.max(1, Number(options && options.max) || 500);
+  // ⚠️ DEUX PLAFONDS, ET LE SECOND EST CELUI QUI COMPTE. Un plafond en NOMBRE d'entrées ne borne rien
+  // quand la taille d'une entrée est choisie par l'appelant : 500 réponses de chat à 600 Ko font
+  // ~286 Mo, et la clé porte un curseur (`chatAfter`) que le visiteur fait varier à volonté — chaque
+  // valeur crée une entrée. On borne donc aussi le POIDS, et le poids est MESURÉ, pas estimé : les
+  // valeurs mises en cache ici sont des chaînes JSON. (Relevé par un audit externe.)
+  const max = Math.max(1, Number(options && options.max) || 100);
+  const maxOctets = Math.max(1, Number(options && options.maxOctets) || 8 * 1024 * 1024);
   const now = (options && options.now) || (() => Date.now());
-  /** @type {Map<string, { echeance: number, promesse: Promise<unknown> }>} */
+  /** @type {Map<string, { echeance: number, promesse: Promise<unknown>, poids: number, enVol: boolean }>} */
   const entrees = new Map();
+  let poidsTotal = 0;
+
+  const oublier = (k) => {
+    const e = entrees.get(k);
+    if (!e) return;
+    poidsTotal -= e.poids;
+    entrees.delete(k);
+  };
+
+  // ⚠️ ON N'ÉVINCE JAMAIS UNE PROMESSE EN VOL. L'éviction sert à borner la mémoire des RÉSULTATS ;
+  // retirer une demande en cours ne libère rien (elle est déjà lancée) et casse le regroupement : les
+  // appelants suivants relanceraient la même production, ce que ce cache existe pour éviter.
+  const borner = () => {
+    for (const [k, e] of entrees) {
+      if (entrees.size <= max && poidsTotal <= maxOctets) break;
+      if (!e.enVol) oublier(k);
+    }
+  };
+
+  const purger = (t) => {
+    for (const [k, e] of entrees) if (!e.enVol && e.echeance <= t) oublier(k);
+  };
 
   return {
     /**
@@ -50,32 +78,46 @@ function creerCache(options) {
     async lire(cle, produire) {
       const k = String(cle);
       const t = now();
+      // ⚠️ PURGE À CHAQUE ACCÈS. Sans elle, une entrée périmée restait en mémoire jusqu'à ce qu'une
+      // AUTRE la pousse dehors : le cache gardait indéfiniment ce qu'il ne servait plus.
+      purger(t);
       const vue = entrees.get(k);
-      if (vue && vue.echeance > t) return vue.promesse;
+      // Une entrée en vol se partage toujours : c'est tout l'objet du regroupement.
+      if (vue && (vue.enVol || vue.echeance > t)) return vue.promesse;
 
       const promesse = Promise.resolve().then(produire);
-      entrees.set(k, { echeance: t + ttl, promesse });
-
-      // ⚠️ On oublie une promesse ROMPUE, jamais une promesse tenue : sinon un hoquet de base
-      // resterait servi pendant toute la fenêtre, et le rétablissement attendrait pour rien.
-      promesse.catch(() => {
-        const courante = entrees.get(k);
-        if (courante && courante.promesse === promesse) entrees.delete(k);
-      });
+      // ⚠️ L'ÉCHÉANCE PART DE LA RÉSOLUTION, PAS DE LA DEMANDE. Posée à la demande, elle expirait
+      // AVANT que la production ne réponde dès que celle-ci dépassait le TTL — et le regroupement ne
+      // servait alors plus à rien pour exactement les producteurs lents, les seuls qu'il valait la
+      // peine de mutualiser. Tant qu'elle est en vol, l'entrée ne périme pas.
+      entrees.set(k, { echeance: 0, promesse, poids: 0, enVol: true });
 
-      // Éviction : la plus ancienne d'abord (Map conserve l'ordre d'insertion). La clé venant de
-      // l'appelant, une table sans borne serait une fuite mémoire commandée depuis l'extérieur.
-      if (entrees.size > max) {
-        for (const vieille of entrees.keys()) {
-          entrees.delete(vieille);
-          if (entrees.size <= max) break;
-        }
-      }
+      promesse.then(
+        (valeur) => {
+          const courante = entrees.get(k);
+          if (!courante || courante.promesse !== promesse) return;
+          courante.enVol = false;
+          courante.echeance = now() + ttl;
+          // Le poids réel : ces valeurs sont des chaînes JSON. Une valeur d'une autre forme compte
+          // pour un poids nominal — mieux vaut sous-estimer que prétendre mesurer ce qu'on ignore.
+          courante.poids = typeof valeur === "string" ? valeur.length : 1;
+          poidsTotal += courante.poids;
+          borner();
+        },
+        () => {
+          // ⚠️ On oublie une promesse ROMPUE, jamais une promesse tenue : sinon un hoquet de base
+          // resterait servi pendant toute la fenêtre, et le rétablissement attendrait pour rien.
+          const courante = entrees.get(k);
+          if (courante && courante.promesse === promesse) oublier(k);
+        },
+      );
       return promesse;
     },
 
     /** Pour les tests et l'exploitation : ce que la table contient réellement. */
     taille: () => entrees.size,
+    /** Poids cumulé des résultats retenus, en caractères. */
+    poids: () => poidsTotal,
   };
 }
 

package/server/handler.js

@@ -728,7 +728,15 @@ async function handler(req, res) {
       // requête base). Il entre dans la CLÉ DE CACHE : deux clients au même curseur — le cas normal,
       // toute une salle à jour du même message — partagent la même lecture ; seuls ceux qui ont pris
       // du retard divergent. Absent → relecture complète (client ancien, ou hôte non migré).
-      const chatAfter = (Number.isFinite(+q.chatAfter) && +q.chatAfter > 0) ? String(Math.trunc(+q.chatAfter)) : null;
+      // ⚠️ ENTIER DÉCIMAL SÛR, ET RIEN D'AUTRE. Cette valeur entre dans une CLÉ DE CACHE : tout ce qui
+      // élargit l'espace des valeurs élargit l'espace des clés, et le cache est une ressource
+      // partagée. `+"1e20"` est fini et passait, produisant une clé qu'aucun message n'atteindra
+      // jamais ; `Number.isSafeInteger` ferme la plage, et le motif décimal ferme les écritures
+      // équivalentes (« 0x10 », « 1e3 », espaces). La normalisation par `String(...)` reste ce qui
+      // fait que « 05 » et « 5 » ne créent pas deux entrées pour la même question.
+      const brutAfter = String(q.chatAfter == null ? "" : q.chatAfter).trim();
+      const nAfter = /^[0-9]{1,15}$/.test(brutAfter) ? Number(brutAfter) : NaN;
+      const chatAfter = (Number.isSafeInteger(nAfter) && nAfter > 0) ? String(nAfter) : null;
       const LECTURES_PARTAGEES = [
         { param: "state", produire: async (p) => ({ ok: true, state: {
           active: p.active !== false,

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; }
+function init(ctx) { PLAYER = ctx; _bumpSansDurcissementJusqua = 0; _avertRpcPresence = false; }
 
 
 const enc = encodeURIComponent;
@@ -779,10 +779,41 @@ let _avertRpcPresence = false;
  * aller-retour perdu ; le chemin de la présence est chaud (un battement toutes les 25 s par
  * participant). On retient donc l'ensemble d'arguments qui a marché, pour le processus.
  */
-let _bumpSansDurcissement = false;   // 0018 absente : ne plus demander p_only_if_unclaimed
+/**
+ * Cette erreur dit-elle « CETTE SIGNATURE N'EXISTE PAS », et rien d'autre ?
+ *
+ * ⚠️ C'EST LA QUESTION QUI MANQUAIT, ET SON ABSENCE RETIRAIT UNE PROTECTION. Le repli vers l'ancien
+ * contrat se déclenchait sur N'IMPORTE QUELLE exception : un `ECONNRESET`, un 500, un délai dépassé
+ * valaient « migration 0018 absente », et le processus restait dégradé — sans contrôle anti-usurpation
+ * — jusqu'à son redémarrage. Une panne réseau d'une seconde désarmait une garde de sécurité sur une
+ * base pourtant entièrement migrée.
+ *
+ * C'est la règle du jour appliquée au code de production : **un mécanisme qui ne peut pas mesurer doit
+ * refuser de conclure, pas conclure par défaut.** Ici, ne pas savoir distinguer PGRST202 d'un timeout
+ * ne rendait pas le repli prudent — il le rendait automatique.
+ *
+ * PostgREST rend `PGRST202` quand aucune fonction ne correspond au jeu d'arguments nommés. On accepte
+ * les DEUX formes que nos contextes produisent (code analysé, ou message contenant le code / la phrase
+ * de PostgREST) — et RIEN d'autre : un statut 404 seul ne suffit pas, il peut venir d'ailleurs.
+ */
+function signatureAbsente(erreur) {
+  if (!erreur) return false;
+  const code = erreur.details && (erreur.details.code || (erreur.details.error && erreur.details.error.code));
+  if (code === "PGRST202") return true;
+  const texte = String((erreur && erreur.message) || "");
+  return texte.includes("PGRST202") || /Could not find the function/i.test(texte);
+}
+
+// ⚠️ LE MÉMO EXPIRE — UN « NON » N'A PAS LA DURÉE DE VIE D'UN « OUI ». C'est la doctrine que schema.js
+// applique déjà à ses sondes, et elle vaut ici pour la même raison : « 0018 absente » est un état que
+// l'exploitant peut RÉPARER pendant que le processus tourne. Mémorisé pour toujours, il aurait exigé un
+// redémarrage pour que le durcissement reprenne — une migration appliquée serait restée sans effet, en
+// 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;
 async function appelerBump(corps, durcissementVoulu) {
   const appel = (b) => PLAYER.db.request("rpc/player_attendance_bump", { method: "POST", body: b });
-  if (durcissementVoulu && _bumpSansDurcissement) {
+  if (durcissementVoulu && Date.now() < _bumpSansDurcissementJusqua) {
     const { p_only_if_unclaimed: _retire, ...sansDurcissement } = corps;
     return appel(sansDurcissement);
   }
@@ -790,9 +821,12 @@ async function appelerBump(corps, durcissementVoulu) {
     return await appel(corps);
   } catch (erreur) {
     if (!durcissementVoulu) throw erreur;   // rien à retirer : l'échec est réel
+    // ⚠️ ON NE SE REPLIE QUE SUR LA PREUVE. Toute autre erreur remonte telle quelle : l'appelant
+    // refusera le battement plutôt que de l'écrire sans le contrôle qu'il avait demandé.
+    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.
-    _bumpSansDurcissement = true;
+    _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
@@ -871,6 +905,21 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
     }
     // Forme inattendue : on n'invente pas de verdict, on laisse la boucle de repli faire l'écriture.
   } catch (erreur) {
+    // ⚠️ UN DURCISSEMENT DEMANDÉ QUI N'A PAS PU S'EXÉCUTER NE SE CONTOURNE PAS. Le repli en boucle
+    // lire-modifier-réécrire écrit SANS le contrôle anti-usurpation : l'emprunter ici reviendrait à
+    // faire par la porte de service ce que le chemin principal vient de refuser. On rend 503 — « je
+    // n'ai pas pu vérifier », pas « c'est refusé » ni « c'est écrit » — et le battement suivant
+    // réessaiera dans quelques secondes. Fail-closed sur le contrôle, jamais sur la disponibilité des
+    // battements ORDINAIRES, qui continuent de se replier normalement.
+    if (onlyIfUnclaimed) {
+      try {
+        PLAYER.errors.capture(new Error(
+          "bootstrap de présence refusé : le contrôle anti-usurpation n'a pas pu s'exécuter — "
+          + ((erreur && erreur.message) || erreur),
+        ), { route: "present-attend" });
+      } catch { /* jamais bloquant */ }
+      return { ok: false, status: 503 };
+    }
     if (!_avertRpcPresence) {
       _avertRpcPresence = true;
       try {