rpg-engine 0.0.0-stage → 0.1.0

package/dist/core/store.d.ts

@@ -0,0 +1,83 @@
+/** What a store keeps of a file: its text, undefined when there is no file, and what it read as, by kind of reading. */
+interface Kept {
+    text: string | undefined;
+    readings: Map<string, {
+        value: unknown;
+    } | {
+        error: unknown;
+    }>;
+}
+/** The files of a call, read once and kept: a module asks for them through files(). */
+export declare class FileStore {
+    protected readonly kept: Map<string, Kept>;
+    private readonly packages;
+    protected readonly listings: Map<string, string[]>;
+    private readonly remembered;
+    /** `packages` are the folders of the installed game systems, whose files the process keeps from one call to the next while they do not change. */
+    constructor(packages?: string[]);
+    /** The text of a file; undefined when there is none. */
+    text(path: string): string | undefined;
+    /** Whether there is a file at `path`. */
+    exists(path: string): boolean;
+    /**
+     * What a file reads as, through `parse`, by a kind of reading such as "page": kept frozen until the file changes, and a reading that failed fails again
+     * the same way. Undefined when there is no file.
+     */
+    read<T>(path: string, kind: string, parse: (text: string) => T): T | undefined;
+    /** The files in `folder` and in the folders inside it whose names `keep` takes, listed once. */
+    files(folder: string, keep: (name: string) => boolean): string[];
+    /** The files and folders right inside `folder`, as they are now, by name; none when there is no such folder. */
+    entries(folder: string): {
+        name: string;
+        isFolder: boolean;
+    }[];
+    /** A file's bytes as they are now, as a save holds them; undefined when there is no file. */
+    bytes(path: string): Uint8Array | undefined;
+    /** The text of a file as it is now, for a command about to write it: in a call, the text the call reads; a session checks the disk (D-193). */
+    fresh(path: string): string | undefined;
+    /** Keeps the files of a campaign up to date for later calls: only the store of a session does (D-193). */
+    track(_root: string): void;
+    /** A file, or the listing of a folder, that the store keeps from now on: a session tells what lasts from a call to the next (D-193). */
+    protected onKept(_path: string): void;
+    /**
+     * A value built from the files, such as the world, kept until something changes that `dependsOn` takes: a file, or a folder that may hold one. A build
+     * that fails is not kept.
+     */
+    remember<T>(key: string, dependsOn: (path: string) => boolean, build: () => T): T;
+    /** Writes a file, with the folders it needs. */
+    write(path: string, text: string): void;
+    /** Writes a file's bytes as they are, with the folders it needs, as a save gives them back: what the store kept of it is read again. */
+    writeBytes(path: string, bytes: Uint8Array): void;
+    /** Adds text at the end of a file, as the log grows. */
+    append(path: string, text: string): void;
+    /** Makes a folder, with those it needs, if it is not there. */
+    makeFolder(path: string): void;
+    /** When a file last changed, in milliseconds, as the disk says now; undefined when there is none. */
+    modified(path: string): number | undefined;
+    /** Removes a file. */
+    remove(path: string): void;
+    protected entry(path: string): Kept;
+    /**
+     * A file of an installed game system as the process last read it, while it has not changed since, nor in the two seconds before; undefined for any other
+     * file. The first reading asks the disk nothing more: a call from the command line, the only one of its process, pays nothing for it.
+     */
+    private packageEntry;
+    /**
+     * What is kept of a file after a change: its new text and no readings, or nothing, to read it again, when its text is not known; whether it is in the
+     * listings of the folders that hold it; and no value remembered from it.
+     */
+    protected changed(path: string, now: {
+        text: string | undefined;
+    } | undefined, exists: boolean): void;
+    /** Forgets the values remembered from a file. */
+    protected forgetBuiltFrom(path: string): void;
+}
+/** The store of the running command; outside one, a new store for each use, which reads the files as they are. */
+export declare function files(): FileStore;
+/** Runs `work` with `store` as the store its modules read and write through; a command run inside another keeps that one's. */
+export declare function withFiles<T>(store: FileStore, work: () => T): T;
+/** Whether a path is inside a folder, below it: a folder named like "..notes" is inside too. */
+export declare function isInside(folder: string, path: string): boolean;
+/** The text of a file, or undefined when there is none: a folder or a file that cannot be read fails as before. */
+export declare function readText(path: string): string | undefined;
+export {};

package/dist/core/store.js

@@ -0,0 +1,224 @@
+// The files as a command sees them (D-137, D-194): each read at most once in a call, kept as its text and as what it reads as, frozen; what the command writes
+// updates what is kept. A command runs inside its store, and the modules reach it with files(): the MCP server will keep one for a whole session.
+import { AsyncLocalStorage } from "node:async_hooks";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { filesIn } from "./files.js";
+import { frozen } from "./frozen.js";
+/**
+ * The files of the installed game systems, kept for the whole process while none changes after it was read: a process that runs many calls, as the tests do,
+ * reads and parses a system's pages once (D-194). Only a store given the systems' folders uses them.
+ */
+const packageFiles = new Map();
+// A file changed this close to its reading may change again within the same tick of the disk's clock: it is read again until it is older, as git does.
+const racyMilliseconds = 2000;
+/** The files of a call, read once and kept: a module asks for them through files(). */
+export class FileStore {
+    kept = new Map();
+    packages;
+    listings = new Map();
+    remembered = new Map();
+    /** `packages` are the folders of the installed game systems, whose files the process keeps from one call to the next while they do not change. */
+    constructor(packages = []) {
+        this.packages = packages.map((folder) => resolve(folder));
+    }
+    /** The text of a file; undefined when there is none. */
+    text(path) {
+        return this.entry(path).text;
+    }
+    /** Whether there is a file at `path`. */
+    exists(path) {
+        return this.text(path) !== undefined;
+    }
+    /**
+     * What a file reads as, through `parse`, by a kind of reading such as "page": kept frozen until the file changes, and a reading that failed fails again
+     * the same way. Undefined when there is no file.
+     */
+    read(path, kind, parse) {
+        const entry = this.entry(path);
+        if (entry.text === undefined) {
+            return undefined;
+        }
+        let reading = entry.readings.get(kind);
+        if (reading === undefined) {
+            try {
+                reading = { value: frozen(parse(entry.text)) };
+            }
+            catch (error) {
+                reading = { error };
+            }
+            entry.readings.set(kind, reading);
+        }
+        if ("error" in reading) {
+            throw reading.error;
+        }
+        return reading.value;
+    }
+    /** The files in `folder` and in the folders inside it whose names `keep` takes, listed once. */
+    files(folder, keep) {
+        const key = resolve(folder);
+        let listing = this.listings.get(key);
+        if (listing === undefined) {
+            listing = filesIn(key, () => true);
+            this.listings.set(key, listing);
+            this.onKept(key);
+        }
+        return listing.filter((path) => keep(basename(path)));
+    }
+    /** The files and folders right inside `folder`, as they are now, by name; none when there is no such folder. */
+    entries(folder) {
+        return existsSync(folder) && statSync(folder).isDirectory()
+            ? readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isFile() || entry.isDirectory()).map((entry) => ({ name: entry.name, isFolder: entry.isDirectory() }))
+            : [];
+    }
+    /** A file's bytes as they are now, as a save holds them; undefined when there is no file. */
+    bytes(path) {
+        return existsSync(path) ? new Uint8Array(readFileSync(path)) : undefined;
+    }
+    /** The text of a file as it is now, for a command about to write it: in a call, the text the call reads; a session checks the disk (D-193). */
+    fresh(path) {
+        return this.text(path);
+    }
+    /** Keeps the files of a campaign up to date for later calls: only the store of a session does (D-193). */
+    track(_root) {
+    }
+    /** A file, or the listing of a folder, that the store keeps from now on: a session tells what lasts from a call to the next (D-193). */
+    onKept(_path) {
+    }
+    /**
+     * A value built from the files, such as the world, kept until something changes that `dependsOn` takes: a file, or a folder that may hold one. A build
+     * that fails is not kept.
+     */
+    remember(key, dependsOn, build) {
+        const kept = this.remembered.get(key);
+        if (kept !== undefined) {
+            return kept.value;
+        }
+        const value = build();
+        this.remembered.set(key, { value, dependsOn });
+        return value;
+    }
+    /** Writes a file, with the folders it needs. */
+    write(path, text) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, text, "utf8");
+        this.changed(path, { text }, true);
+    }
+    /** Writes a file's bytes as they are, with the folders it needs, as a save gives them back: what the store kept of it is read again. */
+    writeBytes(path, bytes) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, bytes);
+        this.changed(path, undefined, true);
+    }
+    /** Adds text at the end of a file, as the log grows. */
+    append(path, text) {
+        const before = this.kept.get(resolve(path));
+        appendFileSync(path, text, "utf8");
+        // A file never read stays to be read: what is kept of it would be only its end.
+        this.changed(path, before === undefined ? undefined : { text: `${before.text ?? ""}${text}` }, true);
+    }
+    /** Makes a folder, with those it needs, if it is not there. */
+    makeFolder(path) {
+        mkdirSync(path, { recursive: true });
+    }
+    /** When a file last changed, in milliseconds, as the disk says now; undefined when there is none. */
+    modified(path) {
+        return existsSync(path) ? statSync(path).mtimeMs : undefined;
+    }
+    /** Removes a file. */
+    remove(path) {
+        rmSync(path);
+        this.changed(path, { text: undefined }, false);
+    }
+    entry(path) {
+        const key = resolve(path);
+        let entry = this.kept.get(key);
+        if (entry === undefined) {
+            entry = this.packageEntry(key) ?? { text: readText(key), readings: new Map() };
+            this.kept.set(key, entry);
+            this.onKept(key);
+        }
+        return entry;
+    }
+    /**
+     * A file of an installed game system as the process last read it, while it has not changed since, nor in the two seconds before; undefined for any other
+     * file. The first reading asks the disk nothing more: a call from the command line, the only one of its process, pays nothing for it.
+     */
+    packageEntry(path) {
+        if (!this.packages.some((folder) => isInside(folder, path))) {
+            return undefined;
+        }
+        const known = packageFiles.get(path);
+        if (known !== undefined && !changedSince(path, known.readAt - racyMilliseconds)) {
+            return known.entry;
+        }
+        const readAt = Date.now();
+        const entry = { text: readText(path), readings: new Map() };
+        packageFiles.set(path, { readAt, entry });
+        return entry;
+    }
+    /**
+     * What is kept of a file after a change: its new text and no readings, or nothing, to read it again, when its text is not known; whether it is in the
+     * listings of the folders that hold it; and no value remembered from it.
+     */
+    changed(path, now, exists) {
+        const key = resolve(path);
+        if (now === undefined) {
+            this.kept.delete(key);
+        }
+        else {
+            this.kept.set(key, { text: now.text, readings: new Map() });
+            this.onKept(key);
+        }
+        this.forgetBuiltFrom(key);
+        for (const [folder, listing] of this.listings) {
+            const inside = isInside(folder, key);
+            const listed = listing.includes(key);
+            if (inside && exists && !listed) {
+                listing.push(key);
+            }
+            else if (inside && !exists && listed) {
+                listing.splice(listing.indexOf(key), 1);
+            }
+        }
+    }
+    /** Forgets the values remembered from a file. */
+    forgetBuiltFrom(path) {
+        for (const [key, value] of this.remembered) {
+            if (value.dependsOn(path)) {
+                this.remembered.delete(key);
+            }
+        }
+    }
+}
+const running = new AsyncLocalStorage();
+/** The store of the running command; outside one, a new store for each use, which reads the files as they are. */
+export function files() {
+    return running.getStore() ?? new FileStore();
+}
+/** Runs `work` with `store` as the store its modules read and write through; a command run inside another keeps that one's. */
+export function withFiles(store, work) {
+    return running.getStore() === undefined ? running.run(store, work) : work();
+}
+/** Whether a path is inside a folder, below it: a folder named like "..notes" is inside too. */
+export function isInside(folder, path) {
+    const below = relative(folder, path);
+    return below !== "" && below !== ".." && !below.startsWith(`..${sep}`) && !isAbsolute(below);
+}
+/** Whether a file changed after a time, or is gone. */
+function changedSince(path, time) {
+    const stats = statSync(path, { throwIfNoEntry: false });
+    return stats === undefined || stats.mtimeMs >= time;
+}
+/** The text of a file, or undefined when there is none: a folder or a file that cannot be read fails as before. */
+export function readText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}

package/dist/core/text.d.ts

@@ -0,0 +1,12 @@
+/** A name as it is compared: any case, accents written either way (NFC) and a curly apostrophe as a straight one (SYS-5), so that "Città" from any system matches "città". */
+export declare function comparableText(text: string): string;
+/** The first sentence of a text, up to its first ". ", as the help and the commands' reference give a command's description. */
+export declare function firstSentence(text: string): string;
+/** A noun with its article, as messages write it: "a character", "an item". */
+export declare function withArticle(noun: string): string;
+/** The name in `names` that `name` writes, ignoring case, how accents are written and the spaces around it; undefined when none does. */
+export declare function sameName(names: string[], name: string): string | undefined;
+/** The value a record holds under a name, as names are compared (INH-5); undefined when it holds none. */
+export declare function valueNamed(record: Record<string, unknown>, name: string): unknown;
+/** The page a link's target names: [[folder/Page.md]], and [[Page\|label]] as written in tables, name Page. */
+export declare function linkTargetName(target: string): string;

package/dist/core/text.js

@@ -0,0 +1,32 @@
+import { rememberedByText } from "./memo.js";
+/** A name as it is compared: any case, accents written either way (NFC) and a curly apostrophe as a straight one (SYS-5), so that "Città" from any system matches "città". */
+export function comparableText(text) {
+    // Names come back at every call: a short text is remembered.
+    return text.length > 200 ? comparable(text) : rememberedComparable(text);
+}
+const rememberedComparable = rememberedByText(comparable);
+function comparable(text) {
+    return text.normalize("NFC").toLowerCase().replace(/[‘’]/g, "'");
+}
+/** The first sentence of a text, up to its first ". ", as the help and the commands' reference give a command's description. */
+export function firstSentence(text) {
+    const end = text.indexOf(". ");
+    return end === -1 ? text : text.slice(0, end + 1);
+}
+/** A noun with its article, as messages write it: "a character", "an item". */
+export function withArticle(noun) {
+    return /^[aeiou]/i.test(noun) ? `an ${noun}` : `a ${noun}`;
+}
+/** The name in `names` that `name` writes, ignoring case, how accents are written and the spaces around it; undefined when none does. */
+export function sameName(names, name) {
+    return names.find((candidate) => comparableText(candidate) === comparableText(name.trim()));
+}
+/** The value a record holds under a name, as names are compared (INH-5); undefined when it holds none. */
+export function valueNamed(record, name) {
+    const key = sameName(Object.keys(record), name);
+    return key === undefined ? undefined : record[key];
+}
+/** The page a link's target names: [[folder/Page.md]], and [[Page\|label]] as written in tables, name Page. */
+export function linkTargetName(target) {
+    return (target.replace(/\\$/, "").split("/").at(-1) ?? "").replace(/\.md$/i, "").trim();
+}

package/dist/core/version.d.ts

@@ -0,0 +1,2 @@
+/** Version of the installed rpg-engine package, read from its package.json. */
+export declare function getVersion(): string;

package/dist/core/version.js

@@ -0,0 +1,6 @@
+import { readFileSync } from "node:fs";
+/** Version of the installed rpg-engine package, read from its package.json. */
+export function getVersion() {
+    const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    return packageJson.version;
+}

package/dist/core/yaml-file.d.ts

@@ -0,0 +1,10 @@
+import { type Document } from "yaml";
+/**
+ * A YAML file of keys and values, read as the disk has it now so that writing it back keeps its comments and loses no change (D-193). `holds` says what it
+ * must hold, for the error message: settings, such as "name: ...".
+ */
+export declare function readYamlFile(path: string, holds: string): Document;
+/** The keys and values of a YAML file, as plain data, read once by the store of the call; an empty file gives an empty object. */
+export declare function readYamlValues(path: string, holds: string): unknown;
+/** Writes a YAML file read with readYamlFile; long values stay on one line. */
+export declare function writeYamlFile(path: string, document: Document): void;

package/dist/core/yaml-file.js

@@ -0,0 +1,42 @@
+import { basename } from "node:path";
+import { isMap, parseDocument } from "yaml";
+import { files } from "./store.js";
+/**
+ * A YAML file of keys and values, read as the disk has it now so that writing it back keeps its comments and loses no change (D-193). `holds` says what it
+ * must hold, for the error message: settings, such as "name: ...".
+ */
+export function readYamlFile(path, holds) {
+    return documentOf(path, files().fresh(path) ?? missing(path), holds);
+}
+/** The keys and values of a YAML file, as plain data, read once by the store of the call; an empty file gives an empty object. */
+export function readYamlValues(path, holds) {
+    return files().read(path, `yaml ${holds}`, (text) => documentOf(path, text, holds).toJS() ?? {}) ?? missing(path);
+}
+/** Writes a YAML file read with readYamlFile; long values stay on one line. */
+export function writeYamlFile(path, document) {
+    files().write(path, document.toString({ lineWidth: 0 }));
+}
+/** The text of a YAML file as a document, refused with the file's name when it is not valid YAML or does not hold keys and values. */
+function documentOf(path, text, holds) {
+    const document = parseDocument(text);
+    // Only the first line of the parser's message: the rest quotes the file.
+    const invalid = (message) => new Error(`${basename(path)} is not valid YAML; fix it by hand: ${message.split("\n")[0]}`);
+    if (document.errors.length > 0) {
+        throw invalid(document.errors[0].message);
+    }
+    if (document.contents !== null && !isMap(document.contents)) {
+        throw new Error(`${basename(path)} must hold ${holds}; fix it by hand.`);
+    }
+    try {
+        document.toJS();
+    }
+    catch (error) {
+        // Such as an alias to an anchor that is not there, which only toJS finds.
+        throw invalid(error instanceof Error ? error.message : String(error));
+    }
+    return document;
+}
+/** A file that is not there, as reading it would say. */
+function missing(path) {
+    throw Object.assign(new Error(`ENOENT: no such file or directory, open '${path}'`), { code: "ENOENT" });
+}

package/dist/counters/counter.d.ts

@@ -0,0 +1,36 @@
+/** A number kept on a page: the current value and, for current/max fields such as 5/12, the maximum. The limits are the minimum, 0 unless given, and the maximum. */
+export interface Counter {
+    value: number;
+    /** Undefined for a plain number, which goes from its minimum up. */
+    max?: number;
+    /** The lowest value a change by an amount reaches, when it is not 0, as a game system works it out (FOR-6); never written in the field. */
+    min?: number;
+}
+/** A change to a counter: by an amount (damage, healing), spending what is there, or to a value. */
+export type CounterChange = {
+    by: number;
+} | {
+    spend: number;
+} | {
+    to: Counter;
+};
+/** The counter a field holds: a whole number, or "current/max" text. Undefined for anything else. */
+export declare function readCounter(field: unknown): Counter | undefined;
+/** A counter given as text: current/max such as 15/15, or a whole number such as -3. */
+export declare function readCounterText(text: string): Counter | undefined;
+/** The counter as its field is written: 5/12, or 20; the minimum is never written. */
+export declare function formatCounter(counter: Counter): number | string;
+/** Whether there is enough to spend: what is spent cannot be what is not there, below 0 or below a minimum above it. */
+export declare function canSpend(counter: Counter, amount: number): boolean;
+/**
+ * Applies a change. `by` stops at a limit and says how far it went beyond; it never pushes a value further outside its limits.
+ * `spend` takes what is there: check `canSpend` first. `to` sets the value, outside the limits too.
+ */
+export declare function changeCounter(counter: Counter, change: CounterChange): {
+    counter: Counter;
+    beyond: number;
+};
+/** Where a counter stands against its limits: at 0, at another minimum, at its maximum, outside them, or within. */
+export declare function counterLimit(counter: Counter): "at 0" | "at min" | "at max" | "outside" | undefined;
+/** Whether a counter's numbers are whole and small enough to count with exactly. */
+export declare function isSafeCounter(counter: Counter): boolean;

package/dist/counters/counter.js

@@ -0,0 +1,59 @@
+// "5/12", or "-3/10" after a value was set outside the limits.
+const currentAndMax = /^(-?\d+)\s*\/\s*(\d+)$/;
+const wholeNumber = /^[+-]?\d+$/;
+/** The counter a field holds: a whole number, or "current/max" text. Undefined for anything else. */
+export function readCounter(field) {
+    if (typeof field === "number") {
+        return safeCounter({ value: field });
+    }
+    return typeof field === "string" ? readCurrentAndMax(field) : undefined;
+}
+/** A counter given as text: current/max such as 15/15, or a whole number such as -3. */
+export function readCounterText(text) {
+    const trimmed = text.trim();
+    return wholeNumber.test(trimmed) ? safeCounter({ value: Number(trimmed) }) : readCurrentAndMax(trimmed);
+}
+/** The counter as its field is written: 5/12, or 20; the minimum is never written. */
+export function formatCounter(counter) {
+    return counter.max === undefined ? counter.value : `${counter.value}/${counter.max}`;
+}
+/** Whether there is enough to spend: what is spent cannot be what is not there, below 0 or below a minimum above it. */
+export function canSpend(counter, amount) {
+    return amount > 0 && counter.value - amount >= Math.max(0, counter.min ?? 0);
+}
+/**
+ * Applies a change. `by` stops at a limit and says how far it went beyond; it never pushes a value further outside its limits.
+ * `spend` takes what is there: check `canSpend` first. `to` sets the value, outside the limits too.
+ */
+export function changeCounter(counter, change) {
+    if ("to" in change) {
+        return { counter: change.to, beyond: 0 };
+    }
+    const target = counter.value + ("by" in change ? change.by : -change.spend);
+    const lowest = Math.min(counter.min ?? 0, counter.value);
+    const highest = counter.max === undefined ? Number.POSITIVE_INFINITY : Math.max(counter.max, counter.value);
+    const value = Math.min(Math.max(target, lowest), highest) || 0;
+    return { counter: { ...counter, value }, beyond: target - value };
+}
+/** Where a counter stands against its limits: at 0, at another minimum, at its maximum, outside them, or within. */
+export function counterLimit(counter) {
+    const lowest = counter.min ?? 0;
+    if (counter.value < lowest || (counter.max !== undefined && counter.value > counter.max)) {
+        return "outside";
+    }
+    if (counter.value === lowest) {
+        return lowest === 0 ? "at 0" : "at min";
+    }
+    return counter.value === counter.max ? "at max" : undefined;
+}
+/** Whether a counter's numbers are whole and small enough to count with exactly. */
+export function isSafeCounter(counter) {
+    return Number.isSafeInteger(counter.value) && (counter.max === undefined || Number.isSafeInteger(counter.max));
+}
+function readCurrentAndMax(text) {
+    const match = currentAndMax.exec(text.trim());
+    return match === null ? undefined : safeCounter({ value: Number(match[1]), max: Number(match[2]) });
+}
+function safeCounter(counter) {
+    return isSafeCounter(counter) ? { ...counter, value: counter.value || 0 } : undefined;
+}

package/dist/counters/index.d.ts

@@ -0,0 +1 @@
+export { canSpend, changeCounter, type Counter, type CounterChange, counterLimit, formatCounter, isSafeCounter, readCounter, readCounterText } from "./counter.ts";

package/dist/counters/index.js

@@ -0,0 +1,2 @@
+// Counters for any game: hit points, uses, ammunition, supply, the segments of a progress track. Depends on nothing else in rpg-engine.
+export { canSpend, changeCounter, counterLimit, formatCounter, isSafeCounter, readCounter, readCounterText } from "./counter.js";

package/dist/dashboard/address.js

@@ -0,0 +1,43 @@
+// Where the page is (D-276, D-309): a section by its address, as #/scene, and for the sheet whom it shows, as #/party/Ettore; the sheet when the address says
+// nothing. #/character/Ettore, the sheet's first address, still leads there (D-310). The page never changes section by itself.
+import { t } from "./text.js";
+/** The sections, in the order the page shows them. */
+// Combat is there only while a fight is open (D-314).
+export const sections = ["party", "scene", "combat", "journal", "world"];
+/** The pages at the row's end, as icons, in the menu on a phone: the saves, played with, then what is read, as Help and the settings are (D-356, D-409). */
+export const menuPages = ["saves", "help", "settings", "about"];
+/** The address a hash says, as #/party/Ettore; the sheet for none or one the page does not know. */
+export function readAddress(hash) {
+    const [, first = "", ...rest] = hash.replace(/^#/, "").split("/");
+    const section = [...sections, ...menuPages].find((candidate) => candidate === first) ?? "party";
+    const name = first === "party" || first === "character" ? decoded(rest.join("/")) : "";
+    return name === "" ? { section } : { section, name };
+}
+/** A section's address, as #/scene. */
+export function sectionAddress(section) {
+    return `#/${section}`;
+}
+/** A section's name as the page writes it, in its language: Scene. */
+export function sectionLabel(section) {
+    const labels = {
+        party: t("Party"),
+        scene: t("Scene"),
+        combat: t("Combat"),
+        journal: t("Journal"),
+        world: t("World"),
+        help: t("Help"),
+        saves: t("Saves"),
+        settings: t("Settings"),
+        about: t("About"),
+    };
+    return labels[section];
+}
+/** A part of an address as written, nothing when it is not well encoded. */
+function decoded(part) {
+    try {
+        return decodeURIComponent(part);
+    }
+    catch {
+        return "";
+    }
+}