discovery-media-player 0.1.165 → 0.1.167

package/context/standalone.js

@@ -18,6 +18,20 @@
 const crypto = require("node:crypto");
 const storage = require("./storage");
 
+// ⚠️ « JAMAIS BLOQUANT » NE TENAIT QUE POUR UNE EXCEPTION SYNCHRONE, ICI AUSSI. Le cœur a reçu
+// `server/capture.js` à la sixième passe de l'audit ; ce contexte gardait cinq appels directs à
+// `journal.capture` sous un `try/catch`, et un helper en ligne dans `appelHote`. Or `ctx.errors` et le
+// journal capturé par ces capacités sont LE MÊME objet : un hôte qui pose un `capture` qui rejette
+// tuait le processus à `mail.send` sans secret, avant tout réseau (reproduit par l'audit, septième
+// passe, 14/09). Même règle que le cœur, reprise ici sans l'importer — le contexte ne dépend pas du
+// serveur — et UNE seule forme : tout appel au journal passe par ici, un banc structurel le tient.
+function capturerJournalSansBloquer(journal, erreur, meta) {
+  try {
+    const resultat = journal && typeof journal.capture === "function" ? journal.capture(erreur, meta) : undefined;
+    if (resultat && typeof resultat.then === "function") resultat.then(undefined, () => { /* un journal ne doit jamais interrompre le traitement */ });
+  } catch { /* exception synchrone : même règle */ }
+}
+
 /**
  * Retire les barres finales d'une base d'URL.
  *
@@ -228,7 +242,7 @@ async function appelHote(url, secret, corps, errors) {
   // indiscernable de « le droit est refusé », et on cherche pendant une demi-journée du côté des
   // rôles. Un hôte qui a écrit sa route sur la description du contrat plutôt que sur le code a
   // perdu exactement ce temps-là.
-  const signaler = (quoi) => { try { errors && errors.capture(new Error(`route hôte : ${quoi}`), { url }); } catch { /* jamais bloquant */ } };
+  const signaler = (quoi) => capturerJournalSansBloquer(errors, new Error(`route hôte : ${quoi}`), { url });
   try {
     const r = await fetchBorne(url, {
       method: "POST",
@@ -333,7 +347,7 @@ function creerLimites(db, journal, horloge = () => Date.now()) {
   function prevenirUneFois(message) {
     if (deja === message) return;
     deja = message;
-    try { journal.capture(new Error(message), { route: "limits" }); } catch { /* jamais bloquant */ }
+    try { capturerJournalSansBloquer(journal, new Error(message), { route: "limits" }); } catch { /* jamais bloquant */ }
   }
 
   async function tablePresente() {
@@ -346,7 +360,7 @@ function creerLimites(db, journal, horloge = () => Date.now()) {
       if (!signale) {
         signale = true;
         try {
-          journal.capture(new Error(
+          capturerJournalSansBloquer(journal, new Error(
             "compteurs de débit non partagés : appliquez supabase/migrations/0003-limites-partagees.sql. "
             + "Sans elle, chaque instance compte pour elle seule et les limites sont plus lâches qu'annoncé.",
           ), { route: "limits" });
@@ -546,7 +560,7 @@ function createStandaloneContext(env = process.env) {
         const secret = String(env.PLAYER_HOST_MAIL_SECRET || "");
         if (!url) return null;
         if (!secret) {
-          try { journal.capture(new Error("PLAYER_HOST_MAIL_URL est configurée sans PLAYER_HOST_MAIL_SECRET : aucun envoi ne partira"), {}); } catch { /* ignore */ }
+          try { capturerJournalSansBloquer(journal, new Error("PLAYER_HOST_MAIL_URL est configurée sans PLAYER_HOST_MAIL_SECRET : aucun envoi ne partira"), {}); } catch { /* ignore */ }
           return null;
         }
         const reponse = await appelHote(url, secret, message, journal);
@@ -591,7 +605,7 @@ function createStandaloneContext(env = process.env) {
         if (emetteur && !cle) {
           // Le refus silencieux est le piège de cette configuration : sans clé, chaque membre est
           // simplement « non authentifié », ce qui ressemble à un droit manquant. On le dit.
-          try { journal.capture(new Error("PLAYER_AUTH_URL est configurée sans PLAYER_AUTH_KEY : aucun jeton ne peut être vérifié"), {}); } catch { /* ignore */ }
+          try { capturerJournalSansBloquer(journal, new Error("PLAYER_AUTH_URL est configurée sans PLAYER_AUTH_KEY : aucun jeton ne peut être vérifié"), {}); } catch { /* ignore */ }
         }
         if (!jeton || !url || !cle) return null;
         try {
@@ -757,7 +771,7 @@ function createStandaloneContext(env = process.env) {
         // parfaitement intentionnée — vaut refus, et le dit. C'est le cas le plus courant au
         // branchement d'un nouvel hôte.
         if (reponse && typeof reponse.allowed !== "boolean") {
-          try { journal.capture(new Error("route d'autorisation : champ `allowed` booléen attendu"), { recu: Object.keys(reponse).join(",") }); } catch { /* ignore */ }
+          try { capturerJournalSansBloquer(journal, new Error("route d'autorisation : champ `allowed` booléen attendu"), { recu: Object.keys(reponse).join(",") }); } catch { /* ignore */ }
         }
         return reponse ? reponse.allowed === true : false;
       },
@@ -842,11 +856,20 @@ 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.
+      // ⚠️ ET « TEL QUEL » VEUT DIRE LA CHAÎNE, PAS `Number(chaîne)`. La seconde écriture convertissait
+      // encore : « abc » arrivait au cœur en NaN et le diagnostic disait `relayStallMs=NaN` — l'exploitant
+      // ne retrouvait pas ce qu'il avait saisi (audit, sixième passe). La chaîne passe intacte ; absente
+      // ou vide, le cœur applique le défaut sans avertir (« non posé »).
+      maxConcurrentRelays: env.PLAYER_MAX_RELAYS,
       // 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,
+      relayMaxMs: env.PLAYER_RELAY_MAX_MS,
 
       /**
        * 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,
@@ -184,7 +185,7 @@ these numbers from their side.
 | `routes` | one entry per family of work — `document`, `presentation`, `action`, `fichier`, `carte`, `autre`. Families absent from the object were never exercised in this process |
 | `base` | the same shape, for calls through the `db` capability **you** supply — measured at the seam, so it covers every call, including ones nobody has written yet |
 | `statuts` | responses by class: `ok` (<400), `refus4xx`, `debit429`, `occupe503`, `erreur5xx` |
-| `memoireMio` | `rss`, `heap` (heap used), `tampons` (`arrayBuffers`) in MiB, read at the moment of the request |
+| `memoireMio` | `rss`, `heap` (heap used), `tampons` (`arrayBuffers`) in MiB, read at the moment of the request. ⚠️ **Half a number**: it is only judicable against the memory ceiling of the process, which the player does not know and no platform serves the same way — on Lambda-based functions (Vercel included) read `AWS_LAMBDA_FUNCTION_MEMORY_SIZE`; in a container, the cgroup limit. A host spent half a day finding that its project API, its logs and its `vercel.json` all left it out (14/09). Display the ceiling beside the RSS, or the RSS says nothing about the relay ceiling you can afford |
 | `boucleMs` | event-loop **delay** — `moyen` and `p99` in ms, with `n` samples and the sampler's `resolutionMs` |
 
 ⚠️ **A percentile over buckets is a bound, not a value.** `p95sousMs: 250` reads *"95% of calls
@@ -237,10 +238,52 @@ saturate*; on a process that started four seconds ago it says *nobody has looked
 same trap as `inconnu` in the two rows above, and the reason the three keys are returned as one
 object rather than as separate fields you could read apart.
 
+⚠️ **Read `fenetreS` first — and on serverless, expect it to stay short.** Every counter on this
+card belongs to the process, and on a serverless platform the process is the unit that dies: a host
+read its two domains a few minutes apart and got windows of 15 s and 19 s, then 4 s and 7 s — the
+processes had been recycled in between (14/09). There, `total: 0` over 15 seconds means *nothing in
+the last quarter of a minute*, which is almost no information, and these counters can structurally
+never accumulate more than a cold start's lifetime. This is not a defect of the field — on a
+long-lived process it says what it should — it is a limit of applicability, and `fenetreS` is the
+key that reveals it. So the reading order is: `fenetreS`, then `total`; and a fleet of short windows
+is a fact about your hosting, never a reassurance. ⚠️ **And sampling from outside does not repair a
+short window — it inherits it.** A host did the arithmetic (14/09): a daily cron reading a counter
+whose window is ~15 s observes 15 × 365 = 5 475 seconds a year out of 31 536 000, 0.017 % of the
+time; an hourly one, 0.42 %. A `total: 0` collected 365 times a year says exactly what it says once,
+with the added look of a time series — the credibility of a surveillance without the surveillance.
+The only form that would work on serverless is a **push at the end of the process**, because the
+process is the one entity that knows its own total and it dies without saying it. The player does
+not do that today, and no serverless platform guarantees a hook to do it in; this paragraph states
+the limit with its way out, so that nobody builds the sampler first.
+The same applies to `relaisRefuses` below and to the **counters** under `mesures` (`statuts`,
+`routes`, `base`).
+
+⚠️ **Three natures share this card, and the rule above covers only the first.** An earlier version
+of this paragraph said it applied to "everything under `mesures`" — too broad, and a host applied
+the counter rule to a gauge because nothing told it the gauge was not covered (14/09).
+
+| nature | examples | what qualifies it | what saves it |
+|---|---|---|---|
+| **counter** | `lectureSaturee`, `relaisRefuses`, `mesures.statuts` | accumulates over `fenetreS` | read `fenetreS` first — a long window makes a zero informative |
+| **gauge** | `mesures.memoireMio` | the state **at the instant of the read** (`process.memoryUsage()`); no window enters its production | **nothing on the card**: a process idle for a week shows the same ~64 MiB as one born a minute ago, and a long window would only make it *look* trustworthy. It says nothing about what the process would weigh under load; the only way to learn that is to read it *during* a load — which an audit can provoke and a host must not on real readers |
+| **sample** | `mesures.boucleMs` | `{ n: 0, moyen: null, p99: null }` until something was observed | itself — it refuses to answer rather than return an interpretable zero |
+
 ⚠️ **It is process-local.** Behind a load balancer this is the count of the instance that answered,
 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 +814,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 +873,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.167",
   "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,63 @@
+// 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 ». ⚠️ La famille est plus
+  // large que les booléens, et un hôte l'a payée : `Number(null)` et `Number("")` valent 0, et chez
+  // lui une absence devenait une coordonnée (0, 0) valide, en six endroits dont un qui débitait un
+  // quota (ADV, 14/09). L'ORDRE des opérations est le seul remède général : l'absence est écartée
+  // ci-dessus AVANT toute conversion, et 0 tombe ensuite sous `min`. Ce n'est pas un hasard.
+  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/capture.js

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright © 2026 3D Discovery
+// « JAMAIS BLOQUANT » NE TENAIT QUE POUR UNE EXCEPTION SYNCHRONE.
+//
+// ⚠️ TRENTE-CINQ APPELS À `errors.capture` PORTAIENT LE COMMENTAIRE « jamais bloquant » SOUS UN
+// `try/catch` — QUI N'ATTRAPE QU'UNE EXCEPTION SYNCHRONE. Le contrat autorise `capture` à rendre une
+// promesse ; une promesse REJETÉE échappait au `catch`, remontait en `unhandledRejection`, et Node
+// arrête le processus : reproduit par un audit externe sur le tag v0.1.166, à `init`, avec un
+// `capture` qui rejette et une configuration hors plage — sortie 1 avant le premier octet servi
+// (sixième passe, 14/09). Un journal qui échoue ne doit rien arrêter, ni de façon synchrone ni de
+// façon asynchrone : c'est la même règle, et elle vit ici, une fois, pour tous les appelants.
+//
+// ⚠️ On n'ATTEND pas la promesse — on la neutralise. Attendre ferait dépendre chaque réponse de la
+// latence du journal de l'hôte ; ici on veut juste qu'un rejet ne tue personne.
+
+/**
+ * Confie une erreur au journal de l'hôte sans que le journal puisse, lui, faire échouer quoi que
+ * ce soit — ni par une exception, ni par une promesse rejetée. `errors` peut être absent.
+ */
+function capturerSansBloquer(errors, erreur, meta) {
+  try {
+    const r = errors && typeof errors.capture === "function" ? errors.capture(erreur, meta) : undefined;
+    if (r && typeof r.then === "function") r.then(undefined, () => { /* un journal qui échoue ne doit rien arrêter */ });
+  } catch { /* exception synchrone : même règle */ }
+}
+
+module.exports = { capturerSansBloquer };

package/server/handler.js

@@ -6,6 +6,7 @@
 //  - GET  /doc/:slug?file=1     → stream le PDF depuis le Storage (MÊME ORIGINE → pas de souci CORS pour pdf.js)
 //  - POST /api/doc {slug,event…}→ journalise un événement (open / page / heartbeat) — best-effort
 const crypto = require("crypto");
+const { capturerSansBloquer } = require("./capture");
 const { Readable } = require("node:stream");
 const { pipeline } = require("node:stream/promises");
 const { getShareBySlug } = require("./shares");
@@ -40,10 +41,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 { capturerSansBloquer(PLAYER.errors, 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 +82,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,24 +98,27 @@ 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)) {
-        PLAYER.errors.capture(new Error(`relais refusés : ${plafondRelais} transferts simultanés atteints dans ce processus (config.maxConcurrentRelays)`), { route: "relais", benin: true });
+        capturerSansBloquer(PLAYER.errors, new Error(`relais refusés : ${plafondRelais} transferts simultanés atteints dans ce processus (config.maxConcurrentRelays)`), { route: "relais", benin: true });
       }
     } catch { /* jamais bloquant */ }
     res.setHeader("Retry-After", "2");
     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 +285,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 ».
@@ -288,7 +311,7 @@ async function relayerFichier(res, r, disposition) {
   const brute = r.headers.get("content-length");
   const annoncee = Number(brute || 0);
   if (annoncee > PLAFOND_RELAIS) {
-    try { PLAYER.errors.capture(new Error(`relais refusé : ${annoncee} octets au-dessus du plafond de ${PLAFOND_RELAIS}`), { route: "relais" }); } catch { /* jamais bloquant */ }
+    try { capturerSansBloquer(PLAYER.errors, new Error(`relais refusé : ${annoncee} octets au-dessus du plafond de ${PLAFOND_RELAIS}`), { route: "relais" }); } catch { /* jamais bloquant */ }
     refuserEnTexte(res, 413, "Fichier trop volumineux");
     // ⚠️ Renoncer ne suffit pas : un corps jamais tiré laisse la connexion amont OUVERTE, et le
     // pool de sockets s'épuise sur les gros fichiers — exactement la ressource qu'on protège.
@@ -347,8 +370,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) {
@@ -365,7 +388,7 @@ async function relayerFichier(res, r, disposition) {
     // reste que la coupure. Une coupure fréquente ici est un plafond mal réglé ou un amont
     // défaillant : l'avaler ferait passer un défaut d'exploitation pour un caprice du réseau.
     const cause = abandon.signal.aborted && abandon.signal.reason instanceof Error ? abandon.signal.reason : erreur;
-    try { PLAYER.errors.capture(cause instanceof Error ? cause : new Error(String(cause)), { route: "relais" }); } catch { /* jamais bloquant */ }
+    try { capturerSansBloquer(PLAYER.errors, cause instanceof Error ? cause : new Error(String(cause)), { route: "relais" }); } catch { /* jamais bloquant */ }
     try { res.destroy(); } catch { /* le socket est peut-être déjà parti */ }
   } finally {
     clearTimeout(stall); clearTimeout(budget);
@@ -817,6 +840,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 +1069,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 +1094,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 +1148,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;
     }
@@ -1188,7 +1220,7 @@ async function handlerMesure(req, res) {
     // exactement comme sans PLAYER_HOST_AUTHZ_URL personne ne peut DIFFUSER.
     if (share.embed && !(PLAYER.config.extraFrameAncestors || []).length) {
       try {
-        PLAYER.errors.capture(
+        capturerSansBloquer(PLAYER.errors,
           new Error("?embed=1 demandé mais DOC_FRAME_ANCESTORS est vide : seuls une page de même origine et *.vercel.app peuvent encadrer cette instance"),
           { route: "doc", indice: "le navigateur bloquera l'iframe avant le chargement — aucun embed-denied ne partira" },
         );
@@ -1211,6 +1243,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/presentations.js

@@ -4,6 +4,7 @@
 // (cf. migration v12324) — écriture service role only. Le présentateur détient un control_token ; on en
 // stocke le HASH (sha256) → l'audience peut lire la ligne (Realtime) sans pouvoir piloter.
 const crypto = require("crypto");
+const { capturerSansBloquer } = require("./capture");
 // Base de données via le contexte injecté (cf. _player-context.js) — aucune adhérence au studio.
 // ⚠️ 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.
@@ -487,7 +488,7 @@ async function createUploadUrl(slug, name, type) {
   // serait pire : une pièce jointe qui ne part jamais, sans que personne sache que la capacité
   // manque.
   if (!PLAYER.storage || typeof PLAYER.storage.signUpload !== "function") {
-    try { PLAYER.errors.capture(new Error("storage.signUpload absent du contexte : les pièces jointes de chat sont indisponibles"), {}); } catch { /* jamais bloquant */ }
+    try { capturerSansBloquer(PLAYER.errors, new Error("storage.signUpload absent du contexte : les pièces jointes de chat sont indisponibles"), {}); } catch { /* jamais bloquant */ }
     return { ok: false, status: 501 };
   }
   const signe = await PLAYER.storage.signUpload("present-attachments", path);
@@ -687,7 +688,7 @@ async function addMessage(slug, { name, email, avatar, isPresenter, isMember, bo
     // attendu est journalisé une fois, en clair, parce qu'un renvoi fréquent est une information.
     const conflit = cle && estConflit(erreur);
     if (!conflit) throw erreur;
-    try { PLAYER.errors.capture(new Error("message déjà enregistré (renvoi) : " + String(slug)), { route: "present-chat", benin: true }); } catch { /* jamais bloquant */ }
+    try { capturerSansBloquer(PLAYER.errors, new Error("message déjà enregistré (renvoi) : " + String(slug)), { route: "present-chat", benin: true }); } catch { /* jamais bloquant */ }
     const deja = await PLAYER.db.request(
       `doc_presentation_messages?slug=eq.${enc(String(slug))}&client_key=eq.${enc(cle)}&select=*&limit=1`);
     const ligne = Array.isArray(deja) && deja[0];
@@ -1022,7 +1023,7 @@ async function appelerBump(corps, durcissementVoulu) {
     // bootstrap auto-déclaré s'emparer d'une présence réclamée — c'est-à-dire une fermeture qui
     // rassure sans protéger. On nomme donc le fichier ET la conséquence.
     try {
-      PLAYER.errors.capture(new Error(
+      capturerSansBloquer(PLAYER.errors, new Error(
         "bootstrap de présence NON durci : appliquez supabase/migrations/0018-bootstrap-non-usurpable.sql. "
         + "Sans elle, un bootstrap auto-déclaré peut écraser une présence déjà réclamée par un porteur "
         + "de jeton — n'armez pas PLAYER_PRESENCE_STRICT avant de l'avoir appliquée.",
@@ -1162,7 +1163,7 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
     // battements ORDINAIRES, qui continuent de se replier normalement.
     if (onlyIfUnclaimed) {
       try {
-        PLAYER.errors.capture(new Error(
+        capturerSansBloquer(PLAYER.errors, 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" });
@@ -1181,7 +1182,7 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
         const fichier = transitionDispo
           ? "supabase/migrations/0017-jeton-presence.sql (ou 0015-presence-atomique.sql)"
           : "supabase/migrations/0015-presence-atomique.sql";
-        PLAYER.errors.capture(new Error(
+        capturerSansBloquer(PLAYER.errors, new Error(
           "présence non atomique : appliquez " + fichier + ". "
           + "Sans elle, la présence est écrite par lire-modifier-réécrire (correct) mais le plafond "
           + "de création de faux participants anonymes n'est pas appliqué. "
@@ -1235,7 +1236,7 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
         if (!estConflit(erreur)) throw erreur;
         // Journalisé comme bénin : deux onglets qui arrivent ensemble sont une information, pas
         // une panne — et la garde des écritures muettes exige que tout rattrapage parle.
-        try { PLAYER.errors.capture(new Error("présence déjà ouverte (second onglet) : " + String(slug)), { route: "present-attend", benin: true }); } catch { /* jamais bloquant */ }
+        try { capturerSansBloquer(PLAYER.errors, new Error("présence déjà ouverte (second onglet) : " + String(slug)), { route: "present-attend", benin: true }); } catch { /* jamais bloquant */ }
         continue;   // le tour suivant relit : la ligne que l'autre onglet vient de créer
       }
     }

package/server/retention.js

@@ -154,7 +154,7 @@ async function retirerFichier(bucket, chemin, opts) {
     if (!sansRemoveDit) {
       sansRemoveDit = true;
       try {
-        PLAYER.errors.capture(new Error("rétention : `storage.remove` n'est pas fourni — les lignes porteuses de fichiers"
+        capturerSansBloquer(PLAYER.errors, new Error("rétention : `storage.remove` n'est pas fourni — les lignes porteuses de fichiers"
           + " sont RETENUES (leur objet resterait sinon inatteignable, la capacité n'exposant jamais `list`)."
           + " Fournissez `storage.remove` pour qu'elles partent."), { route: "retention", benin: true });
       } catch { /* jamais bloquant */ }
@@ -232,6 +232,7 @@ async function resteEncore(table, filtre, colId, curseur, dryRun) {
 // avec le slug de la présentation purgée. Une validation d'écriture n'est jamais la seule barrière
 // d'un delete : les lignes déjà en base d'avant le correctif peuvent porter une URL piégée.
 const { cheminPieceJointe: cheminSurSlug } = require("./presentations");
+const { capturerSansBloquer } = require("./capture");
 
 // Purge des messages d'une présentation morte, par lots bornés qui lisent id+attachment ENSEMBLE :
 // on retire les fichiers du bucket du lot (si l'hôte sait), puis on supprime le lot. Rend `tronque`
@@ -360,7 +361,7 @@ async function purgerRetention(now, optsBrutes = {}) {
   try { f = fenetresValidees(); opts = optionsValidees(optsBrutes); }
   catch (e) {
     if (!e.retentionInvalide) throw e;
-    try { PLAYER.errors.capture(e, { route: "retention" }); } catch { /* jamais bloquant */ }
+    try { capturerSansBloquer(PLAYER.errors, e, { route: "retention" }); } catch { /* jamais bloquant */ }
     return { ok: false, error: e.message };   // config OU option douteuse → zéro DELETE
   }
   const base = String((PLAYER.config && PLAYER.config.supabaseUrl) || "");
@@ -480,7 +481,7 @@ function tick() {
   Promise.resolve()
     .then(() => PLAYER.limits.allow("retention:sweep", 1, 86400))
     .then((permis) => { if (permis) return purgerRetention(Date.now()); })
-    .catch((e) => { try { PLAYER.errors.capture(e, { route: "retention", benin: true }); } catch { /* jamais bloquant */ } });
+    .catch((e) => { try { capturerSansBloquer(PLAYER.errors, e, { route: "retention", benin: true }); } catch { /* jamais bloquant */ } });
 }
 
 /**

package/server/routes-agent.js

@@ -9,6 +9,7 @@
 // des bancs) n'ont que WebCrypto, et la route rendait alors 500 à la première synthèse. Le banc
 // agentVoix.test.js échoue sans cette ligne.
 const crypto = require("node:crypto");
+const { capturerSansBloquer } = require("./capture");
 const { adresseAppelant } = require("./appelant");
 const { jsonPour, etiquetteRoute } = require("./reponses.js");
 
@@ -355,7 +356,7 @@ async function traiter(req, res, body, _slug) {
             cached: extrait.cached || undefined,
             spoken: spoken !== text ? spoken : undefined,
           });
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
       if (body.action === "bot-start" || body.action === "bot-say" || body.action === "bot-history" || body.action === "bot-nudge" || body.action === "bot-book" || body.action === "bot-contact" || body.action === "bot-rate" || body.action === "bot-script") {
         const jp = jsonPour(res);
@@ -470,7 +471,7 @@ async function traiter(req, res, body, _slug) {
           const r = await docbot.botSay(String(body.sessionId || ""), share, text, pages, mobile, blang);
           if (r.error) return jp(400, { ok: false, error: r.error });
           return jp(200, { ok: true, ...r });
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
       // Assistance (heartbeat) : PUBLIC (l'audience est anonyme). Journalise qui suit / combien de temps / pages vues.
       // Rate-limit généreux par IP (heartbeat ≈ 145/h/participant) : bloque le spam d'assistants factices sans

package/server/routes-direct.js

@@ -4,6 +4,7 @@
 // Reste à PLAT dans server/ (les gardes de forge ciblent server/*.js).
 
 const { adresseAppelant, lcMembre, cleAnonyme, profilDuJeton } = require("./appelant");
+const { capturerSansBloquer } = require("./capture");
 const { jsonPour, etiquetteRoute } = require("./reponses.js");
 
 const { createPresentation, getPresentation, setPage, endPresentation, addMessage, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent } = require("./presentations");
@@ -49,7 +50,7 @@ async function traiter(req, res, body, _slug) {
           // hôte, chaque « Terminer » échouait en 23502 (marqueur d'archive NOT NULL) — et ce 500
           // muet ne laissait RIEN, même pas une ligne dans le journal d'erreurs. Un journal que
           // personne ne lit vaut peu ; aucun journal ne vaut rien du tout.
-          try { PLAYER.errors.capture(erreur instanceof Error ? erreur : new Error(String(erreur)), { route: etiquetteRoute("present-" + String(body.action || "").replace(/^present-/, "")) }); } catch { /* jamais bloquant */ }
+          try { capturerSansBloquer(PLAYER.errors, erreur instanceof Error ? erreur : new Error(String(erreur)), { route: etiquetteRoute("present-" + String(body.action || "").replace(/^present-/, "")) }); } catch { /* jamais bloquant */ }
           return jp(500, { ok: false });
         }
       }
@@ -174,7 +175,7 @@ async function traiter(req, res, body, _slug) {
           if (PLAYER.config && PLAYER.config.presenceStrict && !peutEmettre && !profil) {
             try {
               if (await PLAYER.limits.allow("presence:strict-inerte", 1, 3600)) {
-                PLAYER.errors.capture(new Error(
+                capturerSansBloquer(PLAYER.errors, new Error(
                   "PLAYER_PRESENCE_STRICT est posé mais AUCUN jeton ne peut être émis "
                   + "(PLAYER_PRESENCE_SECRET absent) : la porte reste OUVERTE. Armé tel quel, elle "
                   + "refuserait tous les participants anonymes.",
@@ -228,7 +229,7 @@ async function traiter(req, res, body, _slug) {
           // des présences) : une présentation close refuse toute écriture, jeton valide ou non.
           const pt = (r.ok && jetonCandidat) ? jetonCandidat : "";
           return jp(r.ok ? 200 : (r.status || 400), pt ? { ...r, pt } : r);
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
       // Gestion des présentations (membre AUTHENTIFIÉ requis) : liste / reprise / transfert / stats / historique doc.
       if (body.action === "present-list" || body.action === "present-reclaim" || body.action === "present-handover" || body.action === "present-owner-end" || body.action === "present-stats" || body.action === "present-doc-list" || body.action === "present-switch" || body.action === "present-content") {
@@ -281,7 +282,7 @@ async function traiter(req, res, body, _slug) {
           else if (body.action === "present-content") r = await setPresentationContent(String(body.slug || ""), (u && u.email) || "", isAdmin, body.content, String(body.control || ""));
           else r = await handoverPresentation(String(body.slug || ""), u.email, body.newOwner);
           return jp(r.ok ? 200 : (r.status || 400), r);
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
       // Chat de présentation (historisé) : n'importe quel participant (présentateur ou audience) poste un
       // message. Écriture via service role ; anti-spam par IP (60/h). La présentation doit exister.
@@ -313,7 +314,7 @@ async function traiter(req, res, body, _slug) {
             avatar: profil ? profil.avatar : null,
             isPresenter: validControl, isMember: !!profil, body: body.body, replyTo: body.replyTo, replyName: body.replyName, replyText: body.replyText, authorToken: body.authorToken, attachment: body.attachment , clientKey: body.clientKey });
           return jp(r.ok ? 200 : (r.status || 400), r);
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
       // Pièce jointe : URL d'upload signée (la présentation doit exister ; rate-limit).
       if (body.action === "present-upload-url") {
@@ -326,7 +327,7 @@ async function traiter(req, res, body, _slug) {
           if (!allowed) return jp(429, { ok: false, error: "rate" });
           const r = await createUploadUrl(String(body.slug || ""), body.name, body.type);
           return jp(r.ok ? 200 : (r.status || 400), r);
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
       // Chat : éditer / supprimer un message, verrouiller le chat.
       if (body.action === "present-msg-edit" || body.action === "present-msg-delete" || body.action === "present-chatlock") {
@@ -337,7 +338,7 @@ async function traiter(req, res, body, _slug) {
           else if (body.action === "present-msg-delete") r = await deleteMessage(String(body.slug || ""), body.msgId, { authorToken: body.authorToken, control: body.control });
           else r = await setChatLock(String(body.slug || ""), String(body.control || ""), !!body.locked);
           return jp(r.ok ? 200 : (r.status || 400), r);
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
       // Réaction emoji (toggle) sur un message du chat de présentation.
       if (body.action === "present-react") {
@@ -357,7 +358,7 @@ async function traiter(req, res, body, _slug) {
           const reacteur = require("./presentations").reacteurDepuisJeton(body.authorToken);
           const r = await toggleReaction(String(body.slug || ""), body.msgId, body.emoji, reacteur, body.etat);
           return jp(r.ok ? 200 : (r.status || 400), r);
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jp(500, { ok: false }); }
       }
   return false;
 }

package/server/routes-liens.js

@@ -4,6 +4,7 @@
 // Reste à PLAT dans server/ (les gardes de forge ciblent server/*.js).
 
 const { adresseAppelant } = require("./appelant");
+const { capturerSansBloquer } = require("./capture");
 const { jsonPour, repondreJson, etiquetteRoute } = require("./reponses.js");
 const { estConflit } = require("./erreurs-base.js");
 const { createShare, createReshare, sendReshareEmail, revokeShare, setShareAuth, listSharesForDoc, listSessionsForDoc, listSessionsForRecipient, internalStatsForDoc, cleIdempotence, getShareBySlug, logView, upsertSession, upsertInternalSession, overview: docOverview } = require("./shares");
@@ -56,7 +57,7 @@ async function traiter(req, res, body, slug) {
           const { action: _a, ...opts } = body;
           const resultat = await require("./retention").purgerRetention(Date.now(), opts);
           return jd(resultat.ok === false ? 400 : 200, resultat);
-        } catch (e) { try { PLAYER.errors.capture(e, { route: "retention" }); } catch { /* jamais bloquant */ } return jd(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: "retention" }); } catch { /* jamais bloquant */ } return jd(500, { ok: false }); }
       }
       if (String(body.action || "").startsWith("docshare.")) {
         const jd = jsonPour(res);
@@ -159,7 +160,7 @@ async function traiter(req, res, body, slug) {
                 });
               } catch (erreur) {
                 if (!estConflit(erreur)) throw erreur;
-                try { PLAYER.errors.capture(new Error("backfill hôte : la clé était déjà posée ailleurs — " + docId), { route: "hostshare", benin: true }); } catch { /* jamais bloquant */ }
+                try { capturerSansBloquer(PLAYER.errors, new Error("backfill hôte : la clé était déjà posée ailleurs — " + docId), { route: "hostshare", benin: true }); } catch { /* jamais bloquant */ }
                 const gagnant = await PLAYER.db.request(`commercial_doc_shares?idem_key=eq.${encodeURIComponent(cleHote)}&select=slug&limit=1`);
                 if (!Array.isArray(gagnant) || !gagnant[0]) throw erreur;
                 return jd(200, { ok: true, slug: gagnant[0].slug, reused: true });
@@ -186,7 +187,7 @@ async function traiter(req, res, body, slug) {
               return jd(200, { ok: true, slug: neuf.slug, reused: false });
             } catch (erreur) {
               if (!estConflit(erreur)) throw erreur;
-              try { PLAYER.errors.capture(new Error("lien hôte déjà créé par une demande simultanée : " + docId), { route: "hostshare", benin: true }); } catch { /* jamais bloquant */ }
+              try { capturerSansBloquer(PLAYER.errors, new Error("lien hôte déjà créé par une demande simultanée : " + docId), { route: "hostshare", benin: true }); } catch { /* jamais bloquant */ }
               const gagnant = await PLAYER.db.request(`commercial_doc_shares?idem_key=eq.${encodeURIComponent(cleHote)}&select=slug&limit=1`);
               if (!Array.isArray(gagnant) || !gagnant[0]) throw erreur;   // 409 d'autre chose : on ne l'invente pas
               return jd(200, { ok: true, slug: gagnant[0].slug, reused: true });
@@ -266,7 +267,7 @@ async function traiter(req, res, body, slug) {
               await PLAYER.db.request(`commercial_doc_shares?slug=eq.${encodeURIComponent(ex[0].slug)}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { doc_title: body.docTitle || null, file_url: String(body.fileUrl), file_name: body.fileName || null, bot_enabled: true, bot_guided: true, bot_profile_id: (body.profileId || "").trim() || null, revoked: false, ...(cleDispo ? { idem_key: cleTest } : {}) } });
             } catch (erreur) {
               if (!estConflit(erreur)) throw erreur;
-              try { PLAYER.errors.capture(new Error("backfill répétition : la clé était déjà posée ailleurs — " + docId), { route: "docshare-test", benin: true }); } catch { /* jamais bloquant */ }
+              try { capturerSansBloquer(PLAYER.errors, new Error("backfill répétition : la clé était déjà posée ailleurs — " + docId), { route: "docshare-test", benin: true }); } catch { /* jamais bloquant */ }
               const gagnant = await PLAYER.db.request(`commercial_doc_shares?idem_key=eq.${encodeURIComponent(cleTest)}&select=slug&limit=1`);
               if (!Array.isArray(gagnant) || !gagnant[0]) throw erreur;
               return jd(200, { ok: true, slug: gagnant[0].slug, reused: true });
@@ -279,7 +280,7 @@ async function traiter(req, res, body, slug) {
             return jd(200, { ok: true, slug: t.slug });
           } catch (erreur) {
             if (!estConflit(erreur)) throw erreur;
-            try { PLAYER.errors.capture(new Error("lien de répétition déjà créé par une demande simultanée : " + docId), { route: "docshare-test", benin: true }); } catch { /* jamais bloquant */ }
+            try { capturerSansBloquer(PLAYER.errors, new Error("lien de répétition déjà créé par une demande simultanée : " + docId), { route: "docshare-test", benin: true }); } catch { /* jamais bloquant */ }
             const gagnant = await PLAYER.db.request(`commercial_doc_shares?idem_key=eq.${encodeURIComponent(cleTest)}&select=slug&limit=1`);
             if (!Array.isArray(gagnant) || !gagnant[0]) throw erreur;
             return jd(200, { ok: true, slug: gagnant[0].slug, reused: true });
@@ -291,7 +292,7 @@ async function traiter(req, res, body, slug) {
         }
         const { slug } = await createShare({ brandKey: body.brandKey, docId: body.docId, docTitle: body.docTitle, fileUrl: body.fileUrl, fileName: body.fileName, recipientEmail: body.recipientEmail, recipientName: body.recipientName, createdBy: u.email, bot: body.bot, botScript: body.botScript, guided: body.guided, profileId: body.profileId, allowDownload: body.allowDownload, videoLayout: body.videoLayout, logo: body.logo, logoDark: body.logoDark });
         return jd(200, { ok: true, slug });
-        } catch (e) { try { PLAYER.errors.capture(e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jd(500, { ok: false }); }
+        } catch (e) { try { capturerSansBloquer(PLAYER.errors, e, { route: etiquetteRoute(body.action) }); } catch { /* jamais bloquant */ } return jd(500, { ok: false }); }
       }
 
       // Re-partage (forward depuis la visionneuse) : crée un lien enfant tracé, et envoie l'email via 3D
@@ -369,7 +370,7 @@ async function traiter(req, res, body, slug) {
             // Signalé par la seconde passe d'audit (P1-1).
             const publique = String(PLAYER.legal.publicUrl || "").trim();
             if (!publique) {
-              try { PLAYER.errors.capture(new Error("PLAYER_PUBLIC_URL non configurée : envoi refusé (le lien de l'email serait construit depuis l'en-tête Host, que le client choisit)"), { route: "reshare" }); } catch { /* jamais bloquant */ }
+              try { capturerSansBloquer(PLAYER.errors, new Error("PLAYER_PUBLIC_URL non configurée : envoi refusé (le lien de l'email serait construit depuis l'en-tête Host, que le client choisit)"), { route: "reshare" }); } catch { /* jamais bloquant */ }
               refusEnvoi = "public-url-unconfigured";
               throw new Error("URL publique non configurée");
             }
@@ -468,7 +469,7 @@ async function traiter(req, res, body, slug) {
           // et le signalement passe AVANT le `return`, sans quoi il ne s'exécuterait jamais.
           try {
             if (await PLAYER.limits.allow("intsess:quota-avert", 1, 3600)) {
-              PLAYER.errors.capture(new Error(`session interne refusée : quota horaire atteint (${SESSION_QUOTA_PER_HOUR}/h par adresse) — la mesure s'arrête tant qu'il l'est`), { route: "internal-session" });
+              capturerSansBloquer(PLAYER.errors, new Error(`session interne refusée : quota horaire atteint (${SESSION_QUOTA_PER_HOUR}/h par adresse) — la mesure s'arrête tant qu'il l'est`), { route: "internal-session" });
             }
           } catch { /* un journal ne doit jamais empêcher une lecture */ }
           repondreJson(res, 429, { ok: false, error: "rate" });
@@ -486,7 +487,7 @@ async function traiter(req, res, body, slug) {
           // Une fois par heure et par instance : assez pour être vu dans les journaux, pas assez
           // pour les noyer — un avertissement répété à chaque battement ne se lit plus.
           if (await PLAYER.limits.allow("intsess:avert", 1, 3600)) {
-            try { PLAYER.errors.capture(new Error("session interne écrite sans jeton : l'identité vient du navigateur. Poser PLAYER_INTERNAL_STRICT=1 une fois l'hôte à jour"), { route: "internal-session" }); } catch { /* ignore */ }
+            try { capturerSansBloquer(PLAYER.errors, new Error("session interne écrite sans jeton : l'identité vient du navigateur. Poser PLAYER_INTERNAL_STRICT=1 une fois l'hôte à jour"), { route: "internal-session" }); } catch { /* ignore */ }
           }
         }
         // Le jeton fait foi quand il est là : c'est l'hôte qui se porte garant, pas l'appelant.
@@ -517,7 +518,7 @@ async function traiter(req, res, body, slug) {
           // de mesure.
           try {
             if (await PLAYER.limits.allow("intsess:echec", 1, 3600)) {
-              PLAYER.errors.capture(new Error(`écriture de session interne refusée : ${e && e.message ? e.message : "cause inconnue"} — la mesure ne s'enregistre pas`), { route: "internal-session" });
+              capturerSansBloquer(PLAYER.errors, new Error(`écriture de session interne refusée : ${e && e.message ? e.message : "cause inconnue"} — la mesure ne s'enregistre pas`), { route: "internal-session" });
             }
           } catch { /* un journal ne doit jamais empêcher une lecture */ }
         }
@@ -545,7 +546,7 @@ async function traiter(req, res, body, slug) {
         // que l'exploitant peut relier à un quota, plutôt qu'une mesure qui stagne sans explication.
         try {
           const avert = estSession ? "sess:quota-avert" : "view:quota-avert";
-          if (await PLAYER.limits.allow(avert, 1, 3600)) PLAYER.errors.capture(new Error(`télémétrie externe abandonnée (${body.event}) : quota horaire atteint (${quotaTrack}/h par adresse)`), { route: "track", abandon: true });
+          if (await PLAYER.limits.allow(avert, 1, 3600)) capturerSansBloquer(PLAYER.errors, new Error(`télémétrie externe abandonnée (${body.event}) : quota horaire atteint (${quotaTrack}/h par adresse)`), { route: "track", abandon: true });
         } catch { /* jamais bloquant */ }
         repondreJson(res, 200, { ok: true });
         return;
@@ -565,7 +566,7 @@ async function traiter(req, res, body, slug) {
           // n'aurait rien vu : c'est ce qui rend la classe dangereuse, pas l'instance.
           try {
             if (await PLAYER.limits.allow("sess:echec", 1, 3600)) {
-              PLAYER.errors.capture(new Error(`écriture de mesure refusée : ${e && e.message ? e.message : "cause inconnue"} — la lecture n'est pas comptée`), { route: "track" });
+              capturerSansBloquer(PLAYER.errors, new Error(`écriture de mesure refusée : ${e && e.message ? e.message : "cause inconnue"} — la lecture n'est pas comptée`), { route: "track" });
             }
           } catch { /* un journal ne doit jamais empêcher une lecture */ }
         }

package/server/routes-visiteur.js

@@ -4,6 +4,7 @@
 // Reste à PLAT dans server/ (les gardes de forge ciblent server/*.js).
 
 const { adresseAppelant } = require("./appelant");
+const { capturerSansBloquer } = require("./capture");
 const { repondreJson } = require("./reponses.js");
 
 const { getShareBySlug } = require("./shares");
@@ -20,9 +21,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
@@ -52,7 +55,7 @@ function direLeRepli(pourquoi) {
   if (repliDit) return;
   repliDit = true;
   try {
-    PLAYER.errors.capture(new Error(`mur visiteur : ${pourquoi} — les compteurs par identité utilisent une EMPREINTE de l'email (SHA-256 tronqué), pseudonyme mais renversable par dictionnaire. Fournissez rateLimitKey (HMAC, secret côté hôte, séparation de domaine).`), { route: "visitor", benin: true });
+    capturerSansBloquer(PLAYER.errors, new Error(`mur visiteur : ${pourquoi} — les compteurs par identité utilisent une EMPREINTE de l'email (SHA-256 tronqué), pseudonyme mais renversable par dictionnaire. Fournissez rateLimitKey (HMAC, secret côté hôte, séparation de domaine).`), { route: "visitor", benin: true });
   } catch { /* jamais bloquant */ }
 }
 const init = (ctx) => { PLAYER = ctx; repliDit = false; };
@@ -93,7 +96,7 @@ async function traiter(req, res, body, _slug) {
       // noms. Une liste ne voit que ce qu'on y a mis ; une forme voit aussi le prochain.
       try {
         if (await PLAYER.limits.allow("unlock:echec", 1, 3600)) {
-          PLAYER.errors.capture(new Error(`déverrouillage visiteur non journalisé : ${e && e.message ? e.message : "cause inconnue"}`), { route: "visitor-unlock" });
+          capturerSansBloquer(PLAYER.errors, new Error(`déverrouillage visiteur non journalisé : ${e && e.message ? e.message : "cause inconnue"}`), { route: "visitor-unlock" });
         }
       } catch { /* un journal ne doit jamais empêcher une lecture */ }
     }

package/server/schema.js

@@ -52,6 +52,8 @@
 // — il balaie le dossier et refuse un nom qui déclencherait la garde, au moment où on l'écrit.
 // (La forme de la règle vient du STUDIO : une règle tenue par habitude a un taux de couverture que
 // personne ne mesure.)
+const { capturerSansBloquer } = require("./capture");
+
 const RACINE_MIGRATIONS = "supabase/migrations/";
 
 const ATTENDUES = {
@@ -460,7 +462,7 @@ const PORTEE_FUSION =
 // plus rien.
 async function journaliser(cle, message) {
   try {
-    if (await PLAYER.limits.allow(cle, 1, 3600)) PLAYER.errors.capture(new Error(message), { route: "schema" });
+    if (await PLAYER.limits.allow(cle, 1, 3600)) capturerSansBloquer(PLAYER.errors, new Error(message), { route: "schema" });
   } catch { /* jamais bloquant */ }
 }
 
@@ -529,7 +531,7 @@ async function ajouterMigrationsDePresence(etat) {
     // boucle, et un journal sans frein deviendrait une arme.
     try {
       if (await PLAYER.limits.allow("schema:durcissement-absent", 1, 3600)) {
-        PLAYER.errors.capture(new Error(
+        capturerSansBloquer(PLAYER.errors, new Error(
           absente
             ? "migration 0018-bootstrap-non-usurpable.sql ABSENTE : les bootstraps de présence ne "
               + "sont pas contrôlés. N'armez pas PLAYER_PRESENCE_STRICT avant de l'appliquer — il "

package/server/shares.js

@@ -3,6 +3,7 @@
 // GED commerciale : liens de partage tracés (un par destinataire) + agrégation des consultations.
 // Tables service-role only (cf. migration v12321) → tout passe par le service role ici.
 const crypto = require("crypto");
+const { capturerSansBloquer } = require("./capture");
 const { signatureAbsente } = require("./erreurs-base.js");
 // Tout ce qui vient de l'hôte passe par le contexte injecté — base, email, marque. C'est ce qui
 // permettra à ce fichier de partir dans le dépôt du player sans emporter le studio avec lui.
@@ -434,7 +435,7 @@ async function overviewEnBase(since) {
       lastAt: r.last_at || null,
     }])) || [];
   } catch (erreur) {
-    try { PLAYER.errors.capture(erreur, { route: "overview", indice: "consultations internes indisponibles — la vue d'ensemble ne montrera que les ouvertures client" }); } catch { /* jamais bloquant */ }
+    try { capturerSansBloquer(PLAYER.errors, erreur, { route: "overview", indice: "consultations internes indisponibles — la vue d'ensemble ne montrera que les ouvertures client" }); } catch { /* jamais bloquant */ }
   }
   return { byDoc: new Map(vues), intByDoc: new Map(internes) };
 }
@@ -935,7 +936,7 @@ async function upsertInternalSession(p, { ip: _ip, ua }) {
     try {
       if (await PLAYER.limits.allow("intsess:jetee", 1, 3600)) {
         const manque = !sessionId ? "sessionId" : "docId";
-        PLAYER.errors.capture(new Error(`session interne jetée : ${manque} absent — rien ne sera mesuré tant qu'il manque`), { route: "internal-session" });
+        capturerSansBloquer(PLAYER.errors, new Error(`session interne jetée : ${manque} absent — rien ne sera mesuré tant qu'il manque`), { route: "internal-session" });
       }
     } catch { /* un journal ne doit jamais empêcher une lecture */ }
     return;

package/types/context.d.ts

@@ -128,14 +128,20 @@ 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`. */
-  maxConcurrentRelays?: number;
+  /** Transferts de fichiers relayés simultanément par processus (défaut 64 ; entier de 1 à 1024,
+   *  sinon le défaut, dit une fois à `init`). Une chaîne — celle de l'environnement — est acceptée
+   *  telle quelle et bornée par le cœur, qui cite ce qu'il a reçu s'il la refuse. 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 ont fait monter la RSS de 63 à 193–257 Mio (une
+   *  croissance de 130 à 194) — 16 à 32 sur un processus à 256 Mio. */
+  maxConcurrentRelays?: number | string;
   /** 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. */
-  relayStallMs?: number;
-  /** Durée totale maximale d'un relais (défaut 900 000 ms). */
-  relayMaxMs?: number;
+   *  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 | string;
+  /** Durée totale maximale d'un relais (défaut 900 000 ms ; même plage que `relayStallMs`). */
+  relayMaxMs?: number | string;
   /** 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. */
   separateIssuer?: boolean;