rpg-engine 0.0.0-stage → 0.1.0

package/dist/map/index.d.ts

@@ -0,0 +1,3 @@
+export { crossingAlong, directionHelp, directionName, directionTo, distanceBetween, meanPoint, type Point, pointAlong, pointFrom, readDirection } from "./geometry.ts";
+export { biomes, placeKinds, squareKinds } from "./looks.ts";
+export { quickestWay, type Speed, type Start, type Step, type Stretch, stretchesOf, type Way } from "./ways.ts";

package/dist/map/index.js

@@ -0,0 +1,5 @@
+// The world map for any game: roads as stretches between stops, the quickest way across them, and points with their directions and distances. Depends on
+// nothing else in rpg-engine.
+export { crossingAlong, directionHelp, directionName, directionTo, distanceBetween, meanPoint, pointAlong, pointFrom, readDirection } from "./geometry.js";
+export { biomes, placeKinds, squareKinds } from "./looks.js";
+export { quickestWay, stretchesOf } from "./ways.js";

package/dist/map/looks.d.ts

@@ -0,0 +1,9 @@
+/** The kinds of place the map has a symbol for, the largest first. */
+export declare const placeKinds: readonly ["city", "town", "village", "castle", "tower", "ruin", "temple", "shrine", "inn", "farm", "mill", "port", "bridge", "ford", "crossroads", "cave", "mine", "peak", "camp"];
+/**
+ * The kinds of things a place's map draws, each its own way (D-325, GRD-2): walls and ground, ways and passages, water and rough ground, nature, furniture,
+ * the town; any other is drawn neutral.
+ */
+export declare const squareKinds: readonly ["wall", "rock", "floor", "ground", "road", "door", "open-door", "secret-door", "opening", "window", "low-wall", "hedge", "stairs", "ladder", "trapdoor", "pit", "cliff", "bridge", "shallow-water", "deep-water", "mud", "rubble", "brush", "tree", "rocks", "pillar", "statue", "fire", "hearth", "well", "fountain", "table", "seat", "counter", "bed", "shelf", "barrel", "crate", "altar", "machine", "vehicle", "tent", "stall", "building", "hazard", "mark"];
+/** The biomes the map colours a region with. */
+export declare const biomes: readonly ["forest", "swamp", "moor", "hills", "mountains", "plains", "desert", "snow", "water"];

package/dist/map/looks.js

@@ -0,0 +1,57 @@
+// What the dashboard's map draws (D-318, POS-7): a symbol for each kind of place, a colour and marks for each biome of a region; any other value is drawn neutral.
+/** The kinds of place the map has a symbol for, the largest first. */
+export const placeKinds = ["city", "town", "village", "castle", "tower", "ruin", "temple", "shrine", "inn", "farm", "mill", "port", "bridge", "ford", "crossroads", "cave", "mine", "peak", "camp"];
+/**
+ * The kinds of things a place's map draws, each its own way (D-325, GRD-2): walls and ground, ways and passages, water and rough ground, nature, furniture,
+ * the town; any other is drawn neutral.
+ */
+export const squareKinds = [
+    "wall",
+    "rock",
+    "floor",
+    "ground",
+    "road",
+    "door",
+    "open-door",
+    "secret-door",
+    "opening",
+    "window",
+    "low-wall",
+    "hedge",
+    "stairs",
+    "ladder",
+    "trapdoor",
+    "pit",
+    "cliff",
+    "bridge",
+    "shallow-water",
+    "deep-water",
+    "mud",
+    "rubble",
+    "brush",
+    "tree",
+    "rocks",
+    "pillar",
+    "statue",
+    "fire",
+    "hearth",
+    "well",
+    "fountain",
+    "table",
+    "seat",
+    "counter",
+    "bed",
+    "shelf",
+    "barrel",
+    "crate",
+    "altar",
+    "machine",
+    "vehicle",
+    "tent",
+    "stall",
+    "building",
+    "hazard",
+    "mark",
+];
+/** The biomes the map colours a region with. */
+export const biomes = ["forest", "swamp", "moor", "hills", "mountains", "plains", "desert", "snow", "water"];

package/dist/map/ways.d.ts

@@ -0,0 +1,36 @@
+/** A stretch of a road between two stops next to each other: the road, its place in the road, its ends in the road's order and its length in metres. */
+export interface Stretch {
+    road: string;
+    index: number;
+    from: string;
+    to: string;
+    length: number;
+}
+/** A step of a way along a stretch, forward (from its from to its to) or back, over `length` metres: all of it, but where a way starts halfway along it. */
+export interface Step {
+    stretch: Stretch;
+    forward: boolean;
+    length: number;
+}
+/** Where a way starts: at a stop, or on a stretch, `done` metres after its from. */
+export type Start = {
+    stop: string;
+} | {
+    stretch: Stretch;
+    done: number;
+};
+/** A way: its steps in order, how long it takes and how long it is. */
+export interface Way {
+    steps: Step[];
+    minutes: number;
+    length: number;
+}
+/** How many metres a minute along a stretch in a direction; undefined where one cannot go. */
+export type Speed = (stretch: Stretch, forward: boolean) => number | undefined;
+/** The stretches of a road from its stops, in order, and the lengths between them (ROA-1). */
+export declare function stretchesOf(road: string, stops: string[], lengths: number[]): Stretch[];
+/**
+ * The quickest way from a start to a stop (TRV-4): the least time, then the least length, then the first by the order of the stretches; a way from the goal
+ * itself has no steps. Undefined when no way leads there.
+ */
+export declare function quickestWay(stretches: Stretch[], start: Start, goal: string, speed: Speed): Way | undefined;

package/dist/map/ways.js

@@ -0,0 +1,78 @@
+// The roads of the world as a graph (ROA-4) and the quickest way across them (TRV-4). Knows no page and no game: stops are names, lengths are metres.
+/** The stretches of a road from its stops, in order, and the lengths between them (ROA-1). */
+export function stretchesOf(road, stops, lengths) {
+    return lengths.map((length, index) => ({ road, index, from: stops[index], to: stops[index + 1], length }));
+}
+/**
+ * The quickest way from a start to a stop (TRV-4): the least time, then the least length, then the first by the order of the stretches; a way from the goal
+ * itself has no steps. Undefined when no way leads there.
+ */
+export function quickestWay(stretches, start, goal, speed) {
+    const order = new Map(stretches.map((stretch, position) => [stretch, position]));
+    const labels = new Map();
+    const settled = new Set();
+    const offer = (stop, label) => {
+        const known = labels.get(stop);
+        if (!settled.has(stop) && (known === undefined || before(label, known))) {
+            labels.set(stop, label);
+        }
+    };
+    for (const [stop, label] of startLabels(start, speed, order)) {
+        offer(stop, label);
+    }
+    for (;;) {
+        const next = [...labels].filter(([stop]) => !settled.has(stop)).reduce((best, entry) => (best === undefined || before(entry[1], best[1]) ? entry : best), undefined);
+        if (next === undefined) {
+            return undefined;
+        }
+        const [stop, label] = next;
+        if (stop === goal) {
+            return { steps: label.steps, minutes: label.minutes, length: label.length };
+        }
+        settled.add(stop);
+        for (const stretch of stretches) {
+            for (const forward of [true, false]) {
+                if ((forward ? stretch.from : stretch.to) === stop) {
+                    const step = stepAlong(stretch, forward, stretch.length, speed, order);
+                    if (step !== undefined) {
+                        offer(forward ? stretch.to : stretch.from, extended(label, step));
+                    }
+                }
+            }
+        }
+    }
+}
+// Times and lengths that differ by less than this are the same: sums of fractions are not exact.
+const tolerance = 1e-9;
+function startLabels(start, speed, order) {
+    if ("stop" in start) {
+        return [[start.stop, { steps: [], minutes: 0, length: 0, keys: [] }]];
+    }
+    const { stretch, done } = start;
+    const ends = [[stretch.to, true, stretch.length - done], [stretch.from, false, done]];
+    return ends.flatMap(([stop, forward, length]) => {
+        if (length <= 0) {
+            return [[stop, { steps: [], minutes: 0, length: 0, keys: [] }]];
+        }
+        const step = stepAlong(stretch, forward, length, speed, order);
+        return step === undefined ? [] : [[stop, extended({ steps: [], minutes: 0, length: 0, keys: [] }, step)]];
+    });
+}
+function stepAlong(stretch, forward, length, speed, order) {
+    const metresAMinute = speed(stretch, forward);
+    return metresAMinute === undefined || metresAMinute <= 0 ? undefined : { step: { stretch, forward, length }, minutes: length / metresAMinute, key: (order.get(stretch) ?? 0) * 2 + (forward ? 0 : 1) };
+}
+function extended(label, { step, minutes, key }) {
+    return { steps: [...label.steps, step], minutes: label.minutes + minutes, length: label.length + step.length, keys: [...label.keys, key] };
+}
+/** Whether a label comes before another: quicker, then shorter, then first by the order of its stretches. */
+function before(label, other) {
+    if (Math.abs(label.minutes - other.minutes) > tolerance * Math.max(1, other.minutes)) {
+        return label.minutes < other.minutes;
+    }
+    if (Math.abs(label.length - other.length) > tolerance * Math.max(1, other.length)) {
+        return label.length < other.length;
+    }
+    const differs = label.keys.findIndex((key, index) => key !== other.keys[index]);
+    return differs === -1 ? label.keys.length < other.keys.length : other.keys[differs] === undefined ? false : label.keys[differs] < other.keys[differs];
+}

package/dist/mcp-server.d.ts

@@ -0,0 +1,22 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Context } from "./core/context.ts";
+import { SessionStore } from "./core/session-store.ts";
+/**
+ * The MCP server: every command becomes a tool with the same name, description and parameters, and answers with the same text as the command line. Its instructions send
+ * the host to instructions, then status. The commands that ask the player appear for a host that shows forms, through which they ask (D-148), and wherever the
+ * dashboard runs, whose page asks first (D-279).
+ */
+export declare function createMcpServer(context?: Context, environment?: Record<string, string | undefined>, beforeCall?: () => Promise<void>): McpServer;
+/**
+ * Serves the tools over standard input and output, as AI hosts expect, with the files kept for the whole session (D-137, D-193). It ends when the host
+ * goes and its input closes: its watchers, or a player's form still waiting, never keep it alive.
+ */
+export declare function startMcpServer(): Promise<void>;
+/**
+ * Opens the player's dashboard before the first call that finds a campaign in the server's folder, as after init, and lets that call wait for it, so that its
+ * status gives the link (D-270, D-277); never in a folder without a campaign. The game goes on without it.
+ */
+export declare function dashboardOpener(context: Context, session: SessionStore, ports?: number[]): {
+    open(): Promise<void>;
+    close(): Promise<void>;
+};

package/dist/mcp-server.js

@@ -0,0 +1,289 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { findCampaign, refreshHostFiles } from "./campaign/index.js";
+import { outsideNews, whileClosedNews } from "./commands/game-outside.js";
+import { newChatText, wentBackTo } from "./commands/game-saves.js";
+import { campaignWorld } from "./commands/game-world.js";
+import { commands } from "./commands/index.js";
+import { defaultContext } from "./core/context.js";
+import { SessionStore } from "./core/session-store.js";
+import { withFiles } from "./core/store.js";
+import { getVersion } from "./core/version.js";
+import { startDashboard } from "./dashboard-server.js";
+import { startInstructions } from "./instructions/index.js";
+import { computerHelpers, hostPictures, hostWriter } from "./pictures/index.js";
+// How long the player may take to click: as long as a host waits for a tool call that keeps reporting progress.
+const playerWait = 30 * 60 * 1000;
+// While the player decides, the call reports progress this often, so that a host does not take it for a call that hangs.
+const progressEvery = 20 * 1000;
+// A form closed faster than anyone could read it was never shown: the host declares forms it does not show (ASK-6).
+const tooFastForPerson = 1500;
+// Hosts that declare forms but do not show them, by the entry point Claude Code gives its servers: inside the desktop app a form is closed at once,
+// or stays stuck while it renders (tried on 5 October 2026). There the master asks in words (ASK-1).
+// A claude started from inside the desktop app inherits its entry point, so its servers leave out the forms too.
+const entryPointsWithoutForms = ["claude-desktop"];
+// Hosts ask for the tools tens of milliseconds after initialized: the world, which takes a second or more to read in a large campaign, is read after that.
+const preloadAfter = 250;
+/**
+ * The MCP server: every command becomes a tool with the same name, description and parameters, and answers with the same text as the command line. Its instructions send
+ * the host to instructions, then status. The commands that ask the player appear for a host that shows forms, through which they ask (D-148), and wherever the
+ * dashboard runs, whose page asks first (D-279).
+ */
+export function createMcpServer(context = defaultContext(), environment = process.env, beforeCall) {
+    const server = new McpServer({ name: "rpg", version: getVersion() }, { instructions: startInstructions() });
+    const askingTools = [];
+    // A server lives as long as its chat: it gives each part of the instructions once (D-97).
+    context.told ??= new Set();
+    // What changed outside the chat's commands, at the head of each call (OUT-1–OUT-4).
+    const outside = context.files instanceof SessionStore ? watchOutside(context, context.files) : { take: () => [], giveBack: () => undefined };
+    // Before each call, once the files are read again: the dashboard opens, and its page asks the player too, so the asking tools are there, forms or not (ASK-1, D-279).
+    const prepare = async () => {
+        await beforeCall?.();
+        if (context.page !== undefined) {
+            askingTools.filter((tool) => !tool.enabled).forEach((tool) => tool.enable());
+        }
+    };
+    for (const command of commands) {
+        const tool = server.registerTool(command.name, toolConfig(command), (input, extra) => runTool(command, input, context, extra, prepare, outside));
+        if (command.needsPlayer && context.player === undefined) {
+            tool.disable();
+            askingTools.push(tool);
+        }
+    }
+    server.server.oninitialized = () => {
+        const hidesForms = entryPointsWithoutForms.includes(environment.CLAUDE_CODE_ENTRYPOINT ?? "");
+        if (context.player === undefined && !hidesForms && showsForms(server.server.getClientCapabilities())) {
+            context.player = formPlayer(server, () => {
+                context.player = undefined;
+                if (context.page === undefined) {
+                    askingTools.forEach((tool) => tool.disable());
+                }
+            });
+            askingTools.forEach((tool) => tool.enable());
+        }
+        // The world is read once the host has the tools, never before: initialize and the list of tools answer at once (D-194).
+        if (context.files instanceof SessionStore) {
+            setTimeout(() => void preload(context, context.files), preloadAfter);
+        }
+    };
+    return server;
+}
+/**
+ * Serves the tools over standard input and output, as AI hosts expect, with the files kept for the whole session (D-137, D-193). It ends when the host
+ * goes and its input closes: its watchers, or a player's form still waiting, never keep it alive.
+ */
+export async function startMcpServer() {
+    const leave = () => process.exit(0);
+    process.stdin.on("end", leave);
+    process.stdin.on("close", leave);
+    // The pictures, by the chat in use, which names itself as the session starts (D-308, D-390).
+    let server;
+    const host = () => server?.server.getClientVersion()?.name;
+    const context = { ...defaultContext(), pictures: hostPictures(host), writer: hostWriter(host), helpers: computerHelpers() };
+    const session = new SessionStore({ systemFolders: context.systemFolders });
+    const served = { ...context, files: session };
+    server = createMcpServer(served, process.env, dashboardOpener(served, session).open);
+    await server.connect(new StdioServerTransport());
+}
+/**
+ * Opens the player's dashboard before the first call that finds a campaign in the server's folder, as after init, and lets that call wait for it, so that its
+ * status gives the link (D-270, D-277); never in a folder without a campaign. The game goes on without it.
+ */
+export function dashboardOpener(context, session, ports) {
+    let opening;
+    return {
+        open: async () => {
+            opening ??= withFiles(session, () => findCampaign(context.folder)) === undefined ? undefined : startDashboard(context, session, { ports }).catch(() => undefined);
+            const dashboard = await opening;
+            context.dashboard = dashboard?.url;
+            context.page = dashboard?.player;
+            context.news = dashboard?.news;
+        },
+        close: async () => {
+            await (await opening)?.close();
+        },
+    };
+}
+/**
+ * Reads the campaign of the server's folder, if there is one, before the first call needs it; a campaign that does not read waits for that call to say why.
+ * Its start lines in AGENTS.md follow the engine, as after an update (D-97).
+ */
+async function preload(context, session) {
+    try {
+        await session.ready(true);
+        withFiles(session, () => {
+            const root = findCampaign(context.folder);
+            if (root !== undefined) {
+                session.track(root);
+                refreshHostFiles(root, startInstructions(), context.platform);
+                campaignWorld(root, context);
+            }
+        });
+    }
+    catch {
+        // The call that needs the campaign reads it again, and says what is wrong.
+    }
+}
+function toolConfig(command) {
+    const annotations = command.readOnly ? { readOnlyHint: true } : undefined;
+    const meta = command.alwaysLoad ? { "anthropic/alwaysLoad": true } : undefined;
+    return { description: command.description, inputSchema: command.input.strict(), annotations, _meta: meta };
+}
+async function runTool(command, input, context, extra, prepare, outside) {
+    const keepAlive = command.needsPlayer
+        ? reportProgress(extra, () => (context.page?.asking?.() === true ? "waiting for the player's click on the dashboard" : "waiting for the player"))
+        : command.slow === true
+            ? reportProgress(extra, () => "still working")
+            : undefined;
+    let news;
+    let changedOutside = [];
+    // What the chat was told before the call: an answer that never goes tells nothing, so its parts are told again (D-97).
+    const told = new Set(context.told);
+    try {
+        // In a session, the files that changed since the last call are read again; instructions starts a chat, or follows a summary: everything is checked (D-193).
+        if (context.files instanceof SessionStore) {
+            await context.files.ready(command.name === "instructions");
+        }
+        await prepare();
+        // After a load the chat going on remembers what is gone: nothing runs in it, until a new chat begins with instructions (D-361).
+        const back = chatAfterLoad(context, command.name, input);
+        if (back.refused !== undefined) {
+            news = context.news?.();
+            return { content: [{ type: "text", text: [...(news?.lines ?? []), back.refused].join("\n\n") }], isError: true };
+        }
+        // What changed outside the chat comes before the command runs on it, its events fired (OUT-3).
+        changedOutside = outside.take();
+        // The call's own context, with its cancel, as the user stopping it (ASK-9).
+        const text = command.format(await command.run(input, { ...context, signal: extra.signal }));
+        // What the player changed on the dashboard comes first, once, what they changed while the call waited included (D-341).
+        news = context.news?.();
+        return { content: [{ type: "text", text: [...(news?.lines ?? []), ...changedOutside, ...back.begun, text].join("\n\n") }] };
+    }
+    catch (error) {
+        news ??= context.news?.();
+        return { content: [{ type: "text", text: [...(news?.lines ?? []), ...changedOutside, error instanceof Error ? error.message : String(error)].join("\n\n") }], isError: true };
+    }
+    finally {
+        clearInterval(keepAlive);
+        // An answer that never goes, as for a call the user stopped, gives what the player changed back to the next one, and its parts.
+        if (extra.signal.aborted) {
+            news?.restore();
+            outside.giveBack(changedOutside);
+            context.told?.clear();
+            told.forEach((name) => context.told?.add(name));
+        }
+    }
+}
+/**
+ * What changed outside the chat's commands since its last call (OUT-1–OUT-4): the world as it was is read before the session lets the changes in, so that the
+ * events they set off fire; at the server's first call, the files changed while no chat was open.
+ */
+function watchOutside(context, session) {
+    let before;
+    let first = true;
+    // What an answer that never went told, for the next call; and when the chat began, for what changed while no chat was open.
+    let untold = [];
+    const began = Date.now();
+    const inCampaign = (work, none) => {
+        try {
+            return withFiles(session, () => {
+                const root = findCampaign(context.folder);
+                return root === undefined ? none : work(root);
+            });
+        }
+        catch {
+            // A campaign that does not read now: the command says why.
+            return none;
+        }
+    };
+    session.beforeOutsideChanges(() => {
+        before ??= inCampaign((root) => campaignWorld(root, context), undefined);
+    });
+    return {
+        take: () => {
+            const lines = [...untold, ...inCampaign((root) => [...(first ? whileClosedNews(root, context, began) : []), ...outsideNews(root, context, session.takeOutsideChanges(), before)], [])];
+            untold = [];
+            first = false;
+            before = undefined;
+            return lines;
+        },
+        giveBack: (lines) => {
+            untold = [...lines, ...untold];
+        },
+    };
+}
+/**
+ * The chat after a load (SAV-5, D-361, D-362): one going on when the game went back remembers what is gone, so every call is refused but instructions, which
+ * begins a chat, and save new chat, once the player confirms the chat began after it; or until the player confirms it on the dashboard.
+ */
+function chatAfterLoad(context, command, input) {
+    const run = (work) => (context.files === undefined ? work() : withFiles(context.files, work));
+    return run(() => {
+        const root = findCampaign(context.folder);
+        const save = root === undefined ? undefined : wentBackTo(root);
+        if (root === undefined || save === undefined) {
+            return { begun: [] };
+        }
+        const confirmed = command === "save" && input?.action === "new chat";
+        if (command !== "instructions" && !confirmed) {
+            return {
+                refused: `The game went back to save ${save}. If this chat went on before that: ${newChatText} If it began after: ask the player to confirm it, `
+                    + "here or on the dashboard, then call save with action new chat.",
+                begun: [],
+            };
+        }
+        return {
+            begun: confirmed ? [] : [
+                `The game went back to save ${save}. Before going on, ask the player to confirm this chat began after it, here or on the dashboard (Saves), then call save `
+                    + `with action new chat; if it went on before, ${newChatText.charAt(0).toLowerCase()}${newChatText.slice(1)}`,
+            ],
+        };
+    });
+}
+/** Whether the host shows forms (MCP elicitation): before the url mode existed, a capability without modes meant forms. */
+function showsForms(capabilities) {
+    const elicitation = capabilities?.elicitation;
+    return elicitation !== undefined && (elicitation.form !== undefined || elicitation.url === undefined);
+}
+/**
+ * The player through the host's forms: one question, one choice among the labels, required; undefined when no one answered or the form failed.
+ * A form refused or failed faster than a person could read it was never shown: `unavailable` takes the buttons away for the rest of the session.
+ */
+function formPlayer(server, unavailable) {
+    return {
+        async choose(question, title, labels, signal) {
+            const started = Date.now();
+            const notShown = () => {
+                if (Date.now() - started >= tooFastForPerson) {
+                    return undefined;
+                }
+                unavailable();
+                return "unavailable";
+            };
+            try {
+                const requestedSchema = { type: "object", properties: { choice: { type: "string", title, enum: labels } }, required: ["choice"] };
+                // A stop of the call closes the form too (ASK-9).
+                const reply = await server.server.elicitInput({ mode: "form", message: question, requestedSchema }, { timeout: playerWait, signal });
+                if (reply.action !== "accept") {
+                    return notShown();
+                }
+                const index = labels.indexOf(String(reply.content?.choice));
+                return index === -1 ? undefined : index;
+            }
+            catch {
+                return signal?.aborted === true ? undefined : notShown();
+            }
+        },
+    };
+}
+/** Progress notifications while the player decides or a slow command works, when the host asked for them, saying what it waits for; undefined otherwise. */
+function reportProgress(extra, saying) {
+    const progressToken = extra._meta?.progressToken;
+    if (progressToken === undefined) {
+        return undefined;
+    }
+    let progress = 0;
+    return setInterval(() => {
+        void extra.sendNotification({ method: "notifications/progress", params: { progressToken, progress: ++progress, message: saying() } }).catch(() => undefined);
+    }, progressEvery);
+}

package/dist/money/index.d.ts

@@ -0,0 +1 @@
+export { addCoins, type Coin, coinList, coinsProblem, coinsText, formatAmount, formatTotal, isSafePurse, namesCoins, payCoins, type Payment, type Purse, readAmount, readCoins, readSignedAmount, totalOf } from "./money.ts";

package/dist/money/index.js

@@ -0,0 +1,2 @@
+// Money: coins of a campaign, amounts on the pages, paying with change (D-67, D-126–D-129). It knows no game: the coins are data.
+export { addCoins, coinList, coinsProblem, coinsText, formatAmount, formatTotal, isSafePurse, namesCoins, payCoins, readAmount, readCoins, readSignedAmount, totalOf } from "./money.js";

package/dist/money/money.d.ts

@@ -0,0 +1,48 @@
+/** A coin of the campaign (MON-1): its names, the first being the one written; its value in the smallest coin; whether it is rare, never given as change (D-128). */
+export interface Coin {
+    name: string;
+    names: string[];
+    value: number;
+    rare: boolean;
+}
+/** How many coins of each kind there are, by the coin's first name; kinds left out count 0. */
+export type Purse = Record<string, number>;
+/** A payment (MON-5): the purse after it; the coins given beyond those of the price, and the change that came back. */
+export interface Payment {
+    purse: Purse;
+    given: Purse;
+    back: Purse;
+}
+/** What is wrong with a list of coins, as campaign.yaml holds it (MON-1, MON-8); undefined when it is right. */
+export declare function coinsProblem(value: unknown): string | undefined;
+/** The coins of a list that has no problem, in its order: the first is the coin of totals. */
+export declare function coinList(value: Record<string, unknown>): Coin[];
+/** 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 declare function readCoins(text: string): Record<string, number | string>;
+/** "gp/mo 100, pp 1000 rare, sp 10, cp 1": a list of coins as config shows it and takes it. */
+export declare function coinsText(coins: Coin[]): string;
+/** 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 declare function readAmount(value: unknown, coins: Coin[]): Purse | 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 declare function readSignedAmount(text: string, coins: Coin[]): {
+    sign: 1 | -1;
+    purse: Purse;
+} | undefined;
+/** 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 declare function namesCoins(text: string, coins: Coin[]): boolean;
+/** "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 declare function formatAmount(purse: Purse, coins: Coin[]): string;
+/** What a purse is worth, in the smallest coin. */
+export declare function totalOf(purse: Purse, coins: Coin[]): number;
+/** 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 declare function formatTotal(purse: Purse, coins: Coin[]): string;
+/** The purse with coins added: they stay as they are given (MON-3). */
+export declare function addCoins(purse: Purse, added: Purse): Purse;
+/** Whether every count of a purse is a whole number that can be counted exactly. */
+export declare function isSafePurse(purse: Purse, coins: Coin[]): boolean;
+/**
+ * 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 declare function payCoins(purse: Purse, price: Purse, coins: Coin[]): Payment | undefined;