discovery-media-player 0.1.76 → 0.1.78

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

@@ -1,5 +1,10 @@
 # Host contract
 
+> **This document is an export of the package** — resolve it with
+> `require.resolve("discovery-media-player/contrat")` (and the retention policy with
+> `…/retention`). An exposed path is a promise that survives file reorganizations; reading
+> `node_modules` paths by hand is a guess about our tree, and it broke twice in one day.
+
 What a host application may call, what it must implement, and what will not change without a
 version bump. If you are integrating the player, this page and [`API.md`](API.md) are the two you
 need.
@@ -26,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

@@ -0,0 +1,136 @@
+# Rétention des données
+
+Ce document est le **périmètre déclaré** de la rétention : chaque colonne du schéma dont la forme
+peut porter une donnée personnelle y a une politique — *purgée après N* ou *conservée parce que*.
+Une garde de forge énumère les colonnes du schéma **vivant** (`information_schema`, jamais notre
+mémoire du fichier) et refuse toute colonne à forme personnelle absente d'ici : une donnée sans
+politique écrite ne peut pas entrer dans le schéma sans rougir.
+
+Le contrat de vérification a deux moitiés, volontairement **indépendantes** (aucun code partagé —
+ni fonction de périmètre, ni filtre) :
+
+1. la **purge** (`server/retention.js`) déclare ce qu'elle a effacé, compte par compte ;
+2. le **recensement** (`supabase/recensement-retention.sql`, SQL nu) compte ce qui reste dans le
+   périmètre revendiqué. Les deux nombres doivent se contredire si l'un ment.
+
+> ⚠️ **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` — **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
+> toutes ses capacités par défaut — « rien à brancher parce que rien n'a été débranché » — et une
+> suppression est une décision métier : elle n'agit que là où un exploitant l'a écrite. L'action
+> `retention.run` (hôte de confiance ou admin) reste disponible sans opt-in : l'appeler EST la
+> décision.
+
+## Journaux de lecture (population externe)
+
+Finalité : statistiques de lecture d'un document envoyé. **Purge : 13 mois** après l'événement.
+
+| colonne | contenu | sort |
+|---|---|---|
+| `commercial_doc_views.recipient_email` | à qui la lecture est attribuée | purgée avec la ligne, 13 mois après `at` |
+| `commercial_doc_views.session_id` | corrèle les vues d'une session | idem |
+| `commercial_doc_views.ua` | navigateur (User-Agent brut) | idem |
+| `commercial_doc_sessions.recipient_email` | attribution de la session | purgée avec la ligne, 13 mois après `last_at` |
+| `commercial_doc_sessions.session_id` | identifiant de session | idem |
+| `commercial_doc_sessions.ip` | **adresse IP en clair** | idem — c'est la donnée la plus sensible du schéma |
+| `commercial_doc_sessions.ua` | User-Agent brut | idem |
+| `commercial_doc_sessions.num_pages` / `commercial_doc_sessions.pages_time` | comportement de lecture page par page | idem |
+
+## Journaux de lecture (équipe interne)
+
+Même finalité, population interne. **Purge : 13 mois** après `last_at`.
+
+| colonne | sort |
+|---|---|
+| `commercial_doc_internal_sessions.user_email` / `commercial_doc_internal_sessions.user_name` | purgées avec la ligne |
+| `commercial_doc_internal_sessions.session_id` | idem |
+| `commercial_doc_internal_sessions.num_pages` / `commercial_doc_internal_sessions.pages_time` | idem |
+
+## Liens d'envoi (`commercial_doc_shares`)
+
+Un lien **vivant** est un enregistrement métier : ses champs restent tant que l'URL distribuée
+doit fonctionner. Un lien **révoqué** ne sert plus personne : **purge 13 mois après révocation**
+(alignée sur les journaux, qui référencent son slug). La révocation est **datée** par
+`commercial_doc_shares.revoked_at` (migration 0013) ; les révoqués d'avant la colonne ont reçu la
+date de la migration — leur horloge démarre là, compter large plutôt qu'inventer. Sans la
+colonne, cette purge-là se tait (sonde de schéma), les autres tournent.
+
+| colonne | contenu | sort |
+|---|---|---|
+| `commercial_doc_shares.recipient_email` | qui peut expédier au repartage | conservée tant que le lien vit ; ligne purgée 13 mois après révocation |
+| `commercial_doc_shares.attested_recipient_email` | à qui l'hôte atteste le lien | idem |
+| `commercial_doc_shares.recipient_name` | nom du destinataire | idem |
+| `commercial_doc_shares.created_by` | email du commercial créateur | idem |
+| `commercial_doc_shares.file_name` | nom du fichier (peut porter un nom de personne) | métier, purgé avec la ligne |
+
+## Présentations en direct
+
+Une présentation **inactive** (terminée ou abandonnée) est une archive : **purge 12 mois après
+`updated_at`** — la présentation, ses messages, ses présences, et ses pièces jointes du bucket
+`present-attachments` (si l'hôte fournit `storage.remove`, sinon la limite est dite ci-dessous).
+
+| colonne | contenu | sort |
+|---|---|---|
+| `doc_presentations.presenter_name` / `doc_presentations.owner_name` | identité du présentateur | purgées avec la ligne, 12 mois après la fin |
+| `doc_presentations.owner_email` / `doc_presentations.owner_user_id` | propriétaire | idem |
+| `doc_presentations.owner_avatar` | URL d'avatar | idem |
+| `doc_presentations.control_hash` | empreinte du jeton de contrôle (pas le jeton) | idem |
+| `doc_presentations.content` | contenu partagé (cartes, médias) | idem |
+| `doc_presentations.file_name` | nom du fichier présenté | idem |
+| `doc_presentation_messages.author_name` / `doc_presentation_messages.author_email` / `doc_presentation_messages.author_avatar` | identité de l'auteur | purgées avec la présentation |
+| `doc_presentation_messages.author_hash` | empreinte du jeton d'auteur | idem |
+| `doc_presentation_messages.body` | corps du message | idem |
+| `doc_presentation_messages.reply_name` / `doc_presentation_messages.reply_text` | citation d'un autre message | idem |
+| `doc_presentation_messages.attachment` | URL de pièce jointe | idem — fichier du bucket inclus quand `storage.remove` existe |
+| `doc_presentation_messages.client_key` | clé d'idempotence d'envoi | idem |
+| `doc_presentation_attendees.name` / `doc_presentation_attendees.email` / `doc_presentation_attendees.avatar` | identité du participant | purgées avec la présentation |
+| `doc_presentation_attendees.attendee_key` | identifiant de présence | idem |
+| `doc_presentation_attendees.pages` | pages vues par le participant | idem |
+
+## Sessions d'agent (`doc_bot_sessions`)
+
+Parcours guidé par l'agent : **purge 13 mois** après `last_at`.
+
+| colonne | sort |
+|---|---|
+| `doc_bot_sessions.rating` / `doc_bot_sessions.rating_comment` | avis du visiteur — purgés avec la ligne |
+| `doc_bot_sessions.in_tokens` / `doc_bot_sessions.out_tokens` / `doc_bot_sessions.cache_tokens` | volumétrie IA (pas personnelle, mais portée par la ligne) — purgés avec elle |
+
+## Limites de débit (`player_rate_limits`)
+
+| colonne | contenu | sort |
+|---|---|---|
+| `player_rate_limits.key` | peut contenir une **IP en clair** (`hshare:<ip>`) ou un email | ligne purgée dès `expires_at` dépassé (opportuniste, à chaque passage) |
+
+## Limites dites plutôt que tues
+
+- **Pièces jointes orphelines** : la purge des lignes n'efface le fichier du bucket que si le
+  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
+  second hôte, sans réponse mécanique) : une colonne supprimée du schéma sort du périmètre des
+  deux textes, mais sa donnée peut survivre dans un dump, une sauvegarde ou une table d'archive.
+  Ce contrat couvre la BASE VIVANTE ; les copies (sauvegardes, exports, dumps de migration) sont
+  le périmètre de l'exploitant, nommé ici plutôt que simulé. Corollaire opératoire : supprimer
+  une colonne à donnée personnelle est un acte de rétention — sa ligne quitte ce document dans
+  le même commit, et les copies antérieures suivent la politique de sauvegarde de l'hôte.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "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",
@@ -36,6 +36,7 @@
     "LICENSE",
     "LICENSE-MIT",
     "docs/HOST-CONTRACT.md",
+    "docs/RETENTION.md",
     "!**/__tests__"
   ],
   "exports": {
@@ -43,6 +44,8 @@
     "./shares": "./server/shares.js",
     "./presentations": "./server/presentations.js",
     "./brands": "./server/brands.js",
+    "./contrat": "./docs/HOST-CONTRACT.md",
+    "./retention": "./docs/RETENTION.md",
     "./context/standalone": "./context/standalone.js",
     "./context/storage": "./context/storage.js",
     "./bridge": {

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,150 @@ 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;
+}
 
-async function effacer(chemin) {
-  const lignes = await PLAYER.db.request(chemin, { method: "DELETE", headers: { Prefer: "return=representation" } });
-  return Array.isArray(lignes) ? lignes.length : 0;
+// ⚠️ 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();
 }
 
-// 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;
+// 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;
+
+// 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).
+async function purgerParLots(table, filtre, colId, { dryRun = false, taille = LOT, plafond = PLAFOND } = {}) {
+  let examinees = 0, supprimees = 0;
+  const maxTours = Math.max(1, Math.ceil(plafond / taille));
+  let tours = 0, tronque = false;
+  for (;;) {
+    if (tours >= maxTours) { tronque = true; break; }
+    tours += 1;
+    const lot = await PLAYER.db.request(`${table}?${filtre}&select=${colId}&order=${colId}.asc&limit=${taille}`);
+    if (!Array.isArray(lot) || !lot.length) break;
+    examinees += lot.length;
+    if (!dryRun) {
+      const ids = lot.map((r) => r[colId]).filter((v) => v != null).map(guill);
+      if (ids.length) {
+        await PLAYER.db.request(`${table}?${colId}=in.(${ids.join(",")})`, { method: "DELETE", headers: { Prefer: "return=minimal" } });
+        supprimees += ids.length;
+      }
+    }
+    if (lot.length < taille) break;   // dernier lot
+    if (dryRun) { tronque = tours >= maxTours; if (tours >= maxTours) break; }
+  }
+  return { examinees, supprimees, tronque };
 }
 
-async function purgerRetention(now) {
-  const f = fenetres();
-  const efface = {};
+// ⚠️ 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");
+
+async function purgerRetention(now, opts = {}) {
+  let f;
+  try { f = fenetresValidees(); }
+  catch (e) {
+    if (!e.retentionInvalide) throw e;
+    try { PLAYER.errors.capture(e, { route: "retention" }); } catch { /* jamais bloquant */ }
+    return { ok: false, error: e.message };   // config 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) {
+    presRapport.examinees += 1;
+    if (retirer && !opts.dryRun) {
       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 */ }
+        const url = j && 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)) presRapport.fichiers += 1; } catch { presRapport.fichiersErreur += 1; /* le fichier survit, la ligne part */ }
       }
     }
-    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`);
+    if (!opts.dryRun) {
+      presRapport.messages += (await purgerParLots("doc_presentation_messages", `slug=eq.${enc(slug)}`, "id", opts)).supprimees;
+      presRapport.presences += (await purgerParLots("doc_presentation_attendees", `slug=eq.${enc(slug)}`, "attendee_key", opts)).supprimees;
+    }
+    if (!opts.dryRun) {
+      presRapport.supprimees += (await purgerParLots("doc_presentations", `slug=eq.${enc(slug)}`, "slug", opts)).supprimees;
+    }
   }
-  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 +186,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

@@ -326,6 +326,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.

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;