discovery-media-player 0.1.95 → 0.1.97

package/context/standalone.js

@@ -511,6 +511,48 @@ function createStandaloneContext(env = process.env) {
         } catch { return null; }
       },
 
+      /**
+       * JETON DE PRÉSENCE (P1c étape 2) — lie `slug + key + exp`, signé par l'hôte.
+       *
+       * ⚠️ CE QU'IL PROUVE, ET CE QU'IL NE PROUVE PAS. Il prouve que l'hôte a ÉMIS ce couple
+       * (slug, key) : un battement qui le porte prouve donc que son porteur détient la clé que l'hôte
+       * lui a donnée — assez pour empêcher un TIERS d'écraser une présence déjà enregistrée. Il ne
+       * prouve PAS qu'il y a une vraie personne derrière (un visiteur peut demander plusieurs jetons) :
+       * le plafond de création de l'étape 1 reste nécessaire.
+       *
+       * ⚠️ SECRET PAR INSTANCE, PAS PAR MARQUE. `PLAYER_PRESENCE_SECRET` est partagé par toutes les
+       * marques d'une même instance : un jeton émis sur l'une valide sur l'autre. Inoffensif — la vraie
+       * portée est le `slug`, qui est DANS la charge signée et vérifié à l'usage. Même comparaison à
+       * temps constant et même `exp` obligatoire que le jeton interne.
+       */
+      signPresenceToken(slug, key, ttlSeconds) {
+        const secret = String(env.PLAYER_PRESENCE_SECRET || "");
+        if (!secret || !slug || !key) return "";
+        const exp = Math.floor(Date.now() / 1000) + Math.max(60, Math.trunc(Number(ttlSeconds)) || 3600);
+        const corps = Buffer.from(JSON.stringify({ slug: String(slug), key: String(key), exp }), "utf8").toString("base64url");
+        const sig = crypto.createHmac("sha256", secret).update(corps).digest("base64url");
+        return `${corps}.${sig}`;
+      },
+      verifyPresenceToken(jeton) {
+        const secret = String(env.PLAYER_PRESENCE_SECRET || "");
+        const brut = String(jeton || "");
+        if (!secret || !brut) return null;
+        const sep = brut.lastIndexOf(".");
+        if (sep <= 0) return null;
+        const corps = brut.slice(0, sep);
+        const signature = brut.slice(sep + 1);
+        try {
+          const attendue = crypto.createHmac("sha256", secret).update(corps).digest("base64url");
+          const a = Buffer.from(attendue, "utf8"); const b = Buffer.from(signature, "utf8");
+          if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) return null;
+          const d = JSON.parse(Buffer.from(corps, "base64url").toString("utf8"));
+          if (!d || typeof d !== "object") return null;
+          if (!Number.isFinite(d.exp) || d.exp * 1000 < Date.now()) return null;
+          if (!d.slug || !d.key) return null;
+          return { slug: String(d.slug), key: String(d.key) };
+        } catch { return null; }
+      },
+
       // ⚠️ Le rôle vient d'`app_metadata`, JAMAIS d'`user_metadata` : ce dernier est modifiable par
       // l'utilisateur lui-même. S'y fier revient à laisser chacun choisir ses droits.
       roleOf: (user) => String(((user || {}).app_metadata || {}).role || "").trim().toLowerCase(),
@@ -631,6 +673,9 @@ function createStandaloneContext(env = process.env) {
       hostMail: !!String(env.PLAYER_HOST_MAIL_URL || "").trim(),
       // Porte fermée : sans jeton de l'hôte, aucune session interne n'est écrite.
       internalStrict: String(env.PLAYER_INTERNAL_STRICT || "") === "1",
+      // Une fois les bundles déployés des deux côtés ET `presence.sansJeton` retombé à zéro : un
+      // battement sans jeton de présence valide cesse d'être enregistré. Off par défaut (transition).
+      presenceStrict: String(env.PLAYER_PRESENCE_STRICT || "") === "1",
     },
   };
 }

package/docs/RETENTION.md

@@ -93,6 +93,7 @@ Une présentation **inactive** (terminée ou abandonnée) est une archive : **pu
 | `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.creator_ip_hash` | **empreinte tronquée** de l'IP qui a créé la ligne (jamais l'IP en clair) — sert au plafond de création anonyme (migration 0015) | purgée avec la présentation |
+| `doc_presentation_attendees.last_token_at` / `doc_presentation_attendees.last_no_token_at` | horodatage du dernier battement avec / sans jeton de présence — sert au compteur de transition (migration 0017), aucune donnée d'identité | purgés avec la présentation |
 | `doc_presentation_attendees.pages` | pages vues par le participant | idem |
 
 ## Sessions d'agent (`doc_bot_sessions`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.95",
+  "version": "0.1.97",
   "description": "Self-hosted document viewer: per-recipient tracked links, reading analytics, live presentation. The core knows nothing about the application hosting it — everything it borrows arrives through an injected context.",
   "keywords": [
     "pdf-viewer",

package/server/handler.js

@@ -595,6 +595,10 @@ async function handler(req, res) {
         // MESURABLE : un cockpit peut refuser une instance non stricte, au lieu de le découvrir en
         // lisant un journal. Demandé par le second hôte (cinquième audit, P1-4).
         internalStrict: !!(PLAYER.config && PLAYER.config.internalStrict),
+        // ⚠️ La porte du jeton de présence (P1c étape 2) est-elle fermée ? Même raison
+        // qu'internalStrict : un cockpit doit voir l'état des DEUX hôtes sans lire un journal — c'est
+        // ce booléen, lu avec `presence: { avecJeton, sansJeton }` de la carte, qui dit quand fermer.
+        presenceStrict: !!(PLAYER.config && PLAYER.config.presenceStrict),
         // ⚠️ LE BALAYAGE DE RÉTENTION EST-IL ARMÉ ? La capacité `retention` dit que l'instance PEUT
         // purger ; ce booléen dit si le balayage automatique TOURNE (`config.retention.balayage`).
         // Sans lui, une instance armée est indiscernable d'une instance éteinte — et une purge qui

package/server/presentations.js

@@ -768,7 +768,7 @@ let _avertRpcPresence = false;
 // D'OPTIONS, pas dans un slot positionnel : la ranger en 2e position (ce que faisait 0.1.84) déplaçait
 // le vrai paramètre et faisait jeter `Cannot destructure property 'key'` sur un appel à deux arguments
 // (P1a audit CODEX 5.6). `participant || {}` : un appel sans participant tombe en 400, jamais en throw.
-async function recordAttendance(slug, participant, { presentation = null, ipHash = null, anonCap = null } = {}) {
+async function recordAttendance(slug, participant, { presentation = null, ipHash = null, anonCap = null, hasToken = null } = {}) {
   const { key, name, email, avatar, isMember, isPresenter } = participant || {};
   if (!slug || !key) return { ok: false, status: 400 };
   // La route vient DÉJÀ de charger la présentation (contrôle présentateur) : elle la fournit dans les
@@ -795,6 +795,10 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
         p_name: (name || "").slice(0, 120), p_avatar: (avatar || "").slice(0, 600),
         p_is_member: !!isMember, p_is_presenter: !!isPresenter,
         p_max_gap_ms: ATTEND_MAX_GAP_MS, p_anon_cap: capAnon,
+        // Transition du jeton (0017) : true → last_token_at, false → last_no_token_at, null → ni l'un ni
+        // l'autre. La RPC 11-args (p_has_token DEFAULT null) accepte l'appel même sans la 0017 côté code
+        // ancien ; sans la 0017 côté base, la 11-args n'existe pas → on tombe dans le repli ci-dessous.
+        p_has_token: hasToken == null ? null : !!hasToken,
       },
     });
     const ligne = Array.isArray(r) ? r[0] : r;

package/server/routes-direct.js

@@ -102,7 +102,30 @@ async function traiter(req, res, body, _slug) {
           const anonCap = (PLAYER.config && Number(PLAYER.config.presenceAnonCap) > 0)
             ? Math.trunc(Number(PLAYER.config.presenceAnonCap))
             : Math.ceil(ATTENDEES_PER_EGRESS * 1.3);
-          const r = await recordAttendance(String(body.slug || ""), {
+          // ⚠️ JETON DE PRÉSENCE (P1c étape 2). Pour un ANONYME, la clé de sa ligne ne vient plus du
+          // corps quand il porte un jeton VALIDE : elle vient du jeton PROUVÉ (que l'hôte a émis pour
+          // lui), donc un tiers ne peut plus poster sa clé pour écraser sa présence. `wantToken` =
+          // premier battement d'un client moderne (pas encore de jeton) — le distinguer d'un client
+          // legacy est ce qui permet à `sansJeton` de retomber à zéro. Un MEMBRE est prouvé par son JWT.
+          const slug = String(body.slug || "");
+          const jetonEntrant = (typeof PLAYER.identity.verifyPresenceToken === "function")
+            ? PLAYER.identity.verifyPresenceToken(String(body.pt || "")) : null;
+          const jetonValide = !!(jetonEntrant && jetonEntrant.slug === slug && jetonEntrant.key);
+          const bootstrap = !profil && !jetonValide && String(body.wantToken || "") === "1";
+          const cleAnon = jetonValide ? String(jetonEntrant.key) : cleAnonyme(body.key);
+          // Le compteur de transition : true = moderne/prouvé (membre, jeton, ou bootstrap moderne) ;
+          // false = legacy (anonyme, ni jeton ni wantToken). Deux champs distincts en base (0017).
+          const hasToken = !!(profil || jetonValide || bootstrap);
+          // ⚠️ PORTE STRICTE : une fois la transition finie (sansJeton===0) et PLAYER_PRESENCE_STRICT
+          // posé, un battement LEGACY (anonyme, sans jeton ni bootstrap) n'est plus enregistré. Off par
+          // défaut → aucun effet pendant la transition. ⚠️ RÉSIDU CONNU (à durcir en suivant) : un
+          // bootstrap `wantToken` portant la clé d'un anonyme EXISTANT pourrait l'écraser sous strict —
+          // exploitabilité faible (l'attaquant doit connaître un uid anonyme aléatoire, jamais exposé) ;
+          // le fermer proprement demande à la RPC de refuser un bootstrap sur une clé déjà existante.
+          if (PLAYER.config && PLAYER.config.presenceStrict && !profil && !jetonValide && !bootstrap) {
+            return jp(403, { ok: false, error: "presence-token" });
+          }
+          const r = await recordAttendance(slug, {
             // ⚠️ MINUSCULÉE, ET CE DÉTAIL EST UNE LIGNE DE PRÉSENCE. La clé cliente que 0.1.42 a
             // remplacée l'était (`me.email.toLowerCase()`) ; la clé dérivée ne l'était pas, et la
             // ligne se retrouve par `attendee_key=eq.` — une correspondance EXACTE. Un hôte dont
@@ -113,13 +136,22 @@ async function traiter(req, res, body, _slug) {
             // Sans effet là où les adresses sont déjà normalisées — c'est le cas des deux hôtes
             // actuels, et c'est pour ça que rien ne l'aurait signalé. Un contrat ouvert ne se
             // repose pas sur ce que ses deux premiers hôtes font.
-            key: profil ? lcMembre(profil.email) : cleAnonyme(body.key),
+            key: profil ? lcMembre(profil.email) : cleAnon,
             name: (profil && profil.name) || body.name,
             email: profil ? profil.email : body.email,
             avatar: (profil && profil.avatar) || body.avatar,
             isMember: !!profil, isPresenter: estPresentateur,
-          }, { presentation: pres, ipHash, anonCap });
-          return jp(r.ok ? 200 : (r.status || 400), r);
+          }, { presentation: pres, ipHash, anonCap, hasToken });
+          // On ÉMET (ou ré-émet) un jeton pour l'anonyme dont l'écriture a réussi : le client le garde
+          // et le renvoie aux battements suivants. `exp` court (6 h), ré-émis à chaque battement — pas
+          // de table anti-rejeu (le scellé d'archive et l'exp bornent déjà le rejeu, cf. 0007). Un
+          // membre n'en a pas besoin (son JWT le prouve). Sans PLAYER_PRESENCE_SECRET, `signPresenceToken`
+          // rend "" → aucun champ `pt`, le client reste en mode legacy. Rien ne casse.
+          let pt = "";
+          if (!profil && r.ok && typeof PLAYER.identity.signPresenceToken === "function") {
+            pt = PLAYER.identity.signPresenceToken(slug, cleAnon, 6 * 3600);
+          }
+          return jp(r.ok ? 200 : (r.status || 400), pt ? { ...r, pt } : r);
         } catch { return jp(500, { ok: false }); }
       }
       // Gestion des présentations (membre AUTHENTIFIÉ requis) : liste / reprise / transfert / stats / historique doc.

package/server/schema.js

@@ -77,6 +77,15 @@ const ATTENDUES = {
     migration: "supabase/migrations/0016-chat-differentiel.sql",
     fonction: "relire le chat en différentiel (mod_seq > curseur) au lieu des 300 derniers à chaque signal",
   },
+  // Jeton de présence (P1c étape 2). `last_token_at` est sondée AVANT d'écrire les colonnes de
+  // transition et de servir le compteur `presence`. `last_no_token_at` voyage avec elle dans 0017 (elle
+  // est donc exemptée de sonde séparée, cf. NON_SONDEES du test carteSchemaMigrations). Absentes → on
+  // n'écrit pas les colonnes et le compteur n'apparaît pas ; la présence continue de fonctionner.
+  jetonPresence: {
+    table: "doc_presentation_attendees", colonne: "last_token_at",
+    migration: "supabase/migrations/0017-jeton-presence.sql",
+    fonction: "mesurer la transition du jeton de présence (avecJeton / sansJeton) pour savoir quand fermer",
+  },
 };
 
 /**
@@ -305,6 +314,7 @@ async function vraimentSonderTout() {
   for (const nom of Object.keys(ATTENDUES)) await attendue(nom);
   const etat = etatDuSchema();
   await ajouterSansRang(etat);
+  await ajouterPresence(etat);
   return etat;
 }
 
@@ -359,6 +369,35 @@ async function ajouterSansRang(etat) {
   } catch { /* best-effort : un compteur absent vaut mieux qu'une carte en échec */ }
 }
 
+/**
+ * ⚠️ COMPTEUR DE TRANSITION DU JETON DE PRÉSENCE (P1c étape 2). `presence: { avecJeton, sansJeton }`
+ * sur 24 h : `sansJeton === 0` ⇒ plus aucun client legacy ne bat → on peut poser PLAYER_PRESENCE_STRICT.
+ * Sans ce compteur, poser le drapeau reviendrait à fermer la porte sans regarder qui est derrière.
+ *
+ * ⚠️ LES DEUX ENSEMBLES SE RECOUVRENT VOLONTAIREMENT. Un participant qui a envoyé les DEUX sortes de
+ * battements dans la fenêtre (deux onglets, l'un en cache legacy, l'autre à jour) compte dans les DEUX
+ * — c'est le cœur du correctif à deux champs. Donc `avecJeton + sansJeton ≠ nombre de participants` :
+ * quelqu'un qui « corrigerait » l'apparente incohérence en rendant les deux exclusifs ferait revenir le
+ * défaut d'origine (un seul battement moderne effacerait la trace legacy). Le critère est en ANY :
+ * `sansJeton` = « a battu sans jeton dans les 24 h », vrai quoi qu'aient fait ses autres battements.
+ *
+ * Même patron borné-ordonné-parlant que `sansRang`, et pour les mêmes raisons — `doc_presentation_attendees`
+ * est la plus grosse table et la seule écrite pendant qu'on la lit.
+ */
+async function ajouterPresence(etat) {
+  const r = reponses.get("doc_presentation_attendees.last_token_at");
+  if (!r || !r.present) return;
+  try {
+    const depuis = new Date(Date.now() - 24 * 3600 * 1000).toISOString();
+    const bornee = `&order=slug.asc&limit=${PLAFOND_SANS_RANG}`;
+    const avec = await PLAYER.db.request(`doc_presentation_attendees?last_token_at=gt.${encodeURIComponent(depuis)}&select=slug${bornee}`);
+    const sans = await PLAYER.db.request(`doc_presentation_attendees?last_no_token_at=gt.${encodeURIComponent(depuis)}&select=slug${bornee}`);
+    const nAvec = Array.isArray(avec) ? avec.length : 0;
+    const nSans = Array.isArray(sans) ? sans.length : 0;
+    etat.presence = { avecJeton: nAvec, sansJeton: nSans, tronque: nAvec >= PLAFOND_SANS_RANG || nSans >= PLAFOND_SANS_RANG };
+  } catch { /* best-effort */ }
+}
+
 /** La réponse, retenue pour qui la demandera — sans repasser par la base. */
 function noter(cle, present, migration) {
   const a = Object.values(ATTENDUES).find((x) => `${x.table}.${x.colonne}` === cle);

package/supabase/init.sql

@@ -267,6 +267,10 @@ create table if not exists public.doc_presentation_attendees (
   -- Empreinte (jamais l'IP en clair) de l'appelant qui a CRÉÉ la ligne — plafond de création anonyme
   -- par (slug, empreinte). Cf. migration 0015. Nullable : les lignes d'avant ne la portent pas.
   creator_ip_hash text,
+  -- Transition du jeton de présence (migration 0017) : dernier battement AVEC / SANS jeton valide.
+  -- Deux champs, pas un — cf. 0017 : la mesure est en max, la décision en any.
+  last_token_at    timestamptz,
+  last_no_token_at timestamptz,
   primary key (slug, attendee_key)
 );
 create index if not exists doc_presentation_attendees_slug_idx on public.doc_presentation_attendees (slug);
@@ -275,6 +279,10 @@ create index if not exists doc_presentation_attendees_slug_idx on public.doc_pre
 -- `creator_ip_hash` n'existerait qu'au rattrapage de fin de fichier, trop tard pour cet index.
 alter table public.doc_presentation_attendees
   add column if not exists creator_ip_hash text;
+alter table public.doc_presentation_attendees
+  add column if not exists last_token_at    timestamptz;
+alter table public.doc_presentation_attendees
+  add column if not exists last_no_token_at timestamptz;
 -- Compter les créations anonymes par (slug, empreinte) sans scanner toute la table. Cf. migration 0015.
 create index if not exists idx_attendees_slug_creator
   on public.doc_presentation_attendees (slug, creator_ip_hash)
@@ -389,7 +397,8 @@ create or replace function public.player_attendance_bump(
   p_is_member    boolean,
   p_is_presenter boolean,
   p_max_gap_ms   integer,
-  p_anon_cap     integer
+  p_anon_cap     integer,
+  p_has_token    boolean default null
 )
 returns table (ok boolean, created boolean, capped boolean)
 language plpgsql
@@ -401,18 +410,12 @@ declare
   v_count  integer;
   v_page   integer := greatest(1, coalesce(p_page, 1));
 begin
-  -- Chemin rapide : la ligne existe déjà → c'est une ACTUALISATION, jamais soumise au plafond.
   select true into v_exists
     from public.doc_presentation_attendees
     where slug = p_slug and attendee_key = p_key;
 
-  -- Création d'une ligne ANONYME : on sérialise par (slug, ip) et on compte sous le verrou, pour que
-  -- deux créations concurrentes ne franchissent pas le plafond ensemble. Membres et présentateur en
-  -- sont exemptés (leur identité est prouvée, ils ne gonflent pas de faux participants).
   if not coalesce(v_exists, false) and not p_is_member and not p_is_presenter then
     perform pg_advisory_xact_lock(hashtextextended(p_slug || '|' || coalesce(p_ip_hash, ''), 0));
-    -- Re-lire sous le verrou : la ligne a pu naître entre la première lecture et ici (même clé,
-    -- deux onglets). Si elle existe désormais, ce n'est plus une création → pas de plafond.
     select true into v_exists
       from public.doc_presentation_attendees
       where slug = p_slug and attendee_key = p_key;
@@ -423,21 +426,20 @@ begin
           and creator_ip_hash is not distinct from p_ip_hash
           and is_member = false and is_presenter = false;
       if v_count >= p_anon_cap then
-        return query select false, false, true;   -- plafond atteint : on ne crée pas
+        return query select false, false, true;
         return;
       end if;
     end if;
   end if;
 
-  -- L'écriture, en UN geste, pour la création comme pour l'actualisation. `last_seen` strictement
-  -- croissant ; le temps ajouté est le trou depuis le dernier battement, ignoré au-delà de MAX_GAP
-  -- (un onglet resté ouvert ne gonfle pas la présence) ; la page vue rejoint l'ensemble sans doublon.
   insert into public.doc_presentation_attendees as l
     (slug, attendee_key, name, email, avatar, is_member, is_presenter,
-     first_seen, last_seen, total_ms, pages, creator_ip_hash)
+     first_seen, last_seen, total_ms, pages, creator_ip_hash, last_token_at, last_no_token_at)
   values
     (p_slug, p_key, nullif(p_name, ''), null, nullif(p_avatar, ''), p_is_member, p_is_presenter,
-     now(), now(), 0, jsonb_build_array(v_page), p_ip_hash)
+     now(), now(), 0, jsonb_build_array(v_page), p_ip_hash,
+     case when p_has_token is true then now() end,
+     case when p_has_token is false then now() end)
   on conflict (slug, attendee_key) do update
     set last_seen    = greatest(now(), l.last_seen + interval '1 millisecond'),
         total_ms     = l.total_ms + (
@@ -450,19 +452,21 @@ begin
         name         = coalesce(nullif(p_name, ''), l.name),
         avatar       = coalesce(nullif(p_avatar, ''), l.avatar),
         is_member    = p_is_member,
-        is_presenter = p_is_presenter;
+        is_presenter = p_is_presenter,
+        last_token_at    = case when p_has_token is true  then now() else l.last_token_at    end,
+        last_no_token_at = case when p_has_token is false then now() else l.last_no_token_at end;
 
   return query select true, not coalesce(v_exists, false), false;
 end;
 $$;
-revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) from public;
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean) from public;
 do $$
 declare
   r text;
 begin
   foreach r in array array['anon', 'authenticated'] loop
     if exists (select 1 from pg_roles where rolname = r) then
-      execute format('revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) from %I', r);
+      execute format('revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean) from %I', r);
     end if;
   end loop;
 end
@@ -470,7 +474,7 @@ $$;
 do $$
 begin
   if exists (select 1 from pg_roles where rolname = 'service_role') then
-    grant execute on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) to service_role;
+    grant execute on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean) to service_role;
   end if;
 end
 $$;

package/supabase/migrations/0017-jeton-presence.sql

@@ -0,0 +1,122 @@
+-- LA PRÉSENCE GARDE LA TRACE DE CE QUI EST PROUVÉ — POUR SAVOIR QUAND FERMER LA PORTE.
+--
+-- ⚠️ P1c étape 2 (jeton participant signé), incrément 2. Deux colonnes de transition sur la ligne de
+-- présence : `last_token_at` (dernier battement AVEC un jeton valide) et `last_no_token_at` (dernier
+-- battement SANS). Le compteur de la carte lira `presence: { avecJeton, sansJeton }` sur 24 h : quand
+-- `sansJeton` retombe à zéro, plus aucun client legacy ne bat, et on peut poser PLAYER_PRESENCE_STRICT.
+--
+-- ⚠️ DEUX CHAMPS, PAS UN — c'est le cœur du correctif (relevé 2e hôte). `last_token_at` seul est un
+-- champ de MAXIMUM : un seul battement moderne l'écrase et efface la trace des battements legacy du
+-- MÊME participant → `sansJeton` tomberait à zéro pendant que le legacy passe encore. La MESURE est en
+-- max, la DÉCISION est en ANY : il faut le second champ pour que « a-t-il battu sans jeton dans la
+-- fenêtre ? » reste vrai quoi qu'aient fait ses autres battements. Les deux ensembles se recouvrent
+-- volontairement (un participant qui a fait les deux compte dans les deux).
+--
+-- ⚠️ LA RPC CHANGE DE SIGNATURE SANS CASSER LE CONTRAT DE 0015. On DROP l'ancienne (10 args) et on crée
+-- la nouvelle avec un 11e paramètre `p_has_token boolean DEFAULT null` : un appel à 10 arguments de
+-- l'ANCIEN code se résout alors sur la nouvelle (le défaut remplit le 11e), sans surcharge ambiguë ni
+-- corps dupliqué. `p_has_token` : true → écrit `last_token_at` ; false → `last_no_token_at` ; null
+-- (ancien code) → ni l'un ni l'autre. Le reste du corps est IDENTIQUE à 0015.
+--
+-- ⚠️ Sans lui : le player sonde `last_token_at` (server/schema.js) ; absente, il n'écrit pas les
+--    colonnes de transition et le compteur `presence` n'apparaît pas — la présence continue de
+--    fonctionner. Additive ; le DROP+CREATE de la fonction est atomique dans la migration.
+
+alter table public.doc_presentation_attendees
+  add column if not exists last_token_at    timestamptz;
+alter table public.doc_presentation_attendees
+  add column if not exists last_no_token_at timestamptz;
+
+drop function if exists public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer);
+
+create or replace function public.player_attendance_bump(
+  p_slug         text,
+  p_key          text,
+  p_ip_hash      text,
+  p_page         integer,
+  p_name         text,
+  p_avatar       text,
+  p_is_member    boolean,
+  p_is_presenter boolean,
+  p_max_gap_ms   integer,
+  p_anon_cap     integer,
+  p_has_token    boolean default null
+)
+returns table (ok boolean, created boolean, capped boolean)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  v_exists boolean;
+  v_count  integer;
+  v_page   integer := greatest(1, coalesce(p_page, 1));
+begin
+  select true into v_exists
+    from public.doc_presentation_attendees
+    where slug = p_slug and attendee_key = p_key;
+
+  if not coalesce(v_exists, false) and not p_is_member and not p_is_presenter then
+    perform pg_advisory_xact_lock(hashtextextended(p_slug || '|' || coalesce(p_ip_hash, ''), 0));
+    select true into v_exists
+      from public.doc_presentation_attendees
+      where slug = p_slug and attendee_key = p_key;
+    if not coalesce(v_exists, false) then
+      select count(*) into v_count
+        from public.doc_presentation_attendees
+        where slug = p_slug
+          and creator_ip_hash is not distinct from p_ip_hash
+          and is_member = false and is_presenter = false;
+      if v_count >= p_anon_cap then
+        return query select false, false, true;
+        return;
+      end if;
+    end if;
+  end if;
+
+  insert into public.doc_presentation_attendees as l
+    (slug, attendee_key, name, email, avatar, is_member, is_presenter,
+     first_seen, last_seen, total_ms, pages, creator_ip_hash, last_token_at, last_no_token_at)
+  values
+    (p_slug, p_key, nullif(p_name, ''), null, nullif(p_avatar, ''), p_is_member, p_is_presenter,
+     now(), now(), 0, jsonb_build_array(v_page), p_ip_hash,
+     case when p_has_token is true then now() end,
+     case when p_has_token is false then now() end)
+  on conflict (slug, attendee_key) do update
+    set last_seen    = greatest(now(), l.last_seen + interval '1 millisecond'),
+        total_ms     = l.total_ms + (
+                         case
+                           when (extract(epoch from (greatest(now(), l.last_seen + interval '1 millisecond') - l.last_seen)) * 1000) <= p_max_gap_ms
+                           then (extract(epoch from (greatest(now(), l.last_seen + interval '1 millisecond') - l.last_seen)) * 1000)::bigint
+                           else 0
+                         end),
+        pages        = case when l.pages @> to_jsonb(v_page) then l.pages else l.pages || to_jsonb(v_page) end,
+        name         = coalesce(nullif(p_name, ''), l.name),
+        avatar       = coalesce(nullif(p_avatar, ''), l.avatar),
+        is_member    = p_is_member,
+        is_presenter = p_is_presenter,
+        last_token_at    = case when p_has_token is true  then now() else l.last_token_at    end,
+        last_no_token_at = case when p_has_token is false then now() else l.last_no_token_at end;
+
+  return query select true, not coalesce(v_exists, false), false;
+end;
+$$;
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean) from public;
+do $$
+declare
+  r text;
+begin
+  foreach r in array array['anon', 'authenticated'] loop
+    if exists (select 1 from pg_roles where rolname = r) then
+      execute format('revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean) from %I', r);
+    end if;
+  end loop;
+end
+$$;
+do $$
+begin
+  if exists (select 1 from pg_roles where rolname = 'service_role') then
+    grant execute on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean) to service_role;
+  end if;
+end
+$$;