discovery-media-player 0.1.162 → 0.1.163

package/context/standalone.js

@@ -41,6 +41,41 @@ function sansBarreFinale(valeur) {
 }
 
 /** Client REST minimal (PostgREST). Absent de configuration ⇒ chaque appel échoue franchement. */
+/**
+ * ⚠️ UN SEUL ENDROIT QUI BORNE, PARCE QU'IL Y EN AVAIT UN SUR QUATRE.
+ *
+ * `db.request` abandonnait déjà après un délai, avec le raisonnement écrit à côté : sans signal, un
+ * service qui accepte la connexion et ne répond plus immobilise la requête, sa socket ET la place
+ * d'admission jusqu'à ce que la plateforme tue la fonction. Trois autres appels — suppression
+ * Storage, signature d'envoi, vérification de jeton — partaient nus. Un audit externe l'a mesuré le
+ * 11/09 en remplaçant `fetch` : `REST hasSignal true`, les trois autres `false`.
+ *
+ * ⚠️ CE N'EST PAS UN CONTOURNEMENT D'AUTORISATION : ces chemins refusent en cas d'échec, ils rendent
+ * `null` ou `false`. Le risque est de DISPONIBILITÉ — sous concurrence, des sockets, de la mémoire
+ * et des exécutions serverless retenues par un tiers lent, y compris pour les purges et les
+ * consultations protégées.
+ *
+ * ⚠️ ET UNE COURSE DE PROMESSES NE SUFFIRAIT PAS : elle rendrait la main sans ANNULER le `fetch`,
+ * donc sans rien libérer. C'est `AbortSignal` ou rien. Un signal fourni par l'appelant a priorité —
+ * un hôte qui borne lui-même une opération longue n'est pas écrasé.
+ */
+function fetchBorne(cible, options = {}, delaiMs) {
+  const signal = options.signal
+    || (typeof AbortSignal !== "undefined" && AbortSignal.timeout ? AbortSignal.timeout(delaiMs) : undefined);
+  return fetch(cible, { ...options, ...(signal ? { signal } : {}) });
+}
+
+/**
+ * Les délais, nommés plutôt qu'écrits en clair sur l'appel. ⚠️ ILS NE SONT PAS ÉGAUX, ET C'EST LE
+ * SUJET : une vérification de jeton est sur le chemin d'une réponse qu'un visiteur attend, un
+ * transfert vers Storage ne l'est pas. Un délai unique ferait patienter le visiteur au rythme du
+ * service le plus lent.
+ */
+const DELAI_AUTH_MS = 5000;
+const DELAI_ROUTE_HOTE_MS = 4000;
+const DELAI_STOCKAGE_MS = 15000;
+const DELAI_BASE_MS = 15000;
+
 function creerDb(env) {
   const url = sansBarreFinale(env.SUPABASE_URL);
   const cle = String(env.SUPABASE_SERVICE_ROLE_KEY || "");
@@ -67,12 +102,10 @@ function creerDb(env) {
     // transforme un ralentissement en refus général. Une course `Promise.race` ne suffirait pas —
     // elle rendrait la main sans ANNULER le fetch, donc sans libérer quoi que ce soit. L'hôte peut
     // fournir son propre `signal` (opérations longues : purges, transferts). (Audit externe.)
-    const delai = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 15000;
-    const signal = options.signal || (typeof AbortSignal !== "undefined" && AbortSignal.timeout
-      ? AbortSignal.timeout(delai) : undefined);
-    const r = await fetch(`${url}/rest/v1/${chemin}`, {
+    const delai = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : DELAI_BASE_MS;
+    const r = await fetchBorne(`${url}/rest/v1/${chemin}`, {
       method: methode,
-      ...(signal ? { signal } : {}),
+      ...(options.signal ? { signal: options.signal } : {}),
       headers: {
         apikey: cle,
         Authorization: `Bearer ${cle}`,
@@ -80,7 +113,7 @@ function creerDb(env) {
         ...(options.headers || {}),
       },
       body: options.body ? JSON.stringify(options.body) : undefined,
-    });
+    }, delai);
     if (!r.ok) {
       // ⚠️ LE CORPS DIT POURQUOI, LE CODE NE DIT QUE COMBIEN. Un « 400 » nu a coûté un aller-retour
       // de forge complet pour apprendre ce que PostgREST avait écrit dans sa réponse depuis le
@@ -166,15 +199,14 @@ async function appelHote(url, secret, corps, errors) {
   // perdu exactement ce temps-là.
   const signaler = (quoi) => { try { errors && errors.capture(new Error(`route hôte : ${quoi}`), { url }); } catch { /* jamais bloquant */ } };
   try {
-    const r = await fetch(url, {
+    const r = await fetchBorne(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         ...(secret ? { "x-player-fetch-secret": secret } : {}),
       },
       body: JSON.stringify(corps),
-      signal: AbortSignal.timeout(4000), // une décision qui tarde est une décision absente
-    });
+    }, DELAI_ROUTE_HOTE_MS); // une décision qui tarde est une décision absente
     if (!r.ok) { signaler(`réponse ${r.status}`); return null; }
     const d = await r.json().catch(() => null);
     if (!d || typeof d !== "object") { signaler("réponse illisible (JSON attendu)"); return null; }
@@ -306,8 +338,14 @@ function creerLimites(db, journal) {
         // passer ; dans les deux cas on le dit, en NOMMANT le fichier à appliquer. C'est la règle
         // du chemin de migration : dégrader, jamais casser, et ne jamais dégrader en silence.
         prevenirUneFois(
-          "compteurs de débit non atomiques : appliquez supabase/migrations/0004-limites-atomiques.sql. "
-          + "Sans elle, plusieurs requêtes simultanées peuvent dépasser la limite ensemble. "
+          // ⚠️ CE MESSAGE NOMMAIT UN MODE QUI N'EXISTE PAS. Il disait « compteurs non atomiques »,
+          // ce qui décrit un comptage partagé plus faible. Or ici il n'y a PLUS de comptage partagé
+          // du tout : le `return true` ci-dessous laisse passer, et seul l'étage local subsiste.
+          // Dire « non atomique » laisse croire qu'un plafond d'instance tient encore, en moins
+          // précis. Trouvé par un audit externe le 11/09, avec la contradiction jumelle du contrat.
+          "compteur de débit PARTAGÉ INDISPONIBLE : appliquez supabase/migrations/0004-limites-atomiques.sql. "
+          + "Sans elle il ne reste que le compteur LOCAL, par processus — une limite de 120/h en "
+          + "autorise 120 PAR EXÉCUTION. Ce n'est pas un comptage partagé dégradé, c'est aucun. "
           + "(" + ((erreur && erreur.message) || erreur) + ")",
         );
         return true;
@@ -358,9 +396,9 @@ function createStandaloneContext(env = process.env) {
           if (seg === "" || seg === "." || seg === ".." || !/^[A-Za-z0-9._-]+$/.test(seg)) return false;
         }
         try {
-          const r = await fetch(`${base}/storage/v1/object/${encodeURIComponent(bucket)}/${segs.map(encodeURIComponent).join("/")}`, {
+          const r = await fetchBorne(`${base}/storage/v1/object/${encodeURIComponent(bucket)}/${segs.map(encodeURIComponent).join("/")}`, {
             method: "DELETE", headers: { apikey: cle, Authorization: `Bearer ${cle}` },
-          });
+          }, DELAI_STOCKAGE_MS);
           return r.ok;
         } catch { return false; }
       },
@@ -382,11 +420,11 @@ function createStandaloneContext(env = process.env) {
         const cle = String(env.SUPABASE_SERVICE_ROLE_KEY || "");
         if (!base || !cle || !bucket || !chemin) return null;
         try {
-          const r = await fetch(`${base}/storage/v1/object/upload/sign/${bucket}/${chemin}`, {
+          const r = await fetchBorne(`${base}/storage/v1/object/upload/sign/${bucket}/${chemin}`, {
             method: "POST",
             headers: { apikey: cle, Authorization: `Bearer ${cle}`, "Content-Type": "application/json" },
             body: "{}",
-          });
+          }, DELAI_STOCKAGE_MS);
           if (!r.ok) return null;
           const d = await r.json().catch(() => null);
           const url = d && d.url;
@@ -474,9 +512,9 @@ function createStandaloneContext(env = process.env) {
         }
         if (!jeton || !url || !cle) return null;
         try {
-          const r = await fetch(`${url}/auth/v1/user`, {
+          const r = await fetchBorne(`${url}/auth/v1/user`, {
             headers: { apikey: cle, Authorization: `Bearer ${jeton}` },
-          });
+          }, DELAI_AUTH_MS);
           return r.ok ? await r.json() : null;
         } catch { return null; }
       },

package/docs/HOST-CONTRACT.md

@@ -441,10 +441,25 @@ Two deliberate exceptions, both written next to the code:
   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 paragraph that used to stand here said the shared count was not atomic. That has been
+false since `0004`, and it contradicted the paragraph above it in this same document.** It was
+written before the database function existed and outlived what it described. An external audit found
+it on 2026-09-11; it is corrected rather than quietly deleted, because a host who read it may have
+built a compensating control they do not need.
+
+Here is the matrix, stated once, so nothing has to be inferred:
+
+| Installed | What actually protects you |
+|---|---|
+| `0003` **and** `0004` | fast local refusal **+ shared atomic counter** — the limit means what it says for the instance |
+| `0003` without `0004` | **local only.** The function is absent, PostgREST answers 404, and the shared stage lets through after warning by name |
+| neither | **local only**, in memory, warned by name |
+| keys prefixed `pread:` | local only, **deliberately** — see the exception above |
+
+⚠️ **Read the second row carefully: without `0004` the shared stage does not count less well, it
+does not count at all.** The degradation is to the local counter, not to a weaker shared one. The
+warning the player emits used to say *"non-atomic rate counters"*, which named a mode that does not
+exist; it now says the shared counter is unavailable.
 
 ## The three things a host implements
 
@@ -793,7 +808,10 @@ claimed the opposite. Two consequences you must act on:
 - **`bot-tts` now requires a `sessionId`**, bound to the requested `slug`, and the text must match
   something the assistant said in that session. The player reads `listMessages(sessionId)` and
   treats a message as the assistant's when its `role` is `bot`, `assistant` or `ai`, taking the text
-  from `text` or `content`. **Anything it cannot read counts as "not said"** — an unrecognised shape
+  from `text`, `content` or `body` — the same three fields, in the same order, as everywhere else in
+  this document. ⚠️ **This sentence named only the first two**, and an external audit found the
+  mismatch on 2026-09-11: a host whose messages carry `body` and nothing else would have read here
+  that its assistant never speaks, while the code reads it perfectly well. **Anything it cannot read counts as "not said"** — an unrecognised shape
   yields an empty set and every request is refused. On the one route that spends money, *"I could
   not verify"* must read as **no**, never as *go ahead*.
 

package/docs/RETENTION.md

@@ -131,8 +131,11 @@ it is the trace. The row records a fingerprint and a date and nothing else: writ
 would recreate, inside the database, whatever personal data the bucket may already hold — and make
 it queryable, which is strictly worse than not having it.
 
-⚠️ **A visitor chooses what goes in.** `bot-tts` accepts the caller's text, so a unique text leaves
-an MP3 and a JSON in a public bucket. The grouping and ceilings added in 0.1.140 bound the cost per
+⚠️ **This paragraph used to say a visitor chooses what goes in. That stopped being true** when
+`bot-tts` began confronting the text with what the assistant actually said in that session — an
+external audit found the stale claim on 2026-09-11. The caller **proposes** a text; only a text the
+assistant already spoke is accepted. What still holds is the consequence: each *distinct accepted*
+text leaves an MP3 and a JSON in a public bucket. The grouping and ceilings added in 0.1.140 bound the cost per
 hour; only this window bounds the **duration**.
 
 ## Purging the reader IP and User-Agent (migrations 0026 and 0027)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.162",
+  "version": "0.1.163",
   "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/constantes-presentation.js

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright © 2026 3D Discovery
+// UNE FEUILLE, ET C'EST TOUT CE QU'ELLE EST — ELLE N'IMPORTE RIEN, DONC ELLE NE PEUT FERMER AUCUN CYCLE.
+//
+// ⚠️ CE FICHIER NAÎT D'UN CYCLE MESURÉ, PAS D'UN GOÛT POUR LE RANGEMENT. Un audit externe a relevé
+// le 11/09 le seul cycle du graphe serveur : `schema.js` ↔ `presentations.js`, par cinq `require()`
+// DYNAMIQUES croisés — écrits dans le corps des fonctions précisément parce qu'un `require` en tête
+// aurait rendu le cycle visible à l'initialisation. Un cycle qu'on contourne par le placement de
+// l'import est un cycle qu'on a caché, pas retiré.
+//
+// ⚠️ ET LA MOITIÉ DU CYCLE ÉTAIT UN PUR DÉTOUR. `schema.js` allait chercher `signatureAbsente` DANS
+// `presentations.js`, qui l'importe lui-même de `erreurs-base.js` : trois modules pour une fonction
+// qui en habite un. Corrigé en important à la source. L'autre moitié est ce fichier : un seuil de
+// domaine que deux modules lisent, et qui n'appartenait qu'à l'un d'eux par accident d'écriture.
+
+/**
+ * Au-delà de ce silence, une présentation est ABANDONNÉE — pas muette.
+ *
+ * ⚠️ UN SEUL NOMBRE, PARCE QUE DEUX AURAIENT DIVERGÉ. Le présentateur bat toutes les 30 s
+ * (`present-touch`). Ce seuil définit « vivante » pour le balayage des présentations orphelines ET
+ * pour le comptage des présentations actives de la carte d'identité. Les deux doivent répondre la
+ * même chose : une carte qui compte « actives » selon un autre seuil que celui qui les clôt
+ * afficherait des présentations que le balayage vient de retirer.
+ */
+const STALE_MS = 3 * 60 * 1000;
+
+module.exports = { STALE_MS };

package/server/mesures.js

@@ -58,6 +58,16 @@ function creerHistogramme() {
     },
     compte: () => n,
     max: () => Math.round(maxMs),
+    /**
+     * ⚠️ REMET À ZÉRO SANS CHANGER D'IDENTITÉ, ET C'EST LA RAISON DE CETTE MÉTHODE. `histoBase` est
+     * un `const` exporté par identité (`__histoBase`) : le réassigner périmerait l'export et les
+     * bancs mesureraient un objet que le module n'utilise plus. On vide l'état en place.
+     */
+    reset() {
+      seaux.fill(0);
+      n = 0;
+      maxMs = 0;
+    },
   };
 }
 
@@ -218,8 +228,24 @@ function relever() {
 }
 
 /** Pour les bancs : repartir d'une instance vierge sans recharger le module. */
+/**
+ * ⚠️ CETTE FONCTION PROMETTAIT PLUS QUE CE QU'ELLE FAISAIT, ET C'EST UN INSTRUMENT QUI MENTAIT.
+ *
+ * Elle annonçait « repartir d'une instance vierge sans recharger le module » et ne remettait à zéro
+ * que les histogrammes de routes et les compteurs de statut. `histoBase` et le retard de boucle
+ * survivaient. La télémétrie de production n'en souffrait pas — `vider()` n'y est jamais appelée —
+ * mais les BANCS D'ENDURANCE l'appellent entre l'échauffement et la mesure, puis entre scénarios.
+ * Ils pouvaient donc attribuer au scénario courant les appels base de l'échauffement et les
+ * ralentissements de boucle du scénario précédent.
+ *
+ * ⚠️ CE N'EST PAS UN DÉFAUT DE PRODUIT, C'EST PIRE POUR CE DÉPÔT : un instrument affaibli mesure
+ * moins bien le code qu'il surveille, et rien ne le dit. Trouvé par un audit externe le 11/09, qui
+ * l'a REPRODUIT plutôt que lu — `avant base n=1 boucle n=0` puis `apresVider base n=1 boucle n=2`.
+ */
 function vider() {
   for (const nom of FAMILLES) histos.set(nom, creerHistogramme());
+  histoBase.reset();
+  boucle.reset();
   // Écrits un par un, pour la même raison que les deux enveloppes de `observerBase` : une clé
   // calculée sur un objet ordinaire est la forme que `proprieteEcrite.test.js` refuse.
   statuts.ok = 0; statuts.refus4xx = 0; statuts.debit429 = 0; statuts.occupe503 = 0; statuts.erreur5xx = 0;

package/server/presentations.js

@@ -171,7 +171,10 @@ async function touchPresentation(slug, control) {
 
 // Liste des présentations en cours (membre authentifié). Auto-purge : une présentation active dont le
 // dernier heartbeat remonte à > STALE_MS (présentateur parti sans clôturer) est marquée inactive.
-const STALE_MS = 3 * 60 * 1000;
+// ⚠️ LE SEUIL VIT DÉSORMAIS DANS UNE FEUILLE, et `schema.js` le lit de là plutôt que d'ici. Il
+// était défini ici et emprunté par un `require()` dynamique croisé, ce qui fermait le seul cycle du
+// graphe serveur. Le commentaire ci-dessus reste : il explique POURQUOI trois minutes.
+const { STALE_MS } = require("./constantes-presentation.js");
 
 /**
  * ÉCRIRE SEULEMENT SI LA CONDITION TIENT ENCORE — au moment de l'écriture, pas au moment du contrôle.

package/server/retention.js

@@ -231,8 +231,11 @@ async function purgerMessagesPresentation(slug, opts, base, plafond) {
  * `list` : il n'y avait littéralement rien à parcourir. `doc_tts_objects` (migration 0021) est la
  * trace, et c'est elle qui rend cette purge possible.
  *
- * ⚠️ ET C'EST UN VISITEUR QUI DÉCIDE DE CE QUI Y ENTRE. `bot-tts` accepte le texte de l'appelant :
- * un texte unique laisse un MP3 et un JSON dans un bucket PUBLIC. Les plafonds de la 0.1.140
+ * ⚠️ CE COMMENTAIRE DISAIT « C'EST UN VISITEUR QUI DÉCIDE DE CE QUI Y ENTRE ». CE N'EST PLUS VRAI
+ * depuis que `bot-tts` confronte le texte à ce que l'assistant a réellement dit dans cette session :
+ * l'appelant PROPOSE, il ne choisit pas. Trouvé par un audit externe le 11/09, en même temps que la
+ * phrase jumelle de `docs/RETENTION.md`. Ce qui reste vrai est la conséquence : chaque texte DISTINCT
+ * ACCEPTÉ laisse un MP3 et un JSON dans un bucket PUBLIC. Les plafonds de la 0.1.140
  * bornent le coût par heure ; seule cette fenêtre borne la DURÉE.
  */
 async function purgerCacheDeVoix(opts, borneDate) {

package/server/schema.js

@@ -471,7 +471,10 @@ async function ajouterMigrationsDePresence(etat) {
     p_max_gap_ms: 0, p_anon_cap: 0, p_has_token: null, p_only_if_unclaimed: true,
   };
   const estSignatureAbsente = (erreur) => {
-    try { return require("./presentations.js").signatureAbsente(erreur); } catch { return false; }
+    // ⚠️ À LA SOURCE, PAS PAR `presentations.js`. Ce détour fermait le seul cycle du graphe serveur
+    // (audit externe du 11/09) alors que `presentations.js` importe lui-même cette fonction de
+    // `erreurs-base.js` : trois modules pour une fonction qui en habite un.
+    try { return require("./erreurs-base.js").signatureAbsente(erreur); } catch { return false; }
   };
 
   etat.fusionBaseCouvre = PORTEE_FUSION;
@@ -612,7 +615,7 @@ async function ajouterPresence(etat) {
     // même que celui du balayage des présentations orphelines — plutôt que d'inventer un second
     // nombre qui divergerait. Le présentateur bat toutes les 30 s (`present-touch`) : une présentation
     // sans battement depuis trois minutes est abandonnée, pas silencieuse. (Relevé du second hôte.)
-    const vivantDepuis = new Date(Date.now() - require("./presentations").STALE_MS).toISOString();
+    const vivantDepuis = new Date(Date.now() - require("./constantes-presentation.js").STALE_MS).toISOString();
     const actives = await PLAYER.db.request(`doc_presentations?active=eq.true&last_seen=gt.${encodeURIComponent(vivantDepuis)}&select=slug${bornee}`);
     const nActives = Array.isArray(actives) ? actives.length : 0;
     // ⚠️ `couvre` VOYAGE AVEC LES NOMBRES, ET C'EST LE POINT. Le commentaire ci-dessus protège celui