discovery-media-player 0.1.63 → 0.1.64

package/docs/HOST-CONTRACT.md

@@ -29,6 +29,7 @@ need.
   "capabilities": ["docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth", "host-share", "host-mail"],
   "frameAncestors": ["'self'", "https://*.vercel.app", "https://app.example.com"],
   "separateIssuer": true,
+  "internalStrict": true,
   "hostShare": true,
   "hostMail": true,
   "plugins": { "bot": false, "visitors": false, "brandIntro": false, "botBrowser": false, "providerQuotas": false },
@@ -89,6 +90,13 @@ 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.
 
+⚠️ **`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`)
+only accepts host-signed tokens. The flag exists so monitoring can **refuse** a non-strict instance
+instead of discovering it in a log; treat `false` as an alert on any instance whose host already
+issues internal tokens. The default will flip to strict at the next announced breaking change.
+
 ⚠️ **`couvre` states the scope, because `complet` without a scope overpromises.** The card checks
 the **conditional columns** — the ones a feature probes before writing. The rate-limit migrations
 (`0003`, `0004`) are deliberately **not** in it: a host may provide its own `limits` capability, and

package/package.json

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

@@ -336,9 +336,10 @@ var Live=(function(){
   // qui exige que cette table soit lisible publiquement — donc, avec la clé publiable, les
   // conversations de TOUTES les présentations, pas seulement la sienne. C'était le dernier
   // obstacle avant de pouvoir fermer cette lecture.
-  // L'émetteur diffuse la ligne que le serveur vient d'écrire ; les autres l'ajoutent chez eux.
+  // L'émetteur SIGNALE qu'un message existe ; chacun — émetteur compris — tient son affichage de
+  // la RÉPONSE du serveur ou de la relecture HTTP, jamais du canal.
   // ⚠️ La diffusion ne revient pas à son émetteur : il ajoute donc SA copie lui-même — depuis la
-  // RÉPONSE du serveur, jamais depuis le canal.
+  // RÉPONSE du serveur.
   //
   // ⚠️ LA CHARGE EST VIDE, ET C'EST CE QUI REND LA PROPRIÉTÉ STRUCTURELLE. Elle transportait la
   // ligne projetée — que le récepteur IGNORAIT (il relit par HTTP, cf. le commentaire du
@@ -347,13 +348,18 @@ var Live=(function(){
   // était plus forte que le code, et tenait lieu de garde sans en être une — le jour où un
   // récepteur nouveau aurait lu la charge « puisqu'elle est là », la projection serait devenue
   // optionnelle sans que rien ne le dise. Le second hôte a levé l'écart ; sendState et
-  // sendMap avaient déjà la bonne forme. Un commentaire ici même affirmait l'ancien monde
-  // (« les autres l'ajoutent chez eux ») : il a fait dériver sa lecture, pas la nôtre — un
-  // commentaire n'est pas du code, et il vieillit sans essai pour le contredire.
+  // sendMap avaient déjà la bonne forme. Le commentaire d'en tête de ce bloc a affirmé l'ancien
+  // monde (« les autres l'ajoutent chez eux ») pendant des versions : il a fait dériver la
+  // lecture du second hôte — puis a SURVÉCU à sa propre citation : le correctif qui le désignait
+  // comme menteur l'a cité au lieu de le réécrire, et documenter un défaut l'avait rendu
+  // intouchable. Réécrit à la relecture suivante, par le même hôte. Un commentaire n'est pas du
+  // code : il vieillit sans essai pour le contredire — et un essai fige désormais la charge vide.
   function sendMsg(m){if(!m)return;try{if(ch)ch.send({type:'broadcast',event:'msg',payload:{}});}catch(e){}}
   function sendMsgUpd(m){if(!m)return;try{if(ch)ch.send({type:'broadcast',event:'msg-upd',payload:{}});}catch(e){}}
   // Édition, suppression, réaction : le serveur renvoie la ligne à jour, on l'applique chez soi
-  // puis on la diffuse. Même chemin pour les trois — une seule façon de se tromper.
+  // puis on SIGNALE — la charge part vide, les autres relisent. Même chemin pour les trois — une
+  // seule façon de se tromper. (« Puis on la diffuse » a survécu ici une version de trop : second
+  // exemplaire du commentaire d'en tête, trouvé par le second hôte dans le tarball publié.)
   function majDiffusee(r){return r.json().then(function(d){if(d&&d.ok&&d.message){updateMsg(d.message);sendMsgUpd(d.message);}}).catch(function(){});}
   function onState(fn){_onState=fn;}
   // Badge « non lus » sur le bouton chat/FAB (panneau fermé) + pulse du FAB. Aperçu (ticker) au nouveau message.
@@ -3908,6 +3914,12 @@ async function handler(req, res) {
         // l'hôte connaît déjà son émetteur — il veut seulement savoir si l'instance le regarde.
         // Dire lequel n'aiderait personne et renseignerait qui sonde.
         separateIssuer: !!(PLAYER.config && PLAYER.config.separateIssuer),
+        // ⚠️ « L'identité interne vient-elle d'un JETON, ou du navigateur ? » En mode transitoire
+        // (false), la route interne accepte docId/email/name tels que le client les déclare — un
+        // appelant peut fabriquer « tel collègue a consulté tel document ». Le booléen rend l'état
+        // 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),
         // ⚠️ 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/presentations.js

@@ -446,6 +446,11 @@ function messagePublic(row) {
   // relit sans avoir à vérifier d'où vient chaque clé.
   const out = Object.create(null);
   for (const c of CHAMPS_PUBLICS) if (c in row) out[c] = row[c];
+  // ⚠️ LA CEINTURE : une ligne supprimée sort VIDE, quoi que porte encore la base. Les courses
+  // d'avant ce correctif — et les lignes historiques qu'elles ont laissées — peuvent avoir gardé
+  // un corps, une pièce jointe ou une citation sous deleted=true : la projection est le dernier
+  // endroit qui peut refuser de les resservir, et le seul qui couvre AUSSI le passé.
+  if (out.deleted) { out.body = ""; out.attachment = null; out.reactions = {}; out.reply_text = null; out.reply_name = null; }
   if ("reactions" in out) out.reactions = reactionsPubliques(out.reactions);
   // Dérivé, jamais recopié : `author_hash` est lu pour ça et ne sort jamais tel quel.
   if ("author_hash" in row) out.author_ref = refAuteur(row.author_hash);
@@ -551,7 +556,13 @@ async function editMessage(slug, msgId, authorToken, body) {
   const rows = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&select=author_hash,deleted&limit=1`);
   const m = Array.isArray(rows) && rows[0]; if (!m || m.deleted) return { ok: false, status: 404 };
   if (!m.author_hash || m.author_hash !== sha(authorToken)) return { ok: false, status: 403 };
-  const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { body: b, edited: true } });
+  // ⚠️ CE QUI A ÉTÉ VÉRIFIÉ VOYAGE DANS LA CONDITION. Une suppression entre la lecture et
+  // l'écriture vidait le message — et l'édition retardée RÉÉCRIVAIT le texte dans une ligne
+  // marquée supprimée : effacé à l'écran, ressuscité dans le JSON. Cinquième audit, P1-3.
+  // `deleted=eq.false` fait de « pas supprimé » une propriété de l'ÉCRITURE ; `author_hash` et
+  // `slug` par cohérence — l'écriture ne repose plus sur rien qu'elle n'exige elle-même.
+  const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&author_hash=eq.${sha(authorToken)}&deleted=eq.false&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { body: b, edited: true } });
+  if (!Array.isArray(maj) || !maj.length) return { ok: false, status: 409 };
   return { ok: true, message: premierPublic(maj) };
 }
 
@@ -566,7 +577,16 @@ async function deleteMessage(slug, msgId, { authorToken, control }) {
   let byPresenter = false;
   if (!byAuthor && control) { const pres = await getPresentation(slug); byPresenter = !!(pres && tokenMatches(control, pres.control_hash)); }
   if (!byAuthor && !byPresenter) return { ok: false, status: 403 };
-  const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { deleted: true, body: "", reactions: {}, attachment: null } });
+  // ⚠️ Par l'AUTEUR : son hash dans la condition — l'écriture n'exige que ce qu'elle a vérifié.
+  // Par le PRÉSENTATEUR : le jeton vit dans une AUTRE table, aucun filtre PostgREST ne peut le
+  // porter — la fenêtre résiduelle (un ex-présentateur modère dans la seconde où on lui reprend
+  // la main) est assumée : elle ne rend qu'un droit qu'il avait légitimement l'instant d'avant.
+  // `deleted=eq.false` partout : supprimer deux fois est IDEMPOTENT — zéro ligne veut dire
+  // « déjà supprimé », et c'est l'état que l'appelant voulait. `reply_text`/`reply_name` partent
+  // aussi : un message supprimé ne doit pas continuer de citer ce qu'il citait.
+  const cond = byAuthor ? `&author_hash=eq.${sha(authorToken)}` : "";
+  const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}${cond}&deleted=eq.false&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { deleted: true, body: "", reactions: {}, attachment: null, reply_text: null, reply_name: null } });
+  if (!Array.isArray(maj) || !maj.length) return { ok: true, deja: true };
   return { ok: true, message: premierPublic(maj) };
 }
 
@@ -612,7 +632,7 @@ async function toggleReaction(slug, msgId, emoji, reactor, etat) {
   // ⚠️ LE RANG N'EST DEMANDÉ QUE LÀ OÙ IL EXISTE — sélectionner une colonne absente fait échouer
   // la LECTURE entière chez un hôte non migré, et ce serait les réactions qu'on casserait.
   const ordonne = await require("./schema").attendue("reactionsOrdonnees");
-  const rows = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&select=${ordonne ? "reactions,reactions_seq" : "reactions"}&limit=1`);
+  const rows = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&select=${ordonne ? "reactions,reactions_seq,deleted" : "reactions,deleted"}&limit=1`);
   // ⚠️ LE NOM DE PROPRIÉTÉ ÉCRIT ICI VIENT DU CLIENT — et la garde posée en 0.1.2 ne couvrait que
   // les LECTURES. `Object.hasOwn` empêchait de LIRE `constructor` ; rien n'empêchait de l'ÉCRIRE.
   //
@@ -635,6 +655,10 @@ async function toggleReaction(slug, msgId, emoji, reactor, etat) {
   // nombre de concurrents réels, pas par la malchance.
   let lu = rows;
   for (let essai = 0; essai < 4; essai += 1) {
+    // ⚠️ Un message supprimé PENDANT la boucle : on s'arrête — réagir à un message effacé le
+    // ferait revivre dans le tableau des réactions. Et `deleted=eq.false` dans la condition
+    // d'écriture ferme la course entre cette lecture et le PATCH.
+    if (Array.isArray(lu) && lu[0] && lu[0].deleted) return { ok: false, status: 404 };
     const brut = (Array.isArray(lu) && lu[0] && lu[0].reactions && typeof lu[0].reactions === "object" && !Array.isArray(lu[0].reactions)) ? lu[0].reactions : {};
     const rang = ordonne ? Math.trunc(Number((Array.isArray(lu) && lu[0] && lu[0].reactions_seq) || 0)) : 0;
     // Objet NU déclaré tel quel : la garde statique des écritures indexées reconnaît la
@@ -647,11 +671,14 @@ async function toggleReaction(slug, msgId, emoji, reactor, etat) {
     if (veut && i < 0) arr.push(who);
     if (!veut && i >= 0) arr.splice(i, 1);
     if (arr.length) cur[e] = arr; else delete cur[e];
-    const condition = ordonne ? `&reactions_seq=eq.${rang}` : "";
+    const condition = (ordonne ? `&reactions_seq=eq.${rang}` : "") + "&deleted=eq.false";
     const maj = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}${condition}&select=*`, { method: "PATCH", headers: { Prefer: "return=representation" }, body: { reactions: cur, ...(ordonne ? { reactions_seq: rang + 1 } : {}) } });
-    if (!ordonne || (Array.isArray(maj) && maj.length)) return { ok: true, message: premierPublic(maj) };
+    if (Array.isArray(maj) && maj.length) return { ok: true, message: premierPublic(maj) };
+    // Hôte non migré (pas de rang) : zéro ligne ne peut venir que de `deleted` — le message est
+    // parti pendant qu'on écrivait. Pas de rejeu qui le ferait revivre.
+    if (!ordonne) return { ok: false, status: 404 };
     // Rang dépassé : quelqu'un a écrit entre notre lecture et notre écriture. On relit, on rejoue.
-    lu = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&select=reactions,reactions_seq&limit=1`);
+    lu = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&select=reactions,reactions_seq,deleted&limit=1`);
   }
   // Quatre tours perdus : plus de concurrents que de raisons d'attendre. Un refus net vaut mieux
   // qu'une écriture qui écraserait ce que les gagnants viennent de poser.
@@ -794,7 +821,12 @@ async function switchPresentationDoc(slug, email, isAdmin, { fileUrl, fileName,
   if (!row) return { ok: false, status: 404 };
   if (estClose(row)) return { ok: false, status: 409, error: "ended" };
   if (!isAdmin && (!row.owner_email || row.owner_email !== lc(email))) return { ok: false, status: 403 };
-  const ecrit = await ecrireSiEncoreVrai(`doc_presentations?slug=eq.${enc(slug)}&active=eq.true`, {
+  // ⚠️ LE PROPRIÉTAIRE VÉRIFIÉ VOYAGE DANS LA CONDITION — un transfert entre la lecture et
+  // l'écriture donnait la présentation à Bob, et la requête retardée d'Alice changeait ENCORE le
+  // document de Bob. Même classe que reprise/clôture/transfert (#130), deux survivants trouvés par
+  // le cinquième audit. L'admin, lui, écrit sur la présentation active telle quelle : modération.
+  const ecrit = await ecrireSiEncoreVrai(
+    `doc_presentations?slug=eq.${enc(slug)}&active=eq.true${isAdmin ? "" : `&owner_email=eq.${enc(row.owner_email)}`}`, {
     file_url: String(fileUrl), file_name: fileName || null, doc_title: docTitle || null, doc_id: docId ? String(docId) : null,
     content: null, current_page: 1, active: true, last_seen: new Date().toISOString(), updated_at: new Date().toISOString(),
   });
@@ -859,10 +891,12 @@ async function setPresentationContent(slug, email, isAdmin, content, control) {
   // droit en fermant une porte. Le PILOTE écrit tant que son jeton vaut : une carte affichée
   // pendant que le portable dormait doit encore partir, comme une page. Le PROPRIÉTAIRE, lui,
   // n'écrit que sur une présentation vivante : c'est déjà ce que le contrôle au-dessus exige.
+  // ⚠️ Et le PROPRIÉTAIRE (non-admin) voyage dans la condition, comme partout : sans ça, sa
+  // requête retardée écrivait encore sur la présentation qu'un transfert venait de donner.
   const ecrit = await ecrireSiEncoreVrai(
     pilote
       ? `doc_presentations?slug=eq.${enc(slug)}&control_hash=eq.${sha(control)}`
-      : `doc_presentations?slug=eq.${enc(slug)}&active=eq.true`,
+      : `doc_presentations?slug=eq.${enc(slug)}&active=eq.true${isAdmin ? "" : `&owner_email=eq.${enc(row.owner_email)}`}`,
     { content: sanitizeContent(content), active: true, last_seen: new Date().toISOString(), updated_at: new Date().toISOString() },
   );
   if (!ecrit) return { ok: false, status: 409, error: "ended" };

package/supabase/init.sql

@@ -269,6 +269,9 @@ begin
                           then now() + make_interval(secs => p_window_seconds)
                           else l.expires_at end
   returning l.count into v_count;
+
+  -- Le refus est décidé ICI, sur la valeur qu'on vient d'écrire : le client n'a rien à recalculer,
+  -- donc rien à recalculer sur une valeur déjà périmée.
   return query select (v_count <= p_max), v_count;
 end;
 $$;
@@ -344,8 +347,11 @@ alter table public.doc_bot_sessions                  enable row level security;
 -- ── Le scellé de l'archive ─────────────────────────────────────────────────────────────────────
 -- Sept chemins d'écriture vérifient l'archive PUIS écrivent — dans une AUTRE table que celle qui
 -- porte l'état. Aucun filtre PostgREST ne peut fermer cette fenêtre : l'arbitre est la base.
--- `FOR KEY SHARE` bloque une clôture concurrente jusqu'au commit de l'écriture — c'est lui qui
--- rend le refus atomique, pas le simple test.
+-- ⚠️ `FOR SHARE`, PAS `FOR KEY SHARE` — la clôture modifie des colonnes NON-CLÉS, son UPDATE prend
+-- FOR NO KEY UPDATE, que KEY SHARE ne bloque pas. La 0007 a porté ce verrou trop faible pendant
+-- une version, avec un commentaire qui affirmait l'atomicité (corrigé par la 0010, constat du
+-- cinquième audit — VU au banc à deux transactions de la forge : le message entrait dans
+-- l'archive). C'est FOR SHARE qui rend le refus atomique.
 create or replace function public.player_archive_scellee()
 returns trigger
 language plpgsql
@@ -357,7 +363,7 @@ begin
   select p.active, p.control_hash into v_active, v_control
     from public.doc_presentations p
     where p.slug = new.slug
-    for key share;
+    for share;
   -- Pas de présentation : rien à sceller (chat d'un lien sans session live, données historiques).
   if not found then return new; end if;
   if v_active = false and v_control is null then

package/supabase/migrations/0007-archive-scellee.sql

@@ -9,10 +9,11 @@
 -- doc_presentation_attendees, la condition vit dans doc_presentations — une AUTRE table. Sans
 -- transaction ni RPC côté player, l'arbitre ne peut être que la base elle-même. D'où ce trigger.
 --
--- ⚠️ `FOR KEY SHARE` EST CE QUI REND LE REFUS ATOMIQUE, pas le simple test. Sans lui, une clôture
--- peut se COMMITTER entre la vérification du trigger et le commit de l'écriture — la fenêtre
--- rétrécit mais survit. Le verrou de ligne bloque la clôture concurrente jusqu'au commit de
--- l'écriture : l'ordre devient réel, plus probable.
+-- ⚠️ LE VERROU CI-DESSOUS EST TROP FAIBLE, ET LA 0010 LE REMPLACE. Cette migration affirmait que
+-- FOR KEY SHARE rendait le refus atomique : faux — la clôture modifie des colonnes non-clés, son
+-- UPDATE prend FOR NO KEY UPDATE, compatible avec KEY SHARE. La fenêtre prétendue fermée restait
+-- ouverte (cinquième audit, VU au banc à deux transactions). Le fichier reste tel qu'appliqué par
+-- les bases historiques ; la correction est une migration de plus, comme toujours.
 --
 -- Sans lui : rien ne casse — les sept chemins gardent leur vérification préalable, et la fenêtre
 -- de course reste ce qu'elle était avant cette migration. Le trigger est le scellé, pas la porte.

package/supabase/migrations/0010-archive-verrou-share.sql

@@ -0,0 +1,38 @@
+-- LE SCELLÉ DE L'ARCHIVE PRÉTENDAIT UNE ATOMICITÉ QUE SON VERROU NE FOURNISSAIT PAS.
+--
+-- La 0007 verrouillait la présentation en FOR KEY SHARE — et son commentaire affirmait que c'était
+-- « ce qui rend le refus atomique ». Faux : la clôture modifie `active` et `control_hash`, des
+-- colonnes NON-CLÉS, donc son UPDATE prend FOR NO KEY UPDATE — que KEY SHARE ne bloque PAS
+-- (matrice des verrous PostgreSQL : KEY SHARE ne conflit qu'avec FOR UPDATE). Le trigger vérifiait
+-- « ouverte », la clôture se committait sous lui, le message entrait dans l'archive : la fenêtre
+-- que 0007 prétendait fermer était ouverte. Constat P1-1 du cinquième audit — VU au banc de la
+-- forge : deux transactions psql, l'écriture n'attendait pas la clôture.
+--
+-- FOR SHARE, lui, conflit avec FOR NO KEY UPDATE : une clôture non committée fait ATTENDRE
+-- l'écriture (qui voit ensuite l'archive et est refusée) ; une écriture en cours fait attendre la
+-- clôture. Le coût est nul en pratique : plusieurs écritures partagent le verrou entre elles,
+-- seule la clôture entre en conflit — précisément l'objectif.
+--
+-- Sans lui : le scellé garde sa valeur de refus (une écriture APRÈS la clôture committée est
+-- toujours refusée) — seule la fenêtre concurrente reste ouverte, comme entre 0007 et 0010.
+create or replace function public.player_archive_scellee()
+returns trigger
+language plpgsql
+as $$
+declare
+  v_active boolean;
+  v_control text;
+begin
+  select p.active, p.control_hash into v_active, v_control
+    from public.doc_presentations p
+    where p.slug = new.slug
+    for share;
+  -- Pas de présentation : rien à sceller (chat d'un lien sans session live, données historiques).
+  if not found then return new; end if;
+  if v_active = false and v_control is null then
+    raise exception 'presentation archivee : ecriture refusee'
+      using errcode = 'P0001', hint = 'l''archive est en lecture seule';
+  end if;
+  return new;
+end
+$$;