discovery-media-player 0.1.77 → 0.1.79

package/context/standalone.js

@@ -274,8 +274,16 @@ function createStandaloneContext(env = process.env) {
         const base = sansBarreFinale(env.SUPABASE_URL);
         const cle = String(env.SUPABASE_SERVICE_ROLE_KEY || "");
         if (!base || !cle || !bucket || !chemin) return false;
+        // ⚠️ DERNIÈRE BARRIÈRE avant un DELETE à la clé service_role (P1 huitième audit). Bucket en
+        // liste blanche, et refus de toute traversée — chaque segment sur l'alphabet des chemins
+        // signés. `fetch` normalise `..` : un chemin non validé sortirait du bucket visé.
+        if (bucket !== "present-attachments") return false;
+        const segs = String(chemin).split("/");
+        for (const seg of segs) {
+          if (seg === "" || seg === "." || seg === ".." || !/^[A-Za-z0-9._-]+$/.test(seg)) return false;
+        }
         try {
-          const r = await fetch(`${base}/storage/v1/object/${bucket}/${chemin}`, {
+          const r = await fetch(`${base}/storage/v1/object/${encodeURIComponent(bucket)}/${segs.map(encodeURIComponent).join("/")}`, {
             method: "DELETE", headers: { apikey: cle, Authorization: `Bearer ${cle}` },
           });
           return r.ok;

package/docs/HOST-CONTRACT.md

@@ -31,7 +31,7 @@ need.
   "product": "discovery-media-player",
   "contract": 1,
   "version": "<the running version>",
-  "capabilities": ["docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth", "host-share", "host-mail"],
+  "capabilities": ["docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth", "host-share", "host-mail", "retention"],
   "frameAncestors": ["'self'", "https://*.vercel.app", "https://app.example.com"],
   "separateIssuer": true,
   "internalStrict": true,

package/docs/RETENTION.md

@@ -15,7 +15,11 @@ ni fonction de périmètre, ni filtre) :
 
 > ⚠️ **Fenêtres proposées, à valider par l'exploitant.** Les durées ci-dessous sont des défauts
 > raisonnés (journaux analytiques : 13 mois, comparaison année sur année ; archives de
-> présentation : 12 mois après la fin). Un hôte les ajuste via `config.retention`.
+> présentation : 12 mois après la fin). Un hôte les ajuste via `config.retention` — **entiers de
+> mois dans [1, 120] uniquement**. Toute valeur négative, nulle, non entière, `NaN`, `Infinity`
+> ou chaîne fait ÉCHOUER la purge avant le premier `DELETE`, en nommant la clé fautive : une
+> faute de configuration ne supprime jamais rien. Les bornes sont calculées en UTC, rabattues au
+> dernier jour du mois cible (« 31 mars − 1 mois » = 28 février, pas le 3 mars).
 >
 > ⚠️ **Le balayage automatique est OPT-IN STRICT** : il ne tourne que si l'hôte écrit
 > `config.retention.balayage: true`. Un hôte qui consomme le contexte autonome tel quel hérite de
@@ -111,6 +115,16 @@ 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é.
+- **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`
+  (il reste à faire au prochain passage). `retention.run` accepte `{ dryRun: true }` : elle
+  compte sans rien effacer — à lancer avant la première vraie purge d'un gros historique.
+- **Index** (migration 0014) : `commercial_doc_sessions(last_at)`, `doc_bot_sessions(last_at)`,
+  `commercial_doc_shares(revoked_at) where revoked`. Sur une installation VOLUMINEUSE déjà en
+  production, créez-les à la main en `CREATE INDEX CONCURRENTLY` hors migration (la migration les
+  pose en index ordinaire, ce qui verrouille brièvement l'écriture — négligeable sur une base
+  jeune, à éviter sur une grosse table active).
 - **Le recensement ne tourne pas tout seul en production** : c'est un SQL qu'un exploitant lance
   (et que la forge exécute à chaque course sur une base réelle vieillie artificiellement).
 - **« Ce qui existe » a une profondeur temporelle qu'`information_schema` n'a pas** (question du

package/package.json

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

@@ -329,7 +329,7 @@ var Live=(function(){
   function setReply(id){var m=msgData[id];if(!m||m.deleted)return;var nm=m.author_name||'Invité';replyCtx={id:+id,name:nm,text:(m.body||'').slice(0,120)};var el=document.getElementById('chatReply');if(el){el.style.display='flex';el.innerHTML='<span class=cq><b>'+esc(nm)+'</b> '+esc((m.body||'').slice(0,80))+'</span><button id=chatReplyX title=Annuler>×</button>';var x=document.getElementById('chatReplyX');if(x)x.addEventListener('click',clearReply);}var t=document.getElementById('chatText');if(t)t.focus();}
   function clearReply(){replyCtx=null;var el=document.getElementById('chatReply');if(el){el.style.display='none';el.innerHTML='';}}
   function send(){var i=document.getElementById('chatText');var t=(i.value||'').trim();if(!t||!ME)return;if(LOCKED&&!canMod())return;i.value='';toggleSend();
-    
+
     // ⚠️ LA CLÉ EST FABRIQUÉE ICI, UNE FOIS, AVANT LE PREMIER ENVOI. Une clé tirée à chaque
     // tentative ne servirait à rien : deux envois porteraient deux clés et passeraient tous les
     // deux. C'est sa RÉUTILISATION au renvoi qui rend l'opération idempotente.

package/server/handler.js

@@ -576,7 +576,7 @@ async function handler(req, res) {
         // muette sur les URL.
         capabilities: [
           "docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth",
-          "host-share", "host-mail",
+          "host-share", "host-mail", "retention",
         ],
         // ⚠️ POUR QUELLES ORIGINES cette instance accepte d'être encadrée. Un booléen ne
         // suffisait pas : un hôte a besoin de voir que SON domaine manque, pas seulement que

package/server/presentations.js

@@ -310,6 +310,33 @@ async function endPresentation(slug, control) {
 // Pièce jointe : URL d'upload SIGNÉE (service role) → le client PUT directement dans le bucket. Type/taille
 // validés par le bucket (image/*+pdf, ≤10 Mo). L'URL publique finale est renvoyée pour attacher au message.
 const ATT_KINDS = { "image/png": "image", "image/jpeg": "image", "image/webp": "image", "image/gif": "image", "application/pdf": "pdf" };
+const BUCKET_PIECES = "present-attachments";
+
+// ⚠️ LE CHEMIN CANONIQUE D'UNE PIÈCE JOINTE — UNE SEULE FONCTION POUR L'ÉCRITURE ET LA
+// SUPPRESSION (P1 du huitième audit). Rend le chemin RELATIF au bucket (« <slug>/fichier ») si,
+// et seulement si, l'URL publique désigne EXACTEMENT le dossier du slug courant, sans traversée.
+// Refuse tout le reste — `null`. La barrière est la même des deux côtés : un `startsWith` laissait
+// passer `…/present-attachments/../autre-bucket/x`, inerte tant que l'URL n'était que lue, devenu
+// une primitive de suppression avec la rétention.
+//
+// Refusés : `.`/`..` en segment, leurs formes encodées (%2e), les slash/antislash encodés
+// (%2f/%5c), l'antislash brut, l'octet nul — et tout premier segment différent du slug.
+function cheminPieceJointe(url, slug, base) {
+  const prefixe = `${String(base || "")}/storage/v1/object/public/${BUCKET_PIECES}/`;
+  const brut = String(url || "");
+  if (!brut.startsWith(prefixe)) return null;
+  const chemin = brut.slice(prefixe.length).split("?")[0];
+  if (/%2e|%2f|%5c|\\|\0/i.test(chemin)) return null;          // formes encodées + antislash + nul
+  if (chemin.includes("\u0000")) return null;
+  const segments = chemin.split("/");
+  if (segments.length < 2) return null;                          // il faut « <slug>/<fichier> »
+  if (segments[0] !== String(slug)) return null;                 // premier segment = slug courant
+  for (const seg of segments) {
+    if (seg === "" || seg === "." || seg === "..") return null;  // pas de segment vide ni de point
+    if (!/^[A-Za-z0-9._-]+$/.test(seg)) return null;             // même alphabet que createUploadUrl
+  }
+  return chemin;
+}
 /**
  * UNE PRÉSENTATION TERMINÉE DEVIENT UNE ARCHIVE : on la relit, on ne l'écrit plus.
  *
@@ -484,8 +511,19 @@ async function addMessage(slug, { name, email, avatar, isPresenter, isMember, bo
   // et c'est comme ça que `.replace(/\/+$/, "")` s'est retrouvé à cinq exemplaires dans ce dépôt.
   const base = String((PLAYER.config && PLAYER.config.supabaseUrl) || "");
   let att = null;
-  if (attachment && typeof attachment === "object" && attachment.url && String(attachment.url).startsWith(base + "/storage/v1/object/public/present-attachments/")) {
-    att = { url: String(attachment.url).slice(0, 600), name: String(attachment.name || "").slice(0, 120), type: String(attachment.type || "").slice(0, 60), kind: attachment.kind === "pdf" ? "pdf" : "image" };
+  if (attachment && typeof attachment === "object" && attachment.url) {
+    const chemin = cheminPieceJointe(attachment.url, slug, base);
+    if (chemin) {
+      // On stocke le CHEMIN validé et on RECONSTRUIT l'URL publique depuis lui — jamais l'URL
+      // telle que le client l'a envoyée. Deux barrières : ce chemin est revalidé à la suppression.
+      att = {
+        path: chemin,
+        url: `${base}/storage/v1/object/public/${BUCKET_PIECES}/${chemin}`,
+        name: String(attachment.name || "").slice(0, 120),
+        type: String(attachment.type || "").slice(0, 60),
+        kind: attachment.kind === "pdf" ? "pdf" : "image",
+      };
+    }
   }
   if ((!b && !att) || !slug) return { ok: false, status: 400 };
   const rt = Number.isFinite(+replyTo) ? Math.trunc(+replyTo) : null;
@@ -939,4 +977,4 @@ async function listPresentationsForDoc(docId, email, isAdmin, autoriseLarge) {
 module.exports = {
   reacteurDepuisJeton,
   purgerPerimees,
-  messagePublic, CHAMPS_PUBLICS, init, createPresentation, getPresentation, setPage, endPresentation, addMessage, listMessages, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent };
+  messagePublic, CHAMPS_PUBLICS, cheminPieceJointe, init, createPresentation, getPresentation, setPage, endPresentation, addMessage, listMessages, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent };

package/server/retention.js

@@ -20,63 +20,228 @@ const enc = encodeURIComponent;
 
 // Fenêtres par défaut de docs/RETENTION.md — l'hôte ajuste via `config.retention`.
 const FENETRES = { journauxMois: 13, presentationsMois: 12, liensRevoquesMois: 13 };
-const fenetres = () => ({ ...FENETRES, ...((PLAYER.config && PLAYER.config.retention) || {}) });
+const CLES_FENETRE = Object.keys(FENETRES);
+const MIN_MOIS = 1, MAX_MOIS = 120;
 
-// Borne calendaire : N mois avant `now`, en ISO — les fenêtres de RETENTION.md parlent en mois.
-function borne(now, mois) { const d = new Date(now); d.setMonth(d.getMonth() - mois); return d.toISOString(); }
+// ⚠️ UNE FENÊTRE EST UN ENTIER DE MOIS DANS [1,120] — RIEN D'AUTRE (P2 huitième audit). Une valeur
+// négative calculerait une borne FUTURE (perte massive), zéro purgerait tout, une chaîne/NaN/
+// Infinity produirait une date invalide. On refuse AVANT le premier DELETE, en NOMMANT la clé.
+// Zéro n'est PAS une purge immédiate : ce serait un geste trop dangereux pour un défaut de config.
+function fenetresValidees() {
+  const brut = { ...FENETRES, ...((PLAYER.config && PLAYER.config.retention) || {}) };
+  const out = Object.create(null);   // nu : la garde de forme reconnaît cet accumulateur
+  for (const cle of CLES_FENETRE) {
+    const v = brut[cle];
+    if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_MOIS || v > MAX_MOIS) {
+      const e = new Error(`fenêtre de rétention invalide : ${cle}=${JSON.stringify(v)} — attendu un entier de mois dans [${MIN_MOIS},${MAX_MOIS}]. Aucune suppression.`);
+      e.retentionInvalide = true;
+      throw e;
+    }
+    out[cle] = v;
+  }
+  return out;
+}
+
+// ⚠️ Borne = N mois avant `now`, en UTC, RABATTUE au dernier jour du mois cible. `Date.setMonth`
+// déborde (« 31 mars − 1 mois » → 3 mars) et l'heure locale + le changement d'heure décalaient la
+// borne : on construit la date en UTC, jour rabattu sur le dernier du mois visé.
+function borne(now, mois) {
+  const d = new Date(now);
+  const a = d.getUTCFullYear();
+  const m = d.getUTCMonth() - mois;
+  const dernierDuMois = new Date(Date.UTC(a, m + 1, 0)).getUTCDate();   // jour 0 du mois suivant = dernier du mois
+  const jour = Math.min(d.getUTCDate(), dernierDuMois);
+  return new Date(Date.UTC(a, m, jour, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())).toISOString();
+}
+
+// Bornes d'exécution par défaut — un lot raisonnable, un plafond qui tient dans une fenêtre
+// serverless. L'appelant peut resserrer (dryRun, taille, plafond) ; jamais dépasser sans le dire.
+const LOT = 200, PLAFOND = 5000, PLAFOND_PRESENTATIONS = 500;
+const MAX_TAILLE = 500, MAX_PLAFOND = 5000;
+
+// ⚠️ LES OPTIONS D'EXÉCUTION SONT VALIDÉES AVANT TOUT DELETE (P1 neuvième audit). La route les
+// reçoit d'un appelant ; un `dryRun` non booléen strict, une taille/plafond hors bornes ou une
+// clé inconnue font ÉCHOUER la purge — jamais un `Number()` ni un `!!` qui transformerait
+// `"false"` en purge réelle. `dryRun` est ce qu'un exploitant lance EN PREMIER : il ne doit pas
+// pouvoir supprimer par une faute de type.
+const CLES_OPTS = new Set(["dryRun", "taille", "plafond"]);
+function optionsValidees(opts) {
+  const o = opts || {};
+  for (const cle of Object.keys(o)) {
+    if (!CLES_OPTS.has(cle)) { const e = new Error(`option de rétention inconnue : ${cle}`); e.retentionInvalide = true; throw e; }
+  }
+  if ("dryRun" in o && typeof o.dryRun !== "boolean") { const e = new Error("dryRun doit être un booléen strict"); e.retentionInvalide = true; throw e; }
+  const entierDans = (v, min, max, nom) => {
+    if (v === undefined) return undefined;
+    if (typeof v !== "number" || !Number.isInteger(v) || v < min || v > max) {
+      const e = new Error(`${nom} doit être un entier dans [${min},${max}] — reçu ${JSON.stringify(v)}`); e.retentionInvalide = true; throw e;
+    }
+    return v;
+  };
+  return {
+    dryRun: o.dryRun === true,
+    taille: entierDans(o.taille, 1, MAX_TAILLE, "taille") ?? LOT,
+    plafond: entierDans(o.plafond, 1, MAX_PLAFOND, "plafond") ?? PLAFOND,
+  };
+}
+
+// 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, '\\"') + '"';
+
+// ⚠️ 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
+// DELETE non borné qui ramènerait tout l'historique d'un coup (mémoire, WAL, verrous, timeout).
+// `dryRun` sélectionne sans supprimer. Le rapport remplace la liste d'identifiants : examinées,
+// supprimées, tronqué (il reste à faire au prochain passage).
+// ⚠️ Pagination par CURSEUR KEYSET (`colId=gt.<dernier>`), pas par `offset` — la garde de
+// portabilité de la forge interdit `offset=`, et un curseur est de toute façon stable sous
+// suppression concurrente. En dry-run le pool ne rétrécit pas : sans curseur, on relisait le
+// même premier lot à chaque tour (P2 neuvième audit : 120 lignes comptées 300). Le lot est rogné
+// 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 } = {}) {
+  let examinees = 0, supprimees = 0, tronque = false, curseur = null;
+  for (;;) {
+    const reste = plafond - examinees;
+    if (reste <= 0) { tronque = await resteEncore(table, filtre, colId, curseur, dryRun); break; }
+    const limite = Math.min(taille, reste);
+    const borneCur = curseur != null ? `&${colId}=gt.${enc(String(curseur))}` : "";
+    const lot = await PLAYER.db.request(`${table}?${filtre}${borneCur}&select=${colId}&order=${colId}.asc&limit=${limite}`);
+    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;
+      }
+    }
+    if (lot.length < limite) break;   // dernier lot (moins que demandé → plus rien après)
+  }
+  return { examinees, supprimees, tronque };
+}
 
-async function effacer(chemin) {
-  const lignes = await PLAYER.db.request(chemin, { method: "DELETE", headers: { Prefer: "return=representation" } });
-  return Array.isArray(lignes) ? lignes.length : 0;
+// « Reste-t-il une ligne au-delà du curseur ? » — sonde d'UNE ligne. Départage « on s'est arrêté
+// pile au plafond mais tout est parti » de « il reste à faire ». En run réel les lignes lues ont
+// été supprimées : la fenêtre a avancé, on relit depuis le début du filtre (curseur non requis).
+async function resteEncore(table, filtre, colId, curseur, dryRun) {
+  const borneCur = dryRun && curseur != null ? `&${colId}=gt.${enc(String(curseur))}` : "";
+  const sonde = await PLAYER.db.request(`${table}?${filtre}${borneCur}&select=${colId}&order=${colId}.asc&limit=1`);
+  return Array.isArray(sonde) && sonde.length > 0;
 }
 
-// Chemin du bucket depuis l'URL publique d'une pièce jointe — nul si l'URL vient d'ailleurs.
-function cheminPieceJointe(url) {
-  const m = /\/present-attachments\/(.+)$/.exec(String(url || ""));
-  return m ? m[1].split("?")[0] : null;
+// ⚠️ REVALIDATION À LA SUPPRESSION — le MÊME validateur que l'écriture (server/presentations.js),
+// 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");
+
+// 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;
+  for (;;) {
+    const reste = plafond - examinees;
+    if (reste <= 0) { tronque = await resteEncore("doc_presentation_messages", `slug=eq.${enc(slug)}`, "id", curseur, dryRun); break; }
+    const limite = Math.min(taille, reste);
+    const borneCur = curseur != null ? `&id=gt.${enc(String(curseur))}` : "";
+    const lot = await PLAYER.db.request(`doc_presentation_messages?slug=eq.${enc(slug)}${borneCur}&select=id,attachment&order=id.asc&limit=${limite}`);
+    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;
+      }
+    }
+    if (lot.length < limite) break;
+  }
+  return { supprimees, fichiers, fichiersErreur, examinees, tronque };
 }
 
-async function purgerRetention(now) {
-  const f = fenetres();
-  const efface = {};
+async function purgerRetention(now, optsBrutes = {}) {
+  let f, opts;
+  try { f = fenetresValidees(); opts = optionsValidees(optsBrutes); }
+  catch (e) {
+    if (!e.retentionInvalide) throw e;
+    try { PLAYER.errors.capture(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) || "");
+  const rapport = {};
   const bJournaux = borne(now, f.journauxMois);
 
-  efface.commercial_doc_views = await effacer(`commercial_doc_views?at=lt.${enc(bJournaux)}&select=id`);
-  efface.commercial_doc_sessions = await effacer(`commercial_doc_sessions?last_at=lt.${enc(bJournaux)}&select=session_id`);
-  efface.commercial_doc_internal_sessions = await effacer(`commercial_doc_internal_sessions?last_at=lt.${enc(bJournaux)}&select=session_id`);
-  efface.doc_bot_sessions = await effacer(`doc_bot_sessions?last_at=lt.${enc(bJournaux)}&select=id`);
-  efface.player_rate_limits = await effacer(`player_rate_limits?expires_at=lt.${enc(new Date(now).toISOString())}&select=key`);
+  rapport.commercial_doc_views = await purgerParLots("commercial_doc_views", `at=lt.${enc(bJournaux)}`, "id", opts);
+  rapport.commercial_doc_sessions = await purgerParLots("commercial_doc_sessions", `last_at=lt.${enc(bJournaux)}`, "session_id", opts);
+  rapport.commercial_doc_internal_sessions = await purgerParLots("commercial_doc_internal_sessions", `last_at=lt.${enc(bJournaux)}`, "session_id", opts);
+  rapport.doc_bot_sessions = await purgerParLots("doc_bot_sessions", `last_at=lt.${enc(bJournaux)}`, "id", opts);
+  rapport.player_rate_limits = await purgerParLots("player_rate_limits", `expires_at=lt.${enc(new Date(now).toISOString())}`, "key", opts);
 
-  // Liens révoqués : seulement là où la révocation est DATÉE (0013) — sans la colonne, la purge
-  // resterait muette plutôt que d'inventer une borne depuis l'âge du lien.
+  // Liens révoqués : seulement là où la révocation est DATÉE (0013).
   const dateDispo = await require("./schema").attendue("revocationDatee");
-  efface.commercial_doc_shares = dateDispo
-    ? await effacer(`commercial_doc_shares?revoked=eq.true&revoked_at=lt.${enc(borne(now, f.liensRevoquesMois))}&select=slug`)
-    : 0;
+  rapport.commercial_doc_shares = dateDispo
+    ? await purgerParLots("commercial_doc_shares", `revoked=eq.true&revoked_at=lt.${enc(borne(now, f.liensRevoquesMois))}`, "slug", opts)
+    : { examinees: 0, supprimees: 0, tronque: false };
 
-  // Présentations mortes : la ligne, ses messages, ses présences — et les fichiers du bucket si
-  // l'hôte fournit storage.remove (capacité OPTIONNELLE : sans elle, la limite est écrite dans
-  // RETENTION.md plutôt que simulée ici).
+  // Présentations mortes : bornées à PLAFOND_PRESENTATIONS par exécution ; la ligne, ses messages,
+  // 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`);
-  efface.doc_presentations = 0; efface.doc_presentation_messages = 0;
-  efface.doc_presentation_attendees = 0; efface.pieces_jointes = 0;
+  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;
   for (const p of (Array.isArray(mortes) ? mortes : [])) {
     const slug = p && p.slug; if (!slug) continue;
-    if (retirer) {
-      const jointes = await PLAYER.db.request(`doc_presentation_messages?slug=eq.${enc(slug)}&attachment=not.is.null&select=attachment`);
-      for (const j of (Array.isArray(jointes) ? jointes : [])) {
-        const chemin = cheminPieceJointe(j && j.attachment);
-        if (!chemin) continue;
-        try { if (await retirer("present-attachments", chemin)) efface.pieces_jointes += 1; } catch { /* le fichier survit, la ligne part quand même — limite dite */ }
-      }
+    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);
+    presRapport.messages += msgs.supprimees;
+    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.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.
+    if (!opts.dryRun && !msgs.tronque && !pres.tronque) {
+      presRapport.supprimees += (await purgerParLots("doc_presentations", `slug=eq.${enc(slug)}`, "slug", opts)).supprimees;
     }
-    efface.doc_presentation_messages += await effacer(`doc_presentation_messages?slug=eq.${enc(slug)}&select=id`);
-    efface.doc_presentation_attendees += await effacer(`doc_presentation_attendees?slug=eq.${enc(slug)}&select=attendee_key`);
-    efface.doc_presentations += await effacer(`doc_presentations?slug=eq.${enc(slug)}&select=slug`);
   }
-  return { ok: true, efface };
+  rapport.presentations = presRapport;
+
+  // `efface` : l'ANCIENNE forme (table → nombre supprimé), dérivée du rapport — les appelants et
+  // essais existants continuent de lire `r.efface.commercial_doc_views`. Le rapport détaillé vit
+  // à côté, sous `r.rapport`.
+  const efface = {
+    commercial_doc_views: rapport.commercial_doc_views.supprimees,
+    commercial_doc_sessions: rapport.commercial_doc_sessions.supprimees,
+    commercial_doc_internal_sessions: rapport.commercial_doc_internal_sessions.supprimees,
+    doc_bot_sessions: rapport.doc_bot_sessions.supprimees,
+    player_rate_limits: rapport.player_rate_limits.supprimees,
+    commercial_doc_shares: rapport.commercial_doc_shares.supprimees,
+    doc_presentations: presRapport.supprimees,
+    doc_presentation_messages: presRapport.messages,
+    doc_presentation_attendees: presRapport.presences,
+    pieces_jointes: presRapport.fichiers,
+  };
+  return { ok: true, dryRun: !!opts.dryRun, efface, rapport };
 }
 
 // Balayage opportuniste : au plus UN par fenêtre de 24 h (le verrou est le compteur de débit
@@ -99,4 +264,4 @@ function tick() {
     .catch((e) => { try { PLAYER.errors.capture(e, { route: "retention", benin: true }); } catch { /* jamais bloquant */ } });
 }
 
-module.exports = { init, purgerRetention, tick, cheminPieceJointe };
+module.exports = { init, purgerRetention, tick, borne };

package/server/routes-liens.js

@@ -32,7 +32,14 @@ async function traiter(req, res, body, slug) {
           let admin = false;
           if (!hote) { const u = await PLAYER.identity.verifyToken(req.headers.authorization); admin = !!(u && PLAYER.identity.isAdmin(u)); }
           if (!hote && !admin) return jd(403, { ok: false, error: "retention.run : hôte de confiance ou admin requis" });
-          return jd(200, await require("./retention").purgerRetention(Date.now()));
+          // ⚠️ LES OPTIONS TRAVERSENT LA ROUTE (P1 neuvième audit) — dryRun compris, sinon la
+          // purge « à blanc » supprimait pour de vrai. La validation vit dans purgerRetention
+          // (avant tout DELETE) ; un refus (ok:false + error) devient un 400, pas un 200.
+          // Tout le corps SAUF `action` est passé au validateur : une clé inconnue (faute de
+          // frappe d'option) est ainsi refusée, pas ignorée en silence.
+          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 }); }
       }
       if (String(body.action || "").startsWith("docshare.")) {
@@ -326,6 +333,20 @@ async function traiter(req, res, body, slug) {
         // jamais.
         return j(200, { ok: true, slug: out.slug, sent, ...(refusEnvoi ? { sendRefused: refusEnvoi } : {}) });
       }
+      // ⚠️ CE REPLI NE COUVRE QUE LES ÉVÉNEMENTS ANALYTIQUES (P2 huitième audit). Une action POST
+      // qu'aucune famille n'a reconnue tombait ici et repartait `{"ok":true}` — une faute de
+      // frappe (`present-pgae`) passait pour un succès, parfois même journalisée. Un `action`
+      // présent mais inconnu est donc REFUSÉ ; sans action, il faut un `event` autorisé. Jamais un
+      // événement absent ou invalide transformé en ouverture.
+      const EVENEMENTS = new Set(["open", "page", "heartbeat", "session"]);
+      if (typeof body.action === "string" && body.action.trim()) {
+        res.statusCode = 400; res.setHeader("Content-Type", "application/json"); res.end('{"ok":false,"error":"unknown-action"}');
+        return true;
+      }
+      if (!EVENEMENTS.has(body.event)) {
+        res.statusCode = 400; res.setHeader("Content-Type", "application/json"); res.end('{"ok":false,"error":"bad-event"}');
+        return true;
+      }
       const ua0 = req.headers["user-agent"];
       const ip0 = adresseAppelant(req);
       // ⚠️ CONSULTATION INTERNE : L'IDENTITÉ EST AFFIRMÉE PAR LE NAVIGATEUR, PAS PROUVÉE.
@@ -443,9 +464,11 @@ async function traiter(req, res, body, slug) {
       }
       res.statusCode = 200; res.setHeader("Content-Type", "application/json"); res.end('{"ok":true}');
       return;
-  // ⚠️ PAS de `return false` ici : le bloc ci-dessus est le REPLI POST d'origine — toute action
-  // qu'aucune famille n'a reconnue finit {"ok":true}, comme avant l'extraction. Cette famille
-  // répond donc TOUJOURS, et doit rester la DERNIÈRE du dispatch (handler le dit aussi).
+  // ⚠️ PAS de `return false` ici : le bloc ci-dessus est le repli ANALYTIQUE (open/page/heartbeat/
+  // session). Une action inconnue N'Y ARRIVE PLUS — elle est refusée en 400 unknown-action au
+  // début de ce repli (neuvième audit : le commentaire disait encore « finit ok:true », c'était
+  // faux depuis le huitième). Cette famille répond donc toujours pour un événement valide, et doit
+  // rester la DERNIÈRE du dispatch (handler le dit aussi).
 }
 
 module.exports = { init, traiter };

package/server/routes-visiteur.js

@@ -12,7 +12,7 @@ const init = (ctx) => { PLAYER = ctx; };
 // chute au bout rend `false` et le dispatch continue. Aucune liste d'actions n'est dupliquée
 // entre ici et handler (un correctif à deux exemplaires finit par diverger) — et aucun appui
 // sur res.writableEnded, absent des `res` postiches des bancs comme de certains hôtes.
-async function traiter(req, res, body, slug) {
+async function traiter(req, res, body, _slug) {
       // ── Connexion VISITEUR (soft wall) : demande d'un code par email, puis vérification. ──
       // Émet un jeton signé posé en cookie qui débloque les contenus gatés (require_auth).
       if (body.action === "visitor-request" || body.action === "visitor-verify" || body.action === "visitor-google") {

package/supabase/init.sql

@@ -78,6 +78,13 @@ comment on column public.commercial_doc_shares.idem_key is
 create index if not exists cds_parent_idx on public.commercial_doc_shares (parent_slug);
 create index if not exists idx_doc_shares_brand_key
   on public.commercial_doc_shares (brand_key) where brand_key is not null;
+-- Filtres de rétention (migration 0014) : mêmes index sur une base vierge.
+-- ⚠️ RÈGLE (sixième audit) : un index sur une colonne apparue APRÈS un init publié est précédé
+-- de son ALTER, ICI MÊME — sur une base d'hier, `create table if not exists` saute le corps de
+-- table et `revoked_at` n'existe qu'au rattrapage de fin de fichier, trop tard pour cet index.
+alter table public.commercial_doc_shares
+  add column if not exists revoked_at timestamptz;
+create index if not exists idx_shares_revoked_at on public.commercial_doc_shares (revoked_at) where revoked = true;
 
 -- ── Journal des ouvertures (population EXTERNE) ────────────────────────────────────────────────
 create table if not exists public.commercial_doc_views (
@@ -120,6 +127,7 @@ create table if not exists public.commercial_doc_sessions (
 );
 create index if not exists cds_sess_slug_idx on public.commercial_doc_sessions (slug);
 create index if not exists cds_sess_doc_idx  on public.commercial_doc_sessions (doc_id, last_at desc);
+create index if not exists idx_cds_last_at on public.commercial_doc_sessions (last_at);
 
 create table if not exists public.commercial_doc_internal_sessions (
   session_id    text primary key,
@@ -250,6 +258,7 @@ create table if not exists public.doc_bot_sessions (
   journey_step   text,
   etat           jsonb
 );
+create index if not exists idx_bot_last_at on public.doc_bot_sessions (last_at);
 create index if not exists doc_bot_sessions_share_idx on public.doc_bot_sessions (share_slug);
 
 -- ── Limites de débit partagées ─────────────────────────────────────────────────────────────────

package/supabase/migrations/0014-index-retention.sql

@@ -0,0 +1,15 @@
+-- LES FILTRES DE RÉTENTION MÉRITENT LEURS INDEX.
+--
+-- La purge sélectionne par date : `last_at`, `revoked_at`, `expires_at`. Sans index, chaque lot
+-- est un balayage séquentiel — acceptable sur une petite base, coûteux sur un gros historique
+-- (P2 du huitième audit). Trois index, idempotents.
+--
+-- ⚠️ `CREATE INDEX CONCURRENTLY` NE PEUT PAS tourner dans une transaction (et le MCP applique en
+-- transaction) : on pose donc des index ordinaires ici. Sur une installation VOLUMINEUSE déjà en
+-- production, un exploitant préférera les créer à la main en `CONCURRENTLY` hors migration pour
+-- ne pas verrouiller la table en écriture — c'est écrit dans docs/RETENTION.md.
+--
+-- Sans lui : rien ne casse — la purge tourne, plus lentement sur les grosses tables.
+create index if not exists idx_cds_last_at on public.commercial_doc_sessions (last_at);
+create index if not exists idx_bot_last_at on public.doc_bot_sessions (last_at);
+create index if not exists idx_shares_revoked_at on public.commercial_doc_shares (revoked_at) where revoked = true;

package/supabase/recensement-retention.sql

@@ -9,21 +9,30 @@
 -- Usage : psql -f supabase/recensement-retention.sql — chaque ligne rend « table|restantes ».
 -- Après une purge, tout doit être à zéro ; un reste est un mensonge de la purge OU un trou de
 -- son périmètre. La forge l'exécute à chaque course, après le banc base.
+--
+-- ⚠️ FENÊTRES PARAMÉTRABLES (neuvième audit) : si un hôte configure d'autres durées via
+-- `config.retention`, le recensement doit contrôler LA MÊME politique, pas les défauts figés.
+-- Les variables psql ci-dessous portent les défauts de RETENTION.md ; passez-les à l'appel pour
+-- une configuration non standard, ex. :
+--   psql -v journaux_mois=6 -v presentations_mois=3 -v liens_mois=6 -f supabase/recensement-retention.sql
+\if :{?journaux_mois}\else \set journaux_mois 13 \endif
+\if :{?presentations_mois}\else \set presentations_mois 12 \endif
+\if :{?liens_mois}\else \set liens_mois 13 \endif
 select 'commercial_doc_views' as perimetre, count(*) as restantes
   from public.commercial_doc_views
-  where at < now() - interval '13 months'
+  where at < now() - make_interval(months => :journaux_mois)
 union all
 select 'commercial_doc_sessions', count(*)
   from public.commercial_doc_sessions
-  where last_at < now() - interval '13 months'
+  where last_at < now() - make_interval(months => :journaux_mois)
 union all
 select 'commercial_doc_internal_sessions', count(*)
   from public.commercial_doc_internal_sessions
-  where last_at < now() - interval '13 months'
+  where last_at < now() - make_interval(months => :journaux_mois)
 union all
 select 'doc_bot_sessions', count(*)
   from public.doc_bot_sessions
-  where last_at < now() - interval '13 months'
+  where last_at < now() - make_interval(months => :journaux_mois)
 union all
 select 'player_rate_limits', count(*)
   from public.player_rate_limits
@@ -31,11 +40,11 @@ select 'player_rate_limits', count(*)
 union all
 select 'commercial_doc_shares_revoques', count(*)
   from public.commercial_doc_shares
-  where revoked and revoked_at < now() - interval '13 months'
+  where revoked and revoked_at < now() - make_interval(months => :liens_mois)
 union all
 select 'doc_presentations_mortes', count(*)
   from public.doc_presentations
-  where not active and updated_at < now() - interval '12 months'
+  where not active and updated_at < now() - make_interval(months => :presentations_mois)
 union all
 -- Messages et présences : orphelins d'une présentation morte-ancienne OU d'aucune présentation —
 -- formulé par NOT EXISTS, pas par la liste de slugs que la purge a construite.
@@ -44,11 +53,11 @@ select 'doc_presentation_messages_orphelins', count(*)
   where not exists (
     select 1 from public.doc_presentations p
     where p.slug = m.slug
-      and (p.active or p.updated_at >= now() - interval '12 months'))
+      and (p.active or p.updated_at >= now() - make_interval(months => :presentations_mois)))
 union all
 select 'doc_presentation_attendees_orphelins', count(*)
   from public.doc_presentation_attendees a
   where not exists (
     select 1 from public.doc_presentations p
     where p.slug = a.slug
-      and (p.active or p.updated_at >= now() - interval '12 months'));
+      and (p.active or p.updated_at >= now() - make_interval(months => :presentations_mois)));