discovery-media-player 0.1.165 → 0.1.166

package/context/standalone.js

@@ -842,11 +842,16 @@ function createStandaloneContext(env = process.env) {
       extraFrameAncestors: String(env.DOC_FRAME_ANCESTORS || "").split(/\s+/).filter(Boolean),
       // Transferts de fichiers simultanés par processus (défaut 64) : le relais refuse en 503 au-delà,
       // avant tout appel amont. Lu ICI, pas dans le cœur — la configuration entre par le contexte.
-      maxConcurrentRelays: Number(env.PLAYER_MAX_RELAYS || 0) || 64,
+      // ⚠️ TRANSMIS TEL QUEL, PAS NORMALISÉ ICI. La première écriture faisait `Number(x) || 64` : une
+      // valeur illisible devenait le défaut EN SILENCE, et 2 147 483 648 passait jusqu'à `setTimeout`,
+      // qui ramène un tel délai à 1 ms (audit externe, cinquième passe). Les plages vivent dans
+      // `server/bornes.js`, et le cœur les applique à `init` en DISANT une fois ce qu'il a refusé —
+      // si on bornait ici, il ne verrait qu'une valeur valide et l'exploitant ne saurait jamais.
+      maxConcurrentRelays: env.PLAYER_MAX_RELAYS ? Number(env.PLAYER_MAX_RELAYS) : 64,
       // Un relais sans progression pendant relayStallMs, ou plus long que relayMaxMs, est abandonné
       // (source et réponse détruites) : sans ça, un client qui cesse de lire garde sa place pour toujours.
-      relayStallMs: Number(env.PLAYER_RELAY_STALL_MS || 0) || 30_000,
-      relayMaxMs: Number(env.PLAYER_RELAY_MAX_MS || 0) || 900_000,
+      relayStallMs: env.PLAYER_RELAY_STALL_MS ? Number(env.PLAYER_RELAY_STALL_MS) : 30_000,
+      relayMaxMs: env.PLAYER_RELAY_MAX_MS ? Number(env.PLAYER_RELAY_MAX_MS) : 900_000,
 
       /**
        * Clé de `localStorage` sous laquelle VOTRE application range la session de ses membres.

package/docs/HOST-CONTRACT.md

@@ -50,6 +50,7 @@ need.
   "presenceDurcissement": "inconnu",
   "presenceFusion": "inconnu",
   "lectureSaturee": { "total": 0, "fenetreS": 0, "derniereIlYaS": null },
+  "relaisRefuses": { "total": 0, "fenetreS": 0, "derniereIlYaS": null },
   "mesures": { "fenetreS": 0, "seauxMs": [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000], "familles": ["document", "presentation", "action", "fichier", "carte", "autre"], "routes": {}, "base": { "n": 0 }, "statuts": { "ok": 0, "refus4xx": 0, "debit429": 0, "occupe503": 0, "erreur5xx": 0 }, "memoireMio": { "rss": 0, "heap": 0, "tampons": 0 }, "boucleMs": { "n": 0, "moyen": null, "p99": null, "resolutionMs": 20 } },
   "retentionSweep": false,
   "hostShare": true,
@@ -241,6 +242,18 @@ object rather than as separate fields you could read apart.
 not of your deployment. Aggregating is your job — and letting you believe otherwise would be worse
 than returning nothing.
 
+### `relaisRefuses` — what the relay admission refused
+
+Same three keys, same reading rules, **another ceiling**: this counts the file relays refused with
+`503` + `Retry-After: 2` because `config.maxConcurrentRelays` was reached (see *Relay `Range`* in the
+three things a host implements). ⚠️ `lectureSaturee` does **not** cover it — it is the read cache
+only. A host answered *"we never saturate relays"* from `lectureSaturee.total = 0` (13/09), which was
+a reasonable reading of a card that had no relay counter; and `mesures.statuts.occupe503` mixes the
+two refusals. This field exists so that the question *did this instance refuse a relay?* is answered
+by the card, structured and dated, and never by a search through logs for `relais refusés` — the
+log line stays for diagnosis, the card is the way to *notice*. Process-local like everything on this
+card, and **never reset by `init`**, exactly like the counter of open relays.
+
 ⚠️ **Before you upgrade, do not read `presenceDurcissement` or `presenceFusion`.** They are *reports
 of execution*: on an instance where nothing is running they say `inconnu`, which means *nobody
 looked* — not *the migration is there*. A pre-flight check built on one of them silently passes on
@@ -771,6 +784,15 @@ Four requirements, in order of what they cost when missed:
    `config.relayStallMs` (30 s) or a total beyond `config.relayMaxMs` (15 min) aborts the pipeline,
    destroying your response and the client's. A client that stops reading no longer keeps a slot
    forever; a route of yours that stops sending does not either.
+   ⚠️ Three things about those numbers, all measured on 0.1.165 by an audit: **64 is not a safe
+   default everywhere** — 64 relays × 8 MiB with slow consumers took the process RSS from ~63 MiB to
+   193–257 MiB; on a 256 MiB process set 16–32. The settings are **integers in a written range**
+   (`maxConcurrentRelays` 1–1024, the two delays 1–86 400 000 ms): out of range falls back to the
+   default and is reported once at `init` through `errors.capture`, because `setTimeout` clamps
+   anything above 2 147 483 647 ms to 1 ms and a "24-day" delay aborted a relay in 6 ms. And the
+   **counter of open relays is never reset by `init`**: calling `init` again re-reads the ceiling and
+   the delays for the relays admitted afterwards; one already in flight keeps its slot and its
+   bounds, so a re-initialisation cannot let a request past a full ceiling.
 3. **Accept a server-to-server call.** A tracked link is opened by someone with no session on your
    side. Authenticate the player with the shared secret in the `x-player-fetch-secret` **header** —
    header only, never a query string: logs keep URLs.
@@ -821,6 +843,14 @@ back on an inability to *reach*.** And "do not fall back" applies to what you **
 
 ## What will bite
 
+⚠️ **`node_modules` cannot be a symlink, and a repository inside a syncing folder will break under
+you.** Reported by a host (13/09), not reproduced here: a checkout living in iCloud Drive had files
+duplicated and emptied *while being worked on* — four breakages in six days, four different
+signatures, one of which blocked a delivery. Their escape route, a symbolic link from `node_modules`
+to a folder outside the sync, is a dead end: `npm` replaces the link with a real directory, whether
+the target is empty or populated, on `install` as on `ci`. Keep the clone itself outside any
+synchronised folder; there is no way to keep only its dependencies out.
+
 ⚠️ **Every capability you provide must settle in bounded time — `db.request` first of all.** The
 player awaits your `db.request`, `storage.fetchFile`, `mail.send` and the visitor plugin; a promise
 that never settles keeps a request in flight, and the read cache admits at most 128 in-flight reads

package/package.json

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

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright © 2026 3D Discovery
+// LES RÉGLAGES DU RELAIS, BORNÉS À UN SEUL ENDROIT — parce qu'un nombre fini n'est pas un délai.
+//
+// ⚠️ `setTimeout` PLAFONNE À 2 147 483 647 ms ET RAMÈNE TOUT DÉPASSEMENT À 1 ms. Un délai de
+// progression configuré à 2 147 483 648 ms — « environ 24,8 jours » — abandonnait le transfert en
+// 6 ms, avec 65 `TimeoutOverflowWarning` pour le dire (reproduit par un audit externe, cinquième
+// passe, 13/09). La première borne acceptait « tout nombre fini positif » : une décimale, l'infini
+// sous la forme d'un très grand entier, tout passait jusqu'à Node. On n'accepte donc qu'un ENTIER
+// SÛR dans une plage écrite, bien sous la limite native, et une valeur hors plage retombe sur le
+// défaut EN LE DISANT — une fois, à l'initialisation, pas à chaque relais.
+//
+// Le même module sert le cœur (`handler.init`) et le contexte autonome : une seule décision.
+
+/** Relais simultanés par processus. 1 024 est une borne de configuration, pas une recommandation :
+ *  64 relais × 8 Mio avec des clients lents ont fait monter la RSS de 63 à 193–257 Mio (mesuré par
+ *  un audit externe) — sur un processus à 256 Mio, 16 à 32 est le bon ordre de grandeur. */
+const RELAIS_SIMULTANES_DEFAUT = 64, RELAIS_SIMULTANES_MIN = 1, RELAIS_SIMULTANES_MAX = 1024;
+/** Délais du relais, en millisecondes entières : de 1 ms à 24 h. Vingt-quatre heures est une borne
+ *  applicative, très en dessous des 2 147 483 647 ms que `setTimeout` sait tenir. */
+const RELAIS_STALL_MS_DEFAUT = 30_000, RELAIS_MAX_MS_DEFAUT = 900_000;
+const RELAIS_MS_MIN = 1, RELAIS_MS_MAX = 86_400_000;
+
+/**
+ * Un entier sûr dans [min, max], sinon le défaut. `undefined` et `null` sont « non posé » : le
+ * défaut s'applique sans être un défaut de configuration ; tout le reste hors plage l'est.
+ * @returns {{ valeur: number, valide: boolean, posee: boolean }}
+ */
+function entierBorne(v, { defaut, min, max }) {
+  if (v === undefined || v === null || v === "") return { valeur: defaut, valide: true, posee: false };
+  // Un nombre, ou une chaîne (l'environnement n'en connaît pas d'autre) — jamais un booléen, que
+  // `Number(true)` transformerait en un délai de 1 ms parfaitement « valide ».
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v.trim()) : NaN;
+  const valide = Number.isSafeInteger(n) && n >= min && n <= max;
+  return { valeur: valide ? n : defaut, valide, posee: true };
+}
+
+/**
+ * Les trois réglages du relais, lus dans `config`, bornés, avec la liste de ce qui a été refusé —
+ * pour que l'appelant le dise une fois, avec la plage, plutôt que d'appliquer un défaut en silence.
+ * @returns {{ plafond: number, stallMs: number, maxMs: number, invalides: string[] }}
+ */
+function bornesRelais(config) {
+  const c = config || {};
+  const plafond = entierBorne(c.maxConcurrentRelays, { defaut: RELAIS_SIMULTANES_DEFAUT, min: RELAIS_SIMULTANES_MIN, max: RELAIS_SIMULTANES_MAX });
+  const stall = entierBorne(c.relayStallMs, { defaut: RELAIS_STALL_MS_DEFAUT, min: RELAIS_MS_MIN, max: RELAIS_MS_MAX });
+  const total = entierBorne(c.relayMaxMs, { defaut: RELAIS_MAX_MS_DEFAUT, min: RELAIS_MS_MIN, max: RELAIS_MS_MAX });
+  const invalides = [];
+  if (!plafond.valide) invalides.push(`maxConcurrentRelays=${String(c.maxConcurrentRelays)} (entier de ${RELAIS_SIMULTANES_MIN} à ${RELAIS_SIMULTANES_MAX}, défaut ${RELAIS_SIMULTANES_DEFAUT})`);
+  if (!stall.valide) invalides.push(`relayStallMs=${String(c.relayStallMs)} (entier de ${RELAIS_MS_MIN} à ${RELAIS_MS_MAX} ms, défaut ${RELAIS_STALL_MS_DEFAUT})`);
+  if (!total.valide) invalides.push(`relayMaxMs=${String(c.relayMaxMs)} (entier de ${RELAIS_MS_MIN} à ${RELAIS_MS_MAX} ms, défaut ${RELAIS_MAX_MS_DEFAUT})`);
+  return { plafond: plafond.valeur, stallMs: stall.valeur, maxMs: total.valeur, invalides };
+}
+
+module.exports = {
+  entierBorne, bornesRelais,
+  RELAIS_SIMULTANES_DEFAUT, RELAIS_SIMULTANES_MIN, RELAIS_SIMULTANES_MAX,
+  RELAIS_STALL_MS_DEFAUT, RELAIS_MAX_MS_DEFAUT, RELAIS_MS_MIN, RELAIS_MS_MAX,
+};

package/server/handler.js

@@ -40,10 +40,22 @@ function init(ctx) {
   // `init`, et un hôte a le même droit. On n'ajoute qu'une chose, on n'en fige aucune.
   if (ctx && ctx.db) { const vu = Object.create(ctx); vu.db = mesures.observerBase(ctx.db); ctx = vu; }
   PLAYER = ctx;
-  plafondRelais = borneRelais(ctx && ctx.config && ctx.config.maxConcurrentRelays);
-  relaisStallMs = borneMs(ctx && ctx.config && ctx.config.relayStallMs, RELAIS_STALL_MS_DEFAUT);
-  relaisMaxMs = borneMs(ctx && ctx.config && ctx.config.relayMaxMs, RELAIS_MAX_MS_DEFAUT);
-  relaisEnCours = 0;
+  // ⚠️ LA CONFIGURATION SE RELIT, L'ÉTAT VIVANT NE SE REMET PAS À ZÉRO. Cette ligne posait
+  // `relaisEnCours = 0` : un hôte qui rappelle `init` pendant qu'un relais est ouvert désarmait le
+  // plafond — la demande suivante partait vers l'amont avec l'unique place encore prise, et le
+  // `finally` de l'ancien relais rendait ensuite le compteur négatif (reproduit par un audit externe,
+  // cinquième passe, 13/09). Le compteur appartient au processus, pas au contexte : il ne se relit pas.
+  // Les bornes de temps, elles, sont capturées à l'ADMISSION de chaque relais (`relayerSousAdmission`) :
+  // un relais admis sous 30 s reste sous 30 s, quoi qu'un `init` ultérieur décide.
+  const bornes = bornesRelais(ctx && ctx.config);
+  plafondRelais = bornes.plafond;
+  relaisStallMs = bornes.stallMs;
+  relaisMaxMs = bornes.maxMs;
+  if (bornes.invalides.length) {
+    // Une fois, ici — pas à chaque relais : un réglage hors plage est une erreur de déploiement, dite
+    // à l'exploitant avec la plage, plutôt qu'un défaut appliqué en silence.
+    try { PLAYER.errors.capture(new Error(`réglages de relais hors plage, défauts appliqués : ${bornes.invalides.join(" ; ")}`), { route: "relais", benin: true }); } catch { /* jamais bloquant */ }
+  }
   // Le domaine reçoit le même contexte : une seule construction pour tout le player.
   require("./shares").init(ctx);
   require("./retention").init(ctx);
@@ -69,8 +81,15 @@ const isAllowedStorageUrl = (url) => PLAYER.storage.isAllowedUrl(url);
 // contexte (`config.maxConcurrentRelays`, défaut 64) : assez pour les requêtes Range parallèles de
 // pdf.js, borné pour un processus. Sur serverless la plate-forme borne déjà la concurrence globale ;
 // ceci protège le mode autonome et chaque instance chaude.
-const RELAIS_SIMULTANES_DEFAUT = 64;
+const { bornesRelais, RELAIS_SIMULTANES_DEFAUT, RELAIS_STALL_MS_DEFAUT, RELAIS_MAX_MS_DEFAUT } = require("./bornes");
 let plafondRelais = RELAIS_SIMULTANES_DEFAUT, relaisEnCours = 0;
+// ⚠️ COMPTÉS, PARCE QU'UN HÔTE A CRU LES LIRE AILLEURS. On demandait aux hôtes de chercher « relais
+// refusés » dans leurs journaux ; l'un d'eux a répondu par `lectureSaturee.total = 0` de la carte —
+// qui ne compte que le cache de lecture, pas les relais (13/09). Une question qu'un hôte peut
+// trancher par la carte ne doit pas être posée comme une fouille de journaux : la carte est
+// structurée, datée, et répond même pour l'hôte qui ne lit jamais ses journaux. État du processus,
+// comme `relaisEnCours` : jamais remis à zéro par `init`.
+let relaisRefusesTotal = 0, dernierRefusRelais = null;
 // ⚠️ UNE PLACE N'EST BORNÉE QUE SI LE RELAIS QUI L'OCCUPE FINIT. Un client qui cesse de lire — ou un
 // amont qui cesse d'envoyer — laissait le pipeline en attente pour toujours : `finally` jamais atteint,
 // place jamais rendue, et avec un plafond de 1, plus aucun fichier ne partait (reproduit par un audit
@@ -78,12 +97,12 @@ let plafondRelais = RELAIS_SIMULTANES_DEFAUT, relaisEnCours = 0;
 // réponse — le commentaire de `bin/serve.js` affirmait le contraire. Deux bornes, configurables par
 // le contexte : sans progression pendant `relayStallMs` (30 s), ou au-delà de `relayMaxMs` (15 min),
 // le pipeline est ABANDONNÉ par signal — source amont détruite, réponse détruite, rejet, `finally`.
-const RELAIS_STALL_MS_DEFAUT = 30_000, RELAIS_MAX_MS_DEFAUT = 900_000;
+// ⚠️ Les valeurs viennent de `server/bornes.js` : entiers dans une plage écrite, jamais « tout nombre
+// fini » — `setTimeout` ramène à 1 ms tout délai au-delà de 2 147 483 647 ms (audit, cinquième passe).
 let relaisStallMs = RELAIS_STALL_MS_DEFAUT, relaisMaxMs = RELAIS_MAX_MS_DEFAUT;
-const borneMs = (v, defaut) => { const n = Number(v); return Number.isFinite(n) && n > 0 ? n : defaut; };
-function borneRelais(v) { const n = Math.trunc(Number(v)); return Number.isFinite(n) && n >= 1 ? n : RELAIS_SIMULTANES_DEFAUT; }
 async function relayerSousAdmission(res, travail) {
   if (relaisEnCours >= plafondRelais) {
+    relaisRefusesTotal += 1; dernierRefusRelais = Date.now();
     // Une fois par heure, l'exploitant l'apprend : un 503 muet ressemble à une panne d'amont.
     try {
       if (await PLAYER.limits.allow("relais:sature-avert", 1, 3600)) {
@@ -94,8 +113,11 @@ async function relayerSousAdmission(res, travail) {
     refuserEnTexte(res, 503, "Trop de transferts en cours, réessayez dans un instant");
     return;
   }
+  // Les bornes de CE relais sont figées ici : un `init` pendant le transfert relit la configuration
+  // pour les suivants, jamais pour celui-ci.
+  const bornes = { stallMs: relaisStallMs, maxMs: relaisMaxMs };
   relaisEnCours += 1;
-  try { await travail(); } finally { relaisEnCours -= 1; }
+  try { await travail(bornes); } finally { relaisEnCours -= 1; }
 }
 
 // GREFFONS de ce studio — jamais du player. `null` quand le module est absent ou coupé
@@ -262,7 +284,7 @@ const { refuserEnTexte, repondreJson, repondreJsonTexte } = require("./reponses.
 // exemplaires d'un fait divergent, c'est la formule du dépôt.
 const POLITIQUE_PERMISSIONS = "camera=(), microphone=(), geolocation=(), payment=()";
 
-async function relayerFichier(res, r, disposition) {
+async function relayerFichier(res, r, disposition, bornes = { stallMs: relaisStallMs, maxMs: relaisMaxMs }) {
   if (!r) { refuserEnTexte(res, 404, "Fichier indisponible"); return; }
   // 413 et 416 sont des REFUS ARGUMENTÉS de l'amont local (plafond, borne absurde) : les fondre
   // dans un 502 dirait « panne » là où l'amont a dit « demande irrecevable ».
@@ -347,8 +369,8 @@ async function relayerFichier(res, r, disposition) {
   // ne se réarme jamais. L'abandon passe par le signal du pipeline, qui détruit la source ET la réponse.
   const abandon = new globalThis.AbortController();
   let stall = null;
-  const rearmer = () => { clearTimeout(stall); stall = setTimeout(() => abandon.abort(new Error(`relais abandonné : aucune progression depuis ${relaisStallMs} ms`)), relaisStallMs); };
-  const budget = setTimeout(() => abandon.abort(new Error(`relais abandonné : plus de ${relaisMaxMs} ms au total`)), relaisMaxMs);
+  const rearmer = () => { clearTimeout(stall); stall = setTimeout(() => abandon.abort(new Error(`relais abandonné : aucune progression depuis ${bornes.stallMs} ms`)), bornes.stallMs); };
+  const budget = setTimeout(() => abandon.abort(new Error(`relais abandonné : plus de ${bornes.maxMs} ms au total`)), bornes.maxMs);
   rearmer();
   try {
     await pipeline(Readable.fromWeb(r.body), async function* (source) {
@@ -817,6 +839,15 @@ async function handlerMesure(req, res) {
             derniereIlYaS: dernier == null ? null : Math.max(0, Math.round((Date.now() - dernier) / 1000)),
           };
         })(),
+        // ⚠️ MÊME FORME, AUTRE PLAFOND. `lectureSaturee` est le cache de lecture ; ceci est l'admission
+        // des relais de fichiers (`config.maxConcurrentRelays`). Un hôte a lu le premier pour le second
+        // (13/09) parce que le second n'existait pas sur la carte — et `mesures.statuts.occupe503`
+        // les confond. Trois clés, jamais séparées : un total sans sa fenêtre ment par omission.
+        relaisRefuses: {
+          total: relaisRefusesTotal,
+          fenetreS: Math.round(process.uptime()),
+          derniereIlYaS: dernierRefusRelais == null ? null : Math.max(0, Math.round((Date.now() - dernierRefusRelais) / 1000)),
+        },
         // ⚠️ CE QUE CETTE INSTANCE A VÉCU — parce que `lectureSaturee` ne répondait qu'à UNE
         // question. « La route est-elle lente ? », « lesquelles ? », « la base ou nous ? »,
         // « combien de 5xx ? », « la boucle décroche-t-elle ? » n'avaient aucune réponse
@@ -1037,9 +1068,9 @@ async function handlerMesure(req, res) {
       if (String(q.file || "") === "1") {
         if (!isAllowedStorageUrl(pres.file_url)) { refuserEnTexte(res, 404, "Fichier indisponible"); return; }
         const range = req.headers["range"];
-        await relayerSousAdmission(res, async () => {
+        await relayerSousAdmission(res, async (bornes) => {
           const r = await PLAYER.storage.fetchFile(pres.file_url, { range });
-          await relayerFichier(res, r, null);
+          await relayerFichier(res, r, null, bornes);
         });
         return;
       }
@@ -1062,9 +1093,9 @@ async function handlerMesure(req, res) {
       if (!isAllowedStorageUrl(url)) return sendRefusal(res, "url-not-allowed", embed);
       if (String(q.stream || "") === "1") {
         const range = req.headers["range"];
-        await relayerSousAdmission(res, async () => {
+        await relayerSousAdmission(res, async (bornes) => {
           const r = await PLAYER.storage.fetchFile(url, { range });
-          await relayerFichier(res, r, dispositionInline(q.name));
+          await relayerFichier(res, r, dispositionInline(q.name), bornes);
         });
         return;
       }
@@ -1116,9 +1147,9 @@ async function handlerMesure(req, res) {
       // Stream depuis le Storage en RELAYANT les requêtes Range → pdf.js charge progressivement (les 1res
       // pages s'affichent sans télécharger tout le PDF) → affichage bien plus rapide.
       const range = req.headers["range"];
-      await relayerSousAdmission(res, async () => {
+      await relayerSousAdmission(res, async (bornes) => {
         const r = await PLAYER.storage.fetchFile(share.file_url, { range });
-        await relayerFichier(res, r, dispositionInline(share.file_name));
+        await relayerFichier(res, r, dispositionInline(share.file_name), bornes);
       });
       return;
     }
@@ -1211,6 +1242,9 @@ async function handlerMesure(req, res) {
 // regardant si le corps a été lu, ce qu aucune route ne peut montrer de l extérieur.
 // ⚠️ Exporté pour être ÉPROUVÉ : « le contexte reste vivant » ne se vérifie pas de l'extérieur.
 module.exports = { __contexte: () => PLAYER, handler, init, TIERS, POLITIQUE_PERMISSIONS, refuserEnTexte, repondreJson, __relayerFichier: relayerFichier, __jsonPourScript: jsonPourScript,
+  // ⚠️ COUTURE DE BANC : le compteur de relais en vol est un état du PROCESSUS, jamais remis à zéro par
+  // `init`. Un banc doit pouvoir vérifier qu'il revient à zéro et ne passe jamais sous zéro.
+  __relaisEnCours: () => relaisEnCours,
   // ⚠️ COUTURE DE BANC, PAS D'API : le cache de lecture est global au module, et un banc qui laisse des
   // lectures en vol contamine le suivant (128 promesses éternelles, 503 partout — trouvé par un audit
   // externe sous mélange, graine 20260913). Un banc doit pouvoir VÉRIFIER qu'il rend le cache vide.

package/server/routes-visiteur.js

@@ -20,9 +20,11 @@ let PLAYER = null;
 // Deux dimensions pour le code, parce qu'une seule se contourne : par ADRESSE (une adresse ne
 // recommence pas à zéro en changeant d'email) et par IDENTITÉ (plusieurs adresses ne forcent pas un
 // même email). Les compteurs sont pris À L'ADMISSION, donc réussite, échec et exception les
-// consomment pareil. L'identité est une EMPREINTE de l'email normalisé, jamais l'email : la table des
-// compteurs n'a pas à porter d'adresses en clair. (Le cœur n'a pas de secret de serveur, par
-// conception — voir le contexte autonome — donc une empreinte, pas un HMAC.)
+// consomment pareil. L'identité n'est jamais l'email : la table des compteurs n'a pas à porter
+// d'adresses en clair. La clé vient du GREFFON (un HMAC avec un secret chez l'hôte, ci-dessous) ;
+// l'empreinte SHA-256 n'est que le repli, et il est dit. ⚠️ Ce paragraphe affirmait « le cœur n'a
+// pas de secret de serveur, donc une empreinte, pas un HMAC » — retiré (cinquième passe de l'audit,
+// 13/09) : trop absolu, et surtout la clé n'a pas besoin d'un secret du cœur, elle vient de l'hôte.
 const VERIF_PAR_ADRESSE = 100, VERIF_PAR_IDENTITE = 10, VERIF_FENETRE_IDENTITE_S = 900;
 const GOOGLE_PAR_ADRESSE = 100, DEMANDE_PAR_IDENTITE = 5;
 // ⚠️ UN SHA-256 D'EMAIL N'EST PAS UNE ANONYMISATION : il se renverse par dictionnaire — qui lit la

package/types/context.d.ts

@@ -128,13 +128,17 @@ export interface Reglages {
   supabasePublishableKey: string;
   mapsKey: string;
   extraFrameAncestors: string[];
-  /** Transferts de fichiers relayés simultanément par processus (défaut 64). Au-delà, le relais
-   *  répond 503 + Retry-After AVANT l'appel amont ; la place est rendue en `finally`. */
+  /** Transferts de fichiers relayés simultanément par processus (défaut 64 ; entier de 1 à 1024,
+   *  sinon le défaut, dit une fois à `init`). Au-delà, le relais répond 503 + Retry-After AVANT
+   *  l'appel amont ; la place est rendue en `finally`. 64 n'est pas sûr partout : 64 × 8 Mio avec
+   *  des clients lents font monter la RSS de 130 à 194 Mio — 16 à 32 sur un processus à 256 Mio. */
   maxConcurrentRelays?: number;
   /** Un relais sans progression pendant ce délai est abandonné — source et réponse détruites, place
-   *  rendue (défaut 30 000 ms). `requestTimeout` ne borne pas l'émission d'une réponse. */
+   *  rendue (défaut 30 000 ms ; entier de 1 à 86 400 000 ms, sinon le défaut, dit une fois à `init` :
+   *  `setTimeout` ramène à 1 ms tout délai au-delà de 2 147 483 647 ms). `requestTimeout` ne borne
+   *  pas l'émission d'une réponse. */
   relayStallMs?: number;
-  /** Durée totale maximale d'un relais (défaut 900 000 ms). */
+  /** Durée totale maximale d'un relais (défaut 900 000 ms ; même plage que `relayStallMs`). */
   relayMaxMs?: number;
   /** Ce qui est POSÉ, à côté de ce que le code SAIT faire : la carte d'identité publie les deux,
    *  parce qu'une capacité disponible mais non configurée se comporte comme une absence. */