discovery-media-player 0.1.120 → 0.1.122

package/context/storage.js

@@ -12,6 +12,7 @@
 const fs = require("node:fs");
 const fsp = require("node:fs/promises");
 const path = require("node:path");
+const { Readable } = require("node:stream");
 
 /** Chemin canonique des objets PUBLICS du Storage Supabase. */
 const PUBLIC_OBJECT_PREFIX = "/storage/v1/object/public/";
@@ -150,12 +151,17 @@ async function readLocal(cible, range) {
   // `fh.read()`, quoi qu'il advienne du chemin entre-temps.
   let fh;
   try { fh = await fsp.open(cible, "r"); } catch { return null; }
+  // ⚠️ PLUS DE `finally { close() }` : LE DESCRIPTEUR APPARTIENT DÉSORMAIS AU FLUX. Le fermer ici
+  // reviendrait à le fermer AVANT que le relais n'ait lu un octet. `lireDepuis` en prend la
+  // propriété : soit il le rend au flux (qui le referme en fin ou à l'annulation, `autoClose`),
+  // soit il le referme lui-même sur les chemins qui ne lisent rien (416, 413, erreur).
   try {
     const stat = await fh.stat();
-    if (!stat.isFile()) return null;
+    if (!stat.isFile()) { await fh.close(); return null; }
     return await lireDepuis(fh, stat, cible, range);
-  } finally {
-    await fh.close();
+  } catch (e) {
+    await fh.close().catch(() => {});
+    throw e;
   }
 }
 
@@ -168,6 +174,7 @@ async function lireDepuis(fh, stat, cible, range) {
     if (m[1]) { debut = Number(m[1]); fin = m[2] ? Math.min(Number(m[2]), total - 1) : total - 1; }
     else { debut = Math.max(0, total - Number(m[2])); }         // `bytes=-500` : les 500 derniers
     if (!(debut >= 0 && fin >= debut && debut < total)) {
+      await fh.close().catch(() => {});
       return reponse(416, {}, Buffer.alloc(0));                  // borne absurde : on le dit
     }
     statut = 206;
@@ -180,16 +187,61 @@ async function lireDepuis(fh, stat, cible, range) {
   // fabrique son contexte à l'import, avant que l'exploitant ait pu poser la variable.
   const plafond = Number(process.env.PLAYER_MAX_RELAY_BYTES || 0) || 60 * 1024 * 1024;
   if (fin - debut + 1 > plafond) {
+    await fh.close().catch(() => {});
     return reponse(413, {}, Buffer.alloc(0));
   }
-  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);
-  // 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) };
+
+  // ⚠️ ON DIFFUSE, ON N'ALLOUE PLUS — et le plafond ne suffisait pas à rendre l'allocation sûre.
+  //
+  // `Buffer.alloc(fin - debut + 1)` réservait la plage DEMANDÉE en une fois : jusqu'à 60 Mio par
+  // requête, sous le plafond, donc parfaitement « autorisé ». Un visiteur qui connaît un lien
+  // public envoie vingt requêtes SANS `Range` sur un fichier de 50 Mio : environ 1 Gio d'un coup,
+  // avant même les surcoûts de Node. Le plafond bornait la taille d'UNE lecture ; rien ne bornait
+  // leur PRODUIT par la concurrence, qui est ce que la mémoire subit. (P1 audit externe.)
+  //
+  // Le relais distant diffuse déjà (`Readable.fromWeb(r.body)`) et compte les octets qui passent :
+  // en rendant un `body`, le chemin local emprunte le MÊME code et hérite de sa contre-pression —
+  // la mémoire devient fonction de la taille des morceaux, plus de celle du fichier.
+  //
+  // `autoClose` referme le descripteur en fin de flux ET à la destruction : si le client raccroche,
+  // le relais détruit la source et le descripteur part avec elle. C'est pourquoi personne ne le
+  // ferme plus en amont.
+  const flux = fh.createReadStream({ start: debut, end: fin, autoClose: true });
+  // La taille vient d'un `stat` sur le descripteur OUVERT : elle décrit bien ce qu'on envoie, et
+  // permet au relais de refuser avant de lire, à la visionneuse d'afficher une progression.
+  const entetes = { "content-type": type, "content-length": String(fin - debut + 1) };
   if (statut === 206) entetes["content-range"] = `bytes ${debut}-${fin}/${total}`;
-  return reponse(statut, entetes, corps);
+  return reponseFlux(statut, entetes, flux);
+}
+
+/**
+ * Même forme qu'une réponse `fetch`, mais avec un CORPS LISIBLE : `body` est un flux web, ce que le
+ * relais sait consommer. `arrayBuffer()` reste disponible pour un appelant qui ne connaît que lui —
+ * il consomme alors le flux, donc il réalloue : c'est le chemin de repli, pas celui qu'on emprunte.
+ */
+function reponseFlux(status, entetes, fluxNode) {
+  const h = new Map(Object.entries(entetes));
+  const fluxWeb = Readable.toWeb(fluxNode);
+  return {
+    ok: status < 400,
+    status,
+    headers: { get: (k) => (h.has(String(k).toLowerCase()) ? h.get(String(k).toLowerCase()) : null) },
+    // ⚠️ UNE SEULE SOURCE, DONC UNE SEULE CONSOMMATION. `Readable.toWeb` prend possession du flux
+    // Node : itérer celui-ci en parallèle de `body` lirait deux fois la même chose, ou rien. On
+    // construit donc le flux web UNE fois et `arrayBuffer()` lit depuis LUI — même sémantique que
+    // `fetch`, où un corps ne se consomme qu'une fois.
+    body: fluxWeb,
+    arrayBuffer: async () => {
+      const lecteur = fluxWeb.getReader();
+      const morceaux = [];
+      for (;;) {
+        const { done, value } = await lecteur.read();
+        if (done) break;
+        morceaux.push(Buffer.from(value));
+      }
+      return Buffer.concat(morceaux);
+    },
+  };
 }
 
 function reponse(status, entetes, corps) {

package/docs/README.md

@@ -1,7 +1,7 @@
 # Documentation
 
-Nine documents, three readers. Start with the one that matches what you are trying to do —
-none of them assumes you have read the others.
+Three readers, one section each. Start with the one that matches what you are trying to do —
+no document assumes you have read the others.
 
 ## You are integrating the player into an application
 
@@ -37,6 +37,7 @@ tracked version by version in the [CHANGELOG](../CHANGELOG.md).
 |---|---|
 | [`SPEC-MEMBRE-INJECTE.md`](SPEC-MEMBRE-INJECTE.md) | A specification sent to a host for agreement **before** the contract moves. Nothing in it is implemented. (French.) |
 
-Documents marked *(French)* are internal working documents; everything an integrator or an
-operator needs day to day is in English. The reasoning behind that split is at the end of the
+Public entry points are in English. Documents that remain in French — audit traces, and the
+operational documents marked *(French)* above — are labelled explicitly, so nobody discovers
+the language after clicking. The reasoning behind the split is at the end of the
 [README](../README.md#contributing).

package/package.json

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

@@ -848,9 +848,32 @@ let _etatDurcissement = "inconnu";
 // 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
 // de manquant » se lisait « tout va bien » tant qu'on ne distinguait pas « rien demandé ».
+// ⚠️ UN SEUL CONSTRUCTEUR DE REFUS, PARCE QU'IL Y A DEUX CHEMINS. Le mode strict doit refuser à
+// l'endroit où la RPC échoue ET à l'endroit où le mémo évite de la rappeler. Deux messages écrits
+// séparément divergeraient, et c'est la divergence qui a produit le défaut : le premier chemin était
+// gardé, le second non. (P1 audit externe, v0.1.120.)
+function erreurDurcissementAbsent() {
+  const e = 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.",
+  );
+  e.code = "durcissement-absent";
+  return e;
+}
+
 async function appelerBump(corps, durcissementVoulu) {
   const appel = (b) => PLAYER.db.request("rpc/player_attendance_bump", { method: "POST", body: b });
   if (durcissementVoulu && Date.now() < _bumpSansDurcissementJusqua) {
+    // ⚠️ LE SECOND CHEMIN VERS LA MÊME ÉCRITURE — et c'est par là que la porte fermée se rouvrait.
+    // Le refus de 0.1.119 vivait dans le `catch`, donc sur le chemin où la RPC vient d'échouer. Une
+    // fois le mémo armé, on sort par ICI sans jamais rappeler la RPC : le premier bootstrap était
+    // refusé en 503, le deuxième écrivait sans contrôle pendant les 60 s suivantes.
+    //
+    // Corriger un chemin d'une opération qui en a deux ne corrige rien : ça déplace le défaut vers
+    // celui qu'on n'a pas regardé, et le banc reste vert parce qu'il n'éprouvait que le premier
+    // passage. Le régime se teste sur la RÉPÉTITION, pas sur l'appel initial.
+    if (PLAYER && PLAYER.config && PLAYER.config.presenceStrict) throw erreurDurcissementAbsent();
     const { p_only_if_unclaimed: _retire, ...sansDurcissement } = corps;
     return appel(sansDurcissement);
   }
@@ -891,15 +914,7 @@ async function appelerBump(corps, durcissementVoulu) {
     // 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;
-    }
+    if (PLAYER && PLAYER.config && PLAYER.config.presenceStrict) throw erreurDurcissementAbsent();
     const { p_only_if_unclaimed: _retire, ...sansDurcissement } = corps;
     return appel(sansDurcissement);
   }

package/server/schema.js

@@ -304,7 +304,16 @@ async function vraimentSonderTout() {
   } catch {
     // On rend ce qu'on savait déjà — un manque constaté plus tôt reste un fait — mais le verdict
     // dit que cette mesure-ci n'a pas eu lieu. Taire l'un ou l'autre serait mentir d'un côté.
-    return { ...etatDuSchema(), verdict: "indetermine" };
+    // ⚠️ LE CHAMP DOIT ÊTRE LÀ MÊME ICI. Le contrat annonce que `durcissementBase` vaut toujours
+    // l'une des trois valeurs ; ce retour anticipé le faisait DISPARAÎTRE quand la base ne répond
+    // pas du tout. Un hôte qui teste `durcissementBase !== "applique"` avant de déployer lisait
+    // alors `undefined !== "applique"` — vrai par accident, donc juste par accident. Un champ
+    // absent est plus dangereux qu'un champ prudent : il ne se distingue pas d'un contrat plus
+    // ancien. (P2 audit externe.)
+    return {
+      ...etatDuSchema(), verdict: "indetermine",
+      durcissementBase: "indetermine", durcissementBaseCouvre: PORTEE_DURCISSEMENT,
+    };
   }
   // ⚠️ LE TÉMOIN VIENT DE RÉPONDRE : tout « non » encore en cache est SUSPECT — il peut dater
   // d'une panne guérie. On le jette et on repose la question, sinon ce diagnostic rendrait la
@@ -360,6 +369,14 @@ const PLAFOND_SANS_RANG = 1000;
 // être un slug réel (contrat `^[A-Za-z0-9_-]{1,64}$`), et ne peut pas heurter une vraie présence.
 // Un test de base (Postgres réel) vérifie qu'aucune ligne n'apparaît.
 const SLUG_SONDE_DURCISSEMENT = "sonde durcissement";
+// ⚠️ UNE SEULE DESCRIPTION, PARCE QU'IL Y A DEUX SORTIES. Le champ se pose aussi sur le retour
+// ANTICIPÉ (base muette) ; deux textes écrits séparément divergeraient, et c'est exactement ce qui
+// vient de se produire un cran plus haut avec le refus du mode strict.
+const PORTEE_DURCISSEMENT =
+  "propriété de la BASE (migration 0018), globale à toutes les instances — à ne pas confondre avec "
+  + "presenceDurcissement, qui est ce que CE processus a constaté en servant des bootstraps. "
+  + "C'est ce champ-ci qu'on lit AVANT un déploiement ; « indetermine » = la question n'a pas pu "
+  + "être posée, ce n'est ni un oui ni un non.";
 
 async function ajouterDurcissement(etat) {
   const corps = {
@@ -396,11 +413,7 @@ async function ajouterDurcissement(etat) {
       }
     } catch { /* jamais bloquant */ }
   }
-  etat.durcissementBaseCouvre =
-    "propriété de la BASE (migration 0018), globale à toutes les instances — à ne pas confondre avec "
-    + "presenceDurcissement, qui est ce que CE processus a constaté en servant des bootstraps. "
-    + "C'est ce champ-ci qu'on lit AVANT un déploiement ; « indetermine » = la question n'a pas pu "
-    + "être posée, ce n'est ni un oui ni un non.";
+  etat.durcissementBaseCouvre = PORTEE_DURCISSEMENT;
 }
 
 async function ajouterSansRang(etat) {