discovery-media-player 0.1.154 → 0.1.155

package/docs/HOST-CONTRACT.md

@@ -894,15 +894,22 @@ but *did you measure exactly what fails*. Two true statements about the same ins
 different responses.
 
 **⚠️ The ceiling on your requests is set by the role that OPENS the connection, not the one they run
-as.** A host measured this and it is invisible from our side. Their `authenticator` role carries a
-`statement_timeout`; PostgREST's `SET ROLE` does **not** reset it, so code running as `service_role`
-inherits it — while `service_role` itself shows no setting at all, so nothing our code can read
-suggests a limit exists. At that host every request we issue is capped at 8 seconds, and a lock
-waited on for longer than that fails. Your paginated `selectAll`, a batched retention sweep, a
+as.** Two hosts measured this independently, and it is invisible from our side. Their `authenticator`
+role carries a `statement_timeout`; PostgREST's `SET ROLE` does **not** reset it, so code running as
+`service_role` inherits it — while `service_role` itself shows no setting at all, so nothing our code
+can read suggests a limit exists. Both measured **8 seconds** on `authenticator` and on
+`authenticated`, and **3 seconds** on `anon`: this is the platform default on Supabase, not a
+peculiarity of one installation, so assume you have it until you have looked. Every request we issue
+is capped at that value, and a lock waited on for longer than it fails. Your paginated `selectAll`, a batched retention sweep, a
 `count` on a large table: each is one statement, so each gets the whole budget and no more,
 whatever the batch size.
 
-Our own client abort no longer sits at that same value, deliberately. Two timers set to the same
+Our own client abort no longer sits at that same value, deliberately, and it is no longer a
+constant: `config.retention.delaiLectureMs` (1 000–120 000 ms, default 12 000) lets a host who knows
+their ceiling say so. A host put the reason better than we had seen it — *a constant chosen against
+a known case carries the date of that case; the day a host announces 15 s, it is not the timer that
+needs adjusting, it is the fact that it is a constant.* An invalid value falls back to the default
+rather than refusing: a wrong retention window deletes rows, a wrong timeout at worst waits. Two timers set to the same
 number do not produce a wrong answer here — both routes fall back to `null`, and a bench proves it —
 but they make the *cause* undecidable: when our abort wins the race, the server's `57014` never
 reaches us and "too slow" becomes indistinguishable from "the network died".
@@ -967,6 +974,23 @@ unaudited, said so plainly, and that sentence is the only reason we know those r
 cannot measure your code. We can only know what someone wrote down. *"Not measured"* and *"nothing
 found"* are different sentences, and only one of them is honest when you have not looked.
 
+⚠️ **Say which of the two kinds it is: *not measured yet*, or *not measurable here*.** A host asked
+for this distinction in as many words, and they were right that a contract which conflates them
+waits forever for an answer that will never come. *Not measured yet* is a debt: someone will pay it.
+*Not measurable here* is a structural property of that installation — no measurement available to
+them can produce the phenomenon at all.
+
+Their own case is the clean one. `db-max-rows` caps a response at 1000 rows; their largest table
+holds 356, and the largest one readable by `anon` on their application database holds 836. Those are
+usage volumes, not configuration — they cannot make them bigger to see the ceiling, and the only way
+to reach it would be to widen production grants for a diagnosis, which they will not do and should
+not. So that ceiling will never be observed there. **The other host's 1651 rows published as 1000 is
+the only proof of it anyone will produce, and that is final** — which is also why we record where a
+measurement came from rather than only what it said.
+
+The two kinds want opposite things from us: a debt should be chased, a structural limit should be
+written down and stopped being asked about.
+
 **What not to send.** Shapes and counts, never contents. No row data, no reader IPs or User-Agents —
 those are the columns half this contract exists to get rid of — no keys, tokens, connection strings,
 or private hostnames. *"A table of ~1600 rows returned 1000"* is the whole of what we needed to fix

package/package.json

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

@@ -455,15 +455,34 @@ function tick() {
 // pas une opinion sur ce qu'un hôte peut avoir.
 const BORNE_RESTE = 5000;
 
-// ⚠️ DOUZE SECONDES, ET LE NOMBRE VIENT D'ÉVITER UNE ÉGALITÉ, PAS D'UN GOÛT. Il valait 8000 — très
-// exactement le `statement_timeout` qu'un hôte a mesuré sur son rôle `authenticator`. Deux minuteries
-// réglées sur la même valeur ne rendent pas un résultat faux ici (les deux voies retombent sur
-// `null`, un banc l'éprouve), mais elles rendent la CAUSE indécidable : quand notre abandon gagne la
-// course, le `57014` du serveur ne nous parvient jamais, et « la requête était trop lente » devient
-// indistinguable de « le réseau est tombé ». Un plafond client strictement AU-DESSUS des plafonds
-// serveur courants laisse le serveur expliquer son refus. C'est la règle de la marge sur le SUJET,
-// appliquée à du code de production plutôt qu'à un banc.
+// ⚠️ DOUZE SECONDES PAR DÉFAUT, ET LE NOMBRE VIENT D'ÉVITER UNE ÉGALITÉ, PAS D'UN GOÛT. Il valait
+// 8000 — très exactement le `statement_timeout` que DEUX hôtes ont mesuré sur leur rôle
+// `authenticator`, où il est le réglage par défaut de la plateforme et non une particularité. Deux
+// minuteries réglées sur la même valeur ne rendent pas un résultat faux ici (les deux voies
+// retombent sur `null`, un banc l'éprouve), mais elles rendent la CAUSE indécidable : quand notre
+// abandon gagne la course, le `57014` du serveur ne nous parvient jamais, et « la requête était trop
+// lente » devient indistinguable de « le réseau est tombé ».
+//
+// ⚠️ ET C'EST RÉGLABLE PARCE QU'UNE CONSTANTE CHOISIE CONTRE UN CAS CONNU PORTE LA DATE DE CE CAS.
+// Un hôte l'a formulé mieux que nous ne l'avions vu : « le jour où un hôte annonce 15 s, ce n'est pas
+// votre minuterie qu'il faudra ajuster — c'est le fait qu'elle soit une constante ». Corriger le
+// nombre aurait reproduit le défaut avec une mèche plus longue, exactement comme corriger un nombre
+// nu dans de la prose en produit un autre. `config.retention.delaiLectureMs` laisse l'hôte qui
+// CONNAÎT son plafond le dire ; son absence rend le comportement d'aujourd'hui, à l'octet près.
 const DELAI_LECTURE = 12000;
+const DELAI_MIN = 1000, DELAI_MAX = 120000;
+
+/**
+ * ⚠️ UNE VALEUR INVALIDE RETOMBE SUR LE DÉFAUT — elle ne lève PAS, à la différence des fenêtres de
+ * rétention juste au-dessus, et la différence est de conséquence : une fenêtre fausse SUPPRIME des
+ * lignes, un délai faux fait au pire attendre. Refuser de rendre la carte parce qu'un délai est mal
+ * tapé punirait le lecteur pour un réglage sans danger.
+ */
+function delaiLecture() {
+  const r = PLAYER.config && PLAYER.config.retention;
+  const v = r && Number(r.delaiLectureMs);
+  return Number.isFinite(v) && v >= DELAI_MIN && v <= DELAI_MAX ? Math.trunc(v) : DELAI_LECTURE;
+}
 
 const SONDES_RESTE = [
   ["sessionsIp", "commercial_doc_sessions", "session_id", "ip"],
@@ -553,7 +572,7 @@ async function resteApres(chemin, cle, dernier) {
   if (dernier == null) return true;
   try {
     const suite = await PLAYER.db.request(
-      `${chemin}&${cle}=gt.${enc(String(dernier))}&order=${cle}.asc&limit=1`, { timeoutMs: DELAI_LECTURE });
+      `${chemin}&${cle}=gt.${enc(String(dernier))}&order=${cle}.asc&limit=1`, { timeoutMs: delaiLecture() });
     // Pas de réponse analysable ⇒ on ne sait pas ⇒ « au moins ». Se tromper vers le minorant ne
     // fait que sous-estimer ; se tromper vers l'exactitude fait conclure.
     return !Array.isArray(suite) || suite.length > 0;
@@ -606,7 +625,7 @@ async function compterBorne(chemin, cle) {
     // ⚠️ ET L'ORDRE N'EST PAS DÉCORATIF : sans lui, « la dernière ligne reçue » ne désigne aucune
     // frontière, et le curseur de la sonde ne voudrait rien dire.
     const lignes = await PLAYER.db.request(
-      `${chemin}&order=${cle}.asc&limit=${BORNE_RESTE + 1}`, { timeoutMs: DELAI_LECTURE });
+      `${chemin}&order=${cle}.asc&limit=${BORNE_RESTE + 1}`, { timeoutMs: delaiLecture() });
     if (!Array.isArray(lignes)) return compte(null, false, VOIE_BORNEE);
     // Notre propre borne atteinte : la preuve est dans la ligne excédentaire, rien à demander.
     if (lignes.length > BORNE_RESTE) return compte(BORNE_RESTE, true, VOIE_BORNEE);