discovery-media-player 0.1.151 → 0.1.152

package/docs/HOST-CONTRACT.md

@@ -487,7 +487,7 @@ above: an unheard-of action answered *no* narrows this view rather than breaking
 gains a `purge` block counting the rows that still carry a reader IP or a raw User-Agent:
 
     "purge": { "borne": 5000, "tronque": false, "lignes": { "sessions": 1908, "vues": 3200 },
-               "sessionsIp": 0, "sessionsUa": 0, "vuesUa": 0, "vide": true }
+               "sessionsIp": 0, "sessionsUa": 0, "vuesUa": 0, "vide": true, "voie": "bornee" }
 
 `vide` is the reading that matters: `true` means nothing of that legacy is left **on this
 instance's live rows** — the condition under which those columns can eventually be dropped —
@@ -545,6 +545,24 @@ portability rule refuses.
 column. Anything that is not a non-negative integer (a string, a float, `undefined`, `NaN`) is read
 as "no answer" and the player falls back rather than believing it.
 
+⚠️ **And `voie` tells you which route produced the numbers, because the numbers cannot.** `"exact"`,
+`"bornee"`, or `"mixte"` when both served the same read — which happens for real: a host mid-purge
+whose column is already dropped makes `count` throw on the filtered paths and answer on the same
+table's totals.
+
+This field exists because two hosts, independently and on the same day, found they could not verify
+their own seam. An exact count and an untruncated bounded count render an **identical** block —
+same numbers, same `tronque`, same `vide`. So a `db.count` that returns a string, or a float, falls
+back **silently** and the card looks exactly like a working one: you believe your seam is wired
+when it is not. One host caught it only by luck of volume — their table held 1655 rows, and the
+bounded route is structurally incapable of exceeding the 1000-row ceiling, so the number itself
+happened to be proof. Under a thousand rows there is no such luck, and the other host, whose
+volumes are small, could not tell at all.
+
+**Check `voie`, not a value.** A control that distinguishes two *mechanisms* must rest on something
+one can do and the other cannot; a value both could return proves nothing, and a value written down
+from yesterday's measurement rots without anyone touching anything.
+
 ⚠️ **The two alternatives were measured at a host, not assumed here** — recorded so nobody proposes
 them again in six months believing they were never tried. **`?select=count()` is dead**:
 `db-aggregates-enabled` is `false` by default, verified on two distinct Supabase projects, and the

package/package.json

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

@@ -477,8 +477,21 @@ const TABLES_RESTE = [["sessions", "commercial_doc_sessions", "session_id"],
  */
 const COLONNE_ABSENTE = "42703";
 
-/** `{ n, tronque }` — `n` nul veut dire indéterminé, jamais zéro. */
-const compte = (n, tronque) => ({ n, tronque });
+/**
+ * `{ n, tronque, voie }` — `n` nul veut dire indéterminé, jamais zéro.
+ *
+ * ⚠️ ET `voie` NOMME LE MÉCANISME QUI A PRODUIT LE NOMBRE, parce que le nombre seul ne le dit pas.
+ * Un compte exact et un compte borné NON tronqué rendent le même JSON : deux hôtes l'ont relevé le
+ * même jour, l'un en constatant qu'il ne pouvait pas vérifier sa propre couture, l'autre en
+ * écrivant un contrôle qui n'a marché que par chance de volume — sa table dépassait mille, donc la
+ * voie par lignes était structurellement incapable de rendre son chiffre. Sous mille, personne ne
+ * peut trancher, et un `db.count` qui rend une chaîne retombe SILENCIEUSEMENT sur la voie bornée :
+ * l'hôte croit sa couture branchée alors qu'elle ne sert pas.
+ */
+const compte = (n, tronque, voie) => ({ n, tronque, voie });
+
+const VOIE_EXACTE = "exact";
+const VOIE_BORNEE = "bornee";
 
 /**
  * ⚠️ « MOINS QUE DEMANDÉ » NE PROUVE PAS LA FIN — ET C'EST UN HÔTE RÉEL QUI L'A MONTRÉ.
@@ -577,23 +590,24 @@ async function compterBorne(chemin, cle) {
   // méthode par lignes, pas celle-ci. `tronque: false` garde donc le sens qu'il a partout —
   // « lisez ce nombre comme exact » — au lieu d'en prendre un second selon la voie employée.
   const exact = await compteExact(chemin);
-  if (exact !== null) return compte(exact, false);
+  if (exact !== null) return compte(exact, false, VOIE_EXACTE);
   try {
     // ⚠️ BORNE + 1 : la ligne excédentaire ne sert qu'à PROUVER qu'il en reste. On ne la publie pas.
     // ⚠️ 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: 8000 });
-    if (!Array.isArray(lignes)) return compte(null, false);
+    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);
+    if (lignes.length > BORNE_RESTE) return compte(BORNE_RESTE, true, VOIE_BORNEE);
     // Zéro ligne : la sonde au-delà rendrait zéro elle aussi et n'apprendrait rien — y compris sous
     // un plafond à zéro, que ni l'une ni l'autre ne distingue d'une table vide.
-    if (!lignes.length) return compte(0, false);
-    return compte(lignes.length, await resteApres(chemin, cle, lignes[lignes.length - 1][cle]));
+    if (!lignes.length) return compte(0, false, VOIE_BORNEE);
+    return compte(lignes.length, await resteApres(chemin, cle, lignes[lignes.length - 1][cle]),
+      VOIE_BORNEE);
   } catch (e) {
-    if (e && e.details && e.details.code === COLONNE_ABSENTE) return compte(0, false);
-    return compte(null, false);   // indéterminé — surtout pas zéro
+    if (e && e.details && e.details.code === COLONNE_ABSENTE) return compte(0, false, VOIE_BORNEE);
+    return compte(null, false, VOIE_BORNEE);   // indéterminé — surtout pas zéro
   }
 }
 
@@ -636,6 +650,18 @@ async function resteDeLaPurge() {
   // confiance aux autres, alors que la borne est commune et que la question ne l'est pas.
   out.tronque = [...comptes, ...totaux].some((c) => c.tronque);
   out.lignes = parTable;
+  // ⚠️ UNE SEULE RÉPONSE POUR LES CINQ COMPTES, ET TROIS ÉTATS PLUTÔT QUE DEUX. La question qu'un
+  // hôte se pose est « ma couture sert-elle ? », pas « laquelle des cinq ». `"mixte"` n'est pas une
+  // commodité : il arrive vraiment — un `count` qui lève sur le chemin d'une colonne supprimée et
+  // répond sur le total de la même table — et c'est précisément le cas qu'un drapeau binaire
+  // aurait dû arrondir dans un sens ou dans l'autre, donc mentir.
+  //
+  // ⚠️ CE CHAMP NE DIT RIEN SUR LA JUSTESSE DES NOMBRES, seulement sur leur provenance. Il ne
+  // double aucun autre : `tronque` vaut `false` sur les DEUX voies, c'est même toute la raison
+  // d'être de cette ligne.
+  const voies = [...comptes, ...totaux].map((c) => c.voie);
+  out.voie = voies.every((v) => v === VOIE_EXACTE) ? VOIE_EXACTE
+    : voies.every((v) => v === VOIE_BORNEE) ? VOIE_BORNEE : "mixte";
   SONDES_RESTE.forEach(([nom], i) => { out[nom] = comptes[i].n; });
   // ⚠️ TROIS ÉTATS, PAS DEUX. `true` : plus rien, le retrait des colonnes est permis ICI. `false` :
   // il reste des lignes. `null` : au moins une sonde n'a pas répondu — on ne sait pas, et « on ne