npm - discovery-media-player - Versions diffs - 0.1.126 → 0.1.128 - Mend

discovery-media-player 0.1.126 → 0.1.128

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/docs/HOST-CONTRACT.md +22 -3
package/docs/RETENTION.md +123 -124
package/package.json +1 -1
package/server/handler.js +11 -0
package/server/presentations.js +131 -17
package/server/routes-direct.js +16 -5
package/server/schema.js +79 -6
package/supabase/init.sql +68 -14
package/supabase/migrations/0019-presence-lit-la-presentation.sql +181 -0

package/docs/HOST-CONTRACT.md CHANGED Viewed

@@ -38,6 +38,7 @@ need.
   "presenceStrict": true,
   "presenceJetons": true,
   "presenceDurcissement": "inconnu",
+  "presenceFusion": "inconnu",
   "retentionSweep": false,
   "hostShare": true,
   "hostMail": true,
@@ -73,6 +74,7 @@ The three `presence*` fields report what the host has **observed**, not what it
 | `presenceJetons` | measured — the host actually signed a throwaway token, so `PLAYER_PRESENCE_SECRET` works |
 | `presenceStrict` | **effective** — `PLAYER_PRESENCE_STRICT` is set *and* tokens can be issued. A closed door announced over an open one would be the worse failure |
 | `presenceDurcissement` | `actif` (a hardened call came back), `degrade` (migration 0018 is missing), `inconnu` (nothing attempted in this process — **not** a green light, and process-local: another instance may have seen otherwise) |
+| `presenceFusion` | `actif` (a heartbeat used the fused contract — one round trip instead of two), `degrade` (migration 0019 is missing: heartbeats cost 3 round trips instead of 2, nothing breaks), `inconnu` (no heartbeat served in this process). Same three states, same trap, same reading rule as the row above |
 ⚠️ **Before you upgrade, do not read `presenceDurcissement`.** It is a *report of execution*: on an
 instance where nothing is running it says `inconnu`, which means *nobody looked* — not *the migration
@@ -87,9 +89,26 @@ database, so it answers a global fact.
 | `absente` | 0018 is missing: apply it **before** setting `PLAYER_PRESENCE_STRICT`, or bootstraps will be refused with `503` |
 | `indetermine` | the question could not be asked — neither a yes nor a no |
-The probe writes nothing: it calls the function with `p_anon_cap = 0`, so a non-existent row exits
-through the *capped* branch and returns before the insert. A real-Postgres test asserts that no row
-appears. A host missing 0018 is also logged once an hour, so an idle instance still finds out.
+The same answer carries **`schema.fusionBase`**, for migration `0019`, with the same three values.
+Both come from **one** call in the normal case: `0019` succeeds `0018` and its argument set *contains*
+it, so a call the long contract accepts proves both at once. The short contract is only asked again
+when the long one is missing — i.e. exactly on the host that is behind and owes a precise answer.
+| `fusionBase` | meaning |
+|---|---|
+| `applique` | `0019` is in the database — a presence heartbeat costs **2** database round trips |
+| `absente` | `0019` is missing: **nothing breaks**, a heartbeat costs **3** round trips instead of 2 (about 30 ops/s instead of 20 for 250 attendees). Applying it needs no redeploy — the player picks it up within a minute |
+| `indetermine` | the question could not be asked — neither a yes nor a no |
+⚠️ Unlike `0018`, a missing `0019` is a **cost**, not a risk: read it when you are sizing an
+instance, not when you are deciding whether it is safe to run. A host missing it is also logged once
+an hour, with the exact figures, so an idle instance still finds out.
+The probe writes nothing, for **two independent reasons**: `p_page = null` on a slug that does not
+exist leaves through `0019`'s *introuvable* branch before the insert, and `p_anon_cap = 0` already
+left through the previous contract's *capped* branch. Two reasons rather than one, because a
+diagnostic probe is the worst place to discover a regression. A real-Postgres test asserts that no
+row appears. A host missing 0018 is also logged once an hour, so an idle instance still finds out.
 That parameter **is** the one part of this card that needs the database, and only when you ask for
 it. `verdict` is then one of:

package/docs/RETENTION.md CHANGED Viewed

@@ -1,145 +1,144 @@
-# 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).
+# Data retention
+This document is the **declared scope** of retention: every column of the schema whose *shape* can
+carry personal data has a policy here — *purged after N* or *kept because*. A CI guard enumerates
+the columns of the **live** schema (`information_schema`, never our memory of the file) and refuses
+any personal-shaped column missing from this page: data without a written policy cannot enter the
+schema without turning the build red.
+The verification contract has two halves, deliberately **independent** (no shared code — no scope
+function, no filter):
+1. the **purge** (`server/retention.js`) declares what it erased, count by count;
+2. the **census** (`supabase/recensement-retention.sql`, plain SQL) counts what remains inside the
+   claimed scope. The two numbers must contradict each other if either one lies.
+> ⚠️ **Proposed windows, to be confirmed by the operator.** The durations below are reasoned
+> defaults (analytics logs: 13 months, for year-on-year comparison; presentation archives: 12
+> months after the end). A host adjusts them through `config.retention` — **whole months in
+> [1, 120] only**. Any negative, zero, non-integer, `NaN`, `Infinity` or string value makes the
+> purge FAIL before the first `DELETE`, naming the offending key: a configuration mistake never
+> deletes anything. Bounds are computed in UTC and clamped to the last day of the target month
+> ("31 March − 1 month" = 28 February, not 3 March).
 >
-> ⚠️ **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.
+> ⚠️ **The automatic sweep is STRICTLY OPT-IN**: it runs only if the host writes
+> `config.retention.balayage: true`. A host consuming the standalone context as-is inherits all of
+> its capabilities by default — "nothing to wire up because nothing was unwired" — and a deletion is
+> a business decision: it acts only where an operator has written it down. The `retention.run`
+> action (trusted host or admin) stays available without opt-in: calling it IS the decision.
-## Journaux de lecture (population externe)
+## Reading logs (external audience)
-Finalité : statistiques de lecture d'un document envoyé. **Purge : 13 mois** après l'événement.
+Purpose: reading statistics for a document that was sent out. **Purge: 13 months** after the event.
-| colonne | contenu | sort |
+| column | contents | fate |
 |---|---|---|
-| `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 |
+| `commercial_doc_views.recipient_email` | who the read is attributed to | purged with the row, 13 months after `at` |
+| `commercial_doc_views.session_id` | correlates the views of one session | same |
+| `commercial_doc_views.ua` | browser (raw User-Agent) | same |
+| `commercial_doc_sessions.recipient_email` | session attribution | purged with the row, 13 months after `last_at` |
+| `commercial_doc_sessions.session_id` | session identifier | same |
+| `commercial_doc_sessions.ip` | **IP address in the clear** | same — the most sensitive datum in the schema |
+| `commercial_doc_sessions.ua` | raw User-Agent | same |
+| `commercial_doc_sessions.num_pages` / `commercial_doc_sessions.pages_time` | page-by-page reading behaviour | same |
-## Journaux de lecture (équipe interne)
+## Reading logs (internal team)
-Même finalité, population interne. **Purge : 13 mois** après `last_at`.
+Same purpose, internal audience. **Purge: 13 months** after `last_at`.
-| colonne | sort |
+| column | fate |
 |---|---|
-| `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 |
+| `commercial_doc_internal_sessions.user_email` / `commercial_doc_internal_sessions.user_name` | purged with the row |
+| `commercial_doc_internal_sessions.session_id` | same |
+| `commercial_doc_internal_sessions.num_pages` / `commercial_doc_internal_sessions.pages_time` | same |
-## Liens d'envoi (`commercial_doc_shares`)
+## Sending links (`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.
+A **live** link is a business record: its fields stay for as long as the distributed URL must keep
+working. A **revoked** link serves nobody: **purged 13 months after revocation** (aligned with the
+logs, which reference its slug). Revocation is **dated** by `commercial_doc_shares.revoked_at`
+(migration 0013); links revoked before that column existed were given the migration's date — their
+clock starts there, counting generously rather than inventing. Without the column, that particular
+purge stays silent (schema probe); the others still run.
-| colonne | contenu | sort |
+| column | contents | fate |
 |---|---|---|
-| `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 |
+| `commercial_doc_shares.recipient_email` | who may forward on re-share | kept while the link lives; row purged 13 months after revocation |
+| `commercial_doc_shares.attested_recipient_email` | who the host attests the link to | same |
+| `commercial_doc_shares.recipient_name` | recipient's name | same |
+| `commercial_doc_shares.created_by` | email of the salesperson who created it | same |
+| `commercial_doc_shares.file_name` | file name (may carry a person's name) | business data, purged with the row |
-## Présentations en direct
+## Live presentations
-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).
+An **inactive** presentation (finished or abandoned) is an archive: **purged 12 months after
+`updated_at`** — the presentation, its messages, its attendance records, and its attachments in the
+`present-attachments` bucket (if the host provides `storage.remove`, otherwise the limit is stated
+below).
-| colonne | contenu | sort |
+| column | contents | fate |
 |---|---|---|
-| `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.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). ⚠️ **Donnée PSEUDONYMISÉE, pas anonyme** : une IP hachée reste une donnée personnelle au sens du RGPD, et un SHA-256 non salé se recalcule intégralement sur l'espace IPv4. Depuis 0.1.114 l'empreinte est un HMAC salé par `PLAYER_IP_HASH_SECRET` (à défaut `PLAYER_PRESENCE_SECRET`, avec séparation de domaine) et liée au `slug`, ce qui empêche de corréler une même adresse d'une présentation à l'autre. Sans sel configuré, l'ancienne empreinte non salée subsiste. | 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`)
-Parcours guidé par l'agent : **purge 13 mois** après `last_at`.
-| colonne | sort |
+| `doc_presentations.presenter_name` / `doc_presentations.owner_name` | presenter's identity | purged with the row, 12 months after the end |
+| `doc_presentations.owner_email` / `doc_presentations.owner_user_id` | owner | same |
+| `doc_presentations.owner_avatar` | avatar URL | same |
+| `doc_presentations.control_hash` | fingerprint of the control token (not the token) | same |
+| `doc_presentations.content` | shared content (cards, media) | same |
+| `doc_presentations.file_name` | name of the presented file | same |
+| `doc_presentation_messages.author_name` / `doc_presentation_messages.author_email` / `doc_presentation_messages.author_avatar` | author's identity | purged with the presentation |
+| `doc_presentation_messages.author_hash` | fingerprint of the author token | same |
+| `doc_presentation_messages.body` | message body | same |
+| `doc_presentation_messages.reply_name` / `doc_presentation_messages.reply_text` | quotation of another message | same |
+| `doc_presentation_messages.attachment` | attachment URL | same — the bucket file included when `storage.remove` exists |
+| `doc_presentation_messages.client_key` | idempotency key for sending | same |
+| `doc_presentation_attendees.name` / `doc_presentation_attendees.email` / `doc_presentation_attendees.avatar` | attendee's identity | purged with the presentation |
+| `doc_presentation_attendees.attendee_key` | presence identifier | same |
+| `doc_presentation_attendees.creator_ip_hash` | **truncated fingerprint** of the IP that created the row (never the IP in the clear) — used for the anonymous-creation ceiling (migration 0015). ⚠️ **PSEUDONYMISED data, not anonymous**: a hashed IP remains personal data under the GDPR, and an unsalted SHA-256 can be recomputed exhaustively over the whole IPv4 space. Since 0.1.114 the fingerprint is an HMAC salted with `PLAYER_IP_HASH_SECRET` (failing that `PLAYER_PRESENCE_SECRET`, with domain separation) and bound to the `slug`, which prevents correlating one address across presentations. With no salt configured, the old unsalted fingerprint survives. | purged with the presentation |
+| `doc_presentation_attendees.last_token_at` / `doc_presentation_attendees.last_no_token_at` | timestamp of the last heartbeat with / without a presence token — feeds the transition counter (migration 0017), carries no identity | purged with the presentation |
+| `doc_presentation_attendees.pages` | pages the attendee viewed | same |
+## Agent sessions (`doc_bot_sessions`)
+Agent-guided walkthrough: **purged 13 months** after `last_at`.
+| column | fate |
 |---|---|
-| `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 |
+| `doc_bot_sessions.rating` / `doc_bot_sessions.rating_comment` | visitor's feedback — purged with the row |
+| `doc_bot_sessions.in_tokens` / `doc_bot_sessions.out_tokens` / `doc_bot_sessions.cache_tokens` | AI volume (not personal, but carried by the row) — purged with it |
-## Limites de débit (`player_rate_limits`)
+## Rate limits (`player_rate_limits`)
-| colonne | contenu | sort |
+| column | contents | fate |
 |---|---|---|
-| `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é.
-- **Le plafond des présentations est GLOBAL** : messages et présences partagent chacun un budget
-  `plafond` réparti sur toutes les présentations d'une exécution — pas un plafond par présentation
-  (sinon 500 × 5000 = 2,5 M de lignes possibles). La boucle s'arrête quand les budgets sont
-  épuisés, sans supprimer les présentations restantes.
-- **Le rapport dryRun est complet pour les présentations** : `messagesExaminees`,
-  `presencesExaminees` et `fichiersCandidats` disent ce que la VRAIE purge ferait — même parcours
-  de sélection, suppression no-op, `efface.* = 0`.
-- **La purge avance par LOTS bornés** (200 lignes, plafond 5000 par table et 500 présentations
-  par exécution) : elle sélectionne un lot d'identifiants, les supprime par `id=in.(…)`, et
-  recommence. Le rapport (`r.rapport`) porte, par table : `examinees`, `supprimees`, `tronque`
-  (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.
+| `player_rate_limits.key` | may contain an **IP in the clear** (`hshare:<ip>`) or an email | row purged as soon as `expires_at` has passed (opportunistically, on every pass) |
+## Limits stated rather than left unsaid
+- **Orphaned attachments**: purging the rows erases the bucket file only if the host context
+  provides `storage.remove` (an optional capability). Without it, the URL becomes unreachable from
+  the product but the object survives in the bucket — said here rather than simulated.
+- **The presentation ceiling is GLOBAL**: messages and attendance records each share one `plafond`
+  budget spread across every presentation of a run — not a ceiling per presentation (otherwise
+  500 × 5000 = 2.5 M possible rows). The loop stops when the budgets are exhausted, without
+  deleting the remaining presentations.
+- **The dryRun report is complete for presentations**: `messagesExaminees`, `presencesExaminees`
+  and `fichiersCandidats` say what the REAL purge would do — same selection walk, no-op deletion,
+  `efface.* = 0`.
+- **The purge advances in BOUNDED BATCHES** (200 rows, a ceiling of 5000 per table and 500
+  presentations per run): it selects a batch of identifiers, deletes them with `id=in.(…)`, and
+  starts again. The report (`r.rapport`) carries, per table: `examinees`, `supprimees`, `tronque`
+  (there is more left for the next pass). `retention.run` accepts `{ dryRun: true }`: it counts
+  without erasing anything — to be run before the first real purge of a large history.
+- **Indexes** (migration 0014): `commercial_doc_sessions(last_at)`, `doc_bot_sessions(last_at)`,
+  `commercial_doc_shares(revoked_at) where revoked`. On a LARGE installation already in production,
+  create them by hand with `CREATE INDEX CONCURRENTLY` outside the migration (the migration lays
+  them down as ordinary indexes, which briefly locks writes — negligible on a young database, to be
+  avoided on a large active table).
+- **The census does not run by itself in production**: it is a piece of SQL an operator runs (and
+  that CI executes on every run against a real, artificially aged database).
+- **"What exists" has a depth in time that `information_schema` does not have** (a question from the
+  second host, with no mechanical answer): a column dropped from the schema leaves the scope of both
+  texts, but its data may survive in a dump, a backup or an archive table. This contract covers the
+  LIVE DATABASE; copies (backups, exports, migration dumps) are the operator's scope, named here
+  rather than simulated. Operational corollary: dropping a column holding personal data is itself a
+  retention act — its row leaves this document in the same commit, and earlier copies follow the
+  host's backup policy.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.126",
+  "version": "0.1.128",
   "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 CHANGED Viewed

@@ -624,6 +624,17 @@ async function handler(req, res) {
         presenceDurcissement: (() => {
           try { return require("./presentations").etatDurcissementBootstrap(); } catch { return "inconnu"; }
         })(),
+        // ⚠️ LE CHEMIN FUSIONNÉ EST-IL EMPRUNTÉ ? Sans ce champ, un hôte à qui 0019 manque retombe en
+        // silence à trois allers-retours par battement : correct, mais deux fois plus cher sur le
+        // chemin le plus chaud du produit, et RIEN ne le dirait. Une dégradation qu'on ne peut pas
+        // observer est une dégradation qu'on découvre à la facture — ou jamais.
+        //
+        // ⚠️ Mêmes trois états, même piège : « inconnu » veut dire « personne n'a battu dans ce
+        // processus », pas « la migration manque ». Pour la question d'avant-déploiement, c'est
+        // `schema.fusionBase` qu'il faut lire — elle, elle interroge la base.
+        presenceFusion: (() => {
+          try { return require("./presentations").etatFusionBattement(); } catch { return "inconnu"; }
+        })(),
         // ⚠️ LES JETONS DE PRÉSENCE SONT-ILS RÉELLEMENT ÉMIS ? Sans ce booléen, un exploitant qui vient
         // de poser `PLAYER_PRESENCE_SECRET` n'a AUCUN moyen de vérifier que son réglage a pris : la
         // carte affiche `presence: {0,0}` aussi bien quand le secret est actif que quand la variable est

package/server/presentations.js CHANGED Viewed

@@ -839,6 +839,31 @@ function signatureAbsente(erreur) {
 // silence. Un « oui » (la signature existe) n'a pas besoin d'expirer : une fonction ne disparaît pas.
 let _bumpSansDurcissementJusqua = 0;
 const MEMO_SANS_DURCISSEMENT_MS = 60 * 1000;
+// ⚠️ CE QUE CE PROCESSUS A CONSTATÉ DU CHEMIN FUSIONNÉ — pas ce qu'il espère. Trois états, comme
+// pour le durcissement, et pour la même raison : « pas dégradé » n'est pas « vérifié ». Un
+// processus qui vient de démarrer n'a rien tenté ; rendre « actif » annoncerait une propriété sur
+// la foi d'une absence d'observation.
+//
+// ⚠️ ET C'EST UN RAPPORT D'EXÉCUTION, PAS UN INVENTAIRE. Il ne se lit pas avant un déploiement : au
+// repos il vaut « inconnu », ce qui veut dire « personne n'a regardé ». La question « la migration
+// est-elle là ? » se pose à la BASE — c'est `schema.fusionBase`, qui la lui pose vraiment.
+let _etatFusion = "inconnu";
+function etatFusionBattement() {
+  // ⚠️ MÊME LECTURE QUE `etatDurcissementBootstrap`, DÉLIBÉRÉMENT. Les deux champs partagent leur
+  // vocabulaire et se lisent côte à côte dans la carte : leur donner des règles d'expiration
+  // différentes serait un piège pour qui les compare. Tant que le mémo court, la dernière
+  // observation vaut ; passé lui, une preuve NÉGATIVE périmée retombe sur l'ignorance et jamais sur
+  // la confiance. Un « oui » n'expire pas — une fonction ne disparaît pas toute seule.
+  if (Date.now() < _bumpSansFusionJusqua) return "degrade";
+  return _etatFusion === "degrade" ? "inconnu" : _etatFusion;
+}
+// ⚠️ MÉMO DU CONTRAT FUSIONNÉ (0019), MÊME PATRON QUE 0018. La fusion est FONCTION-SEULE : aucune
+// colonne à sonder, donc on la DEMANDE et on retient l'échec, sinon un hôte non migré paierait un
+// aller-retour perdu à chaque battement. Soixante secondes : assez pour ne pas insister, assez court
+// pour qu'appliquer la migration se voie sans redémarrer le processus.
+let _bumpSansFusionJusqua = 0;
+const MEMO_SANS_FUSION_MS = 60 * 1000;
 // ⚠️ LE DERNIER MOT OBSERVÉ, ÉCRIT — pas déduit. Un booléen « on a essayé » ne pouvait pas dire si
 // ce mot fut un succès ou un échec, et c'est lui qui décide. Comparer deux instants le disait, au
 // prix d'une égalité possible à la milliseconde. On écrit donc l'état : « actif » (un appel durci
@@ -862,6 +887,33 @@ function erreurDurcissementAbsent() {
   return e;
 }
+// ⚠️ L'APPEL FUSIONNÉ NE PASSE PAS PAR `appelerBump`, ET CE N'EST PAS UN OUBLI. `appelerBump` lit
+// une signature absente comme « 0018 manque » : c'est vrai tant qu'UN SEUL fichier peut causer cet
+// échec. Avec 0019, deux le peuvent — et le diagnostic se tromperait de fichier, exactement le défaut
+// qu'on a retiré du message d'alerte quelques versions plus tôt (un nom FAUX est pire qu'absent :
+// l'exploitant vérifie la migration nommée, la trouve appliquée, et conclut au faux positif).
+//
+// Ici on ne diagnostique donc RIEN : l'échec de signature arme le mémo et rend la main au chemin
+// classique, qui refera le diagnostic avec un seul fichier possible. Le succès, lui, prouve que 0019
+// est là — donc 0018 aussi, elle la précède — et le durcissement est bien celui qu'on a demandé.
+async function appelerBumpFusionne(corps, durcissementVoulu) {
+  const reponse = await PLAYER.db.request("rpc/player_attendance_bump", { method: "POST", body: corps });
+  // L'appel est REVENU : le contrat à 13 arguments existe. Ce qui se mesure est le RETOUR, jamais
+  // l'intention de partir — et un durcissement demandé qui revient par ici est bien appliqué, 0019
+  // succédant à 0018 elle ne peut pas être là sans elle.
+  _etatFusion = "actif";
+  if (durcissementVoulu) _etatDurcissement = "actif";
+  // ⚠️ ON PROJETTE PLUTÔT QUE DE RENDRE LA LIGNE TELLE QUELLE — une garde de ce dépôt l'exige, et
+  // elle a raison ici : le jour où la RPC rendra une colonne de plus, elle ne traversera pas cette
+  // fonction sans que quelqu'un l'ait décidé. Les sept champs sont ceux que 0019 déclare.
+  const l = Array.isArray(reponse) ? reponse[0] : reponse;
+  if (!l || typeof l.ok !== "boolean") return null;   // forme inattendue : aucun verdict inventé
+  return {
+    ok: !!l.ok, created: !!l.created, capped: !!l.capped, usurpe: !!l.usurpe,
+    introuvable: !!l.introuvable, archivee: !!l.archivee, page: Math.max(0, Math.trunc(Number(l.page) || 0)),
+  };
+}
 async function appelerBump(corps, durcissementVoulu) {
   const appel = (b) => PLAYER.db.request("rpc/player_attendance_bump", { method: "POST", body: b });
   if (durcissementVoulu && Date.now() < _bumpSansDurcissementJusqua) {
@@ -920,19 +972,36 @@ async function appelerBump(corps, durcissementVoulu) {
   }
 }
-async function recordAttendance(slug, participant, { presentation = null, ipHash = null, anonCap = null, hasToken = null, onlyIfUnclaimed = false } = {}) {
+async function recordAttendance(slug, participant, { presentation = null, ipHash = null, anonCap = null, hasToken = null, onlyIfUnclaimed = false, controlHash = null, sansFusion = false } = {}) {
   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
-  // options plutôt que de la faire relire par battement (un battement = un aller-retour DB de moins).
-  // Repli sur une lecture si l'appelant ne la fournit pas — c'est le cas de l'appel public à 2 args.
-  const pres = presentation || await getPresentation(slug);
-  if (!pres) return { ok: false, status: 404 };
-  // ⚠️ La lecture est DÉJÀ faite ici : on s'en sert plutôt que d'en refaire une. Un battement de
-  // présence sur une session close n'a rien à mettre à jour — et il en arrive à chaque onglet
-  // resté ouvert, longtemps après la fin.
-  if (pres.active === false && pres.control_hash == null) return REFUS_ARCHIVE;
-  const page = Math.max(1, Math.trunc(Number(pres.current_page) || 1));
+  // ⚠️ CHEMIN FUSIONNÉ (migration 0019) : C'EST LA BASE QUI LIT LA PRÉSENTATION, PLUS NOUS. Un
+  // battement coûtait TROIS allers-retours — débit par IP, lecture de la présentation, écriture. La
+  // lecture servait à trois choses, et à trois seulement : l'existence, la page courante, et
+  // l'identification du présentateur par son jeton de contrôle. Les trois se font désormais DANS la
+  // transaction d'écriture. Mesuré à 250 participants avant d'être engagé, pas supposé.
+  //
+  // On n'y va pas si l'appelant nous a DÉJÀ fourni la présentation : il l'a lue pour autre chose, la
+  // refaire lire ne ferait rien gagner. `sansFusion` est le repli explicite — il ne dépend pas du
+  // mémo, donc la reprise ci-dessous ne peut pas boucler même si l'horloge se comporte mal.
+  const fusion = presentation == null && !sansFusion && Date.now() >= _bumpSansFusionJusqua;
+  let pres = presentation;
+  if (!fusion) {
+    pres = presentation || await getPresentation(slug);
+    if (!pres) return { ok: false, status: 404 };
+    // ⚠️ La lecture est DÉJÀ faite ici : on s'en sert plutôt que d'en refaire une. Un battement de
+    // présence sur une session close n'a rien à mettre à jour — et il en arrive à chaque onglet
+    // resté ouvert, longtemps après la fin.
+    if (pres.active === false && pres.control_hash == null) return REFUS_ARCHIVE;
+  }
+  // `null` en mode fusionné : la base prendra sa propre `current_page`. C'est aussi le SIGNAL qu'elle
+  // attend pour appliquer les deux refus à notre place (cf. 0019) — un appelant qui a lu envoie
+  // toujours une page, un appelant qui n'a pas lu n'en a pas.
+  const page = fusion ? null : Math.max(1, Math.trunc(Number(pres.current_page) || 1));
+  // ⚠️ LA COMPARAISON DE JETON RESTE ICI HORS FUSION, sinon le présentateur perdrait son titre en
+  // silence sur un hôte non migré : la décision a changé de camp, elle n'a pas disparu d'ici.
+  const presentateurPreuve = !!isPresenter
+    || (!fusion && !!pres && controlHash != null && pres.control_hash != null && controlHash === pres.control_hash);
   // ⚠️ CHEMIN ATOMIQUE (migration 0015) : upsert ET plafond de création anonyme en UN geste, à l'abri
   // des créations concurrentes. Absent (404, migration non appliquée) → on retombe sur la boucle
@@ -956,7 +1025,7 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
   const corpsRpc = {
     p_slug: String(slug), p_key: String(key), p_ip_hash: ipHash || null, p_page: page,
     p_name: (name || "").slice(0, 120), p_avatar: (avatar || "").slice(0, 600),
-    p_is_member: !!isMember, p_is_presenter: !!isPresenter,
+    p_is_member: !!isMember, p_is_presenter: presentateurPreuve,
     p_max_gap_ms: ATTEND_MAX_GAP_MS, p_anon_cap: capAnon,
   };
   // true → last_token_at, false → last_no_token_at, null → ni l'un ni l'autre. 0017 seulement.
@@ -969,10 +1038,41 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
   // pour le processus : un hôte non migré ne paie pas deux allers-retours par battement, un seul.
   const durcissementVoulu = !!onlyIfUnclaimed;
   if (durcissementVoulu) corpsRpc.p_only_if_unclaimed = true;
+  // ⚠️ EN MODE FUSIONNÉ, `p_control_hash` PART TOUJOURS — MÊME NULL, ET C'EST ESSENTIEL. PostgREST
+  // résout une RPC par jeu d'arguments NOMMÉS : omettre l'argument quand le visiteur n'a pas de jeton
+  // de contrôle ferait résoudre l'appel vers le contrat COURT, qui existe encore sur une base non
+  // migrée et qui lit `p_page` null comme « page 1 ». On enregistrerait alors la page 1 pour tout le
+  // monde, sans aucun refus, et RIEN ne le dirait. L'argument explicite est précisément ce qui fait
+  // ÉCHOUER l'appel là où 0019 manque — donc ce qui déclenche le repli au lieu d'un faux succès.
+  if (fusion) corpsRpc.p_control_hash = controlHash || null;
   try {
-    const r = await appelerBump(corpsRpc, durcissementVoulu);
+    let r;
+    if (fusion) {
+      try {
+        r = await appelerBumpFusionne(corpsRpc, durcissementVoulu);
+      } catch (erreurFusion) {
+        // Toute autre erreur est une vraie panne : elle suit le chemin d'erreur commun ci-dessous.
+        if (!signatureAbsente(erreurFusion)) throw erreurFusion;
+        // 0019 n'est pas appliquée. On arme le mémo et on recommence par le chemin classique, qui
+        // lira la présentation et décidera du présentateur ici — SANS rien perdre. Rien à signaler à
+        // l'exploitant : le battement reste exact, il coûte simplement l'aller-retour d'avant.
+        _etatFusion = "degrade";
+        _bumpSansFusionJusqua = Date.now() + MEMO_SANS_FUSION_MS;
+        return recordAttendance(slug, participant,
+          { presentation, ipHash, anonCap, hasToken, onlyIfUnclaimed, controlHash, sansFusion: true });
+      }
+    } else {
+      r = await appelerBump(corpsRpc, durcissementVoulu);
+    }
     const ligne = Array.isArray(r) ? r[0] : r;
     if (ligne && typeof ligne.ok === "boolean") {
+      // ⚠️ LES DEUX REFUS QUE LA ROUTE OPPOSAIT AVANT D'APPELER, RENDUS PAR LA BASE (0019). Ils ne
+      // sont pas décoratifs : sans eux, la fusion aurait supprimé un 404 et un refus d'archive en
+      // déplaçant la décision. Ils arrivent DISTINCTS plutôt que fondus dans un `ok:false`, pour que
+      // le client garde les mêmes codes qu'avant — 404 « cette présentation n'existe pas », 409
+      // « elle est finie ». Un appelant qui a fourni la présentation ne les verra jamais.
+      if (ligne.introuvable) return { ok: false, status: 404 };
+      if (ligne.archivee) return REFUS_ARCHIVE;
       // Plafond de création atteint : on ne crée pas ce faux participant. 429 = « trop », pas une panne.
       if (ligne.capped) return { ok: false, status: 429 };
       // Bootstrap sur une ligne DÉJÀ RÉCLAMÉE par un porteur de jeton : rien n'a été écrit. 409 = « ce
@@ -1024,6 +1124,20 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
   // est conditionnée à la valeur LUE ; zéro ligne = quelqu'un d'autre a battu entre-temps (l'autre
   // onglet du même participant) — on relit et on rejoue. Sans ça, deux onglets qui battent dans la
   // même seconde perdaient une page vue : la seconde réécriture emportait la première.
+  // ⚠️ LE REPLI A BESOIN DE LA PAGE, ET EN MODE FUSIONNÉ NOUS NE L'AVONS PAS. L'économie de 0019 ne
+  // vaut que sur le chemin qui RÉUSSIT : ici la RPC a échoué (ou rendu une forme inattendue), donc on
+  // paie la lecture qu'on avait évitée. Sans ça on écrirait `pages: [null]` et un présentateur
+  // perdrait son titre — deux dégâts silencieux, au moment précis où l'on est déjà en difficulté.
+  let pageEcrite = page;
+  let presentateurEcrit = presentateurPreuve;
+  if (pageEcrite == null) {
+    const relu = await getPresentation(slug);
+    if (!relu) return { ok: false, status: 404 };
+    if (relu.active === false && relu.control_hash == null) return REFUS_ARCHIVE;
+    pageEcrite = Math.max(1, Math.trunc(Number(relu.current_page) || 1));
+    presentateurEcrit = presentateurEcrit
+      || (controlHash != null && relu.control_hash != null && controlHash === relu.control_hash);
+  }
   let cur = null;
   for (let essai = 0; essai < 4; essai += 1) {
     if (cur === null) {
@@ -1032,7 +1146,7 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
     }
     if (!cur) {
       const now = Date.now();
-      const row = { slug: String(slug), attendee_key: String(key).slice(0, 200), name: (name || "").slice(0, 120) || null, email: lc(email) || null, avatar: (avatar || "").slice(0, 600) || null, is_member: !!isMember, is_presenter: !!isPresenter, first_seen: new Date(now).toISOString(), last_seen: new Date(now).toISOString(), total_ms: 0, pages: [page] };
+      const row = { slug: String(slug), attendee_key: String(key).slice(0, 200), name: (name || "").slice(0, 120) || null, email: lc(email) || null, avatar: (avatar || "").slice(0, 600) || null, is_member: !!isMember, is_presenter: presentateurEcrit, first_seen: new Date(now).toISOString(), last_seen: new Date(now).toISOString(), total_ms: 0, pages: [pageEcrite] };
       try {
         await PLAYER.db.request("doc_presentation_attendees", { method: "POST", headers: { Prefer: "return=minimal" }, body: [row] });
         return { ok: true };
@@ -1059,7 +1173,7 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
     const gap = now - lu;
     const addMs = gap > 0 && gap <= ATTEND_MAX_GAP_MS ? gap : 0;
     const pages = Array.isArray(cur.pages) ? cur.pages.slice() : [];
-    if (!pages.includes(page)) pages.push(page);
+    if (!pages.includes(pageEcrite)) pages.push(pageEcrite);
     const ecrit = await ecrireSiEncoreVrai(
       `doc_presentation_attendees?slug=eq.${enc(slug)}&attendee_key=eq.${enc(String(key))}&last_seen=eq.${enc(String(cur.last_seen))}`,
       { last_seen: new Date(now).toISOString(), total_ms: Number(cur.total_ms || 0) + addMs, pages, name: (name || cur.name || "").slice(0, 120) || null, avatar: (avatar || cur.avatar || "").slice(0, 600) || null,
@@ -1067,7 +1181,7 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
         // première ligne : un transfert de présentation change qui porte le titre, et une session qui
         // s'authentifie en cours de route devient un membre. Figés, ils décriraient l'instant de
         // l'arrivée et non la réalité — et le premier arrivé aurait raison pour toujours.
-        is_member: !!isMember, is_presenter: !!isPresenter },
+        is_member: !!isMember, is_presenter: presentateurEcrit },
     );
     if (ecrit) return { ok: true };
     cur = null;   // battu en vol : on relira l'état frais au tour suivant
@@ -1260,4 +1374,4 @@ async function listPresentationsForDoc(docId, email, isAdmin, autoriseLarge) {
 module.exports = {
   reacteurDepuisJeton,
   purgerPerimees,
-  messagePublic, CHAMPS_PUBLICS, etatDurcissementBootstrap, signatureAbsente, cheminPieceJointe, init, createPresentation, getPresentation, setPage, endPresentation, addMessage, listMessages, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent , STALE_MS};
+  messagePublic, CHAMPS_PUBLICS, etatDurcissementBootstrap, etatFusionBattement, signatureAbsente, cheminPieceJointe, init, createPresentation, getPresentation, setPage, endPresentation, addMessage, listMessages, toggleReaction, editMessage, deleteMessage, setChatLock, createUploadUrl, reclaimPresentation, touchPresentation, listActivePresentations, handoverPresentation, endPresentationByOwner, recordAttendance, presentationStats, listPresentationsForDoc, switchPresentationDoc, setPresentationContent , STALE_MS};

package/server/routes-direct.js CHANGED Viewed

@@ -78,9 +78,18 @@ async function traiter(req, res, body, _slug) {
           // route ne le faisait pas. Et l'appartenance se prouve par le jeton d'accès de la session :
           // cette route est un `fetch`, elle peut porter un en-tête (contrairement au suivi de
           // lecture, qui part par `sendBeacon` et signe donc dans le corps).
-          const pres = await getPresentation(String(body.slug || ""));
-          if (!pres) return jp(404, { ok: false });
-          const estPresentateur = !!(body.control && require("crypto").createHash("sha256").update(String(body.control)).digest("hex") === pres.control_hash);
+          // ⚠️ CETTE ROUTE NE LIT PLUS LA PRÉSENTATION (0019). Elle la lisait pour trois choses —
+          // existe-t-elle, est-elle close, et l'appelant porte-t-il le jeton de contrôle — et les
+          // trois se décident maintenant dans la transaction d'écriture. Le battement passe de trois
+          // allers-retours à deux. Ce qui monte est l'EMPREINTE du jeton, jamais le jeton : la
+          // comparaison est la même qu'ici, faite sur la même donnée, un cran plus bas.
+          //
+          // ⚠️ Le 404 et le refus d'archive n'ont pas disparu, ils REMONTENT : `recordAttendance`
+          // rend { status: 404 } et REFUS_ARCHIVE à partir de ce que la base répond. Un déplacement
+          // de décision est l'endroit où une garde se perd — celles-ci sont mesurées, des deux côtés.
+          const controlHash = body.control
+            ? require("crypto").createHash("sha256").update(String(body.control)).digest("hex")
+            : null;
           // ⚠️ Une identité prouvée REMPLACE celle qu'on affirme — elle ne s'y ajoute pas. Sinon la
           // vérification ne servirait qu'à décorer une affirmation qu'on croit toujours.
           const profil = await profilDuJeton(req);
@@ -188,13 +197,15 @@ async function traiter(req, res, body, _slug) {
             name: (profil && profil.name) || body.name,
             email: profil ? profil.email : body.email,
             avatar: (profil && profil.avatar) || body.avatar,
-            isMember: !!profil, isPresenter: estPresentateur,
+            // ⚠️ ON N'AFFIRME PLUS LE TITRE, ON FOURNIT LA PREUVE (`controlHash`, plus bas) : c'est
+            // la base qui compare. Affirmer `false` ici n'enlève donc rien — le titre vient du jeton.
+            isMember: !!profil, isPresenter: false,
             // ⚠️ UN BOOTSTRAP NE PEUT PAS S'EMPARER D'UNE PRÉSENCE DÉJÀ RÉCLAMÉE (0018). `wantToken`
             // est AUTO-DÉCLARÉ : sans ce verrou, un attaquant le déclarait, posait la clé d'un
             // participant enregistré, et écrasait sa ligne — l'usurpation même que l'étape 2 ferme
             // pour les battements ordinaires. Le second hôte l'a EXÉCUTÉE sur sa prod. Le contrôle ne
             // vaut que pour un bootstrap : un porteur de jeton est déjà prouvé, un membre aussi.
-          }, { presentation: pres, ipHash, anonCap, hasToken, onlyIfUnclaimed: bootstrap });
+          }, { ipHash, anonCap, hasToken, onlyIfUnclaimed: bootstrap, controlHash });
           // 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

package/server/schema.js CHANGED Viewed

@@ -313,6 +313,11 @@ async function vraimentSonderTout() {
     return {
       ...etatDuSchema(), verdict: "indetermine",
       durcissementBase: "indetermine", durcissementBaseCouvre: PORTEE_DURCISSEMENT,
+      // ⚠️ LE CHAMP DOIT ÊTRE LÀ ICI AUSSI, pour la raison qui a valu son correctif au voisin : un
+      // champ ABSENT ne se distingue pas d'un contrat plus ancien, et `undefined !== "applique"`
+      // est vrai par accident. Un hôte qui teste avant de déployer mérite un « je ne sais pas »
+      // explicite plutôt qu'un silence qui ressemble à un non.
+      fusionBase: "indetermine", fusionBaseCouvre: PORTEE_FUSION,
     };
   }
   // ⚠️ LE TÉMOIN VIENT DE RÉPONDRE : tout « non » encore en cache est SUSPECT — il peut dater
@@ -324,7 +329,7 @@ async function vraimentSonderTout() {
   const etat = etatDuSchema();
   await ajouterSansRang(etat);
   await ajouterPresence(etat);
-  await ajouterDurcissement(etat);
+  await ajouterMigrationsDePresence(etat);
   return etat;
 }
@@ -378,12 +383,81 @@ const PORTEE_DURCISSEMENT =
   + "C'est ce champ-ci qu'on lit AVANT un déploiement ; « indetermine » = la question n'a pas pu "
   + "être posée, ce n'est ni un oui ni un non.";
-async function ajouterDurcissement(etat) {
-  const corps = {
-    p_slug: SLUG_SONDE_DURCISSEMENT, p_key: "sonde", p_ip_hash: null, p_page: 1,
+// ⚠️ MÊME DISTINCTION, POUR 0019 : `fusionBase` est une propriété de la BASE, `presenceFusion` (la
+// carte) est ce que CE processus a constaté en servant des battements. Le second vaut « inconnu » au
+// repos — c'est-à-dire « personne n'a regardé » — et ne peut donc pas servir de contrôle avant
+// déploiement. On a déjà écrit une consigne de pré-vol sur un champ qui refuse de se prononcer sans
+// observation ; celui-ci existe pour qu'on n'ait pas à recommencer.
+const PORTEE_FUSION =
+  "propriété de la BASE (migration 0019), globale à toutes les instances — à ne pas confondre avec "
+  + "presenceFusion, qui est ce que CE processus a constaté en servant des battements. Sans 0019, "
+  + "rien ne casse : un battement coûte 3 allers-retours au lieu de 2. « indetermine » = la question "
+  + "n'a pas pu être posée, ce n'est ni un oui ni un non.";
+// ⚠️ DEUX MIGRATIONS, UNE SEULE SONDE DANS LE CAS NORMAL. 0019 succède à 0018 et son jeu
+// d'arguments CONTIENT le sien : un appel qui passe le contrat à 13 arguments prouve donc les deux
+// d'un coup. On ne repose la question du durcissement que si le contrat long n'existe pas — c'est-
+// à-dire sur un hôte en retard, qui est exactement celui à qui l'on doit une réponse précise.
+//
+// ⚠️ ET LA SONDE N'ÉCRIT TOUJOURS RIEN, POUR DEUX RAISONS INDÉPENDANTES. `p_page: null` sur un slug
+// qui n'existe pas sort par la branche « introuvable » de 0019, avant l'insert ; et `p_anon_cap: 0`
+// sortait déjà par la branche « capped » du contrat précédent. Deux raisons plutôt qu'une, parce
+// qu'une sonde de diagnostic qui écrirait serait le pire endroit où découvrir une régression.
+// ⚠️ UN SEUL ENDROIT QUI PARLE, PARCE QU'IL Y A PLUSIEURS RAISONS DE PARLER. La carte est publique
+// donc appelable en boucle : un journal sans frein deviendrait une arme. Une fois par heure et par
+// motif — et jamais bloquant, un diagnostic qui tombe en panne en diagnostiquant ne diagnostique
+// plus rien.
+async function journaliser(cle, message) {
+  try {
+    if (await PLAYER.limits.allow(cle, 1, 3600)) PLAYER.errors.capture(new Error(message), { route: "schema" });
+  } catch { /* jamais bloquant */ }
+}
+async function ajouterMigrationsDePresence(etat) {
+  const commun = {
+    p_slug: SLUG_SONDE_DURCISSEMENT, p_key: "sonde", p_ip_hash: null,
     p_name: "", p_avatar: "", p_is_member: false, p_is_presenter: false,
     p_max_gap_ms: 0, p_anon_cap: 0, p_has_token: null, p_only_if_unclaimed: true,
   };
+  const estSignatureAbsente = (erreur) => {
+    try { return require("./presentations.js").signatureAbsente(erreur); } catch { return false; }
+  };
+  etat.fusionBaseCouvre = PORTEE_FUSION;
+  try {
+    await PLAYER.db.request("rpc/player_attendance_bump",
+      { method: "POST", body: { ...commun, p_page: null, p_control_hash: null } });
+    // Le contrat long a répondu : 0019 est là, donc 0018 aussi — elle la précède et 0019 reprend
+    // ses arguments. On ne repose pas une question dont la réponse vient d'être prouvée.
+    etat.fusionBase = "applique";
+    etat.durcissementBase = "applique";
+    etat.durcissementBaseCouvre = PORTEE_DURCISSEMENT;
+    return;
+  } catch (erreur) {
+    if (!estSignatureAbsente(erreur)) {
+      // ⚠️ UNE PANNE NE PROUVE RIEN — NI POUR L'UNE NI POUR L'AUTRE. Insister avec un second appel
+      // ne ferait que frapper une base déjà en difficulté pour en tirer la même absence de réponse.
+      etat.fusionBase = "indetermine";
+      etat.durcissementBase = "indetermine";
+      etat.durcissementBaseCouvre = PORTEE_DURCISSEMENT;
+      await journaliser("schema:sonde-presence-muette",
+        "sonde des migrations de présence (0018/0019) sans réponse exploitable : ni confirmées, ni "
+        + "infirmées — " + ((erreur && erreur.message) || erreur));
+      return;
+    }
+    etat.fusionBase = "absente";
+    // ⚠️ ET ON LE DIT. C'est même toute la raison d'être de cette sonde : sans elle, un hôte à qui
+    // 0019 manque paie deux fois le chemin le plus chaud du produit sans que rien ne le signale.
+    // Le message dit la dégradation EXACTE — pas « ça ne marche pas », qui n'aide personne à
+    // décider si ça vaut une migration.
+    await journaliser("schema:fusion-absente",
+      "migration 0019-presence-lit-la-presentation.sql ABSENTE : rien ne casse, mais chaque "
+      + "battement de présence coûte 3 allers-retours base au lieu de 2 — soit environ 30 op/s au "
+      + "lieu de 20 pour 250 participants. L'appliquer ne demande aucun redéploiement.");
+    // On ne sait toujours rien de 0018 : le contrat court se demande à part, ci-dessous.
+  }
+  const corps = { ...commun, p_page: 1 };
   try {
     await PLAYER.db.request("rpc/player_attendance_bump", { method: "POST", body: corps });
     etat.durcissementBase = "applique";
@@ -391,8 +465,7 @@ async function ajouterDurcissement(etat) {
     // ⚠️ TROIS ISSUES, ET LA TROISIÈME N'EST PAS UNE DES DEUX AUTRES. Seule la signature absente
     // prouve que 0018 manque ; une panne réseau ou un 500 ne prouvent RIEN, et les compter comme
     // « absente » serait le défaut qu'on a mis trois versions à retirer d'ailleurs.
-    let absente = false;
-    try { absente = require("./presentations.js").signatureAbsente(erreur); } catch { /* module absent */ }
+    const absente = estSignatureAbsente(erreur);
     etat.durcissementBase = absente ? "absente" : "indetermine";
     // ⚠️ ET ON LE DIT, PAS SEULEMENT DANS LA CARTE. Une garde de ce dépôt refuse qu'une écriture soit
     // rattrapée en silence, et elle a raison ici pour une raison qu'elle ne pouvait pas connaître :

package/supabase/init.sql CHANGED Viewed

@@ -386,7 +386,11 @@ begin
 end
 $$;
--- Présence en un seul geste + plafond de création anonyme atomique. Cf. migration 0015 (mêmes règles).
+-- Présence en un seul geste + plafond de création anonyme atomique, ET lecture de la présentation
+-- dans la MÊME transaction que l'écriture. Cf. migrations 0015 puis 0019 — texte identique à 0019,
+-- sans quoi rejouer la migration sur une base née d'ici changerait la forme (la CI le mesure).
+drop function if exists public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean);
 create or replace function public.player_attendance_bump(
   p_slug         text,
   p_key          text,
@@ -399,9 +403,11 @@ create or replace function public.player_attendance_bump(
   p_max_gap_ms   integer,
   p_anon_cap     integer,
   p_has_token    boolean default null,
-  p_only_if_unclaimed boolean default null
+  p_only_if_unclaimed boolean default null,
+  p_control_hash text default null
 )
-returns table (ok boolean, created boolean, capped boolean, usurpe boolean)
+returns table (ok boolean, created boolean, capped boolean, usurpe boolean,
+               introuvable boolean, archivee boolean, page integer)
 language plpgsql
 security definer
 set search_path = public
@@ -410,8 +416,56 @@ declare
   v_exists boolean;
   v_claimed boolean;
   v_count  integer;
-  v_page   integer := greatest(1, coalesce(p_page, 1));
+  v_pres_active boolean;
+  v_pres_page   integer;
+  v_pres_hash   text;
+  v_pres_vue    boolean := false;
+  v_presentateur boolean;
+  v_page   integer;
 begin
+  -- ⚠️ LA PRÉSENTATION EST LUE ICI, ET C'EST TOUT L'OBJET DE 0019. L'appelant la lisait avant
+  -- d'appeler : un battement coûtait donc DEUX allers-retours là où un seul suffit. La lecture
+  -- servait à trois choses — l'existence, l'identification du présentateur, la page courante — et
+  -- les trois se font mieux ici, dans la même transaction que l'écriture.
+  select active, current_page, control_hash
+    into v_pres_active, v_pres_page, v_pres_hash
+    from public.doc_presentations where slug = p_slug;
+  v_pres_vue := found;
+  -- ⚠️ LE SIGNAL EST « L'APPELANT A-T-IL LU », PAS « PORTE-T-IL UN JETON ». Première écriture de
+  -- cette migration : les deux refus ci-dessous étaient conditionnés à `p_control_hash is not null`.
+  -- Or un participant ANONYME n'envoie aucun jeton de contrôle — c'est-à-dire l'immense majorité des
+  -- battements — et il aurait donc perdu le 404 et le refus d'archive que la route lui oppose
+  -- aujourd'hui. Une garde perdue en chemin, à l'endroit exact que l'en-tête désigne comme risqué.
+  --
+  -- Ce qui décide, c'est si l'appelant a DÉJÀ lu la présentation, et ça se lit à `p_page` : un
+  -- appelant ANCIEN en fournit toujours une (les deux seuls appelants du dépôt envoient page >= 1,
+  -- et 1 pour la sonde de schéma) ; un appelant NEUF n'en a pas, puisqu'il n'a rien lu. `p_page is
+  -- null` dit donc exactement « c'est à toi de trancher » — pour un anonyme comme pour un
+  -- présentateur, alors que le jeton de contrôle ne parlait que du second.
+  if p_page is null and not v_pres_vue then
+    return query select false, false, false, false, true, false, 0;   -- introuvable, rien écrit
+    return;
+  end if;
+  -- ⚠️ MÊME REFUS QUE LE CODE QU'ON REMPLACE : une présentation close ET archivée (control_hash
+  -- effacé) n'a plus rien à mettre à jour. Le dire ici évite que la fusion perde une garde en
+  -- chemin — c'est le risque propre à tout déplacement de décision.
+  if p_page is null and v_pres_active is false and v_pres_hash is null then
+    return query select false, false, false, false, false, true, 0;   -- archivée, rien écrit
+    return;
+  end if;
+  -- ⚠️ LA DÉCISION QUI CHANGE DE CAMP : « qui est présentateur » se décidait en JavaScript, par
+  -- comparaison du sha256 du jeton de contrôle au control_hash de la ligne. Elle se décide ici
+  -- désormais — sur la MÊME donnée, dans la même transaction. On garde le OU avec l'argument de
+  -- l'appelant : un appelant ancien continue de décider lui-même, et ne perd rien.
+  v_presentateur := coalesce(p_is_presenter, false)
+                    or (p_control_hash is not null and v_pres_hash is not null and p_control_hash = v_pres_hash);
+  -- La page vient de la BASE quand l'appelant ne la fournit pas — il n'a plus à la lire pour nous.
+  v_page := greatest(1, coalesce(p_page, v_pres_page, 1));
   -- On lit l'existence ET l'état « réclamée » en un seul geste : un bootstrap n'a rien à écrire sur
   -- une ligne dont un porteur de jeton s'est déjà servi.
   select true, (last_token_at is not null) into v_exists, v_claimed
@@ -419,11 +473,11 @@ begin
     where slug = p_slug and attendee_key = p_key;
   if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
-    return query select false, false, false, true;   -- usurpation : on n'écrit RIEN
+    return query select false, false, false, true, false, false, v_page;   -- usurpation : on n'écrit RIEN
     return;
   end if;
-  if not coalesce(v_exists, false) and not p_is_member and not p_is_presenter then
+  if not coalesce(v_exists, false) and not p_is_member and not v_presentateur 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-temps — et si elle est née RÉCLAMÉE, un
     -- bootstrap concurrent ne doit pas davantage l'écraser ici qu'au premier contrôle.
@@ -431,7 +485,7 @@ begin
       from public.doc_presentation_attendees
       where slug = p_slug and attendee_key = p_key;
     if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
-      return query select false, false, false, true;
+      return query select false, false, false, true, false, false, v_page;
       return;
     end if;
     if not coalesce(v_exists, false) then
@@ -441,7 +495,7 @@ 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, false;
+        return query select false, false, true, false, false, false, v_page;
         return;
       end if;
     end if;
@@ -451,7 +505,7 @@ begin
     (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,
+    (p_slug, p_key, nullif(p_name, ''), null, nullif(p_avatar, ''), p_is_member, v_presentateur,
      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)
@@ -467,21 +521,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 = v_presentateur,
         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, false;
+  return query select true, not coalesce(v_exists, false), false, false, false, false, v_page;
 end;
 $$;
-revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean) from public;
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean, text) 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, boolean) from %I', r);
+      execute format('revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean, text) from %I', r);
     end if;
   end loop;
 end
@@ -489,7 +543,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, boolean, boolean) to service_role;
+    grant execute on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean, text) to service_role;
   end if;
 end
 $$;

package/supabase/migrations/0019-presence-lit-la-presentation.sql ADDED Viewed

@@ -0,0 +1,181 @@
+-- LA RPC DE PRÉSENCE LIT LA PRÉSENTATION — UN BATTEMENT PASSE DE 3 À 2 ALLERS-RETOURS.
+--
+-- ⚠️ Dernier poste chiffré d'un audit externe, et il exigeait d'être MESURÉ avant d'être engagé.
+-- La mesure existe : à 250 participants, le battement coûte 3 allers-retours (débit par IP, lecture
+-- de présentation, écriture) — soit ~30 op/s. La lecture disparaît ici : ~20 op/s.
+--
+-- ⚠️ CE QUI CHANGE DE CAMP, ET IL FAUT LE LIRE COMME TEL : « qui est présentateur » se décidait en
+-- JavaScript (sha256 du jeton de contrôle comparé au control_hash de la ligne). Cette décision passe
+-- dans le SQL, sur la MÊME donnée et dans la MÊME transaction que l'écriture. Un déplacement de
+-- décision est l'endroit où une garde se perd en chemin : les deux refus que le code JS opposait —
+-- présentation introuvable, présentation close ET archivée — sont donc reproduits ici, et rendus
+-- explicitement (`introuvable`, `archivee`) plutôt que confondus avec un simple `ok = false`.
+--
+-- ⚠️ RÉTROCOMPATIBLE DANS LES DEUX SENS. `p_control_hash` a un DEFAULT : une base NEUVE sert un code
+-- ANCIEN sans rien changer (il passe p_page, décide lui-même du présentateur, et ne demande pas les
+-- nouveaux refus). Le sens inverse — code neuf, base ancienne — reste impossible par construction
+-- (PostgREST résout par jeu d'arguments nommés) : le player réessaie donc le contrat plus court, et
+-- retombe sur sa lecture préalable. Dégrader, jamais casser, jamais en silence.
+--
+-- ⚠️ Sans lui : rien ne casse — le player redemande le contrat court, relit la présentation comme
+-- avant, et le battement garde ses 3 allers-retours. Le titre de présentateur, les deux refus et la
+-- page restent exacts : c'est le CHEMIN qui change, jamais le résultat.
+drop function if exists public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean);
+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,
+  p_only_if_unclaimed boolean default null,
+  p_control_hash text default null
+)
+returns table (ok boolean, created boolean, capped boolean, usurpe boolean,
+               introuvable boolean, archivee boolean, page integer)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  v_exists boolean;
+  v_claimed boolean;
+  v_count  integer;
+  v_pres_active boolean;
+  v_pres_page   integer;
+  v_pres_hash   text;
+  v_pres_vue    boolean := false;
+  v_presentateur boolean;
+  v_page   integer;
+begin
+  -- ⚠️ LA PRÉSENTATION EST LUE ICI, ET C'EST TOUT L'OBJET DE 0019. L'appelant la lisait avant
+  -- d'appeler : un battement coûtait donc DEUX allers-retours là où un seul suffit. La lecture
+  -- servait à trois choses — l'existence, l'identification du présentateur, la page courante — et
+  -- les trois se font mieux ici, dans la même transaction que l'écriture.
+  select active, current_page, control_hash
+    into v_pres_active, v_pres_page, v_pres_hash
+    from public.doc_presentations where slug = p_slug;
+  v_pres_vue := found;
+  -- ⚠️ LE SIGNAL EST « L'APPELANT A-T-IL LU », PAS « PORTE-T-IL UN JETON ». Première écriture de
+  -- cette migration : les deux refus ci-dessous étaient conditionnés à `p_control_hash is not null`.
+  -- Or un participant ANONYME n'envoie aucun jeton de contrôle — c'est-à-dire l'immense majorité des
+  -- battements — et il aurait donc perdu le 404 et le refus d'archive que la route lui oppose
+  -- aujourd'hui. Une garde perdue en chemin, à l'endroit exact que l'en-tête désigne comme risqué.
+  --
+  -- Ce qui décide, c'est si l'appelant a DÉJÀ lu la présentation, et ça se lit à `p_page` : un
+  -- appelant ANCIEN en fournit toujours une (les deux seuls appelants du dépôt envoient page >= 1,
+  -- et 1 pour la sonde de schéma) ; un appelant NEUF n'en a pas, puisqu'il n'a rien lu. `p_page is
+  -- null` dit donc exactement « c'est à toi de trancher » — pour un anonyme comme pour un
+  -- présentateur, alors que le jeton de contrôle ne parlait que du second.
+  if p_page is null and not v_pres_vue then
+    return query select false, false, false, false, true, false, 0;   -- introuvable, rien écrit
+    return;
+  end if;
+  -- ⚠️ MÊME REFUS QUE LE CODE QU'ON REMPLACE : une présentation close ET archivée (control_hash
+  -- effacé) n'a plus rien à mettre à jour. Le dire ici évite que la fusion perde une garde en
+  -- chemin — c'est le risque propre à tout déplacement de décision.
+  if p_page is null and v_pres_active is false and v_pres_hash is null then
+    return query select false, false, false, false, false, true, 0;   -- archivée, rien écrit
+    return;
+  end if;
+  -- ⚠️ LA DÉCISION QUI CHANGE DE CAMP : « qui est présentateur » se décidait en JavaScript, par
+  -- comparaison du sha256 du jeton de contrôle au control_hash de la ligne. Elle se décide ici
+  -- désormais — sur la MÊME donnée, dans la même transaction. On garde le OU avec l'argument de
+  -- l'appelant : un appelant ancien continue de décider lui-même, et ne perd rien.
+  v_presentateur := coalesce(p_is_presenter, false)
+                    or (p_control_hash is not null and v_pres_hash is not null and p_control_hash = v_pres_hash);
+  -- La page vient de la BASE quand l'appelant ne la fournit pas — il n'a plus à la lire pour nous.
+  v_page := greatest(1, coalesce(p_page, v_pres_page, 1));
+  -- On lit l'existence ET l'état « réclamée » en un seul geste : un bootstrap n'a rien à écrire sur
+  -- une ligne dont un porteur de jeton s'est déjà servi.
+  select true, (last_token_at is not null) into v_exists, v_claimed
+    from public.doc_presentation_attendees
+    where slug = p_slug and attendee_key = p_key;
+  if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
+    return query select false, false, false, true, false, false, v_page;   -- usurpation : on n'écrit RIEN
+    return;
+  end if;
+  if not coalesce(v_exists, false) and not p_is_member and not v_presentateur 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-temps — et si elle est née RÉCLAMÉE, un
+    -- bootstrap concurrent ne doit pas davantage l'écraser ici qu'au premier contrôle.
+    select true, (last_token_at is not null) into v_exists, v_claimed
+      from public.doc_presentation_attendees
+      where slug = p_slug and attendee_key = p_key;
+    if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
+      return query select false, false, false, true, false, false, v_page;
+      return;
+    end if;
+    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, false, false, false, v_page;
+        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, v_presentateur,
+     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 = v_presentateur,
+        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, false, false, false, v_page;
+end;
+$$;
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean, text) 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, boolean, text) 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, boolean, text) to service_role;
+  end if;
+end
+$$;