discovery-media-player 0.1.166 → 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;
       },
@@ -847,11 +861,15 @@ function createStandaloneContext(env = process.env) {
       // 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,
+      // ⚠️ 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: 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,
+      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

@@ -185,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
@@ -238,6 +238,36 @@ 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.

package/package.json

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

@@ -29,7 +29,11 @@ const RELAIS_MS_MIN = 1, RELAIS_MS_MAX = 86_400_000;
 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 ».
+  // `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 };

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");
@@ -54,7 +55,7 @@ function init(ctx) {
   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 */ }
+    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);
@@ -106,7 +107,7 @@ async function relayerSousAdmission(res, travail) {
     // 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");
@@ -310,7 +311,7 @@ async function relayerFichier(res, r, disposition, bornes = { stallMs: relaisSta
   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.
@@ -387,7 +388,7 @@ async function relayerFichier(res, r, disposition, bornes = { stallMs: relaisSta
     // 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);
@@ -1219,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" },
         );

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");
@@ -54,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; };
@@ -95,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

@@ -129,17 +129,19 @@ export interface Reglages {
   mapsKey: string;
   extraFrameAncestors: string[];
   /** 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;
+   *  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 ; 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;
+  relayStallMs?: number | string;
   /** Durée totale maximale d'un relais (défaut 900 000 ms ; même plage que `relayStallMs`). */
-  relayMaxMs?: number;
+  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;