rpg-engine 0.0.0-stage → 0.1.1

package/dist/commands/show.js

@@ -0,0 +1,216 @@
+import { z } from "zod";
+import { requireCampaign } from "../campaign/index.js";
+import { defineCommand } from "../core/registry.js";
+import { comparableText, sameName, valueNamed, withArticle } from "../core/text.js";
+import { backlinks, baseChain, findPage, formatFields, inheritedByBase, inheritedFields, locate, namesakes, pageNamed, pagesWithName, parsePageReference, readSection, secretNames, sectionTitles, systemLabel, systemPageNamed, textParts, } from "../pages/index.js";
+import { featureParts } from "../progression/index.js";
+import { effectiveFields, effectsOf } from "./effect-layer.js";
+import { surroundings, surroundingsText } from "./game-environment.js";
+import { closedScenes, copyLink, copyPage, openSceneLog, readOpenScene } from "./game-scene.js";
+import { campaignSystem, campaignWorld, missingSystemHint } from "./game-world.js";
+import { skippedPagesNote } from "./notes.js";
+import { featureSource, progressionOf } from "./progression.js";
+import { sheetFieldNames, sheetGroup, sheetGroupNames, sheetLines } from "./sheet.js";
+import { signedText, workedFields, workedLine, workedParts } from "./worked-out.js";
+export const show = defineCommand({
+    name: "show",
+    description: "Show a page of the world, or one of its sections or secrets, with what it inherits from the pages it derives from. "
+        + "It also says where the thing is and which pages link to it. Use it before describing anything that already exists, so that what you say matches what is written. "
+        + "The player character and the companions show their sheet in groups, such as Abilities; Page#Group shows one group with how each number is made. "
+        + 'Example: page "Old lighthouse#Cellar".',
+    group: "game",
+    readOnly: true,
+    positionals: ["page"],
+    input: z.object({
+        page: z.string().describe("name of the page, or of a copy in the open scene; Page#Name shows one section or one secret, or a group of a character's sheet"),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        const world = campaignWorld(root, context);
+        const system = campaignSystem(root, context);
+        const reference = parsePageReference(input.page);
+        if (reference.section === "") {
+            throw new Error("Give the title of the section after #, or leave out the # to see the whole page.");
+        }
+        // A scene that cannot be read shows no copies; validate reports it.
+        const { scene } = readOpenScene(root);
+        const copy = scene === undefined ? undefined : sameName(Object.keys(scene.copies), reference.name);
+        // A renamed page answers to its old name too, among its aliases (D-417).
+        const found = findPage(world, reference.name) ?? (copy === undefined ? pageNamed(world, reference.name) : undefined);
+        const page = found ?? (scene !== undefined && copy !== undefined ? copyPage(copy, scene.copies[copy]) : undefined);
+        // The open scene's title gives what happened in it so far (SCN-10).
+        if (page === undefined && scene !== undefined && reference.section === undefined && sameName([scene.title], reference.name) !== undefined) {
+            return { sceneLog: openSceneLog(root, scene) };
+        }
+        if (page === undefined) {
+            // A scene's title is no page, as the last scenes status lists.
+            const closed = closedScenes(root).find((other) => sameName([other.title], reference.name) !== undefined);
+            const named = scene !== undefined && sameName([scene.title], reference.name) !== undefined
+                ? ` ${scene.title} is the open scene, not a page: show it without a section for what happened so far.`
+                : closed === undefined
+                    ? ""
+                    : ` ${closed.title} is a scene that closed, not a page (${closed.type}): ${closed.summary}`;
+            throw new Error(`There is no page named ${reference.name}${scene === undefined ? "" : ", nor a copy of that name in the open scene"}.${named || " Look for it with the find command."}${missingSystemHint(world)}`);
+        }
+        const isCopy = found === undefined && scene !== undefined && copy !== undefined;
+        // A section or a secret first, then a group of the sheet (DAT-2).
+        const part = reference.section === undefined ? undefined : findPart(world, page, reference.section);
+        const group = reference.section === undefined || part !== undefined ? undefined : sheetGroup(world, system, page, reference.section);
+        if (reference.section !== undefined && part === undefined && group === undefined) {
+            const groups = sheetGroupNames(world, system, page).length === 0 ? "" : ` The groups of its sheet are: ${sheetGroupNames(world, system, page).join(", ")}.`;
+            throw new Error(`${page.name} has no section or secret "${reference.section}". ${partsOf(world, page)}${groups}`);
+        }
+        const { chain, alsoIn } = isCopy ? { chain: [], alsoIn: [] } : locate(world, page);
+        const sheet = group?.lines ?? (reference.section === undefined ? sheetLines(world, system, page) : []);
+        const inherited = inheritedByBase(world, page);
+        return {
+            page: page.name,
+            type: page.type,
+            path: page.path,
+            system: page.system,
+            hides: page.system === undefined && !isCopy && systemPageNamed(world, page.name) !== undefined ? world.system?.name : undefined,
+            // Acolyte (background) beside the creature Acolyte: the name alone leads here (SYS-2).
+            namesakes: isCopy || reference.section !== undefined ? [] : namesakes(world, page).map((other) => `${other.name}, ${other.system === undefined ? withArticle(other.type ?? "page") : systemLabel(other)}`),
+            section: group?.name ?? reference.section,
+            copyOf: isCopy ? copyLink(scene.copies[copy]) : undefined,
+            scene: isCopy ? scene.title : undefined,
+            alsoCopy: !isCopy && copy !== undefined,
+            isIn: chain.map((holder) => holder.name),
+            alsoIn: alsoIn.map((holder) => holder.name),
+            around: page.type === "place" || page.type === "character" || isCopy ? surroundingsText(surroundings(world, isCopy ? scenePlace(world, scene.place) : page)) : "",
+            sheet,
+            featureHint: sheet.length === 0 || group !== undefined ? undefined : featureHint(world, page),
+            onSheet: sheetFieldNames(world, system, page),
+            fields: reference.section === undefined ? page.fields : undefined,
+            covered: coveredValues(world, page),
+            worked: reference.section === undefined ? workedFields(world, effectiveFields(world, page), true).map((worked) => ({ field: worked.field, line: workedLine(world, worked), repeats: repeatsRead(world, worked) })) : [],
+            group: group !== undefined,
+            systemName: world.system?.name,
+            derivesFrom: baseChain(world, page).map(nameWithSystem),
+            sectionFrom: part?.from,
+            featureOf: part?.feature === true,
+            inherited: reference.section === undefined
+                ? inherited.map((group) => ({
+                    from: nameWithSystem(group.base),
+                    fields: group.fields,
+                    text: [group.introduction, ...group.parts.map((piece) => piece.text)].filter((text) => text !== "").join("\n\n"),
+                    // The parts with text of their own, as a race's traits under its Traits heading.
+                    parts: group.parts.filter((piece) => piece.text.split("\n").slice(1).some((line) => line.trim() !== "")).map((piece) => piece.name),
+                }))
+                : [],
+            text: group === undefined ? (part?.text ?? page.body) : "",
+            linkedFrom: isCopy ? [] : backlinks(world, page).map((link) => ({ page: link.page.name, places: link.places })),
+            problems: world.problems,
+        };
+    },
+    format(result) {
+        if (result.sceneLog !== undefined) {
+            return result.sceneLog;
+        }
+        const what = result.copyOf !== undefined
+            ? `copy of ${result.copyOf} in the open scene "${result.scene}"`
+            : result.system !== undefined
+                ? `${result.type ?? "page"} of the system ${result.system}, read-only`
+                : (result.type ?? "free page");
+        const title = `${result.page}${result.section === undefined ? "" : `#${result.section}`} (${what})${result.system === undefined ? ` · ${result.path}` : ""}`;
+        // A group of the sheet is its values, with what effects cover in them.
+        if (result.group) {
+            return [[title, result.covered.length === 0 ? "" : `While they last: ${result.covered.join(", ")}`].filter((line) => line !== "").join("\n"), result.sheet.join("\n")].join("\n\n");
+        }
+        const header = [
+            title,
+            result.hides === undefined ? "" : `This page hides the system ${result.hides}'s ${result.page}: links to that name lead here.`,
+            result.namesakes.length === 0 ? "" : `There is also ${result.namesakes.join("; ")}: show it by that name.`,
+            result.alsoCopy ? `${result.page} is also a copy in the open scene: change and write refuse both until the scene closes, which removes the copy, or the page is renamed.` : "",
+            result.isIn.length > 0 ? `Is in: ${result.isIn.join(" › ")}` : "",
+            result.alsoIn.length > 0 ? `Also listed in: ${result.alsoIn.join(", ")}. A thing can be in one place only: move it where it is, such as move, page ${result.page}, to ${result.isIn[0]}.` : "",
+            result.around === "" ? "" : `Around: ${result.around}`,
+            result.derivesFrom.length > 0 ? `Derives from: ${result.derivesFrom.join(" › ")}` : "",
+            result.sectionFrom === undefined
+                ? ""
+                : result.featureOf
+                    ? `A feature of ${result.page}, from ${result.sectionFrom}.`
+                    : `Inherited from ${result.sectionFrom}: ${result.page} has no section or secret of its own by this name.`,
+            result.covered.length === 0 ? "" : `While they last: ${result.covered.join(", ")}`,
+        ].filter((line) => line !== "").join("\n");
+        // What a character's sheet shows is not said again with the fields as written (D-207).
+        const onSheet = new Set(result.onSheet.map(comparableText));
+        const offSheet = (fields) => Object.fromEntries(Object.entries(fields).filter(([field]) => !onSheet.has(comparableText(field))));
+        const sheet = [...result.sheet, ...(result.featureHint === undefined ? [] : [result.featureHint])].join("\n");
+        const own = offSheet(result.fields ?? {});
+        const fields = Object.keys(own).length > 0 ? `---\n${formatFields(own)}\n---` : "";
+        // A value that only repeats the one it comes from, as a creature's athletics its str-mod, is not said again.
+        const workedLines = result.worked.filter((worked) => !worked.repeats && !onSheet.has(comparableText(worked.field))).map((worked) => worked.line);
+        const worked = workedLines.length === 0 ? "" : `Worked out by the system ${result.systemName ?? ""}:\n${workedLines.join("\n")}`;
+        const inheritedFields = result.inherited.map((group) => ({ from: group.from, fields: offSheet(group.fields) })).filter((group) => Object.keys(group.fields).length > 0)
+            .map((group) => `Fields inherited from ${group.from}:\n${formatFields(group.fields)}`);
+        // A character with a sheet names what its bases tell, such as its race's traits, instead of copying their text every time (DAT-2).
+        const inheritedText = onSheet.size > 0
+            ? result.inherited.filter((group) => group.parts.length > 0).map((group) => `From ${group.from}: ${group.parts.join(", ")}. show ${result.page}#${group.parts[0]} gives one.`)
+            : result.inherited.filter((group) => group.text !== "").map((group) => `Text inherited from ${group.from}:\n\n${group.text}`);
+        const links = result.linkedFrom.length > 0 ? `Linked from:\n${result.linkedFrom.map((link) => `- ${link.page}: ${link.places.join(", ")}`).join("\n")}` : "";
+        return [header, sheet, fields, worked, ...inheritedFields, result.text, ...inheritedText, links, skippedPagesNote(result.problems)].filter((block) => block !== "").join("\n\n");
+    },
+});
+/** Whether a worked-out value only repeats the one value it is said to come from, as athletics -1 from str-mod -1. */
+function repeatsRead(world, worked) {
+    const parts = workedParts(world, worked.reads).split(", ");
+    return parts.length === 1 && /^\S+ \S+$/.test(parts[0]) && parts[0].endsWith(` ${signedText(world, worked.field, worked.value)}`);
+}
+/** "Wolf (5e)": a page's name, with the game system it comes from (SYS-2). */
+function nameWithSystem(page) {
+    return page.system === undefined ? page.name : `${page.name} (${page.system})`;
+}
+/** The place of the open scene, where its copies are (ENV-2); undefined when it has none, or none that exists. */
+function scenePlace(world, place) {
+    return place === undefined ? undefined : pagesWithName(world, parsePageReference(place).name)[0];
+}
+/** "ac 15 (13 without)": the values the page's effects give, each with the one it reads without them (EFF-10). */
+function coveredValues(world, page) {
+    const without = inheritedFields(world, page);
+    const withThem = effectiveFields(world, page);
+    const read = (fields, field) => valueNamed(fields, field);
+    const fields = [...new Set(effectsOf(page).flatMap((effect) => effect.values.map(([field]) => field)))];
+    return fields.map((field) => `${field} ${String(read(withThem, field))} (${read(without, field) === undefined ? "none" : String(read(without, field))} without)`);
+}
+/** A section or secret of a page; when it has none by that name, the one of its nearest base that has it (INH-13); undefined when none has it. */
+function findPart(world, page, name) {
+    const own = readSection(page.body, name);
+    if (own !== undefined) {
+        return { text: own };
+    }
+    const chain = baseChain(world, page);
+    for (const [index, base] of chain.entries()) {
+        const text = readSection(base.body, name);
+        if (text !== undefined) {
+            const nearer = new Set([page, ...chain.slice(0, index)].flatMap((holder) => textParts(holder.body).map((part) => comparableText(part.name))));
+            const parts = textParts(text).filter((part, position) => position === 0 || part.name === "" || !nearer.has(comparableText(part.name)));
+            return { text: parts.map((part) => part.text).join("\n\n"), from: base.name };
+        }
+    }
+    // A feature the character's classes give, with the text of each page that tells it, in the order of the classes (PRO-4, D-224).
+    const source = featureSource(progressionOf(world, effectiveFields(world, page)), name);
+    const texts = (source?.pages ?? []).flatMap((giver) => {
+        const text = source === undefined ? undefined : readSection(giver.body, source.title);
+        return text === undefined ? [] : [{ from: giver.name, text }];
+    });
+    if (texts.length === 0) {
+        return undefined;
+    }
+    const text = texts.length === 1 ? texts[0].text : texts.map((given) => `From ${given.from}:\n${given.text}`).join("\n\n");
+    return { text, from: texts.map((given) => given.from).join(", "), feature: true };
+}
+/** "show Ettore#Rage gives the text of a feature.": said under a sheet that lists features (PRO-4). */
+function featureHint(world, page) {
+    const [first] = progressionOf(world, effectiveFields(world, page))?.features ?? [];
+    return first === undefined ? undefined : `show ${page.name}#${featureParts(first.name).name} gives the text of a feature.`;
+}
+/** Lists a page's sections and secrets, and those it shows from its bases, for an error message. */
+function partsOf(world, page) {
+    const sections = sectionTitles(page.body);
+    const secrets = secretNames(page.body);
+    const inherited = inheritedByBase(world, page).filter((group) => group.parts.length > 0).map((group) => `from ${group.base.name}: ${group.parts.map((piece) => piece.name).join(", ")}`);
+    const own = [sections.length > 0 ? `Its sections are: ${sections.join(", ")}.` : "", secrets.length > 0 ? `Its secrets are: ${secrets.join(", ")}.` : ""].filter((part) => part !== "");
+    const all = [...own, inherited.length > 0 ? `It shows, ${inherited.join("; ")}.` : ""].filter((part) => part !== "");
+    return all.length > 0 ? all.join(" ") : "It has no sections or secrets.";
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { type SheetSummary } from "./sheet.ts";
+/** A member of the player's party as the status shows them. */
+interface Member {
+    name: string;
+    /** The containers the member is in, nearest first. */
+    where: string[];
+    /** Whether the member is where the first player character is. */
+    withLead: boolean;
+    counters: string[];
+    /** Its effects, with their end: "Spaventato (until round 3, Lena)". */
+    effects: string[];
+    /** Its mood, when it has one (MOOD-6). */
+    mood?: string;
+}
+export declare const status: import("../core/registry.ts").Command<z.ZodObject<{}, z.core.$strip>, {
+    campaign: string[];
+    meanings: string[];
+    note: string;
+    premise: string | undefined;
+    writing: string[];
+    lines: string[];
+    veils: string[];
+    table: string[];
+    precedents: string[];
+    houseRules: string[];
+    players: Member[];
+    companions: Member[];
+    dashboard: string | undefined;
+    offerDashboard: boolean;
+    pictures: string | undefined;
+    translation: string | undefined;
+    mood: "neutral" | "happy" | "delighted" | "curious" | "focused" | "determined" | "worried" | "surprised" | "afraid" | "sad" | "angry" | "disgusted" | "mischievous";
+    place: string | undefined;
+    alsoThere: string[];
+    around: string;
+    scene: string | undefined;
+    journey: string | undefined;
+    lastScenes: string[];
+    sceneCounts: string;
+    openQuests: string[];
+    now: string | undefined;
+    dateProblem: string | undefined;
+    datedEvents: boolean;
+    dueEvents: string[];
+    plannedEvents: string[];
+    clocks: string[];
+    problems: number;
+    halfLoaded: number | undefined;
+    sheet: SheetSummary | undefined;
+    incompleteSheets: string[];
+    levelsDue: string[];
+}>;
+export {};

package/dist/commands/status.js

@@ -0,0 +1,291 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { houseRulesFolderName, readSettings, requireCampaign, settingMeaning } from "../campaign/index.js";
+import { defineCommand } from "../core/registry.js";
+import { isInParty, isPartyMember, locate, pagesWithName, parsePageReference } from "../pages/index.js";
+import { bookTitles, readRuleBook } from "../rules/index.js";
+import { sceneTypes } from "../scene/index.js";
+import { formatGameDate } from "../time/index.js";
+import { effectiveFields, effectsOf } from "./effect-layer.js";
+import { effectShown, keptEffects } from "./game-effects.js";
+import { surroundings, surroundingsText } from "./game-environment.js";
+import { clocksToMove, dueAdvice, dueText, isDated, isDue, plannedEvents, plannedText, worldFacts } from "./game-events.js";
+import { experienceOf, levelDueNote } from "./game-experience.js";
+import { picturesNote } from "./game-images.js";
+import { journeyText, readJourney } from "./game-journey.js";
+import { campaignMode, campaignNote } from "./game-mode.js";
+import { campaignCoins } from "./game-money.js";
+import { livingMood, masterMood } from "./game-moods.js";
+import { isTickedOpenQuest, openQuestText } from "./game-quests.js";
+import { measuresOf, roadsOf } from "./game-roads.js";
+import { interruptedLoad } from "./game-saves.js";
+import { closedScenes, copyCounters, copyPage, partyAwayText, readOpenScene } from "./game-scene.js";
+import { problemText, readPresent } from "./game-time.js";
+import { campaignSystem, campaignWorld, systemInStatus, systemSettingValue } from "./game-world.js";
+import { countersText, pageCounters, partyCounters } from "./page-counters.js";
+import { campaignProblems } from "./problems.js";
+import { missingSheetFields, sheetSummary } from "./sheet.js";
+import { translationOffer } from "./translate.js";
+// Lists in the status show this many names, then say how many more there are and how to find them.
+const shownNames = 3;
+export const status = defineCommand({
+    name: "status",
+    description: "Show where the game stands. "
+        + "It gives the campaign's settings, the player character and companions with their counters and whereabouts, who is with them, open quests, "
+        + "the game date, the events due and planned, the open scene and the last ones, problems. "
+        + "Call it right after instructions at the start of every chat and after a summary, and whenever you need to check where things stand. "
+        + "It shows names and numbers only: read pages with show. Read-only, no parameters.",
+    group: "game",
+    readOnly: true,
+    alwaysLoad: true,
+    input: z.object({}),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        const settings = readSettings(root);
+        const world = campaignWorld(root, context);
+        const characters = world.pages.filter((page) => page.type === "character");
+        const players = characters.filter((page) => page.fields.role === "pc");
+        const place = players.length > 0 ? placeOf(world, players[0]) : undefined;
+        const withLead = (page) => place !== undefined && placeOf(world, page) === place;
+        const { coins } = campaignCoins(root, context);
+        const system = campaignSystem(root, context);
+        const openScene = readOpenScene(root);
+        const member = (page) => {
+            const mood = livingMood(page);
+            return {
+                name: characterName(page),
+                where: locate(world, page).chain.map((holder) => holder.name),
+                withLead: withLead(page),
+                counters: Object.entries(partyCounters(world, page, coins, system)).map(([field, value]) => countersText({ [field]: value })),
+                effects: [...effectsOf(page).map((effect) => effectShown(world, effect)), ...keptEffects(world, openScene.scene, page.name).map((kept) => `keeps ${kept}`)],
+                ...(mood === "neutral" ? {} : { mood }),
+            };
+        };
+        const present = readPresent(root);
+        const now = present.date;
+        const events = plannedEvents(world);
+        const facts = worldFacts(world);
+        const due = events.filter((event) => isDue(event, now, facts));
+        const closed = closedScenes(root);
+        const mode = campaignMode(root, world);
+        return {
+            campaign: [
+                settings.name,
+                settings.language,
+                systemInStatus(root, context),
+                named("difficulty", settings.difficulty),
+                named("lethality", settings.lethality),
+                named("saves", settings.saves),
+                // What the master follows in play (D-241).
+                named("rigor", settings.rigor),
+                named("dice", settings.dice),
+                named("units", settings.units),
+                // How much the master teaches, only when they do (D-347).
+                named("mentor", settings.mentor === "off" ? undefined : settings.mentor),
+                // What the system adds to the setup, as advancement xp (DAT-10).
+                ...(system?.settings ?? []).map((setting) => named(setting.name, systemSettingValue(root, setting))),
+                named("mode", mode),
+            ].filter((part) => part !== undefined),
+            // What the chosen difficulty and rigor mean in play, one line each (D-263).
+            meanings: ["difficulty", "rigor"].flatMap((name) => {
+                const meaning = settingMeaning(name, settings[name]);
+                return meaning === undefined ? [] : [`${name.charAt(0).toUpperCase()}${name.slice(1)} ${settings[name]}: ${meaning}.`];
+            }),
+            // Before play, what the next mode needs and how to enter it; in play, the settings still missing (MOD-7).
+            note: campaignNote(root, context),
+            premise: settings.premise === undefined ? undefined : `${settings.premise}${settings.preparation === undefined ? "" : ` (preparation ${settings.preparation})`}`,
+            // How the master writes, as the player chose it, under the eyes at every start (D-395).
+            writing: [
+                named("prose", settings.author === undefined ? settings.prose : undefined),
+                named("story", settings.story),
+                settings.author === undefined ? undefined : `like ${settings.author}`,
+                settings.style === undefined ? undefined : `the player's words: "${settings.style}"`,
+            ].filter((part) => part !== undefined),
+            lines: settings.lines ?? [],
+            veils: settings.veils ?? [],
+            table: settings.table ?? [],
+            precedents: settings.precedents ?? [],
+            houseRules: bookTitles(readRuleBook(join(root, houseRulesFolderName), "house rules")),
+            players: players.map(member),
+            companions: characters.filter((page) => page.fields.role === "companion").map(member),
+            dashboard: context.dashboard,
+            // The chat's first status opens with the dashboard, for the master to offer it in their first answer (D-353).
+            offerDashboard: offerDashboard(context),
+            // Whether to ask for the places' pictures, or to have this one made (D-308).
+            pictures: picturesNote(root, context, world, players[0] === undefined ? undefined : locate(world, players[0]).chain.find((holder) => holder.type === "place")),
+            // In the setup, the dashboard translated in the chat where nothing here does it in the background (D-423).
+            translation: mode === "setup" ? translationOffer(root, context) : undefined,
+            mood: masterMood(root),
+            place,
+            alsoThere: characters.filter((page) => !isPartyMember(page) && withLead(page)).map(characterName),
+            around: players.length === 0 ? "" : surroundingsText(surroundings(world, players[0])),
+            scene: sceneText(world, openScene.scene),
+            journey: journeyText(world, roadsOf(world), readJourney(root), measuresOf(root, system)),
+            lastScenes: closed.slice(0, shownNames).map((scene) => `${scene.title} (${scene.type}): ${scene.summary}`),
+            sceneCounts: sceneCounts(closed),
+            openQuests: openQuests(world, now),
+            now: now === undefined ? undefined : formatGameDate(now),
+            dateProblem: present.problem === undefined ? undefined : problemText(present.problem),
+            datedEvents: events.some(isDated),
+            dueEvents: due.map(dueText),
+            plannedEvents: events.filter((event) => !due.includes(event)).map((event) => plannedText(event, now)),
+            clocks: clocksToMove(world, now, facts),
+            problems: campaignProblems(root, world, context).length,
+            // A load that stopped halfway leaves the campaign between two times (SAV-5).
+            halfLoaded: interruptedLoad(root)?.number,
+            sheet: system === undefined ? undefined : sheetSummary(system),
+            // A dead character's sheet is no longer kept (D-190); before play, the checklist says what it lacks.
+            incompleteSheets: mode !== "play" ? [] : characters.filter(isInParty).flatMap((page) => {
+                const missing = missingSheetFields(system, world, page);
+                return missing.length === 0 ? [] : [`${characterName(page)}'s sheet still lacks, by these names: ${missing.join(", ")}.`];
+            }),
+            // A level the points reach, until the classes rise (PRO-6).
+            levelsDue: characters.filter(isInParty).flatMap((page) => levelDueNote(characterName(page), experienceOf(world, effectiveFields(world, page)), page.fields.role === "companion") ?? []),
+        };
+    },
+    format(result) {
+        const lead = result.players[0]?.name;
+        const companion = (member) => `${member.name}${member.withLead && lead !== undefined ? `, with ${lead}` : whereabouts(member)}${memberCounters(member)}`;
+        const state = [
+            result.offerDashboard && result.dashboard !== undefined
+                ? `Offer the player their dashboard in your first answer, with its link: ${result.dashboard}. Their sheet, their settings and the dice of the checks you ask `
+                    + "follow the game there, live; the link stays the same, and a page they keep open comes back by itself next time."
+                : "",
+            result.campaign.join(" · "),
+            ...result.meanings,
+            result.note,
+            result.premise === undefined ? "" : `Premise: ${result.premise}`,
+            result.writing.length === 0 ? "" : `Your writing: ${result.writing.join(" · ")}`,
+            boundariesLine(result.lines, result.veils),
+            result.table.length === 0 ? "" : `Table: ${result.table.join("; ")}`,
+            result.precedents.length === 0 ? "" : `Precedents: ${result.precedents.join("; ")}`,
+            result.houseRules.length === 0 ? "" : `House rules (rules): ${result.houseRules.join(", ")}`,
+            timeLine(result),
+            ...(result.players.length === 0 ? [`No player character yet.${sheetNote(result.sheet)}`] : result.players.map((member) => `PC: ${member.name}${whereabouts(member)}${memberCounters(member)}`)),
+            result.around === "" ? "" : `Around ${lead}: ${result.around}`,
+            namesLine("Companions", result.companions.map(companion), "find text companion, type character", "; "),
+            result.dashboard === undefined || result.offerDashboard ? "" : `Dashboard: ${result.dashboard}, the player's sheet, their settings and the dice of the checks you ask, live.`,
+            result.pictures ?? "",
+            result.translation ?? "",
+            result.mood === "neutral" ? "" : `Your mood is ${result.mood}: let your voice follow it.`,
+            ...result.incompleteSheets,
+            ...result.levelsDue,
+            namesLine("Also there", result.alsoThere, `show ${result.place}`),
+            result.scene === undefined ? "" : `Scene: ${result.scene}`,
+            result.journey === undefined ? "" : `Journey: ${result.journey}`,
+            result.lastScenes.length === 0 ? "" : `Last scenes: ${result.lastScenes.join(" · ")}`,
+            result.sceneCounts === "" ? "" : `Scenes so far: ${result.sceneCounts}`,
+            dueLine(result.dueEvents),
+            namesLine("Open quests", result.openQuests, "find text open, type quest"),
+            namesLine("Planned events", result.plannedEvents, "find text planned, type event"),
+            result.clocks.length === 0 ? "" : `Clocks: ${result.clocks.join(" · ")}`,
+            result.halfLoaded === undefined ? "" : `The load of save ${result.halfLoaded} stopped halfway: call save load to finish it, before anything else.`,
+            result.problems === 0 ? "" : `${result.problems} ${result.problems === 1 ? "problem" : "problems"} in the campaign: validate lists them, with how to fix each.`,
+        ];
+        return state.filter((line) => line !== "").join("\n");
+    },
+});
+/** The game date; or why it cannot be read; or, before there is one, a reminder to set it when some planned event has a date. */
+function timeLine(result) {
+    if (result.now !== undefined) {
+        return `Now: ${result.now}`;
+    }
+    if (result.dateProblem !== undefined) {
+        return result.dateProblem;
+    }
+    return result.datedEvents ? "No game date yet: at the first scene, set it with advance to, at the scene's hour, such as day 1, 18:00." : "";
+}
+/** "difficulty normal": a setting named, or nothing when it is missing. */
+function named(name, value) {
+    return value === undefined ? undefined : `${name} ${value}`;
+}
+function boundariesLine(lines, veils) {
+    const listed = (items) => (items.length > 0 ? items.join("; ") : "none");
+    return lines.length === 0 && veils.length === 0 ? "" : `Lines: ${listed(lines)} · Veils: ${listed(veils)}`;
+}
+function characterName(page) {
+    return page.fields.status === "dead" ? `${page.name} (dead)` : page.name;
+}
+function placeOf(world, page) {
+    return locate(world, page).chain[0]?.name;
+}
+/** ", in Room › Building › Town", or nothing when the member is in no container. */
+function whereabouts(member) {
+    return member.where.length === 0 ? "" : `, in ${member.where.join(" › ")}`;
+}
+function memberCounters(member) {
+    const shown = [...member.counters, ...member.effects, ...(member.mood === undefined ? [] : [`mood ${member.mood}`])];
+    return shown.length === 0 ? "" : `: ${shown.join(" · ")}`;
+}
+/**
+ * " The system 5e keeps on a character sheet, by these names: level, xp…; and when they apply: traits…, slots-1…. It works out Skills, str-mod…: never write them.",
+ * for status before there is a player character (DAT-2).
+ */
+function sheetNote(sheet) {
+    if (sheet === undefined) {
+        return "";
+    }
+    const also = sheet.whenTheyApply.length === 0 ? "" : `; and when they apply: ${sheet.whenTheyApply.join(", ")}`;
+    const worked = sheet.workedOut.length === 0 ? "" : ` It works out ${sheet.workedOut.join(", ")}: never write them.`;
+    const lists = sheet.lists.length === 0 ? "" : ` Only its names go in ${sheet.lists.join(", ")}, as it writes them: write lists them if a name is not one.`;
+    return ` The system ${sheet.system} keeps on a character sheet, by these names: ${sheet.written.join(", ")}${also}.${worked}${lists}`;
+}
+/** The planned events due, all of them: the master plays each one first (D-135). */
+function dueLine(events) {
+    return events.length === 0 ? "" : `Due: ${events.join(" · ")}. ${dueAdvice(events.length)}`;
+}
+/** "Scontro all'ossario (combat) at Ossario; round 1, Lena's turn; copies: Annegato 1: hp 22/22; Annegato 2: hp 13/22". */
+function sceneText(world, scene) {
+    if (scene === undefined) {
+        return undefined;
+    }
+    const place = scene.place === undefined ? "" : ` at ${parsePageReference(scene.place).name}`;
+    const characters = scene.with.length === 0 ? "" : `, with ${scene.with.map((link) => sceneMemberText(world, parsePageReference(link).name)).join(", ")}`;
+    const turn = scene.turn === undefined ? "" : `; round ${scene.round ?? 1}, ${scene.turn}'s turn`;
+    const copies = Object.entries(scene.copies).map(([name, copy]) => {
+        const counters = [countersText(copyCounters(world, copy)), ...effectsOf(copyPage(name, copy)).map((effect) => effectShown(world, effect))].filter((part) => part !== "").join(" · ");
+        return counters === "" ? name : `${name}: ${counters}`;
+    });
+    const away = partyAwayText(world, scene);
+    // What happened in it so far is in its log, which show gives (SCN-10).
+    const told = `. show ${scene.title} for what happened so far`;
+    return `${scene.title} (${scene.type})${place}${characters}${turn}${copies.length === 0 ? "" : `; copies: ${copies.join("; ")}`}${away === "" ? "" : `; ${away}`}${told}`;
+}
+/** "Varro (hp 23/30 · Prono · mood angry)": a character in the scene who is not of the party, with counters, effects (EFF-10) and mood (MOOD-6). */
+function sceneMemberText(world, name) {
+    const page = pagesWithName(world, name)[0];
+    if (page === undefined || isPartyMember(page)) {
+        return name;
+    }
+    const mood = livingMood(page);
+    const shown = [countersText(pageCounters(world, page)), ...effectsOf(page).map((effect) => effectShown(world, effect)), mood === "neutral" ? "" : `mood ${mood}`].filter((part) => part !== "");
+    return shown.length === 0 ? name : `${name} (${shown.join(" · ")})`;
+}
+/** "4 social, 2 exploration, 1 combat": the closed scenes by type, most first, then in the order of the list of types. */
+function sceneCounts(scenes) {
+    const counts = new Map();
+    for (const scene of scenes) {
+        counts.set(scene.type, (counts.get(scene.type) ?? 0) + 1);
+    }
+    const rank = (type) => sceneTypes.indexOf(type);
+    return [...counts].sort((first, second) => second[1] - first[1] || rank(first[0]) - rank(second[0])).map(([type, count]) => `${count} ${type}`).join(", ");
+}
+/** The open quests, those whose goals are all ticked first, with what to do about them (D-239). */
+function openQuests(world, now) {
+    const open = world.pages.filter((page) => page.type === "quest" && page.fields.status === "open");
+    return [...open.filter(isTickedOpenQuest), ...open.filter((page) => !isTickedOpenQuest(page))].map((page) => openQuestText(page, now));
+}
+/** "Label: A · B · C, and 2 more: find …", or nothing when there are none. */
+function namesLine(label, names, more, separator = " · ") {
+    if (names.length === 0) {
+        return "";
+    }
+    const shown = names.slice(0, shownNames).join(separator);
+    return names.length > shownNames ? `${label}: ${shown}, and ${names.length - shownNames} more: ${more}` : `${label}: ${shown}`;
+}
+/** Whether this status is the chat's first with a dashboard, which has the master offer it; the next ones only give its link (D-353). */
+function offerDashboard(context) {
+    const first = context.dashboard !== undefined && context.dashboardOffered !== true;
+    context.dashboardOffered ||= first;
+    return first;
+}

package/dist/commands/translate.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { Context } from "../core/context.ts";
+import { type ChatBatch } from "../page-words.ts";
+export declare const translate: import("../core/registry.ts").Command<z.ZodObject<{
+    phrases: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodString]>>;
+}, z.core.$strip>, {
+    kind: "batch";
+    language: string;
+    system?: string;
+    batch: ChatBatch;
+    kept?: number;
+    dropped?: string[];
+} | {
+    kind: "done";
+    language: string;
+    kept?: number;
+    dropped?: string[];
+}>;
+/**
+ * In the setup, with the dashboard open, the offer of status where the page lacks the campaign's language and nothing here translates it in the background
+ * (D-423); undefined anywhere else.
+ */
+export declare function translationOffer(root: string, context: Context): string | undefined;