rpg-engine 0.0.0-stage → 0.1.1

package/dist/money/money.js

@@ -0,0 +1,218 @@
+import { comparableText } from "../core/text.js";
+// A coin name is one word, such as gp or corona; a coin may have several, written gp/mo.
+const word = String.raw `\p{L}[\p{L}\p{M}]*`;
+const coinNames = new RegExp(String.raw `^${word}(?:/${word})*$`, "u");
+// One count and one coin, such as 34 gp or 34gp; pairs are parted by spaces or commas.
+const countAndCoin = new RegExp(String.raw `(\d+)\s*(${word})`, "uy");
+const separator = /[\s,]*/y;
+/** What is wrong with a list of coins, as campaign.yaml holds it (MON-1, MON-8); undefined when it is right. */
+export function coinsProblem(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length === 0) {
+        return 'coins must list each coin with its value in the smallest coin, such as "gp 100, sp 10, cp 1".';
+    }
+    const entries = Object.entries(value);
+    const badName = entries.find(([names]) => !coinNames.test(names));
+    const badValue = entries.find(([, worth]) => readWorth(worth) === undefined);
+    if (badName !== undefined) {
+        return `"${badName[0]}" cannot be a coin: a coin is one word, such as gp or corona, or several names written gp/mo.`;
+    }
+    if (badValue !== undefined) {
+        return `The coin ${badValue[0]} is worth ${JSON.stringify(badValue[1])}: give each coin a whole number from 1 up, its value in the smallest coin, and "rare" after it for a coin never given as change.`;
+    }
+    const coins = coinList(value);
+    const names = coins.flatMap((coin) => coin.names.map(comparableText));
+    const twice = names.find((name, index) => names.indexOf(name) !== index);
+    const values = coins.map((coin) => coin.value);
+    const repeated = values.find((worth, index) => values.indexOf(worth) !== index);
+    const unit = coins.find((coin) => coin.value === 1);
+    if (twice !== undefined) {
+        return `The name ${twice} is given to two coins: give each name once.`;
+    }
+    if (repeated !== undefined) {
+        return `Two coins are worth ${repeated}: each coin needs a value of its own.`;
+    }
+    if (unit === undefined) {
+        return "No coin is worth 1: the smallest coin is worth 1, and the others are worth so many of it.";
+    }
+    return unit.rare ? `The coin ${unit.name} is worth 1, and change comes back in it: it cannot be rare.` : undefined;
+}
+/** The coins of a list that has no problem, in its order: the first is the coin of totals. */
+export function coinList(value) {
+    return Object.entries(value).map(([names, worth]) => {
+        const all = names.split("/");
+        const read = readWorth(worth) ?? { value: 0, rare: false };
+        return { name: all[0], names: all, ...read };
+    });
+}
+/** The list of coins written as text, such as "gp/mo 100, pp 1000 rare, sp 10, cp 1", as campaign.yaml keeps it; refused with what is wrong. */
+export function readCoins(text) {
+    const coins = {};
+    for (const entry of text.normalize("NFC").split(",").map((part) => part.trim()).filter((part) => part !== "")) {
+        const match = new RegExp(String.raw `^(${word}(?:\s*/\s*${word})*)\s*[=:]?\s*(\d+)(\s+rare)?$`, "iu").exec(entry);
+        if (match === null) {
+            throw new Error(`"${entry}" is not a coin and its value: write coins as "gp 100, pp 1000 rare, sp 10, cp 1", each with its value in the smallest coin; give a coin more names as gp/mo.`);
+        }
+        const names = match[1].split("/").map((name) => name.trim()).join("/");
+        if (Object.keys(coins).some((other) => other.split("/").some((name) => names.split("/").some((given) => comparableText(given) === comparableText(name))))) {
+            throw new Error(`The coin ${names} is listed twice: give each coin once.`);
+        }
+        coins[names] = match[3] === undefined ? Number(match[2]) : `${match[2]} rare`;
+    }
+    const problem = coinsProblem(coins);
+    if (problem !== undefined) {
+        throw new Error(problem);
+    }
+    return coins;
+}
+/** "gp/mo 100, pp 1000 rare, sp 10, cp 1": a list of coins as config shows it and takes it. */
+export function coinsText(coins) {
+    return coins.map((coin) => `${coin.names.join("/")} ${coin.value}${coin.rare ? " rare" : ""}`).join(", ");
+}
+/** The purse a value holds, such as "34 gp 4 sp", with any name of each coin; undefined when it is not an amount of these coins (MON-2). */
+export function readAmount(value, coins) {
+    return typeof value === "string" ? readCoinsText(value.trim(), coins) : undefined;
+}
+/** An amount given to change: coins to add, or, with a minus, to pay, such as "+20 gp" or "-5 sp"; undefined when it is not one. */
+export function readSignedAmount(text, coins) {
+    const trimmed = text.trim();
+    const sign = trimmed.startsWith("-") ? -1 : 1;
+    const purse = readCoinsText(trimmed.replace(/^[+-]\s*/, ""), coins);
+    return purse === undefined ? undefined : { sign, purse };
+}
+/** Whether a text names coins of the list after a number, as an amount would, such as "34 mo e 4 ma": what was likely meant as money. */
+export function namesCoins(text, coins) {
+    const named = coins.flatMap((coin) => coin.names.map(comparableText));
+    return [...text.matchAll(new RegExp(String.raw `\d+\s*(${word})`, "gu"))].some((match) => named.includes(comparableText(match[1])));
+}
+/** "34 gp 4 sp": from the coin worth most, by first names, without those at 0; an empty purse is 0 of the first coin (MON-2). */
+export function formatAmount(purse, coins) {
+    const held = byValue(coins).filter((coin) => (purse[coin.name] ?? 0) > 0);
+    return held.length === 0 ? `0 ${coins[0].name}` : held.map((coin) => `${purse[coin.name]} ${coin.name}`).join(" ");
+}
+/** What a purse is worth, in the smallest coin. */
+export function totalOf(purse, coins) {
+    return coins.reduce((total, coin) => total + (purse[coin.name] ?? 0) * coin.value, 0);
+}
+/** What a purse is worth in the first coin, such as "33.9 gp"; when that does not come out in two decimals, in the smallest coin, such as "541 soldo" (MON-7). */
+export function formatTotal(purse, coins) {
+    const total = totalOf(purse, coins);
+    const inFirst = total / coins[0].value;
+    if (Math.round(inFirst * 100) / 100 === inFirst) {
+        return `${inFirst} ${coins[0].name}`;
+    }
+    const unit = byValue(coins)[coins.length - 1];
+    return `${total} ${unit.name}`;
+}
+/** The purse with coins added: they stay as they are given (MON-3). */
+export function addCoins(purse, added) {
+    const result = { ...purse };
+    for (const [name, count] of Object.entries(added)) {
+        result[name] = (result[name] ?? 0) + count;
+    }
+    return result;
+}
+/** Whether every count of a purse is a whole number that can be counted exactly. */
+export function isSafePurse(purse, coins) {
+    return Object.values(purse).every((count) => Number.isSafeInteger(count)) && Number.isSafeInteger(totalOf(purse, coins));
+}
+/**
+ * Pays a price from a purse, as at an inn (MON-5, D-128): the coins of the price; the rest with other coins that make it exactly, from the largest; else the smallest coin
+ * that covers it, or, when none does alone, coins from the largest until they do, and the change comes back in as few coins as can be, never rare ones.
+ * Undefined when the purse is worth less than the price.
+ */
+export function payCoins(purse, price, coins) {
+    if (totalOf(purse, coins) < totalOf(price, coins)) {
+        return undefined;
+    }
+    const ordered = byValue(coins);
+    // The coins of the price, when they are all there; else other coins that make the price exactly, such as 6 sp for 60 cp.
+    if (coins.every((coin) => (purse[coin.name] ?? 0) >= (price[coin.name] ?? 0))) {
+        return { purse: withoutEmpty(addCoins(purse, negate(price))), given: {}, back: {} };
+    }
+    const whole = exactly(purse, ordered, totalOf(price, coins));
+    if (whole !== undefined) {
+        return { purse: withoutEmpty(addCoins(purse, negate(whole))), given: withoutEmpty(whole), back: {} };
+    }
+    const result = { ...purse };
+    let rest = 0;
+    for (const coin of coins) {
+        const taken = Math.min(result[coin.name] ?? 0, price[coin.name] ?? 0);
+        result[coin.name] = (result[coin.name] ?? 0) - taken;
+        rest += ((price[coin.name] ?? 0) - taken) * coin.value;
+    }
+    const given = exactly(result, ordered, rest) ?? covering(result, ordered, rest);
+    const handed = totalOf(given, coins);
+    const back = change(handed - rest, ordered.filter((coin) => !coin.rare));
+    return { purse: withoutEmpty(addCoins(addCoins(result, negate(given)), back)), given: withoutEmpty(given), back: withoutEmpty(back) };
+}
+/** The value and rarity of a coin as the list writes them: 100, or "1000 rare". */
+function readWorth(worth) {
+    const match = typeof worth === "string" ? /^(\d+)\s+rare$/i.exec(worth.trim()) : null;
+    const value = match === null ? worth : Number(match[1]);
+    return Number.isSafeInteger(value) && value >= 1 ? { value: value, rare: match !== null } : undefined;
+}
+/** Reads "34 gp 4 sp" against the list of coins: each coin once, by any of its names, in any case; kept by its first name. */
+function readCoinsText(text, coins) {
+    const purse = {};
+    let position = 0;
+    while (position < text.length) {
+        countAndCoin.lastIndex = position;
+        const match = countAndCoin.exec(text);
+        const coin = match === null ? undefined : coins.find((candidate) => candidate.names.some((name) => comparableText(name) === comparableText(match[2])));
+        if (match === null || coin === undefined || Object.hasOwn(purse, coin.name) || !Number.isSafeInteger(Number(match[1]))) {
+            return undefined;
+        }
+        purse[coin.name] = Number(match[1]);
+        separator.lastIndex = countAndCoin.lastIndex;
+        separator.exec(text);
+        position = separator.lastIndex;
+    }
+    return Object.keys(purse).length === 0 ? undefined : withoutEmpty(purse);
+}
+/** The coins worth exactly `amount`, taken from the largest; undefined when the purse cannot make it so. */
+function exactly(purse, coins, amount) {
+    const taken = {};
+    let left = amount;
+    for (const coin of coins) {
+        taken[coin.name] = Math.min(purse[coin.name] ?? 0, Math.floor(left / coin.value));
+        left -= taken[coin.name] * coin.value;
+    }
+    return left === 0 ? taken : undefined;
+}
+/** The smallest coin worth at least `amount`; when none is, coins from the largest until they are worth it. The purse is worth it all, so they always do. */
+function covering(purse, coins, amount) {
+    const single = [...coins].reverse().find((coin) => coin.value >= amount && (purse[coin.name] ?? 0) > 0);
+    if (single !== undefined) {
+        return { [single.name]: 1 };
+    }
+    const taken = {};
+    let left = amount;
+    for (const coin of coins) {
+        if (left <= 0) {
+            break;
+        }
+        taken[coin.name] = Math.min(purse[coin.name] ?? 0, Math.ceil(left / coin.value));
+        left -= taken[coin.name] * coin.value;
+    }
+    return taken;
+}
+/** `amount` in as few coins as can be, from the largest: the coin worth 1 is among them, so it always comes out exactly. */
+function change(amount, coins) {
+    const back = {};
+    let left = amount;
+    for (const coin of coins) {
+        back[coin.name] = Math.floor(left / coin.value);
+        left -= back[coin.name] * coin.value;
+    }
+    return back;
+}
+/** The coins from the one worth most. */
+function byValue(coins) {
+    return [...coins].sort((first, second) => second.value - first.value);
+}
+function negate(purse) {
+    return Object.fromEntries(Object.entries(purse).map(([name, count]) => [name, -count]));
+}
+function withoutEmpty(purse) {
+    return Object.fromEntries(Object.entries(purse).filter(([, count]) => count !== 0));
+}

package/dist/page-words.d.ts

@@ -0,0 +1,46 @@
+import type { Context } from "./core/context.ts";
+import { type SystemWords } from "./systems/index.ts";
+/** What the page has of a language: its phrases so far, whether they are being translated, whether this computer can, and how many it still lacks. */
+export interface PageWords {
+    phrases: Record<string, string>;
+    translating: boolean;
+    can: boolean;
+    missing: number;
+}
+/** A game system as the translation needs it: its name, and its folder, where words/it.yaml lists its words with their meaning. */
+export interface WordsSystem {
+    name: string;
+    folder: string;
+}
+/** The page's words on the fly: what a language has, and the phrases the page asks first; `notify` tells the pages when more have come. */
+export interface PageTranslator {
+    read(language: string, system?: WordsSystem): PageWords;
+    ask(language: string, first: string[]): void;
+}
+/** The page's words on the fly for the page in `page`, whose i18n/it.json lists every phrase with its meaning. */
+export declare function pageTranslator(context: Context, page: string, notify: () => void): PageTranslator;
+/** A batch the master translates in the chat (D-423): the page's phrases, then the game system's words, each by a short id, with what the language still lacks. */
+export interface ChatBatch {
+    part: "page" | "system";
+    entries: {
+        id: string;
+        english: string;
+        italian: string;
+        kind?: string;
+    }[];
+    /** How many the language still lacks, this batch included. */
+    left: number;
+}
+/** Whether the built page in `page` ships a language: its own file, its base language's (pt-BR, pt), or English. */
+export declare function shipsLanguage(page: string, language: string): boolean;
+/** The next batch the master translates in the chat, the page's phrases first; undefined once the language lacks none. */
+export declare function chatBatch(home: string, page: string, language: string, system: WordsSystem | undefined): ChatBatch | undefined;
+/** Keeps what the master translated in the chat, by id, as the background work keeps its own; returns how many it kept, and the ids dropped for a lost {name}. */
+export declare function keepChatAnswer(home: string, page: string, language: string, system: WordsSystem | undefined, answer: Record<string, unknown>): {
+    kept: number;
+    dropped: string[];
+};
+/** A language's name in English, as Vietnamese for vi; its code where the runtime does not know it. */
+export declare function languageName(language: string): string;
+/** The game system's words in a language translated on the fly, in the player's data folder; none where it has none there. */
+export declare function homeSystemWords(home: string | undefined, system: WordsSystem, language: string): SystemWords | undefined;

package/dist/page-words.js

@@ -0,0 +1,221 @@
+// The page in a language the package does not ship, translated on the fly (D-406): the writer of this computer, Codex or Claude Code with the player's login,
+// translates in the background all the page's phrases a language lacks, those the page asks first first, then the game system's words, and keeps them in the
+// player's data folder for every campaign; the page reads them as they come, in English until then. A translation that loses a {name} is dropped.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { stringify } from "yaml";
+import { files } from "./core/store.js";
+import { systemWords } from "./systems/index.js";
+// How many phrases go in one request.
+const batchSize = 130;
+// How long a language whose translation stopped short waits before it is tried again, so that a writer that fails is not called at every reading.
+const pause = 10 * 60 * 1000;
+/** The page's words on the fly for the page in `page`, whose i18n/it.json lists every phrase with its meaning. */
+export function pageTranslator(context, page, notify) {
+    // Every phrase of the page, with its curated Italian as its meaning, read when first needed.
+    let phrases;
+    const reference = () => (phrases ??= readJson(join(page, "i18n", "it.json")));
+    const running = new Map();
+    const stopped = new Map();
+    const run = async (language, system) => {
+        const writer = context.writer;
+        const home = context.home;
+        if (writer === undefined || home === undefined) {
+            return;
+        }
+        const file = join(home, "i18n", `${language}.json`);
+        for (;;) {
+            const own = readJson(file);
+            const first = running.get(language) ?? new Set();
+            const missing = Object.keys(reference()).filter((phrase) => !(phrase in own));
+            const batch = [...missing.filter((phrase) => first.has(phrase)), ...missing.filter((phrase) => !first.has(phrase))].slice(0, batchSize);
+            if (batch.length === 0) {
+                break;
+            }
+            const answer = answerOf(await writer.write(pageBrief(language, batch.map((phrase) => ({ id: phrase, english: phrase, italian: reference()[phrase] })))));
+            const kept = keptOf(answer, batch.map((phrase) => ({ id: phrase, source: phrase })));
+            // A request that brings nothing ends the work: the page stays in English where it lacks a phrase.
+            if (Object.keys(kept).length === 0) {
+                break;
+            }
+            writeJson(file, { ...readJson(file), ...kept });
+            notify();
+        }
+        if (system !== undefined) {
+            await translateSystem(writer, home, language, system);
+            notify();
+        }
+    };
+    return {
+        read: (language, system) => {
+            const own = context.home === undefined ? {} : readJson(join(context.home, "i18n", `${language}.json`));
+            const missing = Object.keys(reference()).filter((phrase) => !(phrase in own)).length;
+            const can = context.writer?.ready() === true && context.home !== undefined;
+            const waiting = context.now().getTime() - (stopped.get(language) ?? -pause) < pause;
+            if (can && !waiting && !running.has(language) && (missing > 0 || (system !== undefined && systemMissing(context.home, language, system)))) {
+                running.set(language, new Set());
+                void run(language, system).finally(() => {
+                    running.delete(language);
+                    stopped.set(language, context.now().getTime());
+                });
+            }
+            return { phrases: own, translating: running.has(language), can, missing };
+        },
+        ask: (language, first) => {
+            first.filter((phrase) => phrase in reference()).forEach((phrase) => running.get(language)?.add(phrase));
+        },
+    };
+}
+// How many phrases the master translates in one call: the page's in four, the system's in three.
+const chatBatchSize = 160;
+/** Whether the built page in `page` ships a language: its own file, its base language's (pt-BR, pt), or English. */
+export function shipsLanguage(page, language) {
+    const base = language.toLowerCase().split("-")[0];
+    return base === "en" || [language.toLowerCase(), base, base === "no" ? "nb" : ""].some((code) => code !== "" && existsSync(join(page, "i18n", `${code}.json`)));
+}
+/** The next batch the master translates in the chat, the page's phrases first; undefined once the language lacks none. */
+export function chatBatch(home, page, language, system) {
+    const pagePart = missingPhrases(home, page, language);
+    const systemPart = system === undefined ? [] : missingWords(home, language, system);
+    const [part, entries] = pagePart.length > 0 ? ["page", pagePart] : ["system", systemPart];
+    return entries.length === 0 ? undefined : { part, entries: entries.slice(0, chatBatchSize).map(({ key: _key, ...entry }) => entry), left: pagePart.length + systemPart.length };
+}
+/** Keeps what the master translated in the chat, by id, as the background work keeps its own; returns how many it kept, and the ids dropped for a lost {name}. */
+export function keepChatAnswer(home, page, language, system, answer) {
+    const phrases = missingPhrases(home, page, language).filter((entry) => entry.id in answer);
+    const words = system === undefined ? [] : missingWords(home, language, system).filter((entry) => entry.id in answer);
+    const keptPhrases = keptOf(answer, phrases.map(({ id, english }) => ({ id, source: english })));
+    const keptWords = keptOf(answer, words.map(({ id, italian }) => ({ id, source: italian })));
+    if (Object.keys(keptPhrases).length > 0) {
+        const file = join(home, "i18n", `${language}.json`);
+        writeJson(file, { ...readJson(file), ...Object.fromEntries(phrases.filter((entry) => entry.id in keptPhrases).map((entry) => [entry.key, keptPhrases[entry.id]])) });
+    }
+    if (system !== undefined && Object.keys(keptWords).length > 0) {
+        writeSystemWords(home, language, system, Object.fromEntries(words.filter((entry) => entry.id in keptWords).map((entry) => [entry.key, keptWords[entry.id]])));
+    }
+    const kept = [...Object.keys(keptPhrases), ...Object.keys(keptWords)];
+    return { kept: kept.length, dropped: [...phrases, ...words].map((entry) => entry.id).filter((id) => !kept.includes(id)) };
+}
+/** A language's name in English, as Vietnamese for vi; its code where the runtime does not know it. */
+export function languageName(language) {
+    try {
+        return new Intl.DisplayNames(["en"], { type: "language" }).of(language) ?? language;
+    }
+    catch {
+        return language;
+    }
+}
+/** The game system's words in a language translated on the fly, in the player's data folder; none where it has none there. */
+export function homeSystemWords(home, system, language) {
+    return home === undefined ? undefined : systemWords(join(home, "systems", system.name), language);
+}
+/** The system's words a language still lacks in the player's data folder, against its Italian list. */
+function systemMissing(home, language, system) {
+    const italian = systemWords(system.folder, "it");
+    const own = homeSystemWords(home, system, language);
+    return italian !== undefined && Object.keys(wordEntries(italian)).some((id) => !(id in wordEntries(own ?? { groups: {}, fields: {}, words: {} })));
+}
+/** The game system's words translated at once, all in one request so that one concept has one term, after its Italian list. */
+async function translateSystem(writer, home, language, system) {
+    const italian = systemWords(system.folder, "it");
+    if (italian === undefined || !systemMissing(home, language, system)) {
+        return;
+    }
+    const entries = Object.entries(wordEntries(italian)).map(([id, word]) => ({ id, english: id.includes(": ") ? id.slice(id.indexOf(": ") + 2) : id, italian: word }));
+    const kept = keptOf(answerOf(await writer.write(systemBrief(language, entries))), entries.map(({ id, italian: source }) => ({ id, source })));
+    writeSystemWords(home, language, system, kept);
+}
+/** The game system's words translated, by id ("fields: str"), added to those this computer already has of the language. */
+function writeSystemWords(home, language, system, kept) {
+    const all = { ...wordEntries(homeSystemWords(home, system, language) ?? { groups: {}, fields: {}, words: {} }), ...kept };
+    const words = (section) => Object.fromEntries(Object.entries(all).filter(([id]) => id.startsWith(`${section}: `)).map(([id, word]) => [id.slice(section.length + 2), word]));
+    // Through the store the words are read with, so that a read after it in the same call finds them.
+    files().write(join(home, "systems", system.name, "words", `${language}.yaml`), stringify({ groups: words("groups"), fields: words("fields"), words: words("words"), ...(all.headline === undefined ? {} : { headline: all.headline }) }, { lineWidth: 0 }));
+}
+/** The page's phrases a language still lacks on this computer, each by a short id from its place in the page's Italian list, which gives its meaning. */
+function missingPhrases(home, page, language) {
+    const own = readJson(join(home, "i18n", `${language}.json`));
+    return Object.entries(readJson(join(page, "i18n", "it.json"))).flatMap(([phrase, italian], index) => (phrase in own ? [] : [{ id: `p${index}`, key: phrase, english: phrase, italian }]));
+}
+/** The game system's words a language still lacks on this computer, each by a short id from its place in the system's Italian list, with what it is. */
+function missingWords(home, language, system) {
+    const italian = systemWords(system.folder, "it");
+    const own = wordEntries(homeSystemWords(home, system, language) ?? { groups: {}, fields: {}, words: {} });
+    return Object.entries(italian === undefined ? {} : wordEntries(italian)).flatMap(([key, word], index) => {
+        const section = key.includes(": ") ? key.slice(0, key.indexOf(": ")) : key;
+        return key in own ? [] : [{ id: `w${index}`, key, english: key.slice(section.length + 2) || key, italian: word, kind: section.replace(/s$/, "") }];
+    });
+}
+/** A system's words by id: "fields: str", "words: Cleric", "headline". */
+function wordEntries(words) {
+    const sections = ["groups", "fields", "words"];
+    return {
+        ...Object.fromEntries(sections.flatMap((section) => Object.entries(words[section]).map(([key, word]) => [`${section}: ${key}`, word]))),
+        ...(words.headline === undefined ? {} : { headline: words.headline }),
+    };
+}
+/** The request for the page's phrases in a language. */
+function pageBrief(language, entries) {
+    const name = languageName(language);
+    return [
+        `Translate the user interface of a web page into ${name} (${language}). The page is the dashboard of a tabletop role-playing game played with an AI`,
+        "game master in a chat: the player's character sheet, the dice and the rolls, the quests and the story, the maps, the saves and the settings.",
+        `- Write natural, concise ${name}, as a well-made game app would: buttons and labels short; address the player informally where the language can.`,
+        "- Keep every {name} in braces exactly as it is, untranslated; move it where the language wants it.",
+        "- Keep names of products and programs as they are: RPG Engine, Codex, Claude, Claude Code, ChatGPT, and file names.",
+        "- Each phrase stands alone; the Italian beside it, written for the same page, shows what it means there.",
+        "Answer with a JSON object alone, from each id exactly as given to its translation.",
+        "",
+        JSON.stringify(entries),
+    ].join("\n");
+}
+/** The request for a game system's words in a language. */
+function systemBrief(language, entries) {
+    const name = languageName(language);
+    return [
+        `Translate the words a game system shows on the dashboard of a tabletop role-playing game into ${name} (${language}).`,
+        `- Where the game has an official translation in ${name}, use its terms exactly; else the words its players use.`,
+        "- Each id says what it is: group (a heading of the character sheet), field (a short label), word (a name the game uses), headline (the line under a",
+        "  character's name). One concept, one term in every entry, only its case following the entry's; an entry such as until long rest is a whole phrase.",
+        "- Keep every {name} in braces exactly as it is. The Italian beside an entry shows what it means.",
+        "Answer with a JSON object alone, from each id exactly as given to its translation.",
+        "",
+        JSON.stringify(entries),
+    ].join("\n");
+}
+/** The translations of an answer that keep every {name} of what they translate and are not garbled; none of any other. */
+function keptOf(answer, entries) {
+    const names = (text) => [...text.matchAll(/\{\w+\}/g)].map(String).sort().join();
+    return Object.fromEntries(entries.flatMap(({ id, source }) => {
+        const own = answer[id];
+        return typeof own === "string" && own.trim() !== "" && names(own) === names(source) && !isGarbled(own, source) ? [[id, own]] : [];
+    }));
+}
+// What UTF-8 read as another encoding leaves, as a model writing a long answer sometimes does: signs no language writes in a word ("Đ·∫øn" for "Đến"), or
+// à and  before a sign of Latin-1 ("é" for "é").
+const garbledMarks = /[√∫∞∑≈∂Ω¬ƒ†∆]|·ª|[ÃÂ][ -¿]/;
+/** Whether a translation is garbled: it has what a misread encoding leaves, and what it translates has not. */
+function isGarbled(text, source) {
+    return garbledMarks.test(text) && !garbledMarks.test(source);
+}
+/** The JSON object in a writer's answer, whatever came around it; none when there is none. */
+function answerOf(text) {
+    try {
+        return text === undefined ? {} : JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
+    }
+    catch {
+        return {};
+    }
+}
+function readJson(file) {
+    try {
+        return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeJson(file, value) {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}

package/dist/pages/check.d.ts

@@ -0,0 +1,9 @@
+import type { Problem } from "../core/problem.ts";
+import { type Page, type World } from "./world.ts";
+/**
+ * The exact checks on the world's pages (D-58, first level): files that cannot be read, repeated names, standard fields, links, containers, environments.
+ * A world never changes: its problems are found once, and a session of the MCP server keeps the world while its files do not change (D-194).
+ */
+export declare function checkWorld(world: World): Problem[];
+/** What a character has equipped and does not hold (CON-12), as write says it after a change of its inventory or of what it has equipped. */
+export declare function equippedNotes(world: World, character: Page): string[];