discovery-media-player 0.1.0

package/README.md

@@ -0,0 +1,152 @@
+<div align="center">
+
+# Discovery Media Player
+
+**Send a document. Know if it was read.**
+
+A self-hosted document viewer with per-recipient tracked links, reading analytics,
+and live presentation — for teams who would rather not hand their commercial documents
+to a third-party SaaS.
+
+[![CI](https://github.com/Juli1artha/discovery-media-player/actions/workflows/ci.yml/badge.svg)](https://github.com/Juli1artha/discovery-media-player/actions/workflows/ci.yml)
+[![License: AGPL v3](https://img.shields.io/badge/license-AGPL--3.0-blue.svg)](LICENSE)
+[![Node](https://img.shields.io/badge/node-%E2%89%A518-brightgreen.svg)](package.json)
+[![Docker](https://img.shields.io/badge/docker-ghcr.io-informational.svg)](#docker)
+
+</div>
+
+---
+
+## Try it in two minutes
+
+```bash
+docker run --rm -p 3000:3000 -v "$PWD/documents:/data" ghcr.io/juli1artha/discovery-media-player
+```
+
+Drop a PDF in `./documents`, open `http://localhost:3000/preview/your-file.pdf`. No database,
+no account, no configuration — the viewer, progressive page loading, and the reading timer all
+work from a folder on disk.
+
+From source, the same thing:
+
+```bash
+git clone https://github.com/Juli1artha/discovery-media-player
+cd discovery-media-player && npm install
+PLAYER_LOCAL_ROOT=./documents npm start
+```
+
+That is the whole demo. Tracked links, analytics and live presentation need a database —
+see [Going further](#going-further).
+
+---
+
+## Why this exists
+
+Sending a PDF by email tells you nothing. Did they open it? Did they reach the page with the
+price? Did they forward it? The products that answer those questions are SaaS: your commercial
+documents, your prospects' email addresses and your reading data live on someone else's servers.
+
+This player answers the same questions and runs on your own infrastructure.
+
+|  | What you get |
+|---|---|
+| **Tracked links** | One link per recipient. Revocable. Re-shares are chained to their parent, so you see when a document travels. |
+| **Reading analytics** | Time per page, furthest page reached, device. Counted only while the tab is visible and focused — an open tab in the background is not reading. |
+| **Live presentation** | Present a document to a remote audience, with chat, presence, and handover. The audience follows your page without a video call. |
+| **Access wall** | Optional: a document can require an email + code before it opens. |
+| **Brand per client** | The loader carries your client's logo, resolved at display time — fix a logo and links already in inboxes follow. |
+| **Anything on disk** | PDFs and images from a local folder, from S3-compatible storage, or from your own application's file route. |
+
+Two populations are never merged: a prospect reading your proposal and a colleague re-reading
+it in-house produce different records. Mixing them makes "this prospect read for 12 minutes"
+a lie, which is worse than having no number at all.
+
+---
+
+## How it fits your application
+
+The player is a request handler, not a framework. It knows nothing about the application that
+hosts it: everything it borrows — storage, database, identity, rate limits, branding, logging —
+arrives through a single injected context.
+
+```mermaid
+flowchart LR
+    R([Reader]) -->|/doc/:slug| P
+    subgraph P["Discovery Media Player"]
+        H[handler] --- D[(shares · presentations)]
+    end
+    P -->|"context.identity<br/>context.branding"| A["Your application"]
+    P -->|"context.storage"| F[("Files<br/>disk · S3 · your route")]
+    A -.->|"iframe + postMessage"| P
+```
+
+That seam is what lets one codebase serve several products without either of them
+forking it. A fix lands once and reaches every instance on its next deploy.
+
+- **Serverless** — `module.exports = require("discovery-media-player").handler`
+- **Node / Express / Next.js** — same handler, mounted on a route
+- **Standalone** — `npm start`, or the Docker image
+
+See [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the boundary, and
+[`docs/API.md`](docs/API.md) for the surface an integrator implements.
+
+---
+
+## Going further
+
+Tracked links, analytics and live presentation need a Postgres database (Supabase REST for now):
+
+```bash
+psql "$DATABASE_URL" -f supabase/init.sql
+```
+
+One file, replayable, no migration history to sort through. It installs **already hardened** —
+no anonymous read policy is ever created.
+
+Minimum configuration:
+
+| Variable | What it does |
+|---|---|
+| `PLAYER_LOCAL_ROOT` | serve documents from a folder (the two-minute demo) |
+| `SUPABASE_URL`, `SUPABASE_SERVICE_ROLE_KEY` | tracked links, analytics, presentations |
+| `PLAYER_BRAND_NAME`, `PLAYER_LOADER_NAME` | your name in the tab title and the loader |
+| `PLAYER_SOURCE_URL` | where readers can obtain the source (AGPL, see below) |
+
+Full list: [`docs/CONFIGURATION.md`](docs/CONFIGURATION.md).
+Examples you can copy: [`examples/`](examples/).
+
+---
+
+## Security
+
+The file proxy denies by default. It accepts three sources and nothing else: a public object
+on an allow-listed storage origin, one explicitly configured route of your own application,
+or a file under a configured local root. No credentials in URLs, no redirect following into
+your private network.
+
+Found a hole? [`SECURITY.md`](SECURITY.md) — please do not open a public issue.
+
+---
+
+## Licence
+
+**AGPL-3.0-or-later** ([`LICENSE`](LICENSE)). It carries an obligation most licences do not:
+if you run a modified version and people read documents through it over a network, they must be
+able to obtain your source. Set `PLAYER_SOURCE_URL` to where yours lives — the pages served
+link to it.
+
+One exception, on purpose: **[`src/bridge.ts`](src/bridge.ts) is MIT**
+([`LICENSE-MIT`](LICENSE-MIT)). It is the message contract a host application imports to talk to
+the player. Putting it under the core licence would make integration itself a toll. We protect
+the player, not the people plugging into it.
+
+---
+
+## Contributing
+
+[`CONTRIBUTING.md`](CONTRIBUTING.md) — how to run the tests, what the review looks for, and the
+one rule that matters: a behaviour worth keeping is worth a test that fails without it.
+
+The code comments are in French. The project was built in a French company and the reasoning
+behind each decision is written where the decision is; translating it would have meant either
+losing it or maintaining two versions. Everything an integrator needs is in English.

package/bin/__tests__/serve.test.js

@@ -0,0 +1,84 @@
+// LE SERVEUR AUTONOME — la preuve que le cœur ne dépend d'aucune plateforme.
+//
+// Le player est un gestionnaire `(req, res)` : Vercel, Next.js, Express et le serveur HTTP de Node
+// l'acceptent tel quel. Ce test tient cette promesse — si un jour le cœur se met à exiger un objet
+// de requête particulier, c'est ici que ça casse, pas chez celui qui essaie de l'héberger.
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const racine = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "player-serve-")));
+fs.writeFileSync(path.join(racine, "rapport.pdf"), "%PDF-1.4 " + "x".repeat(400));
+process.env.PLAYER_LOCAL_ROOT = racine;
+
+const { versParametres } = require("../serve.js");
+
+const params = (chemin) => versParametres(new URL("http://localhost:3000" + chemin));
+
+describe("traduction des chemins publics", () => {
+  // ⚠️ Ces deux formes vivent dans des courriels envoyés à des tiers. Elles ne changent jamais.
+  it("garde /doc/:slug et /present/:slug", () => {
+    expect(params("/doc/Ab3-_xYz9012")).toMatchObject({ slug: "Ab3-_xYz9012" });
+    expect(params("/present/Ab3-_xYz9012")).toMatchObject({ present: "Ab3-_xYz9012" });
+  });
+
+  it("refuse un slug qui n'en est pas un", () => {
+    expect(params("/doc/../../etc/passwd").slug).toBeUndefined();
+  });
+
+  it("ouvre un document du dossier local par son nom", () => {
+    const q = params("/preview/rapport.pdf");
+    expect(q.preview).toBe("1");
+    expect(q.url).toBe("file://" + path.join(racine, "rapport.pdf"));
+    expect(q.name).toBe("rapport.pdf");
+  });
+});
+
+describe("le player répond sans plateforme", () => {
+  const player = require("../../server/handler.js");
+  const { createStandaloneContext } = require("../../context/standalone.js");
+  player.init(createStandaloneContext(process.env));
+
+  async function appel(query, headers = {}) {
+    const res = {
+      statusCode: 0, headers: {}, body: "",
+      setHeader(k, v) { this.headers[k.toLowerCase()] = v; },
+      end(b) { this.body = b == null ? "" : b; },
+    };
+    await player.handler({ method: "GET", headers, socket: {}, query }, res);
+    return res;
+  }
+
+  it("affiche un document du dossier local, sans base ni Storage", async () => {
+    const res = await appel(params("/preview/rapport.pdf"));
+    expect(res.statusCode).toBe(200);
+    expect(String(res.body)).toMatch(/Player\.tracking\.createTracker\(/);
+  });
+
+  it("sert le fichier avec sa vraie taille et accepte un Range", async () => {
+    const q = { ...params("/preview/rapport.pdf"), stream: "1" };
+    const entier = await appel(q);
+    expect(entier.statusCode).toBe(200);
+    expect(entier.headers["content-length"]).toBe("409");
+
+    const bout = await appel(q, { range: "bytes=0-8" });
+    expect(bout.statusCode).toBe(206);
+    expect(bout.headers["content-range"]).toBe("bytes 0-8/409");
+  });
+
+  it("dit qui il est sans configuration", async () => {
+    const carte = JSON.parse(await appel({ contract: "1" }).then((r) => r.body));
+    expect(carte.contract).toBe(1);
+    // Aucun greffon : le cœur affiche, trace et présente tout seul.
+    expect(Object.values(carte.plugins).every((v) => v === false)).toBe(true);
+  });
+
+  // ⚠️ Le défaut qui compte : sans câblage, le player ne SAIT PAS qui a le droit de diffuser.
+  // Il refuse. Un droit qu'on ne sait pas accorder ne s'accorde pas.
+  it("refuse la diffusion tant que l'hôte n'a pas répondu", async () => {
+    const ctx = createStandaloneContext({ ...process.env, PLAYER_HOST_AUTHZ_URL: "" });
+    expect(await ctx.identity.canManageShares({ email: "a@b.fr" }, "create")).toBe(false);
+    expect(await ctx.identity.canManageShares(null, "create")).toBe(false);
+  });
+});

package/bin/serve.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// SERVEUR AUTONOME — le player sans plateforme.
+//
+// Le cœur est un gestionnaire `(req, res)` sans framework : c'est ce qui lui permet de tourner
+// sur Vercel, dans Next.js, derrière Express… ou ici, sur le serveur HTTP de Node, sans rien
+// d'autre. Ce fichier est la preuve la moins coûteuse de cette portabilité — et le point d'entrée
+// de l'image Docker.
+//
+//   node bin/serve.js                    # PLAYER_LOCAL_ROOT=./documents suffit à afficher
+//   PORT=8080 node bin/serve.js
+//
+// Il ne fait que trois choses : traduire des chemins jolis en paramètres, servir un point de
+// santé, et déléguer. Toute la logique est dans le player.
+
+const http = require("node:http");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+const player = require("../server/handler");
+const { createStandaloneContext } = require("../context/standalone");
+
+const PORT = Number(process.env.PORT || 3000);
+const HOST = process.env.HOST || "0.0.0.0";
+
+player.init(createStandaloneContext(process.env));
+
+
+/**
+ * Chemins publics → paramètres du player.
+ *
+ * ⚠️ `/doc/:slug` et `/present/:slug` sont des URL qui vivent dans des courriels envoyés à des
+ * tiers. Elles ne changent pas, jamais : un lien tracé cassé, c'est une relation commerciale qui
+ * tombe sur une page d'erreur.
+ */
+function versParametres(url) {
+  const q = Object.fromEntries(url.searchParams);
+  // Confort du mode dossier : `/preview/rapport.pdf` ouvre le document de ce nom dans la racine
+  // locale. Purement cosmétique — la garde reste seule juge, et un nom qui remonte d'un cran
+  // (`..`) ne la franchira pas. C'est ce qui rend l'essai possible sans construire une URL `file:`.
+  const local = /^\/preview\/(.+)$/.exec(url.pathname);
+  if (local && process.env.PLAYER_LOCAL_ROOT) {
+    const nom = decodeURIComponent(local[1]);
+    const chemin = path.resolve(process.env.PLAYER_LOCAL_ROOT, nom);
+    return { ...q, preview: "1", url: pathToFileURL(chemin).href, name: path.basename(nom), title: q.title || path.basename(nom) };
+  }
+  const doc = /^\/doc\/([A-Za-z0-9_-]{1,64})$/.exec(url.pathname);
+  if (doc) return { ...q, slug: doc[1] };
+  const present = /^\/present\/([A-Za-z0-9_-]{1,64})$/.exec(url.pathname);
+  if (present) return { ...q, present: present[1] };
+  return q;
+}
+
+const serveur = http.createServer(async (req, res) => {
+  const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
+
+  // Point de santé : un orchestrateur doit pouvoir savoir si le processus répond sans ouvrir un
+  // document ni toucher la base.
+  if (url.pathname === "/healthz") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true }));
+    return;
+  }
+
+  const q = versParametres(url);
+  const routeConnue =
+    url.pathname === "/api/doc" || url.pathname === "/doc" || url.pathname === "/present" ||
+    q.slug || q.present || q.preview || q.contract;
+  if (!routeConnue) {
+    res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("Not found");
+    return;
+  }
+
+  // Le player lit `req.query` (convention des plateformes serverless) et `req.body` déjà analysé.
+  req.query = q;
+  if (req.method === "POST") {
+    req.body = await lireCorpsJson(req);
+  }
+
+  try {
+    await player.handler(req, res);
+  } catch (error) {
+    console.error("[player] erreur non rattrapée", error);
+    if (!res.headersSent) res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("Erreur");
+  }
+});
+
+/** Corps JSON, borné. Un corps sans fin est une façon peu coûteuse de faire tomber un serveur. */
+function lireCorpsJson(req, maxOctets = 1_000_000) {
+  return new Promise((resolve) => {
+    let taille = 0;
+    const morceaux = [];
+    req.on("data", (c) => {
+      taille += c.length;
+      if (taille > maxOctets) { req.destroy(); resolve({}); return; }
+      morceaux.push(c);
+    });
+    req.on("end", () => {
+      try { resolve(JSON.parse(Buffer.concat(morceaux).toString("utf8") || "{}")); }
+      catch { resolve({}); }
+    });
+    req.on("error", () => resolve({}));
+  });
+}
+
+// N'écoute QUE lorsqu'on lance ce fichier. Sans cette garde, un test qui l'importe ouvrirait un
+// port — et deux tests en parallèle s'attraperaient sur le même.
+if (require.main === module) serveur.listen(PORT, HOST, () => {
+  const racine = process.env.PLAYER_LOCAL_ROOT;
+  console.log(`Discovery Media Player — http://localhost:${PORT}`);
+  console.log(racine ? `  documents : ${racine}` : "  documents : aucun dossier local (PLAYER_LOCAL_ROOT)");
+  console.log(`  état      : http://localhost:${PORT}/api/doc?contract=1`);
+});
+
+module.exports = { serveur, versParametres };

package/context/__tests__/storage.test.js

@@ -0,0 +1,99 @@
+// LE DOSSIER LOCAL — la source qui rend le player essayable, et celle qui pourrait tout ouvrir.
+//
+// Servir un dossier est le mode d'exploitation le plus simple (aucune base, aucun Storage) et le
+// plus dangereux si la contenance est approximative : un `..`, un lien symbolique, une racine
+// voisine dont le nom commence pareil. Ces tests sont la raison pour laquelle on peut la proposer.
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const { localRoot, resolveLocal, isAllowedStorageUrl, fetchAllowedFile } =
+  require("../storage.js");
+
+const base = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "player-")));
+const racine = path.join(base, "documents");
+const voisin = path.join(base, "documents-prives");   // ⚠️ commence comme la racine
+fs.mkdirSync(racine); fs.mkdirSync(voisin);
+fs.writeFileSync(path.join(racine, "rapport.pdf"), "%PDF-1.4 " + "x".repeat(200));
+fs.writeFileSync(path.join(voisin, "salaires.pdf"), "%PDF-1.4 confidentiel");
+fs.writeFileSync(path.join(base, "dehors.pdf"), "%PDF-1.4 dehors");
+try { fs.symlinkSync(path.join(base, "dehors.pdf"), path.join(racine, "evasion.pdf")); } catch { /* FS sans liens */ }
+
+const root = localRoot({ PLAYER_LOCAL_ROOT: racine });
+const url = (p) => "file://" + p;
+
+describe("racine locale", () => {
+  it("n'existe que si on la demande — aucun fichier local par défaut", () => {
+    expect(localRoot({})).toBeNull();
+    expect(isAllowedStorageUrl(url(path.join(racine, "rapport.pdf")), [], null, null)).toBe(false);
+  });
+
+  it("accepte un document de la racine", () => {
+    expect(resolveLocal(url(path.join(racine, "rapport.pdf")), root)).toBe(path.join(racine, "rapport.pdf"));
+    expect(isAllowedStorageUrl(url(path.join(racine, "rapport.pdf")), [], null, root)).toBe(true);
+  });
+
+  // ⚠️ Le piège de la comparaison de chaînes : `/…/documents` accepterait `/…/documents-prives`.
+  // C'est le même défaut que la barre finale d'un préfixe d'URL, une couche plus bas.
+  it("ne confond pas un dossier voisin dont le nom commence pareil", () => {
+    expect(resolveLocal(url(path.join(voisin, "salaires.pdf")), root)).toBeNull();
+  });
+
+  it("ne remonte pas hors de la racine", () => {
+    expect(resolveLocal(url(path.join(racine, "..", "dehors.pdf")), root)).toBeNull();
+    expect(resolveLocal(url("/etc/passwd"), root)).toBeNull();
+  });
+
+  // Un lien posé DANS la racine et pointant dehors : le chemin normalisé a l'air bon, le fichier
+  // réel ne l'est pas. Seule la résolution des liens le voit.
+  it("ne suit pas un lien symbolique qui sort de la racine", () => {
+    const lien = path.join(racine, "evasion.pdf");
+    if (!fs.existsSync(lien)) return;
+    expect(resolveLocal(url(lien), root)).toBeNull();
+  });
+
+  it("refuse un octet nul et tout ce qui n'est pas un fichier", () => {
+    expect(resolveLocal("file://" + path.join(racine, "rapport.pdf") + "%00.png", root)).toBeNull();
+    expect(resolveLocal("https://exemple.fr/x.pdf", root)).toBeNull();
+    expect(resolveLocal("", root)).toBeNull();
+  });
+});
+
+describe("lecture d'un fichier local", () => {
+  const source = { origins: [], hostBase: null, root };
+
+  it("sert le fichier entier avec sa vraie taille", async () => {
+    const r = await fetchAllowedFile(url(path.join(racine, "rapport.pdf")), {}, source);
+    expect(r.status).toBe(200);
+    expect(r.headers.get("content-type")).toBe("application/pdf");
+    expect(Buffer.from(await r.arrayBuffer()).length).toBe(209);
+  });
+
+  // Le chargement progressif de pdf.js en dépend : sans Range, un document lourd reste blanc.
+  it("honore un Range, et le dit", async () => {
+    const r = await fetchAllowedFile(url(path.join(racine, "rapport.pdf")), { range: "bytes=0-8" }, source);
+    expect(r.status).toBe(206);
+    expect(r.headers.get("content-range")).toBe("bytes 0-8/209");
+    expect(Buffer.from(await r.arrayBuffer()).toString()).toBe("%PDF-1.4 ");
+  });
+
+  it("comprend un suffixe (`bytes=-10`)", async () => {
+    const r = await fetchAllowedFile(url(path.join(racine, "rapport.pdf")), { range: "bytes=-10" }, source);
+    expect(r.status).toBe(206);
+    expect(r.headers.get("content-range")).toBe("bytes 199-208/209");
+  });
+
+  it("répond 416 sur une borne absurde plutôt que de servir n'importe quoi", async () => {
+    const r = await fetchAllowedFile(url(path.join(racine, "rapport.pdf")), { range: "bytes=9999-" }, source);
+    expect(r.status).toBe(416);
+  });
+
+  it("ne lit rien hors de la racine, même si le chemin existe", async () => {
+    expect(await fetchAllowedFile(url(path.join(voisin, "salaires.pdf")), {}, source)).toBeNull();
+  });
+
+  it("ne sert pas un dossier", async () => {
+    expect(await fetchAllowedFile(url(racine), {}, source)).toBeNull();
+  });
+});

package/context/standalone.js

@@ -0,0 +1,224 @@
+// CONTEXTE PAR DÉFAUT — de quoi faire tourner une instance sans écrire une ligne.
+//
+// L'architecture veut qu'un hôte écrive son câblage : c'est ce qui lui permet de brancher SON
+// modèle de droits, SA base, SA marque. Mais exiger ce fichier avant le premier document rendrait
+// le projet inessayable — et « inessayable » est la façon la plus sûre de n'être jamais essayé.
+//
+// Ce contexte-ci couvre le cas courant à partir de variables d'environnement seules :
+//   • un dossier de documents (`PLAYER_LOCAL_ROOT`) ou un Storage Supabase ;
+//   • une base Supabase pour les liens tracés et les présentations — FACULTATIVE ;
+//   • les décisions propres à l'hôte (qui a le droit de diffuser, quelle marque pour quel client)
+//     déléguées à des routes de l'hôte, ou refusées si elles ne sont pas configurées.
+//
+// ⚠️ Il ne remplace pas un câblage : il ne sait rien de vos rôles. Ce qu'il ne sait pas, il le
+// REFUSE — jamais il n'accorde par défaut. Cf. CONTRAT.md, « Le câblage d'une instance ».
+
+const storage = require("./storage");
+
+/** Client REST minimal (PostgREST). Absent de configuration ⇒ chaque appel échoue franchement. */
+function creerDb(env) {
+  const url = String(env.SUPABASE_URL || "").replace(/\/+$/, "");
+  const cle = String(env.SUPABASE_SERVICE_ROLE_KEY || "");
+
+  async function request(chemin, options = {}) {
+    if (!url || !cle) {
+      // Message explicite plutôt que `undefined` plus loin : sans base, ce sont les liens tracés
+      // et les présentations qui sont indisponibles — pas l'affichage d'un document.
+      throw new Error(
+        "Base non configurée : SUPABASE_URL et SUPABASE_SERVICE_ROLE_KEY sont requis pour les " +
+        "liens tracés et les présentations. L'aperçu de documents fonctionne sans.",
+      );
+    }
+    const methode = String(options.method || "GET").toUpperCase();
+    const r = await fetch(`${url}/rest/v1/${chemin}`, {
+      method: methode,
+      headers: {
+        apikey: cle,
+        Authorization: `Bearer ${cle}`,
+        "Content-Type": "application/json",
+        ...(options.headers || {}),
+      },
+      body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+    if (!r.ok) throw new Error(`Supabase ${methode} ${chemin} → ${r.status}`);
+    const texte = await r.text();
+    return texte ? JSON.parse(texte) : null;
+  }
+
+  /** Lecture paginée complète : un document très partagé dépasse la pagination par défaut. */
+  async function selectAll(chemin, taille = 1000) {
+    const tout = [];
+    for (let debut = 0; ; debut += taille) {
+      const lot = await request(chemin, { headers: { Range: `${debut}-${debut + taille - 1}` } });
+      if (!Array.isArray(lot) || !lot.length) return tout;
+      tout.push(...lot);
+      if (lot.length < taille) return tout;
+    }
+  }
+
+  return { request, selectAll, configuree: !!(url && cle) };
+}
+
+/**
+ * Appel d'une route de l'HÔTE (autorisation, marque). Authentifié par le même secret partagé que
+ * la route de fichiers, et **jamais en query** : les journaux gardent les URL.
+ */
+async function appelHote(url, secret, corps) {
+  if (!url) return null;
+  try {
+    const r = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(secret ? { "x-player-fetch-secret": secret } : {}),
+      },
+      body: JSON.stringify(corps),
+      signal: AbortSignal.timeout(4000), // une décision qui tarde est une décision absente
+    });
+    return r.ok ? await r.json() : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Limites en mémoire, PAR PROCESSUS.
+ *
+ * ⚠️ Honnête sur ce que c'est : derrière plusieurs instances, chacune compte les siennes — la
+ * limite réelle est donc N fois celle annoncée. C'est suffisant pour freiner une boucle, pas pour
+ * contenir un attaquant déterminé. Un hôte sérieux branche un compteur partagé dans son câblage.
+ */
+function creerLimites() {
+  const seaux = new Map();
+  return {
+    async allow(cle, max, fenetreSecondes) {
+      const maintenant = Date.now();
+      const debut = maintenant - fenetreSecondes * 1000;
+      const vus = (seaux.get(cle) || []).filter((t) => t > debut);
+      if (vus.length >= max) { seaux.set(cle, vus); return false; }
+      vus.push(maintenant);
+      seaux.set(cle, vus);
+      if (seaux.size > 5000) for (const [k, v] of seaux) if (!v.some((t) => t > debut)) seaux.delete(k);
+      return true;
+    },
+  };
+}
+
+/** Construit le contexte d'une instance autonome à partir de l'environnement. */
+function createStandaloneContext(env = process.env) {
+  const db = creerDb(env);
+  const secret = String(env.PLAYER_HOST_FETCH_SECRET || "");
+  const origins = () => storage.storageOrigins(env);
+  const hostBase = () => storage.hostFetchBase(env);
+  const root = () => storage.localRoot(env);
+
+  return {
+    // Aucun greffon : l'assistant IA, l'intro de marque et les comptes visiteurs sont des produits
+    // d'un hôte particulier. Le cœur affiche, trace et présente sans eux — c'est testé.
+    plugins: {},
+    has() { return false; },
+
+    storage: {
+      get allowedOrigins() { return origins(); },
+      get hostFetchBase() { return hostBase(); },
+      isAllowedUrl: (url) => storage.isAllowedStorageUrl(url, origins(), hostBase(), root()),
+      fetchFile: (url, options) => storage.fetchAllowedFile(url, options, {
+        origins: origins(), hostBase: hostBase(), root: root(), secret,
+      }),
+      // Écriture de fichier : hors périmètre d'une instance autonome (elle sert, elle ne range pas).
+      async put() { throw new Error("storage.put n'est pas disponible sans câblage d'hôte"); },
+    },
+
+    db: { request: db.request, selectAll: db.selectAll },
+
+    // Sans expéditeur configuré, le re-partage et le code du mur d'accès sont indisponibles — et
+    // le disent. Ils ne prétendent pas avoir envoyé.
+    mail: { async send() { return null; } },
+
+    identity: {
+      /** Vérifie un jeton auprès de Supabase Auth. Sans base : personne n'est authentifié. */
+      async verifyToken(authorization) {
+        const jeton = String(authorization || "").replace(/^Bearer\s+/i, "").trim();
+        const url = String(env.SUPABASE_URL || "").replace(/\/+$/, "");
+        const cle = String(env.SUPABASE_PUBLISHABLE_KEY || env.SUPABASE_SERVICE_ROLE_KEY || "");
+        if (!jeton || !url || !cle) return null;
+        try {
+          const r = await fetch(`${url}/auth/v1/user`, {
+            headers: { apikey: cle, Authorization: `Bearer ${jeton}` },
+          });
+          return r.ok ? await r.json() : null;
+        } 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(),
+      isAdmin: (user) => String(((user || {}).app_metadata || {}).role || "").toLowerCase() === "admin",
+
+      /**
+       * Qui a le droit de diffuser un document ? **Question de l'hôte, pas du player.**
+       * Sans `PLAYER_HOST_AUTHZ_URL`, la réponse est non. Un droit qu'on ne sait pas accorder ne
+       * s'accorde pas — c'est la seule position tenable pour un défaut.
+       */
+      async canManageShares(user, action) {
+        if (!user || !user.email) return false;
+        const reponse = await appelHote(env.PLAYER_HOST_AUTHZ_URL, secret, {
+          email: user.email, role: ((user.app_metadata || {}).role) || "", action: String(action || ""),
+        });
+        return !!(reponse && reponse.allowed);
+      },
+    },
+
+    limits: creerLimites(),
+
+    branding: {
+      async logo() { return String(env.PLAYER_BRAND_LOGO || "").trim(); },
+      get name() { return String(env.PLAYER_BRAND_NAME || "").trim(); },
+      get poweredBy() { return String(env.PLAYER_BRAND_POWERED_BY || "").trim(); },
+      get loaderName() { return String(env.PLAYER_LOADER_NAME || env.PLAYER_BRAND_NAME || "").trim(); },
+
+      /**
+       * Marque d'un CLIENT, résolue à l'affichage à partir d'une clé portée par le lien — jamais
+       * recopiée dans le lien. Un lien tracé vit des semaines dans une boîte mail : un logo figé à
+       * l'envoi ne suivrait pas une charte corrigée.
+       *
+       * `name` n'est pas décoratif : c'est ce qui s'affiche quand le logo ne charge pas.
+       */
+      async forKey(key) {
+        if (!key) return null;
+        const b = await appelHote(env.PLAYER_HOST_BRAND_URL, secret, { key: String(key) });
+        return b && b.logo ? { logo: String(b.logo), name: String(b.name || ""), dark: !!b.dark } : null;
+      },
+
+      title(base, qualificatif) {
+        const suffixe = [String(qualificatif || "").trim(), String(env.PLAYER_BRAND_NAME || "").trim()]
+          .filter(Boolean).join(" ");
+        return suffixe ? `${base} — ${suffixe}` : base;
+      },
+    },
+
+    errors: {
+      async capture(error, meta) {
+        console.error("[player]", (meta && meta.route) || "", (error && error.stack) || error);
+      },
+    },
+
+    legal: {
+      get sourceUrl() { return String(env.PLAYER_SOURCE_URL || "https://github.com/Juli1artha/discovery-media-player").trim(); },
+      get legalUrl() { return String(env.PLAYER_LEGAL_URL || "").trim(); },
+      get privacyUrl() { return String(env.PLAYER_PRIVACY_URL || "").trim(); },
+      get trackingNotice() {
+        const perso = String(env.PLAYER_TRACKING_NOTICE || "").trim();
+        return perso || "La consultation de ce document est mesurée (pages vues, temps de lecture) et transmise à son expéditeur.";
+      },
+    },
+
+    config: {
+      supabaseUrl: env.SUPABASE_URL || "",
+      supabasePublishableKey: env.SUPABASE_PUBLISHABLE_KEY || "",
+      mapsKey: env.GOOGLE_MAPS_API_KEY || "",
+      extraFrameAncestors: String(env.DOC_FRAME_ANCESTORS || "").split(/\s+/).filter(Boolean),
+    },
+  };
+}
+
+module.exports = { createStandaloneContext };