discovery-media-player 0.1.79 → 0.1.81

package/docs/HOST-CONTRACT.md

@@ -35,6 +35,7 @@ need.
   "frameAncestors": ["'self'", "https://*.vercel.app", "https://app.example.com"],
   "separateIssuer": true,
   "internalStrict": true,
+  "retentionSweep": false,
   "hostShare": true,
   "hostMail": true,
   "plugins": { "bot": false, "visitors": false, "brandIntro": false, "botBrowser": false, "providerQuotas": false },
@@ -95,6 +96,12 @@ exactly the monitoring case where "no data" would otherwise read as "all clear".
 ⚠️ **`incomplet` wins over `partiel`**: a missing column is a positive fact and settles the verdict
 on its own, even when the rest has not been checked.
 
+⚠️ **`retentionSweep`** says whether the automatic retention purge is *armed*
+(`config.retention.balayage === true`). The `retention` capability only says the instance *can*
+purge; this boolean says whether it *does*, on its own, once a day. Default `false` — nothing is
+deleted unless an operator wrote the policy. A cockpit can read this to know if an instance is
+subject to automatic deletion, instead of inferring it from a log.
+
 ⚠️ **`internalStrict: false` means internal identity comes from the browser.** In transitional
 mode the internal-analytics route accepts `docId`, `email` and `name` as the client declares them —
 a caller can fabricate "this colleague read this document". Strict mode (`PLAYER_INTERNAL_STRICT=1`)

package/docs/RETENTION.md

@@ -115,6 +115,13 @@ Parcours guidé par l'agent : **purge 13 mois** après `last_at`.
   contexte hôte fournit `storage.remove` (capacité optionnelle). Sans elle, l'URL devient
   introuvable depuis le produit mais l'objet survit dans le bucket — c'est dit ici plutôt que
   simulé.
+- **Le plafond des présentations est GLOBAL** : messages et présences partagent chacun un budget
+  `plafond` réparti sur toutes les présentations d'une exécution — pas un plafond par présentation
+  (sinon 500 × 5000 = 2,5 M de lignes possibles). La boucle s'arrête quand les budgets sont
+  épuisés, sans supprimer les présentations restantes.
+- **Le rapport dryRun est complet pour les présentations** : `messagesExaminees`,
+  `presencesExaminees` et `fichiersCandidats` disent ce que la VRAIE purge ferait — même parcours
+  de sélection, suppression no-op, `efface.* = 0`.
 - **La purge avance par LOTS bornés** (200 lignes, plafond 5000 par table et 500 présentations
   par exécution) : elle sélectionne un lot d'identifiants, les supprime par `id=in.(…)`, et
   recommence. Le rapport (`r.rapport`) porte, par table : `examinees`, `supprimees`, `tronque`

package/package.json

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

@@ -595,6 +595,12 @@ async function handler(req, res) {
         // MESURABLE : un cockpit peut refuser une instance non stricte, au lieu de le découvrir en
         // lisant un journal. Demandé par le second hôte (cinquième audit, P1-4).
         internalStrict: !!(PLAYER.config && PLAYER.config.internalStrict),
+        // ⚠️ LE BALAYAGE DE RÉTENTION EST-IL ARMÉ ? La capacité `retention` dit que l'instance PEUT
+        // purger ; ce booléen dit si le balayage automatique TOURNE (`config.retention.balayage`).
+        // Sans lui, une instance armée est indiscernable d'une instance éteinte — et une purge qui
+        // supprime se compose mal avec l'ignorance de savoir si l'on est concerné (signalé par le
+        // second hôte). Défaut false, comme la décision par défaut : rien ne s'efface tout seul.
+        retentionSweep: !!(PLAYER.config && PLAYER.config.retention && PLAYER.config.retention.balayage === true),
         // ⚠️ L'ÉTAT DU SCHÉMA, LÀ OÙ ON REGARDE. Une colonne absente était signalée par un
         // `console.warn`, une fois par processus : sur une fonction serverless, une ligne perdue
         // dans une sortie que personne n'ouvre tant que tout a l'air de marcher — et « tout a

package/server/retention.js

@@ -88,7 +88,29 @@ function optionsValidees(opts) {
 // Une valeur pour `id=in.(…)` : double-guillemets, guillemet et antislash internes échappés —
 // PostgREST exige le guillemetage dès qu'une valeur porte un caractère réservé (`:` d'une clé de
 // débit, par exemple). Guillemeter TOUJOURS est correct et évite d'avoir à deviner.
-const guill = (v) => '"' + String(v).replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+// ⚠️ DOUBLE encodage nécessaire (trouvé par le banc volumétrique, audit 10) : le guillemetage
+// gère les délimiteurs de PostgREST (virgule, parenthèse) ; l'encodage d'URL gère ceux de l'URL
+// (`&`, `#`, `+`, espace…) — un `&` non encodé dans une valeur coupe le filtre `in.(…)` en deux.
+// PostgREST décode le percent-encoding avant de parser, donc `%22…%26…%22` redevient `"…&…"`.
+const guill = (v) => encodeURIComponent('"' + String(v).replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"');
+
+// ⚠️ LES DEUX SEULES PORTES DE DESTRUCTION DU MODULE — dryRun court-circuité en PREMIÈRE ligne.
+// « Honoré » ne se prouve pas en lisant chaque DELETE (une fenêtre de lecture décide de la réponse
+// — le piège du périmètre), mais en n'ayant QU'UNE porte, gardée ici, et une garde de forme qui
+// exige qu'il n'y en ait qu'une (server/__tests__/retentionUnePorte.test.js). Un troisième chemin
+// d'écriture DEVRA passer par ces portes, ou il rougira le compte. C'est « retirer la seconde
+// source de vérité » appliqué à la suppression : un seul endroit peut détruire.
+async function effacerParIds(table, colId, ids, opts) {
+  if (opts.dryRun || !ids || !ids.length) return 0;
+  const del = await PLAYER.db.request(`${table}?${colId}=in.(${ids.map(guill).join(",")})&select=${colId}`, { method: "DELETE", headers: { Prefer: "return=representation" } });
+  return Array.isArray(del) ? del.length : 0;   // lignes RENDUES, pas ids présélectionnés
+}
+async function retirerFichier(chemin, opts) {
+  if (opts.dryRun || !chemin) return null;   // null = rien tenté ; true = retiré ; false = échec
+  const retirer = PLAYER.storage && typeof PLAYER.storage.remove === "function" ? PLAYER.storage.remove.bind(PLAYER.storage) : null;
+  if (!retirer) return null;
+  try { return !!(await retirer("present-attachments", chemin)); } catch { return false; }
+}
 
 // ⚠️ PURGE PAR LOTS BORNÉS (P2 huitième audit). On SÉLECTIONNE un lot d'identifiants (borné,
 // ordonné par la colonne de date), on les supprime par `id=in.(…)`, on recommence — jamais un
@@ -102,7 +124,8 @@ const guill = (v) => '"' + String(v).replace(/\\/g, "\\\\").replace(/"/g, '\\"')
 // au RESTE du plafond (`min(taille, plafond - examinees)`) pour ne jamais le dépasser. Et on
 // compte les lignes RENDUES par le DELETE (`return=representation&select=id`), pas les ids
 // présélectionnés : deux exécutions concurrentes n'annoncent pas deux fois la même suppression.
-async function purgerParLots(table, filtre, colId, { dryRun = false, taille = LOT, plafond = PLAFOND } = {}) {
+async function purgerParLots(table, filtre, colId, { dryRun = false, taille = LOT, plafond = PLAFOND } = {}, plafondForce) {
+  if (plafondForce !== undefined) plafond = plafondForce;
   let examinees = 0, supprimees = 0, tronque = false, curseur = null;
   for (;;) {
     const reste = plafond - examinees;
@@ -113,13 +136,7 @@ async function purgerParLots(table, filtre, colId, { dryRun = false, taille = LO
     if (!Array.isArray(lot) || !lot.length) break;
     examinees += lot.length;
     curseur = lot[lot.length - 1][colId];
-    if (!dryRun) {
-      const ids = lot.map((r) => r[colId]).filter((v) => v != null).map(guill);
-      if (ids.length) {
-        const del = await PLAYER.db.request(`${table}?${colId}=in.(${ids.join(",")})&select=${colId}`, { method: "DELETE", headers: { Prefer: "return=representation" } });
-        supprimees += Array.isArray(del) ? del.length : 0;
-      }
-    }
+    supprimees += await effacerParIds(table, colId, lot.map((r) => r[colId]).filter((v) => v != null), { dryRun });
     if (lot.length < limite) break;   // dernier lot (moins que demandé → plus rien après)
   }
   return { examinees, supprimees, tronque };
@@ -142,9 +159,9 @@ const { cheminPieceJointe: cheminSurSlug } = require("./presentations");
 // 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`
 // pour que l'appelant décide de garder ou non la présentation. Compte les lignes RENDUES.
-async function purgerMessagesPresentation(slug, opts, retirer, base) {
-  const { dryRun, taille, plafond } = opts;
-  let supprimees = 0, fichiers = 0, fichiersErreur = 0, examinees = 0, tronque = false, curseur = null;
+async function purgerMessagesPresentation(slug, opts, base, plafond) {
+  const { dryRun, taille } = opts;
+  let supprimees = 0, fichiers = 0, fichiersErreur = 0, fichiersCandidats = 0, examinees = 0, tronque = false, curseur = null;
   for (;;) {
     const reste = plafond - examinees;
     if (reste <= 0) { tronque = await resteEncore("doc_presentation_messages", `slug=eq.${enc(slug)}`, "id", curseur, dryRun); break; }
@@ -154,25 +171,17 @@ async function purgerMessagesPresentation(slug, opts, retirer, base) {
     if (!Array.isArray(lot) || !lot.length) break;
     examinees += lot.length;
     curseur = lot[lot.length - 1].id;
-    if (!dryRun) {
-      if (retirer) {
-        for (const j of lot) {
-          const url = j.attachment && (typeof j.attachment === "object" ? j.attachment.url : j.attachment);
-          const chemin = cheminSurSlug(url, slug, base);
-          if (!chemin) continue;   // hors du dossier du slug → jamais supprimé (barrière 2)
-          try { if (await retirer("present-attachments", chemin)) fichiers += 1; else fichiersErreur += 1; }   // false = échec compté aussi
-          catch { fichiersErreur += 1; }
-        }
-      }
-      const ids = lot.map((r) => r.id).filter((v) => v != null).map(guill);
-      if (ids.length) {
-        const del = await PLAYER.db.request(`doc_presentation_messages?id=in.(${ids.join(",")})&select=id`, { method: "DELETE", headers: { Prefer: "return=representation" } });
-        supprimees += Array.isArray(del) ? del.length : 0;
-      }
+    for (const j of lot) {
+      const url = j.attachment && (typeof j.attachment === "object" ? j.attachment.url : j.attachment);
+      const chemin = cheminSurSlug(url, slug, base);   // hors du dossier du slug → null → jamais retiré (barrière 2)
+      if (chemin) fichiersCandidats += 1;              // compté même en dry-run (ce que la vraie purge tenterait)
+      const issue = await retirerFichier(chemin, { dryRun });
+      if (issue === true) fichiers += 1; else if (issue === false) fichiersErreur += 1;   // false = échec compté
     }
+    supprimees += await effacerParIds("doc_presentation_messages", "id", lot.map((r) => r.id).filter((v) => v != null), { dryRun });
     if (lot.length < limite) break;
   }
-  return { supprimees, fichiers, fichiersErreur, examinees, tronque };
+  return { supprimees, fichiers, fichiersErreur, fichiersCandidats, examinees, tronque };
 }
 
 async function purgerRetention(now, optsBrutes = {}) {
@@ -203,23 +212,32 @@ async function purgerRetention(now, optsBrutes = {}) {
   // ses présences — et les fichiers du bucket si storage.remove est fourni (OPTIONNELLE).
   const bPres = borne(now, f.presentationsMois);
   const mortes = await PLAYER.db.request(`doc_presentations?active=eq.false&updated_at=lt.${enc(bPres)}&select=slug&order=slug.asc&limit=${PLAFOND_PRESENTATIONS}`);
-  const presRapport = { examinees: 0, supprimees: 0, messages: 0, presences: 0, fichiers: 0, fichiersErreur: 0, tronque: Array.isArray(mortes) && mortes.length >= PLAFOND_PRESENTATIONS };
-  const retirer = PLAYER.storage && typeof PLAYER.storage.remove === "function" ? PLAYER.storage.remove.bind(PLAYER.storage) : null;
+  // ⚠️ BUDGET GLOBAL AUX PRÉSENTATIONS (P2 dixième audit). Le plafond n'était appliqué qu'À CHAQUE
+  // présentation : 500 présentations × 5 000 = 2,5 M de messages en une exécution, timeout et
+  // contention avec le chat. Deux budgets partagés — messages et présences — décrémentés au fil
+  // des présentations ; la boucle s'arrête quand ils sont épuisés (tronque), sans supprimer les
+  // parents restants. En dry-run, on parcourt quand même pour REMONTER ce que la vraie purge
+  // ferait (examinés), sans jamais détruire.
+  const presRapport = { examinees: 0, supprimees: 0, messages: 0, presences: 0, messagesExaminees: 0, presencesExaminees: 0, fichiers: 0, fichiersErreur: 0, fichiersCandidats: 0, tronque: Array.isArray(mortes) && mortes.length >= PLAFOND_PRESENTATIONS };
+  let budgetMessages = opts.plafond, budgetPresences = opts.plafond;
   for (const p of (Array.isArray(mortes) ? mortes : [])) {
     const slug = p && p.slug; if (!slug) continue;
+    if (budgetMessages <= 0 && budgetPresences <= 0) { presRapport.tronque = true; break; }   // budgets épuisés
     presRapport.examinees += 1;
-    // Messages : lot borné qui lit id ET attachment ENSEMBLE (la lecture des pièces jointes n'est
-    // plus une requête globale non bornée — P2), retire les fichiers du lot, puis supprime le lot.
-    const msgs = await purgerMessagesPresentation(slug, opts, retirer, base);
+    const msgs = await purgerMessagesPresentation(slug, opts, base, budgetMessages);
     presRapport.messages += msgs.supprimees;
+    presRapport.messagesExaminees += msgs.examinees;
     presRapport.fichiers += msgs.fichiers;
     presRapport.fichiersErreur += msgs.fichiersErreur;
-    const pres = opts.dryRun ? { supprimees: 0, tronque: false } : await purgerParLots("doc_presentation_attendees", `slug=eq.${enc(slug)}`, "attendee_key", opts);
+    presRapport.fichiersCandidats += msgs.fichiersCandidats;
+    budgetMessages -= opts.dryRun ? msgs.examinees : msgs.supprimees;
+    // Présences : interrogées AUSSI en dry-run (pour remonter presencesExaminees), suppression
+    // no-op via effacerParIds. Budget global partagé.
+    const pres = await purgerParLots("doc_presentation_attendees", `slug=eq.${enc(slug)}`, "attendee_key", opts, Math.max(0, budgetPresences));
     presRapport.presences += pres.supprimees;
-    // ⚠️ LA PRÉSENTATION N'EST SUPPRIMÉE QUE SI TOUS SES ENFANTS SONT PARTIS (P2 neuvième audit) :
-    // sinon 5 000 messages partent, le parent aussi, et 1 000 orphelins restent que le balayage
-    // suivant ne peut plus rattacher à leur présentation. Tronqués → on garde le parent inactif
-    // pour le passage suivant.
+    presRapport.presencesExaminees += pres.examinees;
+    budgetPresences -= opts.dryRun ? pres.examinees : pres.supprimees;
+    // La présentation n'est supprimée que si TOUS ses enfants sont partis (9e audit).
     if (!opts.dryRun && !msgs.tronque && !pres.tronque) {
       presRapport.supprimees += (await purgerParLots("doc_presentations", `slug=eq.${enc(slug)}`, "slug", opts)).supprimees;
     }