dndkit 0.4.0__py3-none-any.whl

dndkit/ui/shared.js

@@ -0,0 +1,242 @@
+/* dndkit pages: how they get their data, and shared DOM helpers.
+ *
+ * Two transports, same pages. As an MCP App in roomkit-ui, a page gets only
+ * the tool's text result, sometimes in the widget it replaces, so it reads
+ * its data through tools/call get_screen_data and polls it. The host answers
+ * request ids as strings, may not listen yet when the page loads
+ * (ui/initialize is retried), and shows any console.error under the widget,
+ * so errors are rendered, never logged.
+ * As a web page (window.GM_WEB, set by the server), a page opens one event
+ * stream for all its views and the server pushes each change.
+ */
+"use strict";
+
+import { I18N } from "./words.js";
+
+export const GM = (() => {
+  const WEB = window.GM_WEB || null;
+  const t = I18N.t;
+  const pending = new Map();
+  const inputWaiters = [];
+  const RETRY_AFTER_REFUSAL_MS = 10000;
+  const resultHandlers = [];
+  let nextId = 1;
+  let ready = false;
+  let input = null;
+  let lastHeight = 0;
+
+  const post = (message) => window.parent.postMessage({ jsonrpc: "2.0", ...message }, "*");
+  const notify = (method, params) => post({ method, params });
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  function request(method, params, timeoutMs) {
+    const id = nextId++;
+    post({ id, method, params });
+    return new Promise((resolve, reject) => {
+      pending.set(String(id), { resolve, reject });
+      setTimeout(() => {
+        if (pending.delete(String(id))) reject(new Error("timeout"));
+      }, timeoutMs);
+    });
+  }
+
+  window.addEventListener("message", (event) => {
+    const msg = event.data;
+    if (!msg || msg.jsonrpc !== "2.0") return;
+    if (msg.id !== undefined && msg.method === undefined) {
+      const waiter = pending.get(String(msg.id));
+      if (!waiter) return;
+      pending.delete(String(msg.id));
+      if (msg.error) waiter.reject(new Error(msg.error.message || "error"));
+      else waiter.resolve(msg.result);
+    } else if (msg.method === "ui/notifications/tool-input") {
+      input = (msg.params && msg.params.arguments) || {};
+      inputWaiters.splice(0).forEach((resolve) => resolve(input));
+    } else if (msg.method === "ui/notifications/tool-result") {
+      resultHandlers.forEach((handler) => handler(msg.params || {}));
+    }
+  });
+
+  async function connect() {
+    for (let attempt = 0; attempt < 10 && !ready; attempt++) {
+      try {
+        await request(
+          "ui/initialize",
+          {
+            protocolVersion: "2026-01-26",
+            appInfo: { name: "dndkit", version: "1" },
+            appCapabilities: {},
+          },
+          800,
+        );
+        ready = true;
+      } catch (_) {
+        /* the host was not listening yet: ask again */
+      }
+    }
+    notify("ui/notifications/initialized", {});
+  }
+
+  /** The arguments the model called the tool with ({} if none arrive). */
+  function toolInput(timeoutMs = 3000) {
+    if (input) return Promise.resolve(input);
+    return new Promise((resolve) => {
+      inputWaiters.push(resolve);
+      setTimeout(() => resolve(input || {}), timeoutMs);
+    });
+  }
+
+  async function callTool(name, args) {
+    const result = await request("tools/call", { name, arguments: args || {} }, 15000);
+    const text = ((result && result.content) || [])
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .join("\n");
+    if (result && result.isError) throw new Error(text || "error");
+    return text;
+  }
+
+  const data = async (view, extra) =>
+    JSON.parse(await callTool("get_screen_data", { view, ...(extra || {}) }));
+
+  /** Render *view* now and at every change: pushed on the web, polled in a widget. */
+  function live(view, extra, render, intervalMs) {
+    if (WEB) return feed.add(view, render);
+    let previous = "";
+    let failures = 0;
+    const tick = async () => {
+      try {
+        const text = await callTool("get_screen_data", { view, ...(extra || {}) });
+        failures = 0;
+        if (text !== previous) {
+          previous = text;
+          render(JSON.parse(text));
+          status("");
+        }
+      } catch (error) {
+        failures += 1;
+        status(error.message);
+      }
+      if (failures < 5) setTimeout(tick, intervalMs);
+    };
+    tick();
+  }
+
+  /** The web pages' one event stream: every view a page shows, sent at each change. */
+  const feed = {
+    renders: new Map(),
+    errors: new Map(), // view -> its last error, until it renders again
+    source: null,
+    add(view, render) {
+      if (!this.renders.has(view)) this.renders.set(view, []);
+      this.renders.get(view).push(render);
+      if (!this.source) this.source = Promise.resolve().then(() => this.open());
+    },
+    show() {
+      status([...new Set(this.errors.values())].join(" · "));
+    },
+    open() {
+      const views = [...this.renders.keys()].join(",");
+      const source = new EventSource(`${WEB.feed}?views=${encodeURIComponent(views)}`);
+      for (const [view, renders] of this.renders) {
+        source.addEventListener(view, (event) => {
+          const data = JSON.parse(event.data);
+          if (data.error) this.errors.set(view, t(data.error));
+          else {
+            this.errors.delete(view);
+            renders.forEach((render) => render(data));
+          }
+          this.show();
+        });
+      }
+      // The browser reconnects by itself, and the server then sends every view
+      // again; after a refusal (a link that no longer matches) it gives up, so
+      // the page tries again a little later.
+      source.onerror = () => {
+        status(t("offline"));
+        if (source.readyState !== EventSource.CLOSED) return;
+        setTimeout(() => this.open(), RETRY_AFTER_REFUSAL_MS);
+      };
+      source.onopen = () => this.show();
+    },
+  };
+
+  function fit() {
+    if (WEB) return;
+    const height = Math.ceil(document.body.getBoundingClientRect().height) + 2;
+    if (Math.abs(height - lastHeight) < 4) return;
+    lastHeight = height;
+    notify("ui/notifications/size-changed", { width: document.body.scrollWidth, height });
+  }
+
+  function status(message) {
+    const box = document.getElementById("status");
+    if (box) box.textContent = message || "";
+    fit();
+  }
+
+  /** Children to append: nested lists flattened, empty values dropped
+   *  (DOM methods would print null as the text "null"). */
+  const nodes = (children) =>
+    children
+      .flat(Infinity)
+      .filter((child) => child !== null && child !== undefined && child !== false && child !== "")
+      .map((child) => (child instanceof Node ? child : document.createTextNode(String(child))));
+
+  /** Replace an element's content. */
+  const fill = (el, ...children) => el.replaceChildren(...nodes(children));
+
+  /** Build DOM without innerHTML: names come from players and the model. */
+  function h(tag, attrs, ...children) {
+    const el = document.createElement(tag);
+    for (const [key, value] of Object.entries(attrs || {})) {
+      if (value === null || value === undefined || value === false) continue;
+      if (key === "class") el.className = value;
+      else if (key === "style") el.style.cssText = value;
+      else el.setAttribute(key, value === true ? "" : value);
+    }
+    el.append(...nodes(children));
+    return el;
+  }
+
+  function hpBar(hp, max, temp) {
+    if (hp === null || hp === undefined || !max) return h("div", { class: "muted small" }, t("hp") + " ?");
+    const ratio = Math.max(0, Math.min(1, hp / max));
+    const tone = ratio > 0.5 ? "" : ratio > 0.25 ? " mid" : " low";
+    const label = `${hp}/${max}` + (temp ? ` (+${temp} ${t("temp")})` : "");
+    return h(
+      "div",
+      { class: "hp" },
+      h("div", { class: "hpbar" + tone }, h("i", { style: `width:${ratio * 100}%` })),
+      h("span", { class: "hplabel" }, label),
+    );
+  }
+
+  /** A creature's conditions (turns left on a timed one), exhaustion and spell held. */
+  const conditions = ({ conditions: names, rounds, exhaustion, concentration }) =>
+    h(
+      "div",
+      { class: "chips" },
+      concentration ? h("span", { class: "chip conc", title: t("concentration") }, `◎ ${concentration}`) : null,
+      (names || []).map((name) => h("span", { class: "chip cond" },
+        rounds && rounds[name] ? `${t(name)} · ${t("turnsLeft", { n: rounds[name] })}` : t(name))),
+      exhaustion ? h("span", { class: "chip warn" }, `${t("exhaustion")} ${exhaustion}`) : null,
+    );
+
+  function pips(filled, total, kind) {
+    return h(
+      "span",
+      { class: "pips " + (kind || "") },
+      Array.from({ length: total }, (_, i) => h("i", { class: i < filled ? "on" : "" })),
+    );
+  }
+
+  /** Connect to the host (a widget) or not (a web page), then run the page's main function. */
+  function start(main) {
+    if (!WEB) new ResizeObserver(fit).observe(document.body);
+    (WEB ? Promise.resolve() : connect()).then(main).catch((error) => status(error.message));
+  }
+
+  return { web: Boolean(WEB), start, toolInput, data, live, callTool, h, fill, t, hpBar, conditions, pips,
+    status, fit, sleep, onResult: (handler) => resultHandlers.push(handler) };
+})();

dndkit/ui/sheet.js

@@ -0,0 +1,75 @@
+/* A character sheet as its player reads it: who they are, their numbers, how
+ * they cast, their spells (each opening on its description), their gear,
+ * proficiencies and story. */
+"use strict";
+
+import { I18N } from "./words.js";
+import { GM } from "./shared.js";
+
+export function CharacterSheet() {
+  const { h, fill, t } = GM;
+  const signed = (n) => (n >= 0 ? `+${n}` : `${n}`);
+  const section = (title, ...content) => h("div", { class: "section" }, h("h4", {}, title), ...content);
+  const chips = (items) => h("div", { class: "list" }, items.map((item) => h("span", { class: "chip" }, item)));
+  const bonus = (name, value) => (value === null || value === undefined ? name : `${name} ${signed(value)}`);
+  const stat = ([label, value]) => h("div", { class: "stat" }, h("b", {}, value), h("span", {}, label));
+  const el = h("div", { class: "card sheet" }, h("div", { class: "empty" }, "…"));
+
+  const spell = (s) => h("details", { class: "spell" + (s.prepared ? " prepared" : "") },
+    h("summary", {}, h("b", {}, s.name), " ",
+      h("span", { class: "muted small" }, s.level === 0 ? t("cantrip") : `${t("level")} ${s.level}`),
+      s.prepared ? h("span", { class: "chip warn" }, t("prepared")) : null),
+    s.details ? h("div", { class: "muted small" }, s.details) : null,
+    s.description ? h("p", { class: "small" }, s.description) : null);
+
+  const item = (i) => h("div", { class: "item" },
+    i.slot ? h("span", { class: "chip" }, i.slot) : null, " ",
+    h("b", {}, i.qty > 1 ? `${i.name} ×${i.qty}` : i.name),
+    i.details ? h("span", { class: "muted small" }, ` (${i.details})`) : null,
+    i.description ? h("span", { class: "muted small" }, ` — ${i.description}`) : null);
+
+  function render(c) {
+    const stats = [[t("ac"), c.ac], [t("speed"), I18N.distance(c.speed)], [t("initiative"), signed(c.initiative)],
+      [t("proficiency"), signed(c.proficiency)], [t("xp"), c.xp]];
+    const casting = c.casting ? [[t("castsWith"), t(c.casting.ability.slice(0, 3))], [t("spellAttack"), signed(c.casting.attack)],
+      [t("spellDc"), c.casting.dc]] : [];
+    const xpRatio = c.next_level_xp ? Math.min(1, c.xp / c.next_level_xp) : 1;
+    const identity = [c.background, c.alignment].filter(Boolean).join(" · ");
+    const deathSaves = c.hp !== 0 ? null : c.stable ? h("div", { class: "small" }, t("stable")) :
+      h("div", { class: "small" }, `${t("deathSaves")} `,
+        GM.pips(c.death_saves[0], 3, "good"), " ", GM.pips(c.death_saves[1], 3, "bad"));
+    fill(el,
+      h("div", { class: "head" }, h("span", { class: "title" }, c.inspiration ? `${c.name} ★` : c.name),
+        h("span", { class: "muted small" }, c.summary + (c.player ? ` — ${c.player}` : ""))),
+      identity ? h("div", { class: "muted small identity" }, identity) : null,
+      h("div", { class: "vitals" }, GM.hpBar(c.hp, c.hp_max, c.temp)),
+      deathSaves,
+      h("div", { class: "stats" }, stats.map(stat)),
+      casting.length ? h("div", { class: "stats casting" }, casting.map(stat)) : null,
+      c.next_level_xp ? h("div", { class: "muted small" }, `${t("nextLevel")}: ${c.next_level_xp} ${t("xp")}`,
+        h("div", { class: "xp" }, h("i", { style: `width:${xpRatio * 100}%` }))) : null,
+      h("div", { class: "abilities" }, c.abilities.map((a) => h("div", { class: "ability" },
+        h("div", { class: "key" }, t(a.key)), h("div", { class: "mod" }, signed(a.mod)),
+        h("div", { class: "score" }, a.score)))),
+      GM.conditions(c),
+      c.slots.length ? section(t("slots"), h("div", { class: "list" }, c.slots.map(([level, left, max]) =>
+        h("span", { class: "slot" }, `${t("lvl")} ${level} `, GM.pips(left, max))))) : null,
+      c.spells.length ? section(t("spells"), h("div", { class: "spells" }, c.spells.map(spell))) : null,
+      c.equipment.length ? section(t("equipped"), h("div", {}, c.equipment.map(item))) : null,
+      c.inventory.length ? section(t("inventory"), h("div", {}, c.inventory.map(item))) : null,
+      c.race.subrace || c.race.traits.length ? section(c.race.subrace ? `${c.race.name} · ${c.race.subrace}` : c.race.name,
+        chips(c.race.traits)) : null,
+      c.features.length ? section(t("features"), chips(c.features)) : null,
+      c.skills.length || c.saves.length ? section(t("proficiencies"),
+        chips([...c.skills.map((s) => bonus(t(s.name), s.bonus)),
+          ...c.saves.map((s) => bonus(`${t("save")} ${t(s.name)}`, s.bonus))])) : null,
+      c.languages.length ? section(t("languages"), chips(c.languages)) : null,
+      c.description || c.bio ? section(t("story"),
+        c.description ? h("p", { class: "small appearance" }, c.description) : null,
+        c.bio ? h("p", { class: "small" }, c.bio) : null) : null,
+      h("div", { class: "muted small" }, `${t("hitDice")}: ${c.hit_dice}`),
+    );
+  }
+
+  return { el, render };
+}

dndkit/ui/table.html

@@ -0,0 +1,41 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Table</title>
+    <!--gm:shared-->
+  </head>
+  <body class="web">
+    <div id="heading"></div>
+    <div class="board">
+      <div class="col" id="main"></div>
+      <div class="col" id="side"></div>
+    </div>
+    <div id="status"></div>
+    <script>
+      // The shared screen: what everyone at the table may see, and the codes
+      // that open each character on a phone.
+      const combat = Views.combat();
+      const heading = Views.campaign();
+      document.getElementById("heading").append(heading.el);
+      const seating = Views.seating();
+      const party = Views.party({ quests: false, campaign: false });
+      const dice = Views.dice();
+      const journal = Views.journal();
+      const join = Views.join();
+      document.getElementById("main").append(combat.el, party.el, seating.el);
+      document.getElementById("side").append(dice.el, journal.el, join.el);
+
+      GM.start(() => {
+        GM.live("party", null, heading.render);
+        GM.live("seating", null, seating.render);
+        GM.live("combat", null, (data) => { combat.el.hidden = !data.in_combat; combat.render(data); });
+        GM.live("party", null, (data) => { document.title = data.campaign; party.render(data); });
+        GM.live("dice", null, dice.render);
+        GM.live("journal", null, journal.render);
+        GM.live("join", null, join.render);
+      });
+    </script>
+  </body>
+</html>

dndkit/ui/words.js

@@ -0,0 +1,120 @@
+/* dndkit pages: their words in English and French, picked from the
+ * browser's language. t("key") also passes through an unknown key, so a
+ * server message without a translation still shows. */
+"use strict";
+
+export const I18N = (() => {
+  const FRENCH = (navigator.language || "").toLowerCase().startsWith("fr");
+  const WORDS = {
+    round: ["Round", "Round"], turn: ["turn", "tour"], hp: ["HP", "PV"], ac: ["AC", "CA"],
+    total: ["Total", "Total"], advantage: ["Advantage", "Avantage"],
+    disadvantage: ["Disadvantage", "Désavantage"], waiting: ["Rolling…", "Lancer…"],
+    noCombat: ["No combat running.", "Aucun combat en cours."],
+    defeated: ["Overcome", "Vaincus"], xp: ["XP", "XP"], session: ["Session", "Session"],
+    funds: ["Funds", "Bourse"], quests: ["Active quests", "Quêtes en cours"],
+    noQuest: ["No active quest.", "Aucune quête en cours."], inCombat: ["In combat", "En combat"],
+    party: ["Party", "Groupe"], noParty: ["No character yet.", "Aucun personnage."],
+    slots: ["Spell slots", "Emplacements de sorts"], spells: ["Spells", "Sorts"],
+    inventory: ["Inventory", "Inventaire"], cantrip: ["Cantrip", "Tour de magie"],
+    level: ["Level", "Niveau"], prepared: ["prepared", "préparé"],
+    proficiency: ["Proficiency", "Maîtrise"], inspiration: ["Inspiration", "Inspiration"],
+    deathSaves: ["Death saves", "Jets contre la mort"], exhaustion: ["Exhaustion", "Épuisement"],
+    temp: ["temp", "temp"], unknown: ["unknown", "inconnu"], nextLevel: ["next level", "niveau suivant"],
+    turnOf: ["{name}'s turn", "Tour de {name}"], lvl: ["Lvl", "Niv."],
+    str: ["STR", "FOR"], dex: ["DEX", "DEX"], con: ["CON", "CON"], int: ["INT", "INT"],
+    wis: ["WIS", "SAG"], cha: ["CHA", "CHA"],
+    blinded: ["blinded", "aveuglé"], charmed: ["charmed", "charmé"], deafened: ["deafened", "assourdi"],
+    frightened: ["frightened", "effrayé"], grappled: ["grappled", "agrippé"],
+    incapacitated: ["incapacitated", "neutralisé"], invisible: ["invisible", "invisible"],
+    paralyzed: ["paralyzed", "paralysé"], petrified: ["petrified", "pétrifié"],
+    poisoned: ["poisoned", "empoisonné"], prone: ["prone", "à terre"],
+    restrained: ["restrained", "entravé"], stunned: ["stunned", "étourdi"],
+    unconscious: ["unconscious", "inconscient"],
+    // How hurt a monster looks to the players.
+    unhurt: ["unhurt", "indemne"], hurt: ["hurt", "blessé"], bloodied: ["bloodied", "en sang"],
+    down: ["down", "hors de combat"],
+    speed: ["Speed", "Vitesse"], hidden: ["hidden", "caché"], boss: ["Boss", "Boss"],
+    initiative: ["Initiative", "Initiative"], castsWith: ["Casts with", "Lance avec"],
+    spellAttack: ["Spell attack", "Attaque de sort"], spellDc: ["Spell save DC", "DD des sorts"],
+    intelligence: ["Intelligence", "Intelligence"], wisdom: ["Wisdom", "Sagesse"], charisma: ["Charisma", "Charisme"],
+    features: ["Features", "Capacités"], proficiencies: ["Proficiencies", "Maîtrises"], save: ["Save", "JS"],
+    languages: ["Languages", "Langues"], story: ["Story", "Histoire"], hitDice: ["Hit dice", "Dés de vie"],
+    legendaryActions: ["Legendary actions", "Actions légendaires"],
+    legendaryResistances: ["Legendary resistances", "Résistances légendaires"],
+    // The table.
+    theTable: ["🪑 The table", "🪑 La table"], noCharacter: ["no character yet", "pas encore de personnage"],
+    nobodySeated: ["Nobody seated yet: the game master asks who is playing.",
+      "Personne n'est encore installé : le maître du jeu demande qui joue."],
+    absentees: ["Absent", "Absents"], knownPlayers: ["Known players", "Joueurs connus"],
+    noPlayer: ["No player", "Sans joueur"], away: ["absent", "absent"], unplayed: ["no player", "sans joueur"],
+    // Web pages.
+    yourTurn: ["Your turn!", "À toi de jouer !"], journal: ["Adventure log", "Journal"],
+    noEvent: ["Nothing logged yet.", "Rien de noté pour l'instant."], from: ["from {name}", "confiée par {name}"],
+    players: ["Players", "Joueurs"], showCodes: ["Join codes", "Codes joueurs"], hideCodes: ["Hide", "Masquer"],
+    scanToJoin: ["Scan your character's code to follow it on your phone.",
+      "Scanne le code de ton personnage pour le suivre sur ton téléphone."],
+    unreachable: ["Phones cannot reach this server: start it with DNDKIT_WEB_HOST=0.0.0.0.",
+      "Les téléphones ne peuvent pas joindre ce serveur : lance-le avec DNDKIT_WEB_HOST=0.0.0.0."],
+    noCampaign: ["No active campaign.", "Aucune campagne active."],
+    unknownLink: ["This link no longer matches a character of the active campaign.",
+      "Ce lien ne correspond plus à un personnage de la campagne active."],
+    offline: ["Connection lost, reconnecting…", "Connexion perdue, reconnexion…"],
+    // Skills, by their English names (PHB ch. 7) and the French translation.
+    Acrobatics: ["Acrobatics", "Acrobaties"], "Animal Handling": ["Animal Handling", "Dressage"],
+    Arcana: ["Arcana", "Arcanes"], Athletics: ["Athletics", "Athlétisme"], Deception: ["Deception", "Tromperie"],
+    History: ["History", "Histoire"], Insight: ["Insight", "Perspicacité"], Intimidation: ["Intimidation", "Intimidation"],
+    Investigation: ["Investigation", "Investigation"], Medicine: ["Medicine", "Médecine"], Nature: ["Nature", "Nature"],
+    Perception: ["Perception", "Perception"], Performance: ["Performance", "Représentation"],
+    Persuasion: ["Persuasion", "Persuasion"], Religion: ["Religion", "Religion"],
+    "Sleight of Hand": ["Sleight of Hand", "Escamotage"], Stealth: ["Stealth", "Discrétion"], Survival: ["Survival", "Survie"],
+    concentration: ["Concentration", "Concentration"],
+    stable: ["Stable at 0 HP", "Stabilisé à 0 PV"],
+    turnsLeft: ["{n} turns left", "{n} tours restants"],
+    reactionUsed: ["Reaction used this round", "Réaction utilisée ce round"],
+    secretRoll: ["Secret roll, for the game master", "Jet secret, pour le MJ"],
+    viewFailed: ["This part failed: see the server log.", "Cette partie a échoué : voir le journal du serveur."],
+    // Adventure log entries.
+    combat: ["combat", "combat"], roleplay: ["roleplay", "interprétation"], exploration: ["exploration", "exploration"],
+    quest: ["quest", "quête"], character: ["character", "personnage"], world: ["world", "monde"],
+    // The world, on the backstage.
+    locations: ["Locations", "Lieux"], noLocation: ["No location yet.", "Aucun lieu."],
+    partyHere: ["the party is here", "le groupe est ici"], population: ["Population", "Population"],
+    government: ["Government", "Gouvernement"], notable: ["Notable", "À remarquer"], leadsTo: ["Leads to", "Mène à"],
+    ties: ["Ties", "Liens"], inFight: ["fighting", "en combat"],
+    // Sizes ("medium" is shared with the difficulty ratings below).
+    tiny: ["tiny", "très petite"], small: ["small", "petite"],
+    large: ["large", "grande"], huge: ["huge", "très grande"], gargantuan: ["gargantuan", "gigantesque"],
+    // The desk, on the backstage.
+    activity: ["Model activity", "Activité du MJ"], noCall: ["No call yet.", "Aucun appel pour l'instant."],
+    failures: ["{n} failed", "{n} en échec"], notebook: ["Notebook", "Carnet"],
+    situation: ["Situation", "Situation"], worldNotes: ["World notes", "Notes du monde"],
+    setting: ["Setting", "Univers"], show: ["Show", "Afficher"], sessions: ["Past sessions", "Sessions passées"],
+    noNotes: ["No notes yet.", "Pas encore de notes."], dm: ["GM", "MJ"], saved: ["saved", "enregistré"],
+    skills: ["skills", "skills"],
+    lastFight: ["Last fight ({rounds} rounds):", "Dernier combat ({rounds} rounds) :"], treasure: ["Treasure", "Butin"],
+    equipped: ["Equipped", "Équipé"], stats: ["Statistics", "Statistiques"], done: ["done", "terminée"],
+    // Backstage.
+    backstage: ["Backstage", "Régie"], encounters: ["Planned encounters", "Rencontres prévues"],
+    noEncounter: ["Nothing planned.", "Rien de prévu."], npcs: ["NPCs", "PNJ"], noNpc: ["No NPC yet.", "Aucun PNJ."],
+    allQuests: ["Quests", "Quêtes"], bestiary: ["Bestiary", "Bestiaire"], noMonster: ["Empty.", "Vide."],
+    notes: ["Notes", "Notes"], reward: ["Reward", "Récompense"], secret: ["Secret", "Secret"],
+    planned: ["planned", "prévue"], running: ["running", "en cours"],
+    trivial: ["trivial", "triviale"], easy: ["easy", "facile"], medium: ["medium", "moyenne"],
+    hard: ["hard", "difficile"], deadly: ["deadly", "mortelle"],
+    friendly: ["friendly", "amical"], neutral: ["neutral", "neutre"], hostile: ["hostile", "hostile"],
+    active: ["active", "en cours"], completed: ["completed", "accomplie"], failed: ["failed", "échouée"],
+    on_hold: ["on hold", "en pause"],
+  };
+
+  function t(key, values) {
+    const text = (WORDS[key] ? WORDS[key][FRENCH ? 1 : 0] : String(key)).replace(/\{(\w+)\}/g, (_, name) =>
+      values && values[name] !== undefined ? values[name] : "");
+    // French elision: "Tour de Élodie" -> "Tour d'Élodie".
+    return FRENCH ? text.replace(/\bde ([aeiouyàâéèêëîïôûü])/gi, "d'$1") : text;
+  }
+
+  /** A distance as the players' books give it: feet, or metres in French (5 ft = 1.5 m). */
+  const distance = (feet) => (FRENCH ? `${(feet * 0.3).toLocaleString("fr")} m` : `${feet} ft`);
+
+  return { t, distance, FRENCH };
+})();

dndkit/ui/world.js

@@ -0,0 +1,56 @@
+/* The world as the game master knows it, for the backstage: NPCs with their
+ * secrets, the places (the party's own marked), and the bestiary's stat
+ * blocks. Each entry opens on its details. */
+"use strict";
+
+import { GM } from "./shared.js";
+
+export function World() {
+  const { h, fill, t } = GM;
+  const empty = (key) => h("div", { class: "empty small" }, t(key));
+  const lists = { npcs: h("div"), locations: h("div"), monsters: h("div") };
+  const card = (title, list) => h("div", { class: "card world" },
+    h("div", { class: "head" }, h("span", { class: "title" }, title)), list);
+  const el = h("div", { class: "worldgrid" },
+    card(t("npcs"), lists.npcs), card(t("locations"), lists.locations), card(t("bestiary"), lists.monsters));
+  const fact = (label, value) => (value || value === 0
+    ? h("div", { class: "small" }, h("b", {}, `${label} `), Array.isArray(value) ? value.join(", ") : value)
+    : null);
+  const secret = (label, text) => (text ? h("div", { class: "note small" }, h("b", {}, `${label} `), text) : null);
+  const line = (...parts) => parts.filter(Boolean).join(" · ");
+  const signed = (n) => (n >= 0 ? `+${n}` : `${n}`);
+
+  const entry = (summary, ...body) => h("details", { class: "entry" }, h("summary", {}, ...summary), ...body);
+
+  const npc = (n) => entry(
+    [h("b", {}, n.name), n.attitude ? h("span", { class: `chip ${n.attitude}` }, t(n.attitude)) : null,
+      h("span", { class: "muted small" }, line(n.race, n.occupation, n.location))],
+    n.description ? h("p", { class: "small" }, n.description) : null,
+    fact(t("ties"), n.ties.length ? n.ties : null), fact(t("stats"), n.stats.length ? n.stats : null),
+    secret(`🔒 ${t("secret")}`, n.bio), secret(t("notes"), n.notes));
+
+  const place = (p) => entry(
+    [h("b", {}, p.name), h("span", { class: "muted small" }, p.type),
+      p.current ? h("span", { class: "chip here" }, `📍 ${t("partyHere")}`) : null],
+    p.description ? h("p", { class: "small" }, p.description) : null,
+    fact(t("population"), p.population), fact(t("government"), p.government),
+    fact(t("notable"), p.features.length ? p.features : null), fact(t("npcs"), p.npcs.length ? p.npcs : null),
+    fact(t("leadsTo"), p.connections.length ? p.connections : null), secret(t("notes"), p.notes));
+
+  const monster = (m) => entry(
+    [m.boss ? h("span", { class: "crown" }, "♛") : null, h("b", {}, m.name),
+      h("span", { class: "muted small" }, line(`${t("ac")} ${m.ac}`, `${t("hp")} ${m.hp}`, m.cr ? `CR ${m.cr}` : "")),
+      m.fighting ? h("span", { class: "chip warn" }, `${m.fighting} ${t("inFight")}`) : null],
+    h("div", { class: "muted small" }, line(t(m.size), m.speed, `${t("initiative")} ${signed(m.initiative)}`, `${m.xp} ${t("xp")}`)),
+    m.legendary[0] || m.legendary[1] ? h("div", { class: "small" },
+      `${t("legendaryActions")} ${m.legendary[0]} · ${t("legendaryResistances")} ${m.legendary[1]}`) : null,
+    m.actions ? h("p", { class: "small actions" }, m.actions) : null, secret(t("notes"), m.notes));
+
+  function render(data) {
+    fill(lists.npcs, data.npcs.length ? data.npcs.map(npc) : empty("noNpc"));
+    fill(lists.locations, data.locations.length ? data.locations.map(place) : empty("noLocation"));
+    fill(lists.monsters, data.monsters.length ? data.monsters.map(monster) : empty("noMonster"));
+  }
+
+  return { el, render };
+}

dndkit/views/__init__.py

@@ -0,0 +1,7 @@
+"""JSON views of the game for screens: the MCP widgets and the web pages.
+
+``everyone`` (dice, party, seats, a sheet) and ``public`` (the fight, the
+journal) are what the players may see, field by field; ``widgets`` (the fight
+in full), ``backstage`` (plans), ``world`` (NPCs, places, bestiary) and
+``desk`` (activity, notebook) add what only the game master knows.
+"""

dndkit/views/backstage.py

@@ -0,0 +1,49 @@
+"""The game master's plans: encounters still to fight and quests, notes included."""
+
+from dndkit.errors import GameError
+from dndkit.game import bestiary
+from dndkit.models import Campaign, Encounter, Quest
+from dndkit.views.everyone import Json
+
+
+def backstage(campaign: Campaign) -> Json:
+    """The plans: every encounter (running, planned, then done) and quest, notes included."""
+    order = {"running": 0, "planned": 1, "done": 2}
+    encounters = sorted(campaign.encounters.values(), key=lambda e: order[e.status])
+    return {
+        "encounters": [_encounter(campaign, e) for e in encounters],
+        "quests": [_quest(q) for q in campaign.quests.values()],
+    }
+
+
+def _encounter(campaign: Campaign, encounter: Encounter) -> Json:
+    try:
+        rated = bestiary.difficulty(campaign, encounter)
+    except GameError:  # a monster since removed from the bestiary
+        rated = None
+    return {
+        "name": encounter.name,
+        "status": encounter.status,
+        "location": encounter.location,
+        "description": encounter.description,
+        "notes": encounter.notes,
+        "monsters": [f"{g.count}× {g.monster}" for g in encounter.monsters],
+        "difficulty": rated.rating if rated else None,
+        "xp": rated.adjusted_xp if rated else None,
+    }
+
+
+def _quest(quest: Quest) -> Json:
+    return {
+        "title": quest.title,
+        "status": quest.status,
+        "giver": quest.giver,
+        "description": quest.description,
+        "objectives": [
+            {"text": text, "done": text in quest.completed_objectives} for text in quest.objectives
+        ],
+        "done": len(quest.completed_objectives),
+        "total": len(quest.objectives),
+        "reward": quest.reward,
+        "notes": quest.notes,
+    }